Swift 学习笔记(一)

swift学习笔记第一篇,主要常量,变量,数据类型,条件判断,循环, 函数等基础知识的汇总

大纲汇总

Swift 学习笔记(一) : 常量,变量,数据类型,条件判断,循环, 函数等基础知识的汇总

变量 常量

使用 let来声明常量

一个常量的值，在编译的时候，并不需要有明确的值，但是你只能为它赋值一次。这说明你可以用一个常量来命名一个值，一次赋值就可在多个地方使用。

使用 var 来声明变量。

类型推断

常量或者变量的类型必须和你赋给它们的值一样。然而，你不用明确地声明类型。当你通过一个值来声明变量和常量时，编译器会自动推断其类型。

显示声明类型

let explicitDouble: Double = 70

显式类型转换

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

let label = "The width is"
let width = 94
let widthLabel = label + String(width)

可选值

类型后面加一个问号（?）来标记这个变量的值是可选的。

var optionalString: String? = "Hello"
print(optionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

数据类型

String

转换成字符串

// 使用 String方法
let width = 94
let widthString = String(width)
// 使用 \(  )
let apples = 3
let appleSummary = "I have \(apples) apples."

数组

数组的创建

let emptyArray = [String]()

字典

字典的创建

let emptyDictionary = [String: Float]()

控制流

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

// if 语句中，条件必须是一个布尔表达式,而不会隐形地与 0 做对比。
if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }

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

switch 支持任意类型的数据(不仅仅是整数), 和各种比较操作(不仅仅是测试相等)。

匹配到的 case 语句之后，程序会退出 switch 语句，并不会继续向下运行，所以不需要在每个子句结尾写 break。

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 ??

使用 if 和 let 一起来处理值缺失的情况

// 如果变量的可选值是 nil，条件会判断为 false，大括号中的代码会被跳过。
// 如果不是 nil，会将值解包并赋给 let 后面的常量，这样代码块中就可以使用这个值了。
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

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

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

循环

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

for-in

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

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
]
for (kind, numbers) in interestingNumbers {
    for number in numbers {
       print(number)
    }
}

可以在循环中使用 ..< 或者 ... 来表示下标范围。
使用 ..< 创建的范围不包含上界，如果想包含的话需要使用 ...。

var total = 0
for i in 0..<4 {
    total += i
}

while

var n = 2
while n < 100 {
    n *= 2
}

var m = 2
repeat {
    m *= 2
} while m < 100

函数和闭包

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

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person:"Bob", day: "Tuesday")

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

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

使用元组来生成复合值，比如让一个函数返回多个值。该元组的元素可以用名称或数字下标来获取。

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)
print(statistics.2)

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

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 将参数和返回值类型的声明与闭包函数体进行分离。
// {} 包含了闭包, 其中   in  把参数返回值 和 闭包的实现进行了分离

// map 方法的参数就是闭包
[1,2,3].map({
  (num:Int)->Int in
    return num * 3
})
 
//如果一个闭包的类型已知，比如作为一个代理的回调，你可以忽略参数，返回值，甚至两个都忽略。单个语句闭包会把它语句的值当做结果返回。
[1,2,3].map({num in
  return num * 3
})
// 单个语句闭包会把它语句的值当做结果返回。
[1,2,3].map({(num:Int)->Int in
  num * 3
})

// 你可以通过参数位置而不是参数名字来引用参数
// 当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在圆括号后面。
// 当一个闭包是传给函数的唯一参数，你可以完全忽略圆括号。
 [1,2,3].map{$0 * 3}
let sortedNumbers = numbers.sorted { $0 > $1 }