×

Swift4.0基础知识回顾

96
博行天下
2017.12.06 13:44* 字数 3630
简单介绍一下Swift

Swift 语言由苹果公司在 2014 年推出,用来撰写 OS X 和 iOS 应用程序,Swift语言让应用开发更简单、更快、更稳定,确保最终应用有着更好的质量更多了解Swift可以去 《The Swift Programming Language》中文版,这次分享给大家是Swift基础知识,如果你耐心看完本篇文章,并且可以理解Swift的编程技巧和方法,恭喜你可以顺利的使用Swift开发了,已经掌握了Swift的基本语法,想要真正从事苹果开发,还需要在以后的学习中不断探索和挖掘Swift
在接下来的文章中,直接深入主题,不做过多没必要的文字说明,提高大家阅读和吸收能力

一、常量和变量
常量:使用let来定义常量,定义之后不可以修改
变量:使用var来定义变量,定义之后可以修改
在使用过程中建议先定义常量,如果需要修改再修改为变量

import UIKit
let a : Int = 10
var b : Int = 20
b = 30 变量可以修改
// a = 20是错误的,常量是不能修改的

二、数据类型
1、类型介绍
Swift中的数据类型也有:整型/浮点型/对象类型/结构体类型等,整型分为有符号整型和无符号整型,例如Int、UInt,浮点型分为Float和Double

// 定义一个Int类型
var m : Int = 10
// 定义一个Double类型
let n : Double = 3.14

2、类型推导
Swift是强类型的语言,Swift中任何一个标识符都有明确的类型,如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略,Swift会自动根据后面的赋值来决定前面的标识符的数据类型,同时可以通过option+鼠标左键来查看变量的数据类型

Swift会自动识别a是整数,如果之后再赋值给a一个其他类型(比如浮点型)数值,则会报错
var a = 20
// 正确写法
var b = 3.33
b = 6.66

3、基本运算
Swift中在进行基本运算时必须保证类型一致,否则会出错,相同类型之间才可以进行运算,Swift中没有隐式转换
Swift中数据类型的转化,Int类型转成Double类型是Double(标识符),Double类型转成Int类型是Int(标识符)

let a = 12
let b = 3.14

// 错误写法,形同类型之间才可以进行运算
// let c = a + b
// let c = a * b

// 正确写法,转换类型进行运算
let c = Double(a) + b
let d = a + Int(b)

三、逻辑分支
1、分支的了解
分支即if、switch、三目运算符等判断语句,通过分支语句可以控制程序的执行流程
2、if分支语句
和OC不同,Swift判断句可以不加(),在Swift的判断句中必须有明确的真假,不再有非0即真,必须有明确的Bool值,Bool有两个取值:false、true,没有Yes、NO的使用

例1
确定值存在的判断
let a = 12

// 错误写法,在Swift的判断句中必须有明确的真假,不再有非0即真
//if a {
//    print("a")
//}

// 正确写法
if a > 9 {
    print(a)
}
例2
可选类型的判断,判断如果view有值,则设置背景
let view : UIView? = UIView()
// 错误写法
//if view {
//    view.backgroundColor = UIColor.red
//}

if view != nil {
    view!.backgroundColor = UIColor.red
}

3、三目运算符
Swift 中的 三目 运算符和 OC 的用法是一样的

var a = 12
var b = 24

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

4、guard的使用
guard是很重要的,在以后的开发中会经常用到,来判断该值是否是可选类型,guard在Swift2.0就出现了,与if语句非常类似,它设计的目的是提高程序的可读性
guard语句必须带有else语句,当条件表达式为true时候跳过else语句中的内容,执行语句组内容,条件表达式为false时候执行else语句中的内容,跳转语句一般是return、break、continue和throw

例1
guard用法说明
guard 条件表达式 else {
    // 条换语句,走这里的都是错误的,判断不符合要求的
    break
}
语句组,正确的执行这里
例2
简单使用guard的用法
 func gotToSchool(time:Int) -> Void {
        guard time > 6 else {
            print("去上学")
            return
        }
        print("不去上学")
    }
gotToSchool(time: 5)

5、switch分支
Switch作为选择结构中必不可少的语句也被加入到了Swift中,只要有过编程经验的人对Switch语句都不会感到陌生,苹果对Switch进行了大大的增强,使其拥有其他语言中没有的特性
基本用法和OC用法一致,switch后可以不跟(),case后可以不跟break(默认会有break)

例1
switch对整数的判断

let sex = 0
switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}
例2
一个case判断中,可以判断多个值,多个值以,隔开

