基础巩固一地址

程序执行的过程：

硬盘（程序\软件）---装载--->内存----->CPU(cpu对内存的数据进行读写操作)-----> 控制计算机做响应的操作
CPU=寄存器(信息存储)+运算器(信息处理)+控制器
汇编语言分类：

• 8086汇编（16bit）
• x86汇编（32bit）
• x64汇编（64bit）
• ARM汇编（嵌入式、移动设备）

常量

• 只能赋值一次
• 它的值不要求在编译期确定，但是在使用之前必须赋值一次，所以变量和常量在初始化之前都不可以使用

标志符

• 常量名、变量名、函数名几乎可以使用任何字符*但是不能以数字、空白字符、制表符、箭头等特殊字符开头

数据类型

• Swift中只有两种类型：1. 值类型 2. 引用类型
• 浮点类型：Float，32位 精度只有6位；Double 64位 精度至少15位

元组

let loveMessage = (loveFlutter:"Dart",loveObjectC:"OC")
print("i love \(loveMessage.loveFlutter) and \(loveMessage.loveObjectC)")
//i love Dart and OC

for-区间运算符

• 单侧区间：让一个区间朝一个方向无穷大

let fruits = ["apple","banana","water"]
for fruit in fruits[1...]{
    print(fruit)
}
//banana water
//单侧区间从无穷小到一个方向
for fruit in fruits[...2] {
    print(fruit)
}
//apple banana water
let rangeNumber = ...10
print(rangeNumber.contains(30))//false

// 区间类型
let range1: ClosedRange<Int> = 1...3
let range2: Range<Int> = 1..<3 //半开区间
let range3: PartialRangeThrough<Int> = ...5//半侧区间

for循环

var num = -3
repeat{
    print("123")
    num += 1
}while num < 0
//123 123  123
// 相当于C语言中的do-while

var numbers = [-10,-20,-10,-20,30,-30]
var sum = 0
for num in numbers where num > 0 {
    sum += num
}
print(sum)
//30

标签语句
outer: for i in 1...4{
    for j in 1...4 {
        if j == 3 {
            continue outer
        }
        if i == 3 {
            break outer
        }
        print("i==\(i),j==\(j)")
    }
}
//i==1,j==1
//i==1,j==2
//i==2,j==1
//i==2,j==2

带间隔的区间值

for number in stride(from: 0, to: 10, by: 2) {
    print(number)
}
//0 2 4 6 8

• 注意点：并不包含最后一个值 例子中就不会打印10

switch语句

var num = 1
switch num {
case 1:
    print("1")
default:
    print("default")
}
// 如果能够处理完所有的事情，可以不使用default
switch num {
case 1...5:
    print("yes")
default:
    print("no")
}
//yes

• Swift中的switch是支持Character 和String类型的

let string = "apple"
switch string {
case "apple":
    print("apple")
    fallthrough
case "water":
    print("water")
    fallthrough
case "orange":
    print("orange")
default:
    print("fruits")
}

//apple water orange
//复合条件的编写，可以用逗号隔开
switch string {
case "apple","water":
    print("apple,water")
case "orange":
    print("orange")
default:
    print("fruits")
}
//apple,water

let point = (1,1)
switch point {
case (0,0):
    print("不在该坐标系中")
case (_,1):
    print("匹配到了！！")
    fallthrough
case (0...3,0...3):
    print("在这个范围内")
default:
    print("default")
}
//匹配到了！！
//在这个范围内

let coordinate = (1,0)
switch coordinate {
case (let x, 0):
    print("x轴随意，y轴为0")
case (0,let y):
    print("y轴随意，x轴为0")
case let(x,y):
    print("这个坐标系随便选择")
}
//x轴随意，y轴为0

coordinate = (1,1)
switch coordinate {
case (let x, 0) :
    print("x轴随意，y轴为0")
case (0,let y):
    print("y轴随意，x轴为0")
case let(x,y) where x == y:
    print("x,y 相等")
case (_, _):
    print("00")
}
//x,y 相等

函数

func sum (p1:Int,p2:Int) -> Int{
    return p1 + p2
}
print(sum(p1: 10, p2: 10))
//20

//默认参数值

func eatFruits(one: String = "apple",another:String = "orange"){
    print("one:\(one),another:\(another)")
}
eatFruits(one: "banana", another:"")
eatFruits()
//one:banana,another:
//one:apple,another:orange

/// 可变参数,一个函数最多只能有1个可变参数
/// 紧跟在可变参数后面的参数不能省略参数标签
func sum(_ numbers:Int...) -> Int{
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}
print(sum(10,20,30))
//输入输出参数 inout ：可以在函数内部修改外部实参的值
func swapValues(_ v1: inout Int,_ v2:inout Int){
    let temp = v1
    v1 = v2
    v2 = temp
}
var num1 = 10
var num2 = 0
swapValues(&num1, &num2)
print(num1,num2)
// 0 10
注意点：可变参数不能标记为inout
inout参数不可以有默认值
inout参数本质是地址传递
intout参数只能传递可以被多次赋值的

// 函数重载
// 规则
// 函数名相同
// 参数个数不同 || 参数类型不同 || 参数标签不同
func sum(v1:Int,v2:Int) -> Int{
    return v1 + v2
}
func sum(v1:Int,v2:Int,v3:Int) -> Int{
    return v2 + v1 + v3
}

func sum(v1:Double,v2:Int) -> Double{
    return v1 + Double(v2)
}
注意：返回值类型与函数重载无关

返回值是函数类型的函数叫做高阶函数

typealias 用来给类型或者元组起别名

枚举类型

* 有时候会将枚举的成员值跟其他类型的关联存储在一起，会非常有用
enum Score{
    case points(Int)
    case grade(Character)
}
var score = Score.points(96)
score = .grade("A")

enum Date{
    case digit(year:Int,month:Int,day:Int)
    case string(String)
}
var date = Date.digit(year: 2019, month: 8, day: 04)
date = .string("2019-08-05")

switch date {
case .digit(let year,let month,let day):
    print(year,month,day)
case let .string(value):
    print(value)
}
//2019-08-05
// 枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做：原始值
enum PokerSuit:Character{
    case spade = "♠️"
    case heart = "♥️"
    case diamond = "♦️"
    case club  = "♣️"
    
}

var suit = PokerSuit.spade
print(suit)
print(suit.rawValue)
print(PokerSuit.club.rawValue)
//spade
//♠️
//♣️

//递归枚举
indirect enum ArithExpr{
    case number(Int)
    case sum(ArithExpr,ArithExpr)
    case difference(ArithExpr,ArithExpr)
}

let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let sum = ArithExpr.sum(five, four)
let two = ArithExpr.number(2)
let difference = ArithExpr.difference(sum, two)

func calculate(_ expr: ArithExpr)-> Int{
    switch expr {
    case let ArithExpr.number(value):
       return value
    case let .sum(left,right):
        return calculate(left) + calculate(right)
    case let .difference(left,right):
        return calculate(left) - calculate(right)
    }
}

calculate(difference)
var num = calculate(difference)
print(num)
//7

//可选项绑定
//可以使用可选项绑定来判断可选项是否包含值
//如果包含只就自动解包，把值赋给一个临时的常量或者变量，并返回true，否则返回false
if let number = Int("123"){
    print("转换成功\(number)")
}else{
    print("转换失败")
}
//转换成功123

• 04 58