Swift相比OC语言有哪些优点


Swift相比OC语言有哪些优点
1、自动做类型推断

2、可以保证类型使用安全

Swif类型说明符
——Swift增加了Tuple表示元组类型

——Swift增加了Optional表示可选类型

常量一变量命名:
——可以用任何你喜欢的字符作为常量和变量名,包含Unicode 字符

——常量与变量名不能包含数学符号,箭头,保留的(或者非法的)Unicode 码位,连线与制表符

——不能以数字开头,但是可以在常量与变量名的其他地方包含数字

/*

\n —— 换行

\t —— 水平制表符 (4个空格)

\—— 表示1个\

\"—— 表示1个"

\'——表示1个'

*/

3.5e2 == 3.5乘以10的二次方

3.5e-3 == 3.5乘以10的-3次方

C的函数定义
         charname[10] ="China";

        char address[10] = {'C','h','i','n','a','\0','B','e','i','\0'};

        NSLog(@"%ld",strlen(name));//里面字符串的长度

        NSLog(@"%ld",sizeof(address));

        //包含\0的长度(自己定义字符串长度后会使用调用后的长度)

         charsex[] ="nan";

        NSLog(@"%c",sex[2]);

Swift
Swift中要想越界

num = num &+ 1(溢出运算)

var str1 = "China"

var str2 = str1 + "Beijing"

str1 += "Beijing" 

9 % 4  //  等于1

9 % -4  //  等于1

-9 % 4  //  等于-1

-9 % -4  //  等于-1

BOOL类型比较
只能使用 == 或者 !=   不可以使用  >、<、>=、<=

当俩个元组中的数据类型及顺序完全匹配时,可以使用比较运算符比较

如果元组包含Bool类型,只能使用==和!=比较,不可以使用>、<、>=、<=

Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时,你需要自己实现比较运算符。

空合运算符(只适用于可选类型)
形式:a ?? b

对可选类型 a 进行空判断,如果 a 包含一个值就进行解封,否则就返回一个值 b

表达式 a 必须是 Optional 类型

默认值 b 的类型必须要和 a 储存值的类型保持一致

区间运算符
1、闭区间

    a…b定义一个包含从 a 到 b (包含 a 和 b )的所有值的区间

    a 的值不能超过 b

2、半开区间

    a ..< b 定义一个包含从 a 到 b(不包含b)的所有值的区间

    a 的值不能超过 b

3、自增自减运算符在Swift中不能用

    ++a (前增)         a++ (后增)        --a (前减) a-- (后减)

//使用索引值
var name = "yangyingqiu"        (后面会自定添加\0)

var index = name.startIndex //得到字符“Y”的索引值

index  = name.endIndex  //得到最后位置的索引值,比最后一个字符“g”的位置打1

index = name.index(after: name.startIndex) //获取起始位置之后的索引值

index = name.index(before: name.endIndex)  //获取最后位置之前的索引值

index = name.index(name.startIndex, offsetBy:3) //

index = name.index(name.endIndex, offsetBy:-4) //

print(name[index])

遍历字符串中的每个字符
//for in循环

for item in name {

    print(item, terminator:"")

}

print()

//while循环

var offset = 0

while offset < name.count {

let index = name.index(name.startIndex, offsetBy: offset)

//(let index:String.Index = name.index(name.startIndex, offsetBy: offset))

print(name[index])

offset += 1

}

//遍历字符串的所有索引值,从而遍历每个字符

for myIndex in name.indices {

    print(name[myIndex])

}

可选绑定语法
if let item = a {

print{item}

}

//遍历语法
for var item in1…5   {      //如果不加var默认为let

print{item}

}

let base = 3

let power = 10

var answer = 1

//如果在循环体中不需要循环变量的值,可以使用下划线代替变量的名称

for _ in 1…power {

answer * = base

}

Switch语句中可以加 int char string 枚举 double(后面必须加default)如果想满足多个条件打印同一个结果可以用“,”来隔开
var ch = 3

switch ch {

case 10:

print("不讲价")

case 7…9:

print("(ch)折")

default :

print ("不可能")

} //可以添加元组类型的数据

给循环添加 标签

outer: for I in 1…3 {

    inner:for j in 1…5{

        break outer

    }

print("I = (i),j = (j)")

}

//Swift中,Struct,Double,String、数组、字典、都是值类型
//swift中,类、函数、闭包都是引用类型
//如果结构体中的s已经是常量,里面的成员变量和结构体本身就不可以重新赋值了
//如果类中的s是常量,里面的成员变量可以重新赋值变量,不能重新赋值常量
//、在swift中 == 号只能用在值类型不能用在引用类型(== 在自定义的结构体中自定义的类中也不可以用)
//Swift中 === (恒等于)  !==(恒不等于)只能用于引用类型,不能用于值类型,判断俩个对象指向同一个内存空间(判断地址)
//在结构体中,必须讲方法声明为可变的,才可以在方法体中改变属性的值
//在类中可以直接改变属性的值
重写set、get方法的时候方法里面不能出现sum属性本省否则出现死循环、

如果没有加set、get就会默认重写get语句,get中有俩个语句的话就必须添加get方法

lazy起到延迟加载作用,在调用的时候使用

//便利构造器(如果在某个构造器中调用其他的构造器,须要将构造器做成便利构造器)

指定构造器与便利构造器的区别:

默认构造器是系统提供的构造器

指定构造器是类中主要的构造器,一个指定构造器将初始化类中所提供的所有属性

便利构造器是类中次要的、辅助型的构造器,可以定义便利构造器来调用同一个类中的指定构造器

//子类可以继承父类中所有的属性和方法,子类可以有自己独有的属性和方法

//子类可以重写父类中的方法

你可以将一个继承来的只读属性重写为一个读写属性,只需要在重写版本的属性里提供,getter 和setter 即可,但是,你可以将一个继承来的读写属性重写为一个只读属性

循环强引用问题(retain cycle),在俩个类中互相包含对方的对象做成自己的属性会发生循环强引用

解决:1、使用弱引用,用一个weak来修饰

2、unowned(不能使用引用类型,只能使用基本类型)

thows:一般用于方法定义的按返回值之前,表好似将该方法做成一个可抛出错误的方法(throwing)

Thow:一般用于方法体内,抛出某个具体的错误,如果能执行throw,后续语句都不会执行,该方法调用立即结束,等效return语句

Ios  多态

不同类中有相同方法,调用的时候互不影响

父类指针指向子类,调用一个被重写的方法,父类指针调用这个方法呈现的都是子类中方法的定义执行

扩展

//var name:String = ""(在扩展中不可以扩展存储属性)

//可以扩展“计算属性”

//可以扩展“只读属性”

//存储类型的类属性

//计算类型的类属性

//只读类型的类属性

//添加对象方法

//添加类方法

//在扩展中只能为类添加便利构造器,不可以添加指定构造器