1小时入门Swift语法

Swift

简介

Swift 语言由苹果公司在 2014 年推出，用来撰写 OS X 和 iOS 应用程序
2014 年，在 Apple WWDC 发布

特点

从它的语法中能看到Objective-C、JavaScript、C#、Python等语言的影子
语法简单、代码简洁、使用方便
- 可与Objective-C混合使用（相互调用）
- 提供了类似 Java 的名字空间(namespace)、泛型(generic)、运算对象重载（operator overloading）
- 可选绑定、可选类型、类型推导
为什么设计Swift语言
- 让应用开发更简单、更快、更稳定
- 确保最终应用有着更好的质量

历史

2010 年 7 月，苹果开发者工具部门总监 Chris Lattner,开始着手 Swift 编程语言的设计工作
用一年时间，完成基本架构
Swift 大约历经 4 年的开发期，2014 年 6 月发表

Chris Lattner

克里斯·拉特纳何许人?

LLVM 项目的主要发起人与作者之一
Clang 编译器的作者
苹果公司『开发者工具』部门的主管
领导Xcode、Instruments和编译器团队
Swift的大部分基础架构均由他1人完成
评价:
- 大神中的大神
- 牛逼中的牛逼

Playground是什么?

从Xcode6开始出现(Swift开始出现)
翻译为:操场/游乐场
对于学习Swift基本语法非常方便
所见即所得(快速查看结果)
语法特性发生改变时,可以快速查看.
Swift最基本的语法变化
- 导入框架 import UIKit
- 定义标识符时，必须声明该标识符是变量还是常量
  - 声明标识符的格式:变量/常量关键字名称 : 数据类型
- 语句结束时不需要加;
  - 如果同一行有多个语句,则依然需要加
  - 但是不建议一行多条语句
- Swift中的打印语句:print(打印的内容)

什么是常量和变量

在Swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量
使用let来定义常量,定义之后不可以修改
使用var来定义变量,定义之后可以修改

常量和变量的使用注意:

注意:
- 是指向的对象不可以再进行修改.但是可以通过指针获得对象后,修改对象内部的属性
- 在真实使用过程中,建议先定义常量,如果需要修改再修改为变量(更加安全)

Swift中的类型推导

Swift是强类型的语言
Swift中任何一个标识符都有明确的类型
注意:
- 如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略.
- 因为Swift有类型推导,会自动根据后面的赋值来决定前面的标识符的数据类型
- 可以通过option+鼠标左键来查看变量的数据类型

Swift中基本运算

Swift中在进行基本运算时必须保证类型一致,否则会出错
- 相同类型之间才可以进行运算
- 因为Swift中没有隐式转换
数据类型的转化
- Int类型转成Double类型:Double(标识符)
- Double类型转成Int类型:Int(标识符)

let a = 10
let b = 3.14

// 错误写法
//let c = a + b

// 正确写法
let c = Double(a) + b
let d = a + Int(b)

分支的介绍

分支即if/switch/三目运算符等判断语句
通过分支语句可以控制程序的执行流程

if分支语句

和OC中if语句有一定的区别
- 判断句可以不加()
- 在Swift的判断句中必须有明确的真假
  - 不再有非0即真
  - 必须有明确的Bool值
  - Bool有两个取值:false/true

// 演练一:
let a = 10

// 错误写法:
//if a {
// print("a")
//}

// 正确写法
if a > 9 {
  print(a)
}

// 演练二:
let score = 87

if score < 60 {
  print("不及格")
} else if score <= 70 {
  print("及格")
} else if score <= 80 {
  print("良好")
} else if score <= 90 {
  print("优秀")
} else {
  print("完美")
}

三目运算符

Swift中的三目运算保持了和 OC一致的风格

var a = 10
var b = 50
var result = a > b ? a : b
println(result)

guard的使用

guard是Swift2.0新增的语法
它与if语句非常类似，它设计的目的是提高程序的可读性
guard语句必须带有else语句，它的语法如下：
- 当条件表达式为true时候跳过else语句中的内容，执行语句组内容
- 条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw

