【澳门葡京备用网址】斯维夫特基础语法

简介

  • 特点
    (1)优于OC,快速,安全
    (二)打消了预编写翻译指令包涵宏定义(OC用的太多了)
    (叁)撤除了OC指针和不安全访问的使用(看不到星星了)
    (四)吐弃 Objective-C 早期采用 Smalltalk 的语法,周密改为点语法
    (5)3.0中对Foundation框架做了无数改成,去除了NS,将大举class调换到struct结构体(为了考虑质量和安全性,绝大多数应用结构体来替代原先的类,可是在实质上采用感到不到)
    (陆)能够动用现有的 Cocoa 和 Cocoa Touch 框架
    , 此前是OC调UIKit,以后就是斯威夫特调UIKit,那一点事没难题的
    (七)斯威夫特因为语法的严俊性能够让许多荒唐提前遭受,那样很少出现bug让程序停在main导致力不从心找到
    【澳门葡京备用网址】斯维夫特基础语法。(8)@UIApplicationMain是先后的进口
    (9)只有.h没有.m
    (拾)全部的代码都不外乎在{}里,私下认可方法func都有缩进!
    (11)语法的allocinit替换成()

  • PlayGround
    (1)能够看苹果官方自带的tips和玖拾玖个tips,都在Placground来使用

  • 基础点
    (一)不适用self. 在闭包或许编写翻译器提醒的时候再选择
    (2)分号是用来分割语句的,借使一行洗诸多,就可以加分号,一般时候能够不加
    (3)#function打字与印刷实践的函数
    (四)加多标志用到// MAKoleosK: – 选用,尽管是接下去要做的能够用//
    TODO:和// FIXME:这一个尤其实惠

简介

  • 特点
    (1)优于OC,快速,安全
    (贰)打消了预编写翻译指令包涵宏定义(OC用的太多了)
    (3)撤除了OC指针和不安全访问的使用(看不到星星了)
    (肆)吐弃 Objective-C 早期选取 Smalltalk 的语法,周密改为点语法
    (五)3.0中对Foundation框架做了累累更改,去除了NS,将大举class转变来struct结构体(为了考虑质量和安全性,绝大部分用到结构体来取代原先的类,可是在骨子里运用感到不到)
    (陆)能够行使现成的 Cocoa 和 Cocoa Touch 框架
    , 之前是OC调UIKit,未来正是Swift调UIKit,那一点事没难题的
    (7)斯维夫特因为语法的严苛性能够让诸多不当提前境遇,那样很少出现bug让程序停在main导致不或者找到
    (八)@UIApplicationMain是先后的入口
    (9)只有.h没有.m
    (十)全体的代码都囊括在{}里,暗许方法func都有缩进!
    (11)语法的allocinit替换成()

  • PlayGround
    (一)能够看苹果官方自带的tips和9十九个tips,都在Placground来行使

  • 基础点
    (壹)不适用self. 在闭包只怕编写翻译器提醒的时候再使用
    (二)分号是用来分割语句的,假若一行洗诸多,就足以加分号,一般时候能够不加
    (3)#function打字与印刷推行的函数
    (四)增添标识用到// MA奥迪Q三K: – 采取,借使是接下去要做的能够用//
    TODO:和// FIXME:那一个分外实惠

简介

  • 特点
    (1)优于OC,快速,安全
    (贰)撤消了预编写翻译指令包涵宏定义(OC用的太多了)
    (3)撤消了OC指针和不安全访问的运用(看不到星星了)
    (四)放弃 Objective-C 早期采纳 Smalltalk 的语法,全面改为点语法
    (5)3.0中对Foundation框架做了成都百货上千更换,去除了NS,将大举class转变到struct结构体(为了驰念品质和安全性,绝超越四分之一选择结构体来替代原先的类,然而在实质上采取感到不到)
    (陆)能够利用现存的 Cocoa 和 Cocoa Touch 框架
    , 从前是OC调UIKit,现在正是Swift调UIKit,那点事没问题的
    (7)Swift因为语法的严苛性可以让多数似是而非提前遇到,那样很少出现bug让程序停在main导致力不从心找到
    (八)@UIApplicationMain是先后的入口
    (9)只有.h没有.m
    (10)全体的代码都包蕴在{}里,私下认可方法func都有缩进!
    (11)语法的allocinit替换成()

  • PlayGround
    (1)能够看苹果官方自带的tips和玖八个tips,都在Placground来利用

  • 基础点
    (一)不适用self. 在闭包大概编译器提醒的时候再采纳
    (二)分号是用来分割语句的,假如1行洗许多,就能够加分号,一般时候能够不加
    (3)#function打字与印刷施行的函数
    (四)加多标识用到// MA揽胜极光K: – 选取,假若是接下去要做的能够用//
    TODO:和// FIXME:这个格外实惠

骨干格式

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // swift 中 () 代替 oc 中的 alloc / init
        let v = UIView(frame: CGRect(x: 0, y: 20, width: 100, height: 100))

        // [UIColor redColor];
        v.backgroundColor = UIColor.redColor()

        // 按钮
        let btn = UIButton(type: .ContactAdd)
        v.addSubview(btn)

        // 监听方法
        btn.addTarget(self, action: "click:", forControlEvents: .TouchUpInside)

        view.addSubview(v)
    }

    func click(btn: UIButton) {
        print("点我了 \(btn)")
    }
}
  • 在 Swift 中绝非了 main.m,@UIApplicationMain 是程序入口

  • 在 Swift 中唯有 .swift 文件,未有 .h/.m 文件的区分

  • 在 Swift 中,1个类便是用壹对 { } 括起的,未有 @implementation 和
    @end

  • 各样语句的最终未有分号,在任何语言中,分号是用来分别不相同语句的

  • 在 Swift 中,一般都以一行一句代码,因而不要接纳分号

  • 与 OC 的语法迅速对比

  • 在 OC 中 alloc / init 对应 ( )

  • 在 OC 中 alloc / initWithXXX 对应 (XXX: )

  • 在 OC 中的类函数调用,在 Swift 中,直接利用 .

  • 在 斯威夫特 中,绝大多数得以轻松self.,提出一般不写,能够加强对语境的知情(闭包时会体会到)

  • 在 OC 中的 枚举类型使用 UIButtonTypeContactAdd,而 斯威夫特中分离了,操作热键:回车 -> 向右 -> .

  • Swift中,枚举类型的前缀能够大概,如:.ContactAdd,不过:好些个时候从不智能提示

  • 监听方法,直接动用字符串引起

  • 在 Swift 中使用 print() 替代 OC 中的 NSLog

1、常量和变量

1、常量和变量

1、常量和变量

变量与常量

定义

  • “` 定义常量,壹经赋值不容许再修改

  • “` 定义变量,赋值之后还能够修改

//: # 常量
//: 定义常量并且直接设置数值
let x = 20
//: 常量数值一经设置,不能修改,以下代码会报错
// x = 30

//: 使用 `: 类型`,仅仅只定义类型,而没有设置数值
let x1: Int
//: 常量有一次设置数值的机会,以下代码没有问题,因为 x1 还没有被设置数值
x1 = 30
//: 一旦设置了数值之后,则不能再次修改,以下代码会报错,因为 x1 已经被设置了数值
// x1 = 50

//: # 变量
//: 变量设置数值之后,可以继续修改数值
var y = 200
y = 300

定义

  • let 定义常量,一经赋值不允许再修改
  • var 定义变量,赋值之后仍旧能够修改
    常量和变量的细节

    • 利用 : 类型,仅仅只定义类型
    • 常量有二次设置的空子
    • 有道是尽大概先选择常量,唯有在必须修改时,才须求修改为 var

// 定义常量并且直接设置数值
let x: Int = 10
// 常量数值一经设置,不能修改,以下代码会报错
// x = 30

let y: Int
// 常量有一次设置的机会,以下代码没有问题,因为 `y` 还没有被设置数值
y = 10

// 一旦设置之后,则不能再次修改,以下代码会报错,因为 `y` 已经被设置了数值
// y = 50

print(x + y)

// 变量设置数值之后,可以继续修改数值
var z: Int
z = 100
z = 200

print(x + y + z)

定义

  • let 定义常量,壹经赋值不允许再修改
  • var 定义变量,赋值之后如故能够修改
    常量和变量的底细

  • 接纳 : 类型,仅仅只定义类型

  • 常量有三遍设置的时机
  • 应当尽也许先选取常量,唯有在必须修改时,才需求修改为 var

// 定义常量并且直接设置数值
let x: Int = 10
// 常量数值一经设置,不能修改,以下代码会报错
// x = 30

let y: Int
// 常量有一次设置的机会,以下代码没有问题,因为 `y` 还没有被设置数值
y = 10

// 一旦设置之后,则不能再次修改,以下代码会报错,因为 `y` 已经被设置了数值
// y = 50

print(x + y)

// 变量设置数值之后,可以继续修改数值
var z: Int
z = 100
z = 200

print(x + y + z)

定义

  • let 定义常量,一经赋值不允许再修改

  • var 定义变量,赋值之后依然能够修改
    常量和变量的细节

    • 动用 : 类型,仅仅只定义类型
    • 常量有一遍设置的火候
    • 有道是尽大概先采用常量,只有在必须修改时,才供给修改为 var

// 定义常量并且直接设置数值
let x: Int = 10
// 常量数值一经设置,不能修改,以下代码会报错
// x = 30

let y: Int
// 常量有一次设置的机会,以下代码没有问题,因为 `y` 还没有被设置数值
y = 10

// 一旦设置之后,则不能再次修改,以下代码会报错,因为 `y` 已经被设置了数值
// y = 50

print(x + y)

// 变量设置数值之后,可以继续修改数值
var z: Int
z = 100
z = 200

print(x + y + z)

Optional 可选类型

  • Optional 是 斯维夫特 的一大特征,也是 Swift 初专家最轻巧思疑的题目
  • 概念变量时,若是钦赐是可选的,表示该变量能够有三个内定项目标值,也得以是
    nil
  • 概念变量时,在品种后边增多叁个 ?,表示该变量是可选的
  • 变量可挑选的私下认可值是 nil
  • 常量可挑选未有默许值,主要用于在构造函数中给常量设置开首数值

//: num 可以是一个整数,也可以是 nil,注意如果为 nil,不能参与计算
var num: Int? = 10
  • 万1 Optional 值是 nil,不容许参加总结
  • 除非解包(unwrap)后技巧参预总计
  • 在变量后增加一个 ** ! **,能够强行解包

机关推导

斯威夫特 能够基于左边的代码,推导出变量的正确类型
只有平等档案的次序的值才干够实行演算

// 整数默认的类型是 Int
let intValue = 200
// 小数的默认类型是 Double
let doubleValue = 10.5

// 如果要对不同类型的数据进行计算,必须要显式的转换
print(intValue + Int(doubleValue))
print(Double(intValue) + doubleValue)

瞩目:斯维夫特对项目必要11分暴虐,任何例外档期的顺序的数据不可能直接运算(哪怕是Int和Double),不会做一些机动的转变成转换来Double。Swift不存在基本数据类型,Int和Double都是结构体其实,强转用Double(x)达成,也许在概念的时候一向钦点变量的等级次序let
x : Double = 拾;(很少使用)

活动推导

