Swift基本语法学习笔记

Swift与OC的不同点

导入框架的方式

OC使用#import <UIKit/UIKit.h>

Swift使用import UIKit

定义标识符的方式

Swift中定义标识符,必须指定该标识符是一个常量还是一个变量

语句结束后的标志

Swift可以不用分号";"分割(只限于一行有一条语句时)

OC需要分号进行分割

打印语句

直接使用print()语句进行打印

OC中使用NSLog()语句进行打印

常量和变量的使用注意

优先使用常量

常量的本质:保存的时常量的内存地址,不可以修改,但可以通过内存地址拿到对象内部属性进行修改

Swift中的类型推导

在定义一个标识符,如果有直接赋值,那么会根据赋值的类型推导出前面标识符的类型,所以后面的类型可以省略

Swift中没有隐式转换,所以只有相同类型之间才可以进行运算

显式类型转换:Int(),Double()等

逻辑分支

if条件判断可以不要括号,没有非0即真的概念

OC中BOOL的值为YES/NO

Swift中的布尔Bool类型的值为true/false

guard的使用,适合多层if嵌套,使用guard代替,该语法是自Swift 2.0以后推出的.作用和if相同,但是可读性比if好.

switch的用法:

switch可以不跟()

case语句结束后,不跟break,系统会默认添加

如果希望一个case中出现case穿透,可以在case语句结束后跟上fallthrough

case后面可以跟多个条件,多个条件以","分割

switch可以判断浮点型

switch可以判断字符串

switch可以判断区间

swift中的区间表示:

a..<b 相当于数学上 [a, b)

a...b 相当于数学上 [a, b]

swift中没有全开区间的概念,即没有(a, b)的写法

swift中的for循环:

for后面的括号可以省略

swift3中已经移除了普通的for循环写法

forin写法:区间遍历

forin写法,如果不需要用到下标值,可以用下划线"_"省略

swift中的while循环

在OC中,使用do while循环

在swift中,使用repeat while循环

字符串

swift中的字符串为String类型,是个结构体.而OC中的NSString是对象,所以swift中的字符串类型比OC的效率高.

定义字符串,可以不用指定String类型

可以直接遍历字符串中的字符,使用for c in str.characters{}

字符串的拼接

直接使用str1+str2

拼接其他标识符的字符串:使用(str)

字符串的格式化:String(format:"%02d:%02d", arguments: [min, second])

字符串的截取:可以先转换为OC的NSString类型,再进行截取

(urlString as NSString).substring(to: 3)

(urlString as NSString).substring(with: NSRange(location: 4, length: 5))

(urlString as NSString).substring(from: 10)

数组

数组的定义:

可变数组(使用let声明):let array = ["a", "b"]

不可变数组(使用var声明):

var arrayM = Array()

var arrayM = [String]()

对可变数组的操作:

添加元素:arrayM.append("c")

删除元素:arrayM.remove(at: 0)

修改元素:arrayM[0] = "m"

获取元素:arrayM[0]

遍历数组:

for i in 0..<arrayM.count {}

for name in arrayM {}

for i in arrayM[0..<2] {}

数组的合并:

swift中,如果两个数组类型是完全一致的,才可以进行相加合并.

字典

字典的定义:

不可变字典(let)

注意:在swift中无论是数组还是字典,都使用[],但是如果[]中存放的是元素,编译器会认为是一个数组.如果[]中存放的是键值对,编译器会认为是一个字典.

let dict = ["key" : "value"]

可变字典(var)

var dictM = Dictionary<String, AnyObject>()

var dictM = [String : AnyObject]()

注意:一般在指定数据类型时,使用AnyObject,在声明变量类型时使用NSObject.

对可变字典的操作:

添加元素:dictM["newKey"] = "newValue"

修改元素:dictM["key"] = "newValue",如果存在key,则覆盖该key之前的value,如果不存在key,则直接添加.

删除元素:dictM.removeValue(forKey: "key")

获取元素:dictM["key"]

遍历字典:

遍历所有的key:for key in dictM.keys {}

遍历所有的value:for value in dictM.values {}

遍历所有的key/value: for (key, value) in dictM {}

合并字典:

注意:即使两个字典的类型一致,也不能进行相加合并

如果必须进行合并,可以遍历一个字典,将其逐个添加到另外一个字典中.

元组

元组一般用于函数的返回值,其与数组和字典功能类似,但是写法更为直观,所以swift中新增了元祖的类型.