guard 条件表达式 else {  
  // 条换语句
  break
}
语句组

例子

var age = 18

func online(age : Int) -> Void {

  guard age >= 18 else {
    print("回家去")
    return
  }
  print("可以上网")
}

online(age)

switch的简单使用

基本用法和OC用法一致
不同之处:
- switch后可以不跟()
- case后可以不跟break(默认会有break)
- 一个case判断中,可以判断多个值
- 多个值以,隔开

let sex = 0

switch sex {
  case 0, 1: 
    print("正常人")
  default: 
    print("其他")}

简单使用补充:
- 如果希望出现之前的case穿透,则可以使用关键字fallthrough

let sex = 0

switch sex {
  case 0: 
    fallthrough
  case 1:
    print("正常人")
  default: 
    print("其他")
}

switch支持多种数据类型

浮点型的switch判断

let f = 3.14

switch f {
  case 3.14: 
    print("π")
  default: 
    print("not π")
}

支持字符串类型

let m = 5
let n = 10
var result = 0
let opration = "+"

switch opration {
  case "+": 
    result = m + n
  case "-":
    result = m - n
  case "*":
    result = m * n
  case "/":
    result = m / n
  default:
    result = 0
}

print(result)

switch支持区间判断

什么是区间?
- 通常我们指的是数字区间:0_10,100200
- swift中的区间常见有两种
  - 开区间:0..<10 表示:0~9,不包括10
  - 闭区间:0...10 表示:0~10

let score = 88

switch score {
  case 0..<60:
    print("不及格")
  case 60..<80:
    print("几个")
  case 80..<90:
    print("良好")
  case 90..<100:
    print("优秀")
  default:
    print("满分")
}

for循环的写法

最常规写法

// 传统写法
for var i = 0; i < 10; i++ {
  print(i)
}

区间for循环

//开区间
for i in 0..<10 {
  print(i)
}

//闭区间
for i in 0...10 {
  print(i)
}

特殊写法
- 如果在for循环中不需要用到下标i

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

while和do while循环
- while循环
  - while的判断句必须有正确的真假,没有非0即真
  - while后面的()可以省略


var a = 0
while a < 10 {
  a++
}

do while循环
- 使用repeat关键字来代替了do

let b = 0
repeat {
  print(b) 
  b++
} while b < 20

字符串的介绍

OC和Swift中字符串的区别
- 在OC中字符串类型时NSString,在Swift中字符串类型是String
- OC中字符串@"",Swift中字符串""
使用 String的原因
- String是一个结构体，性能更高
- NSString是一个 OC对象，性能略差
- String支持直接遍历
- Swift提供了 String和NSString之间的无缝转换

字符串的使用

遍历字符串

// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {
  print(c)
}

字符串拼接
- 两个字符串的拼接

let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2

字符串和其他数据类型的拼接

let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"

字符串的格式化
- 比如时间:03:04

let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])

字符串的截取

Swift中提供了特殊的截取方式
- 该方式非常麻烦
- Index非常难创建
- 简单的方式是将String转成NSString来使用
  - 在标识符后加:as NSString即可

let myStr = "zhenniukeji"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

数组的介绍

数组（Array）是一串有序的由相同类型元素构成的集合
数组中的集合元素是有序的，可以重复出现
Swift中的数组
- swift字典类型是Array，是一个泛型集合

数组的初始化

数组分成:可变数组和不可变数组
- 使用let修饰的数组是不可变数组
- 使用var修饰的数组是可变数组

// 定义一个可变数组,必须初始化才能使用
var array1 : [String] = [String]()

// 定义一个不可变数组
let array2 : [NSObject] = ["why", 18]

在声明一个Array类型的时候可以使用下列的语句之一

var stuArray1:Array
var stuArray2: [String]

声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的

// 定义时直接初始化
var array = ["why", "lnj", "lmj"]

// 先定义,后初始化
var array : Array
array = ["why", "lnj", "lmj"]

对数组的基本操作

