Swift函数/结构体/类/属性/方法

定义函数：

//不带参数
func sitename() -> String {
    return "菜鸟教程"
}
print(sitename())
//带一个参数
func runoob(site: String) -> String {
    return (site)
}
print(runoob(site: "www.runoob.com"))
//带多个参数
func runoob(name: String, site: String) -> String {
    return name + site
}
print(runoob(name: "菜鸟教程：", site: "www.runoob.com"))
print(runoob(name: "Google：", site: "www.google.com"))
//带不定个参数
func vari<N>(members: N...){
    for i in members {
        print(i)
    }
}

如果我们的函数是返回一个复合值

func minMax(array: [Int]) -> (min: Int, max: Int) {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax) //元组
}

如果你不确定返回的元组一定不为nil，那么你可以返回一个可选的元组类型。
你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如(Int, Int)?或(String, Int, Bool)?

如果函数没有返回值

func runoob(site: String) {
    print("菜鸟教程官网：\(site)")
}

函数参数的名称：
局部参数名

func sample(number: Int) { //number 为局部参数名，只能在函数体内使用。
   println(number)
}
sample(number: 1)

外部参数名：

//firstArg and secondArg is 外部参数名 a, b是内部参数名
func pow(firstArg a: Int, secondArg b: Int) -> Int { 
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}
pow(firstArg:5, secondArg:3)

最后需要注意的一点是：

一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。
如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。
上面的两句话意味着：如果我们需要写一个小小的swap函数 就要加inout关键字在某个地方

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")

在swift里面 函数这个类型和其他类型没有什么区别，因此意味着 我可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它

var addition: (Int, Int) -> Int = sum //and of course sum is a function

更进一步想：
既然函数类型和其他并没有区别，因此 函数类型可以作为参数传给其他参数 并且甚至可以作为返回类型

func sum(a: Int, b: Int) -> Int {
    return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
    print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)

而且函数也可以嵌套：
函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。

结构体：
Swift 结构体是构建代码所用的一种通用且灵活的构造体。
结构体的定义与使用：

struct studentMarks {
   var mark1 = 100
   var mark2 = 78
   var mark3 = 98
}
let marks = studentMarks() //注意使用let
print("Mark1 是 \(marks.mark1)")
print("Mark2 是 \(marks.mark2)")
print("Mark3 是 \(marks.mark3)")

结构体看上去是简化版 的类的定义 那么他的适用场景都有哪些呢？
按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：

1. 结构体的主要目的是用来封装少量相关简单数据值。
2. 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
3. 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
4. 结构体不需要去继承另一个已存在类型的属性或者行为。
   更具体一点 以下情景更适用于结构体
   几何形状的大小，封装一个width属性和height属性，两者均为Double类型。
   一定范围内的路径，封装一个start属性和length属性，两者均为Int类型。
   三维坐标系内一点，封装x，y和z属性，三者均为Double类型。

类：
类与结构体些共同点和不同点：
5. 定义属性用于存储值
6. 定义方法用于提供功能
7. 定义附属脚本用于访问值
8. 定义构造器用于生成初始化值
9. 通过扩展以增加默认实现的功能
10. 符合协议以对某类提供标准功能

类独有的地方在于：
继承允许一个类继承另一个类的特征
类型转换允许在运行时检查和解释一个类实例的类型
解构器允许一个类实例释放任何其所被分配的资源
引用计数允许对一个类的多次引用

对于类的属性的访问方式 swift和java 一样。
类的构造器的定义：

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

属性 就是将值跟特定的类、结构或枚举关联。
属性可分为存储属性和计算属性: 存储常量或变量作为实例的一部分。计算属性是计算（而不是存储）一个值
有一种特殊类型的属性叫延迟储存属性。是指当第一次被调用的时候才会计算其初始值的属性。
这种属性的适用场景：
延迟对象的创建。
当属性的值依赖于其他未知类
比如：

class sample {
    lazy var no = number() // `var` 关键字是必须的
}

class number {
    var name = "Runoob Swift 教程"
}

var firstsample = sample()
print(firstsample.no.name)

方法：
看下面的代码就会懂了

class calculations {
    let a: Int
    let b: Int
    let res: Int
    
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
        res = a + b
        print("Self 内: \(res)")
    }
    
    func tot(c: Int) -> Int {
        return res - c
    }
    
    func result() {
        print("结果为: \(tot(c: 20))")
        print("结果为: \(tot(c: 50))")
    }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()