swift基本语法（总结提炼版）之002逻辑分支

简单体验

var i = 10

if i > 0 {
print("OK")
}

阶段性小结

Swift

中没有 C 语言中的

非零即真

概念
在逻辑判断时必须显示地指明具体的判断条件

if

语句条件的

()

可以省略
但是

{}

不能省略

三目

var a = 10
var b = 50

var result = a > b ? a : b
print(result)

阶段性小结

Swift

中的

三目

运算保持了和 OC 一致的风格

可选项

演练 1

let url = NSURL(string: "http://www.520it.com/")

if url != nil {
NSURLSession.sharedSession().dataTaskWithURL(url!, completionHandler: { (data, _, _) -> Void in
print(NSString(data: data!, encoding: NSUTF8StringEncoding))
}).resume()
}

阶段性小结

在

Swift

中，不是所有的对象实例化方法都会返回值，在实际开发中需要注意实例化函数的返回类型，例如：

convenience init?(string URLString: String)

如果有

?

表示改方法有可能无法实例化到正确的对象

这种函数返回的对象，被称为

可选项

，即有可能有值，也有可能没有值
实际开发时，需要针对这种对象加以判断，并且在分支内部使用

!

，指明改对象确实是存在的
相比在

OC

的开发，尤其在日常练习时，会给定一个能够运行的值，而在实际运行时，一旦条件不满足，会直接闪退，这样用户体验会非常不好

Swift

的设计者考虑到因为对类型的强制要求，会让代码很难看，因此提供了一个变通的解决方案

演练 2

if let url = NSURL(string: "http://520it.com") {
NSURLSession.sharedSession().dataTaskWithURL(url, completionHandler: { (data, _, _) -> Void in
print(NSString(data: data!, encoding: NSUTF8StringEncoding))
}).resume()
}

阶段性小结

使用

if let 常量 = 可选构造函数

的方式能够确保分支内部常量一定是有值的
并且在分支内部不再需要使用

!

这是

Swift

代码中的一个非常重要的使用技巧

提示

尽管

Swift

提供了类型校验的手段，但是要写出

优雅

的 Swift 代码，还是需要多加练习的，否则一不小心就会出现分支嵌套层次很深的代码
有关

?

和

!

的选择，可以借助 Xcode 的辅助工具，但是强烈建议每次遇到提示时，要多加思考，反复揣摩

演练3

var name: String?
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

name = "lnj"
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

let l = 10
print(l + (name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding) ?? 0))

阶段性小结

??

是一个非常有用的操作符，能够快速对

nil

进行判断
如果对象是

nil

，则使用

??

后面的值代替前面的

nil

值参与计算
在使用

??

时，整个部分需要使用

()

包装
这一技巧在

UITableView

的数据源方法中尤为重要

操练：
/*

if语句基本使用

OC:

int age1 = 10;

int age2 = 20;

int max;

max = age2;

if (age1 > age2) {

max = age1;

}

NSLog(@"%d", max);

if (age1 > age2) {

max = age1;

}else

{

max = age2;

}

NSLog(@"%d", max);

如果只有一条指令if后面的大括号可以省略

/**Swift:

if 条件表达式 {指令} if 条件表达式 {指令} else{指令}

0.if后的圆括号可以省略

1.只能以bool作为条件语句

2.如果只有条指令if后面的大括号不可以省略

*/



/*

多分支

OC:

float score = 99.9;

if (score >= 90) {

NSLog(@"优秀");

}else

{

if (score >= 60) {

NSLog(@"良好");

}else

{

NSLog(@"不给力");

}

}

if (score >= 90) {

NSLog(@"优秀");

}else if (score >= 60)

{

NSLog(@"良好");

}else

{

NSLog(@"不给力");

}

*/

var score = 99.9;

if score >= 90

{

print("优秀")

}else if score >= 60

{

print("良好")

}else

{

print("不给力")

}

可选类型

/*

可选类型:

可选类型的本质其实就是一个枚举

None 没有值

Some 有值

格式: Optional<类型> 或 在类型后面加上?号

由于可选类型在Swift中随处可见, 所以系统做了一个语法糖, 在类型后面加上?

*/

var opa: Optional<Int>

var opb: Int?

var nora: Int

nora = 10

// 基本类型变量, 在使用之前必须进行初始化, 否则报错

// 目的: 安全, 不管在什么时候访问都是有意义的

// 普通变量和可选类型的区别, 普通变量只有一种状态, 有值

// 注意:Swift的变量和C/OC的不一样, C/OC可以没有值, 是一个随机值

//int *p;

//NSLog("%d", *p); // 会报错, 不安全

