Swift相比OC语言有哪些优势

Swift相比OC语言有哪些优势
一、自动作类型推断

二、能够保证类型使用安全

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 储存值的类型保持一致

区间运算符
一、闭区间

    a...b定义一个包含从 a 到 b （包含 a 和 b ）的全部值的区间

    a 的值不能超过 b

二、半开区间

    a ..< b 定义一个包含从 a 到 b（不包含b）的全部值的区间

    a 的值不能超过 b

三、自增自减运算符在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），在俩个类中互相包含对方的对象作成本身的属性会发生循环强引用

解决：一、使用弱引用，用一个weak来修饰

二、unowned（不能使用引用类型，只能使用基本类型）

thows:通常用于方法定义的按返回值以前，表好似将该方法作成一个可抛出错误的方法（throwing）

Thow:通常用于方法体内，抛出某个具体的错误，若是能执行throw，后续语句都不会执行，该方法调用当即结束，等效return语句

Ios  多态

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

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

扩展

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

//能够扩展“计算属性”

//能够扩展“只读属性”

//存储类型的类属性

//计算类型的类属性

//只读类型的类属性

//添加对象方法

//添加类方法

//在扩展中只能为类添加便利构造器，不能够添加指定构造器