Swift3.0-初级用法（适合初学者）

一、关于Swift

Swift是一种新的编程语言，这个应该每个iOS开发者都有过了解，这门语言是用于编写iOS、macOS、watchOS和tvOS的应用程序。Swift结合了C和Objective-C的优点并且不受C兼容性的限制，可以说相当的nb。Swift采用安全的编程模式并添加了很多新特性，使得编程更加的简洁、更灵活、也更有趣。Swift是基于成熟而且倍受喜爱的Cocoa和Cocoa Touch框架。

之前的开发用的都是Objective-C语言，那接受Swift语言是不是很难呢？通过我近几天的了解来说，根本不会，而且感觉语法炒鸡好用简单。Swift采用了Objective-C的命名参数以及动态对象模型，可以无缝对接到现有的Cocoa框架，并且可以兼容Objective-C代码。在此基础上，Swift还有许多新特性并且支持过程式编程和面向对象式编程，其实也是苹果极力推荐的新的编程语言。

二、Swift基本语法及用法

（1）简单值

通常来说，我们学习一门语言首先第一个程序就是打印“Hello World”。在Swift中，就可以用一句代码来实现啦：

print("hello world")

写过C、Objective-C代码的都知道这种形式，在Swift中，这行代码就是一个完整的程序。你不需要为了输入输出或者字符串倒入一个单独的库。全局作用域中的代码会被自动当作程序的入口点，所以你会发现Swift中再也没有main（）函数。而且不需要在每个语句后面加分号。

使用let来声明常量，使用var来声明变量。一个常量的值，在编译的时候，并不需要有明确的值，但是你只能为它赋值一次。也就是说你可以用常量来表示这样的一个值：你只需要决定一次，但是需要使用很多次。

    /*
    声明一个 myVariable 变量 不用明确的声明它的类型，随便给它值 整型42，这个时候myVariable就被决定为int类型了，编译器会自动的推断它的类型。
    *／
        var myVariable = 42
        //修改myVariable变量的值,这个值必须是int型
        myVariable = 50
        //打印一下这个值
        print(myVariable)

如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。

       //有足够的信息说明implicitInteger是integer类型
        let implicitInteger = 70
        //有足够的信息说明implicitDouble是double类型
        let implicitDouble = 70.0
        //初始值70，但是我想要声明的是double类型的变量
        let explicitDouble:Double = 70

值永远不会被自动转换为其他类型。如果你需要把一个值转换成其他类型，可以显示类型的转换。

//声明一个字符串类型变量
        let label = "The width is"
       //声明一个integer类型的变量
        let width = 66
        //现在想声明一个字符串“The width is 66”，需要把width转换成字符串类型：String(需要转换的变量)
        let widthLabel = label + String(width)

大家可以看到，上面的代码用+就能将两个字符串拼接起来，是不是很方便很爽啊。接下来还有更爽的，有一种更简单的把值转换成字符串的方法：把值写到（）中，并且在括号之前加上\ ，举个栗子：

        let apples = 3
        let oranges = 9

        let appleSum = "I have \(apples) apples"

        let fruitSum = "I have \(apples + oranges) pieces of fruit"

使用方括号[]来创建数组和字典，并使用下标或键（key）来访问元素。最后一个元素允许有逗号（只是和OC形成对比）

//创建一个数组
        var shoppingList = ["catfish","water","tulips","blue paint"]

        //改变数组中的元素
        shoppingList[1] = "bottle of water"

        //创建一个字典
        var occupations = [

            "Malcom":"Captain",
            "Kaylee":"Mechanic",
        ]
        //增加键值对/改变键值对   注：key如果找不到就默认添加
        occupations["Jayne"] = "Public Relations"

要创建一个空数组或字典，使用初始化语法。

        //初始化数组
        let emptyArray = [String]()
        //初始化字典
        let emptyDictionary = [String:Float]()

(2)控制流

使用 if 和 switch 来进行条件操作，使用 for-in 、 for 、 while 和 repeat-while 来进行循环。包裹条件和循环 变量括号可以省略，但是语句体的大括号是必须的。

let indiciduaScores = [75,12,435,56]
        var teamScore = 0
        for score in indiciduaScores {

            if score > 50 {
                teamScore += 3
            }else{
                teamScore += 1

            }

        }

        print(teamScore)

值得注意的是：在 if 语句中，条件必须是一个布尔表达式——这意味着像 if score { … } 这样的代码将报错，而不会隐形地 与 0 做对比。

你可以一起使用 if 和 let 来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者 是 nil 以表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。

      var optionalString:String? = "Hello"

        print(optionalString == nil)


        var optionalName:String? = "John Appleseed"
        /*
         optionalName = nil  把optionalName置为nil 
         下面的greeting就会是hello了
         */
        var greeting = "Hello"
        if let name = optionalName {

            greeting = "Hello,\(name)"
        }
        print(greeting)
    }

