Swift学习一 初步认识

//swift中打印用 print,句末中可以不用分号结尾
// print("hello world");

    //let声明常量 ，var声明变量
    
    let myConstant = 42
    
    var myVariable = 42
    
    myVariable = 50
    
    print(myConstant,myVariable)
    
    //如果初始值没有提供足够的信息（或没有初始值），那需要在变量后面声明类型，用冒号分割。
    let string:String = "ssss"
    
    print(string)
    

    //值永远不会被隐式转换成其他类型，如果需要把一个值转换成其他类型，请显示转换
    let label = "the width is"
    
    let width = 100
    
    let widthLabel  = label + String(width)
    
    print(widthLabel)
    
    //简单的把值转换成字符串的方法：把值写到括号中，并在括号之前写一个反斜杠
    
    let apples = 3
    let oranges = 5
    let appleSummary = "I have\(apples) apple."
    let fruitSummary = "I have\(apples + oranges) pieces of fruit"
    print(appleSummary,fruitSummary)
    
    //使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素，最后一个元素后面允许有个逗号。
    var shoppingList = ["1","2","3","4"]
    shoppingList[1] = "bottle if water"
    
    var occupadtions = ["Malcolm":"Captain","Kaylee":"Mechanic",]
    
    occupadtions["Jayne"] = "Public Relations"
    
    print(shoppingList ,occupadtions);
    
    //创建一个空数组或者字典，使用初始化语法
    
    let emptyArray = [String]()
    let emptyDictionary = [String:Float]()
    
    //如果类型信息可以被推断出来，可以用[]和[:]来创建空数组和空字典--就像你声明变量或给函数传参数的时候一样
    shoppingList = []
    occupadtions = [:]
    
    //控制流
    //使用if和switch来进行条件操作，使用for-in,for,while和repeat-while来进行循环，包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的
    
    let individuaScores  = [75,43,103,87,12]
    var teamScore = 0
    for score in individuaScores {
    
        if  score > 50 {
            
            teamScore += 3
            
        }else{
        
            teamScore += 1
        }

    }
    print(teamScore);//输出值为11
    
//使用if语句中，条件必须是一个布尔表达式---这意味着像if score {...} 这样的代码将报错，而不会隐形的与0作对比。可以用if和let来处理缺失的情况，这些值可由可选值来代表，一个可选的值是一个具有的值或者是nil以表示值缺失。在类型后面加一个问号 来标记这个变量的值是可选的
    
    var optionalString:String? = "Hello"
    print(optionalString == nil)
    
    //如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过，如果不是nil，会将值解包并赋值给let后面的常量，这样代码块就可以使用这个值了。
    var optionalName:String? = "John Appleseed"
    var greeting = "hello"
    
    if let name = optionalName {
        greeting = "Hello,\(name)"
        
    }else{
    //把optionalName改成nil,greeting会是什么?添加一个optionalName语句,当optionalName是nil时给 greeting 赋一个不同的值。
        greeting = "Hello,\(optionalName == nil)"
    }
    print(greeting)
    
//      print("hello,\(greeting)")

    //另一种处理可选值的方法是通过使用??操作符号来提供一个默认值，如果可选值缺失的话，可以使用默认值来代替。
    let nickName:String? = nil
    let fullName:String = "Jhon Appleseed"
    let informalGreeting = "Hi \(nickName ?? fullName)"
    
    print(informalGreeting)
    
    //switch支持任意类型的数据以及各种比较操作--不仅仅是整数以及测试相等
    let vegetable = "red pepper"
    switch vegetable {
        
    case "cekery":
        print("Add some raisins and make ants on a log")
        
    case "cucumber","watercress":
        print("That would make a good tea sandwich")
       
        //注意let 将匹配等式的值赋值给常量x
    case let x where x.hasSuffix("pepper"):
        print("Is it a spicy \(x)?")
        
    default:
        print("Everything tastes good in soup.")
    }
    
    //用for-in 来遍历字典,需要两个变量来表示每个键值对.字典是一个无需的集合,所以他们的键和值以任意顺序迭代结束
    let interstingNumbers  = ["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 interstingNumbers {
        
        print(numbers,kind)
        
        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)
    
    //你可以在循环中使用..<来表示范围，如果想包含的话需要使用...
    var total = 0
    for i in 0..<4 {
        total += i
    }
    print(total)
    
    
    /*-------------函数和闭包----------------*/
    //使用func 来声明一个函数，使用名字和参数来调用函数，使用->来指定函数返回值得的类型
    func greets(persons:String,day:String) -> String {
        return "Hello \(persons) , today is \(day)."
    }
    
    print(greets(persons: "Bob" , day: "Tuesday"))
    
    
    //默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用_表示不使用参数标签
    func greet (_ person:String, on day:String)->String{
    
        return"hello \(person),today is \(day)"
    }
    
    print(greet("John", on: "wednesday"))
    
    
    //使用元祖来让一个函数返回多个值，该元素的元素可以用名称或数字来表示
    func calculateStatistics(scores:[NSInteger]) -> (min: NSInteger,max:NSInteger,sum:NSInteger) {
    
        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.1)
    
    //函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式
    func sumOf(numbers:NSInteger...) -> NSInteger{
    
        var sum = 0
        for number in numbers {
            sum += number
        }
        
        return sum
        
    }
    
    print(sumOf(),sumOf(numbers: 42,597,12))
    
    //函数可以嵌套，被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数
    func returnFifteen() -> NSInteger {
    
        var y = 10
        func add() {
        
            y += 5
        }
        add()
        return y
        
    }
    
    print(returnFifteen())
    
    //函数是第一等类型，这意味着函数可以作为另一个函数的返回值
    func makeIncrementer() -> ((NSInteger) -> (NSInteger)){
    
        func addOne(number: NSInteger) ->NSInteger {
        
            return 1 + number
        }
        return addOne
    }
    
    let increment = makeIncrementer()
    print(increment(7))
    
    
    //函数也可以当做参数传入另一个函数
    func hasAnyMatches(list:[NSInteger],condition:(NSInteger) -> Bool) -> Bool {
    
        for item in list {
            if condition(item) {
                return true
            }
        }
        return false
    }
    
    func lessThanTen(number:NSInteger) -> Bool {
    
        return number < 10
    }
    let numbers = [20,19,7,12]
    print(hasAnyMatches(list: numbers, condition: lessThanTen))
    
    //函数实际上是一种特殊的闭包：它是一段能之后被调取的代码，闭包中的代码能访问闭包所建作用域中能得到的变量函数，即使闭包是在一个不同的作用域被执行的，你已经在嵌套函数例子中多看到，你可以用{}来创建一个匿名闭包， 使用in将参数和返回值类型声明与闭包函数进行分离
    let mappedNumbers1  = numbers.map({
    
        (number:NSInteger) -> NSInteger in
        let resault = 3 * number
        return resault
    })
    print(mappedNumbers1)
    
    //有很多种创建简单的闭包方法，如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值，单个语句闭包会把他语句的值当做结果返回
    let mappedNumbers2 = numbers.map({number in 3*number})
    
    print(mappedNumbers2)
    
    //你可以通过参数位置而不是参数名字来引用参数---这个方法在非常的闭包中非常有用。当一个闭包作为最后一个参数传至给一个函数的时候，它可以直接跟在括号后面，当一个闭包是还给函数的唯一参数，你可以完全忽略括号
    let sortedNumbers = numbers.sorted()
    print(sortedNumbers)