Swift语言基础

对Swift的简单想法

现在还处于过渡时期，但趋势很明朗了，Swift 必然会替代 Objective-C，并且比想象中来得快。现在就应该做好准备了。假如之前已经掌握了 Objective-C，切换到 Swift 也不难。Swift 中很多概念在 Objective-C 中已经存在。

很多大公司为求稳定，会仍然采用 Objective-C。而个人开发者和小团队，新项目应该直接采用 Swift 编写，旧项目的新模块也应该使用 Swift 编写。这样慢慢将整个语言重心从 Objective-C 切换到 Swift。Swift 的代码更简洁，开发效率更高。

Swift基础部分

第一个程序

import UIKit   
print("Hello World!")

通过import导入框架，直接写上框架名；
没有main函数，程序从第一个非声明语句开始执行；
输出使用print,效率更高；
Swift语句后面没有分号，即使加了分号，也不会出错，但是为了代码的规范，还是不要加

声明常量和变量

在Swift中，声明变量或者声明常量的时候，可以不用写类型，因为系统会自动推导出对应的类型。Swift中如果要在一条语句后再加一条语句，用分号隔开，但不建议使用。

var a = 10; a = 20  // 变量
let b = 10  // 常量
var 😱 = 20  // Swift 可以使用表情或者中文来表示，原来的OC是不可以的
var 张三 = 20
var c = 99.0

Swift中的类型

var a:Int = 100
var b:Float = 99.0
// Character 为字符类型，就是只有一个字符，和C语言中的 char 相似
var c:Character = "z"
// Swift不支持隐式转换，在OC中强制转换为(float)a，但在Swift中是Float(a)
Float(c) + b

字符串

// 判断字符串是否为空
var  str = "我是一只快乐的金龙鱼"  
//  在Swift中,布尔值不再是YES和NO了,而是 true 和 false
var isTure:Bool = true
isTure = str.isEmpty  
// Swift中字符串可以看做是字符的集合，求字节的长度
str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
str.characters.count  // 求字符串的长度
// 在Swift中字符串的第二种写法，字符串为空
var abc = ""
var abcd = String()
// 拼接字符串、万能转化
var 小明 = "小明"
var baby  = "baby"
小明 + "❤️" + baby
let str2 = String(format: "%d : %d", 1, 2)
// 打印可以直接把对象或变量写在括号里
print(str)
// 在打印中插入字符串
print("123\(str)4555")
// 字符串的其他操作先转化为NSString 在进行操作
let str4:NSString = str2 as NSString
// 判断两个字符串是否相等
小明 == baby
// 将两个字符串变量的值交换
swap(&小明, &baby)

数组

var array1:Array = ["小明", "Love", "baby"]
var array2 = ["小明", "hate", "baby"]
// 声明一个空的数组，数组的元素都是String类型
// OC中的 initWith/int  在swift里都用 () 代替
var array3 = Array<String>()
// 声明一个空的 String 类型的数组
var array4 = [String]()
// 赋值
array2[1] = "love"
// 添加元素
array2 += ["何必", "那么", "认真"]
array2.append("1314")  // 这需要添加同种类型的元素
array2.appendContentsOf(["222", "333"])
array2.appendContentsOf(["4444", "5555"])
// 在指定下标删除
array2.insert("结婚啦", atIndex: 0)
array2.insertContentsOf(["他们结婚了"], at: 0)
// 删除最后的元素
array2.removeLast()
// 删除指定下标的元素
array2.removeAtIndex(0)
// 删除所有
array2.removeAll()
// 移除前2个
mutableArray.removeFirst(2) 
// 遍历数组
for temp in array1 as [String]{
   print(temp)
}

字典

var dic1:Dictionary<String, Int> = ["a":10]
var dic2 = ["b":20]
// 空的字典
var dic3:Dictionary<String, Float> = [:]
var dic4 = Dictionary<String, Int>()
dic3 = ["b":1.0]
dic3.removeValueForKey("b")
// 删除所有
dic3.removeAll()
// 遍历
for (key, value) in dic {
    print(key, value)
}
// 合并
for (tempKey, tempValue) in dic {
    // 如果key存在则更新 没有则创建
    dic2[tempKey] = tempValue
}
print(dic2)

元组

// 类似C中的结构体，可以存放字符串，数组，字典，可以放在一起
var aaa = ("b", ["a":"b"], ["1", "2", "gadsf"], "a")
aaa.0
aaa.1
aaa.2[0]
aaa.3
// 元祖遍历
for (index, value) in array1.enumerate() {
    print("index = \(index)  value = \(value)")
}

枚举

enum Month:Float {
    case January = 10
    case February
    case March
    case April
}

