swift（一）基础知识

本文主要内容来自菜鸟联盟，仅用于个人学习。啧啧——

import UIKit //加载类库
var str = “Hello, playground”

• 声明方式

命名可以用字母、数字、下划线，不能以数字开头，区分大小写（同oc） swift强类型语言，自动判断类型

• 变量

var varConstant = 2
var varx = 1, vary = 2, varz = 3
var varString: String = "varString"
var varx1, varx2, varx3: Int //这种声明比较少见

• 常见数据类型

Int、String、UInt、Float（表示32位浮点数）、Double（表示64位浮点数）、Bool、Character、Optional（使用可选类型来处理值可能缺失的情况。可选类型表示有值或没有值。）Array, Dictionary, Struct, 和 Class
Double精确度很高，至少有15位数字，而 Float 最少只有6位数字
在 32 位系统上, Int 和 Int32 长度相同。
在 64 位系统上, Int 和 Int64 长度相同。
在 32 位系统上, UInt 和 UInt32 长度相同。
在 64 位系统上, UInt 和 UInt64 长度相同。
Int8, Int16, Int32, Int64 分别表示 8 位, 16 位, 32 位, 和 64 位的有符号整数形式。
UInt8, UInt16, UInt32, UInt64 分别表示 8 位, 16 位, 32 位 和 64 位的无符号整数形式。
Int.max//Int最大值
Int.min
print("(varConstant)") //在字符串中可以使用括号与反斜线来插入变量

let 常量一旦设定，在程序运行时就无法改变其值
let letConstant = “letConstantString”//let声明格式同var

• 类型别名

语法格式：typealias newname = type, 如定义了 Int 的类型别名为 Feet

typealias Feet = Int
var distance: Feet = 100

• 类型安全

var varA = 42
//varA = “This is hello”, 报错varA已经是Int类型，再给赋String类型，报错

/类型推断/
let meaningOfLife = 42 // meaningOfLife 会被推测为 Int 类型
let pi = 3.14159 // pi 会被推测为 Double 类型
//当推断浮点数的类型时，Swift 总是会选择Double而不是Float。如果表达式中同时出现了整数和浮点数，会被推断为Double类型
let anotherPi = 3 + 0.14159 // anotherPi 会被推测为 Double 类型
//1.3 Optional可选类型，用于处理值缺失的情况,可选表示"那儿有一个值，并且它等于 x “或者"那儿没有值”。
//语法格式：类型后缀加？作为命名类型Optional的简写，类型和?之间没有空格
var optionalInteger: Int? //简写
var optionalInteger1: Optional //或者这么写
//在这两种情况下，变量 optionalInteger 都是可选整数类型。注意，在类型和 ?之间没有空格。Optional 是一个含有两种情况的枚举，None 和 Some(T)，用来表示可能有或可能没有值。任何类型都可以明确声明为（或者隐式转换）可选类型。当声明一个可选类型的时候，要确保用括号给 ? 操作符一个合适的范围。例如，声明可选整数数组，应该写成 (Int[])? 写成 Int[]? 会报错。
//当你声明一个可选变量或者可选属性的时候没有提供初始值，它的值会默认为 nil。
//可选项遵照 LogicValue 协议，因此可以出现在布尔环境中。在这种情况下，如果可选类型T?包含类型为T的任何值（也就是说它的值是 Optional.Some(T) ），这个可选类型等于 true，反之为 false。
//如果一个可选类型的实例包含一个值，你可以用后缀操作符 ！来访问这个值，如下所示：
optionalInteger = 42
optionalInteger! // 42

• 强制解析

当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个感叹号表示"我知道这个可选有值，请使用它。"这被称为可选值的强制解析（forced unwrapping）。

var myString:String?
    myString = "Hello, Swift!"
if myString != nil {
   
    //print(myString)     //Optional("Hello, Swift!")
    // 强制解析
    print( myString!)       //Hello, Swift!
}else{
   
    print("字符串为 nil")
}

• 自动解析

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

var myString:String!

• 可选绑定

使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。
可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。

格式：
if let constantName = someOptional {
   
    statements
}

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

• 浮点型字面量

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

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

3. 负的浮点型字面量由一元运算符减号 - 和浮点型字面量组成，例如 -42.5。
   浮点型字面量允许使用下划线 _ 来增强数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 0，并不会影响字面量的值

