• swift基础学习笔记

     1、变量声明

    1.1 类型标注

            当你声明常量或者变量的时候可以加上类型标注（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称

    1. 变量 var 修饰  例如：var a:Int=10//声明一个为Int类型的变量a并赋值为10 
    2. 获取 var b:String="hello 树哥"//声明一个为String类型的变量b并赋值为" hello 树哥 "

    1.2 自动类型推断

            swift 可以自动类型推断 ，当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。

    1. var a=10//自动推断为Int类型
    2. var b="hello 树哥"//自动推断为String 类型
    3. var varB = 3.14159// varB 会被推测为 Double 类型

    1.3 类型安全

    Swift 是一个类型安全（type safe）的语言。

    由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误

    1. var a=10
    2. a="hello 树哥"//提示错误：error: cannot assign value of type 'String' to type 'Int'

    意思为不能将 'String' 字符串赋值给 'Int' 变量

    1.4 可选类型

    Swift 的可选（Optional）类型，用于处理值缺失的情况。可选表示"那儿有一个值，并且它等于 x "或者"那儿没有值"。类似与kotlin dart语言 可空类型,例如：

    var myString:String? = nil

    说明myString的值可以赋值为nil 如 myString=nil,也可以赋值正常String 值 ，如 myString ="hello 树哥"

    1.4.1 强制解析

    当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个感叹号表示这个值一定不为空 这个和dart语言类似 跟kotlin的!!类似，比如：

    1. var myString:String? = "hello 树哥"
    2. print(myString) //打印输出: Optional("hello 树哥")

    加上！

    1. var myString:String? = "hello 树哥"
    2. print(myString!) //打印输出:hello 树哥

    1.4.2 自动解析

    在声明可选变量时使用感叹号（!）替换问号（?）。这样可选变量在使用时就不需要再加一个感叹号（!）来获取值，它会自动解析。

    1. var myString:String!
    2. myString = "hello 树哥"
    3. print(myString)//打印输出:hello 树哥

    当然如果变量在声明时就已经赋初始值的情况就可以直接使用了，例如：

    1. var myString:String = "hello 树哥"
    2. print(myString)//打印输出:hello 树哥

    1.4.3 可选绑定

    使用 if let临时常量 = 可选类型 来判断可选类型是否包含值，如果包含就把值赋给临时常量，否则（可选类型为nil时）if语句判断为假。

    1. var optionalName: String? = "树哥"
    2. var greeting = "树哥!"
    3. if let name = optionalName {
    4.     greeting = "Hello, \(name)"
    5. }
    6. print(greeting)

    如果optionalName的值不为空，则把optionalName的值赋值给name ,然后运行  {

        greeting = "Hello, \(name)"

    }的语句，比如以上例子 最后打印下greeting值，因为 greeting = "树哥!"已赋值不为空，所以最后打印 Hello,树哥！

    如果optionalName的值是nil   条件会判断为false 大括号里面的代码会跳过；

    1.4.4 类型别名

    类型别名对当前的类型定义了另一个名字，类型别名通过使用 typealias 关键字来定义。语法格式如下：

    typealias newname = type

    例如以下定义了 Int 的类型别名为 Feet：

    typealias Feet = Int

    现在，我们可以通过别名来定义变量：

    1. typealias Feet = Int
    2. var distance: Feet = 100
    3. print(distance)

    1.5 Swift 字符串 

    1.5.1 字符串

    你可以通过使用字符串字面量或 String 类的实例来创建一个字符串：

    1. // 使用字符串字面量
    2. var stringA = "Hello, World!"
    3. print( stringA )
    4.  
    5.  
    6. // String 实例化
    7. var stringB = String("Hello, World!")
    8. print( stringB )
    9.  
    10.  
    11. // 使用字符串字面量创建空字符串
    12. var stringA = ""

    1.5.2 Swift 字符(Character)

    let char1: Character = "A" //只能单个字符 多个会报错

    例如：

    1. // Swift 中以下赋值会报错
    2. let char: Character = "AB"

    //空字符变量

    Swift 中不能创建空的 Character（字符） 类型变量或常量：

    2、声明常量

    常量一旦设定，在程序运行时就无法改变其值。

    常量可以是任何的数据类型如：整型常量，浮点型常量，字符常量或字符串常量。同样也有枚举类型的常量：

    常量类似于变量，区别在于常量的值一旦设定就不能改变，而变量的值可以随意更改。

    1. let a= 42
    2. a=20//报错 ，常量不可修改值
    3. print(a)

    其他都和变量一样，比如类型推荐、类型标注、类型别名等

    3、运算符

    像算术运算符（swift取消了++和--）、比较运算符、逻辑运算符和大多数编程语言一样，区间运算符 ... 这个比较独特类似kotlin的

    Swift 提供了两个区间的运算符。

    运算符

    描述

    实例

    闭区间运算符

    闭区间运算符（a...b）定义一个包含从a到b(包括a和b)的所有值的区间，b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在for-in循环中：

    1...5 区间值为 1, 2, 3, 4 和 5

    半开区间运算符

    半开区间（a..<b）定义一个从a到b但不包括b的区间。 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。

    1..< 5 区间值为 1, 2, 3, 和 4

    比如

    1. //闭区间运算符:
    2. for index in 1...5 {
    3.     print(index)
    4. }
    5. //打印 1,2,3,4,5
    6.  
    7.  
    8. //半开区间运算
    9. for index in 1..<5 {
    10.     print(index)
    11. }//打印 1,2,3,4

    3.1 Swift 空格

    Swift语言并不是像C/C++，Java那样完全忽视空格，Swift对空格的使用有一定的要求

    运算符不能直接跟在变量或常量的后面。例如下面的代码会报错：

    1. let a= 1 + 2 //a后面直接加上等号（=）
    2. let a = 1+ 2//1后面直接添加 加号（+）
    3. let a =1+ 2
    4. let a=1+2
    5. let a=1+ 2
    6. let a =1+2//=后面直接跟上数值

    只有这样写才不会报错：

    1. let a = 1 + 2;  // 编码规范推荐使用这种写法
    2. let b = 3+4 // 这样也是OK的

    4、条件语句

    if语句和其他编程语言一样 忽略

    switch语句有点区别

    Swift switch 语句中，默认语法是必须要添加 default 语句。但也可以不加

    注意：在大多数语言中，switch 语句块中，case 要紧跟 break，否则 case 之后的语句会顺序运行，而在 Swift 语言中，默认是不会执行下去的，switch 也会终止（switch 不会从上一个 case 分支落入到下一个 case 分支中。只要第一个匹配到的 case 分支完成了它需要执行的语句，整个switch代码块完成了它的执行）。如果你想在 Swift 中让 case 之后的语句会按顺序继续运行，则需要使用 fallthrough 语句。

    4.1 省略break

    Swift Switch 语句中， break 是可以省略不写的(添加了也可以)，默认执行完当前 case 下的内容后，直接返回了，即使后续还有可满足的条件。

    1. var a=2
    2. switch(a){
    3.     case 1:
    4.     print("hello 树哥")
    5.     case 2:
    6.     print("hello 王哥")
    7.     case 2:
    8.     print("hello 宝哥")
    9.     case 4:
    10.     print("hello 强哥")
    11.     default:
    12.     print("hello 绿哥")
    13.     
    14. }
    15. //打印hello 王哥

    4.2 fallthrough

    Swift fallthrough 语句让 case 之后的语句会按顺序继续运行，且不论条件是否满足都会执行。

    1. var a=2
    2. switch(a){
    3.     case 1:
    4.     print("hello 树哥")
    5.     case 2:
    6.     print("hello 王哥")
    7.      fallthrough
    8.     case 3://这里改为3了
    9.     print("hello 宝哥")
    10.     case 4:
    11.     print("hello 强哥")
    12.     default:
    13.     print("hello 绿哥")
    14.     
    15. }
    16. //hello 王哥
    17. //hello 宝哥

    5、Swift 数组

    Swift 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

    Swift 数组会强制检测元素的类型，如果类型不同则会报错，Swift 数组应该遵循像Array<Element>这样的形式，其中Element是这个数组中唯一允许存在的数据类型。

    如果创建一个数组，并赋值给一个变量，则创建的集合就是可以修改的。这意味着在创建数组后，可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量，数组就不可更改，并且数组的大小和内容都不可以修改。

    5.1 创建数组

    以下是创建一个初始化大小数组的语法：

    var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)

    以下实例创建了一个类型为 Int ，数量为 3，初始值为 0 的空数组：

    var someInts = [Int](repeating: 0, count: 3)

    以下实例创建了含有三个元素的数组：

    1. var someInts:[Int] = [10, 20, 30]
    2. var someStrings:[String]=["hello","啊","树哥"]

    5.2 访问数组

    我们可以根据数组的索引来访问数组的元素，语法如下：

    var someVar = someArray[index]

    index 索引从 0 开始，即索引 0 对应第一个元素，索引 1 对应第二个元素，以此类推。

    1. var a:[Int] = [1,2,3,5]
    2. print(a[0])//打印：1

    5.3 遍历数组

    var a:[String]=["hello","啊","树哥"]

    for 循环

    1. for i in a{
    2.     print(i)
    3. }

    forEach循环

    1. a.forEach {
    2. i in print(i)
    3. }

     enumerate() 方法遍历（需要每个数据项的值和索引值）

    1. var a:[]=["hello","啊","树哥"]
    2. for (index, item) in a.enumerated() {
    3.     print("在 index = \(index) 位置上的值为 \(item)")
    4. }
    5. 打印:
    6. 在 index = 0 位置上的值为 hello
    7. 在 index = 1 位置上的值为 啊
    8. 在 index = 2 位置上的值为 树哥

    5.4 修改数组

    使用 append() 方法或者赋值运算符 += 在数组末尾添加元素

    1. var a:[String]=["hello","啊","树哥"]
    2. a.append("宝哥")
    3. //或者 a+=["宝哥"]
    4. print(a)
    5. //打印: ["hello", "啊", "树哥", "宝哥"]
    6. 也可以通过索引修改数组元素的值：
    7.  
    8. var a:[String]=["hello","啊","树哥"]
    9. a[1]="呀"//修改数组第二个元素的值
    10. print(a)
    11. //打印：["hello", "呀", "树哥"]

    5.5 isEmpty 属性

    我们可以通过只读属性 isEmpty 来判断数组是否为空，返回布尔值：

    1. var a:[String]=["hello","啊","树哥"]
    2.  
    3. print("a.isEmpty = \(a.isEmpty)") //输出 a.isEmpty = false

    6、 字典

    Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。

    Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。

    和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

    Swift 字典的key没有类型限制可以是整型或字符串，但必须是唯一的。

    如果创建一个字典，并赋值给一个变量，则创建的字典就是可以修改的。这意味着在创建字典后，可以通过添加、删除、修改的方式改变字典里的项目。如果将一个字典赋值给常量，字典就不可修改，并且字典的大小和内容都不可以修改。

    6.1 创建字典

    var someDict =  [KeyType: ValueType]()

    以下是创建一个空字典，键的类型为 Int，值的类型为 String 的简单语法：

    var someDict = [Int: String]()

    创建一个非空字典，同样key为Int类型，value为String类型,例如 ：

    var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] ，

    6.2 访问字典

    我们可以根据字典的索引来访问数组的元素，语法如下：

    var someVar = someDict[key]

    例如

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3. print(someDict[2]!)//打印：a (此处使用了强制解析！不然会打印Optional("a"))

    6.3 修改字典

    6.3.1 updateValue

    我们可以使用 updateValue(forKey:) 增加或更新字典的内容。如果 key 不存在，则添加值，如果存在则修改 key 对应的值。updateValue(_:forKey:)方法返回Optional值。

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3. print(someDict[2])
    4.  
    5. someDict.updateValue("呀",forKey:2)
    6.  
    7. print(someDict[2])
    8. //打印：
    9. Optional("a")
    10. Optional("呀")

    6.3.2 通过指定的 key 来修改

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3. print(someDict[2])
    4.  
    5. someDict[2]="啊"
    6.  
    7. print(someDict[2])
    8. //打印：
    9. Optional("a")
    10. Optional("啊")

    6.4 移除 Key-Value 对

    6.4.1  removeValueForKey() 

    我们可以使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值，如果不存在返回 nil 

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3. someDict.removeValue(forKey: 2)
    4.  
    5. for x in someDict{
    6.     
    7.     print(x)
    8. }
    9. //打印：
    10. (3, "树哥")
    11. (1, "hello")

    6.4.2 指定键的值为 nil 

    通过指定键的值为 nil 来移除 key-value（键-值）对

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3.  
    4. someDict[2]=nil
    5.  
    6.  
    7. for x in someDict{
    8.     
    9.     print(x)
    10. }
    11. //打印：
    12. (3, "树哥")
    13. (1, "hello")

    6.5 字典遍历

    字典的遍历和数组一样 for循环、forEach或者enumerate()方法

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3.  
    4. for (key,value) in someDict{
    5.     
    6.     print("key=\(key),value=\(value)")
    7. }
    8.  
    9.  
    10. for (key, value) in someDict.enumerated() {
    11.     print("字典 key \(key) -  字典 (key, value) 对 \(value)")
    12. }
    13.  
    14.  
    15. someDict.forEach{
    16.     
    17.     (key,value) in  print("key=\(key),value=\(value)")
    18. }
    打印结果：
    key=2,value=a