// 如果明确指出一个变量/常量是属于那种枚举类型的话，可以直接 .枚举值 ，否则就 枚举类型.枚举值
let month = Month.February
let month1:Month = .January
var month2 = Month.January
month2 = .February
switch month {
case .January:
    print(month)
    print("hashValue = \(month.hashValue)  rowValue = \(month.rawValue)")
case .February :
    print(month)
    print("hashValue = \(month.hashValue)  rowValue = \(month.rawValue)")
case .March :
    print(month)
case .April:
    print(month)
}

枚举值可以关联浮点，字符串, 没有默认关联值;
关联如果是Int，会默认的递增上去，如果不是Int，必须每个枚举值都要关联对应的值;
在枚举中，我们直接取值，只能取等号左边的值，再点rawValue 就可以取到值;
当与switch配合使用时，把所有情况列举后，就不用写default

循环结构

// 在Swift3.0之前可以这样写，而且运算符++也被废弃
for var i = 0; i < 5; i++ {
    print(i)
}
for j in 1...10 {
    print(j)
}
for k in 0..<10 {
}

// while
var f2 = 10
while(f2 < 100) {
    // 在Swift 3 以后不能使用 ++ 用 +=
    f2 += 1
    print(f2)
}
while f2 < 200 {
    f2 += 2
}

// do while  repeat while
repeat {
    f2 += 3
} while f2 < 300

// if else
if f2 < 400 {
    print(f2)
} else {
    print("heh")
}

// switch
// 这里不用写 break ,也不会贯穿执行
switch (a) {
case 0..<100:
    print("0")
case 1:
    print("1")
default :
    print("default")
}

switch 不局限判断整形，可以是浮点型，也可以是字符串。。。
switch 后面的小括号可以省略，大括号不可以省略;
case 后面至少要有一条执行语句！！！并且case后的大括号可以省略，break可以不写，不会造成贯穿;
default 一定要写，并且只能写在最后

可选类型的条件分支

let str:String? = "hello"
// if-let 是对可选类型的判断，如果可选类型为nil，则不执行代码块，反之用tempStr 来接收这个可选类型解包后的值
 而且只能判断可选类型
if let tempStr = str {
    print(tempStr)
}

// if-let-where 与 if-let类似 加了一步对前面定义的局部变量的判断
if let tempStr2 = str where tempStr2.characters.count > 2 {
    print("tempStr2.length = \(tempStr2.characters.count)")
}

// guard-let-else(守护)
 如果可选类型为空，执行括号内的code代码块，执行完，直接返回，不执行下面的代码。反之{}外就可以使用tempStr3
guard let tempStr3 = str else {
    code
    return
}

函数

// 无参无返
func test() {
    print("i love Swift")
}
test()

// 无参有返
func test1() ->Int {
    return 10
}
test1()

// 有参无返
// 当只写一次参数时，在调用时时不显示的，要写两次参数名，才显示
func test2(num1 num1: Int, num2: Int) {
    print(num1 + num2)
}
test2(num1: 1, num2: 2)

// 有参有返
func test3(num1 num1: Int, num2: Int) -> Int {
    return num1 + num2
}
test3(num1: 1, num2: 2)

// 元组作为返回值
func yuanzu(num1: Int, num2: Int) -> (Int, Int) {
    return (num1 + num2, num1 * num2)
}
yuanzu(2, num2: 3)

// 函数的嵌套
func test4() {
    print("1")
    func test5() {
        print(2)
    }
    test5()
}
test4()

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

/*
 外部参数：外面调用的时候能够看到的参数
 func test(外部参数1 内部参数1：Int， 外部参数2 内部参数2：Int) -> 返回值 {
     return 内部参数1 + 内部参数2
 }
 */

// 在函数中 所有的参数的类型都是let来修饰的，所以我们要改变的话，就必须在外部声明一个 var 变量
// inout修饰 相当于我们之前的指针变量 让外界传进来一个值修改我们的值
func test7(inout num1: Int, num2: Int) {
    num1 = 100
    print(num1 + num2)
}
var number1 = 10
var number2 = 10
test7(&number1, num2: number2)

// 简单计算器
// 要求是外界传入两个数和一个符号 + - * / 来进行计算
// 要求使用函数嵌套


func calculator(num1: Float, num2: Float, operation: Character) -> Float{
    switch operation {
    case  "+":
        func add(a: Float, b: Float) -> Float {
            return a + b
        }
        return add(num1, b: num2)
    case  "-":
        return num1 - num2
    case  "*":
        return num1 * num2
    case  "/":
        return num1 / num2
    default:
        return 0.00000000
    }
}

calculator(2, num2: 3, operation: "+")

let bajie = 10
switch  bajie {
case var value where bajie < 20:
    value += 1
    print(value)
default:
    print("hehe")
}