Swift-基础

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

• 苹果宣称 Swift 的特点是：快速、现代、安全、互动，而且明显优于 Objective-C 语言
• 可以使用现有的 Cocoa 和 Cocoa Touch 框架
• Swift 取消了 Objective C 的指针及其他不安全访问的使用
• 舍弃 Objective C 早期应用 Smalltalk 的语法，全面改为句点表示法
• 提供了类似 Java 的名字空间(namespace)、泛型(generic)、运算对象重载（operator overloading）
• Swift 被简单的形容为 “没有 C 的 Objective-C”（Objective-C without the C）

目录

• 常量和变量
• 基本数据类型
• 类型转换
• Bool类型
• 元祖
• 可选值
• 字符和字符串
• 字符串常用方法
• 运算符
• 数组的基本使用
• 数组其他操作
• 字典
• if
• while循环
• for循环
• break-continue
• Switch
• 函数定义
• 闭包
• 枚举
• 结构体
• 懒加载

---

常量和变量

• var 定义变量，设置之后可以修改

• let 定义常量，设置之后不可以修改

变量

01> 先定义，再初始化

var num: Intnum = 10

02> 定义的同时进行初始化

var num2 = 20// 如果要显式的指定变量的类型，可以在定义是使用 var 变量名: 类型 = 值var num3: Int = 30

常量

Swift中的常量必须在定义时初始化

格式：let num : Int

let num4 = 30let num5: Int = 30

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

---

基本数据类型

整型

var intValue: Int = 10

浮点型

var floatValue1:Double = 99.99 // 表示64位浮点数var floatValue2:Float = 8.8    // 表示32位浮点数

如果按长度分，swift中的长短比OC更加精确

var intValue1:Int8  = 8var intValue2:Int16 = 16var intValue3:Int32 = 32var intValue4:Int64 = 64

有无符号划分，默认是有符号的

• 无符号（UInt8/UInt16/UInt32/UInt64）

var uintValue:UInt8 = 100

注意：无符号的数比有符号的数取值范围更大，因为符号位也用来存储值

---

类型转换

隐式类型转换

 OC: int intValue = 10; double doubleValue = (double)intValue

Swift 不允许隐式类型转换，但可以使用显式类型转换（强制类型转换）

var intValue: Int = 10// var doubleValue: Double = intValue 报错var doubleValue: DoubledoubleValue = Double(intValue)// 注意：Double(）不会修改 intValue 的值，而是通过 intValue 的值生成一个临时的值赋值给 doubleValueprint(intValue)    // 10print(doubleValue) // 10.0

---

Bool类型

C语言的Bool类型是非0即真

OC语言的Bool类型是typedef signed char BOOL

Swift 引入了真正的Bool类型
真：true
假：false

let isOpen = trueif isOpen {    print("打开")} else {    print("关闭")}

---

元祖

将多个相同或者不同类型的值用一个小括号括起来就是一个元祖

• 元祖其实和结构体很像，只是不需要提前定义类型。
• 元祖其实是复合类型，小括号中可以写任意类型

元祖的其他定义方式：
01>指明元祖内部每个元素的类型

let student1: (String,Int,Double) = ("Larry",20,59.5)

02>指明对应元祖元素的名称

let student2 = (name:"Vivian",age:18,score:99.5)

03>通过指定的名称提取元祖对应的值，会将对应位置的值，赋值给对应位置的名称

let(name,age,score) = ("Eric",26,88.5)

04>如果不关心元祖中某个值，可以利用通配符(_)来忽略提取

let(name1,age1,_) = ("Owen",30,77.5)

---

可选值

可选值：optionals 有两种状态

• 1.有值
• 2.没有值,没有值就是 nil

// 有值var optionalValue1: Int? = 9// 没有值var optionalValue2: Int?var optionalValue3: Int? = nil

可选类型的值的提取（强制解析）”!”

var optValue2: Int? = 8var result: Int = optValue2!

可选绑定：

为了更安全的解析可选类型的值，一般情况下使用可选绑定

如果optValue没有值就不会做任何操作，如果optValue有值会返回true并将optValue的值赋值给result，然后执行大括号值的内容

var optValue: Int? = 88;if let result3 = optValue {    print(optValue) // Optional(88)}

---

字符和字符串

字符

单个字符

var charValue1:Character = "a"var charValue2:Character = "王" // 正确

字符串

字符是单个字符的集合，字符串是多个字符的集合，想要存放多个字符需要使用字符串

var stringValue3 = "abc"var stringValue4:String = "abcdef"

---

字符串常用方法

计算字符串的长度

var stringValue = "swift学习"print(stringValue.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))// 打印结果11 字符占一个字节，汉子占3个字节