var varFloat = 1000_000_000 //增加可读性
let decimalDouble = 12.1875       //十进制浮点型字面量
let exponentDouble = 1.21875e1    //十进制浮点型字面量
let hexadecimalDouble = 0xC.3p0   //十六进制浮点型字面量

• 字符串型字面量

字符串型字面量中不能包含未转义的双引号 （"）、未转义的反斜线（\）、回车符或换行符。
字符串型字面量由被包在双引号中的一串字符组成，形式如下：
“characters”
转义字符 含义
\0 空字符
\ 反斜线
\b 退格(BS) ，将当前位置移到前一列
\f 换页(FF)，将当前位置移到下页开头
\n 换行符
\r 回车符
\t 水平制表符
\v 垂直制表符
’ 单引号
" 双引号
\000 1到3位八进制数所代表的任意字符
\xhh… 1到2位十六进制所代表的任意字符

• 布尔型字面量

布尔型字面量的默认类型是 Bool。
布尔值字面量有三个值，它们是 Swift 的保留关键字：
true 表示真。false 表示假。nil 表示没有值。

• 运算符

算术运算符：+、-、、/、% //swift3 中已经取消了++、–。
比较运算符：==、!=、>、<、>=、<=
赋值运算符：=、+=、-=、=、/= 、%=、<<=（按位左移后再赋值C <<= 2 相当于 C = C << 2）、>>=、 &=（按位与运算后赋值C &= 2相当于C = C & 2）、^=（按位异或运算符后再赋值C ^= 2相当于C = C ^ 2）、|=（按位或运算后再赋值C |= 2相当于C = C | 2）
逻辑运算符：&&、||、！
位运算符：位运算符用来对二进制位进行操作，~，&，|，^分别为取反，按位与与，按位与或，按位与异或运算
区间运算符：闭区间运算符（a…b）如：1…5 区间值为 1, 2, 3, 4 和 5；半开区间运算符（a… 如：1…< 5 区间值为 1, 2, 3, 和 4
三元运算符：condition ? X : Y 如果 condition 为 true ，值为 X ，否则为 Y

• 条件语句: if、if else、white、switch等
• 循环语句

for-in、repeat…while(类似 while 语句区别在于判断循环条件之前，先执行一次循环的代码块。)

• 循环控制语句

continue 告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。
break 中断当前循环。
fallthrough 如果在一个case执行完后，继续执行下面的case，需要使用fallthrough(贯穿)关键字。

• 字符串 String

使用字符串字面量创建空字符串
var stringA = “”
实例化 String 类来创建空字符串
let stringB = String()
stringA += “http://www.runoob.com”
isEmpty、count、append、hasPrefix(prefix: String)、hasSuffix(suffix: String)、Int(String)、utf8、utf16、unicodeScalars（通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量编码）、比较
if stringA == stringB {//<、>对两个字符串的字母逐一比较
}

• Unicode 字符串

Unicode 是一个国际标准，用于文本的编码，Swift 的 String 类型是基于 Unicode建立的。你可以循环迭代出字符串中 UTF-8 与 UTF-16 的编码

for code in stringA.utf8 {
   //nicodeScalars
    print("\(code) ")
}

• 字符 Character

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

let char1: Character = ""     error: cannot convert value of type 'String' to specified type 'Character'

便利字符串中的字符

for ch in "Runoob" {
   
    print(ch)
}

• 数组

构造语法来创建一个由特定数据类型构成的空数组：

var someArray = [SomeType]()
var someArray = [String]()
someArray = ["aaa", "bbb", "ccc"]

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

var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)
//类型为 Int ，数量为 3，初始值为 0 的空数组
var someInts = [Int](repeating: 0, count: 3)
var someInt:[Int] = [10, 20, 30]
var someAny = Array<Any>()
someAny = ["aaa", 2]
var someAnyObjectArray = [AnyObject]()

• 修改数组

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

someInt.append(20)
someInt += [40]
someInt[3] = 50
for item in someInt {
   
    print(item)
}

如果我们同时需要每个数据项的值和索引值，可以使用 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)")
}
var someStrings = [String]()
someStrings = ["ali"]

合并数组,同类型才能合并

var someS = someStrs + someStrings

• 字典

var someDict = KeyType: ValueType
var someDict:[Int:String] = [1:“One”, 2:“Two”, 3:“Three”]

访问字典

var someVar = someDict[1]

修改
updateValue(forKey:) 增加或更新字典的内容；updateValue(_:forKey:)方法返回Optional值