// 添加数据array.append("yz")
// 删除元素array.removeFirst()
// 修改元素array[0] = "why"
// 取值array[1]

数组的遍历

// 遍历数组
for i in 0..

 
 数组的合并 
 // 数组合并
// 注意:只有相同类型的数组才能合并
// 不建议一个数组中存放多种类型的数据
var array = ["why", "lmj","lnj"]var array1 = ["yz", "wsz"]
var array2 = array + array1

 
 字典的介绍 
  
  字典允许按照某个键来访问元素 
  字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合 
  键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的 
  Swift中的字典 
    
    Swift字典类型是Dictionary，也是一个泛型集合 
   
  
  
 字典的初始化 
  
  Swift中的可变和不可变字典 
    
    使用let修饰的数组是不可变字典 
    使用var修饰的数组是可变字典 
   
  
  
 // 定义一个可变字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定义一个不可变字典
let dict2 = ["name" : "why", "age" : 18]

 
  
  在声明一个Dictionary类型的时候可以使用下面的语句之一 
  
 var dict1: Dictionary
var dict2: [Int: String]
 
  
  声明的字典需要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的 
  
 // 定时字典的同时,进行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary
dict = ["name" : "why", "age" : 18]
 
 字典的基本操作 
 // 添加数据dict["height"] = 1.88dict["weight"] = 70.0
// 删除字段dict.removeValueForKey("height")
// 修改字典dict["name"] = "NN"
// 查询字典dict["name"]
 
 字典的遍历 
 // 遍历字典中所有的值

for value in dict.values {
  print(value)
}

// 遍历字典中所有的键
for key in dict.keys {
  print(key)
}

// 遍历所有的键值对
for (key, value) in dict {
  print(key)
  print(value)
}
 
 字典的合并 
 // 字典的合并
var dict1 = ["name" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]

// 字典不可以相加合并
for (key, value) in dict1 {
  dict2[key] = value
}
 
 元组的介绍 
  
  元组是Swift中特有的 
  它是什么呢? 
    
    它是一种数据结构，在数学中应用广泛。 
    类似于数组或者字典 
    可以用于定义一组数据 
   
  
  
 元祖的定义 
  
  元祖的常见写法有两种 
  
 ("1001", "张三", 30, 90)
(id:"1001", name:"张三", english_score:30, chinese_score:90)
 
 元祖的简单使用 
  
  用元组来描述一个HTTP的错误信息 
  
 // 元祖:HTTP错误
// let array = [404, "Not Found"]

// 写法一:
let error = (404, "Not Found")print(error.0)print(error.1)

// 写法二:
let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

// 写法三:
let (errorCode, errorIno) = (404, "Not Found")
print(errorCode)
print(errorIno) 
 
 可选类型的介绍 
  
  概念: 
    
    在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型) 
    在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强语言) 
    但是开发中赋值nil,在所难免.因此推出了可选类型 
   
  
  可选类型的取值: 
    
    空值 
    有值 
   
  
  
 定义可选类型 
  
  定义一个可选类型有两种写法 
    
    最基本的写法 
    语法糖(常用) 
   
  
  
 // 错误写法
// let string : String = nil

// 正确写法:
// 写法一:定义可选类型
let string : Optional = nil

// 写法二:定义可选类型,语法糖(常用)
let string : String? = nil
 
 可选类型的使用 
 // 演练一:

// 定义可选类型
var string : Optional = nil

// 给可选类型赋值
string = "Hello world"

// 打印结果
print(string)

// 结果:
Optional("Hello world")\n
// 因为打印出来的是可选类型,所有会带Optional

// 演练二:
// 取出可选类型的真实值(解包)
print(string!)
// 结果:Hello world\n
//注意:如果可选类型为nil,强制取出其中的值(解包),会出错string = nilprint(string!) 

// 正确写法:
if string != nil {
  print(string!)
}

// 简单写法:为了让在if语句中可以方便使用string

if var str = string {
  print(str)
}

 
 真实应用场景 
  
  目的:让代码更加严谨(可选绑定) 
  
 // 通过该方法创建的URL,可能有值,也可能没有值
