元组

• 是一种数据结构
• 类似于数组或者字典
• 用于定义一组数据
• 组成元组类型的数据我们叫元素

//使用元祖来定义一组数据
let infoTuple = ("why",18,1.88)
let nameTuple = infoTuple.0
let count = nameTuple.characters.count

//使用元祖来定义一个网络请求的错误
let errorArray = ["Not Found",404]
let errorTuple = ("Not Found",404)
errorTuple.0

//给元组中所有的元组起别名
let errorTuple1 = (errorMsg :"Not Found",errorCode :404)
errorTuple1.errorMsg
errortuple1.errorCode

//元组的别名就是元组的名称
let(errorMsg,errorCode) = ("Not Found",404)
errorMsg
errorCode

可选类型

• 在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)

• 在swift开发中,nil也是一个特殊的类型,因为和真实的类型不匹配是不能赋值的(swift是强类型语言)

• 但是开发中赋值为Nil ,在所难免,因此推出了可选类型

• 可选类型取值

  • 有值
  • 空值

//1.如何定义可选类型
//可选类型是一个泛型集合,必须告诉可选类型中存放什么元素
var name : Optionl<String> = nil //不常见
var name : String? = nil //语法糖

//2.给可选类型赋值 Optional("why")
//name = 18 错误写法
name = "why"

//3.取出可选类型中的值 Optional("why")
//从可选类型中取出具体的值可以通过强制解包 可选类型+!
print(name!)

//4.注意 : 如果可选类型中没有值的,那么强制解包,程序会崩溃,所以强制解包是一个非常危险的操作

if name != nil{
  print(name!)
}

//5.可选绑定
//做了两件事情 :1. 系统会先判断name是否有值,如果没有值,那么跳过{},{}中所有的代码都不执行
// 2.如果有值,那么系统会对name进行解包,并且将解包后的结果赋值给前面的tempName
  if let tempName = name{
    print(name)
    print(name)
    print(name)
    print(name)
  }
  
    if let name = name{
    print(name)
    print(name)
    print(name)
    print(name)
  }

类型转换

• is :用于判断一个实例是否是某一个类型
• as :将NSObject转换成具体的类型

//is
let array = ["why",18,1.88]
let item = array[1]
if item is String{
  print("第一个元素是一个String类型")
}

//as
//as? 将NOObject转成一个可选类型
//as! 将NSObject转换成一个具体的类型(如果转换不成功,程序就会崩溃)
let infoDict = ["name":"why","age": 18, "height" : 1.88]
let value = infoDIct["name"]

if let value = value{
  let name = value as? String
  if let name = name{
  print()
  }
}

函数

func 函数名(参数列表) ->返回值类型{
  代码块
  return 返回值

}

• func是关键字,多个参数列表之间可以用逗号(,)分隔,也可以没有参数
• 使用箭头"->"返回值类型
• 如果没有返回值-> 可以省略

// 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)

// 5.有多个返回值的函数
let nums = [1, 3, 4, 8, 22, 23]
func getNumCount(nums : [Int]) -> (oddCount : Int, evenCount : Int) {
    var oddCount = 0
    var evenCount = 0
    for num in nums {
        if num % 2 == 0 {
            oddCount++
        } else {
            evenCount++
        }
    }
    return (oddCount, evenCount)
}

let result = getNumCount(nums)
result.oddCount
result.evenCount

函数的特殊用法

• 内部参数和外部参数
• 内部参数:在函数内部能看到参数名称就叫内部参数
• 外部参数:在函数外部能看到的参数名称就叫外部参数
• 从第二个参数开始,所有的参数即使内部参数也是外部参数,但是第一个参数只是内部参数,不是外部参数
• 如果希望第一个参数也是外部参数,可以在标示符前加上外部参数的名称
• 如果从第二个参数开始不希望是外部参数可以在第二个参数开始的标示符前面加上 _

// 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() // 执行函数会先打印'test',再打印'demo'

函数的类型

• 函数类型的概念
  • 每个函数都有属于自己的类型，由函数的参数类型和返回类型组成
    • 这个例子中定义了两个简单的数学函数：addTwoInts 和 multiplyTwoInts
    • 这两个函数都传入两个 Int 类型， 返回一个合适的Int值
    • 这两个函数的类型是 (Int, Int) -> Int

// 定义两个函数
func addTwoInts(a : Int, b : Int) -> Int {
    return a + b
}

func multiplyTwoInt(a : Int, b : Int) -> Int {
    return a * b
}

• 抽取两个函数的类型,并且使用

// 定义函数的类型
var mathFunction : (Int, Int) -> Int = addTwoInts

// 使用函数的名称
mathFunction(10, 20)

// 给函数的标识符赋值其他值
mathFunction = multiplyTwoInt

// 使用函数的名称
mathFunction(10, 20)

• 函数作为方法的参数

// 3.将函数的类型作为方法的参数
func printResult(a : Int, b : Int, calculateMethod : (Int, Int) -> Int) {
    print(calculateMethod(a, b))
}

printResult(10, b: 20, calculateMethod: addTwoInts)
printResult(10, b: 20, calculateMethod: multiplyTwoInt)

• 函数作为方法的返回值

// 1.定义两个函数
func stepForward(num : Int) -> Int {
    return num + 1
}

