1.获取类型占用字节数
var intSize = MemoryLayout<Int>.size // intSize = 8
2.为类型指定别名
typealias Price = Int
var penPrice: Price = 100
3.检查某个数字是否包含于范围中
var range = 0...10
print(range ~= 8) // 打印true
4.'for - in' 循环的特殊姿势
for i in stride(from: 0, to: 10, by: 2) {
print(i)
}
//0 2 4 6 8
for i in stride(from: 0, through: 10, by: 2) {
print(i)
}
//0 2 4 6 8 10
如果我们想让i递减，可以将步长也就是by设置成负值，实现递减遍历。
5.遍历数组的索引，print函数的3个参数
// 打印：索引:0 索引:1 索引:2
for index in ["a", "b", "c"].indices {
print("索引", index, separator: ":", terminator: " ")
}
6.swich-case支持在一个case子句中编写多个匹配条件
// 打印chara is word
var charac = "b"
switch charac {
case "a", "b", "c":
print("chara is word")
case "1"..."3":
print("chara is num")
default:
print("no charac")
}
7.swich-case支持捕获元组元素，再追加条件判断
// 打印0
var tuple = (0, 0)
switch tuple {
case (let a, 1):
print(a)
case (let b, 0) where b == 0:
print(b)
case let(a, b) where a == b:
print(a, b)
default:
() // 什么都不做，空语句
}
- 自动闭包
// 自动闭包不能有参数，调用函数传参时，
// 闭包的实现只能由一句表达式组成，闭包的返回值即为此表达式的值
func myFunc2(closure:@autoclosure ()-> Bool) {
}
myFunc2(closure: 1 + 2 + 3 > 10)
9.自定义运算符
// 自定义前缀运算符++
prefix operator ++
prefix func ++(param: Int) -> Int {
return param + 1
}
++5 // 6
// 自定义中缀运算符++
precedencegroup MyPrecedence{ //定义运算符左右结合性和优先级
associativity: left
higherThan: AdditionPrecedence
}
infix operator ++:MyPrecedence
func ++(param1: Int, param2: Int) -> Int {
return param1 * param1 + param2 * param2
}
5 ++ 4 // 41
// 自定义后缀运算符++
postfix operator ++
postfix func ++(param1: Int) -> Int {
return param1 + param1
}
5++ // 10
10.枚举的相关值
enum Shape {
case circle(center:(Double, Double), radius: Double)
case rect(center:(Double, Double), width: Double, height: Double)
}
var rect = Shape.rect(center: (0, 0), width: 10, height: 15)
switch rect {
case let .circle(center, radius):
print("此圆的圆心为：\(center)，半径为：\(radius)")
case let .rect(center, width, height) where width == height:
print("正方形的中心为：\(center)，宽为：\(width)，高为：\(height)")
case let .rect(center, width, height) where width != height:
print("长方形的中心为：\(center)，宽为：\(width)，高为：\(height)")
default:
()
}
// 打印：长方形的中心为：(0.0, 0.0)，宽为：10.0，高为：15.0
11.延时构造属性
class People {
lazy var work: Work = Work()
}
12.类属性用static或class来声明，存储属性只能由static声明，计算属性如果需要被子类覆写，则需要用class声明
class SomeClass {
static var className = "SomeClass"
static var subName: String {
return "sub" + className
}
class var classSubName: String {
return "class" + subName
}
}
class SubClass: SomeClass {
override class var classSubName: String {
return "newName"
}
}
13.在类方法中也可以使用self关键字，代表当前类，可对当前类的类属性和类方法进行调用
struct Point {
static let name = "Point"
static func printName() {
print(self.name)
}
}
Point.printName() // 打印：Point
14.下标方法
class MyArray {
var array: Array<Int>
init(param: Int...) {
array = param
}
subscript(index: Int) -> Int {
set {
array[index] = newValue
}
get {
return array[index]
}
}
}
var myArray = MyArray(param: 1, 2, 3, 4, 5)
myArray[2]
myArray[1] = 0
15.如果子类没有覆写或者重写任何指定构造方法，则继承父类的所有指定构造方法。
如果子类提供了父类所有指定构造方法，无论是继承还是覆写，子类会继承父类的便利构造方法
16.指定构造函数中，存储属性赋值放在super.init()之前，调用父类属性、方法和本身方法、计算属性，放在super.init之后。
便利构造函数，子类、父类的属性、方法调用都在self.init()之后。
17.通过闭包的方式进行属性构造
class Check {
var name: Int = {
return 6 + 6
}()
}
18.避免循环引用用weak或unowned关键字，修饰循环引用的属性。倘若你使用 weak,属性可以是可选类型，即允许有 nil 值的情况。否则使用 unowned。
19.声明闭包的捕获列表，来消除闭包中的循环引用。捕获多个对象，用逗号进行分隔。
// 打印：MyClass deinit
class MyClass {
var name: String = "HS"
lazy var closure: () -> Void = {
[unowned self]() -> Void in
print(self.name)
}
deinit {
print("MyClass deinit")
}
}
var obj: MyClass? = MyClass()
obj?.closure
obj = nil
20.定义的协议中包含可选属性或方法，需用optional和@objc修饰
@objc protocol ClassProtocol {
@objc optional var name: String {get set}
@objc optional func log()
}