//removeValueForKey()
var oldVal = someDict.updateValue("One 新的值", forKey: 1)
print( "key = 1 旧的值 \(oldVal)" )
print( "key = 1 旧的值 \(oldVal ?? "可选值")" )
print( "key = 1 旧的值 \(String(describing: oldVal))" )
for (key, value) in someDict {
   
    print("字典 key \(key) -  字典 value \(value)")
}
for (key, value) in someDict.enumerated() {
   
    print("字典 key \(key) -  字典 (key, value) 对 \(value)")
}

key、value数组

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)
for (key) in dictKeys {
   
    print("\(key)")
}

//isEmpty、count

• 函数

语法
func funcname(参数名：类型) -> returntype
{
Statement1
Statement2
……
Statement N
return parameters
}

无参无返回
func function1() {
}

有参有返回
func function2(para1: String, para2: Int) -> String {
let intStr = para2
let str = String(intStr)
return para1 + str
}

调用
print(function2(para1: “name”, para2: 1))

• 元组作为函数返回值

返回的不是一个值，是多个值，oc没有，Python有这个特性
如果你不确定返回的元组一定不为nil，那么你可以返回一个可选的元组类型。
//你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如(Int, Int)?或(String, Int, Bool)?
可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

func minMax(array: [Int]) -> (min: Int, max: Int) {
   
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
   
        if value < currentMin {
   
            currentMin = value
        } else if value > currentMax {
   
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
	print("最小值为 \(bounds.min) ，最大值为 \(bounds.max)")
func minMax(array: [Int]) -> (min: Int, max: Int)? {
   
    if array.isEmpty {
    return nil }       //此时数组可能是空，判断
}

• 外部参数名

你可以在局部参数名前指定外部参数名，中间以空格分隔，外部参数名用于在函数调用时传递给函数的参数,如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。

func sampleNumber(number: Int) {
   
    print(number)
}
sampleNumber(number: 2)

func sampleNum(intNum a: Int, strNum b: String) {
   
    
}
func pow(firstArg a: Int, secondArg b: Int) -> Int {
   
    var res = a
    for _ in 1..<b {
   
        res = res * a
    }
    print(res)
    return res
}
pow(firstArg:5, secondArg:3)

• 可变参数

可变参数可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数，其数量是不确定的。
//可变参数通过在变量类型名后面加入（…）的方式来定义
func vari(members: N…){
for i in members {
print(i)
}
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu", "Runoob")

• 常量，变量及 I/O 参数

一般默认在函数中定义的参数都是常量参数，也就是这个参数你只可以查询使用，不能改变它的值。
//如果想要声明一个变量参数，可以在参数定义前加 inout 关键字，这样就可以改变这个参数的值了。
func getName(_ name: inout String){
}

func swapTwoInts(a: Int, b: Int) {
   
    let temporaryA = a
    a = b
    b = temporaryA
}
error: cannot assign to value: 'a' is a 'let' constant
a = b
^
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
   
    let temporaryA = a
    a = b
    b = temporaryA
}
var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")

• 使用函数类型

使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：

func sum(a: Int, b: Int) -> Int {
   
    return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")
//sum 和 addition 有同样的类型，所以以上操作是合法的

• 函数类型作为参数类型、函数类型作为返回类型

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
        //函数类型作为参数类型
    print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)

func stepForward(a: Int, b: String) -> String {
   
    let str = a
    return String(str)
}

func stepBackForward(b: Int, a: String) -> String {
   
    let str = b
    return String(str)
}

func chooseStepFunction(isBack: Bool) -> (Int, String) -> String {
        //函数类型作为返回类型
    return isBack ? stepForward : stepBackForward
}
print(chooseStepFunction(isBack: true))

• 函数嵌套

函数嵌套指的是函数内定义一个新的函数，外部的函数可以调用函数内定义的函数。

func calcDecrement(forDecrement total: Int) -> () -> Int {
   
    var overallDecrement = 0
    func decrementer() -> Int {
   
        overallDecrement += total
//        func de() -> Int {
   
//            return 2
//        }
        return overallDecrement //de()
    }
    return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

返回值是一个()-> Int的函数。
函数题内，声明了变量overallDecrement 和一个函数decrementer。decrementer函数并没有获取任何参数，但是在函数体内访问了overallDecrement和total变量。这是因为其通过捕获在包含它的函数体内已经存在的overallDecrement和total变量而实现。由于没有修改total变量，decrementer实际上捕获并存储了该变量的一个副本