print(nora)

// 由于普通变量只有一种状态, 有局限性, 所以Swift设计了可选类型

print(opb)

// 可选类型是安全的么? 是, 可以通过可选绑定判断后再使用

// Swift的发明者完全是基于安全的考虑, 当我们使用基本类型时完全不用考虑是否有值

// 当我们使用可选类型时, 总会记得先判断再使用. 让程序时刻了解哪些有值哪有没有值

opb = 55

if let b = opb{

// print(opb!)

print(b)

}

// Swift中的可选类型变量更贴近于OC中的普通变量

//NSData *data = [NSData .dataWithContentsOfMappedFile:@"/Users/Jonathan_Lee/Desktop/老员工奖.xlsx"];

//NSLog("%@", data);

var data:NSData? = NSData(contentsOfFile: "/Users/Jonathan_Lee/Desktop/老员工奖.xlsx")

print(data)

/*

可选链: 通过可选类型的变量来调用相应的属性和方法

可选链的返回值是一个可选值

格式:

可选值?.属性

可选值?.方法

*/

class Person {

var name: String

init(name:String){

self.name = name

}

func whoami() ->String{

print("my name is \(self.name)")

return name

}

}

var p0 : Person?

var p1 : Person = Person(name: "lnj")

//p1.name = "zs"

//p1.whoami()

// 如何通过可选类型来调用对应的方法和属性

// 1.通过强制解包

// 但是强制解包非常危险, 如果可选类型没有值, 会引发运行时错误

//p0!.name = "ls"

//p0!.whoami()

// 2.通过可选绑定, 代码繁琐(会将p0里面的值取出来赋值给p，如果值不为空才进入{})

//if let p = p0{

// p.name = "ls"

// p.whoami()

//}

// 3.通过可选链, 如果问号前面的变量没有值, 整个可选链会失效

// 更加简洁高效, 有利用使用可选类型

p0 = p1

p0?.name = "ls"

p0?.whoami()

// 可选链的返回值会自动包装成一个可选值

// 因为可选链可用能失效, 所以返回值可能有值也可能没有值, 要想表达有值或者没有值只能用可选值, 所以返回值会自动包装成一个可选值

print(p0?.name)

print(p0?.whoami())

print(p1.name)

var a:String? = p0?.name

p0?.name = "ww"

var b:String = p1.name

/*

可选链调用下标索引

格式:

可选值?[]

*/

struct Student {

var name:String = "lnj"

var math:Double = 99.0

var chinese:Double = 99.0

var english:Double = 99.0

// 要想实现下标访问, 必须实现subscript方法

// 如果想要通过下标访问, 必须实现get方法

// 如果想要通过下表赋值, 必须实现set方法

subscript(course:String) ->Double?{

get{

switch course{

case "math":

return math

case "chinese":

return chinese

case "english":

return english

default:

return nil

}

}

set{

switch course{

case "math":

// 因为返回的是可选类型

math = newValue!

case "chinese":

chinese = newValue!

case "english":

english = newValue!

default:

print("not found")

}

}

}

}

var stu:Student? = Student()

// 可选链调用下标索引不需要., 直接在问号后面写上[]即可

print(stu?["math"])

//var arr:Array? = [1, 2, 3, 4]

//print(arr?[1])

// 利用可选链赋值. 注意: 早起版本中不能利用可选链赋值

stu?.name = "ww"

print(stu?.name)

// 利用可选链给下标赋值

stu?["math"] = 88

print(stu?["math"])

// 判断赋值操作是否成功, 可选链的赋值操作也有返回值

// 如果赋值成功会返回一个可选类型, 返回()?也就是Viod? 代表成功. 返回nil代表失败

//let res: = stu?.name = "zl"

//let res: ()? = stu?.name = "zl"

//let res: Void? = stu?.name = "zl"

stu = nil

let res: Void? = stu?.name = "zl"

print(res)

/*

多层可选链:

单层:可选值?.属性

多层:可选值?.属性.属性?.属性 或者 可选值?.属性?.属性?.属性

*/

class A {

var name:String = "lnj"

}

class B{

var a1:A?

}

class C{

var b1:B = B()

}

class D{

var c1: C?

}

var a1 = A()

var b1 = B()

var c1 = C()

var d1 = D()

d1.c1 = c1

//b1.a1 = a1

// 通过d直接给b赋值

// 由于D中的C是可选值, 所以需要在C后面加上?

d1.c1?.b1.a1 = a1

// 通过d直接获取a中的name

// 其实只需要在可选值后面加上问号即可, 如果可选值不存在, 那么后面的链失效

print(d1.c1?.b1.a1?.name)