Swift速成 笔记 备忘

一、基础语法

1. 属性类别

1. let 用于定义常量，定义完后不能修改。let 用于定义常量，定义完后不能修改。

2. var 用于定义变量，可以修改。

3. swift可以自动识别属性类别。

4. Swift 是一个区分大小写的语言，所以字母大写与小写是不一样的。

5. 变量名也可以使用简单的 Unicode 字符.

import UIKit

var _var = "Hello, Swift!"
print(_var)

var 你好 = "你好世界"

Hello, Swift!
你好世界

6. (变量名或者常量名)可以在字符串中插入变量或常量

import UIKit


var 变量名 = "你好，中国！"

let 常量名 = "我很好，你呢？"

print("小明说：\(变量名),中国回答说：\(常量名)")

“小明说：你好，中国！,中国回答说：我很好，你呢？\n”

2. 内置数据类型 (注意首字母大写)

a. Int ：

在32位平台上，Int和Int32长度相同。在64位平台上，Int和Int64长度相同。在32位平台上，Int和Int32长度相同。在64位平台上，Int和Int64长度相同。

Int8, Int16, Int32, Int64 分别表示 8 位, 16 位, 32 位, 和 64 位的有符号整数形式。

b. UInt:

在32位平台上，UInt和UInt32长度相同。在64位平台上，UInt和UInt64长度相同。
UInt8, UInt16, UInt32, UInt64 分别表示 8 位, 16 位, 32 位 和 64 位的无符号整数形式。

c. Double :
表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
Float :
表示32位浮点数。精度要求不高的话可以使用此类型。

d. Bool :

Swift 有一个基本的布尔（Boolean）类型，叫做 Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift 有两个布尔常量，true 和 false。还有保留字 nil表示没有值。

e. String :

字符串是字符的序列集合, 例如：“Hello, World!”

f. Character :

字符指的是单个字母，例如：“C”

g. Optional
使用可选类型来处理值可能缺失的情况。可选类型表示有值或没有值。

3. 类型别名

typealias newname = type

4. 类型安全

import Cocoa

var varA = 42
varA = "This is hello"
print(varA)

error: cannot assign value of type ‘String’ to type ‘Int’
varA = “This is hello”
意思为不能将 ‘String’ 字符串赋值给 ‘Int’ 变量。

5. 类型推导

let a : Int = 10相当于
let a = 10（系统判定类型，可以用 option+鼠标左键查看属性）

同理
let view = UIView()
var btn = UIButton()
view.backgroundColor = UIColor.blue

6. 类型转化

7. guard

增加可阅读性：

8. 可选类型（可选表示"那儿有一个值，并且它等于 x “或者"那儿没有值”。）

a. Swfit语言定义后缀？作为命名类型Optional的简写，换句话说，以下两种声明是相等的：

var optionalInteger: Int?
var optionalInteger: Optional

b. 如果一个可选类型的实例包含一个值，你可以用后缀操作符 ！来访问这个值

optionalInteger = 42
optionalInteger! // 42

注意：在类型和 ? ！之间没有空格
c. 可选绑定, 来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。

var myString:String?

myString = "Hello, Swift!"

if let yourString = myString {
   print("你的字符串值为 - \(yourString)")
}else{
   print("你的字符串没有值")
}

你的字符串值为 - Hello, Swift!

9.字面量

整型字面量可以是一个十进制，二进制，八进制或十六进制常量。十进制没有前缀， 二进制前缀为 0b，八进制前缀为 0o，十六进制前缀为 0x，

let decimalInteger = 17           // 17 - 十进制表示
let binaryInteger = 0b10001       // 17 - 二进制表示
let octalInteger = 0o21           // 17 - 八进制表示
let hexadecimalInteger = 0x11     // 17 - 十六进制表示

a. 十进制浮点型字面量由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 . 后跟十进制数字串组成。指数部分由大写或小写字母 e 为前缀后跟十进制数字串组成，这串数字表示 e 之前的数量乘以 10 的几次方。例如：1.25e2 表示 1.25 ⨉ 10²，也就是 125.0；同样，1.25e－2 表示 1.25 ⨉ 10^－2，也就是 0.0125。