// 错误写法:如果返回值是nil时,就不能接收了
let url : NSURL = NSURL(string: "www.baidu.com")

// 正确写法:使用可选类型来接收
let url : NSURL? = NSURL(string: "www.baidu.com")

// 通过url来创建request对象
if let tempUrl = url {
  let request = NSURLRequest(URL: tempUrl)
}

 
 函数的介绍 
  
  函数相当于OC中的方法 
  函数的格式如下 
  
 func 函数名(参数列表) -> 返回值类型 {
  代码块
  return 返回值
}

 
  
  func是关键字,多个参数列表之间可以用逗号（,）分隔，也可以没有参数 
  使用箭头“->”指向返回值类型 
  如果函数没有返回值，返回值为Void.并且“-> 返回值类型”部分可以省略 
  
 常见的函数类型 
 // 1.没有参数,没用返回值
func about() -> Void {
  print("iphone6s plus")
}
// 调用函数
about()

// 简单写法
// 如果没用返回值,Void可以写成()
func about1() -> () {
  print("iphone6s plus")
}

// 如果没有返回值,后面的内容可以都不写
func about2() {
  print("iphone6s plus")
}

about2()

// 2.有参数,没用返回值
func callPhone(phoneNum : String) {
  print("打电话给\(phoneNum)")
}

callPhone("+86 110")

// 3.没用参数,有返回值
func readMessage() -> String {
  return "吃饭了吗?"
}

var str = readMessage()
print(str)

// 4.有参数,有返回值
func sum(num1 : Int, num2 : Int) -> Int {
  return num1 + num2
}

var result = sum(20, num2: 30)
print(result)

 
 函数的使用注意 
  
  注意一: 外部参数和内部参数 
    
    在函数内部可以看到的参数,就是内部参数 
    在函数外面可以看到的参数,就是外部参数 
    默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数 
    如果第一个参数也想要有外部参数,可以设置标签:在变量名前加标签即可 
    如果不想要外部参数,可以在参数名称前加_ 
   
  
  
 // num1和a是外部参数的名称
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
  return num1 * num2 * num3
}

var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
  return num1 * num2
}