Swift 能够基于左侧的代码,推导出变量的高精度类型
唯有同样类别的值才干够举办演算

// 整数默认的类型是 Int
let intValue = 200
// 小数的默认类型是 Double
let doubleValue = 10.5

// 如果要对不同类型的数据进行计算,必须要显式的转换
print(intValue + Int(doubleValue))
print(Double(intValue) + doubleValue)

专注:Swift对项目要求丰硕严苛,任何例外品类的数码不能够直接运算(哪怕是Int和Double),不会做一些机动的转移来调换到Double。Swift不存在基本数据类型,Int和Double都是结构体其实,强转用Double(x)完成,恐怕在概念的时候一直钦赐变量的品类let
x : Double = 拾;(很少使用)

机动推导

Swift 能够依照左侧的代码,推导出变量的确切类型
唯有同样体系的值手艺够进行演算

// 整数默认的类型是 Int
let intValue = 200
// 小数的默认类型是 Double
let doubleValue = 10.5

// 如果要对不同类型的数据进行计算,必须要显式的转换
print(intValue + Int(doubleValue))
print(Double(intValue) + doubleValue)

留意:斯维夫特对品种必要十二分阴毒,任何例外品种的多寡不可能一贯运算(哪怕是Int和Double),不会做一些机动的转换到转变到Double。斯威夫特不存在基本数据类型,Int和Double都以结构体其实,强转用Double(x)实现,只怕在概念的时候向来钦命变量的品类let
x : Double = 十;(很少使用)

只顾:要求求保管解包后的值不是 nil,不然会报错

//: num 可以是一个整数,也可以是 nil,注意如果为 nil,不能参与计算
var num: Int? = 10

//: 如果 num 为 nil,使用 `!` 强行解包会报错
let r1 = num! + 100

//: 使用以下判断,当 num 为 nil 时,if 分支中的代码不会执行
if let n = num {
    let r = n + 10
}

二、控制流

二、控制流

二、控制流

普及错误

unexpectedly found nil while unwrapping an Optional value

翻译

在[解包]一个可选值时发现 nil

if

  • Swift 中从未 C 语言中的非零即真概念
  • 在逻辑决断时务必出示地指明具体的决断标准 true / false
  • if 语句条件的 () 能够简简单单
  • 而是 {} 无法大致

let num = 100

if num > 10 {
    print("大 \(num)")
} else {
    print("小 \(num)")
}

if

  • Swift 中从未 C 语言中的非零即真概念
  • 在逻辑推断时务必出示地指明具体的决断规范 true / false
  • if 语句条件的 () 能够总结
  • 唯独 {} 无法轻易

let num = 100

if num > 10 {
    print("大 \(num)")
} else {
    print("小 \(num)")
}

if

  • 斯维夫特 中从不 C 语言中的非零即真概念
  • 在逻辑判定时务必出示地指明具体的推断标准 true / false
  • if 语句条件的 () 能够轻松
  • 唯独 {} 不能够简单

let num = 100

if num > 10 {
    print("大 \(num)")
} else {
    print("小 \(num)")
}

?? 运算符 (空合并运算符)

  • ?? 运算符能够用来决断 变量/常量 的数值是不是是
    nil,假如是则使用前面包车型地铁值代替
  • 在使用 Swift 开辟时,?? 能够简化代码的编写

var num: Int?

let r1 = (num ?? 0) + 10
print(r1)

三目

  • 斯威夫特 中的 三目 运算保持了和 OC 1致的风骨
  • 唤醒:以下代码,能够按 cmd + shift + y,展开调控台,查看输出结果

num > 10 ? print("大 \(num)") : print("小 \(num)")

或者

num > 10 ? print("大 \(num)")  : () 
这样就对后面的不作处理。
() 表示空执行。

三目

  • Swift 中的 三目 运算保持了和 OC 一致的品格
  • 提示:以下代码,能够按 cmd + shift + y,展开调控台,查看输出结果

num > 10 ? print("大 \(num)") : print("小 \(num)")

或者

num > 10 ? print("大 \(num)")  : () 
这样就对后面的不作处理。
() 表示空执行。

三目

  • 斯维夫特 中的 三目 运算保持了和 OC 一致的品格
  • 唤醒:以下代码,能够按 cmd + shift + y,展开调节台,查看输出结果

num > 10 ? print("大 \(num)") : print("小 \(num)")

或者

num > 10 ? print("大 \(num)")  : () 
这样就对后面的不作处理。
() 表示空执行。

控制流

if

  • 斯维夫特 中绝非 C 语言中的非零即真概念
  • 在逻辑判断时务必出示地指明具体的决断标准 true / false
  • if 语句条件的 () 能够轻便
  • 不过 {} 不可能轻易

let num = 200
if num < 10 {
    print("比 10 小")
} else if num > 100 {
    print("比 100 大")
} else {
    print("10 ~ 100 之间的数字")
}

switch

  • switch 不再局限于整数
  • switch 可以针对自便数据类型进行判别
  • 每多少个 case 前面总得有能够实践的语句
  • 不再强制需求 break
  • 假如未有此外索要实践的讲话,能够选取 break
    要确认保障拍卖全数相当的大可能率的意况,不然编写翻译器直接报错,不管理的规格能够放在
    default 分支中
  • 每3个 case 中定义的变量仅在目前 case 中央银立见成效,而 OC 中必要选用 {}
  • 多值 case 能够行使 , 分隔

let scoreString = "优"

switch scoreString {
case "优":
    let name = "学生"
    print(name + "80~100分")
case "良", "中": print("60~80分")
case "差": print("不及格")
default: break
}

switch 的规格推断

  • switch 中得以运用 where 子句评定尺度
  • 只要只做标准推断,case 部分能够采用 _ 省略
  • 提示:斯维夫特 中得以利用 _ 忽略任何不关怀的内容

let score = 90
switch score {
case _ where score >= 80: print("优")
case _ where score >= 70: print("良")
case _ where score >= 60: print("中")
default: print("差")
}

switch

  • switch 不再局限于整数
  • switch 能够针对任性数据类型进行剖断
  • 每2个 case 后边总得有能够实行的话语
  • 不再强制须要 break
  • 固然未有其他索要试行的话语,能够运用 break
    要力保拍卖全数非常大也许的景况,不然编写翻译器直接报错,不管理的规则得以放在
    default 分支中
  • 每2个 case 中定义的变量仅在现阶段 case 中央银卓有成效,而 OC 中供给动用 {}
  • 多值 case 能够选用 , 分隔

let scoreString = "优"

switch scoreString {
case "优":
    let name = "学生"
    print(name + "80~100分")
case "良", "中": print("60~80分")
case "差": print("不及格")
default: break
}

switch 的准绳判别

  • switch 中得以采纳 where 子句推断规范
  • 倘使只做标准判别,case 部分能够行使 _ 省略
  • 提示:Swift 中得以利用 _ 忽略任何不关注的内容

let score = 90
switch score {
case _ where score >= 80: print("优")
case _ where score >= 70: print("良")
case _ where score >= 60: print("中")
default: print("差")
}

switch

  • switch 不再局限于整数
  • switch 能够本着放四数据类型实行剖断
  • 各个 case 前面总得有能够举办的讲话
  • 不再强制须要 break
  • 若果未有别的索要实行的说话,能够利用 break
    要保险拍卖全体相当的大概率的状态,不然编译器直接报错,不管理的规格得以放在
    default 分支中
  • 每叁个 case 中定义的变量仅在脚下 case 中有效,而 OC 中必要利用 {}
  • 多值 case 能够使用 , 分隔

let scoreString = "优"

switch scoreString {
case "优":
    let name = "学生"
    print(name + "80~100分")
case "良", "中": print("60~80分")
case "差": print("不及格")
default: break
}

switch 的尺码推断

  • switch 中得以行使 where 子句判定规范
  • 设若只做标准决断,case 部分能够使用 _ 省略
  • 晋升:Swift 中得以选择 _ 忽略任何不保护的始末

let score = 90
switch score {
case _ where score >= 80: print("优")
case _ where score >= 70: print("良")
case _ where score >= 60: print("中")
default: print("差")
}

三目运算

  • 斯维夫特 中的 三目 运算保持了和 OC 一致的作风

var a = 10
var b = 20
let c = a > b ? a : b
print(c)

合适地动用三目,能够让代码写得尤为简明

for

  • swift撤除了i++和++i和守旧的for循环

for i in 0...5 {

}

for i in 0..<5 {

}
  • 反序遍历

 for i in (0..<10).reversed() {

}

for

  • swift撤除了i++和++i和历史观的for循环

for i in 0...5 {

}

for i in 0..<5 {

}
  • 反序遍历

 for i in (0..<10).reversed() {

}

for

  • swift打消了i++和++i和历史观的for循环

for i in 0...5 {

}

for i in 0..<5 {

}
  • 反序遍历

 for i in (0..<10).reversed() {

}

可挑选推断

  • 鉴于可采纳的情节只怕为 nil,而1旦为 nil 则区别意参预总括
  • 因此在实际上费用中,常常索要看清可选用的剧情是或不是为 nil

单个可挑选判定

let url = NSURL(string: "http://www.baidu.com")

//: 方法1: 强行解包 - 缺陷,如果 url 为空,运行时会崩溃
let request = NSURLRequest(URL: url!)

//: 方法2: 首先判断 - 代码中仍然需要使用 `!` 强行解包
if url != nil {
    let request = NSURLRequest(URL: url!)
}

//: 方法3: 使用 `if let`,这种方式,表明一旦进入 if 分支,u 就不在是可选项
if let u = url where u.host == "www.baidu.com" {
    let request = NSURLRequest(URL: u)
}

可选项原则判断

//: 1> 初学 swift 一不小心就会让 if 的嵌套层次很深,让代码变得很丑陋
if let u = url {
    if u.host == "www.baidu.com" {
        let request = NSURLRequest(URL: u)
    }
}

//: 2> 使用 where 关键字,
if let u = url where u.host == "www.baidu.com" {
    let request = NSURLRequest(URL: u)
}

** 小结**

  • if let 不能够与运用 &&、|| 等原则决断
  • 设若要加进条件,能够利用 where 子句
  • 留神:where 子句未有智能提示
  • 多个可选拔剖断

//: 3> 可以使用 `,` 同时判断多个可选项是否为空
let oName: String? = "张三"
let oNo: Int? = 100

if let name = oName {
    if let no = oNo {
        print("姓名:" + name + " 学号: " + String(no))
    }
}

if let name = oName, let no = oNo {
    print("姓名:" + name + " 学号: " + String(no))
}

决断之后对变量须求修改

let oName: String? = "张三"
let oNum: Int? = 18

if var name = oName, num = oNum {

    name = "李四"
    num = 1

    print(name, num)
}
guard

guard 是与 if let 相反的语法,Swift 二.0 推出的

let oName: String? = "张三"
let oNum: Int? = 18

guard let name = oName else {
    print("name 为空")
    return
}

guard let num = oNum else {
    print("num 为空")
    return
}

// 代码执行至此,name & num 都是有值的
print(name)
print(num)
  • 在先后编写制按时,条件检查评定之后的代码相对是比较复杂的
  • 使用 guard 的好处
    能够看清每四个值
    在真的的代码逻辑部分,省略了1层嵌套