b. 十六进制浮点型字面量由前缀 0x 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 p 为前缀后跟十进制数字串组成，这串数字表示 p 之前的数量乘以 2 的几次方。例如：0xFp2 表示 15 ⨉ 2²,也就是 60；同样，0xFp-2 表示 15 ⨉ 2^-2，也就是 3.75。

c. 负的浮点型字面量由一元运算符减号 - 和浮点型字面量组成，例如 -42.5。

10. 运算符

大部分继承的是C语言中运算符，不同：

区间运算符：
闭区间运算符 （a…b）定义一个包含从a到b(包括a和b)的所有值的区间，b必须大于等于a。 ‌ 如在for-in循环中： 1…5 区间值为 1, 2, 3, 4 和 5
半开区间运算符 半开区间，（a… 如，1…< 5 区间值为 1, 2, 3, 和 4

11. 数组

a. 创建数组
创建一个类型为 Int ，数量为 3，初始值为 0 的空数组：

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

创建含有三个元素的数组：

var someInts:[Int] = [10, 20, 30]

b.访问数组（跟C语言一致）

c. 修改数组

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

var someVar = someInts[0]

print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )

第一个元素的值 20
第二个元素的值 30
第三个元素的值 40

d. 遍历数组
如果我们同时需要每个数据项的值和索引值，可以使用 String 的 enumerate() 方法来进行数组遍历。

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]

for (index, item) in someStrs.enumerated() {
    print("在 index = \(index) 位置上的值为 \(item)")
}

在 index = 0 位置上的值为 Apple
在 index = 1 位置上的值为 Amazon
在 index = 2 位置上的值为 Runoob
在 index = 3 位置上的值为 Google

e. count 属性
我们可以使用 count 属性来计算数组元素个数

f. isEmpty 属性
通过只读属性 isEmpty 来判断数组是否为空，返回布尔值

12.字典

a.创建字典

var someDict =   [KeyType: ValueType]()

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

var someDict = [Int: String]()

创建一个字典的实例：

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

b. 访问字典

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

var someVar = someDict[1]

print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

key = 1 的值为 Optional(“One”)
key = 2 的值为 Optional(“Two”)
key = 3 的值为 Optional(“Three”)

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

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

var oldVal = someDict.updateValue("One 新的值", forKey: 1)
或者：
someDict[1] = "One 新的值"
 
var someVar = someDict[1]

print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 的值为 \(someVar)" )
print( "key = 2 的值为 \(someDict[2])" )
print( "key = 3 的值为 \(someDict[3])" )

key = 1 旧的值 Optional(“One”)
key = 1 的值为 Optional(“One 新的值”)
key = 2 的值为 Optional(“Two”)
key = 3 的值为 Optional(“Three”)

使用 removeValueForKey() 方法来移除字典 key-value 对。或者someDict[i] = nil

d. 遍历字典

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

for (key, value) in someDict {
   print("字典 key \(key) -  字典 value \(value)")
}

字典 key 2 - 字典 value Two
字典 key 3 - 字典 value Three
字典 key 1 - 字典 value One

e. 字典转数组

import UIKit


var 某字典:[Int:String] = [1:"book", 2:"pen", 3:"study"]

let 字典里的key = [Int](某字典.keys)
let 字典里的value = [String](某字典.values)

[3, 1, 2]
[“study”, “book”, “pen”]

字典是无序的，若要排序，可以采用以下方法：

var array = 某字典.keys.sorted()

for i in array{
    print("\(i) : \(某字典[i]!)")
}

1 : book
2 : pen
3 : study

**注意:**有个！，若不加则会报 1 : Optional(“book”) 。。。

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

g. isEmpty 属性
通过只读属性 isEmpty 来判断字典是否为空，返回布尔值

十三.函数

a.函数定义
func funcname(形参) -> returntype
{
Statement1
Statement2
……
Statement N
return parameters
}

b. 例子

import UIKit

func function(name : String)->String{
    print("\(name),你好！")
    return name
}

function(name: "小明")

小明,你好！

优化：

func function(name : String, say : String)->String{
    return name + "，" + say
}

print(function(name: "小红", say: "早上好"))

小红，早上好

c.元组作为函数返回值