Swift基础语法

一.Swift简介

1. Swift有安全的编程模型
2. 使用ARC管理内存
3. 提供编译检查
4. 支持代码预览

二.Swift基本数据类型

1. 数值
2. 字符
3. 元组
4. 数组 字典

//给常量赋值 在可以通过值推断出类型的时候，类型可省略
let x: Double = 1
let y = 1.0

//给变量赋值
var i = 1
var j = 2
//如果不赋值就要写类型，不然没办法分辨是什么类型，?是告诉编译器这个name可能有值，也可能没有值，即nil
var name: String?
name = "kevin"
name = nil

//let str = "x+y="
//let xy = x + y
//print(str + String(xy))
print("x+y = \(x + y)")

//数组赋值
let numbers = [1,2,3]
var names = ["kevin","Jack"]

//字典
let dic = ["one":1, "two":2]

//元组
let t = (1, 3, 5)
t.0//访问元组的第一个元素

三.Swift基本运算符

1. 赋值 算数

//赋值 算数
let a = 5
var b = 6
b = a

let (x,y) = (1,2)
x
y

//四则运算
1 + 1
1 - 1
1 * 2
4 / 2

let i = -1
-i
+i  //不会改变
9 % 4   //求余

2. 组合赋值，比较运算符

//组合赋值，比较运算符
//swift中赋值运算符=没有返回值
var a = 0
a += 2  //即a = a+2
a -= 1

1 == 1
1 != 0
1 > 0
1 < 2
1 >= 1
1 <= 1

if "hi"=="hi" {
    print("hi")
}
//元组运算符比较会从第一个开始比，第一个相等才会开始比第二个,元组 中最多只能比7个元素，超过7个就要自己实现比较逻辑
let at = (1, "cbc")
let bt = (2, "bcd")
at > bt

3. 三目，空合

//三目，空合
let a = 1
let b = 2
//var c = ""
//if a > b {
//    c = "a > b"
//} else {
//    c = "a <= b"
//}
let c = a > b ? "a > b":"a <= b"

var name : String?

let realName = name != nil ? name! : "unknown"//!是强制取出name的值
//空合运算符 name是否为空，如果为空，返回"unknown",否则返回name
name = "kevin"
let realName1 = name ?? "unknown"
print(realName1)

4. 区间，逻辑

//区间，逻辑
//1...5闭区间
//1..<5开区间
for idx in 1..<5 {
    print(idx)
}

let a = true
let b = false
a && b
a || b
!a
!b

a || (b && true)

四.Swift常用流程控制语句

1. For-In循环

//for in
//数组 字典 区间
let numbers = [1, 2, 3, 4, 5]
for num in numbers {
    print(num)
}

for _ in numbers {
    //如果需要遍历数组但是又不会使用数组中的元素，可以使用_，本例会打印5次a（数组numbers含5个元素）
    print("a")
}

//字典是无序的
let dic = ["one":1, "two":2, "three":3]
for (key, value) in dic {
    print("\(key): \(value)")
}

for _ in 1...5 {
    print(1)
}

2. While循环

//while
var i = 0
while i<100 {
    i += 1
}
//repeat
//后执行判断 repeat 相当于其他语言的do while
repeat{
    i += 1
}while i<100

3. 条件语句（if 和 switch）

//条件语句
//if
let a = 40
let b = 20
let c = 30
if a > b {
    print("a > b")
} else if a > c{
    print("a > c")
} else if b > c {
    print("b > c")
} else {
    print("empty")
}

// switch
//swift中switch语句不存在隐式贯穿,不需要break，即执行完某一个匹配，直接跳出，不会继续向下执行
let someCharacter: Character = "a"
switch someCharacter {
case "a":
    print("a")
case "A":
    print("A")
default:
    print("other")
}
//区间匹配
let someInt = 10
switch someInt {
case 0...5:
    print("0...5")
case 5...15:
    print("5...15")
default:
    print("other")
}

//元组匹配
let point = (2,-2)   //x y
switch point {
case (0,0):
    print("(0,0)")
case (let x,0): //值绑定
    print("x:\(x)")
case (0,_):
    print("该点在y轴")
case let(x,y) where x == -y:  //值绑定 where
    print("x:\(x) y:\(y)")
default:
    print("other")  //如果上面的case不能包含所有情况，必须有default，否则报错
}

//复合匹配
let someCharacter1: Character = "b"
switch someCharacter1 {
case "a","b","c","d":
    print("abcd")
case "A":
    print("A")
default:
    print("other")
}

4. 控制转移语句

(1) continue

let numbers = [1, 3, 5, 7, 9]
for number in numbers {
    if number == 5 {
        continue       
}
    print(number)
}
//运行结果：
只打印了1 3 7 9 ，等于5的情况下没有打印出来

(2) break

let numbers = [1, 3, 5, 7, 9]
for number in numbers {
    if number == 5 {
        break    
    }
    print(number)
}
//运行结果：
只打印了1 3，等于5及之后的情况下没有打印出来

(3) fallthrough

