Swift 基础补充(1)

最新推荐文章于 2024-05-14 01:15:48 发布

终有丶

最新推荐文章于 2024-05-14 01:15:48 发布

阅读量291

点赞数

分类专栏： Swift

本文链接：https://blog.csdn.net/qq_28379951/article/details/52381502

版权

Swift 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

1.Swift 是一种新的编程语言，用于编写 iOS，OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制，Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架

简单值（Simple Values）
控制流（Control Flow）
函数和闭包（Functions and Closures）
对象和类（Objects and Classes）
枚举和结构体（Enumerations and Structures）
协议和扩展（Protocols and Extensions）
泛型（Generics）

3.print("Hello, world!")

简单值：使用let来声明常量，使用var来声明变量。let声明的常量只能赋值一侧而var可以多出赋值

例如：

var myVariable =42 myVariable =50let myConstant =42

常量或变量的类型必须和所赋值的类型一样，可以不用明确的声明类型，因为赋值时编译器会自动推断类型，在上面的例子中，编译器推断出myVariable是一个整数（integer）因为它的初始值是整数。

如果没有初始值或没有足够的信息定义它的类型，那么可以再变量后面声明类型用冒号分开。

例：

let implicitInteger =70let implicitDouble = 70.0 let explicitDouble: Double =70

显示转化和隐式转化：系统可以自己识别转换的类型为隐式转化，而需要认为的指定类型转换的为显示转化，否则系统自身无法处理类型转换。

把常量或变量转转换为字符串,再常量前加一个反斜杠

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

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

varshoppingList = ["test1","test2","test3","test4 "]
        shoppingList[1] ="test5"
        print(shoppingList)

        var occupations = [
            "OM1" : "OM1",
            "OM0" : "OM1"
        ]
        occupations["OM2"] ="test3"

print(occupations)

输出["test1", "test5", "test3", "test4 "]

["OM1": "OM1", "OM0": "OM1", "OM2": "test3"]

当key存在时直接替换掉key对应的值，若key不存在则添加一直新的key值

创建空数组字典

letemptyArray = [String]()

letemptyDic = [String:Float]()

print(emptyArray)

print(emptyDic)

如果类型已确定：可直接这样声明

shoppingList = [] occupations = [:]

控制流

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

letsoureArray = ["OM1","OM2","OM3","OM4","OM5"]
        for soure in soureArray {
            if soure == "OM2" {
               print(soure)
            }
        }

        let soureArray2 = [10,11,12,13,14,15]
        var jiSuan = 0
        for value in soureArray2 {
            if value > 12 {
                jiSuan += value
                print(jiSuan)
            }

}

在if语句中，条件必须是一个布尔表达式——这意味着像if score { ... }这样的代码将报错，而不会隐形地与 0 做对比。例如 ifvalue >12, 处理数值缺失使用if和let 。在类型后面加一个问号来标记这个变量的值是可选的 ,此时值可以为NIL

letoptainString:String? ="Hello"
        print(optainString ==nil)

        let optainName :String? ="John"
        var getting = "Hello!"
        if let name = optainName {
            getting = "Hello \(name)"
            print(getting)

}

如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过。如果不是nil，会将值赋给let后面的常量，这样代码块中就可以使用这个值了。

switch支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。

例

letvegetable ="perper.OM2"
        switch vegetable {
        case "celery":
            print("Add some raisins and make ants on a log.")
        case "OM1", "OM2":
            print("That would make a good tea sandwich.")
        case let x where x.hasPrefix("perper"):
            print("Is it a spicy\(x)")
        default:
            print("Everything tastes good in soup.")

}

switch 可以是if判断可以加或（多个值）

遍历字典可以使用for in

letnumbers = [
            "OM1":[2,3,4, 5, 6],
            "OM2":[7,8,9],
            "OM3":[10,11,12,13],
        ]

        var largest = 0
        for (kind, number) in numbers {
            for soures in number {
                if soures > largest {
                    largest = soures;
                    print(kind)
                    print(largest)
                }
            }

}

kind 为遍历的key值 number 为value 集

使用if和switch来进行条件操作，使用for-in、for、while和repeat-while来进行循环

varn =2
        while n < 100 {
            n = n * 2
        }
        print(n)

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

print(m)

for 循环有两种方式

varfirstForLoop =0
        for i in 0..<4{
           firstForLoop += i
        }
        print(firstForLoop)


        var secondForLoop = 0
        for var i = 0; i < 4; ++i {
            secondForLoop += i
        }

print(secondForLoop)

0..<4 i<4 效果一致使用..<创建的范围不包含上界，如果想包含的话需要使用...。

// 闭包函数

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

func greet(name: String, foot:String) ->String{
            return "hello \(name), today eat\(foot)."
        }
        greet("xiaoMing", foot:"salad")

print(greet("xiaoMing", foot:"salad"))

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

funccalculates(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 = calculates([5,3,100,3 ,9])
        print(statistics.sum)

print(statistics.1)

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

funcsumOf(numbers:Int...) ->Int {

           varsum =0
            for number in numbers {
                sum += number
            }
            return sum
        }
        sumOf()
        sumOf(42,579,12)
        print(sumOf(42,579,12))

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

        func calculates(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 = calculates([5,3,100,3 ,9])
        print(statistics.sum)

print(statistics.1)

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

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

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

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(numbers, condition: lessThanTen)