三、可选项(Optional)

三、可选项(Optional)

三、可选项(Optional)

switch

  • switch 不再局限于整数
  • switch 能够针对放4数据类型举行推断
  • 不再须求 break
  • 每三个 case后边总得有能够实行的语句
  • 要力保拍卖全体希望的情形,不然编写翻译器直接报错,不管理的尺码得以放在
    default 分支中
  • 每二个 case 中定义的变量仅在当前 case 中有效,而 OC 中要求采用 {}

let score = "优"
switch score {
case "优":
    let name = "学生"
    print(name + "80~100分")
case "良": print("70~80分")
case "中": print("60~70分")
case "差": print("不及格")
default: break
}

switch 中平等可以赋值和接纳 where 子句

let point = CGPoint(x: 10, y: 10)
switch point {
case let p where p.x == 0 && p.y == 0:
    print("中心点")
case let p where p.x == 0:
    print("Y轴")
case let p where p.y == 0:
    print("X轴")
case let p where abs(p.x) == abs(p.y):
    print("对角线")
default:
    print("其他")
}

若果只期待举办标准判别,赋值部分能够回顾

switch score {
case _ where score > 80: print("优")
case _ where score > 60: print("及格")
default: print("其他")
}

简要

(1)定义变量时,固然是可选的,表示能够有值,也能够是nil,用“?”
(贰)强行解包 “!”,技术员来注意!,并且要少用,或许会崩
(叁)最遍布的荒唐:解包的时候开采nil。fatal error: unexpectedly found
nil while unwrapping an Optional value
(4)let可选的话,未有暗中同意值,需求赋值。var可选的话,默许值为nil
(伍)可选项在参预总计时候必须解包

简要

(1)定义变量时,若是是可选的,表示能够有值,也得以是nil,用“?”
(二)强行解包 “!”,技士来注意!,并且要少用,大概会崩
(叁)最分布的荒唐:解包的时候开掘nil。fatal error: unexpectedly found
nil while unwrapping an Optional value
(4)let可选的话,未有暗中认可值,需求赋值。var可选的话,默许值为nil
(5)可选项在插香港足球总会括时候必须解包

简要

(1)定义变量时,假设是可选的,表示能够有值,也足以是nil,用“?”
(二)强行解包 “!”,程序员来注意!,并且要少用,可能会崩
(三)最普及的失实:解包的时候开采nil。fatal error: unexpectedly found
nil while unwrapping an Optional value
(四)let可选的话,未有暗许值,须求赋值。var可选的话,暗中认可值为nil
(伍)可选项在加入总括时候必须解包

for 循环

  • C 风格的循环 (斯维夫特 2.二 中过时,斯维夫特 叁.0中被屏弃)

var sum = 0
for var i = 0; i < 10; i++ {
    sum += i
}
print(sum)
for-in,0..<10 表示从0到9
sum = 0
for i in 0..<10 {
    sum += i
}
print(sum)
  • 范围 0…10 表示从0到10

sum = 0
for i in 0...10 {
    sum += i
}
print(sum)
  • 归纳下标
  • _” 能够相称任性类型
  • _“表示忽略对应地方的值

for _ in 0...10 {
    print("hello")
}

概念

  • Optional 是 Swift 的一大特点,也是 斯威夫特 初学者最轻易质疑的难点
  • 概念变量时,在档期的顺序前面增加三个 ?,表示该变量是可选的
  • 概念变量时,纵然钦命是可选的,表示该变量:
    • 能够有3个钦赐项目标值
    • 也能够是 nil

概念

  • Optional 是 Swift 的一大特征,也是 斯威夫特 初专家最轻松质疑的标题
  • 概念变量时,在类型前边增加八个 ?,表示该变量是可选的
  • 概念变量时,如若钦定是可选的,表示该变量:
  • 能够有1个点名项目标值
  • 也能够是 nil

概念

  • Optional 是 斯威夫特 的一大特征,也是 Swift 初专家最轻易狐疑的标题
  • 概念变量时,在档期的顺序前面增多3个 ?,表示该变量是可选的
  • 概念变量时,要是内定是可选的,表示该变量:
    • 可以有叁个钦点项目标值
    • 也能够是 nil

字符串

  • 在 Swift 中山大学部的气象下,推荐使用 String 类型
  • String 是3个结构体,品质更加高
  • String 近来颇具了绝大很多 NSString 的意义
  • String 援助直接遍历
  • NSString 是三个 OC 对象,质量略差
  • Swift 提供了 String 和 NSString 之间的无缝转变

字符串练习

  • 遍历字符串中的字符

for s in str.characters {
    print(s)
}
  • 字符串长度

// 返回以字节为单位的字符串长度,一个中文占 3 个字节
let len1 = str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
// 返回实际字符的个数
let len2 = str.characters.count
// 返回 utf8 编码长度
let len3 = str.utf8.count
  • 字符串拼接
  • 直接在 “” 中使用 (变量名) 的章程得以长足拼接字符串

let str1 = "Hello"
let str2 = "World"
let i = 32
str = "\(i) 个 " + str1 + " " + str2
  • 自家和自家的伴儿再也并非思索 stringWithFormat 了 😀
  • 可挑选的拼接
  • 如若变量是可挑选,拼接的结果中会有 Optional
  • 为了回应强行解包存在的危机,苹果提供了 ?? 操作符
  • ?? 操作符用于检查测试可挑选是不是为 nil
  • 就算不是 nil,使用当前值
  • 壹经是 nil,使用后边的值代替

let str1 = "Hello"
let str2 = "World"
let i: Int? = 32
str = "\(i ?? 0) 个 " + str1 + " " + str2
  • 格式化字符串
    在骨子里支出中,假若急需钦点字符串格式,可以使用 String(format:…)
    的不贰诀要

let h = 8
let m = 23
let s = 9
let timeString = String(format: "%02d:%02d:%02d", arguments: [h, m, s])
let timeStr = String(format: "%02d:%02d:%02d", h, m, s)

定义

  • 格式1(自动推导):var 变量名: Optional = 值
  • 格式2(泛型):var 变量名:Optional<类型> = 值
  • 格式三(简化格式):var 变量名: 类型? = 值

// 格式1
let x: Optional = 20
// 格式2
let y: Optional<Int> = 30
// 格式3
let z: Int? = 10

print(x)
print(y)
print(z)

定义

  • 格式一(自动推导):var 变量名: Optional = 值
  • 格式2(泛型):var 变量名:Optional<类型> = 值
  • 格式叁(简化格式):var 变量名: 类型? = 值

// 格式1
let x: Optional = 20
// 格式2
let y: Optional<Int> = 30
// 格式3
let z: Int? = 10

print(x)
print(y)
print(z)

定义

  • 格式一(自动推导):var 变量名: Optional = 值
  • 格式2(泛型):var 变量名:Optional<类型> = 值
  • 格式三(简化格式):var 变量名: 类型? = 值

// 格式1
let x: Optional = 20
// 格式2
let y: Optional<Int> = 30
// 格式3
let z: Int? = 10

print(x)
print(y)
print(z)

String & Range 的结合

  • 在 Swift 中,String 和 Range连用时,语法结构相比较复杂
  • 若是不习贯 斯维夫特 的语法,能够将字符串转变来 NSString 再管理

let helloString = "我们一起飞"
(helloString as NSString).substringWithRange(NSMakeRange(2, 3))
使用 Range 的写法
let startIndex = helloString.startIndex.advancedBy(0)
let endIndex = helloString.endIndex.advancedBy(-1)

helloString.substringWithRange(startIndex..<endIndex)

默认值

  • 变量可接纳的暗中同意值是 nil
  • 常量可选用没有默许值,必要在概念时,大概构造函数中赋值

var x1: Int?
print(x1)

let x2: Int?
// 常量可选项没有默认值,在赋值之前不能使用
// print(x2)
x2 = 100
print(x2)

默认值

  • 变量可挑选的暗中认可值是 nil
  • 常量可选择未有暗许值,供给在概念时,或许构造函数中赋值

var x1: Int?
print(x1)

let x2: Int?
// 常量可选项没有默认值,在赋值之前不能使用
// print(x2)
x2 = 100
print(x2)

默认值

  • 变量可挑选的暗中认可值是 nil
  • 常量可挑选未有暗中同意值,需求在概念时,只怕构造函数中赋值

var x1: Int?
print(x1)

let x2: Int?
// 常量可选项没有默认值,在赋值之前不能使用
// print(x2)
x2 = 100
print(x2)

集合

计量和残忍解包

  • 可选值在参预总结前,必须解包 unwarping
  • 除非解包(unwrap)后才能参预计算
  • 在可采用后增多三个 !,表示强行解包
    • 如果有值,会取值,然后参与后续总括
    • 设若为 nil,强行解包会导致崩溃

print(x! + y! + z!)

程序员要对每三个 ! 负责

计算和残暴解包

  • 可选值在加入总括前,必须解包 unwarping
  • 唯有解包(unwrap)后手艺出席计算
  • 在可挑选后加多2个 !,表示强行解包
  • 假使有值,会取值,然后涉足后续计算
  • 假设为 nil,强行解包会导致崩溃

print(x! + y! + z!)

技师要对每1个 ! 负责

算算和无情解包

  • 可选值在参预总计前,必须解包 unwarping
  • 唯有解包(unwrap)后本领加入总计
  • 在可挑选后增加2个 !,表示强行解包
    • 设若有值,会取值,然后涉足后续计算
    • 倘诺为 nil,强行解包会导致崩溃

print(x! + y! + z!)

程序员要对每四个 ! 负责

数组

  • 数组使用 [] 定义,那或多或少与 OC 相同

//: [Int]
let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
遍历
for num in numbers {
    print(num)
}
  • 因此下标获取内定项内容

let num1 = numbers[0]
let num2 = numbers[1]
  • 可变&不可变

 - let 定义不可变数组
 - var 定义可变数组
let array = ["zhangsan", "lisi"]
//: 不能向不可变数组中追加内容
//array.append("wangwu")
var array1 = ["zhangsan", "lisi"]

//: 向可变数组中追加内容
array1.append("wangle")
  • 数组的类型
  • 假若初步化时,全数剧情类型1致,择数组中保存的是该项目的剧情
  • 即便早先化时,全体剧情类型不相同样,择数组中保存的是 NSObject

//: array1 仅允许追加 String 类型的值
//array1.append(18)

var array2 = ["zhangsan", 18]
//: 在 Swift 中,数字可以直接添加到集合,不需要再转换成 `NSNumber`
array2.append(100)
//: 在 Swift 中,如果将结构体对象添加到集合,仍然需要转换成 `NSValue`
array2.append(NSValue(CGPoint: CGPoint(x: 10, y: 10)))
  • 数组的概念和实例化
  • 采纳 : 能够只定义数组的连串
  • 实例化以前不容许加多值
  • 使用 类型
    能够实例化二个空的数组

var array3: [String]
//: 实例化之前不允许添加值
//array3.append("laowang")
//: 实例化一个空的数组
array3 = [String]()
array3.append("laowang")
  • 数组的联合
  • 必须是一模同样类其余数组本事够联合
  • 支出中,日常数组中保存的靶子类型没有分裂的!

