Swift-基础巩固

1.简单值

常量或者变量的类型必须和你赋给它们的值一样，然而，你不用明确地声明类型，声明的同时赋值的话，编译器会自动推断类型。
```
let number: Float = 4
print("输出数字:", number)
```
输出数字: 4.0

值永远不会被隐式转换为其他类型，如果你需要把一个值转换成其他类型，请显示转换

数字转换字符串操作（方法一）

let label = "the width is"
let width = 94
let widthLabel = label + String(width)//数字转换字符串操作
print(widthLabel)

打印结果：the width is94

数字转字符串操作（方法二）把值写到括号中，并且在括号之前写一个反斜杠

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pices of fruit"
print(appleSummary)
print(fruitSummary)

输出结果：I have 3 apples.
输出结果：I have 8 pices of fruit

数组的创建和字典的使用
使用方括号 [] 来创建数组和字典，并使用下标或者键（key）来访问元素，最后一个元素前允许有个逗号

var shoppingList = ["catfish","water","tulips","blue paint"]
shoppingList[1] = "bottle of water"
print("shoppingList:",shoppingList)
//shoppingList: ["catfish", "bottle of water", "tulips", "blue paint"]

var occupations = [
           "Malcolm":"Captain",
           "Kaylee":"Mechanic",
       ]
occupations["Jayne"] = "public relations"
print(occupations)//["Kaylee": "Mechanic", "Malcolm": "Captain", "Jayne": "public relations"]
//要创建一个空数组或者字典，使用初始化方法
let emptyArray = [String]();
let emptyDictionary = [String:Float]()
       
//如果类型信息可以被推断出来，你可以用【】和[:]创建空数组和空字典----就像你声明变量或者给函数传参数的时候一样。
shoppingList = []
occupations = [:]
print(shoppingList.isEmpty)//true

2.控制流

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

 let individualScores = [75,43,103,87,12]
 var teamScore = 0
 for score in individualScores{
    if score > 50 {
         teamScore += 3
    } else{
         teamScore += 1
    }
   }
 print("temaScore:",teamScore)//temaScore: 11

在if语句中，条件必须是一个布尔表达式--这意味着像 if score {....}这样的代码将报错，而不会隐形的与0作比较。

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

 var optionalString :String? = "hello"
 print(optionalString == nil)//false
 print(optionalString as Any)//Optional("hello")

 var optionalName:String? = nil
 var greeting="Hello!"
 if let name = optionalName {
     greeting = "Hello,\(name)"
 }
 print(greeting)//Hello!

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

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

使用while来重复运行一段代码知道不满足条件。循环条件也可以在结尾，保证能至少循环一次。

 var n = 2;
 while n < 100 {
         n = n*2//128
 }
 print(n)
 var m = 2
 repeat{
       m = m * 2
}while m < 100
 print(m)//128

你可以在循环中使用..<表示范围，也可以使用传统的写法，两者是等价的

        var firstForLoop = 0
        for i  in 0..<4 {
            firstForLoop += i
        }
        print(firstForLoop)
        //总结: ..< 创建的范围不包含上届，如果想要包含的话需要使用...
        /*
         该中写法已经被swift3 废弃
        var secondForLoop = 0
        for var i = 0; i < 4; ++i {
            secondForLoop += i
        }
        print(secondForLoop)
        */

3.函数和闭包

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

 func greet(name:String,day :String) -> String{
       return "Hello \(name),today is \(day)"
}
var str = greet(name: "Bob", day: "Tuesday")
print(str)   //Hello Bob,today is Tuesday

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

func calculateStatistics (scores:[Int]) -> (min:Int,max:Int,sum:Int){
  var min = scores[0]
  var max = scores[0]
  var sum = 0

for score in scores {
    if score > max {
             max = score
      } else if score < min
     {
             min = score
      }
      sum += score
    }
            return (min,max,sum)
 }
let statistics = calculateStatistics(scores: [5,3,100,3,9])
print(statistics.sum)//输出结果：120
print(statistics.2)// 输出结果：120 如果把2改成3 提示：Value of tuple type '(min: Int, max: Int, sum: Int)' has no member '3'

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

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

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

 func returnFifteen() -> Int{
    var y = 10
    func add(){
           y += 5
      }
 add()
 return y
}
var y =  returnFifteen()
print("y=",y)//y=15

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

func makeIncrementer() -> ((Int) -> Int){  // swift3以后参数需要加括号，否则报错Single argument function types require parentheses
  func addOne(number: Int) -> Int{
        return 1 + number
    }
   return addOne
}
 var  increment = makeIncrementer()
 print("increment:",increment)//increment: (Function)
 increment(7)
 print("increment含参数:",increment)//increment含参数: (Function)

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

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]
        var result = hasAnyMatches(list: numbers, condition: lessThanTen(number:))
        print(result)//true  当遇到数字7的时候就跳出本次循环了函数结束执行

     函数实际上是一种特殊的闭包：它是一段能之后被调取的代码。
     闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即时闭包是在一个不同的作用域被执行的
     你已经在嵌套函数例子中看到,你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离
     */
    numbers.map ({ (number:Int) -> Int in
        let result = 3 * number
        return result
    })
    /*
     有很多种创建更简洁闭包的方法，如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
     */
    let mappedNumbers = numbers.map({number in 3*number })
    print(mappedNumbers)//[60, 57, 21, 36]
    
    /*
     你可以通过参数位置而不是参数名字来引用参数--这个方法在非常短的闭包中非常有用。
     当一个闭包作为最后一个参数传给一个函数的时候，它可以直接更在括号后面
     当一个闭包是传给函数的唯一参数，你可以完全忽略括号
     */
    let sortedNumbers = numbers.sort { $0 > $1 }
    print(sortedNumbers)