美文网首页
Swift 学习笔记(一)

Swift 学习笔记(一)

作者: forping | 来源:发表于2021-01-15 13:53 被阅读0次

    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 }
    

    相关文章

      网友评论

          本文标题:Swift 学习笔记(一)

          本文链接:https://www.haomeiwen.com/subject/aeiiaktx.html