let sex = 0
switch sex {
case 0, 1:
    print("正常人")
default:
    print("其他")
}
例3
希望出现之前的case穿透,则可以使用关键字fallthrough

let sex = 0
switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

Switch支持多种数据类型

① 浮点型的switch判断

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}
② 支持字符串类型

let m = 5
let n = 10
var result = 0

let opration = "+"

switch opration {
    case "+":
        result = m + n
    case "-":
        result = m - n
    case "*":
        result = m * n
    case "/":
        result = m / n
default:
    result = 0
}
③ switch支持区间判断
开区间:0..<10 表示:0~9,不包括10
闭区间:0...10 表示:0~10

let score = 88
switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("几个")
case 80..<90:
    print("良好")
case 90..<100:
    print("优秀")
default:
    print("满分")
}

四、循环
在开发中经常会需要循环,常见的循环有:for、while、do while
1、for循环

① 传统写法
for var i = 0; i < 10; i++ {
    print(i)
}
② 区间for循环
for i in 0..<10 {
    print(i)
}

for i in 0...10 {
    print(i)
}
③ 特殊写法
如果在for循环中不需要用到下标i,用`_`标示
for _ in 0..<10 {
    print("hello")
}

2、while和do while循环

① while的判断句必须有正确的真假,没有非0即真,while后面的()可以省略
var a = 0
while a < 10 {
    a++
}
② do while循环,使用repeat关键字来代替了do
let b = 0
repeat {
    print(b)
    b++
} while b < 20

五、字符串
OC和Swift中字符串的区别,在OC中字符串类型时NSString,在Swift中字符串类型是String,OC中字符串@"",Swift中字符串""
Swift中的String 是一个结构体,性能更高,NSString 是一个 OC 对象,性能略差,String 支持直接遍历,Swift 提供了 String 和 NSString 之间的无缝转换,可以使用as或者as?进行转换
1、遍历字符串

// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {
    print(c)
}

2、字符串拼接

例1
let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2
例2
let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"
例3
字符串的格式化
let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])

3、字符串的截取
Swift中提供了特殊的截取方式,该方式非常麻烦,简单的方式是将String转成NSString来使用,在标识符后加:as NSString即可

let myStr = "www.baidu.com"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

六、数组
数组(Array)是一串有序的由相同类型元素构成的集合,数组中的集合元素是有序的,可以重复出现,swift数组类型是Array,是一个泛型集合
1、数组的初始化
数组分成可变数组和不可变数组,使用let修饰的数组是不可变数组,使用var修饰的数组是可变数组

// 定义一个可变数组,必须初始化才能使用
var array1 : [String] = [String]()

// 定义一个不可变数组
let array2 : [NSObject] = ["xiaoming", 18]
在声明一个Array类型的时候可以使用下列的语句之一
var stuArray1:Array<String>
var stuArray2: [String]
声明的数组需要进行初始化才能使用,数组类型往往是在声明的同时进行初始化的
// 定义时直接初始化
var array = ["xm", "xl", "my"]

// 先定义,后初始化
var array : Array<String>
array = ["xm", "xl", "my"]

2、对数组的基本操作

// 添加数据
array.append("xiaoming")

// 删除元素
array.removeFirst()

// 修改元素
array[0] = "xiaoming"

// 取值
array[1]

3、数组的遍历

// 遍历数组
for i in 0..<array.count {
    print(array[i])
}

// forin方式,经常使用
for item in array {
    print(item)
}

// 设置遍历的区间
for item in array[0..<2] {
    print(item)
}

4、数组的合并

// 数组合并
// 注意:只有相同类型的数组才能合并
var array = ["xm", "xl","my"]
var array1 = ["haha", "wsz"]
var array2 = array + array1;

// 不建议一个数组中存放多种类型的数据
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4

七、字典
字典是由两部分集合构成的,一个是键(key)集合,一个是值(value)集合,键集合是不能有重复元素的,而值集合是可以重复的,键和值是成对出现的,Swift字典类型是Dictionary,也是一个泛型集合
1、Swift中的可变和不可变字典,使用let修饰的数组是不可变字典,使用var修饰的数组是可变字典

// 定义一个可变字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定义一个不可变字典
let dict2 = ["name" : "xl", "age" : 18]
在声明一个Dictionary类型的时候可以使用下面的语句之一
var dict1: Dictionary<Int, String>
var dict2: [Int: String]
声明的字典需要进行初始化才能使用,字典类型往往是在声明的同时进行初始化的
// 定义字典的同时,进行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]

2、字典的基本操作