元组的基本写法:let userInfo = ("name", 18, 1.8)

userInfo.0

给每一个元素起别名:let userInfo = (name: "name", age: 18, height: 1.8)

userInfo.name

别名就是元组变量的名称

let (name, age, height) = ("name", 18, 1.8)

直接使用name,age,height即可获取元组中元素的值

可选类型

可选类型的作用:当声明一个变量为String类型,而想要给它赋值为nil,需要使用可选类型.

定义方式:

方式一:基本定义方式,不常用,var name: Optional = nil

方式二:语法糖,常用,var name: String? = nil

给可选类型赋值:name = "abc"

在使用可选类型时,拿到optional(具体的值)

强制解包:

通过在变量后使用"!"来进行强制解包

注意:强制解包是非常危险的过程,在强制解包时,如果里面没有值,程序会发生崩溃.

严谨的解包方式:if name != nil {}

可选绑定:

如果name不等于nil,则解包name,并且将解包后的值赋值给新值

方式一(不常用):if let tempName = name {}

方式二(常用):if let name = name {}

以上操作其实可以分为两步:

首先判断name是否有值

如果有值,则进行强制解包(系统会默认处理),并且将解包后的值赋给前面的常量,并执行大括号里面的代码

如果没有值,则不进行强制解包,同时也不执行括号里面的代码

可选类型的应用场景

在使用一个字符串创建URL类型的常量时,需要使用可选类型

因为如果字符串中包含中文时,创建的URL对象可能为空

在使用的时候,需要对可选类型进行判断,此时可以使用可选绑定,在大括号内创建NSURLRequest对象

函数

在OC中叫做方法,在swift中叫做函数

没有参数,没有返回值

func about() -> Void {}

func about() {}

没有参数,有返回值

func readMessage() -> String {}

有参数,没有返回值

func callPhone(phoneNum : String) -> Void {}

func callPhone(phoneNum : String) {}

有参数,有返回值

func sum(num1: Int, num2: Int) -> Int {}

函数的注意点

注意一:内部参数和外部参数

内部参数:在函数内部可以看到的参数就是内部参数,默认情况下所有的参数都是内部参数

外部参数:在函数外部可以看到的参数名称就是外部参数,在swift3之前默认从第二个参数开始既是内部参数又是外部参数,但是从swift3开始,默认第一个内部参数也是外部参数.

注意二:swift中的默认参数

func makeCoffe(coffeName: String = "雀巢") -> String {}

在调用函数是,如果没有传递某个参数的值,swift会根据函数的声明,自动添加默认参数的值.

注意三:可变参数

func sum(num: Int...) -> Int {}

注意四:指针类型

swift函数参数,默认是值传递,在函数中直接交换两个参数的值,调用函数后,参数的值并不会发生改变.

func swapNum(m: inout Int, n: intout Int) {}

调用时:swapNum(m: &m, n: &n)

注意五:函数的嵌套使用(用的不多,了解即可)

在函数内部,可以声明新的函数,如果不调用,则不会执行函数内的代码.

只有在调用了函数,才会执行,哪里调用就在哪里执行.

Swift中类的注意事项

类的定义

可以不继承任何类:class Person {}

可以继承NSObject:class Person : NSObject {}

不继承父类,可以使自定义的类更加轻量级.如果需要使用到NSObject中的属性或方法,则需要继承,比如使用KVC对属性进行赋值

注意:任何一个类,都要保证它里面的属性,在类初始化的时候要有一个默认值.

创建类对应的对象

let p = Person()

let p: Person = Person()

给类的属性赋值

可以通过点语法直接赋值

也可以通过KVC,调用类对象的setValuesForKeys()方法

可以重写setValue...forUndefinedKey方法,那么字典中没有的字段可以在类中没有对应的属性,程序也不会报错.

如果要写的某一个方法是对父类方法的重写,那么必须在该方法前加上override关键字

定义Swift类中的属性

在swift中,声明的类属性都需要进行初始化,类属性分为三类:

存储属性:

var age: Int = 0

var mathScore: Double = 0.0

var chineseScore: Double = 0.0

计算属性:

通过别的方式计算到结果的属性,称之为计算属性

var averageScore: Double { return (mathScore + chineseScore) * 0.5 }

类属性:

类属性是和整个类相关的属性,而且是通过类名进行访问

在生成单例的时候,会用到类属性

static var courseCount: Int = 0

给类属性赋值:Student.courseCount = 2

创建对象:let stu = Student()

给对象的属性赋值:stu.age = 10

