简介

• Swift 语言由苹果公司在 2014 年推出，用来撰写 OS X 和 iOS 应用程序
• 2014 年，在 Apple WWDC 发布

历史

• 2010 年 7 月，苹果开发者工具部门总监 Chris Lattner(克里斯·拉特纳) 开始着手 Swift 编程语言的设计工作
• 用一年时间，完成基本架构

• Swift 大约历经 4 年的开发期，2014 年 6 月发表

  
  abc.jpg

常量&变量

// 定义变量
var i = 10
print(i)
i = 15
print(i)

let j = 20
// 常量一经定义不能自改数值
//        j = 25
print(j)

• 小结
  • var 定义变量，设置之后可以修改
  • let 定义常量，设置之后不可以修改
  • 语句末尾不用使用 ;
  • 在 Swift 中使用 print() 替代 OC 中的 NSLog
  • print 的性能更好

定义 OC 对象

// 实例化视图
let v = UIView(frame: CGRectMake(0, 0, 100, 100))
// 设置背景颜色
v.backgroundColor = UIColor.redColor()
// 添加到根视图
view.addSubview(v)

• 小结
  • 在 Swift 中要实例化一个对象可以使用 类名() 的格式，与 OC 中的 alloc/init 等价
  • OC 中的 initWithXXX 在 Swift 中通常可以使用 类名(XXX: ) 找到对应的函数
  • OC 中的 [UIColor redColor] 类方法，在 Swift 中通常可以使用 类名.XXX 找到对应的函数
  • 使用 let 修饰 v 并且赋值，表示 该常量的内存地址不允许修改，但是可以修改其内部的属性
  • 当前对象的属性，不需要使用 self.

常量&变量的使用原则：尽量先用 let，只有需要变的时候，再用 var，能够更加安全

变量类型

let x = 10
let y = 10.5
let z: Double = 20

print(Double(x) + y)
print(x + Int(y))
print(y + z)

• 小结
  • 初次接触 Swift 中会因为简单的 var let 误以为 Swift 中的类型非常松散
  • 其实所有变量的准确类型都是在赋值的同时自动推导的
  • Swift 是对类型要求非常严格的一门语言，一个值永远不会被自动转换成其他类型
  • 如果要转换，必须显示转换，Swift 中
    • 小数默认是 Double 类型
    • 整数默认是 Int 类型
  • 如果要显式的指定变量的类型，可以在定义是使用 var 变量名: 类型 = 值