array3 += array1
//: 必须是相同类型的数组才能够合并,以下两句代码都是不允许的
//array3 += array2
//array2 += array3
  • 数组的去除

//: 删除指定位置的元素
array3.removeAtIndex(3)
//: 清空数组
array3.removeAll()
  • 内部存款和储蓄器分配
  • 假若向数组中加进成分,超越了容积,系统会大增适量的体量

var list = [Int]()

for i in 0...16 {
    list.append(i)
    print("添加 \(i) 容量 \(list.capacity)")
}

可选解包

  • 若果只是调用可选用的函数,而不须求参与总括,能够行使可选解包
  • 在可挑选后,使用 ? 然后再调用函数
  • 动用可选解包能够:
    • 1经有值,会取值,然后实施后续函数
    • 假使为 nil,不会实施此外函数

var optionValue: Int?
print(optionValue?.description)
// 输出 nil

optionValue = 10
print(optionValue?.description)
// 输出 Optional("10")

与野蛮解包比较,可选解包更安全,可是只好用来函数调用,而不可能用来总计

澳门葡京备用网址 1

可选解包

  • 比如只是调用可挑选的函数,而不须求加入总括,能够利用可选解包
  • 在可采用后,使用 ? 然后再调用函数
  • 选择可选解包能够:
  • 即使有值,会取值,然后试行后续函数
  • 假定为 nil,不会试行别的函数

var optionValue: Int?
print(optionValue?.description)
// 输出 nil

optionValue = 10
print(optionValue?.description)
// 输出 Optional("10")

与野蛮解包比较,可选解包更安全,可是只好用来函数调用,而不能够用来总结

澳门葡京备用网址 2

可选解包

  • 假若只是调用可挑选的函数,而不要求参加计算,能够利用可选解包
  • 在可挑选后,使用 ? 然后再调用函数
  • 采纳可选解包能够:
    • 如若有值,会取值,然后施行后续函数
    • 一旦为 nil,不会奉行其余函数

var optionValue: Int?
print(optionValue?.description)
// 输出 nil

optionValue = 10
print(optionValue?.description)
// 输出 Optional("10")

与野蛮解包相比,可选解包更安全,可是只可以用来函数调用,而不能够用于总结

澳门葡京备用网址 3

Paste_Image.png

字典

  • 定义
  • 如出壹辙使用 [] 定义字典
  • let 不可变字典
  • var 可变字典
  • [String : NSObject] 是最常用的字典类型

//: [String : NSObject] 是最常用的字典类型
var dict = ["name": "zhangsan", "age": 18]
  • 赋值

  • 赋值直接动用 dict[key] = value 格式

  • 一经 key 不设有,会安装新值

  • 若是 key 存在,会覆盖现成值

//: * 如果 key 不存在,会设置新值
dict["title"] = "boss"
//: * 如果 key 存在,会覆盖现有值
dict["name"] = "lisi"
dict
  • 遍历
  • k,v 能够不管写
  • 前方的是 key
  • 前边的是 value

//: 遍历
for (k, v) in dict {
    print("\(k) ~~~ \(v)")
}
  • 集结字典
  • 借使 key 不设有,会确立新值,不然会覆盖现存值

 - //: 合并字典
var dict1 = [String: NSObject]()
dict1["nickname"] = "大老虎"
dict1["age"] = 100

//: 如果 key 不存在,会建立新值,否则会覆盖现有值
for (k, v) in dict1 {
    dict[k] = v
}
print(dict)

澳门葡京备用网址,可选用判别

可挑选推断

可挑选判定

函数

不野蛮解包的章程

是因为可选拔的值或者为
nil,不容许直接参加运算,因而在事实上支出中,常常索要决断可挑选是不是有值。

1经单纯运用
if,会让代码嵌套等级次序很深,不宜阅读和体贴,为了消除这一标题,苹果提供了以下三种艺术:

  • ??
  • if let / var
  • guard let / var

不强行解包的点子

鉴于可选拔的值可能为
nil,不容许直接出席运算,因而在事实上耗费中,平日索要判别可挑选是还是不是有值。

一经仅仅运用
if,会让代码嵌套档期的顺序很深,不宜阅读和爱护,为了消除那1标题,苹果提供了以下二种方法:

  • ??
  • if let / var
  • guard let / var

不强行解包的不二等秘书技

出于可选用的值大概为
nil,不容许直接出席运算,由此在骨子里支出中,常常索要看清可接纳是还是不是有值。

若果单纯施用
if,会让代码嵌套等级次序很深,不宜阅读和维护,为了化解那1主题材料,苹果提供了以下二种办法:

  • ??
  • if let / var
  • guard let / var

目标

  • 左右函数的概念
  • 支配外部参数的用途
  • 左右无重回类型的二种函数定义格局

??

  • ?? 运算符能够用于判定可选拔是还是不是为 nil,假若是则利用后边的值代替

小心:?? 的优先级低,在行使时,应该注意利用 ()

let x: Int? = 10
let y: Int? = 100

print((x ?? 0) + (y ?? 0))

??

  • ?? 运算符可以用来决断可挑选是不是为 nil,借使是则选择后边的值代替

专注:?? 的预先级低,在选拔时,应该小心使用 ()

let x: Int? = 10
let y: Int? = 100

print((x ?? 0) + (y ?? 0))

??

  • ?? 运算符能够用于推断可挑选是还是不是为 nil,如果是则利用前边的值代替

留意:?? 的预先级低,在利用时,应该小心选取 ()

let x: Int? = 10
let y: Int? = 100

print((x ?? 0) + (y ?? 0))

代码完结

  • 函数的概念
  • 格式 func 函数名(行参列表) -> 再次回到值 {代码落成}
  • 调用 let result = 函数名(值1, 参数2: 值2…)

func sum(a: Int, b: Int) -> Int {
    return a + b
}

let result = sum(10, b: 20)
  • 尚无重回值的函数,1共有三种写法
  • 省略
  • ()
  • Void

func demo(str: String) -> Void {
    print(str)
}
func demo1(str: String) -> () {
    print(str)
}
func demo2(str: String) {
    print(str)
}

demo("hello")
demo1("hello world")
demo2("olleh")

if let / var

  • 使用 if let,1旦进入 if 分支,表示可选拔一定有值
  • 常量/变量的成效域仅在 {} 内部
  • 接纳 , 能够决断多个可挑选是或不是有值
  • 利用同名常量/变量,幸免双重起名的郁闷
  • 假如要在分层逻辑中期维修改值,能够接纳 var,常常选取 let

let name: String? = "Mike"
let age: Int? = 18

if let name = name,
    let age = age {
    print("\(name) 今年 \(age) 岁")
} else {
    print("姓名或者年龄为 nil")
}

if let / var

  • 利用 if let,一旦进入 if 分支,表示可选拔一定有值
  • 常量/变量的效用域仅在 {} 内部
  • 应用 , 能够推断四个可采用是还是不是有值
  • 运用同名常量/变量,制止重新起名的愤懑
  • 设若要在分层逻辑中期维修改值,能够应用 var,平日采纳 let

let name: String? = "Mike"
let age: Int? = 18

if let name = name,
    let age = age {
    print("\(name) 今年 \(age) 岁")
} else {
    print("姓名或者年龄为 nil")
}

if let / var

  • 运用 if let,壹旦进入 if 分支,表示可选用一定有值
  • 常量/变量的效能域仅在 {} 内部
  • 选用 , 能够判明八个可挑选是或不是有值
  • 动用同名常量/变量,制止双重起名的苦恼
  • 只要要在分层逻辑中修改值,能够动用 var,日常使用 let

let name: String? = "Mike"
let age: Int? = 18

if let name = name,
    let age = age {
    print("\(name) 今年 \(age) 岁")
} else {
    print("姓名或者年龄为 nil")
}

表面参数

  • 在形参名前再增添3个外表参数名,能够方便调用人士越来越好地理解函数的语义
  • 格式:func 函数名(外部参数名 格局参数名: 格局参数类型) ->
    重临值类型 { // 代码达成 }
  • Swift 2.0 中,默许第一个参数名省略

func sum1(num1 a: Int, num2 b: Int) -> Int {
    return a + b
}

sum1(num1: 10, num2: 20)

guard let / var

  • guard 是与 if let 相反的语法,斯维夫特 二.0 推出
  • guard 同样能够看清可挑选是不是有值
  • 多值决断使用 , 分隔
  • 如若开掘 nil,在 else 分支重临
  • 分层甘休后,全体的 常量/变量 都有值
  • 相比较 if let,guard 语法的道岔协会能省去1层
  • 例如要在三番五次逻辑中期维修改值,能够选取 var,平时使用 let

func demo(name: String?, age: Int?) {

    guard let name = name,
        let age = age else {
            print("姓名或者年龄为 nil")

            return
    }

    print("\(name) 今年 \(age) 岁")
}

demo(name: name, age: age)

guard let / var

  • guard 是与 if let 相反的语法,斯威夫特 贰.0 推出
  • guard 同样能够判别可挑选是还是不是有值
  • 多值决断使用 , 分隔
  • 若是开掘 nil,在 else 分支重回
  • 分层截止后,全部的 常量/变量 都有值
  • 相比较 if let,guard 语法的分层协会能省掉一层
  • 假设要在一而再逻辑中期维修改值,能够使用 var,日常选用 let

func demo(name: String?, age: Int?) {

    guard let name = name,
        let age = age else {
            print("姓名或者年龄为 nil")

            return
    }

    print("\(name) 今年 \(age) 岁")
}

demo(name: name, age: age)

guard let / var

  • guard 是与 if let 相反的语法,Swift 2.0 推出
  • guard 一样能够判明可挑选是不是有值
  • 多值推断使用 , 分隔
  • 倘使开采 nil,在 else 分支再次来到
  • 支行甘休后,全数的 常量/变量 都有值
  • 绝相比 if let,guard 语法的支行组织能省掉1层
  • 只要要在三番五次逻辑中修改值,能够运用 var,经常选用 let

func demo(name: String?, age: Int?) {

    guard let name = name,
        let age = age else {
            print("姓名或者年龄为 nil")

            return
    }

    print("\(name) 今年 \(age) 岁")
}

demo(name: name, age: age)

闭包

  • 与 OC 中的 Block
    类似,闭包主要用来异步操作实践到位后的代码回调,网络访问结果以参数的样式传递给调用方

  • 闭包类似于 OC 中的 Block

  • 预先定义好的代码

  • 在供给时施行

  • 能够看做参数字传送递

  • 能够有再次回到值

  • 带有 self 时必要留意循环引用

  • 闭包的概念

  • 概念1个函数

//: 定义一个 sum 函数
func sum(num1 num1: Int, num2: Int) -> Int {
    return num1 + num2
}
sum(num1: 10, num2: 30)

//: 在 Swift 中函数本身就可以当作参数被定义和传递
let mySum = sum
let result = mySum(num1: 20, num2: 30)
  • 概念1个闭包
  • 闭包 = { (行参) -> 返回值 in // 代码落成 }
  • in 用于区分函数定义和代码完结

//: 闭包 = { (行参) -> 返回值 in // 代码实现 }
let sumFunc = { (num1 x: Int, num2 y: Int) -> Int in
    return x + y
}
sumFunc(num1: 10, num2: 20)
  • 最简易的闭包,假设没有参数/重临值,则 参数/重返值/in 统统都得以省略

  • { 代码实现 }

let demoFunc = {
    print("hello")
}

guard let和if let能够用同名变量接收。

因为总会取名字,if let name =
name那样就能够,注意前边使用的时候用非空的十一分!并且iflet和guardlet能够依次判定,先推断是三个字典,再拿字典的数组,在认清数组的值,能够一条线判别出来。
澳门葡京备用网址 4

guard let和if let能够用同名变量接收。

因为总会取名字,if let name =
name那样就能够,注意前面使用的时候用非空的不胜!并且iflet和guardlet能够依次剖断,先判定是一个字典,再拿字典的数组,在认清数组的值,可以一条线判断出来。
澳门葡京备用网址 5

guard let和if let能够用同名变量接收。

因为总会取名字,if let name =
name那样就能够,注意前面使用的时候用非空的不胜!并且iflet和guardlet能够依次剖断,先判定是贰个字典,再拿字典的数组,在认清数组的值,能够一条线推断出来。

澳门葡京备用网址 6

基本使用

  • GCD 异步

  • 模仿在后台线程加载数据

func loadData() {
    dispatch_async(dispatch_get_global_queue(0, 0), { () -> Void in
        print("耗时操作 \(NSThread .currentThread())")
    })
}
  • 随行闭包,假使闭包是最终三个参数,能够用以下写法
    在意前后两段代码,} 的义务

func loadData() {
    dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
        print("耗时操作 \(NSThread .currentThread())")
    }
}
  • 闭包的简写,要是闭包中并未参数和再次来到值,能够回顾