字符串拼接

var str1 = "abc"var str2 = "123"var str = str1 + str2print(str) // abc123

格式化字符串

var name = "Mazy"var str3 = "\(name) have fun"print(str3) // Mazy have fun

字符串比较

Swift: (== / != / >= / <=)

var str4 = "have fun"var str5 = "have fun"if str4 == str5 {    print("相等")} else {    print("不相等")}var str6 = "abc"var str7 = "abd"if str6 >= str7 {    print("大于或者等于")} else {    print("小于")}

判断前后缀

var urlString = "http://www.baidu.com"if urlString.hasPrefix("http") {    print("是URL")}if urlString.hasSuffix(".com") {    print("是域名")}

大小写转换

var str8 = "Study Swift"print(str8.lowercaseString) // study swiftprint(str8.uppercaseString) // STUDY SWIFT

转换为基本数据类型

var str9 = "12306"// 如果string不能转换为整数，那么可选类型返回nil// 当str9 = "12306a" 不能转换为整型，所以转换结果为nilvar number: Int? = Int(str9)if (number != nil) {    print(number) // Optional(12306)}

---

运算符

算术运算符

+ - * / % += 1 -= 1

var result = 10 + 10print(result) // 20result = 10 - 10print(result) // 0result = 10 * 10print(result) // 100result = 10 / 10print(result) // 1result = 10 % 10print(result) // 0

取模

print(10 % 3.0) // 3.0// 10 / 3.5 = 2-->3// 如果分子和分母有一个是小数，最后的结果就是浮点型

自增自减

• Swift 2.0 可以用 ++ 和 –
• Swift 3.0 以后用 += 1 和 -= 1

var number = 10number += 1print(number)number -= 1print(number)

赋值运算

 = += -= /= *= %=

var number1 = 10number1 = 20print(number1) // 20number1 += 10print(number1) // 30number1 -= 10print(number1) // 20number1 *= 10print(number1) // 100number1 /= 10print(number1) // 20number1 %= 10print(number1) // 0

关系运算符

• 运算结果是Bool值，基本语法和OC一样

 > < >= <= == != ?:(三目运算符)

var result1:Bool = 20 > 10print(result1)// MARK: - 三目运算符var result2 = 20 > 10 ? 20 : 10print(result2)

逻辑运算符

var open = falseif !open {    print("打开")}var age = 20var heiget = 170var weight = 160if (age > 18 && age < 30 && heiget > 165) || weight < 160 {    print("合格")}

区间

闭区间：包含区间的所有值 a...b 例如：1...5 ->（1,2,3,4,5）半闭区间：包含头不包含尾 a..<b 例如：1..<5 ->（1,2,3,4）

注意：区间只能用于整数，写小数会出问题

应用场景：遍历，数组等

for i in 1...5 {    print(i)}for i in 1..<5 {    print(i)}

---

数组的基本使用

数组定义

// 有值数组var arr1 = [1,2,3]var arr2: Array = [1,2,3]var arr3: Array<Int> = [1,2,3]var arr4: [Int] = [1,2,3]// 空数组var arr5 = []var arr6 = [Int]()var arr7 = Array<Int>()// 可变数组var arr8 = []// 不可变数组let arr9 = []

数组的操作

01 获取长度

var arr12 = [1,2,3]print(arr12.count) // 3

02 判断是否为空

var arr13 = [1,2,3]print(arr13.isEmpty) // false

03 检索数组内部元素

var arr14 = [1,2,3]print(arr14[0])print(arr14[2])print(arr14.first)print(arr14.last)print(arr14.minElement())print(arr14.maxElement())

04 追加元素

var arr15: Array<Any> = [1,2,3]arr15 .append(4)arr15 .append("a")print(arr15) // [1, 2, 3, 4, "a"]

05 插入元素

var arr17 = [1,2,3]arr17.insert(4, atIndex: 0)print(arr17) // [4, 1, 2, 3]

06 更新元素

var arr18 = [1,2,3]arr18[1] = 9print(arr18) // [1, 9, 3]

07 删除元素

var  arr19 = [1,2,3]arr19.removeAtIndex(0)print(arr19)var  arr20 = [1,2,3]arr20.removeLast()print(arr20)var  arr21 = [1,2,3]arr21.removeFirst()print(arr21)var  arr22 = [1,2,3]arr22.removeAll()print(arr22)var  arr23 = [1,2,3]arr23.removeAll(keepCapacity: false) // 是否保持容量，如果是true,即使删除了容量依然存在，容量是2的倍数print(arr23)print(arr23.capacity)// 注意：如果数组是一个不可变数组，不能更新、插入、删除

数组其他操作

Range 范围