key=3,value=树哥
key=1,value=hello
字典 key 0 -  字典 (key, value) 对 (2, "a")
字典 key 1 -  字典 (key, value) 对 (3, "树哥")
字典 key 2 -  字典 (key, value) 对 (1, "hello")
key=2,value=a
key=3,value=树哥
key=1,value=hello

    6.6 count 属性

    使用只读的 count 属性来计算字典有多少个键值对：

    1. var someDict:[Int:String] = [1:"hello", 2:"a", 3:"树哥"]
    2.  
    3. print(someDict.count)//打印：3

    7、元组

    元组类型，用于在单个复合值中对多个值进行分组

    元组中的值可以是任何类型，并且不需要是相同类型

    7.1 元组声明

    方式1:最简单的元组，就是在圆括号中，用逗号分隔的一组值

    1. var aTuple = (10, "TottiLV")
    2. //也可以存放数组和字典
    3. //例如
    4. let arr = [1,2,3]
    5. let dic = ["key1":"value1","key2":"value2","key3":"value3"]
    6. let anyTuple = (arr, dic)

    是一个具有两个值的元组，一个元素是整数类型，另一个元素是字符串类型（这是一个合法的数据）

    方式2:可以在声明时命名元组的变量，也可以使用它们的名称来调用

    let error404= (errorCode:404, description:"Not Found")

    7.2 访问元组

    7.2.1 使用下标取值

    1. let error404 = (errorCode:401, description:"Not Found")
    2. //取下标为1处的值
    3. print(error404.1)//打印：Not Found

    7.2.2 使用元素名称

    1. let error404 = (errorCode:401, description:"Not Found")
    2.  
    3. print(error404.errorCode)//输出:401

    7.2.3 拆分成常量/变量

    1. let error404 = (errorCode:401, description:"Not Found")
    2. var (x,y)=error404
    3. print(x)
    4. print(y)
    5. //打印：
    6. 401
    7. Not Found

    7.2.4 总结

    元组优点：

     1、元组可以同时存储多种类型元素，且元素类型固定，以保数据安全，除非你定义数据类型为Any。编译器会对赋值参数类型进行检查

     2、元组的元素个数固定，不允许增加、删除，编译器会严格校验赋值参数个数

     3、无需定义key，但是必要时可以为数据命名，方便数据访问

     4、适合同时遍历多元数据

     元组缺点：

     1、不适合存储大量数据，因为元组不支持append、remove等方法

     2、考虑到工程实际情况，后段使用的语言可能不支持元组，需要转换为其他格式

     元组适合应用于组合少量的多元的数据，与数组、字典结合使用可以产生强大威力

    8、函数

    8.1函数定义

    Swift 定义函数使用关键字 func。

    定义函数的时候，可以指定一个或多个输入参数和一个返回值类型。

    每个函数都有一个函数名来描述它的功能。通过函数名以及对应类型的参数值来调用这个函数。函数的参数传递的顺序必须与参数列表相同。

    函数的实参传递的顺序必须与形参列表相同，-> 后定义函数的返回值类型。

    语法

    1. func funcname(形参) -> returntype
    2. {
    3.    Statement1
    4.    Statement2
    5.    ……
    6.    Statement N
    7.    return parameters
    8. }

    8.2 函数的创建

    8.2.1 无参数、无返回值

    1. func fun1(){   
    2.     print("无参数、无返回值函数")
    3. }

    8.2.2 有参数 无返回值

    1. func fun2(name:String){   
    2.     print("有参数无返回值函数 \(name)")
    3. }
    //调用
