注意点
- 1.无隐式转换
Float(param)
通用
关键字
注意: 不可以在一个实体中定义访问级别更低的实体
-
1.方法/属性
* internal: 在本模块(项目/bundle/target)中都可以访问,系统默认的方法/属性权限
* private: 只有在本类中才可以访问(extension亦不可访问,修饰方法是需要加@objc)
* fileprivate: 在类所在文件中都可以访问
* open: 可以跨模块访问(系统类可访问的属性/方法均为open)
internal/fileprivate/private(set) 改变set访问权限* mutating: 修饰函数,表示该函数可以修改函数所属实例(属性) * subscript: 下标语法 * inout: 输入输出参数,表示传入的参数本身会在函数内被修改,需要是¶m指针类型,不能为let类型或者有默认值 *convenience: 便利构造器 @required: 必要的 required init(){ //构造器代码 } 2.类型
* 1.AnyObject > 任意class类型
* 2.Any > 任意类型,包括函数类型
* 3.as > 类型转换 A as B (switch A to B)3.文件级
SwiftCustomLogFunction
func log<T>(message: T, file: String = #file, function: String = #function, line: Int = #line) {
// setting: buildPhases - Swift complier-Custom Flags - Other Swift Flags - Debug -+ -D DEBUG
#if DEBUG
let fileName = (#file as NSString).lastPathComponent.split(separator: ".")
print(">> \(message) << line:\(line) \(fileName) . \(function)")
#endif
}
逻辑语句
- 1.
if> Swift所有条件表达式无非0/nil即真的概念 - 2.
guard>== specialif
guard 条件表达式1 else {
//条件1false 异常处理code
return/break/continue/throw 关键字
}
(条件1ture) 执行语句
guard 条件表达式2 else {
//条件1true + 条件2false 异常处理
return/break/contine/throw 关键字
}
(条件1true + 条件2true)执行语句
```
- 3.
switch
* 1.判断条件可以使:Int \ Floaf \ String \ 区间范围
* 2.关键字fallthrough (默认每个case 语句包含break)
* 3.case 可以跟多个判断表达式 > case : 条件1, 条件2
- 4.
repeat while>==do wile inOC
字符串
- 1.
拼接>str1 + str2 - 2.
和标识符拼接>\(param): "name is \(name), age is \(age)" - 3.
格式化>String(format: arguments:): String(format: "%02d:%02d", arguments:[min, second]); - 4.
as NSString用法>常用于截取字符串场景: (urlString as NSString).substringToIndex(3)
数组 (泛型集合,一般不存放不同类型元素)
-
initializer* 1. let array = [1, 2, 3, 4, 5] * 2. var arrayM = [String]() 拼接>array + array2(+ 仅限array1 与array2元素类型相同)遍历 > for param in array[0..<2] { }
字典
- 1.
initializer
* 1. let dict = ["key1" : "value1", "key2" : "value2"]
* 2. var dictM = Dictionary<String : anyObject>()
- 2.
增/改 删 查
dictM[key] = value (无key为增, 有key为改)
dictM.removeValue(forKey: "key") 删
dictM["key"]
for (key, value) in dictM {
dictM[key] = value
}
元组
initializer
* 1. let info = (name : "why", age : 19, height : 1.88) > info.name
* 2. let info = ("why", 18, 1.88) > info.index >= info.1
* 3. let (name, age, height) = ("why", 18, 1.89) > name
可选类型
- 1.
initializer
* 1. var name : String? = nil
* 2. var name : Optional<String> = nil
example:
let errorInfo = (errorCode: 404, errorMessage: "Not Found")
- 2.
强制解包与可选绑定
1. optionalName! > 注意:强制解包前一定要判断!= nil,否则崩溃
2. if let optionalName = optionalName {
执行optionalName用途
}
相当于执行2步操作: 判断optionalName != nil, optionalName = optionalName!
(当optionalName == nil,不执行{ }代码)
函数
- 1.
intializer
func 函数名(参数名: 参数类型, 参数名2: 参数类型) -> 返回值类型 {
函数代码块
return 返回值
}
- 2.
使用注意* 1. 内部参数 & 外部参数 (参数别名可见范围区分,默认第一个参数为内部参数,其余为外部参数) 参数1转换成外部参数 > 在参数1前再+别名 * 2. 默认参数 func makeCoffee(coffeeName: String = "雀巢") -> String {} makeCoffee() * 3. 可变参数(参数数组) func calculator(params: Int...) -> Int { var result = 0 for param in params { result += param } return result } * 4. 指针参数 func swapNum(inout m: Int, inout n: Int) { let temp = m m = n n = temp } swapNum(m: &m, n: &n) * 5. 函数嵌套 func nestFunc() { func test() { print("Test") } print"nestFunc" test() }
枚举
注意: Swift枚举值可以是Int,Float,character,String,并且不手动提供枚举值,系统不会默认指定,如果需要指定枚举值,则必须在枚举后指定枚举值类型
定义
* 1. enum CompassPoint {
case North
case South
case East
case West
}
* 2. enum Planet: Int { // 可以枚举列举在一行
case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
结构体
- 1.
结构体是一个数据结构/值类型,在方法中是值传递, 类是指针传递 - 2.
定义格式: struct 结构体名称 { // 属性和方法 }
struct Location {
var x: Double
var y: Double
/// 构造函数必须确保素有成员变量都有被初始化,构造函数都不需要返回值
// 系统默认会创建此种构造函数
init(x: Double, y:Double) {
self.x = x
self.y = y
}
// 如果手动创建构造函数,就会覆盖默认构造函数,但可以手动再创建
init(xyString: String) {
let strs = xyString.components(separatedBy: ",")
self.x = Double(strs.first ?? "0") ?? 0
self.y = Double(strs.last! ?? "0") ?? 0
}
}
/// 枚举拓展 - 可以拓展系统定义的结构体
extension Location {
mutating func move(x: Double, y: Double) { // 结构体可以扩充方法,修改成员变量的方法必须+ mutating
self.x += x
self.x += y
}
}
类
class Student : NSObject {
/***** 属性3种 *****/ // 初始化类的属性一般要赋值(值类型属性)或者指定可选类型(对象属性)
/// 1.存储属性
var englishScore: Double = 0.0
var chineseScore: Double = 0.0
/// 2.计算属性
var averageScore: Double {
return (englishScore + chineseScore) * 0.5
}
/// 3.类属性
static var courseCount: Int = 0
/***** 构造函数 *****/
/// 1.重写构造函数
override init() {
super.init()
// custom initCode
}
/// 2.自定义构造函数
init(englishScore: Double, chineseScore: Double) {
super.init() // 可省略,init默认会调用super.init()
self.englishScore = englishScore
self.chineseScore = chineseScore
}
/// 3.自定义构造函数withDictionary
// init(dictT: [String : AnyObject]) {
// if let score = dictT["chineseScore"] as? Double {
// chineseScore = score
// }
// }
init(dict: [String : AnyObject]) {
super.init()
setValuesForKeys(dict)
}
override func setValue(_ value: Any?, forUndefinedKey key: String) {} // 必须重写防止崩溃
/***** 类方法 *****/
class func classFunc() {}
/***** 属性监听器器 *****/
var targetValue: Int = 0 {
willSet { /* newValue */ }
didSet { /* oldValue */ }
}
/****** 下标语法 *****/
subscript (index: Int) -> Int { // 必须要有返回值 getter
get {
return index * index;
}
set { // newValue }
}
/***** 销毁 *****/
deinit {
相当于dealloc inOC
}
}
Student.courseCount = 2
let student = Student()
student.englishScore = 78.0
student.chineseScore = 80.0
可选链
- 1.
从可选链中进行取值?> 返回值是可选类型,其中任意可选为nil,则整个可选链结果为nil let toy = person.dog?.toy? - 2.
可选链获取目标进行赋值或调用方法> 可选链任一部分为nil,不执行后续代码\方法 person.dog?.toy? = "Hello Kity"
协议
注意点
0.协议作为类型,可以作为参数类型或返回值类型,集合元素类型
1.协议协议遵守者可以是 class, enum, static
2.代理类型的协议需要: class > 这样可以用执行修饰class的weak修饰可选类型的delegate
3.optional特性来自OC,需要定义optional func 需要在protocol 和该方法前 + @objc
4.协议定义属性:要求协议遵守者提供协议定义的属性,使用var定义,且只定义属性的名称、类型、读写属性
-
用法- & 把两个协议结合成一个临时局部协议 : A & B
func wishHappyBirthday(to celebrator: NamedProtocol & AgedProcotol) {
print("Happy birthday, (celebrator.name), you're (celebrator.age)!")
}
- & 把两个协议结合成一个临时局部协议 : A & B
-
example@objc protocol SportProtocol {//协议遵守者可以是 class, enum, static func playBasketball() @objc optional func playFootball() } protocol purchaseDelegate: class {// func buy() } class person: SportProtocol { weak var deletage: purchaseDelegate? func goForeign() { deletage?.buy() } // SportProtocol implementation func playBasketball() { } }
# 扩展 extension
* 1.**定义**:为已有的类 结构体 枚举或者协议添加新功能
* 2.**功能:**(类似 分类 inObjc)
1.添加计算型 类/实例属性
2.定义 实例/类方法,包括构造器
3.定义下标
4.定义和使用新的嵌套类型
5.使一个已有类型符合某个协议
* 3.**注意** 只能添加,不能重写已有功能
# 闭包
* 1.`格式: 类型 (参数列表) -> (返回值)`
闭包的写法:
类型:(形参列表)->(返回值)
技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值
值:
{
(形参) -> 返回值类型 in
// 执行代码
}
* 2.`闭包解决循环引用`
```
方式1: == 简写方式2
tools.loadData{[weak self] (jsonData) -> () in {
self?.view.backgroundColor = UIColor.redColor
}
}
方式2:
weak var weakSelf = self
tools.loadData { (jsonData) -> () in {
weakSelf?.view.background = UIColor.redColor // 如果weakSelf != nil 执行语句
}
}
```
* 3.`尾随闭包` > `当闭包是函数的最后一个参数,则该闭包为尾随闭包,尾随闭包函数可以将闭包提到()后,如果函数只有一个参数且为闭包,则可以省略参数列表外的()`
# Error
* 1.定义
func 方法(参数) throws返回值 {
条件语句 {throw someError}
}
example:
func age(age : Int) throws -> String {
if age < 0 {
throw AgeError.wrongAge // 错位定义成枚举类型, throw == return in 流程控制
}
return "OK"
}
* 2.处理 - 未被catch的error将层层传递
```
1. do catch
do {
try throws类型的函数
} catch 特定error {// 特定error
} catch {// 所有error
}
example:
do {
try student.age(age: -1)
} catch {
print("error")
}
2. try try? & try!(类似强制解包>有崩溃风险)
try? > let str = stry? tudent.age(age: 10) 如果抛出错误,str = nil, 如果未抛出错误, str = 返回值
```
# 指定清理操作 defer
* `1. 用途` defer定义在即将离开当前代码块时执行的语句,离开当前代码块包括return , break, throw ERROR等
* `2.注意:` defer语句中不能有流程控制转移,如break, return, throw ERROR等
* `3.顺序` 多条fefer语句,反序执行,即最后的defer语句最先执行
func processFile(filename: String) throws {
if exists(filename) {
let file = open(filename)
defer {
close(file)
}
while let line = try file.readline() { // 处理文件。
}
// close(file) 会在这里被调用，即作用域的最后。 }
}
# 类型转换
* 1.判断字:**is** > **if** *(something)* **is** *(anotherThing)* *return true/false*
* 2.关键字:**as** > ** if let item = product as? Movie**
# 元类型
类、结构体、枚举类型的元类型: .Type / type(of: someInstance) > example: SomeClass.Type
协议的元类型: .Protocol > example: SomeProtocal.Protocol