引用類型的賦值操作
class Size {
var width = 1
var height = 2
}
值類型厂画、引用類型的let
struct Point {
var x: Int
var y: Int
}
let p = Point(x: 1, y: 2)
p = Point(x: 2, y: 3)//?
p.x = 33//?
p.y = 44//?
class Size {
var w: Int
var h: Int
init(w: Int, h: Int) {
self.w = w
self.h = h
}
}
let s = Size(w: 1, h: 2)
s.h = 3
s.w = 4
let str = "Jack"
str.append("_rose")//?
func testInstanceSize() {
class Size {
var w: Int
var h: Int
var test: Bool?
init(w: Int, h: Int) {
self.w = w
self.h = h
}
}
let s = Size(w: 1, h: 2)//malloc
print(class_getInstanceSize(Size.self)) // 40
print(class_getInstanceSize(type(of: s)))// 40
}
testInstanceSize()
嵌套類型
struct TestStruct {
enum TestEnum {
case one
}
enum TestEnum1 {
case one
}
}
枚舉获三、結(jié)構(gòu)體挤渐、類都可以定義方法
class Size {
func test() {
}
}
思考??: 方法占用實(shí)例對象的內(nèi)存空間嗎?
存儲在哪里?在內(nèi)存中,在內(nèi)存的哪個位置呢?
代碼端,函數(shù)放在哪里方法就放在哪里,方法本質(zhì)就是函數(shù)
class Size {
func test() {
}
}
func test1() {
}
class Size1 {
}
var s = Size()
s.test()
類似于
var s1 = Size1()
test1(s1)
全局變量
堆空間
椊缸瘢空間
閉包表達(dá)式(Closure Expression)
func sum(_ v1: Int, _ v2: Int) -> { v1 + v2 }
var fn = { (v1 :Int, v2: Int) -> Int in
return v1 + v2
}
fn(10, 20)
閉包表達(dá)式的簡寫
func exec(_ v1: Int, _ v2: Int, fn:(Int, Int) -> Int) {
print(fn(v1, v2))
}
exec(v1: 10, v2: 20, fn: {
(v1: Int, v2:Int) -> Int in
return v1 + v2
})
省略
exec(v1: 10, v2: 20, fn: {
v1, v2 in
return v1 + v2
})
再省略
exec(v1: 10, v2: 20, fn: {
v1, v2 in
v1 + v2
})
再省略
exec(v1: 10, v2: 20, fn: {
$0 + $1
})
再省略
exec(v1: 10, v2: 20, fn: +)
尾隨閉包
如果將一個很長的閉包表達(dá)式作為函數(shù)的最后一個實(shí)參,使用尾隨閉包可以增強(qiáng)函數(shù)的可讀性.
func exec(v1: Int, v2: Int, fn:(Int, Int) -> Int) {
print(fn(v1,v2))
}
exec(v1: 10, v2: 20) {
$0 + $1
}
如果閉包表達(dá)式作為函數(shù)的唯一參數(shù),而且使用尾隨閉包的語法,那么就不需要在函數(shù)后面添加圓括號.
func exec( fn:(Int, Int) -> Int) {
print(fn(1,2))
}
調(diào)用
exec(fn: {$0+$1})
exec(){$0+$1}
exec{$0+$1}
事栗-數(shù)組的排序
func testSort() {
var arr = [2,3,4,1,6,7,8,3,4]
arr.sort()
print(arr)
}
[1, 2, 3, 3, 4, 4, 6, 7, 8]
Program ended with exit code: 0
sort源碼
func sort(by areInIncreasingOrder: (Element, Element)->Bool)
///返回true: i1排在i2前面
///返回false: i1排在i2后面
func cmp(i1: Int, i2: Int) -> Bool {
//大的排在前面
return i1 > i2
}