逻辑分支

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.baidu.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://www.baidu.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 = "zhangsan"
print(name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
let l = 10
print(l + (name?.lengthOfBytesUsingEncoding(NSUTF8StringEncoding) ?? 0))

• 阶段性小结
  • ?? 是一个非常有用的操作符，能够快速对 nil 进行判断
  • 如果对象是 nil，则使用 ?? 后面的值代替前面的 nil 值参与计算
  • 在使用 ?? 时，整个部分需要使用 () 包装
  • 这一技巧在 UITableView 的数据源方法中尤为重要

循环

OC风格的 for

// 传统写法
for var i = 0; i < 10; i++ {
    print(i)
}

Swift风格的 for

// 遍历 0 ~ <10
for i in 0..<10 {
    print(i)
}
print("---")
// 遍历 0 ~ 10
for i in 0...10 {
    print(i)
}

• 小结
  • Swift 中使用 in 关键字标示循环的范围
  • 0..<10 表示从0到9
  • 0...10 表示从0到10
  • 注意之间不能出现空格

特殊写法

for _ in 0...10 {
    print("hello")
}

• 小结
  • 如果不关心循环本身的索引，可以使用 _ 忽略
  • 这一技巧在之前的分支演练中出现过

while

while和OC差不多,swift中很少使用

var a = 0
while a < 10
{
    print(a)
    a += 1;
}

do while

循环发生很大的变化，do while 没有do了，因为do被用作捕获异常
取而代之的是repeat

var b = 0;
repeat {
    print(b);
    b+=1;
}while b < 10

数组

简单体验

let arr = ["zhangsan", "lisi"]
print(arr)

// 遍历每一个元素
for a in arr {
    print(a)
}

// 像 OC 一样打印
print(arr as NSArray)

数组中保存的对象类型

// 数组中保存的都是字符串
let arr = ["zhangsan", "lisi"]

// 数组中保存的是 NSObject
let arr1 = ["zhangsan", 1]

• 小结
  • 数组使用 [] 定义，这一点与 OC 相同
  • 如果初始化时，所有内容类型一致，择数组中保存的是该类型的内容
  • 如果初始化时，所有内容类型不一致，择数组中保存的是 NSObject

常见数组操作

// 定义只能保存字符串类型数组
var array: [String]

// 初始化数组
array = ["zhangsan"]

// 添加元素
array.append("lisi")

print(array)

// 删除元素
array.removeAtIndex(1)
print(array)

// 删除所有元素
array.removeAll(keepCapacity: true)
print(array.capacity)

// 注意数组容量的变化
for i in 0..<10 {
    array.append("\(i)")
    print("\(array) --- \(array.capacity)")
}

// 实例化新的数组
var array2 = [String]()
array2.append("1")
array2.append("2")

// 拼接数组
array += array2

print(array)

• 小结
  • 如果定义数组时指定了保存对象的类型，择不能向数组中添加其他类型的内容
  • 可以使用 [String]()
  • let 定义的数组是不可变的
  • var 定义的数组是可变的

字典

//创建字典 let dict: [String : NSObject]类型是以后iOS开始种最为常见的一种格式
var dict = ["name":"mJ","age":30];

//获取value
dict["name"]
dict["123"]

//遍历1
for key in dict.keys
{
    print(dict[key]);
}

//遍历2
//利用原则类型遍历字典，会自动将字典中的key赋值给元组中的第一变量 将value赋值元组中的第二个变量
for(key ,value) in dict
{
    print(key);
    print(value);
}

//增加key/value
//如果对应的key在字典中没有，就会新增
dict["sex"] = "man"
print(dict);

//更新
//如果对应的key在字典中有，就会更新
dict["sex"] = "women";
dict

//删除
dict .removeValueForKey("sex");
dict

//合并 += 是不可以的 //利用如果字典中没有key就新增的特性
var dict2 = ["score":99];

for(key,value) in dict2
{
    dict[key] = value
}

字符串

• OC中的字符串 NSString 类型
• Swift中是String类型
• OC 中字符串是一个对象 继承NSObject
• Swift中的字符串是一个结构体
• Swift中的字符串性能比OC中高

var str1: String = "hello world"
var str2: String = "123"
//拼接
str1 + str2

//格式化 swift使用\()来拼接
let age = 1;
let name = "name"
var str3 = "name = \(name)---age = \(age)"
str3

//另一种拼接方式(对应stringWithFormat)
var str4 = String(format: "%02d:%02d:%02d", arguments:[0,6,7])
//注意所有的值必须放到数组中,哪怕只有一个值也要放到数组中

//截取 
//Swift中，如果需要截取字符串，建议使用OC 字符串截取，Swift中字符串和OC字符串可以非常方便的进转换
//创建一个NSString类型的字符串
var str5:NSString = "zhangsan";
//创建一个swift的字符串并且把它当做NSString
var str6 = "zhangsan" as NSString
var subStr = str6.substringWithRange(NSMakeRange(1, 3))

//Swift中字符串支持直接遍历
for a in str4.characters
{
    print(a);
}

函数

语义->将前面计算的结果返回给->返回值

 定义格式 function 函数名称（参数列表）-> 返回值
 {
    执行代码
 }

//没有返回值没有参数 没有返回值使用Void
//简写
//1.func say ->()
//2.func say
func say()-> Void{
    print("hello");
}
say()

//有返回值没有参数
func speak() -> Bool
{
    return false;
}
speak()

//有参数没有返回值 在swift中会自动将形参列表中的第二个参数开始的参数名称作为标签，以便提高阅读性
func sun (a :Int, b :Int)
{
    let sun = a+b;
    print(sun)
}
sun(10, b: 20)

//添加标签Swift2.0之前, x/y称之为外部参数.a/b称之为内部参数
func sum2 (x a:Int, y b:Int)
{
    print(a + b);
}
sum2(x: 1, y: 2)

//有参数有返回值
func sum3 (a : Int , b :Int) -> Int
{
    return (a + b);
}
sum3(1, b: 10)