Swift --- 01 基础语法

Swift 的ABI趋于稳定之后，开始加入Swift的学习队伍中；
基本从 0 开始，写下Swift的学习笔记

常量

let 关键字，修饰一个不可变的常量；
1、使用let，修饰，只能赋值一次；

例子：
let a = 1

2、不要求在编译时期确定值，但在使用之前必须有值；

例子：
let a:Int 
a = 1

3、常量在初始化之前，都不能使用；
例子： 4、编译时期，未赋值的常量，必须有类型，不能给未确定类型的常量赋值；

常见数据类型

Swift 主要分为：值类型、引用类型
值类型
包含：

• 枚举
  包含：Optional（可选项）

• 结构体
  包含：Bool、Int、Float、Double、Character、String、Array、Dictionary、Set

  疑问🤔️：
  不知道大家会不会好奇，为什么要把Bool、Int等，定义为结构体，
  那会不会导致结构体占用空间过大？
  
  解答：
  定义为结构体，主要是为了方便使用，后续会解答为什么会说很方便；
  
  要清楚，一个结构体占用的空间大小，取决于它内部属性的数量；所以Bool、Int占用的大小并不会太多；
  并且Swift内部也会做一定的优化，所以不用太担心，使用结构体会有内存空间大小问题；
  

引用类型
包含：

• 类（Class）

字面量

1、布尔字面量

let bool = true

true 就是字面量

2、字符串字面量

let string = "我爱吃榴莲"

 "我爱吃榴莲" 就是字面量

3、字符字面量

let character:Character = "🐶🐶"

 "🐶🐶" 就是字面量

4、整数字面量

let number = 10

 10 就是字面量

5、浮点字面量

let float = 10.12

 10.12 就是字面量

6、数组字面量

let array = [1,2,3,4]
[1,2,3,4] 就是字面量

7、字典字面量

let dict = ["name":"榴莲", "age":2]
["name":"榴莲", "age":2] 就是字面量

类型转换

注意：只有类型相同，才能执行运算逻辑；
1、整数转换，

let int1:UInt16 = 10
let int2:UInt8 = 2;
let int3 = int1 + UInt16(int2);

2、整数、浮点数转换

let int = 3
let double = 0.0234
let sum = Doubl(int) + double

3、字面量相加
注意：字面量可以直接做运算逻辑，因为数字字面量本身没有确定类型

let sum = 3 + 0.123

元组

元组（tuples）把多个值组合成一个复合值；

元组的声明、使用

1、元组内的值可以是任意类型，不要求是相同类型

简单的元组：
   let aTuple = (10,"I'm Tuple")
   print("age = \(aTuple.0)")
     
   let (age, name) = aTuple
   print("age = \(age), name = \(name)")

带名称的元组：
   let aTuple = (age:10,name:"I'm Tuple")
   print("age = \(aTuple.age),name =  \(aTuple.name)")

2、元组赋值的时候，不接收某个元素时，使用_表示；

   let (age, _) = aTuple
   print("age = \(age)")

3、一旦声明，可以改值，但不能添加/删除元素

   var aTuple = (10,"I'm Tuple")
   aTuple = (20,"Tuple2","我是新增元素")//此处会报错误
   //元组元素变动，系统会提示错误；

4、不能更改已经声明的元素名称

   var aTuple = (age:10,name:"I'm Tuple")
   aTuple = (20,myName:"Tuple2")//此处会报错误
   //使用时，可以省略元素名称，但不能修改；

5、已声明的名称可以省略，但未声明名称的元组，不可添加名称：

var aTuple = (10, "Tuple") // 未声明名称
aTuple = (10, name:"Tuple") // 后期添加名称，可行但无效
aTuple.name // 错误

if-else

if条件只能是Bool类型的，条件可以省略小括号；

let age = 4
if age>= 20 {
} else if age >18 {
} else if age >10 {
}else {}

while

var num = 3
while num > 0 {
    print(num = \(num))
    num -= 1
}
//打印3次

var num = -1
repeat {
    print(num = \(num))
}while num > 0 
//打印一次

注意：
1、repeat-while 相当于C语言里的 do-while
2、Swift 没有 --、++的运算符

for 循环

1、闭区间运算符：a...b；a<= 取值 <= b；a、b可以随意取值

let characters = ["a","b","c","d"]
// i 默认是let，需要时也可声明为var
for var i in 0...3
{
    print(character = \(i))
}

