Swift 学习

周末闲来无事，接触一下swift,
在Xcode的playground上玩儿swift还很好玩儿的，会一边编写代码一边检查一遍即使显示

基础

基本类型

Int
Double Float
String
Bool

let c = 1_000_000_000
let d:Int = 1
let e:Double = 1.5
let f:Float = 2.2
let g:String = "12"

变量与常量

let 常量
var 变量
在swift中值永远不会被隐式转换为其他类型。如果需要把一个值转换成其他类型，需要进行显式转换。

使用 \() 也可以把值转换成字符串

显式转换

let str = "The width is"
let intlet = 94
let result = str + String(intlet)
print(result)

let a = 3
let b = 0.1415926
let pi = Double(a)+b

let version = 4
let 新变量 = "你好 swift \(version)"

数组与字典

[] 来创建数组和字典 也可以用 [] 和 [:] 来设置空数组和空字典

let emptyArray = [String]()
let emptyDictionary = [String: Float]()
var str = "Hello, playground"
var array = [1,2,3,4,5,6,7,8]
var ar1 = array[1]
array[1]=5
ar1 = array[1]
var dic = [String:Any]()
dic = ["a":"1","b":2.2,"c":3]
var ar2 = dic["c"]
array = []
dic=[:]

元祖

多个数据的集合 类似python

 var tuples = ("aven" , 200 , false)
 let (nickname,code,success) = tuples
 let (name,_,_) = tuples

 print (tuples.0)//aven
 print (nickname)//aven
 print (name)//aven
 let test = ( nickname:"aven" , code:200 , success:false )
 print (test.nickname)//aven

逻辑操作

if 和 switch 进行条件操作

–if 语句中，条件必须是一个布尔表达式
可以一起使用 if 和 let 来处理值缺失的情况。
另一种处理可选值的方法是通过使用 ?? 操作符来提供一个默认值。如果可选值缺失的话，可以使用默认值来代替。
–switch 支持任意类型的数据以及各种比较操作
– switch 中匹配到的子句之后，程序会退出 switch 语句，并不会继续向下运行，所以不需要在每个子句结尾写 break。但一定要加上default，不然会报错。

for-in、 for、 while 和 repeat-while 进行循环操作
——for-in 来遍历字典，需要两个变量来表示每个键值对。字典是一个无序的集合，所以他们的键和值以任意顺序迭代结束。 循环中可以使用 ..< 来表示范围。使用 ..< ==> [)， … ==> []
repeat-while 类似do-while

 let array = [11, 22, 33, 44, 55,66,77,88,99,111]
 var team = 0
 for data in array {
    if data > 50 {
        team += 3
    } else {
        team += 1
    }
 }
///////////////////
 var optionalName: String? = nil
 var greeting = "Hello!"
 if let name = optionalName {
    greeting = "Hello, \(name)"
 }else{
    greeting = "nobody"
 }

 let nickName: String? = "aven"
 let fullName: String = "X"
 let informalGreeting = "Hi \(nickName ?? fullName)"

//////////////////////////////////////////////////////

 let vegetable = "red pepper"
 switch vegetable {
 case "celery":
    print("Add some raisins and make ants on a log.")
 case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
 case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
 default:
    print("Everything tastes good in soup.")
 }

//// 遍历字典
let dic = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
 ]
 var largestNumber = 0
 var largestKey: String = ""
 for (key, values) in dic {
    for value in values {
        if value > largestNumber {
            largestNumber = value
            largestKey = key
        }
    }
 }
 print(largestKey)
 print(largestNumber)


 var n = 2
 while n > 100 {
    n = n * 2
 }
 print(n)//2
 var m = 2
 repeat {
    m = m * 2
 } while m > 100
 print(m)//4

 for i in 0..<4 {
    print(i)//0 1 2 3
 }

函数

func 来声明一个函数，
-> 来指定函数返回值的类型, 使用元组来让一个函数返回多个值
可变参数在函数内表现为数组的形式。
函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 _ 表示不使用参数标签。

func hi(name: String) -> String {
    return "Hello \(name)."
}
print( hi(name:"aven"))//Hello aven.

func hi2(_ name: String) -> String {
    return "Hello \(name)."
}
print( hi2("aven"))//Hello aven.

func hi2(nickname name: String) -> String {
    return "Hello \(name)."
}
print( hi2(nickname:"aven")) //Hello aven.

func compare(_ numbers: [Int]) -> (min: Int, max: Int, sum: Int) {
   var min = numbers[0]
   var max = numbers[0]
   var sum = 0
   for score in numbers {
       if score > max {
           max = score
       } else if score < min {
           min = score
       }
       sum += score
   }   
   return (min, max, sum)
}
let result = compare([11,2,34,56,1])
print (result) //(min: 1, max: 56, sum: 104)

/////
func data(numbers: Int...) -> Double {
    var sum = 0
    let count = numbers.count
    for number in numbers {
        sum += number
    }
    if count == 0 {
        return 0
    }
    return Double(sum/count)
 }
 print(data(numbers: 1,2,111))//38.0
 print(data(numbers: 22,1,43,12,53))//26.0
 print(data())//0.0

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量。

func newdata(_ number: Int) -> Int {
    var y = number;
    func add() {
       y += 5
    }
    add()
    return y
}
print(newdata(18)) //23

函数可以作为另一个函数的返回值,也可以当做参数传入另一个函数。

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

 func hasAnyMatches(bumber: Int, condition: (Int) -> Bool) -> Bool {
    if condition(bumber) {
        return true
    }
    return false
 }
 func lessThanTen(number: Int) -> Bool {
    return number < 10
 }
 var number = 9
 hasAnyMatches(bumber: number, condition: lessThanTen) // true

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

var numbers = [20, 19, 7, 12]
let ok = numbers.map({
    (number: Int) -> Int in
    if(number%2 != 0){
        return 0
    }else{
        return number
    }
 })
print(ok)//[20, 0, 0, 12]
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)//[60, 57, 21, 36]
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)//[20, 19, 12, 7]