【swift】swift quick start

一、常量和变量

常量let，变量var
也可以用于确定数组和字典的不可变和可变

二、数据类型：

Int：整数类型，可表示有符号整数或无符号整数，分别使用Int和UInt表示。
Float：单精度浮点数类型，用于存储小数。
Double：双精度浮点数类型，用于存储更大的小数，精度更高。
Bool：布尔类型，表示真或假。
String：字符串类型，用于存储文本数据。
Character：字符类型，用于存储单个字符。
Array：数组类型，用于存储有序集合。
Dictionary：字典类型，用于存储键值对集合。
Set：集合类型，用于存储无序集合。
Optional：可选类型，用于表示值可能不存在的情况。

四则运算

类型匹配才能加减乘除
或者有些情况需要(Type)强转类型

数据类型里需要特别注意的几个：
String

遍历： for in 
拼接： + 
格式化输出 ： let str = String(format: "%@=%@", key, value)
还有一种\()的快速输出方法 var str =  "制作一杯\(type)咖啡。"
模版语法：let string = "”" 
                         Hello Swift! 
                         Hello Swift!
                         Hello Swift! 
                     """

Array

定义和初始化：

// let代表不可变数组
let array:Array<String> 
// var代表可变数组
var array: [String]

然后初始化的时候字面量给值就可以了
后边的类型可给可不给

增：
append 

删:
remove(at: 0) // 删除第一个元素并将其返回
removeLast() // 删除最后一个元素并将其返回
removeFirst()

改:
array[0] = "asd"

插入:
myArray.insert(7, at: 0) // 在第一个位置插入元素 7

数组长度：
.count可以拿到长度

拼接：
+

遍历for in 和map闭包都可
//for in
for element in myArray { 
    print(element) 
}

//map
let result = numbers.map({ (number: Int) -> Int in
    let result = number * 2
    return result
})

Dictionary（map）
定义和初始化：

var dict1: Dictionary<Int, String> 
var dict2: [Int: String]
然后初始化的时候字面量给值就可以了
后边的类型可给可不给

// 添加数据
dict["height"] = 1.88 
// 删除字段
dict.removeValueForKey("height”) 
// 修改字典
dict["name"] = "花花” 
// 查询字典
dict["name”]


//合并
var dict1 = ["name" : "花花", "age" : 18] 
var dict2 = ["height" : 1.8] 
// 字典不可以直接相加合并 
for (key, value) in dict2 { 
    dict1[key] = value 
}

//遍历
// 遍历字典中所有的值 
for value in dict.values { 
    print(value) 
} 
// 遍历字典中所有的键 
for key in dict.keys {
    print(key) 
} 
// 遍历所有的键值对 
for (key, value) in dict { 
    print(key) print(value) 
}

Optional
Pre: nil

在 Swift 中，nil 是一个特殊的值，用于表示“没有值”。nil 是一个可选类型（Optional），它可以用于表示一个值不存在的情况。
在 Swift 中，所有的变量和常量都必须要初始化，即使是一个空字符串或者空数组。如果你没有为一个变量或常量赋值，Swift 会报错。但是，当你使用可选类型时，可以将其初始化为 nil，表示该值目前不存在。这个特性很有用，因为有时你并不知道一个变量或常量的初始值是什么。

1)定义可选类型
在 Swift 中，可选类型的定义使用 ? 符号。例如，下面的代码定义了一个可选类型的字符串变

var optionalString: String?

这个字符串可以存储一个字符串或者nil

2)赋值和访问

optionalString = "Hello, Swift!"

访问需要解包，一般可以借助if else

if let string = optionalString { 
    print(string) 
} else { 
    print("optionalString is nil”) 
}

3)强制访问用！直接赋值

var optionalString: String?
optionalString = "Hello, Swift!"
let string = optionalString!
print(string)

三、条件判断和循环

1.条件语句

首先if和for都不需要括号，这里写法跟python很像
If就常规用：

let a = 10 
if a > 9 { 
    print(a) 
}

但是这里不要直接if某个值，eg if(a), 要像上边一样加上条件判断
三目运算符：

var result = a > b ? a : b

switch：
不喜欢用，一般都是if单个名中
注意switch有一点很先进，swift中的switch不需要break，自动加了
再也不用为忘加break担心了

let sex = 0 
switch sex { 
    case 0 : 
        print("男”) 
    case 1 : 
        print("女”) 
    default : 
        print("其他”) 
}

guard:
语法很奇怪，不建议用

var age = 18 
func online(age : Int) -> Void { 
    //注意这里意思的<18的判断
    guard age >= 18 else { 
        print("回家去”) 
        return 
    } 
    print("可以上网”) 
} 
online(age)

2.循环语句
for in就够了

for i in 0...10 { 
    print(i) 
}

四、函数

func 函数名(参数列表) -> 返回值类型 { 
    代码块 
    return 返回值 
}

没有返回值可以写void或者不写
默认参数应该是比较常用的一种状态：

func makecoffee(type :String = "卡布奇诺") -> String { 
    return "制作一杯\(type)咖啡。” 
}

至于可变参数，实际上是解构一个数组：

func sum(numbers:Double...) -> Double {}
sum(100.0, 20, 50)

五、 闭包

带参数的闭包：

{(parameters) -> return type in
   // code
}

Eg1:

let greet = {(name: String) -> String in
    return "Hello, \(name)!"
}
print(greet("Swift"))
// 输出："Hello, Swift!"

Eg2:

let numbers = [1, 2, 3, 4, 5]

let result = numbers.map({ (number: Int) -> Int in
    let result = number * 2
    return result
})

print(result)
// 输出：[2, 4, 6, 8, 10]

swift中解决weak strong dance的方法
weak stong dance主要是关于内外self的区别，方便后期释放

httpTool.loadRequest { 
    [weak self] in 
    self.view.backgroundColor = UIColor.redColor() 
}
// [weak self] () -> () in ，因为()=>()都为空省略掉了

六、懒加载

lazy关键词，只会被实例化一次

lazy var array : [String] = { 
    () -> [String] in 
    return ["a", "b", "c”]
}() //这里直接()执行赋值了'

七、类

class 类名 : SuperClass { 
    // 定义属性和方法
}
⚠️ 定义的类,可以没有父类.那么该类是 rootClass

类的属性有以下几种

• 存储属性:存储实例的常量和变量
• 计算属性:通过某种方式计算出来的属性
• 类属性:与整个类自身相关的属性
  存储属性，就是正常在类里边定义的属性值
  计算属性的关键就是setter和getter，间接获取和改变其他属性
  类属性可以直接类名调用加了，static

eg:
class Student : NSObject { 
    // 存储属性 
    var age : Int = 0 
    var name : String? 
    var englishScore : Double = 0.0 
    var mathScore : Double = 0.0 
    // 计算属性 
    var averageScore : Double { 
        get { 
            return (englishScore + mathScore) / 2 
        } 
       // 没有意义.newValue是系统分配的变量名,内部存储着新值 
       set { 
            self.averageScore = newValue } 
    } 
    // 类属性 
    static var corseCount : Int = 0 
} 
// 设置类属性的值 
Student.corseCount = 3

类的构造函数：

• 创建一个类时,必然会调用一个构造函数
• 即便是没有编写任何构造函数，编译器也会提供一个默认的构造函数。
• 如果是继承自NSObject,可以对父类的构造函数进行重写，当然也可以自己定义

Eg: 初始化的时候给属性赋值

class Person: NSObject { 
    var name : String? var age : Int = 0 
    // 自定义构造函数,会覆盖init()函数 ，省略重定义的override
    init(name : String, age : Int) { 
        self.name = name self.age = age
     } 
} 
// 创建一个Person对象 
let p = Person(name: "花花", age: 18)