// 添加数据
dict["height"] = 1.80
dict["weight"] = 65.0

// 删除字段
dict.removeValueForKey("height")

// 修改字典
dict["name"] = "lmj"

// 查询字典
dict["name"]

3、字典的遍历

// 遍历字典中所有的值
for value in dict.values {
    print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
    print(key)
}
// 遍历所有的键值对
for (key, value) in dict {
    print(key)
    print(value)
}

4、字典的合并

// 字典的合并
var dict1 = ["name" : "xl", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

八、元组
元组是Swift中特有的,OC中并没有相关类型,类似于数组或者字典,可以用于定义一组数据,组成元组类型的数据可以称为“元素”
1、元组的定义

元组的常见写法
// 使用元组描述一个人的信息
("1001", "张三", 30, 90)
// 给元素加上元素名称,之后可以通过元素名称访问元素
(id:"1001", name:"张三", english_score:30, chinese_score:90)

2、元祖的简单使用

// 元祖使用

// 写法一:
let object = (xiaoming, "18")
print(object.0)
print(object.1)

// 写法二:
let object = (name : xiaoming, age : "18")
print(object.name)
print(object.age)

// 写法三:
let (name, age) = (xiaoming, "18")
print(name)
print(age)

九、可选类型
在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型),在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言),但是开发中赋值nil,在所难免,因此推出了可选类型
可选类型的取值:空值或者有值
1、定义可选类型

// 写法一:定义可选类型
let name : Optional<String> = nil

// 写法二:定义可选类型,语法糖(常用)
let name : String? = nil

2、可选类型的使用

// 定义可选类型
var string : Optional<String> = nil

// 给可选类型赋值
string = "Hello world"

// 打印结果
print(string)
// 结果:Optional("Hello world")\n

// 取出可选类型的真实值(解包)
print(string!)
// 结果:Hello world\n

// 注意:如果可选类型为nil,强制取出其中的值(解包),会出错
string = nil
print(string!) // 报错

// 正确写法:
if string != nil {
    print(string!)
}

// 简单写法:为了让在if语句中可以方便使用string
// 可选绑定
if let str = string {
    print(str)
}

十、函数
1、函数介绍
函数相当于OC中的方法,函数的格式如下

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}

func是关键字,多个参数列表之间可以用逗号(,)分隔,也可以没有参数,使用箭头“->”指向返回值类型,如果函数没有返回值,返回值为Void.并且“-> 返回值类型”部分可以省略

2、常见的函数类型

① 没有参数,没用返回值
func about() -> Void {
    print("iphone6s plus")
}
// 调用函数
about()

如果没用返回值,Void可以写成()
func about1() -> () {
    print("iphone6s plus")
}
// 如果没有返回值,后面的内容可以都不写
func about2() {
    print("iphone6s plus")
}
about2()

② 有参数,没用返回值
func callPhone(phoneNum : String) {
    print("打电话给\(phoneNum)")
}
callPhone("+86 110")

③ 没用参数,有返回值
func readMessage() -> String {
    return "吃饭了吗?"
}
var str = readMessage()
print(str)

④ 有参数,有返回值
func sum(num1 : Int,num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20,num2: 30)
print(result)

3、函数的使用
① 外部参数和内部参数
在函数内部可以看到的参数,就是内部参数,在函数外面可以看到的参数,就是外部参数,默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数,如果第一个参数也想要有外部参数,可以设置标签,在变量名前加标签即可,如果不想要外部参数,可以在参数名称前加_

// num1和a是外部参数的名称
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
    return num1 * num2 * num3
}
var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = ride(20, 20)

② 默认参数
如果没有传入具体的参数,可以使用默认参数

func makecoffee(type :String = "卡布奇诺") -> String {
    return "制作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("铁观音")
let coffee2 = makecoffee()

③ 可变参数
Swift中函数的参数个数可以变化,它可以接受不确定数量的输入类型参数,它们必须具有相同的类型,我们可以通过在参数类型名后面加入(...)的方式来指示这是可变参数

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0, 20, 30)
sum(30, 80)

④ 引用类型(指针的传递)
默认情况下,函数的参数是值传递,如果想改变外面的变量,则需要传递变量的地址,必须是变量,因为需要在内部改变其值,Swift提供的inout关键字就可以实现

// 函数一:值传递
func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp
    print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")

// 函数二:指针的传递
func swap1(inout a : Int, inout b : Int) {
    let temp = a
    a = b
    b = temp

    print("a:\(a), b:\(b)")
}

swap1(&a, b: &b)
print("a:\(a), b:\(b)")