func loadData() {
    dispatch_async(dispatch_get_global_queue(0, 0)) {
        print("耗时操作 \(NSThread .currentThread())")
    }
}
  • 自定义闭包参数,落成主线程回调

  • 丰盛尚无参数,未有再次来到值的闭包

override func viewDidLoad() {
    super.viewDidLoad()

  loadData {
     print("完成回调")
    }
}

// MARK: - 自定义闭包参数
func loadData(finished: ()->()) {

    dispatch_async(dispatch_get_global_queue(0, 0)) {
        print("耗时操作 \(NSThread.currentThread())")

        dispatch_sync(dispatch_get_main_queue()) {
            print("主线程回调 \(NSThread.currentThread())")

            // 执行回调
            finished()
        }
    }
}
  • 增加回调参数

override func viewDidLoad() {
    super.viewDidLoad()

    loadData4 { (html) -> () in
     print(html)
    }
}

/// 加载数据
/// 完成回调 - 传入回调闭包,接收异步执行的结果
func loadData4(finished: (html: String) -> ()) {

    dispatch_async(dispatch_get_global_queue(0, 0)) {
        print("加载数据 \(NSThread.currentThread())")

        dispatch_sync(dispatch_get_main_queue()) {
            print("完成回调 \(NSThread.currentThread())")

            finished(html: "<h1>hello world</h1>")
        }
    }
}

四、字符串

用String,是2个结构体,具有绝大大多NSString功用,帮忙直接遍历

(1)遍历:

func demo3() {

    // 字符串遍历(NSString不支持这么遍历)
    let str = "wowosnshi是"

    for s in str.characters {
        print(s)
    }
}

(2)长度:

// 返回指定编码对应的字节数,每个汉字三个字节
print(str.lengthOfBytes(using: .utf8))

// 返回真正字符串长度
print(str.characters.count)

(三)拼接:要留意可选项拼接不消除会带上Optional,剩下的都能够凑合,再也不用看StringWithFormat了

let name = "AA"

let age = 19

let title : String? = "sss"

print("\(name)\(age)\(title ?? "")")

(4)格式化:

  • 格式化成日期

let h = 8 , m = 10, s = 44

// OC中用stringWithFormat格式化日期,Swift中可以

let strDate = String(format: "%02d-%02d-%02d", h,m,s)

print(strDate)

(5)截取字符串:提出用NSStrin作中间转播,因为swift取串方法一直在改动

  • NSString方法

let str = "红红火火恍恍惚惚"

let strOC = str as NSString

strOC .substring(to: 1)

strOC.substring(with: NSMakeRange(0, 2))

四、字符串

用String,是三个结构体,具有绝大大多NSString功用,扶助直接遍历

(1)遍历:

func demo3() {

    // 字符串遍历(NSString不支持这么遍历)
    let str = "wowosnshi是"

    for s in str.characters {
        print(s)
    }
}

(2)长度:

// 返回指定编码对应的字节数,每个汉字三个字节
print(str.lengthOfBytes(using: .utf8))

// 返回真正字符串长度
print(str.characters.count)

(3)拼接:要注意可选项拼接不消除会带上Optional,剩下的都能够凑合,再也不用看StringWithFormat了

let name = "AA"

let age = 19

let title : String? = "sss"

print("\(name)\(age)\(title ?? "")")

(4)格式化:

  • 格式化成日期

let h = 8 , m = 10, s = 44

// OC中用stringWithFormat格式化日期,Swift中可以

let strDate = String(format: "%02d-%02d-%02d", h,m,s)

print(strDate)

(伍)截取字符串:提出用NSStrin作中间转播,因为swift取串方法一贯在改变

  • NSString方法

let str = "红红火火恍恍惚惚"

let strOC = str as NSString

strOC .substring(to: 1)

strOC.substring(with: NSMakeRange(0, 2))

四、字符串

用String,是二个结构体,具备绝大许多NSString效用,支持直接遍历

(1)遍历:

func demo3() {

    // 字符串遍历(NSString不支持这么遍历)
    let str = "wowosnshi是"

    for s in str.characters {
        print(s)
    }
}

(2)长度:

// 返回指定编码对应的字节数,每个汉字三个字节
print(str.lengthOfBytes(using: .utf8))

// 返回真正字符串长度
print(str.characters.count)

(三)拼接:要注意可选项拼接不消除会带上Optional,剩下的都得以凑合,再也不用看StringWithFormat了

let name = "AA"

let age = 19

let title : String? = "sss"

print("\(name)\(age)\(title ?? "")")

(4)格式化:

  • 格式化成日期

let h = 8 , m = 10, s = 44

// OC中用stringWithFormat格式化日期,Swift中可以

let strDate = String(format: "%02d-%02d-%02d", h,m,s)

print(strDate)

(伍)截取字符串:提出用NSStrin作中间转播,因为swift取串方法向来在转移

  • NSString方法

let str = "红红火火恍恍惚惚"

let strOC = str as NSString

strOC .substring(to: 1)

strOC.substring(with: NSMakeRange(0, 2))

循环引用

  • 建立 NetworkTools 对象

class NetworkTools: NSObject {

    /// 加载数据
    ///
    /// - parameter finished: 完成回调
    func loadData(finished: () -> ()) {
        print("开始加载数据...")

        // ...
        finished()
    }

    deinit {
        print("网络工具 88")
    }
}
  • 实例化 NetworkTools 并且加载数据

class ViewController: UIViewController {

    var tools: NetworkTools?

    override func viewDidLoad() {
     super.viewDidLoad()

        tools = NetworkTools()
        tools?.loadData() {
            print("come here \(self.view)")
        }
    }

    /// 与 OC 中的 dealloc 类似,注意此函数没有()
    deinit {
        print("控制器 88")
    }
}
  • 运作不会产生巡回引用,因为 loadData 实施完结后,就会放出对 self
    的引用
  • 修改 NetworkTools,定义回调闭包属性

/// 完成回调属性
var finishedCallBack: (()->())?

/// 加载数据
///
/// - parameter finished: 完成回调
func loadData(finished: () -> ()) {

    self.finishedCallBack = finished

    print("开始加载数据...")

    // ...
    working()
}

func working() {
    finishedCallBack?()
}

deinit {
    print("网络工具 88")
}
  • 运维测试,会出现循环引用

五、数组

(一)就是中括号,注意数组的类型,并且基本数据类型不须求包装,能够直接方数组里,尽管类型不1致(混合数组,可是基本不用),自动推导[NSObject]。在斯威夫特中还有三个[AnyObject类型],标示放4对象,因为在斯威夫特中1个类能够未有其余父类。

(2)遍历:

    // 遍历1(按照下标遍历)
    for i in 0..<array.count {


    }

    // 遍历2(遍历元素)
    for s in array {


    }

    // 遍历3(同时遍历下标和元素)
    for e in array.enumerated() {

        // let e: (offset: Int, element: String) e是一个元组        
        print("\(e.offset), \(e.element)")

    }

    // 遍历4(同时遍历下标和元素)
    for (n,s) in array.enumerated() {

        print("\(n),\(s)")

    }

    // 反序遍历
    for s in array.reversed() {


    }

    // 反序索引下标(这样写才对,先枚举再反序)
    for (n,s) in array.enumerated().reversed() {


    }

(3)增删改:

    array.append("AA")

    array[1] = "BBB"

    array.remove(at: 2)

(四)合并:用“+”号。但是要联合的数组的多个种类必须一律。

五、数组

(一)便是中括号,注意数组的项目,并且基本数据类型不必要包装,能够直接方数组里,假使类型不均等(混合数组,然则基本不用),自动推导[NSObject]。在斯威夫特中还有1个[AnyObject类型],标示自便对象,因为在Swift中四个类能够未有别的父类。

(2)遍历:

    // 遍历1(按照下标遍历)
    for i in 0..<array.count {


    }

    // 遍历2(遍历元素)
    for s in array {


    }

    // 遍历3(同时遍历下标和元素)
    for e in array.enumerated() {

        // let e: (offset: Int, element: String) e是一个元组        
        print("\(e.offset), \(e.element)")

    }

    // 遍历4(同时遍历下标和元素)
    for (n,s) in array.enumerated() {

        print("\(n),\(s)")

    }

    // 反序遍历
    for s in array.reversed() {


    }

    // 反序索引下标(这样写才对,先枚举再反序)
    for (n,s) in array.enumerated().reversed() {


    }

(3)增删改:

    array.append("AA")

    array[1] = "BBB"

    array.remove(at: 2)

(4)合并:用“+”号。然而要联合的数组的八个门类必须1致。

五、数组

(1)正是中括号,注意数组的档期的顺序,并且基本数据类型不供给包装,可以一向方数组里,要是类型不等同(混合数组,可是基本不用),自动推导[NSObject]。在Swift中还有3个[AnyObject类型],标示任性对象,因为在Swift中多个类能够未有其余父类。

(2)遍历:

    // 遍历1(按照下标遍历)
    for i in 0..<array.count {


    }

    // 遍历2(遍历元素)
    for s in array {


    }

    // 遍历3(同时遍历下标和元素)
    for e in array.enumerated() {

        // let e: (offset: Int, element: String) e是一个元组        
        print("\(e.offset), \(e.element)")

    }

    // 遍历4(同时遍历下标和元素)
    for (n,s) in array.enumerated() {

        print("\(n),\(s)")

    }

    // 反序遍历
    for s in array.reversed() {


    }

    // 反序索引下标(这样写才对,先枚举再反序)
    for (n,s) in array.enumerated().reversed() {


    }

(3)增删改:

    array.append("AA")

    array[1] = "BBB"

    array.remove(at: 2)

(4)合并:用“+”号。不过要联合的数组的三个体系必须1律。