直接使用计算属性:let averageScore = stu.averageStudent

在swift开发中,如果使用当前对象的某一个属性,或者调用当前对象的某一个方法时,可以直接使用,不需要加self.但是在产生歧义的情况下,还是需要加上self的.

Swift中类的构造方法

swift中类的构造函数和OC中的初始化方法功能相同,只是写法不同.

在构造函数中,如果没有明确super.init(),那么系统会帮助调用super.init()

自定义构造函数:

参数非字典类型:init(name: String, age: Int) {}

参数为字典类型:

可以直接遍历字典,在遍历字典的时候,需要判断可选类型,然后转换可选类型,再使用可选绑定,对属性进行赋值

也可以直接使用KVC,但是在调用setValueForKeys()前,需要调用父类的初始化函数super.init(),虽然系统会默认调用该函数,但是在自定义构造函数尾部才去调用,所以需要首先调用super.init().

在使用KVC的时候,也需要重写setValue(forUndefinedKey)方法,以便处理类中没有定义key的属性.

属性监听器

class Person: NSObject {
    // 属性监听器
    var name : String? {
        // 属性即将改变时进行监听
        willSet {
            print(name)
            print(newValue)
        }
        
        // 属性已经改变时进行监听
        didSet {
            print(name)
            print(oldValue)
        }
    }
}

回顾OC中的block

使用block模拟网络请求中的回调

自定义一个网络请求的工具类HttpTool,提供loadData方法

- (void)loadData:(void (^)(NSString *))callBack
{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"发送网络请求:%@", [NSThread currentThread]);
        
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"拿到数据,并且进行回调:%@", [NSThread currentThread]);
            
            callBack(@"json数据");
        });
    });
}

在ViewController中通过点击屏幕,在ViewController中拿到block返回的数据

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    /*
     __weak修饰的弱引用,如果指向的对象销毁,那么指针会立马指向nil(0x0)
     __unsafe_unretained修饰的弱引用,如果指向的对象销毁,那么指针依然指向之前的内存地址,很容易产生'野指针'/'僵尸对象'
     */
    __weak ViewController *weakSelf = self;
    
    [self.tools loadData:^(NSString *jsonData) {
        // NSLog(@"在ViewController拿到数据:%@", jsonData);
        weakSelf.view.backgroundColor = [UIColor redColor];
    }];
}

闭包

闭包的写法:(参数列表) -> (返回值类型)

weakself?.view

如果前面的可选类型,没有值,后面所有的代码都不会执行

如果前面的可选类型,有值,系统会自动将weakself进行解包,并且使用weakself

闭包解决循环引用的三种方式:

方式一(写法比较复杂):使用weak var weakSelf = self

注意:必须使用var来声明,因为self可能会发生变化,如果使用let声明,编译器会报错.

方式二(比较危险,当self指向nil时,可能会发生崩溃):tools.loadData {[unowned self] (jsonData) -> () in ... }

方式三(常用写法):tools.loadData {[weak self] (jsonData) -> () in ... }

尾随闭包:如果闭包作为方法的最后一个参数,那么闭包可以将()省略掉

普通写法:tools.loadData ({[weak self] (jsonData) -> () in ... })

尾随闭包的写法一:tools.loadData() {[weak self] (jsonData) -> () in ... }
- 但是闭包中可以直接使用self,而不需要进行解包

尾随闭包的写法二(系统默认写法):tools.loadData {[weak self] (jsonData) -> () in ... }

注意:swift中的deinit()方法相当于OC中的dealloc方法,当对象销毁时,会调用该函数.

OC中使用__weak修饰self,当对象销毁时,self将指向nil(0x0)

OC中使用__unsafe__unretain修饰self,当对象销毁时,self仍指向原内存地址,会产生"野指针"错误或"僵尸对象",这个写法相当于swift中的unowned.

懒加载

懒加载的介绍

swift中也有懒加载的方式.

苹果的设计思想:希望所有的对象在使用时才真正加载到内存中

和OC不同的是,swift有专门的关键字来实现懒加载

lazy关键字可以用于定义某一个属性懒加载

懒加载的使用

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

// 懒加载的本质是,在第一次使用的时候,执行闭包
// 将闭包的返回值赋值给属性
// lazy的作用是只会赋值一次
lazy var array: [String] = {
	() -> [String] in
	return ["abc", "def", "ghi"]
}()

也可以写成下面这种方式

lazy var array: [String] = {
	return ["abc", "def", "ghi"]
}()