⑤ 函数的嵌套使用
swift中函数可以嵌套使用,即函数中包含函数,但是不推荐该写法
十一、类的使用
1、类的介绍和定义
Swift也是一门面向对象开发的语言,面向对象的基础是类,类产生了对象,class是Swift中的关键字,用于定义类

定义的类,可以没有父类.那么该类是rootClass,通常情况下,定义类时,继承自NSObject(非OC的NSObject)
class 类名 : SuperClass {
    // 定义属性和方法
}

2、定义类的属性
Swift中类的属性有多种:存储属性,存储实例的常量和变量;计算属性,通过某种方式计算出来的属性;类属性,与整个类自身相关的属性
① 存储属性
存储属性是最简单的属性,它作为类实例的一部分,用于存储常量和变量,可以给存储属性提供一个默认值,也可以在初始化方法中对其进行初始化

// 给存储属性赋值
stu.age = 10
stu.name = "xiaoming"

stu.chineseScore = 89.0
stu.mathScore = 98.0

② 计算属性
计算属性并不存储实际的值,而是提供一个getter和一个可选的setter来间接获取和设置其它属性,计算属性一般只提供getter方法,如果只提供getter,而不提供setter,则该计算属性为只读属性,并且可以省略get{}

class Student : NSObject {
    // 存储属性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 计算属性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 没有意义,因为之后获取值时依然是计算得到的
        // newValue是系统分配的变量名,内部存储着新值
        set {
            self.averageScore = newValue
        }
    }
}

③ 类属性
类属性是与类相关联的,而不是与类的实例相关联,类属性的设置和修改,需要通过类来完成,类属性使用static来修饰

class Student : NSObject {
    // 类属性
    static var corseCount : Int = 0
}

// 设置类属性的值
Student.corseCount = 3
// 取出类属性的值
print(Student.corseCount)