解决循环引用

  • 与 OC 类似的主意

/// 类似于 OC 的解除引用
func demo() {
    weak var weakSelf = self
    tools?.loadData() {
        print("\(weakSelf?.view)")
    }
}
  • Swift 推荐的章程

loadData { [weak self] in
    print("\(self?.view)")
}
  • 还可以

loadData { [unowned self] in
    print("\(self.view)")
}

闭包(Block) 的巡回引用小结

  • Swift

  • [weak self]

    • self是可挑选,若是self已经被释放,则为nil
  • [unowned self]

    • self不是可采取,若是self已经被放走,则出现野指针访问
  • Objc

  • __weak typeof(self) weakSelf;

    • 壹旦self已经被假释,则为nil
  • __unsafe_unretained typeof(self) weakSelf;

    • 只要self已经被放飞,则产出野指针访问

六、字典

一般是[String:NSObject],对应键值对.由于三.0后大多数都以结构体了,AnyObject倒霉用了,Any范围越来越大
(一)字典数组:
(2)增加和删除改:和数组都接近,正是多个字典合并不像数组直接相加,而是须求遍历

六、字典

一般是[String:NSObject],对应键值对.由于3.0后许多都以结构体了,AnyObject不好用了,Any范围更加大
(壹)字典数组:
(2)增加和删除改:和数组都就好像,就是四个字典合并不像数组直接相加,而是要求遍历

六、字典

一般是[String:NSObject],对应键值对.由于三.0后半数以上都以结构体了,AnyObject倒霉用了,Any范围越来越大
(壹)字典数组:
(二)增加和删除改:和数组都类似,便是八个字典合并不像数组直接相加,而是须求遍历

七、函数

(1)外部参数,当外部参数用_代表的时候,会在外部调用的时候忽略形参名
澳门葡京备用网址 7

(二)函数的暗中同意值(OC不富有),这些使斯维夫特比OC灵活许多众多,多少个主意能够做过多事,因为OC会有各样参数和烧结,Swift只需写一个最多的参数,然后不供给的设定私下认可值正是了

澳门葡京备用网址 8

(叁)无重临值 :直接省略 () Void都足以

