1.常量和变量
常量用let修饰，定义之后值不以修改，变量用var修饰，定义之后值可以修改。
let x = 5
let y = 10.5
var z = 15
z = 20
// 1.自动推导 常量／变量的类型会根据右侧代码的执行结果，推导对应的类型
print(x,y,z)
// 2.不同类型之间不能直接进行计算，需要作转换
// let a = 10
// let b = 0.5
// print(a + Int(b))
let a :Double = 10
let b = 0.5
print(a + b)
2.可选项
使用Optional或者?,表示该常量／变量可能有值，也可能没有值。
// 1.定义可选项用 `Optional` 或者 `?`
let x:Optional = 10
let y:Int? = 20
print(x)
print(y)
// 2.可选项参与计算的时候需要解包，使用 `!` 解包，从可选值中取出对应的非空值
print(x! + y!)
3.逻辑分支
let a = 5
let b = 10
// 1.条件语句可以省略(),但是必须加上{}
if a > b {
print("a > b")
}else{
print("a < b")
}
// 2.三目的写法与OC基本一致
a > b ?print("a > b"):print("a < b")
// 3. ?? 是一个简单的三目，如果有值，就使用值，如果没值，就使用 ?? 后面的值
let c :Int? = nil
print(Int(b) + (c ?? 0)) // 10
if let / var
if let 连用，用来判断对象的值是否为nil，{}中一定有值，不需要解包。
if var 连用，{}中可以对值进行修改。
// 1.if let
let oname:String? = "xiaoshayu"
let oage:Int? = 18
// 如果{}中没有使用，可以用_代替
if let _ = oname,
let _ = oage{
print(oname! + oage!.description)
}
// 2.if var
if var name = oname,
var age = oage{
name = "jack"
age = 20
print(name + age.description)
}
guard let
// 1.guard let 保证变量／常量一定有值，没有值则返回。
let oname:String? = "xiaoshayu"
let oage:Int? = nil//18
guard let name = oname,
let age = oage else{
print("oname or oage is nil")
return
}
// 2.程序运行到此，name和age一定有值
print(name + age.description)
switch
// switch
// 1.可以针对任意类型的值进行分支，不再局限于整型（OC为整型）。
// 2.不需要添加break,如果需要多值，用`,`隔开。
// 3.每一个分支至少需要一条指令
// 4.在分支中定义变量／常量时不需要加{}
let num = "June"//"January"
switch num {
case "January":
let a = 31
print("一月" + a.description + "天")
case "February":
print("二月")
case "March":
print("三月")
case "April","May","June":
print("第二季度")
default:
print("none")
}
4.for循环
// 0..<5,表示从0开始到5之间（不包含5）的数[0,5)
// 0...5,表示从0开始到5之间（包含5）的数[0,5]
for i in 0..<5 {
print(i) // 0 1 2 3 4
}
print("-----")
for i in 0...5{
print(i) // 0 1 2 3 4 5
}
5.字符串
let str = "床前明月光"
// 1.字节数
// 每个汉字事3个字节
print(str.lengthOfBytes(using: .utf8))// 15
// 2.字符串的长度
print(str.characters.count)// 5
// 3. String转化NSString，通过.length获取长度
let ocString = str as NSString
print(ocString.length)
// 4.字符串的遍历
for c in str.characters{
print(c)
}
// 5. 字符串的拼接 \(常量／变量)
let a = "疑是"
let b = "地上霜"
let c = "\(a)\(b)\(20)"
print(c)
// 6. 字符串的格式化
let date = String(format:"%@年%@月%@日 %@:%@:%@",
arguments:["2019","02","23","18","33","56"])
print(date)
print("字符串的截取---")
// 7.字符串的截取
let str2:String = "举头望明月，低头思故乡。"
let subStr1 = str2.prefix(3) // 举头望
let subStr2 = str2.suffix(4) // 低头思故乡
let index1 = str2.index(str2.startIndex, offsetBy: 2)
let index2 = str2.index(str2.startIndex, offsetBy: 8)
let subStr3 = str2[index1...index2]
print(subStr1) // 举头望
print(subStr2) // 低头思
print(subStr3) // 望明月，低头思
6.数组
// 1.数组的定义 和 初始化 OC @[] Swift []
// OC 可变数组 NSMutableArray 不可变 NSArray
// Swift 可变数组 var 不可变 let
var array1 = ["Jan","Feb","Mar","Apr","May","Jun"]
print(array1)
// 初始化 [类型]()
var array2 = [String]()
array2.append("a")
print(array2)
// 2.基本数据类型不需要包装 OC @[@(1),@(2)]
let array3 = [1,2,3,4,5]
print(array3)
// 3.数组的遍历
// a>按照下标遍历
for i in 0..<array1.count{
print(array1[i])
}
print("for in 遍历")
// b>for in 遍历
for i in array1 {
print(i)
}
print("enum 遍历")
// c>enum 遍历 同时遍历下标和内容
for e in array1.enumerated() {
print("\(e.offset) \(e.element)")
}
print("enum 遍历2")
// d>enum 遍历 同时遍历下标和内容
for (index,value) in array1.enumerated() {
print("\(index) \(value)")
}
print("反序遍历")
// e>反序遍历
for e in array1.reversed(){
print(e)
}
// 4.数组添加元素 .append
array2.append("b")
array2.append("c")
print(array2) // ["a", "b", "c"]
// 5.数组修改元素
array2[1] = "d"
print(array2) // ["a", "d", "c"]
// 6.数组删除元素 .remove
array2.remove(at: 2)
print(array2) // ["a", "d"]
// 7.数组的合并 保证两个数组类型一致
array1 += array2
// ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "a", "d"]
print(array1)
7.字典
// 1.初始化一个空字典
var dict1 = [String:AnyObject]()
// 2.字典的定义 OC @{} Swift中同样使用 []
let dict2 = ["name":"小鲨鱼","age":18] as [String : Any]
print(dict2) // ["name": "小鲨鱼", "age": 18]
// 3.字典的添加元素 (有则更新键值对，没有则添加)
var dict3 = ["许嵩":"清明雨上","周杰伦":"告白气球","邓紫棋":"光年之外"] as [String:Any]
dict3["张靓颖"] = "我的梦"
print(dict3)
// ["张靓颖": "我的梦", "许嵩": "清明雨上", "周杰伦": "告白气球", "邓紫棋": "光年之外"]
dict3["许嵩"] = "有何不可"
print(dict3)
// ["张靓颖": "我的梦", "许嵩": "有何不可", "周杰伦": "告白气球", "邓紫棋": "光年之外"]
// 4.字典元素的修改
dict3.updateValue("倒数", forKey: "邓紫棋")
// ["张靓颖": "我的梦", "许嵩": "有何不可", "周杰伦": "告白气球", "邓紫棋": "倒数"]
print(dict3)
// 5.字典元素的删除
// a>通过dict3[key] = nil 的方式删除
dict3["邓紫棋"] = nil
print(dict3)
// ["张靓颖": "我的梦", "许嵩": "有何不可", "周杰伦": "告白气球"]
// b>通过.removeValue的方式删除
dict3.removeValue(forKey: "张靓颖")
print(dict3)
// ["许嵩": "有何不可", "周杰伦": "告白气球"]
print("字典的遍历 --- ")
// 6.字典的遍历
// a>
for e in dict3{
print(e)
}
//(key: "许嵩", value: "有何不可")
//(key: "周杰伦", value: "告白气球")
// b>
for (key,value) in dict3{
print("\(key) \(value)")
}
// 许嵩 有何不可
// 周杰伦 告白气球
print("字典的合并 ---")
// 7.字典的合并
let dict4 = ["田馥甄":"小幸运"] as [String:Any]
// 将dict4合并到dict3中
for (key,value) in dict4{
dict3[key] = value
}
print(dict3)
// ["许嵩": "有何不可", "周杰伦": "告白气球", "田馥甄": "小幸运"]
8.函数
// 1.函数的定义格式: 函数名（形参列表）-> 返回值类型
func sum1(x:Int, y:Int) -> Int{
return x + y
}
// 2.外部参数：就是在形参前面加一个名字
// 外部参数不会影响函数内部的细节，看起来更加直观
// 外部参数如果使用 _ ,在外部调用函数时会省略形参的名字
func sum2(num1 x:Int, num2 y:Int) -> Int{
return x + y
}
func sum3(_ x:Int, _ y:Int) -> Int{
return x + y
}
// 3.函数的默认值
// 通过给参数设置默认值，在调用的时候，如果不设定值的，使用默认值。
func sum4(x:Int = 11, y:Int = 22) -> Int{
return x + y
}
// 4.函数无返回值的三种写法
// a. func demo(){}
// b. func demo() -> (){}
// c. func demo() -> void{}
9.闭包
闭包类似于OC的block，但是比OC的block应用更广，在Swift中函数时特殊的闭包。
闭包的使用场景：
- 异步执行回调
- 控制器件回调
- 自定义视图回调
// 闭包 格式：{(形参列表) -> 返回值类型 in 实现代码}
// 1.有参数有返回值的闭包
let a = { (x: Int ,y: Int) -> Int in
return x + y
}
print(a(5,5)) // 10
// 2.有参数无返回值的闭包
let b = {(x:Int?) -> () in
print((x ?? 0))
}
b(100)
// 3.无参数无返回值的闭包
let c = {() -> () in
print("无参数无返回值的闭包")
}
c()
// 其中 ()->() in 可以省略 简写成 let c = { print("...")}
