一、swift特性
- Swift 是一门开发 iOS, macOS, watchOS 和 tvOS 应用的新语言。
- Swift 使用变量来进行存储并通过变量名来关联对应的值。（与C语言类似）
- Swift 中，如果要处理的值不需要改变，那使用常量可以让代码更加安全并且更清晰地表达意图。（能用常量就用常量）
二、常量与变量
- 使用let表示常量、var表示变量。（如果代码中有不需要改变的值，请使用
let关键字将它声明为常量。只将需要改变的值声明为变量 var 关键字） - 类型标注
-
var str1: String //（声明一个String类型，名为str1的变量）。一般来说在有赋初值的情况下不需要标注类型，swift会根据所赋的值推断出类型。
- 如需定义同一类型的多个变量可采用 :
-
var zhao, qian, sun, li: String
- Swift中在进行基本运算时必须保证类型一致,否则会出错，相同类型之间才可以进行运算，Swift中没有隐式转换
三、字符串
var str = "Hello, playground"
//for c in str.characters {
// print(c)
//}
//字符串的拼接-格式化
let number_a = 132
let number_b = 100
let number_str = String (number_a + number_b)
let str1 = "this string is \(number_a) and \(number_b)"
let str2 = String.init(format: "%04d:%05d", number_a,number_b)
//字符串截取-转位NSString来操作
let str3 = (str as NSString).substring(to: 2)
let str4 = (str as NSString).substring(from: 4)
let range = NSRange.init(location: 2, length: 3)
let str5 = (str as NSString).substring(with: range)
//字符串长度的判断
str.lengthOfBytes(using: .utf8)
let str6:String = "jhhgftytyiuh09887gybgjgv"
str6.lengthOfBytes(using: .utf8)
//let strLength = lengthOfString(str7:str6)
//
//func lengthOfString(str7:String) -> (Int) {
// guard str7.lengthOfBytes(using: .utf8) == 0 else {
// return str7.lengthOfBytes(using: .utf8)
// }
// return 0
//}
//for c in str.characters {
// print(c)
//}
//字符串的拼接-格式化
let number_a = 132
let number_b = 100
let number_str = String (number_a + number_b)
let str1 = "this string is \(number_a) and \(number_b)"
let str2 = String.init(format: "%04d:%05d", number_a,number_b)
//字符串截取-转位NSString来操作
let str3 = (str as NSString).substring(to: 2)
let str4 = (str as NSString).substring(from: 4)
let range = NSRange.init(location: 2, length: 3)
let str5 = (str as NSString).substring(with: range)
//字符串长度的判断
str.lengthOfBytes(using: .utf8)
let str6:String = "jhhgftytyiuh09887gybgjgv"
str6.lengthOfBytes(using: .utf8)
//let strLength = lengthOfString(str7:str6)
//
//func lengthOfString(str7:String) -> (Int) {
// guard str7.lengthOfBytes(using: .utf8) == 0 else {
// return str7.lengthOfBytes(using: .utf8)
// }
// return 0
//}
四、数组
//数组 Array let修饰不可变数组、var修饰可变数组
//定义一个可变数组
var array1:Array<String>
var array2:[String]
//定义一个不可变数组
let array3 = [1, 2, 3, 4, 8]//直接初始化的话通过值去推断array3的类型
let array4 = [1, 2, 3, 4, "i"] as [Any]
let array5:[NSObject] = [1 as NSObject, 2 as NSObject, "x" as NSObject, 3.14 as NSObject]
//声明数组时、需要初始化才能使用。
//先声明在初始化
var array6:Array<String>
array6 = ["1", "2", "3"]
array6 = Array()
//声明的同时并初始化
var array7:[String] = [String]()
var array8:Array<String> = Array()
var array9 = [1, 2, 3, 4, 5]
//Array增
array9.append(6)//增到最后位
//Array插
array9.insert(4000, at: 1)
//Array改
array9[1] = 10086
//Array删
array9.remove(at: 2)//删除第3个元素3
array9.removeAll()//清空
//取值
array9[4]
//遍历全部
for item in array9 {
print(item)
}
//遍历部分
for item in array9[0...3] {
print(item)
}
for item in array9[0..<3] {
print(item)
}
//数组的合并 用+ 确保类型一致才可以
let array10 = ["1", "2", "3"]
let array11 = ["A", "B", "C"]
let array12 = array10 + array11
//定义一个可变数组
var array1:Array<String>
var array2:[String]
//定义一个不可变数组
let array3 = [1, 2, 3, 4, 8]//直接初始化的话通过值去推断array3的类型
let array4 = [1, 2, 3, 4, "i"] as [Any]
let array5:[NSObject] = [1 as NSObject, 2 as NSObject, "x" as NSObject, 3.14 as NSObject]
//声明数组时、需要初始化才能使用。
//先声明在初始化
var array6:Array<String>
array6 = ["1", "2", "3"]
array6 = Array()
//声明的同时并初始化
var array7:[String] = [String]()
var array8:Array<String> = Array()
var array9 = [1, 2, 3, 4, 5]
//Array增
array9.append(6)//增到最后位
//Array插
array9.insert(4000, at: 1)
//Array改
array9[1] = 10086
//Array删
array9.remove(at: 2)//删除第3个元素3
array9.removeAll()//清空
//取值
array9[4]
//遍历全部
for item in array9 {
print(item)
}
//遍历部分
for item in array9[0...3] {
print(item)
}
for item in array9[0..<3] {
print(item)
}
//数组的合并 用+ 确保类型一致才可以
let array10 = ["1", "2", "3"]
let array11 = ["A", "B", "C"]
let array12 = array10 + array11
四、字典
//let修饰不可变字典 var修饰可变字典
//定义一个不可变字典、直接定义
let dict1 = ["a":"A", "b":"B", "c":"C"]
//取值
dict1["a"]
//定义一个可变字典并初始化
var dict2:[String: NSObject] = [String: NSObject]()
var dict3:Dictionary<String, Int> = Dictionary()
var dict4 = ["a":"A", "b":"B", "c":"C"]
//先定义后初始化
var dict5:Dictionary<String, String>
dict5 = ["a":"A", "b":"B", "c":"C"]
//增
dict5["e"] = "E"
dict5["爱"] = "❤️"
//dict5 = ["b": "B", "e": "E", "a": "A", "c": "C", "爱": "❤️"]
//改
dict5["爱"] = "🐷"
//dict5 = ["b": "B", "e": "E", "a": "A", "c": "C", "爱": "🐷"]
//删
dict5.removeValue(forKey: "爱")
//dict5 = ["b": "B", "e": "E", "a": "A", "c": "C"]
//查 - 用键查值
dict5["e"]
//清空
dict5.removeAll()
var dict6:Dictionary<String, String>
dict6 = ["1":"a","2":"b","3":"c","4":"d","5":"e","6":"f"]
//遍历字典的键
for key in dict6.keys {
print(key)
}
//遍历值
for value in dict6.values {
print(value)
}
//遍历所有的键值对
for (k, v) in dict6 {
print(k, v)
}
//两字典的合并
var dict7 = ["一":"甲", "二":"已","三":"丙"]
var dict8 = ["1":"A","2":"B","3":"C"]
//不能和数组那样直接+ 需要遍历一个字典将键值加到另外一个字典上
for (key, value) in dict7 {
dict8[key] = value
}
//dict8 = ["三": "丙", "2": "B", "1": "A", "二": "已", "一": "甲", "3": “C"]
//定义一个不可变字典、直接定义
let dict1 = ["a":"A", "b":"B", "c":"C"]
//取值
dict1["a"]
//定义一个可变字典并初始化
var dict2:[String: NSObject] = [String: NSObject]()
var dict3:Dictionary<String, Int> = Dictionary()
var dict4 = ["a":"A", "b":"B", "c":"C"]
//先定义后初始化
var dict5:Dictionary<String, String>
dict5 = ["a":"A", "b":"B", "c":"C"]
//增
dict5["e"] = "E"
dict5["爱"] = "❤️"
//dict5 = ["b": "B", "e": "E", "a": "A", "c": "C", "爱": "❤️"]
//改
dict5["爱"] = "🐷"
//dict5 = ["b": "B", "e": "E", "a": "A", "c": "C", "爱": "🐷"]
//删
dict5.removeValue(forKey: "爱")
//dict5 = ["b": "B", "e": "E", "a": "A", "c": "C"]
//查 - 用键查值
dict5["e"]
//清空
dict5.removeAll()
var dict6:Dictionary<String, String>
dict6 = ["1":"a","2":"b","3":"c","4":"d","5":"e","6":"f"]
//遍历字典的键
for key in dict6.keys {
print(key)
}
//遍历值
for value in dict6.values {
print(value)
}
//遍历所有的键值对
for (k, v) in dict6 {
print(k, v)
}
//两字典的合并
var dict7 = ["一":"甲", "二":"已","三":"丙"]
var dict8 = ["1":"A","2":"B","3":"C"]
//不能和数组那样直接+ 需要遍历一个字典将键值加到另外一个字典上
for (key, value) in dict7 {
dict8[key] = value
}
//dict8 = ["三": "丙", "2": "B", "1": "A", "二": "已", "一": "甲", "3": “C"]
五、元组（Swift特有的）
//写法一：
let tump1 = ("liuhuakun", 27, "GD", 173.5)
tump1.0 //"liuhuakun"
tump1.3 //173.5
//写法二：
let tump2 = (name:"liuhuakun", age:28, address:"GD", height:173.5)
tump2.name //"liuhuakun"
tump2.height //173.5
//写法三
let (name, age) = ("liuhuakun", 28)
name //173.5
age //28
let tump1 = ("liuhuakun", 27, "GD", 173.5)
tump1.0 //"liuhuakun"
tump1.3 //173.5
//写法二：
let tump2 = (name:"liuhuakun", age:28, address:"GD", height:173.5)
tump2.name //"liuhuakun"
tump2.height //173.5
//写法三
let (name, age) = ("liuhuakun", 28)
name //173.5
age //28
七、可选类型 Optional
//可选类型 - Optional值
//OC中如果有暂时不使用的变量、可以赋值为0（基础数据类型）或赋值为nil（对象类型）
//Swift中nil是一个特殊类型，与真实的变量类型不一致不能被复制（Swift为强类型语言）。但开发中确实需要用到赋值为nil，这就引入了可选类型Optional（空值或有值）
//var str1:String = nil//报错-类型不匹配不能被赋值
//写法1
var str1:Optional<String> = nil
//写法2
var str2:String? = nil //语法糖
//解包 - 当确保当前可选值有值时可解包
var str3:String? = nil
str3 = "hello"
//print(str3) //Optional("hello")
//print(str3!) //hello
//若str3为空时解包则报错
str3 = nil
//print(str3) //nil
//print(str3!)//报错
//1.强制解包、2.隐式解包、3.可选绑定
//1.强制解包
var a:Int? = nil
a = 7
let aa = a! //这里对a进行强制解包 - 强制解包后 aa为7 不强制解包的话 aa为Optional(7)
print(aa)
//2.隐式解包 - 还是不太理解
var b:Int! = nil //这里声明对b要进行隐式解包
b = 8
let bb = b
print(bb as Any)
//可选绑定 - 在 if里面可以方便操作 当前可选值
var str4:String? = nil
str4 = "hello"
if let string = str4 {
print(string)
}else {
print("nil")
}
//OC中如果有暂时不使用的变量、可以赋值为0（基础数据类型）或赋值为nil（对象类型）
//Swift中nil是一个特殊类型，与真实的变量类型不一致不能被复制（Swift为强类型语言）。但开发中确实需要用到赋值为nil，这就引入了可选类型Optional（空值或有值）
//var str1:String = nil//报错-类型不匹配不能被赋值
//写法1
var str1:Optional<String> = nil
//写法2
var str2:String? = nil //语法糖
//解包 - 当确保当前可选值有值时可解包
var str3:String? = nil
str3 = "hello"
//print(str3) //Optional("hello")
//print(str3!) //hello
//若str3为空时解包则报错
str3 = nil
//print(str3) //nil
//print(str3!)//报错
//1.强制解包、2.隐式解包、3.可选绑定
//1.强制解包
var a:Int? = nil
a = 7
let aa = a! //这里对a进行强制解包 - 强制解包后 aa为7 不强制解包的话 aa为Optional(7)
print(aa)
//2.隐式解包 - 还是不太理解
var b:Int! = nil //这里声明对b要进行隐式解包
b = 8
let bb = b
print(bb as Any)
//可选绑定 - 在 if里面可以方便操作 当前可选值
var str4:String? = nil
str4 = "hello"
if let string = str4 {
print(string)
}else {
print("nil")
}
八、函数
//默认下函数是值传递 - 值传递 函数内部是不能去改变参数的值的。
func myFunc1(a:Int, b:Int) -> Int {
return a+b
}
var a = 3
var b = 7
myFunc1(a: a, b: b)
//函数的指针传递 inout - 指针传递 函数内部是可以改变参数值的
func myFunc2( a:inout Int, b:inout Int) -> Int {
a = a*b //a = 63
b = b*b //b = 81
return a*b //a*b = 5103
}
var x = 7
var y = 9
myFunc2(a: &x, b: &y)
x //x=63,此时x的值在函数内部被改变 x在外部也被改变了，因为传入的是x的指针地址
y //y=81,此时y的值在函数内部被改变 y在外部也被改变了，因为传入的是x的指针地址
func myFunc1(a:Int, b:Int) -> Int {
return a+b
}
var a = 3
var b = 7
myFunc1(a: a, b: b)
//函数的指针传递 inout - 指针传递 函数内部是可以改变参数值的
func myFunc2( a:inout Int, b:inout Int) -> Int {
a = a*b //a = 63
b = b*b //b = 81
return a*b //a*b = 5103
}
var x = 7
var y = 9
myFunc2(a: &x, b: &y)
x //x=63,此时x的值在函数内部被改变 x在外部也被改变了，因为传入的是x的指针地址
y //y=81,此时y的值在函数内部被改变 y在外部也被改变了，因为传入的是x的指针地址
九、类
//类的使用
/// class为类关键字、myClass类名、:父类（可以没有父类）
class myClass:NSObject {
/// swift中类的属性有多种
//1、存储属性：存储实例的常量和变量
//2、计算属性：通过某种计算方式得出的属性
//3、类属性：与整个类相关的属性
//1、存储属性
var a:Int = 88
var b:Int = 99
var name = "xiaohong"
//2、计算属性
var totalInt:Int {
get {
return (a + b)/2
}
// 没有意义,因为之后获取值时依然是计算得到的
// newValue是系统分配的变量名，内部存储着新值
set {
self.totalInt = newValue
}
}
//3、类属性
//类属性是与类相关联的，而不是与类的实例相关联，类属性的设置和修改,需要通过类来完成，类属性使用static来修饰
static var appleCount:Int = 100
func myCount(num1:Int, num2:Int ) -> Int {
return num1 + num2
}
}
//1、外部实例类的对象
let my = myClass()
//2、外部调用存储属性和计算属性
//my.a = 5 //外部可赋值改变存储属性a的值
//my.b = 7 //外部可赋值改变存储属性b的值
print(my.name) //xiaohong
my.myCount(num1: my.a, num2: my.b) //187
my.totalInt //93
//3、外部调用类属性
//my.appleCount //用类的实例去调用类属性是不可以调用的
myClass.appleCount //只能通过类本身去调用带 static的类属性
myClass.appleCount = 99
print(myClass.appleCount) //99
/// class为类关键字、myClass类名、:父类（可以没有父类）
class myClass:NSObject {
/// swift中类的属性有多种
//1、存储属性：存储实例的常量和变量
//2、计算属性：通过某种计算方式得出的属性
//3、类属性：与整个类相关的属性
//1、存储属性
var a:Int = 88
var b:Int = 99
var name = "xiaohong"
//2、计算属性
var totalInt:Int {
get {
return (a + b)/2
}
// 没有意义,因为之后获取值时依然是计算得到的
// newValue是系统分配的变量名，内部存储着新值
set {
self.totalInt = newValue
}
}
//3、类属性
//类属性是与类相关联的，而不是与类的实例相关联，类属性的设置和修改,需要通过类来完成，类属性使用static来修饰
static var appleCount:Int = 100
func myCount(num1:Int, num2:Int ) -> Int {
return num1 + num2
}
}
//1、外部实例类的对象
let my = myClass()
//2、外部调用存储属性和计算属性
//my.a = 5 //外部可赋值改变存储属性a的值
//my.b = 7 //外部可赋值改变存储属性b的值
print(my.name) //xiaohong
my.myCount(num1: my.a, num2: my.b) //187
my.totalInt //93
//3、外部调用类属性
//my.appleCount //用类的实例去调用类属性是不可以调用的
myClass.appleCount //只能通过类本身去调用带 static的类属性
myClass.appleCount = 99
print(myClass.appleCount) //99
///监听属性的变化
/*
1、在OC中我们可以重写set方法来监听属性的改变。
2、在Swift中可以通过属性观察者来监听和响应属性值的变化，通常是监听存储属性和类属性的改变。
(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
3、willSet：在属性值被存储之前设置，此时新属性值作为一个常量参数被传入，该参数名默认为newValue，
我们可以自己定义该参数名；
didSet：在新属性值被存储后立即调用，与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue；
4、willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法*/
class Student :NSObject {
var name: String? {
willSet(new) {//属性即将改变、还未改变时调用
print("name=\(String(describing: name))")
print("new=\(String(describing: new))")
}
didSet(old) {//属性已经改变时调用
print("name=\(String(describing: name))")
print("old=\(String(describing: old))")
}
}
}
let stu = Student()
stu.name = "x"
stu.name = "huakun"
stu.name = "hakan"
/*
/*
1、在OC中我们可以重写set方法来监听属性的改变。
2、在Swift中可以通过属性观察者来监听和响应属性值的变化，通常是监听存储属性和类属性的改变。
(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
3、willSet：在属性值被存储之前设置，此时新属性值作为一个常量参数被传入，该参数名默认为newValue，
我们可以自己定义该参数名；
didSet：在新属性值被存储后立即调用，与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue；
4、willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法*/
class Student :NSObject {
var name: String? {
willSet(new) {//属性即将改变、还未改变时调用
print("name=\(String(describing: name))")
print("new=\(String(describing: new))")
}
didSet(old) {//属性已经改变时调用
print("name=\(String(describing: name))")
print("old=\(String(describing: old))")
}
}
}
let stu = Student()
stu.name = "x"
stu.name = "huakun"
stu.name = "hakan"
/*
打印出来的信息：
-----------------------------------
name=nil
new=Optional("x")
name=Optional("x")
old=nil
name=nil
new=Optional("x")
name=Optional("x")
old=nil
-----------------------------------
name=Optional("x")
new=Optional("huakun")
name=Optional("huakun")
old=Optional("x”)
name=Optional("x")
new=Optional("huakun")
name=Optional("huakun")
old=Optional("x”)
-----------------------------------
name=Optional("huakun")
new=Optional("hakan")
name=Optional("hakan")
old=Optional("huakun”)
name=Optional("huakun")
new=Optional("hakan")
name=Optional("hakan")
old=Optional("huakun”)
-----------------------------------
*/
*/
来源：https://www.cnblogs.com/liuhuakun/p/8276945.html