var result2 = ride(20, 20)

 
  
  注意二: 默认参数 
    
    某些情况,如果没有传入具体的参数,可以使用默认参数 
   
  
  
 func makecoffee(type :String = "卡布奇诺") -> String {
  return "制作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("拿铁")
let coffee2 = makecoffee()

 
  
  注意三: 可变参数 
    
    swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数 
    它们必须具有相同的类型 
    我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数 
   
  
  
 func sum(numbers:Double...) -> Double {
  var total: Double = 0

  for number in numbers {
    total += number
  } 
  return total
}

sum(100.0, 20, 30)
sum(30, 80)

 
  
  注意四: 引用类型(指针的传递) 
    
    默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址 
    必须是变量,因为需要在内部改变其值 
    Swift提供的inout关键字就可以实现 
    对比下列两个函数 
   
  
  
 // 函数一:值传递
func swap(var a : Int, var b : Int) {
  let temp = a; 
  a = b; 
  b = temp
  print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)print("a:\(a), b:\(b)")

// 函数二:指针的传递
func swap1(inout a : Int, inout b : Int) {
  let temp = a
  a = b
  b = temp
  print("a:\(a), b:\(b)")
}
swap1(&a, b: &b)
print("a:\(a), b:\(b)")

 
  
  函数的嵌套使用(了解即可) 
    
    swift中函数可以嵌套使用 
    即函数中包含函数,但是不推荐该写法 
   
  
  
 // 函数的嵌套
let value = 55
func test() {
  func demo() {
    print("demo \(value)")
  }
  print("test")
  demo()
}
demo() // 错误
test()

 
 类的介绍 
  
  Swift也是一门面向对象开发的语言 
  面向对象的基础是类,类产生了对象 
  在Swift中如何定义类呢? 
    
    class是Swift中的关键字,用于定义类 
   
  
  
 class 类名 : SuperClass {
  // 定义属性和方法
}

 
  
  注意: 
    
    定义的类,可以没有父类.那么该类是rootClass 
    通常情况下,定义类时.继承自NSObject(非OC的NSObject) 
   
  
  
 如何定义类的属性 
  
  Swift中类的属性有多种 
    
    存储属性:存储实例的常量和变量 
    计算属性:通过某种方式计算出来的属性 
    类属性:与整个类自身相关的属性 
   
  
  存储属性 
    
    存储属性是最简单的属性，它作为类实例的一部分，用于存储常量和变量 
    可以给存储属性提供一个默认值，也可以在初始化方法中对其进行初始化 
    下面是存储属性的写法 
      
      age和name都是存储属性,用来记录该学生的年龄和姓名 
      chineseScore和mathScore也是存储属性,用来记录该学生的语文分数和数学分数 
     
  
   
  
  
 class Student : NSObject {
  // 定义属性
  // 存储属性
  var age : Int = 0
  var name : String? 
  var chineseScore : Double = 0.0
  var mathScore : Double = 0.0
}

// 创建学生对象
let stu = Student()

// 给存储属性赋值
stu.age = 10
stu.name = "why"
stu.chineseScore = 89.0
stu.mathScore = 98.0

 
 计算属性 
  
  计算属性并不存储实际的值，而是提供一个getter和一个可选的setter来间接获取和其它设置属性 
  存储属性一般只提供getter方法 
  如果只提供getter，而不提供setter，则该计算属性为只读属性,并且可以省略get{} 
  下面是计算属性的写法 
    
    averageScore是计算属性,通过chineseScore和mathScore计算而来的属性 
    在setter方法中有一个newValue变量,是系统指定分配的 
   
  
  
 class Student : NSObject {
  // 定义属性
  // 存储属性
  var age : Int = 0
  var name : String?
  var chineseScore : Double = 0.0
  var mathScore : Double = 0.0

  // 计算属性
  var averageScore : Double {
  get {
    return (chineseScore + mathScore) / 2
    } 

  // 没有意义.newValue是系统分配的变量名,内部存储着新值
  set {
    self.averageScore = newValue
    }
  }
}

// 获取计算属性的值
print(stu.averageScore)

 
 类属性 
  
  类属性是与类相关联的，而不是与类的实例相关联 
  所有的类和实例都共有一份类属性.因此在某一处修改之后,该类属性就会被修改 
  类属性的设置和修改,需要通过类来完成 
  下面是类属性的写法 
    
    类属性使用static来修饰 
    例：courseCount是类属性,用来记录学生有多少门课程 
   
  
  
 class Student : NSObject {
  // 定义属性
  // 存储属性
  var age : Int = 0
  var name : String?
  var chineseScore : Double = 0.0
  var mathScore : Double = 0.0

  // 计算属性
  var averageScore : Double {
    get {
      return (chineseScore + mathScore) / 2
    } 

    // 没有意义.newValue是系统分配的变量名,内部存储着新值
    set {
      self.averageScore = newValue
    }
  } 

  // 类属性
  static var corseCount : Int = 0
}

// 设置类属性的值
Student.corseCount = 3

// 取出类属性的值
print(Student.corseCount)

 
 监听属性的改变 
  
  在OC中我们可以重写set方法来监听属性的改变 
  Swift中可以通过属性观察者来监听和响应属性值的变化 
  通常是监听存储属性和类属性的改变.(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化) 
  我们通过设置以下观察方法来定义观察者 
    
    willSet：在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue，我们可以自己定义该参数名 
    didSet：在新属性值被存储后立即调用。与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue 
    willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法 
    监听的方式如下: 
      
      监听age和name的变化 
     
  
   
  
  
 class Person : NSObject {
 var name : String? {
    // 可以给newValue自定义名称
    willSet (new){
      // 属性即将改变,还未改变时会调用的方法
      // 在该方法中有一个默认的系统属性newValue,用于存储新值
      print(name)
      print(new)
     }

     // 可以给oldValue自定义名称
     didSet (old) {
      // 属性值已经改变了,会调用的方法
      // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
      print(name)
      print(old)
     } 
  } 

  var age : Int = 0
  var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "why"

 
 构造函数的介绍 
  
  构造函数类似于OC中的初始化方法:init方法 
  默认情况下载创建一个类时,必然会调用一个构造函数 
  即便是没有编写任何构造函数，编译器也会提供一个默认的构造函数。 
  如果是继承自NSObject,可以对父类的构造函数进行重写 
  
 构造函数的基本使用 
  
  类的属性必须有值 
  如果不是在定义时初始化值,可以在构造函数中赋值 
  
 class Person: NSObject {
  var name : Stringvar
  age : Int

  // 重写了NSObject(父类)的构造方法
  override init() {
    name = "" 
   age = 0
  }
}

// 创建一个Person对象
let p = Person()

 
 初始化时给属性赋值 
  
  很多时候,我们在创建一个对象时就会给属性赋值 
  可以自定义构造函数 
  注意:如果自定义了构造函数,会覆盖init()方法,即不在有默认的构造函数 
  
 class Person: NSObject {
  var name : String
  var age : Int

  // 自定义构造函数,会覆盖init()函数
  init(name : String, age : Int) {
    self.name = name
    self.age = age
  }
}

// 创建一个Person对象
let p = Person(name: "why", age: 18)

 
 字典转模型(初始化时传入字典) 
  
  真实创建对象时,更多的是将字典转成模型 
  注意: 
    
    去字典中取出的是NSObject,任意类型 
    可以通过as!转成需要的类型,再赋值(不可以直接赋值) 
   
  
  
 class Person: NSObject {
  var name : Stringvar
  age : Int

  // 自定义构造函数,会覆盖init()函数
  init(dict : [String : NSObject]) {
    name = dict["name"] as! String
    age = dict["age"] as! Int
  }
}

// 创建一个Person对象
let dict = ["name" : "why", "age" : 18]
let p = Person(dict: dict)

 
 字典转模型(利用KVC转化) 
  
  利用KVC字典转模型会更加方便 
  注意: 
    
    KVC并不能保证会给所有的属性赋值 
    因此属性需要有默认值 
    基本数据类型默认值设置为0 
    对象或者结构体类型定义为可选类型即可(可选类型没有赋值前为nil) 
   
  
  
 class Person: NSObject {
  // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
  var name : String? 

  // 基本数据类型不能是可选类型,否则KVC无法转化
  var age : Int = 0

  // 自定义构造函数,会覆盖init()函数
  init(dict : [String : NSObject]) {
    // 必须先初始化对象
    super.init()

    // 调用对象的KVC方法字典转模型
    setValuesForKeysWithDictionary(dict)
  }
}

// 创建一个Person对象
let dict = ["name" : "why", "age" : 18]
let p = Person(dict: dict)

 
 闭包的介绍 
  
  闭包和OC中的block非常相似 
  OC中的block是匿名的函数 
  Swift中的闭包是一个特殊的函数 
  block和闭包都经常用于回调 
  
 闭包的使用 
 block的用法回顾 
  
  定义网络请求的类 
  
 @interface HttpTool : NSObject
- (void)loadRequest:(void (^)())callBackBlock;

@end

@implementation HttpTool
- (void)loadRequest:(void (^)())callBackBlock{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
      NSLog(@"加载网络数据:%@", [NSThread currentThread]); 

    dispatch_async(dispatch_get_main_queue(), ^{
      callBackBlock(); 
    });
  });
}
@end

 
  
  进行网络请求,请求到数据后利用block进行回调 
  
 - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
  [self.httpTool loadRequest:^{
    NSLog(@"主线程中,将数据回调.%@", [NSThread currentThread]);
  }];
}

 
  
  block写法总结： 
  
 block的写法: 类型: 返回值(^block的名称)(block的参数) 