// i 取值范围为：0、1、2、3

2、半开区间运算符：a.. <b，a<= 取值 < b

for i in 1..<3
{
    print(i = \(i))
}
// i 取值范围为：1、2

3、区间运算符在数组上使用

let names =["a","b","c","d"]
for name in names[0...3]
{
    print(name)
}

4、单侧区间运算符：让区间朝一个方向尽可能的远

let names =["a","b","c","d"]
for name in names[0...]
{
    print(name)
}
注意⚠️：目前names数组，最大是4，所以达到4的时候，就会跳出循环

for name in names[...2]
{//限制区间最大是2，最小是0
    print(name)
}

for name in names[...<2]
{//最大值<2，最小是0
    print(name)
}

5、带间隔的区间值 比如上面说的区间值，都是连续的，1...5，区间值就是1，2，3，4，5；
那如果我想跳着取区间，比如说取：1，3，5，这就需要通过 stride 函数来实现

let hours = 11
let hoursInterval = 2
//ticMark 从4开始，最大区间为11，间隔2个数据取值
for ticMark in stride(from: 4, through: hours, by: hoursInterval){

    print(ticMark)

}// 4、6、8、10

switch

1、case、default后面，不能写大括号{}

let number = 1
switch number{
    case 1:
        print("number = 1")
        break
    case 2:
        print("number = 2")
        break
    default:
        break
}

2、默认可以不写break，并不会贯穿到后面的条件；

let number = 1
switch number{
    case 1:
        print("number = 1")
    case 2:
        print("number = 2")
    default:
}

3、如果要在switch实现贯穿效果，可以添加fallthrough

let number = 1
switch number{
    case 1:
        print("number = 1")
        fallthrough
    case 2:
        print("number = 2")
    default:
}
// 如此，case1、case2就都可以执行了

4、‼️‼️switch如果能保证处理了所有的情况，可以不使用default；
如果没有处理完整，那么需要在使用case、default搭配使用

enum Answer {case aright,awrong}
let answer = Answer.aright
switch answer{
    case .aright:
        print("aright")
    case .awrong:
        print("awrong")
}

switch answer{
    case .aright:
        print("aright")
    defalut:
        break
}

5、switch 判断条件，也支持Character、String类型，并且支持复合条件case

let character:Character = "a"
switch character{
    case "a","A"://复合条件
        print("aright")
    default:
        break
}

6、区间匹配、元组匹配

// 区间匹配
let number = 50
switch number{
    case 0 :
        print("0")
    case 10...20 :
        print("10~20")
    case 21..<30 :
        print("21~29")
    default:
        break
}

// 元组匹配
let point = (1,1)
switch point{
    case (0,0) :
        print("x，y = 0")
    case (_,1) :
        print("只要满足y=1，x不要求")
    case (1,_) :
        print("只要满足x = 1，y不要求")
    case (-1...1,-1...1) :
        print("x，y = 1")
    default:
        break
}

7、值绑定

let point = (1,1)
switch point{
    case (let x,0) :
        print("x 0= \(x)")
    case (let x ,1) :
        print("x = \(x)")
    default:
        break
}
// 将元组里的数据，赋值给一个常量，可以在case内部，使用该常量

注意⚠️： case、default后面至少要有一句代码，不然系统会提示错误

where

where额外条件判断语句

let point = (1,1)
switch point{
    case (let x,let y) where x==y: //满足case，并且满足where的额外条件，才执行print
        print("x = y")
    case (let x ,let y) where x == -y:
        print("x = -y")
    default:
        break
}

var numbers = [-10,10,4,-30,20]
var sum = 0
for num in numbers where num > 0 // 满足 num > 0 ，才执行for循环内部逻辑
{
    sum += num
}
print(sum)

标签语句

outer: for i in 1...4{
    print("w i == \(i)")
    for k in 1...4 {
        print("k == \(k)")
        if k == 3
        {
            continue outer 
        }
        if i == 3
        {
            break outer
        }
        print(i,k)
    }
}

// while 循环体使用自定义标签
let a = 1
let b = 3
gameLoop: while a != b {
    switch xxx {
    case xxx:
        break gameLoop
    case xxx:
        continue gameLoop
    default:
        break
    }
}

outer 为标签名，可自定义；
continue outer 表示：外部for循环执行continue逻辑；
break outer表示：外部for循环，执行break逻辑，结束循环；