④ 监听属性的改变
在OC中我们可以重写set方法来监听属性的改变,在Swift中可以通过属性观察者来监听和响应属性值的变化,通常是监听存储属性和类属性的改变,(对于计算属性,我们不需要定义属性观察者,因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
willSet:在属性值被存储之前设置,此时新属性值作为一个常量参数被传入,该参数名默认为newValue,我们可以自己定义该参数名;didSet:在新属性值被存储后立即调用,与willSet相同,此时传入的是属性的旧值,默认参数名为oldValue;
willSet与didSet只有在属性第一次被设置时才会调用,在初始化时,不会去调用这些监听方法

class Person : NSObject {
    var name : String? {
        // 可以给newValue自定义名称
        willSet (new){ // 属性即将改变,还未改变时会调用的方法
            // 在该方法中有一个默认的系统属性newValue,用于存储新值
            print(name)
            print(new)
        }
        // 可以给oldValue自定义名称
        didSet (old) { // 属性值已经改变了,会调用的方法
            // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "xiaoming"

十二、类的构造函数
构造函数类似于OC中的初始化方法init方法,默认情况下载创建一个类时,必然会调用一个构造函数,即便是没有编写任何构造函数,编译器也会提供一个默认的构造函数,如果是继承自NSObject,可以对父类的构造函数进行重写
1、构造函数的基本使用
① 类的属性必须有值,如果不是在定义时初始化值,可以在构造函数中赋值

class Person: NSObject {
    var name : String
    var age : Int
    // 重写了NSObject(父类)的构造方法
    override init() {
        name = ""
        age = 0
    }
}

// 创建一个Person对象
let p = Person()

② 初始化时给属性赋值
我们在创建一个对象时就会给属性赋值,可以自定义构造函数,如果自定义了构造函数,会覆盖init()方法,即不在有默认的构造函数

class Person: NSObject {
    var name : String
    var age : Int

    // 自定义构造函数,会覆盖init()函数
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
}

// 创建一个Person对象
let p = Person(name: "xiaoming", age: 18)

③ 字典转模型(初始化时传入字典)

例1
class Person: NSObject {
    var name : String
    var age : Int

    // 自定义构造函数,会覆盖init()函数
    init(dict : [String : NSObject]) {
        name = dict["name"] as! String
        age = dict["age"] as! Int
    }
}

// 创建一个Person对象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)
例2
利用KVC字典转模型
class Person: NSObject {
    // 结构体或者类的类型,必须是可选类型,因为不能保证一定会赋值
    var name : String?

    // 基本数据类型不能是可选类型,否则KVC无法转化
    var age : Int = 0

    // 自定义构造函数,会覆盖init()函数
    init(dict : [String : NSObject]) {
        // 必须先初始化对象
        super.init()

        // 调用对象的KVC方法字典转模型
        setValuesForKeysWithDictionary(dict)
    }
}

// 创建一个Person对象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

十三、闭包
Swift闭包和OC中的block非常相似,OC中的block是匿名的函数,Swift中的闭包是一个特殊的函数,block和闭包都经常用于回调
1、OC中Block的使用

首先介绍一下OC中Block写法
① 第一种Block方式

@property (nonatomic, copy) void(^callBack)(NSString *name);
callBack 是block对象
回调方法
if(_callBack){
_callBack(name)
}

② 第二种Block方式

typedef void(^CallBack)(NSString *str);
@property (nonatomic, copy) CallBack callback;
callback是block对象
回调方法
if(_callBack){
_callBack(name)
}

③ 第三种Block方式

- (void)setUpWith:(void(^)(NSString *str))callback;
callback是block对象
回调方法
if(_callBack){
_callBack(name)
}
总结
Block的写法:
    类型:
    返回值类型(^block的名称)(block的参数)

    值:
    ^(参数列表) {
        // 执行的代码
    };

2、Swift中闭包的使用
① 第一种闭包方式

var callBack : (()->())?

② 第二种闭包方式

func loadRequest(callBack : ()->()){
                callBack()
    }
总结
闭包的写法:
   callBack: (形参列表) -> (返回值类型)
    类型:(形参列表) -> (返回值类型)
    值:
    {
        (形参) -> 返回值类型 in
        // 执行代码
    }

闭包的简写,如果闭包没有参数,没有返回值,in和in之前的内容可以省略

尾随闭包写法
① 如果闭包是函数的最后一个参数,则可以将闭包写在()后面
    httpTool.loadRequest() {
        print("回到主线程", NSThread.currentThread());
    }
② 如果函数只有一个参数,并且这个参数是闭包,那么()可以不写
    // 开发中建议该写法
    httpTool.loadRequest {
        print("回到主线程", NSThread.currentThread());
    }

3、闭包的循环引用
如果在HttpTool中有对闭包进行强引用,则会形成循环引用,在Swift中检测一个对象是否销毁,可以实现对象的deinit函数

// 析构函数(相当于OC中dealloc方法)
    deinit {
        print("ViewController----deinit")
    }

4、swift中解决循环引用的方式
① 使用weak,对当前控制器使用弱引用
但是因为self可能有值也可能没有值,因此weakSelf是一个可选类型,在真正使用时可以对其强制解包(该处强制解包没有问题,因为控制器一定存在,否则无法调用所在函数)

解决一
weak var weakSelf = self
    httpTool.loadData {
        print("加载数据完成,更新界面:", NSThread.currentThread())
        weakSelf!.view.backgroundColor = UIColor.redColor()
    }

② 可以写在闭包中,并且在闭包中用到的self都是弱引用

解决二
 httpTool.loadData {[weak self] () -> () in
        print("加载数据完成,更新界面:", NSThread.currentThread())
        self!.view.backgroundColor = UIColor.redColor()
    }

③ 使用关键字unowned
unowned 更像OC中的 unsafe_unretained,unowned 表示即使它原来引用的对象被释放了,仍然会保持对被已经释放了的对象的一个 "无效的" 引用,它不能是 Optional 值,也不会被指向 nil

解决三
httpTool.loadData {[unowned self] () -> () in
        print("加载数据完成,更新界面:", NSThread.currentThread())
        self.view.backgroundColor = UIColor.redColor()
    }

十四、懒加载
swift中也有懒加载的方式,希望所有的对象在使用时才真正加载到内存中,和OC不同的是swift有专门的关键字来实现懒加载,lazy关键字可以用于定义某一个属性懒加载
1、懒加载普通方式

lazy var 变量:类型 = 系统类()
lazy var button:UIButton = UIButton()

2、懒加载升级方式

lazy var array : [String] = {
        () -> [String] in
        return ["xiaoming", "xl", "lisi"]
    }()

心得体会:
Swift好用,如果你读完本篇文章基本上掌握了Swift基础知识,剩下的就是实战了,实战会增加你编写Swift的能力,对Swift有更深的理解,后期也会补充新的Swift知识,也会分享自己的开源Swift项目共大家学习讨论,请关注下我的github账号lb2281075105,开始分享自己的项目和Demo,如果更好的意见请及时给我说哦,合理我会毫不犹豫采纳,谢谢,您的点赞会更加激励我的热情。

iOS、Swift、React Native
Web note ad 1