值: ^(参数列表) { 
  // 执行的代码
};

 
 使用闭包代替block 
  
  定义网络请求的类 
  
 class HttpTool: NSObject {
  func loadRequest(callBack : ()->()){
      dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
        print("加载数据", [NSThread.currentThread()])

      dispatch_async(dispatch_get_main_queue(), { () -> Void in
        callBack()
      })
    }
  }
}

 
  
  进行网络请求,请求到数据后利用闭包进行回调 
  
 override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
  // 网络请求
  httpTool.loadRequest ({ () -> () in
    print("回到主线程", NSThread.currentThread());
  })
}

 
  
  闭包写法总结: 
  
 闭包的写法: 类型:(形参列表)->(返回值)

技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值

值: { (形参) -> 返回值类型 in 
  // 执行代码 
}

 
 闭包的简写 
  
  如果闭包没有参数,没有返回值.in和in之前的内容可以省略 
  
   httpTool.loadRequest({
    print("回到主线程", NSThread.currentThread());
  })

 
  
  尾随闭包写法: 
    
    如果闭包是函数的最后一个参数,则可以将闭包写在()后面 
    如果函数只有一个参数,并且这个参数是闭包,那么()可以不写 
   
  
  
 httpTool.loadRequest() {
  print("回到主线程", NSThread.currentThread());
}