Swift的switch结构中，fallthrough的用法注意总结(转自作者（阿曌）
https://blog.csdn.net/XieYupeng520/article/details/46764219)
在swift的switch中，case后面加了fallthrough的用法，就和OC的case后面没加break的用法是一样的！

使用fallthrough需要注意的有：

(1) 加了fallthrough后，会直接运行【紧跟的后一个】case或default语句，不论条件是否满足都会执行

var age = 10
switch age {
    case 0...10:
        print("小朋友")
        fallthrough
    case 11...20:
        print("大朋友")
    case let x:
        print("\(x)岁的朋友")
}

//输出结果：
小朋友
大朋友

(2) 加了fallthrough语句后，【紧跟的后一个】case条件不能定义常量和变量

var age = 10
switch age {
    case 0...10:
        print("小朋友")
        fallthrough //此处报错
    case let x:
        print("\(x)岁的朋友")
}

//程序报错：
'fallthrough' cannot transfer control to a case label that declares variables

原因，我理解的是：由第一点我们知道，第一个case执行完后（输出“小朋友”）会直接执行下一个case，而下一个case条件里定义了临时变量x，这样就导致直接从上一个case进来的并没有这个变量x，那如果case语句里用到了x，很明显就会出错。swift这么要求安全的一种语言自然是不允许发生这种事情的，所以，fallthrough后一个case条件里不允许定义常量/变量——除了紧跟着的后一个，后面的其他case还是可以定义常量/变量的（如第一个代码例子）

(3) 执行完fallthrough后直接跳到下一个条件语句，本条件执行语句后面的语句不执行

var age = 10
switch age {
    case 0...10:
        print("小朋友")
        fallthrough
        print("我跳转了哦") //这一句没有执行
    case 11...20:
        print("大朋友")
    case let x:
        print("\(x)岁的朋友")
}

//输出结果：
小朋友
大朋友

(4) return

(5) throw

五.Swift函数的使用

1. 定义与调用

//定义与调用
func greet(person: String) -> String {
    return "Hello \(person)"
}
print(greet(person:"Kevin"))

2. 参数与返回

//参数与返回

//无参数
func sayHello() -> String {
    return "Hello"
}
print(sayHello())

//多参数
func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return "Already Greeted \(person)"
    } else {
        return "Hello \(person)"
    }
    
}
print(greet(person:"Kevin",alreadyGreeted:true))

//无返回值
func greet(person:String) {
    print("Hello \(person)")
}
greet(person:"Kevin")

3. 参数标签和名称

//参数标签和名称

//from就是参数标签
func hello(person:String, from hometown:String) -> String {
    //参数名称（person和hometown）是在函数内部使用的
    return "Hello \(person) from \(hometown)"
}
//外部调用时使用参数标签（from），无标签则使用名称
hello(person:"Kevin",from:"China")

// _代替参数标签 调用时"Kevin"前面不用加person:
func hello1(_ person:String) -> String{
    return "Hello \(person)"
}
hello1("Kevin")

//默认参数，调用时可以省去这个参数
func hello2(_ person:String, from hometown:String = "China") -> String {
    return "Hello \(person) from \(hometown)"
}
print(hello2("Kevin"))
//运行结果：Hello Kevin from China

4. 函数类型和嵌套函数

//函数类型是由参数和返回值来决定的
func addTwoInts(a:Int, b:Int) -> Int {
    return a+b
}
func sayHello() {
    print("Hello")
}

let a = addTwoInts  //(Int, Int) -> Int

//使用函数类型，把函数作为参数来传递，嵌套函数
func printMathFunctionResult(_ mathFunction:(Int,Int) -> Int, _ a:Int, _ b:Int) {
    print("Result:\(mathFunction(a,b))")
}
printMathFunctionResult(addTwoInts, 10, 10)

//函数类型作为返回类型
let value = 3
func forward(_ value:Int) -> Int {
    return value + 1
}

func backward(_ value:Int) -> Int {
    return value - 1
}

func chooseFunc(_ value:Int) -> (Int) -> Int {
    return value>0 ? forward:backward
}
let function = chooseFunc(value)
print(function(value))

5. Swift面向对象

类：属性 方法 继承 可选链式调用 构造过程&&析构过程

class Shape {
    var numberOfSides = 0
    init(_ numberOfSides:Int) {
        self.numberOfSides = numberOfSides;
    }
    func simpleDescription() {
        print("A shape with \(numberOfSides) sides")
    }
}

//let shape = Shape()
//shape.numberOfSides = 3
let shape = Shape(3)    //有init方法时使用这种方式

shape.simpleDescription()

//可选链式调用
var shape1:Shape? = Shape(3)    //?代表Shape类型的shape1可能为nil
shape1 = nil
shape1?.simpleDescription()     //?代表这个方法可能执行不了，在shape1为nil的情况下

//继承
class NamedShape : Shape {
    let name : String
    init(name:String, numberOfSides:Int) {
        self.name = name
        super.init(numberOfSides)
    }

    override func simpleDescription() {
        print("\(name) shape with \(numberOfSides) sides")
    }
}
let shape2 = NamedShape(name:"Text", numberOfSides:7)
shape2.simpleDescription()