func stepBackward(num : Int) -> Int {
    return num - 1
}

// 2.定义一个变量,希望该变量经过计算得到0
var num = -4

// 3.定义获取哪一个函数
func getOprationMethod(num : Int) -> (Int) -> Int {
    return num <= 0 ? stepForward : stepBackward
}

// 4.for循环进行操作
while num != 0 {
    let oprationMethod = getOprationMethod(num)
    num = oprationMethod(num)
    print(num)
}

枚举类型

• 概念介绍

  • 枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。
  • 在 C/OC 语言中枚举指定相关名称为一组整型值
  • Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值.也可以提供一个值是字符串，一个字符，或是一个整型值或浮点值

• 枚举类型的语法

  • 使用enum关键词并且把它们的整个定义放在一对大括号内

enum SomeEnumeration {
// enumeration definition goes here
}

枚举类型的定义

• 以下是指南针四个方向的一个例子
  • case关键词表明新的一行成员值将被定义
  • 不像 C 和 Objective-C 一样，Swift 的枚举成员在被创建时不会被赋予一个默认的整数值
  • 在上面的CompassPoints例子中，North，South，East和West不是隐式的等于0，1，2和3

enum CompassPoint {
  case North
  case South
  case East
  case West
}

• 定义方式二:多个成员值可以出现在同一行上

enum Planet {
  case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

给枚举类型赋值

• 枚举类型赋值可以是字符串/字符/整型/浮点型
• 注意如果有给枚举类型赋值,则必须在枚举类型后面明确说明具体的类型

// 1.枚举类型的赋值
enum CompassPoint : Int {
  case North = 1
  case South = 2
  case East = 3
  case West = 4
}

enum Planet {
  case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}


// 2.枚举类型的使用
let p = Planet(rawValue: 3)

if let p = p {
    switch p {
    case .Mercury:
        print("Mercury")
    case .Venus:
        print("Venus")
    case .Earth:
        print("Mercury")
    case .Mars:
        print("Mars")
    case .Jupiter:
        print("Jupiter")
    case .Saturn:
        print("Saturn")
    case .Uranus:
        print("Uranus")
    case .Neptune:
        print("Neptune")
    }
}

结构体

• 概念介绍
  • 结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合
  • 结构体(struct)指的是一种数据结构
  • 结构体是值类型,在方法中传递时是值传递
• 结构的定义格式

struct 结构体名称 {
    // 属性和方法
}

为什么需要结构体?

• 先来看一个例子
• 我们要计算平面坐标里某个点距点Center的距离是否小于200
• 算起来很简单，勾股定理就搞定了：

Snip20160616_2.png

- 其中sqrt(n)用来计算n的平方根
- pow(x, n)用来计算x的n次方

let centerX : Double = 100
let centerY : Double = 100

func inRange(x : Double, y : Double) -> Bool {
    let disX = x - centerX
    let disY = y - centerX

    let dis = sqrt(pow(disX, 2) + pow(disY, 2))

    return dis < 200
}

let x : Double = 100
let y : Double = 1000

inRange(x, y: y)

• 问题
  • 但是这样有一个不足，当我们需要比较很多个点和Center的距离的时候，这些数字并不能明确告诉我们它们代表的位置的意义，甚至我们都无法知道它们代表一个数字。
  • 如果我们可以像这样来比较位置：
    • 相比数字，它们看上去就会直观的多
    • 而这，就是我们需要自定义struct类型最直接的原因

inRange(location1)
inRange(myHome)

• 使用结构体进行改进

// 初始化结构体
struct Location {
    var x : Double
    var y : Double
}

// 创建结构体
let location = Location(x: 90, y: 90)

// 优化刚才的方法
func inRange(location : Location) -> Bool {
    let disX = location.x - centerX
    let disY = location.y - centerY

    let dis = sqrt(pow(disX, 2) + pow(disY, 2))

    return dis < 200
}

inRange(location)

结构体的增强

• 扩充构造函数
  • 默认情况下创建Location时使用Location(x: x值, y: y值)
  • 但是为了让我们在使用结构体时更加的灵活,swift还可以对构造函数进行扩充
• 扩充的注意点
  • 在扩充的构造函数中必须保证成员变量是有值的
  • 扩充的构造函数会覆盖原有的构造函数

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.componentsSeparatedByString(",")
        x = Double(strs.first!)!
        y = Double(strs.last!)!
    }
}

let location = Location(x: 100, y: 100)
let location1 = Location(xyString: "100,100")

• 为结构体扩充方法
  • 为了让结构体使用更加灵活,swift的结构体中可以扩充方法
  • 例子:为了Location结构体扩充两个方法
    • 向水平方向移动的方法
    • 向垂直方向移动的方法

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.componentsSeparatedByString(",")
        x = Double(strs.first!)!
        y = Double(strs.last!)!
    }

    mutating func moveH(x : Double) {
        self.x += x
    }

    mutating func moveV(y : Double) {
        self.y += y
    }
}

• 注意:
  • 如果我们使用的Location不是自己定义的，但是我们仍旧希望在自己的项目里扩展Location的操作
  • Swift也能帮我们达成，这个机制，叫做extension

extension Location {
    mutating func moveH(x : Double) {
        self.x += x
    }

    mutating func moveV(y : Double) {
        self.y += y
    }
}