var arr24 = [1,2,3]arr24.removeRange(Range(1..<2))print(arr24) // [1,3]var arr25 = [1,2,3]arr25.removeRange(Range(0...0))print(arr25) // [2,3]var range = 0...5var range1: Range<Int> = 0...5var range2: Range<Int> = 0..<5print(range)  // 0..<6print(range1) // 0..<6print(range2) // 0..<5

数组的批量操作

var arr = [1,2,3]arr.replaceRange(1..<2, with: [99,98,97,96])print(arr) // [1, 99, 98, 97, 96, 3]

遍历

var arr1 = [1,2,3]for i in 0 ..< arr1.count {    print(arr1[i])}for number in arr1 {    print(number)}var arr2 = [1,2,3]for number in arr2[0..<3] {    print(number)}

---

字典

字典的定义

// 注意：key一定是可以hash的(String,Int,Float,Double,Bool),value没有要求var dict = ["name":"Eric","age":28]print(dict) // ["age": 28, "name": Eric]var dict1: Dictionary = ["name":"Larry","age":26]print(dict1) // ["age": 26, "name": Larry]// key必须是String类型，value任意var dict2: Dictionary<String,AnyObject> = ["name":"Vivian","age":24]print(dict2) // ["age": 24, "name": "Vivian"]// key必须是String类型，value任意var dict3: [String:AnyObject] = ["name":"Vivian","age":24]var dict4: [String:AnyObject] = Dictionary(dictionaryLiteral:("name","Owen"),("age",30))print(dict4)// 可变字典var dict5 = [:]// 不可变字典let dict6 = [:]

字典操作

01.获取

var dict7 = ["name":"Eric","age":28]print(dict7["name"])

02.修改

dict7["name"] = "Brouth"print(dict7)dict7.updateValue("Lucy", forKey: "name")print(dict7)

03.更新

// updateValue返回一个可选类型，如果字典中不存在需要更新的key，那么返回nil，如果存在，返回原始值var dict8 = ["name":"Vivian","age":24]if let original = dict8.updateValue("Marry", forKey: "name") {    print(dict8["name"])}print(dict8)

04.添加

var dict9 = ["name":"Eric","age":28]dict9["weight"] = 130

05.删除

var dict10 = ["name":"Eric","age":28]dict10.removeValueForKey("age")// 注意：removeValueForKey() 返回一个可选类型，如果字典中不存在需要删除的key，那么返回nil并且不会执行任何操作，如果存在则删除key对应的值，并且返回被删除的值var dict11 = ["name":"Eric","age":28]if let orignal = dict11.removeValueForKey("name") {    print(dict11)    print(orignal)}

06.遍历字典

var dict12 = ["name":"Eric","age":28,"sex":"male","height":170.5]// 取出所有的key和valuefor (key,value) in dict12 {    print("key = \(key) value = \(value)")}// 取出所有的keyfor key in dict12.keys {    print(key)}// 取出所有的valuefor value in dict12.values {    print(value)}

---

if

if 条件表达式 {指令}

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

• 1.if后面的圆括号可以省略
• 2.只能以Bool作为条件语句
• 3.如果只有一条指令，if后面的大括号不可以省略

var age1: Int = 10var age2: Int = 8var max: Int?if age1 > age2 {    max = age1}print(max) // 10if age1 > age2 {    max = age1} else {    max = age2}print(max) // 10

---

while循环

• 1.while后面的圆括号可以省略
• 2.只能bool作为条件语句
• 3.如果只有一条条件语句，while后面的大括号不可以省略

while i <= 10 {    i = i+1    sum = i    print("\(sum)")}

do while 循环

格式：do while (循环保持条件) {执行的语句}

Swift 2.0之后变为repeat while, do用于捕捉异常

• 1.while后面的圆括号可以省略
• 2.只能bool作为条件语句
• 3.如果只有一条条件语句，while后面的大括号不可以省略

var j:Int = 0var sum1:Int = 0repeat {    j = j + 1    sum1 = j    print(sum1)} while (j <= 10)repeat {    j = j + 1    sum1 = j    print(sum1)} while j <= 10

---

for循环

格式1: for (初始化表达式;循环保持条件;循环后表达式) {需要执行的语句} // swift3.0弃用
格式2: for in

• 1.for后面的圆括号可以省略
• 2.只能Bool作为条件语句
• 3.for后面的三个参数都可以省略，如果省略循环保持语句，那么默认为真

var sum: Int = 0for i in 0..<10 {    sum += i    print(i)    print(sum)}for dict in ["name":"Vivian","age":18] {    print(dict)}for (key,value) in ["name":"Lucy","age":19] {    print("\(key) = \(value)")}

---

break-continue