// 开发中建议该写法
httpTool.loadRequest {
  print("回到主线程", NSThread.currentThread());
}

 
 闭包的循环引用 
  
  如果在HttpTool中有对闭包进行强引用,则会形成循环引用 
  
 class HttpTool: NSObject {

// 定义属性,来强引用传入的闭包
var callBack : (()->())? 
func loadRequest(callBack : ()->()){
      dispatch_async(dispatch_get_global_queue(0, 0)) {() -> Void in
        print("加载数据", [NSThread.currentThread()])
      dispatch_async(dispatch_get_main_queue(), { () -> Void in
        callBack()
      })
    }

    self.callBack = callBack
  }
}

 
  
  swift中解决循环引用的方式 
  
 // weak var weakSelf = self;
// [weak self] () -> () in
// [unowned self] () -> () in

httpTool.loadRequest { [unowned self] () -> () in
  self.view.backgroundColor = UIColor.redColor()
  print("回到主线程", NSThread.currentThread());
}

 
 懒加载的介绍 
  
  swift中也有懒加载的方式 
    
    (苹果的设计思想:希望所有的对象在使用时才真正加载到内存中) 
    和OC不同的是swift有专门的关键字来实现懒加载 
    lazy关键字可以用于定义某一个属性懒加载 
   
  
  
 懒加载的使用 
  
  格式 
  
 lazy var 变量: 类型 = {
  创建变量代码
}()

 
  
  懒加载的使用 
  
 // 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性
// lazy的作用是只会赋值一次lazy

var array : [String] = { () -> [String] in
  return ["why", "lmj", "lnj"]
}()

1小时入门Swift语法

简介

特点

历史

克里斯·拉特纳何许人?

Playground是什么?

什么是常量和变量

常量和变量的使用注意:

Swift中的类型推导

Swift中基本运算

分支的介绍

if分支语句

三目运算符

guard的使用

switch的简单使用

switch支持多种数据类型

switch支持区间判断

for循环的写法

字符串的介绍

字符串的使用

字符串的截取

数组的介绍

数组的初始化

对数组的基本操作

数组的遍历

数组的合并

字典的介绍

字典的初始化

字典的基本操作

字典的遍历

字典的合并

元组的介绍

元祖的定义

元祖的简单使用

可选类型的介绍

定义可选类型

可选类型的使用

真实应用场景

函数的介绍

常见的函数类型

函数的使用注意

类的介绍

如何定义类的属性

计算属性

类属性

监听属性的改变

构造函数的介绍

构造函数的基本使用

初始化时给属性赋值

字典转模型(初始化时传入字典)

字典转模型(利用KVC转化)

闭包的介绍

闭包的使用

block的用法回顾

使用闭包代替block

闭包的简写

闭包的循环引用

懒加载的介绍

懒加载的使用

你可能感兴趣的:(1小时入门Swift语法)