(四)闭包:类似Block,比Block还遍布。OC中Block是佚名函数,Swift中等高校函授数是独特的闭包。闭包在一切开垦如月Block的选取场景一样。用于调节器/自定义视图/异步推行到位的回调。这几个回调的风味即是都以以参数回调解和管理理结果,重临值为Void。

  • 定义:

   let biBao = { (x: Int) -> Int in
            
       return x + 100
   }
        
   print(biBao(10))
  • GCD:将义务加多到行列,钦定施行义务的函数。任务正是Block/闭包,队列以二只/异步的点子实行。

 func loadData(compeletion:@escaping ( _ result: [String])->()) -> Void {                  DispatchQueue.global().async {                          print("耗时操作会获得一些结果 \(Thread.current)")                          Thread.sleep(forTimeInterval: 1.0)                          let json = ["天气","不错","刮大风"]                          // 主线程回调             DispatchQueue.main.async(execute: {                                  print("主线程更新UI \(Thread.current)")                                  // 回调 -> 通过参数传递 执行闭包                 compeletion(json)             })         }         }

调用:

        // 执行的适合我就拿到了值
        loadData { (result) in
            
            print("获取的新闻数据 \(result)")
        }
  • 尾随闭包:假诺函数的尾声叁个参数是闭包,那么参数就大致了,最后三个参数直接{}大括号包装

  • 闭包的轮回引用:

澳门葡京备用网址 9
        

澳门葡京备用网址 10

(5)面向对象(各类构造函数):()正是allocInit,在斯威夫特中对应init()。在swift中一个类型所有类都以共享的,可以直接访问,每1个类都私下认可有2个命名空间。A.name
B.name God.name
Dog.name。同一个类能够从属于分化的命名空间(即使有多个框架有Person类,做用户,还有八个框架做后台,也用Person。在OC中就只好靠前缀消除,HouTaiPerson,KuangJiaPerson。而Swift中的命名空间便是类小名。AAA项目有多少个Person,那么AAA.Person正是AAA的Person类,此时再导入框架,那也是框架的.Person)
澳门葡京备用网址 11
 

  • 在自定义的Nsobjiect类中,has no
    initalizers 标示未有起初化器,初步化器能够有多少个,暗中认可是init。当以此类有总体性的时候,属性要分配内部存款和储蓄器空间,正是说要有初叶值。那么实际上就是先给本人的性质分配,然后给父开头。其实这么1看,Swift和OC是倒转的!

澳门葡京备用网址 12

思路:OC是先调用父亲。正是Person,Person会再调用NSObject,便是先跑上去什么都不管,先开始化了NSObject,然后才往下走挨个发轫化。斯维夫特是把本人完全初步化,再上去起初化老爸,这么看比OC快了一圈,品质要好。

澳门葡京备用网址 13

  • 重载构造函数:(重写是父类有这几个办法,override。重载是函数名一样,参数和个数不相同。init就重写,init+参数就重载。OC是平素不重载的!都是initWithXXXXX)。重载其实是最中央的格局,OC未有实际很low,不过斯维夫特有。

澳门葡京备用网址 14
专注:倘若重载了构造函数并且未有得以达成父类的init,那么系统不再提供init构造函数了(默许是某些),因为暗中同意的构造函数无法给本类的习性分配空间(你不协和写name = ,系统就不能分配)
 

  • KVC构造函数:只需记住下边四点
    澳门葡京备用网址 15
    之所以一般在模型中加个? 然后用KVC落成(先调用init因为是运作时机制)

  • 模型中属性定义:基本数据类型 = 0,对象设置?
    运作时中,基本类型设置?   
    属性设置个人都会让运转时拿不到,此时kvc就会出错。
    澳门葡京备用网址 16

  • 如若子类未有重写父类方法,调用的时候就会向来调用父类的点子。当承袭一个类,就持续全体属性和形式,包蕴KVC。当PE福睿斯SON写好了KVC后,
  • 整体
    澳门葡京备用网址 17
    (6)便利构造函数:关键字Convenience(开拓用的很少,因为模型都以框架转,UI不需求有利)
    *指标:条件判别,唯有满意条件才实例化对象,制止不必要的内部存款和储蓄器耗费,简化对象创造。本身是不承担属性的创导和开始化的。
     
    澳门葡京备用网址 18

 
  
(7)deinit:类似OC的Dealloc
澳门葡京备用网址 19

七、函数

(一)外部参数,当外部参数用_替代的时候,会在表面调用的时候不经意形参名
澳门葡京备用网址 20

(二)函数的默许值(OC不具有),这些使斯威夫特比OC灵活多数浩大,三个措施能够做过多事,因为OC会有各类参数和重组,斯威夫特只需写2个最多的参数,然后不供给的设定暗中同意值正是了

澳门葡京备用网址 21

(3)无重返值 :直接省略 () Void都能够

(4)闭包:类似Block,比Block还普及。OC中Block是无名氏函数,Swift中函数是新鲜的闭包。闭包在全部开拓卯月Block的利用场景一样。用于调整器/自定义视图/异步实践到位的回调。这个回调的特色正是都以以参数回调解和管理理结果,再次回到值为Void。

  • 定义:

       let biBao = { (x: Int) -> Int in
                
           return x + 100
       }
            
       print(biBao(10))
    
  • GCD:将职责增添到行列,钦命推行职责的函数。职责就是Block/闭包,队列以协同/异步的秘诀推行。

 func loadData(compeletion:@escaping ( _ result: [String])->()) -> Void {                  DispatchQueue.global().async {                          print("耗时操作会获得一些结果 \(Thread.current)")                          Thread.sleep(forTimeInterval: 1.0)                          let json = ["天气","不错","刮大风"]                          // 主线程回调             DispatchQueue.main.async(execute: {                                  print("主线程更新UI \(Thread.current)")                                  // 回调 -> 通过参数传递 执行闭包                 compeletion(json)             })         }         }

调用:

        // 执行的适合我就拿到了值
        loadData { (result) in
            
            print("获取的新闻数据 \(result)")
        }
  • 紧跟着闭包:假若函数的结尾三个参数是闭包,那么参数就归纳了,尾数参数直接{}大括号包装

  • 闭包的巡回引用:

澳门葡京备用网址 22
        

澳门葡京备用网址 23

(伍)面向对象(各个构造函数):()正是allocInit,在Swift中对应init()。在swift中八个项目全体类都以共享的,可以直接待上访问,每三个类都默许有叁个命名空间。A.name
B.name God.name
Dog.name。同1个类能够从属于差异的命名空间(要是有三个框架有Person类,做用户,还有贰个框架做后台,也用Person。在OC中就只好靠前缀消除,HouTaiPerson,KuangJiaPerson。而斯维夫特中的命名空间就是体系名。AAA项目有3个Person,那么AAA.Person就是AAA的Person类,此时再导入框架,那也是框架的.Person)
澳门葡京备用网址 24
 

  • 在自定义的Nsobjiect类中,has no
    initalizers 标示未有开首化器,开始化器能够有多少个,暗中同意是init。当以此类有总体性的时候,属性要分配内部存款和储蓄器空间,正是说要有初始值。那么实际上正是先给自个儿的性质分配,然后给父伊始。其实这么一看,斯威夫特和OC是倒转的!

澳门葡京备用网址 25

思路:OC是先调用父亲。正是Person,Person会再调用NSObject,正是先跑上去什么都不管,先初阶化了NSObject,然后才往下走挨个开端化。斯维夫特是把温馨完全初步化,再上去初步化老爸,这么看比OC快了①圈,质量要好。

澳门葡京备用网址 26

  • 重载构造函数:(重写是父类有那些办法,override。重载是函数名同样,参数和个数分歧。init就重写,init+参数就重载。OC是尚未重载的!都是initWithXXXXX)。重载其实是最基本的办法,OC未有实际很low,不过斯威夫特有。

澳门葡京备用网址 27
瞩目:借使重载了构造函数并且未有落到实处父类的init,那么系统不再提供init构造函数了(私下认可是部分),因为默许的构造函数不可能给本类的性质分配空间(你不和煦写name = ,系统就不能够分配)
 

  • KVC构造函数:只需记住下边四点
    澳门葡京备用网址 28
    所以一般在模型中加个? 然后用KVC达成(先调用init因为是运作时机制)

  • 模型中属性定义:基本数据类型 = 0,对象设置?
    运转时中,基本类型设置?   
    属性设置个人都会让运转时拿不到,此时kvc就会出错。
    澳门葡京备用网址 29

  • 比如子类未有重写父类方法,调用的时候就会直接调用父类的不二等秘书技。当承接八个类,就一连全部属性和章程,包蕴KVC。当PE兰德酷路泽SON写好了KVC后,
  • 整体
    澳门葡京备用网址 30
    (6)便利构造函数:关键字Convenience(开垦用的很少,因为模型都以框架转,UI不须求有利)
    *目标:条件决断,唯有满意条件才实例化对象,防止不须求的内部存款和储蓄器费用,简化对象创造。本人是不担当属性的创制和发轫化的。
     
    澳门葡京备用网址 31

 
  
(7)deinit:类似OC的Dealloc
澳门葡京备用网址 32

七、函数

(一)外部参数,当外部参数用_替代的时候,会在表面调用的时候不经意形参名

澳门葡京备用网址 33

(二)函数的默许值(OC不抱有),这么些使Swift比OC灵活多数过多,三个方法能够做过多事,因为OC会有各样参数和烧结,Swift只需写二个最多的参数,然后不要求的设定暗中认可值正是了

澳门葡京备用网址 34

(三)无再次回到值 :间接省略 () Void都得以

(肆)闭包:类似Block,比Block还布满。OC中Block是佚名函数,斯维夫特中等高校函授数是独特的闭包。闭包在一切开拓春季Block的选择场景一样。用于调控器/自定义视图/异步试行到位的回调。那么些回调的性状就是都是以参数回调解和管理理结果,重回值为Void。

  • 定义:

   let biBao = { (x: Int) -> Int in

       return x + 100
   }

   print(biBao(10))
  • GCD:将义务加多到行列,钦点推行任务的函数。任务正是Block/闭包,队列以联合/异步的艺术进行。

   func loadData(compeletion:@escaping ( _ result: [String])->()) -> Void {

       DispatchQueue.global().async {

           print("耗时操作会获得一些结果 \(Thread.current)")

           Thread.sleep(forTimeInterval: 1.0)

           let json = ["天气","不错","刮大风"]

           // 主线程回调
           DispatchQueue.main.async(execute: {

               print("主线程更新UI \(Thread.current)")

               // 回调 -> 通过参数传递 执行闭包
               compeletion(json)
           })
       }

   }

调用:

        // 执行的适合我就拿到了值
        loadData { (result) in

            print("获取的新闻数据 \(result)")
        }
  • 跟随闭包:假设函数的末尾3个参数是闭包,那么参数就大致了,最终一个参数直接{}大括号包装

  • 闭包的循环引用:

澳门葡京备用网址 35

方法1

澳门葡京备用网址 36

方法2

(5)面向对象(各样构造函数):()就是allocInit,在Swift中对应init()。在swift中二个体系全数类都是共享的,能够向来访问,每多少个类都默许有三个命名空间。A.name
B.name God.name
Dog.name。同二个类能够从属于分化的命名空间(就算有二个框架有Person类,做用户,还有1个框架做后台,也用Person。在OC中就只好靠前缀化解,HouTaiPerson,KuangJiaPerson。而斯威夫特中的命名空间正是项目名。AAA项目有1个Person,那么AAA.Person便是AAA的Person类,此时再导入框架,那也是框架的.Person)

澳门葡京备用网址 37

  • 在自定义的Nsobjiect类中,has no initalizers
    标示未有开端化器,起先化器能够有四个,默许是init。当以此类有质量的时候,属性要分配内部存储器空间,正是说要有开端值。那么实际上就是先给协和的本性分配,然后给父初阶。其实这么一看,Swift和OC是相反的!

澳门葡京备用网址 38

思路:OC是先调用父亲。正是Person,Person会再调用NSObject,正是先跑上去哪边都不管,先开端化了NSObject,然后才往下走挨个初叶化。斯威夫特是把自身全然伊始化,再上去开首化老爸,这么看比OC快了一圈,品质要好。

澳门葡京备用网址 39

  • 重载构造函数:(重写是父类有其一点子,override。重载是函数名一样,参数和个数分歧。init就重写,init+参数就重载。OC是一贯不重载的!都是initWithXXXXX)。重载其实是最宗旨的措施,OC未有实际很low,不过Swift有。

澳门葡京备用网址 40

专注:固然重载了构造函数并且未有得以完成父类的init,那么系统不再提供init构造函数了(默许是有些),因为私下认可的构造函数不可能给本类的性质分配空间(你不团结写name
= ,系统就不能分配)

  • KVC构造函数:只需记住上面4点

    澳门葡京备用网址 41

**所以一般在模型中加个?
然后用KVC实现(先调用init因为是运行时机制)**
  • 模型中属性定义:基本数据类型 = 0,对象设置?
    运维时中,基本类型设置?
    属性设置个人都会让运营时拿不到,此时kvc就会出错。
![](https://upload-images.jianshu.io/upload_images/1868951-0e8c14816279da28.png)
  • 若是子类未有重写父类方法,调用的时候就会一贯调用父类的措施。当承袭一个类,就继续全数属性和办法,包蕴KVC。当PE冠道SON写好了KVC后,

  • 整体

![](https://upload-images.jianshu.io/upload_images/1868951-722a51e523596920.png)



(6)便利构造函数:关键字Convenience(开发用的很少,因为模型都是框架转,UI不需要便利)  
\*目的:条件判断,只有满足条件才实例化对象,防止不必要的内存开销,简化对象创建。本身是不负责属性的创建和初始化的。

澳门葡京备用网址 42

(7)deinit:类似OC的Dealloc

澳门葡京备用网址 43

八、分类:extension

福利构造函数 + 分类能够简轻便单抽出多数代码。比方给UITextField/UIButton写分类,然后写便利构造函数,方便。

八、分类:extension

有利构造函数 + 分类能够轻巧抽取多数代码。举例给UITextField/UIButton写分类,然后写便利构造函数,方便。

八、分类:extension

方便人民群众构造函数 +
分类能够总结抽出大多代码。举个例子给UITextField/UIButton写分类,然后写便利构造函数,方便。

九、Swift的类,结构体,枚举两种都有构造函数,都能够有主意,就如OC的类

九、斯维夫特的类,结构体,枚举三种都有构造函数,都能够有点子,就像是OC的类

九、Swift的类,结构体,枚举两种都有构造函数,都足以有法子,就像OC的类

十、其它

十、其它

十、其它

懒加载:

在OC开采中,懒加载一般自定义控件。在Swift中,懒加载依然供给用的,可以保险控件延迟制造,仍是能够幸免管理控件解包。借使间接定义控件var
label =
UILabel,根据代码从上到下,会让控件在ViewDidLad在此以前就提前创制了。所以必要懒加载。OC中懒加载就是Get方法,Swift直接lazy var。当然也能够private lazy var来限制功能域。

(一)轻易的懒加载:
澳门葡京备用网址 44

(2)完整的懒加载:()正是函数推行,正是贰个极度的闭包,所以懒加载本质是贰个闭包。一般不这么写。
澳门葡京备用网址 45
  
(3)OC和Swift区别

  • OC:

- (UILabel *)label{
    //如果label等于nil就会创建!
    if (_label == nil) {
        _label = [[UILabel alloc]init];
        _label.text = @"loirou";
        [_label sizeToFit];
        _label.center = self.view.center;
    }
    return _label;
}

OC是相等nil时候就懒加载

    [self.view addSubview:self.label];
    //释放label
    _label = nil;

    //会再次调用懒加载的代码
    NSLog(@"%@",self.label);

当label设nil的时候就在此调用。在ios陆中,didReceiveMemoryWarning是不清理视图的。
 
 

  • Swift:

澳门葡京备用网址 46
此刻自由的时候就会报错。因为定义的时候未有?,正是自然有值得。
那么壹旦定义时候加? 1旦label = nil,也不会在推行懒加载了!因为懒加载根本没写假若是空就创办。
懒加载只会在率先次调用的时候实施闭包。Swift中自然注意不要主动清理视图或控件,因为懒加载不会创造了(例如内部存款和储蓄器警告别干掉控件,干掉了在也用不成了,因为懒加载就一遍)

懒加载:

在OC开垦中,懒加载一般自定义控件。在斯维夫特中,懒加载仍旧必要用的,能够确认保证控件延迟创立,还是可以制止管理控件解包。借使直白定义控件var
label =
UILabel,依照代码从上到下,会让控件在ViewDidLad在此之前就提前创设了。所以需求懒加载。OC中懒加载正是Get方法,斯维夫特直接lazy var。当然也能够private lazy var来界定效用域。

(一)简单的懒加载:
澳门葡京备用网址 47

(贰)完整的懒加载:()正是函数试行,正是一个特出的闭包,所以懒加载本质是多少个闭包。一般不这么写。
澳门葡京备用网址 48
  
(3)OC和Swift区别

  • OC:

- (UILabel *)label{
    //如果label等于nil就会创建!
    if (_label == nil) {
        _label = [[UILabel alloc]init];
        _label.text = @"loirou";
        [_label sizeToFit];
        _label.center = self.view.center;
    }
    return _label;
}

OC是相等nil时候就懒加载

    [self.view addSubview:self.label];
    //释放label
    _label = nil;

    //会再次调用懒加载的代码
    NSLog(@"%@",self.label);

当label设nil的时候就在此调用。在ios陆中,didReceiveMemoryWarning是不清理视图的。
 
 

  • Swift:

澳门葡京备用网址 49
那会儿假释的时候就会报错。因为定义的时候未有?,正是一定有值得。
那么一旦定义时候加? 壹旦label = nil,也不会在施行懒加载了!因为懒加载根本没写如若是空就创办。
懒加载只会在首先次调用的时候推行闭包。Swift中势必留神不要主动清理视图或控件,因为懒加载不会成立了(比方内部存款和储蓄器警送别干掉控件,干掉了在也用不成了,因为懒加载就2回)

懒加载:

在OC开拓中,懒加载一般自定义控件。在斯威夫特中,懒加载依旧必要用的,能够确认保证控件延迟创设,还能防止处理控件解包。如若直接定义控件var
label =
UILabel,依据代码从上到下,会让控件在ViewDidLad在此以前就提前创设了。所以要求懒加载。OC中懒加载便是Get方法,斯维夫特直接lazy
var。当然也得以private lazy var来限制作用域。

(1)轻易的懒加载:

澳门葡京备用网址 50

(二)完整的懒加载:()便是函数实践,便是三个奇特的闭包,所以懒加载本质是一个闭包。一般不这么写。

澳门葡京备用网址 51

  
(3)OC和Swift区别

  • OC:

- (UILabel *)label{
    //如果label等于nil就会创建!
    if (_label == nil) {
        _label = [[UILabel alloc]init];
        _label.text = @"loirou";
        [_label sizeToFit];
        _label.center = self.view.center;
    }
    return _label;
}

OC是相等nil时候就懒加载

    [self.view addSubview:self.label];
    //释放label
    _label = nil;

    //会再次调用懒加载的代码
    NSLog(@"%@",self.label);

当label设nil的时候就在此调用。在ios6中,didReceiveMemoryWarning是不清理视图的。

  • Swift:

澳门葡京备用网址 52

此时获释的时候就会报错。因为定义的时候从不?,正是毫无疑问有值得。
那正是说一旦定义时候加? 一旦label =
nil,也不会在试行懒加载了!因为懒加载根本没写假使是空就创办。
懒加载只会在首先次调用的时候实行闭包。Swift中必然注意不要主动清理视图或控件,因为懒加载不会创设了(举个例子内部存款和储蓄器警告辞干掉控件,干掉了在也用不成了,因为懒加载就二遍)

总括型属性(只读):

(一)getter/setter(开辟不用):
 

    // 开发一般不用,还给搞一个_name。
    // swift一般不会重写getter和setter
    private var _name: String? // 假装的一个值
    var name: String? { get{return _name}  set{_name = newValue}} // get返回成员变量 set记录成员变量

    override func viewDidLoad() {
        super.viewDidLoad()

        demo()
    }

}

(二)总结型属性:readOnly只读:OC中重写get。Swift也是重写get,不管set就足以。
 

  // 只读,此时set赋值时候就会报错
   var name: String? { get{return "ABC"}}
  // 还有一种简写:
   var name: String? { return "ABC"}

看那类属性,是本身不保留内容的,都以经过测算得到结果。就能够当自身正是个未有参数唯有重临值的函数!!笔者每一次return值给你本身的任务就完了了。每一遍你调用作者这些个性的时候,笔者都会议及展览开一次计算!都会举行小编的代码然后return给你。我本人不存款和储蓄的。
 
(三)懒加载和总计型属性的界别:
澳门葡京备用网址 53

(四)存款和储蓄型属性:需求开拓空间,存款和储蓄数据。一般的性质都是存款和储蓄型属性(懒加载)

(五)存款和储蓄和总结都得以?也许不加。看景况是还是不是必选

(四)斯威夫特中装置模型数据:
斯维夫特做好模型后。别的控件拿到模型后,由视图自个儿来展现。此时在didSet里写。正是顶替OC的Setter方法。(OC的Setter要思虑_分子变量 = 值,而且一旦是copy须求.copy,而斯维夫特不必要考虑任何)

总计型属性(只读):

(一)getter/setter(开采不用):
 

    // 开发一般不用,还给搞一个_name。
    // swift一般不会重写getter和setter
    private var _name: String? // 假装的一个值
    var name: String? { get{return _name}  set{_name = newValue}} // get返回成员变量 set记录成员变量

    override func viewDidLoad() {
        super.viewDidLoad()

        demo()
    }

}

(二)总结型属性:readOnly只读:OC中重写get。斯威夫特也是重写get,不管set就足以。
 

  // 只读,此时set赋值时候就会报错
   var name: String? { get{return "ABC"}}
  // 还有一种简写:
   var name: String? { return "ABC"}

看那类属性,是自己不保留内容的,都以因此测算得到结果。就可以当本人正是个尚未参数唯有再次来到值的函数!!笔者每一次return值给你自个儿的职务就落成了。每一次你调用作者这特性格的时候,笔者都会张开贰回计算!都会进行我的代码然后return给您。笔者本人不存款和储蓄的。
 
(三)懒加载和计算型属性的分别:
澳门葡京备用网址 54

(四)存款和储蓄型属性:须要开荒空间,存款和储蓄数据。一般的品质都以存款和储蓄型属性(懒加载)

(5)存款和储蓄和测算都足以?只怕不加。看意况是否必选

(四)斯威夫特中安装模型数据:
Swift做好模型后。别的控件得到模型后,由视图本身来展现。此时在didSet里写。就是顶替OC的Setter方法。(OC的Setter要牵挂_成员变量 = 值,而且若是是copy须要.copy,而Swift不须求思考1切)

总计型属性(只读):

(一)getter/setter(开拓不用):

    // 开发一般不用,还给搞一个_name。
    // swift一般不会重写getter和setter
    private var _name: String? // 假装的一个值
    var name: String? { get{return _name}  set{_name = newValue}} // get返回成员变量 set记录成员变量

    override func viewDidLoad() {
        super.viewDidLoad()

        demo()
    }

}

(二)总计型属性:readOnly只读:OC中重写get。Swift也是重写get,不管set就足以。

  // 只读,此时set赋值时候就会报错
   var name: String? { get{return "ABC"}}
  // 还有一种简写:
   var name: String? { return "ABC"}

看那类属性,是自家不保留内容的,都是透过测算获得结果。就足以当小编正是个没有参数唯有再次回到值的函数!!小编老是return值给您自己的职务就产生了。每一趟你调用小编这么些特性的时候,作者都会进展一遍总括!都会施行笔者的代码然后return给您。小编自家不存款和储蓄的。

(3)懒加载和总计型属性的区别:

澳门葡京备用网址 55

(四)存款和储蓄型属性:需求开拓空间,存款和储蓄数据。一般的质量都以存款和储蓄型属性(懒加载)

(伍)存款和储蓄和计量都得以?也许不加。看状态是还是不是必选

(四)斯威夫特中设置模型数据:
Swift做好模型后。别的控件得到模型后,由视图本人来展现。此时在didSet里写。即是代表OC的Setter方法。(OC的Setter要思量_分子变量
= 值,而且假使是copy必要.copy,而Swift不要求考虑壹切)

取名空间:

  • 在同三个上空(项目),全局共享。用第1方时,要是间接拖拽,这就从属于叁个空间,很有极大希望争执,所以用Cocopod
  • 动态得到命名空间(从info.plist加载),命名空间和项目名称有关系。info的Bundle name其实正是命名空间(一般写的很奇怪 #(ProdectNmae))。
    打印info
    print(Bundle.main.infoDictionary)
     澳门葡京备用网址 56

赋值

// 获取命名空间的值,可选 let str = 
Bundle.main.infoDictionary?["CFBundleName"] as? String ?? ""                  
let con = NSClassFromString(str + "." + "ViewController") as? UIViewController.Type

命名空间:

  • 在同3个空间(项目),全局共享。用第3方时,要是直接拖拽,那就从属于3个空间,很有相当的大概率争辩,所以用Cocopod
  • 动态获得命名空间(从info.plist加载),命名空间和项目名称有提到。info的Bundle name其实正是命名空间(一般写的很诡异 #(ProdectNmae))。
    打印info
    print(Bundle.main.infoDictionary)
     澳门葡京备用网址 57

赋值

// 获取命名空间的值,可选 let str = 
Bundle.main.infoDictionary?["CFBundleName"] as? String ?? ""                  
let con = NSClassFromString(str + "." + "ViewController") as? UIViewController.Type

命名空间:

  • 在同一个空中(项目),全局共享。用第3方时,要是向来拖拽,这就从属于2个上空,很有十分大可能争执,所以用Cocopod
  • 动态获得命名空间(从info.plist加载),命名空间和项目名称有关联。info的Bundle
    name其实正是命名空间(一般写的很奇异 #(ProdectNmae))。
    打印info
    print(Bundle.main.infoDictionary)
![](https://upload-images.jianshu.io/upload_images/1868951-f0870f71a52c609a.png)

赋值

// 获取命名空间的值,可选 let str = 
Bundle.main.infoDictionary?["CFBundleName"] as? String ?? ""                  
let con = NSClassFromString(str + "." + "ViewController") as? UIViewController.Type

反射机制:

对此别的类都得以清楚类的全数属性和章程,对于其他对象都能够调用任何性质和艺术,那种动态获取的消息和动态调用对象属性方法的意义成java的反射机制(斯威夫特也有了)

(一)在OC中选用反射机制

  • 利用NSClassFromString办法来利用字符串获取类
  • 利用isMemberOfClass判别是不是是某2个类
  • 利用isKindOfClass认清是不是是某二个类的子类
  • 利用conformsToProtocol剖断目的是或不是遵循某一个磋商
  • 利用respondsToSelector判别是还是不是落到实处了某2个主意
  • 利用performSelector或者objc_msgSend间接调用方法

(二)在斯维夫特中使用反射机制就像是。职业中用的成都百货上千众多。
此情此景:AppDelegate(OC中也用过,利用NSClassFromString获得类,然后设置根调控器。可是斯威夫特中多了二个命名空间写法。)
 

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

    window = UIWindow(frame: UIScreen.main.bounds)

    // 依据String名字拿到控制器(添加项目名称,命名空间,不能有数字和特殊符号)
    // 返回的是AnyClass? 需要as?强转
    // 控制器添加Type类型
    let rootControl = NSClassFromString("SwiftyDemo.ViewController") as? UIViewController.Type

    let vc = rootControl?.init()

    window?.rootViewController = vc

    window?.makeKeyAndVisible()

    return true
}

 
(三)第一方框架,用了无数反光机制和工厂方法,为了贯彻大气的解耦和包装,很勤奋。2个主意也许跳拾3个办法十一个调节器才写了四个加法。可是若是涉及高档开荒和包装,必供给经过这一步。

反射机制:

对此别的类都得以通晓类的全部属性和章程,对于别的对象都能够调用任何性质和艺术,那种动态获取的音信和动态调用对象属性方法的效果成java的反射机制(Swift也有了)

(壹)在OC中动用反射机制

  • 利用NSClassFromString办法来行使字符串获取类
  • 利用isMemberOfClass判定是还是不是是某贰个类
  • 利用isKindOfClass判断是或不是是某多个类的子类
  • 利用conformsToProtocol决断目的是还是不是坚守某1个共谋
  • 利用respondsToSelector认清是不是完成了某叁个办法
  • 利用performSelector或者objc_msgSend直接调用方法

(贰)在斯威夫特中利用反射机制就如。工作中用的洋洋过多。
情景:AppDelegate(OC中也用过,利用NSClassFromString得到类,然后设置根调控器。不过Swift中多了3个命名空间写法。)
 

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

    window = UIWindow(frame: UIScreen.main.bounds)

    // 依据String名字拿到控制器(添加项目名称,命名空间,不能有数字和特殊符号)
    // 返回的是AnyClass? 需要as?强转
    // 控制器添加Type类型
    let rootControl = NSClassFromString("SwiftyDemo.ViewController") as? UIViewController.Type

    let vc = rootControl?.init()

    window?.rootViewController = vc

    window?.makeKeyAndVisible()

    return true
}

 
(三)第一方框架,用了多数反光机制和工厂方法,为了落到实处大气的解耦和包裹,很劳碌。一个办法恐怕跳11个办法十二个调整器才写了一个加法。然而壹旦涉及高档开采和打包,须要求透过这一步。

反射机制:

对此别的类都能够知道类的持有属性和章程,对于任何对象都能够调用任何性质和形式,那种动态获取的音讯和动态调用对象属性方法的效益成java的反射机制(Swift也有了)

(一)在OC中采纳反射机制

  • 利用NSClassFromString办法来使用字符串获取类
  • 利用isMemberOfClass看清是还是不是是某贰个类
  • 利用isKindOfClass看清是还是不是是某一个类的子类
  • 利用conformsToProtocol判别目的是否遵从某3个研商
  • 利用respondsToSelector决断是不是得以达成了某三个主意
  • 利用performSelector或者objc_msgSend直接调用方法

(二)在Swift中央银行使反射机制就像是。工作中用的大队人马众多。
情景:AppDelegate(OC中也用过,利用NSClassFromString得到类,然后设置根调整器。不过斯维夫特中多了1个命名空间写法。)

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

    window = UIWindow(frame: UIScreen.main.bounds)

    // 依据String名字拿到控制器(添加项目名称,命名空间,不能有数字和特殊符号)
    // 返回的是AnyClass? 需要as?强转
    // 控制器添加Type类型
    let rootControl = NSClassFromString("SwiftyDemo.ViewController") as? UIViewController.Type

    let vc = rootControl?.init()

    window?.rootViewController = vc

    window?.makeKeyAndVisible()

    return true
}

(3)第二方框架,用了无尽反光机制和工厂方法,为了促成大气的解耦和包裹,很辛勤。贰个格局只怕跳11个措施11个调整器才写了贰个加法。可是只要涉嫌高端开辟和打包,供给求由此这一步。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website