如果变量的可选值是nil，条件会判断为false，大括号中的语句就会跳过。如果不是nil，会将值解包并赋给let后面的变量，代码就可以使用这个值了。

另一种处理可选值的方法是通过??操作浮来提供一个默认值。如果可选值缺失的话，可以使用默认值来代替。

        let nickName:String? = nil
        let fullName:String = "John Appleseed"
        let informalGreeting = "Hi \(nickName ?? fullName)"

        print(informalGreeting)

Switch支持任意类型的数据以及各种比较操作，不仅仅是整数以及测试相等。

        /*

          值得注意的是：
          Swift中，运行switch中匹配到子句之后，程序会自动退出switch语句，并不会继续往下运行，所以并不需要在每个子句结尾写break。


         */
        let vegetable = "red pepper"
        switch vegetable {
        case "celery":
            print("We are famliy")
            //这个，相当于||
        case "red pepper","watercress":
            print("I am back")

            //注意：let where的使用，它将匹配等式的值赋给常量x
        case let x where x.hasSuffix("pepper"):
            print("We are \(x)")
        default:
            print("end")
        }

Swift中也可以使用for-in来遍历字典，需要两个变量来表示每个键值对。字典是一个无序的集合，所以它们的键和值以任意顺序迭代结束。

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
} }
print(largest)

使用while来重复运行一段代码直到不满足条件。循环条件也可以在结尾，保证能之手循环一次。

 //第一种写法：
        var n = 2

        while n<100 {
            n = n*2
        }

        print(n)

        //第二种写法：
        var m = 2

        repeat{

          m = m * 2


        }while m < 100


        print(m)

在循环中可以使用..<来表示范围。

//使用..<创建的范围不包含上界 0+1+2+3 = 6
        var total = 0
        for i in 0 ..< 4 {
            total += i
        }

        print(total)

（3）函数和闭包

使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数的返回值类型。

/*
      实现一个带两个参数返回值类型是String类型的函数,代码块：

     func <#name#>(<#parameters#>) -> <#return type#> {
     <#function body#>
     }
     */

    func greet(person:String,day:String) -> String {

        return"Hello \(person),today is \(day)"
    }

默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用表示不使用参数标签。

func freeStyle(_ person:String,on day:String) -> String {
        return"Hello \(person) , today is \(day)"
    }

调用：

//这里说明一下：需要一个返回值类型的变量来接受这个freeStyle方法才会成功调用,或者直接print(freeStyle("LY", on: "星期八"))

        var result = String()

        result =  freeStyle("LY", on: "星期八")

        print(result)

*使用元组来让一个函数返回多个值。改元组的元素可以名称或数字来表示。

//实现函数
func calculateStatistcs(scres:[Int]) -> (min:Int,max:Int,sum:Int) {

        var min = scres[0]
        var max = scres[0]
        var sum = 0

        for score in scres {
            if score > max {
                max = score
            }else if score < min{
                min = score
            }

            sum += score

        }
        return(min,max,sum)

    }

 //调用函数
        let statistics = calculateStatistcs(scres: [5,3,177,3,9])

        print(statistics.sum)
        print(statistics.0)

函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式:

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
}
return sum }
sumOf()
sumOf(numbers: 42, 597, 12)

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

函数是第一等类型，这意味着函数可以作为另一个函数的返回值。

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

函数也可以当做参数传入另一个函数。

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
} }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)

函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变 量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用 {} 来创建 一个匿名闭包。使用 in 将参数和返回值类型声明与闭包函数体进行分离。

numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})

有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型
和返回值。单个语句闭包会把它语句的值当做结果返回。

let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)

你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后
一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略
括号。

let sortedNumbers = numbers.sort { $0 > $1 }
print(sortedNumbers)

好了，先说这么多，想学习Swift的小伙伴如果觉得我的文章有帮助到你，动动小手帮忙顶一下，谢谢。

接下来我会继续更新Swift的用法，如果有什么问题或者建议欢迎在评论区里讨论！让我们一起学习交流！