fun2(name:"hello")

    8.2.3 无参数 有返回值

    1. func fun3()->String{
    2.     return "hello"
    3. }

    8.2.4 有参数 有返回值

    1. func fun4(name:String)->String{
    2.     return "hello " + "\(name)"
    3. }

    //调用
    fun2(name:"hello"）

    8.3 参数标签

    8.3.1 参数名带标签

    swift 函数中 参数名可以带标签

    一般情况下我们声明一个函数，如下

    1. func fun5(name:String){
    2.   print("hello \(name)")
    3. }

    调用：fun5(name:"树哥")

    然后使用参数标签的话，可以这样写

    1. func fun6(xxx name:String){
    2.   print("hello \(name)")
    3. }

    调用: fun6(xxx :"树哥)

    8.3.2 忽略参数名

    标签的作用就是提示 标签可以使用 _ 来代替，这样调用函数的时候，直接传值要传的值就行了,例如：

    1. func fun9(_ name:String){
    2.   print("hello \(name)")
    3. }
    4. fun9("树哥")

    8.4 函数参数默认值

    函数中默认参数指的是赋了初始值的参数，在调用函数的时候 默认参数可传也可不传，类似kotlin和dart一样

    1. func fun10(msg:String,name:String="树哥"){   
    2.     print(msg+"\(name)")
    3. }
    4.  
    5. fun10(msg:"hello")
    6. fun10(msg:"hello",name:"大树")

    8.5 函数中的输入输出函数（inout）

    一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。

    如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。例如：

    func  getName(_ name: inout String).........

    此时这个 name 值可以在函数中改变。

    一般默认的参数传递都是传值调用的，而不是传引用。所以传入的参数在函数内改变，并不影响原来的那个参数。传入的只是这个参数的副本。

    当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

    1. func swapValues(_ v1: inout Int, _ v2: inout Int) {
    2.     let tmp = v1
    3.     v1 = v2
    4.     v2 = tmp
    5. }
    6. var num1 = 10
    7. var num2 = 20
    8. swapValues(&num1, &num2)
    9. print(num1)//打印输出：20 
    10. print(num2)//打印输出：10

    8.6 函数重载

    规则

    1、函数名相同

    2、参数个数不同 || 参数类型不同 || 参数标签不同

    9、 闭包

    10、结构体

    11、类

    12、拓展

  • 相关阅读:
    数据库审核工具SQLE接口调用
    递归最小二乘法RLS
    ＜MySQL＞ 表的增删改查 - 基本查询
    Git 名词简单学习
    Unity中Shader的扭曲（不是UV的扭曲）
    JRaft框架学习笔记
    穿越时空的创新：解析云原生与Web3.0的奇妙渊源
    P02项目诊断报警组件（学习操作日志记录、单元测试开发）
    使用MicroApp重构旧项目
    Xilinx FPGA 超温关机保护
  • 原文地址：https://blog.csdn.net/csj731742019/article/details/125453038