Swift3.0 - 真的很简单
Swift3.0 - 数据类型
Swift3.0 - Array
Swift3.0 - 字典
Swift3.0 - 可选值
Swift3.0 - 集合
Swift3.0 - 流控制
Swift3.0 - 对象和类
Swift3.0 - 属性
Swift3.0 - 函数和闭包
Swift3.0 - 初始化和释放
Swift3.0 - 协议protocol
Swift3.0 - 类和结构体的区别
Swift3.0 - 枚举
Swift3.0 - 扩展
Swift3.0 - 下标
Swift3.0 - 泛型
Swift3.0 - 异常错误
Swift3.0 - 断言
Swift3.0 - 自动引用计数(strong,weak,unowned)
Swift3.0 - 检测API
Swift3.0 - 对象的标识
Swift3.0 - 注释
Swift3.0 - 元类型
Swift3.0 - 空间命名
Swift3.0 - 对象判等
Swift3.0 - 探究Self的用途
Swift3.0 - 类簇
Swift3.0 - 动态调用对象(实例)方法
Swift3.0 - 文本输出
Swift3.0 - 黑魔法swizzle
Swift3.0 - 镜像
Swift3.0 - 遇到的坑
- 常量定义
let myConstant = 42
let myConstant:Int = 42 // 指定类型定义
let name = "酷走天涯" // 类型推断定义
var red, green, blue: Double //单行定义多个变量
let cat = "🐱"; print(cat) // 如果有；单行可以写多个语句
let binaryInteger = 0b10001 //2进制数字的定义
let octalInteger = 0o21 // 八进制数字的定义
let hexadecimalInteger = 0x11 //16进制数字的定义
let exponentDouble = 1.21875e1 // 科学技术法定义
let hexadecimalDouble = 0xC.3p0 // 16进制科学技术法定义
let oneMillion = 1_000_000 // 可以使用_线将数字分开,便于认知
- 变量定义
var myVariable = 42
- 类型转换
let str = "\(num1)"
let str1 = String(num1)
let num2 = Int(num1)
let num3 = Int(str1)
let num4 = Double(str1)
- 数组的几种定义方式
let list1 = ["你好","2","3","4"]
let list2:[String] = ["你好","2","3","4"]
let list3:[Any] = ["你好","2","3",3,UILabel()]
let list4:NSArray = ["你好","2","3","4",UILabel()]
let list5:NSMutableArray = ["1","2","3","4"]
// 清空数组
list2.removeAll() // 如果定义为var
list2 = [] // 如果定义为var
list5.removeAllObjects() // var 和let 都可以
list5 = [] // 如果定义为var
// 取代操作
shoppingList[4...6] = ["Bananas", "Apples"] // 将数组4...6 的范围用指定的数组取代
// 插入操作
shoppingList.insert("Maple Syrup", at: 0)
- 字典
let dic1:[String:Int] = [:]
let dic2 = [String:Int]()
let dic3 :NSDictionary = NSDictionary()
let dic4:NSMutableDictionary = [:]
- 获取数据类型的最大和最小值
let minValue = UInt8.min
let maxValue = UInt8.max
- 给数据类型设置别名
typealias Code = Int32 // 给Int32 设置个别名
var tel:Code = 376823
-
元组类型
a.定义
// 第一种定义方法
let http404Error = (404, "Not Found") // 定义元组类型的常量
let code = http404Error.0
let error = http404Error.1
// 第二种定义方法
let http404Error = (code:404, error:"Not Found") // 定义元组类型的常量
let code = http404Error.code
let error = http404Error.error
也可以像上面一个获取对应的数据
// 第三种定义方法
let http404Error:(code:Int,error:String) = (404, "Not Found") // 定义元组类型的常量
let code = http404Error.code
let error = http404Error.1
// 第四种定义方法
let http404Error:(code:Int,error:String) = (code:404, error:"Not Found") // 定义元组类型的常量
let code = http404Error.code
let error = http404Error.error
// 第五种定义方式
var http404Error:(code:Int,error:String) = (_:404, _:"Not Found")
提示:
第四种定义的时候,等号坐标和右边的元素名称必须对应,不然系统会报错,建议不使用这种方式定义
2.分解变量
let (statusCode, _) = http404Error// 缺省不需要的值
let (statusCode, statusMessage) = http404Error
3.赋值
var http404Error:(code:Int,error:String)
http404Error = (code:404,error:"Not Found")// 完整
http404Error = (404,error:"Not Found") // 部分名称缺省
http404Error = (404,"Not Found")// 全部名称缺省
http404Error = (_:404,"Not Found") // 可以使用_代替名称
http404Error = (code1:404,"Not Found") // 不允许这样必须,名称必需和定义时保持一致
- 字符串和字符
let string = "hello, " + "world" // Swift中 终于可以这么方便处理字符串的拼接了
name.append("你好") // 也可以这样拼接 name必须为var
var anotherEmptyString = String()// 定义空字符串
// 判断字符串是否为空
if emptyString.isEmpty {
print("Nothing to see here")
}
// 获取字符串中每个字符
for character in "Dog!🐶".characters {
print(character)
}
for index in greeting.characters.indices {
print("\(greeting[index]) ", terminator: "")
}
// 定义字符
let exclamationMark: Character = "!"
// 定义字符数组
let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
// 字符数组转字符串
let catString = String(catCharacters)
// Unicode编码
let precomposed: Character = "\u{D55C}" // 한
let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}" //🇺🇸
var name = "🐶a我"
print(name.characters.count) // 3 一个不管是什么都算一个字符
// 截取字符串
let greeting = "Guten Tag!"
// 截取单个
greeting[greeting.startIndex]
// 截取一段
greeting[greeting.index(greeting.startIndex, offsetBy: 2)..<greeting.index(greeting.endIndex, offsetBy: -3)]
// 在指定位置插入字符串
welcome.insert("!", at: welcome.endIndex)
welcome.insert(contentsOf:" there".characters, at: welcome.index(before: welcome.endIndex))
// 移除字符串
welcome.remove(at: welcome.index(before: welcome.endIndex))
let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// 前缀和后缀
if scene.hasSuffix("Capulet's mansion"){
} // hasPrefix(_:)
// 获取对应的编码数据
for codeUnit in dogString.utf16 {
print("\(codeUnit) ", terminator: "")
}
深入
- 扩展
extension Int{
func description()-> String{
return "我是一个Int类型的数字\(self)"
}
}
print(3.description())
运行:
我是一个Int类型的数字3
- 协议扩展的好处1
// 定义个协议
protocol NumberProtocol{
func description()-> String
}
// 扩展实现协议
extension Int:NumberProtocol{
func description()-> String{
return "我是一个Int类型的数字\(self)"
}
}
extension Double:NumberProtocol{
func description()-> String{
return "我是一个Double类型的数字\(self)"
}
}
// 定义一个协议类型
var a:NumberProtocol = 3
print(a.description())
a = 3.4
print(a.description())
运行:
我是一个Int类型的数字3
我是一个Double类型的数字3.4
通过这种方法,我们可以给同一个变量,赋值不同类型的值了,其实这个符合swift的语法要求,只是我们利用它的灵活性,达到了我们的目的
- 协议好处2
需求
给Int 类型和 Double类型增加一个方法,判断它的数据类型
// 定义个协议
protocol NumberProtocol{
}
// 扩展实现协议
extension Int:NumberProtocol{
}
extension Double:NumberProtocol{
}
// 给协议扩展方法
extension NumberProtocol{
func description()-> String{
if self is Int{
return "我是一个Int类型的数字\(self)"
}
if self is Double{
return "我是一个Double类型的数字\(self)"
}
return "我既不是Int也不是Double类型的数字\(self)"
}
}
print(3.44.description())
print(3.description())
运行:
我是一个Double类型的数字3.44
我是一个Int类型的数字3
- Self 的好处
专门用于不确定数据类型的
需求:给所有数字类型,扩展一个平方的函数,返回自己的操作
// 定义个协议
protocol NumberProtocol{
}
// 扩展实现协议
extension Int:NumberProtocol{
}
extension Double:NumberProtocol{
}
// 给协议扩展方法
extension NumberProtocol{
// 我们不确定返回的Self 到底是什么类型
func squareValue()-> Self{
if self is Int{
let n = self as! Int
return n * n as! Self
}
if self is Double{
let n = self as! Double
return n * n as! Self
}
return 0 as! Self
}
}
print(3.44.squareValue())
print(3.squareValue())
运行:
11.8336
9
结论
我只想说这个用法只是Self的冰山一角更多神奇的东西,等待我们去探索。
你需要注意的
- 如果指出变量的类型,赋值的值必须是和他类型相同的值,不然编译不通过
var num:Int = 43.0//(编译错误)
2.浮点数类型推断出来的默认为Double类型
let name = 30.0 // Double
3.Float 类型的值 赋值给Double类型也必须转换
let name:Float = 30.0
let explicitDouble: Double = Double(name)
4.数字之间的转换结果为非可选值,数字转字符串也是非可选值,但是字符串转数字就是可选值(因为它有可能转换失败)
let str = "\(num1)"
let str1 = String(num1)
let num2 = Int(num1)
let num3 = Int(str1)
let num4 = Double(str1)
输出结果:
30.0
30
nil
Optional(30.0)
注意:
字符串33.0 转Int 类型只会是nil 不会是33 因为字符串33.0 不是Int类型转换失败,但是浮点数33.0 可以转换为33
5.不能推断出下面的类型
let list1 = ["你好","2","3",3] // 不能这样写,swift推断不出来
你应该:
let list1 = ["你好","2","3",3] as [Any]
let list1:[Any] = ["你好","2","3",3]
let list1:NSArray = ["你好","2","3",3]
let list1:NSMutableArray = ["你好","2","3",3]
6.使用Dictionary定义字典必须指定数据类型
let dic5:Dictionary = [:] // 错误
let dic5:Dictionary = [String:Int]() // 正确
无聊的测试
- 类型推断对性能的影响
for i in 0...50000000{
let i = 10;
}
运行三次消耗时间:
4.58978801965714
4.41006201505661
4.87126302719116
for i in 0...50000000{
let i:Int = 10;
}
运行三次消耗时间
4.42452102899551
4.68995898962021
4.52677303552628
类型推断对性能没有影响
- Array 和NSArray,NSMutableArray的区别
1.测试类型
var list1:Array = ["你好","2","3","4"]
let list2 = list1
list1[1] = "哈哈"
print(list1)
print(list2)
运行结果:
["你好", "哈哈", "3", "4"]
["你好", "2", "3", "4"]
var list1:NSMutableArray = ["你好","2","3","4"]
let list2 = list1
list1[1]="哈哈"
print(list1)
print(list2)
运行结果:
("你好", "哈哈", "3", "4")
("你好", "哈哈", "3", "4")
结论:
Array 为值类型,NSArray,NSMutableArray为引用类型
2.测试内存占用
func add(){
var array: [Any] = [3]
for _ in 0...10000000{
array.append(3)
}
}
执行代码前 3.5M 执行代码后 3.8 M 内存占用最高 308.6M
func add(){
let array: NSMutableArray = NSMutableArray()
for i in 0...10000000{
array.add(3)
if i == 10000000{
}
}
}
执行代码前3.5 M ,代码执行完毕后 17.3M,内存占用最高为 422.3
3.我们使用Array 放对象
func add(){
var array: [Any] = []
for i in 0...10000{
array.append([UILabel()])
}
}
运行前 3.5 运行后10.5 最高占内存 21.5，发现内存没有释放完毕
尝试修改代码如下:
autoreleasepool {
var array: [Any] = []
for i in 0...10000{
array.append([UILabel()])
}
}
运行结果依旧
结论:
Swift 中新增的Array 存放非对象类型,内存清理的更及时,更彻底!
4.数据的上溢或者下溢系统都会报错
Int8.min - 1
Int8.max + 1
报错:
arithmetic operation '127 + 1' (on type 'Int8') results in an overflow
error: arithmetic operation '-128 - 1' (on type 'Int8') results in an overflow
5.浮点数取余运算
let z = CGFloat(23.4).truncatingRemainder(dividingBy: 20)
运行:
3.4