• break: 跳出循环，无论循环保持条件是否还为真都不会再执行循环
• continue: 跳出本次循环，如果循环保持条件还为真会继续执行循环

var array:Array<Int> = [1,3,5,8,9]for num in array {    if num == 8 {        print("找到幸运数字-\(num)")        break    }    print("没有找到幸运数字-\(num)")}var arr: Array<Int> = [1,3,5,8,9]var count:Int = 0for num in arr {    if num % 2 != 0 {        print("\(num)-不能被2整除")        continue    }    print("\(num)-能被2整除")}

---

Switch

格式： switch(需要匹配的值) case 匹配的值: 需要执行的语句 break

• 不可以穿透
• 可以不写break

var rank = "A"switch rank {    case "A": // 相当于if        print("优")    case "B": // 相当于else if        print("良")    case "C": // 相当于else if        print("中")    case "D": // 相当于else if        print("差")    default:  // 相当于else    print("没有评级")}

可以这样写

var rank1 = "A"switch rank {case "A","B": // 相当于if    print("优")case "C","D": // 相当于else if    print("中")default:  // 相当于else    print("没有评级")}

---

函数定义

函数：完成某个特定任务的代码块，给代码块起一个合适的名称称为函数名称。以后需要执行代码块只需要利用函数名称调用即可。好比每个人都有一个名字，叫名字就能找到对应的人

格式：func 函数名称(参数名:参数类型,参数名:参数类型…) -> 函数返回值 {函数实现部分}

无参无返回值

func say() -> Void {    print("hello")}

有参无返回值

func sayWithName(name:String) {    print("hello \(name)")}sayWithName("word")func sayWithName1(name:String, age:Int) {    print("hello \(name) my age is \(age)")}sayWithName1("Eric", age: 25)

无参有返回值

func info() -> String {    return "name = Larry, age = 26"}info()

有参有返回值

func info(name:String,age:Int) -> String {    return "name is \(name), age is \(age)"}print(info("Owen",age:30))

---

闭包

函数是闭包的一种

类似于OC语言的block

闭包表达式(匿名函数) – 能够捕获上下文的值

语法：

 in 关键字的目的是便于区分返回值和执行语句 闭包表达式的类型和函数的类型一样，是参数加上返回值，也就是in之前的部分 {    (参数) -> 返回值类型 in    执行语句 }

完整写法：

let say:(String) -> Void = {    (name: String) -> Void in    print("hi \(name)")}say("Mazy")

没有返回值写法

let say2:(String) -> Void = {    (name: String) in     print("hi \(name)")}say2("Lerry")// 简写let say2:(String) = {    (name: String) in     print("hi \(name)")}say2("Lerry")

没有参数没有返回值写法

let say3:() -> Void = {    print("hello world")}say3()

---

枚举

// 格式： enum Method  {    case 枚举值 }

enum Method {//    case Add//    case Sub//    case Mul//    case Div    // 可以连在一起写    case Add,Sub,Mul,Div}

利用switch匹配枚举值

// 注意：如果case中包含了所有的值，可以不写default。如果case中没有包含枚举中的所有的值，必须写defaultswitch (Method.Add) {    case Method.Add:        print("加")    case Method.Sub:        print("减")    case Method.Mul:        print("乘")    case Method.Div:        print("除")}

原始值

OC中枚举的本质就是整数，所以OC中的枚举是有原始值的，默认是从0开始的 而swift值的枚举值默认是没有原始值的，但是可以在定义时告诉系统让枚举有原始值enum Method: 枚举的原始值类型 {  case 枚举值}

enum Method1: Int {    // 可以连在一起写    case Add,Sub,Mul,Div}// 和OC的枚举一样，也可以指定原始值，后面的值默认+1enum Method2: Int {    // 可以连在一起写    case Add = 5,Sub,Mul,Div}// swift 中的枚举除了可以指定整形以外还可以指定其他类型，但是如果指定了其他类型，必须给所有的枚举值赋值，因为不能自动递增enum Method3: Double {    case Add = 5.0,Sub = 8.0,Mul = 9.0,Div = 10.0}

---

结构体

结构体是用于封装不同或相同类型的数据的，swift中的结构体是一种类型，可以定义属性和方法(甚至构造方法和析构方法等)格式：struct 结构体名称 {    结构体属性和方法 }

struct Rect {    var width: Double = 0.0    var height:Double = 0.0}

---

懒加载

格式：lazy var 变量: 类型 = { 创建变量代码 }()

lazy var demoView: UIView = {    let view = UIView(frame: CGRectMake(10, 10, 100, 100))    view.backgroundColor = UIColor.redColor()    return view}()

懒加载的写法本质上是定义并执行一个闭包