Swift 基础知识点总结(一)

一.基本语法

引入swift和oc一样也是使用import + 库名 不需要双引号,例如:

import Cocoa

注释swift和oc一样 有单行//  多行/* */  还有嵌套/*  /* */  */

分号swift不要求在每行语句的结尾使用分号(;)，但当你在同一行书写多条语句时，必须用分号隔开：

标识符就是给变量、常量、方法、函数、枚举、结构体、类、协议等指定的名字

Swift语言中标识符的命名规则如下:

 区分大小写，Myname与myname是两个不同的标识符；

 标识符首字符可以以下划线（_）或者字母开始，但不能是数字；

 标识符中其他字符可以是下划线（_）、字母或数字

如果一定要使用关键字作为标识符，可以在关键字前后添加重音符号（`），例如：

 let `class` = "Runoob"

在Swift中，运算符不能直接跟在变量或常量的后面。例如下面的代码会报错：

let a= 1 + 2

二.数据类型 (和oc差不多)

Int

UInt

浮点数：Float、Double

布尔值：Bool

Swift 有两个布尔常量，true 和 false。

字符串：String

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

字符：Character

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

可选类型：Optional

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

类型别名

类型别名对当前的类型定义了另一个名字，类型别名通过使用 typealias 关键字来定义。语法格式如下：

typealias newname = type

例如以下定义了 Int 的类型别名为 Feet：

typealias Feet = Int

可以通过别名来定义变量：

import Cocoa

typealias Feet = Int

var distance: Feet = 100

print(distance)

输出结果为：100

类型安全

Swift 是一个类型安全（type safe）的语言,它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。

import Cocoa

var varA = 42

varA = "This is hello"

print(varA)

以上程序，会在 Xcode 中报错：

error: cannot assign value of type 'String' to type 'Int'

varA = "This is hello"

意思为不能将 'String' 字符串赋值给 'Int' 变量。

类型推断

当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。

如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。

例如，如果你给一个新常量赋值42并且没有标明类型，Swift 可以推断出常量类型是Int，因为你给它赋的初始值看起来像一个整数：

let meaningOfLife = 42

// meaningOfLife 会被推测为 Int 类型

同理，如果你没有给浮点字面量标明类型，Swift 会推断你想要的是Double：

let pi = 3.14159

// pi 会被推测为 Double 类型

当推断浮点数的类型时，Swift 总是会选择Double而不是Float。如果表达式中同时出现了整数和浮点数，会被推断为Double类型：

let anotherPi = 3 + 0.14159

// anotherPi 会被推测为 Double 类型

原始值3没有显式声明类型，而表达式中出现了一个浮点字面量，所以表达式会被推断为Double类型。

实例

import Cocoa

// varA 会被推测为 Int 类型

var varA = 42

print(varA)

// varB 会被推测为 Double 类型

var varB = 3.14159

print(varB)

// varC 也会被推测为 Double 类型

var varC = 3 + 0.14159

print(varC)

执行以上代码，输出结果为：

42

3.14159

3.14159

三.变量

变量声明使用 var 关键字声明它，如下所示：

var variableName = <initial value>

以下是一个 Swift 程序中变量声明的简单实例：

import Cocoa

var varA = 42

print(varA)

var varB:Float

varB = 3.14159

print(varB)

以上程序执行结果为：

42

3.14159

变量命名变量名可以由字母，数字和下划线组成。变量名需要以字母或下划线开始。注意:Swift 是一个区分大小写的语言，所以字母大写与小写是不一样的。变量名也可以使用简单的 Unicode 字符(中文)

变量输出变量和常量可以使用 print函数来输出。在字符串中可以使用括号与反斜线来插入变量，如下实例：

import Cocoa

var name = "你好"

var site = "夏天"

print("\(name)现在是：\(site)")

以上程序执行结果为：

你好现在是:夏天

四.常量

常量一旦设定，在程序运行时就无法改变其值。

常量可以是任何的数据类型如：整型常量，浮点型常量，字符常量或字符串常量。同样也有枚举类型的常量：

常量类似于变量，区别在于常量的值一旦设定就不能改变，而变量的值可以随意更改。

常量声明

常量使用关键字 let 来声明，语法如下：

let constantName = <initial value>

实例：

import Cocoa

let constA = 42

print(constA)

以上程序执行结果为：

42

类型标注

当你声明常量或者变量的时候可以加上类型标注（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。

var constantName:<data type> = <optional initial value>

以下是一个简单是实例演示了 Swift 中常量使用类型标注。需要注意的是常量定义时必须初始值：

import Cocoa

let constA = 42

print(constA)

let constB:Float = 3.14159

print(constB)

以上程序执行结果为：

42

3.14159

五.可选(Optionals)类型

可选（Optional）类型，用于处理值缺失的情况。可选表示"那儿有一个值，并且它等于 x "或者"那儿没有值"。

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

var optionalInteger: Int?

var optionalInteger: Optional<Int>

在这两种情况下，变量 optionalInteger 都是可选整数类型。注意，在类型和 ?之间没有空格。

Optional 是一个含有两种情况的枚举，None 和 Some(T)，用来表示可能有或可能没有值。任何类型都可以明确声明为（或者隐式转换）可选类型。

当声明一个可选类型的时候，要确保用括号给 ? 操作符一个合适的范围。例如，声明可选整数数组，应该写成 (Int[])? 写成 Int[]? 会报错。

当你声明一个可选变量或者可选属性的时候没有提供初始值，它的值会默认为 nil。

可选项遵照 LogicValue 协议，因此可以出现在布尔环境中。在这种情况下，如果可选类型T?包含类型为T的任何值（也就是说它的值是 Optional.Some(T) ），这个可选类型等于 true，反之为 false。

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

optionalInteger = 42

optionalInteger! // 42

使用操作符！去获取值为nil的可选变量会有运行时错误。

你可以用可选链接和可选绑定选择性执行可选表达式上的操作。如果值为nil，任何操作都不会执行，也不会有运行报错。

让我们来详细看下以下实例来了解 Swift 中可选类型的应用:

import Cocoa

var myString:String? = nil

if myString != nil {

    print(myString)

}else{

    print("字符串为 nil")

}

以上程序执行结果为：

字符串为 nil

可选类型类似于Objective-C中指针的nil值，但是nil只对类(class)有用，而可选类型对所有的类型都可用，并且更安全。

强制解析

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

实例如下：

import Cocoa

var myString:String?

myString = "Hello, Swift!"

if myString != nil {

    print(myString)

}else{

    print("myString 值为 nil")

}

以上程序执行结果为：

Optional("Hello, Swift!")

强制解析可选值，使用感叹号（!）：

import Cocoa

var myString:String?

myString = "Hello, Swift!"

if myString != nil {

    // 强制解析

    print( myString! )

}else{

    print("myString 值为 nil")

}

以上程序执行结果为：

Hello, Swift!

注意：

使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。

自动解析

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

实例如下：

import Cocoa

var myString:String!

myString = "Hello, Swift!"

if myString != nil {

    print(myString)

}else{

    print("myString 值为 nil")

}

以上程序执行结果为：

Hello, Swift!

可选绑定

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

像下面这样在if语句中写一个可选绑定：

if let constantName = someOptional {

    statements

}

让我们来看下一个简单的可选绑定实例：

import Cocoa

var myString:String?

myString = "Hello, Swift!"

if let yourString = myString {

    print("你的字符串值为 - \(yourString)")

}else{

    print("你的字符串没有值")

}

以上程序执行结果为：

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

六.字面量

所谓字面量，就是指像特定的数字，字符串或者是布尔值这样，能够直接了当地指出自己的类型并为变量进行赋值的值。比如在下面：

let aNumber = 3         //整型字面量

let aString = "Hello"   //字符串字面量

let aBool = true        //布尔值字面量

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

以下为一些整型字面量的实例：

let decimalInteger = 17           // 17 - 十进制表示

let binaryInteger = 0b10001       // 17 - 二进制表示

let octalInteger = 0o21           // 17 - 八进制表示

let hexadecimalInteger = 0x11     // 17 - 十六进制表示

浮点型字面量有整数部分，小数点，小数部分及指数部分。

除非特别指定，浮点型字面量的默认推导类型为 Swift 标准库类型中的 Double，表示64位浮点数。

以下为一些浮点型字面量的实例：

let decimalDouble = 12.1875       //十进制浮点型字面量

let exponentDouble = 1.21875e1    //十进制浮点型字面量

字符串型字面量由被包在双引号中的一串字符组成，形式如下：

"characters"

字符串型字面量中不能包含未转义的双引号 （"）、未转义的反斜线（\）、回车符或换行符。

转义字符    含义

\0    空字符

\\    反斜线 \

\b    退格(BS) ，将当前位置移到前一列

\f    换页(FF)，将当前位置移到下页开头

\n    换行符

\r    回车符

\t    水平制表符

\v    垂直制表符

\'    单引号

\"    双引号

\000    1到3位八进制数所代表的任意字符

\xhh...    1到2位十六进制所代表的任意字符

布尔型字面量的默认类型是 Bool。

布尔值字面量有三个值，它们是 Swift 的保留关键字：

true 表示真。

false 表示假。

nil 表示没有值。

七.运算符

Swift 提供了以下几种运算符：

算术运算符      + - * / %

比较运算符      ==  !=  >  <  >=  <=

逻辑运算符      &&    ||  !

位运算符~,&,|,^分别为取反，按位与与，按位与或，按位与异或运算

赋值运算符      =  +=  -=  *= /=  %=  <<=  >>=  &=  ^=  |=

区间运算符

闭区间        实例:  1...5 区间值为 1, 2, 3, 4 和 5

半开区间    实例:  1..< 5 区间值为 1, 2, 3, 和 4

其他运算符 

                      一元减(数字前添加 - 号前缀) 

                      一元加(数字前添加 + 号前缀) 

                      三元运算符 (condition ? X : Y)

八.条件语句 (和oc相同)

  if 语句

  if...else语句

  if...else if ...else语句

  内嵌if语句

  switch语句

九.循环语句(和oc相同)

  for-in

for 循环该循环方式在 Swift 3 中已经弃用。

  while 循环

  repeat...while循环

  switch语句

十.字符串

Swift 字符串是一系列字符的集合。例如 "Hello, World!" 这样的有序的字符类型的值的集合，它的数据类型为 String。

创建字符串

你可以通过使用字符串字面量或 String 类的实例来创建一个字符串：

import Cocoa

// 使用字符串字面量

var stringA = "Hello, World!"

print( stringA )

// String 实例化

var stringB = String("Hello, World!")

print( stringB )

以上程序执行输出结果为：

Hello, World!

Hello, World!

空字符串

你可以使用空的字符串字面量赋值给变量或初始化一个String类的实例来初始值一个空的字符串。 我们可以使用字符串属性 isEmpty 来判断字符串是否为空：

import Cocoa

// 使用字符串字面量创建空字符串

var stringA = ""

if stringA.isEmpty {

    print( "stringA 是空的" )

} else {

    print( "stringA 不是空的" )

}

// 实例化 String 类来创建空字符串

let stringB = String()

if stringB.isEmpty {

    print( "stringB 是空的" )

} else {

    print( "stringB 不是空的" )

}

以上程序执行输出结果为：

stringA 是空的

stringB 是空的

字符串常量

你可以将一个字符串赋值给一个变量或常量，变量是可修改的，常量是不可修改的。

import Cocoa

// stringA 可被修改

var stringA = "菜鸟教程："

stringA += "http://www.runoob.com"

print( stringA )

// stringB 不能修改

let stringB = String("菜鸟教程：")

stringB += "http://www.runoob.com"

print( stringB )

以上程序执行输出结果会报错，因为 stringB 为常量是不能被修改的：

error: left side of mutating operator isn't mutable: 'stringB' is a 'let' constant

stringB += "http://www.runoob.com"

字符串中插入值

字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。 您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：

import Cocoa

var varA   = 20

let constA = 100

var varC:Float = 20.0

var stringA = "\(varA) 乘于 \(constA) 等于 \(varC * 100)"

print( stringA )

以上程序执行输出结果为：

20 乘于 100 等于 2000.0

字符串连接

字符串可以通过 + 号来连接，实例如下：

import Cocoa

let constA = "夏天："

let constB = "你好"

var stringA = constA + constB

print( stringA )

以上程序执行输出结果为：

夏天：你好

字符串长度

字符串长度使用 String.count 属性来计算，实例如下：

import Cocoa

var varA   = "www.runoob.com"

print( "\(varA), 长度为 \(varA.count)" )

以上程序执行输出结果为：

www.runoob.com, 长度为 14

字符串比较

你可以使用 == 来比较两个字符串是否相等：

import Cocoa

var varA   = "Hello, Swift!"

var varB   = "Hello, World!"

if varA == varB {

    print( "\(varA) 与 \(varB) 是相等的" )

} else {

    print( "\(varA) 与 \(varB) 是不相等的" )

}

以上程序执行输出结果为：

Hello, Swift! 与 Hello, World! 是不相等的

Unicode 字符串

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

import Cocoa

var unicodeString   = "你好夏天"

print("UTF-8 编码: ")

for code in unicodeString.utf8 {

    print("\(code) ")

}

print("\n")

print("UTF-16 编码: ")

for code in unicodeString.utf16 {

    print("\(code) ")

}

以上程序执行输出结果为：

UTF-8 编码: 

228 

189 

160 

229 

165 

189 

229 

164 

143 

229 

164 

169 

UTF-16 编码: 

20320 

22909 

22799 

22825 

字符串函数及运算符

Swift 支持以下几种字符串函数及运算符：

isEmpty                                判断字符串是否为空，返回布尔值

hasPrefix(prefix: String)    检查字符串是否拥有特定前缀

hasSuffix(suffix: String)    检查字符串是否拥有特定后缀。

Int(String)                            转换字符串数字为整型。

String.count                        计算字符串的长度

utf8                                      您可以通过遍历 String 的 utf8 属性来访问它的 UTF-8 编码

utf16                                    您可以通过遍历 String 的 utf8 属性来访问它的 utf16 编码

unicodeScalars 您可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量编码.

+ 连接两个字符串，并返回一个新的字符串

+= 连接操作符两边的字符串并将新字符串赋值给左边的操作符变量

==         判断两个字符串是否相等

< 比较两个字符串，对两个字符串的字母逐一比较。

!= 比较两个字符串是否不相等。

十一.字符(Character)

Swift 的字符是一个单一的字符字符串字面量，数据类型为 Character。

以下实例列出了两个字符实例：

import Cocoa

let char1: Character = "A"

let char2: Character = "B"

print("char1 的值为 \(char1)")

print("char2 的值为 \(char2)")

以上程序执行输出结果为：

char1 的值为 A

char2 的值为 B

如果你想在 Character（字符） 类型的常量中存储更多的字符，则程序执行会报错，如下所示：

import Cocoa

// Swift 中以下赋值会报错

let char: Character = "AB"

print("Value of char \(char)")

以上程序执行输出结果为：

error: cannot convert value of type 'String' to specified type 'Character'

let char: Character = "AB"

空字符变量

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

import Cocoa

// Swift 中以下赋值会报错

let char1: Character = ""

var char2: Character = ""

print("char1 的值为 \(char1)")

print("char2 的值为 \(char2)")

以上程序执行输出结果为：

error: cannot convert value of type 'String' to specified type 'Character'

let char1: Character = ""

    ^~

error: cannot convert value of type 'String' to specified type 'Character'

var char2: Character = ""

遍历字符串中的字符

Swift 的 String 类型表示特定序列的 Character（字符） 类型值的集合。 每一个字符值代表一个 Unicode 字符。

您可通过for-in循环来遍历字符串中的characters属性来获取每一个字符的值：

import Cocoa

for ch in "Runoob".characters {

    print(ch)

}

以上程序执行输出结果为：

R

u

n

o

o

b

字符串连接字符

以下实例演示了使用 String 的 append() 方法来实现字符串连接字符：

import Cocoa

var varA:String = "Hello "

let varB:Character = "G"

varA.append( varB )

print("varC  =  \(varA)")

以上程序执行输出结果为：

varC  =  Hello G

十二. 数组

Swift 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

Swift 数组会强制检测元素的类型，如果类型不同则会报错，Swift 数组应该遵循像Array<Element>这样的形式，其中Element是这个数组中唯一允许存在的数据类型。

如果创建一个数组，并赋值给一个变量，则创建的集合就是可以修改的。这意味着在创建数组后，可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量，数组就不可更改，并且数组的大小和内容都不可以修改。

创建数组

我们可以使用构造语法来创建一个由特定数据类型构成的空数组：

var someArray = [SomeType]()

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

var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)

以下实例创建了一个类型为 Int ，数量为 3，初始值为 0 的空数组：

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

以下实例创建了含有三个元素的数组：

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

访问数组

我们可以根据数组的索引来访问数组的元素，语法如下：

var someVar = someArray[index]

index 索引从 0 开始，即索引 0 对应第一个元素，索引 1 对应第二个元素，以此类推。

我们可以通过以下实例来学习如何创建，初始化，访问数组：

import Cocoa

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

var someVar = someInts[0]

print( "第一个元素的值 \(someVar)" )

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

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

以上程序执行输出结果为：

第一个元素的值 10

第二个元素的值 10

第三个元素的值 10

修改数组

你可以使用 append() 方法或者赋值运算符 += 在数组末尾添加元素，如下所示，我们初始化一个数组，并向其添加元素：

import Cocoa

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

我们也可以通过索引修改数组元素的值：

import Cocoa

var someInts = [Int]()

someInts.append(20)

someInts.append(30)

someInts += [40]

// 修改最后一个元素

someInts[2] = 50

var someVar = someInts[0]

print( "第一个元素的值 \(someVar)" )

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

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

以上程序执行输出结果为：

第一个元素的值 20

第二个元素的值 30

第三个元素的值 50

遍历数组

我们可以使用for-in循环来遍历所有数组中的数据项：

import Cocoa

var someStrs = [String]()

someStrs.append("Apple")

someStrs.append("Amazon")

someStrs.append("Runoob")

someStrs += ["Google"]

for item in someStrs {

    print(item)

}

以上程序执行输出结果为：

Apple

Amazon

Runoob

Google

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

import Cocoa

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

合并数组

我们可以使用加法操作符（+）来合并两种已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来：

import Cocoa

var intsA = [Int](repeating: 2, count:2)

var intsB = [Int](repeating: 1, count:3)

var intsC = intsA + intsB

for item in intsC {

    print(item)

}

以上程序执行输出结果为：

2

2

1

1

1

count 属性

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

import Cocoa

var intsA = [Int](count:2, repeatedValue: 2)

var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB

print("intsA 元素个数为 \(intsA.count)")

print("intsB 元素个数为 \(intsB.count)")

print("intsC 元素个数为 \(intsC.count)")

以上程序执行输出结果为：

intsA 元素个数为 2

intsB 元素个数为 3

intsC 元素个数为 5

isEmpty 属性

我们可以通过只读属性 isEmpty 来判断数组是否为空，返回布尔值：

import Cocoa

var intsA = [Int](count:2, repeatedValue: 2)

var intsB = [Int](count:3, repeatedValue: 1)

var intsC = [Int]()

print("intsA.isEmpty = \(intsA.isEmpty)")

print("intsB.isEmpty = \(intsB.isEmpty)")

print("intsC.isEmpty = \(intsC.isEmpty)")

以上程序执行输出结果为：

intsA.isEmpty = false

intsB.isEmpty = false

intsC.isEmpty = true

十三.字典

Swift 字典用来存储无序的相同类型数据的集合，Swift 字典会强制检测元素的类型，如果类型不同则会报错。

Swift 字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。

和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

Swift 字典的key没有类型限制可以是整型或字符串，但必须是唯一的。

如果创建一个字典，并赋值给一个变量，则创建的字典就是可以修改的。这意味着在创建字典后，可以通过添加、删除、修改的方式改变字典里的项目。如果将一个字典赋值给常量，字典就不可修改，并且字典的大小和内容都不可以修改。

创建字典

我们可以使用以下语法来创建一个特定类型的空字典：

var someDict =  [KeyType: ValueType]()

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

var someDict = [Int: String]()

以下为创建一个字典的实例：

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

访问字典

我们可以根据字典的索引来访问数组的元素，语法如下：

var someVar = someDict[key]

我们可以通过以下实例来学习如何创建，初始化，访问字典:

import Cocoa

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")

修改字典

我们可以使用 updateValue(forKey:) 增加或更新字典的内容。如果 key 不存在，则添加值，如果存在则修改 key 对应的值。updateValue(_:forKey:)方法返回Optional值。实例如下：

import Cocoa

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

var oldVal = someDict.updateValue("One 新的值", forKey: 1)

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")

你也可以通过指定的 key 来修改字典的值，如下所示：

import Cocoa

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

var oldVal = someDict[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")

移除 Key-Value 对

我们可以使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值，如果不存在返回 nil 。实例如下：

import Cocoa

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

var removedValue = someDict.removeValue(forKey: 2)

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

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

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

以上程序执行输出结果为：

key = 1 的值为 Optional("One")

key = 2 的值为 nil

key = 3 的值为 Optional("Three")

你也可以通过指定键的值为 nil 来移除 key-value（键-值）对。实例如下:

import Cocoa

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

someDict[2] = nil

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

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

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

以上程序执行输出结果为：

key = 1 的值为 Optional("One")

key = 2 的值为 nil

key = 3 的值为 Optional("Three")

遍历字典

我们可以使用 for-in 循环来遍历某个字典中的键值对。实例如下:

import Cocoa

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

我们也可以使用enumerate()方法来进行字典遍历，返回的是字典的索引及 (key, value) 对，实例如下:

import Cocoa

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

for (key, value) in someDict.enumerated() {

    print("字典 key \(key) -  字典 (key, value) 对 \(value)")

}

以上程序执行输出结果为：

字典 key 0 -  字典 (key, value) 对 (2, "Two")

字典 key 1 -  字典 (key, value) 对 (3, "Three")

字典 key 2 -  字典 (key, value) 对 (1, "One")

字典转换为数组

你可以提取字典的键值(key-value)对，并转换为独立的数组。实例如下：

import Cocoa

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

let dictKeys = [Int](someDict.keys)

let dictValues = [String](someDict.values)

print("输出字典的键(key)")

for (key) in dictKeys {

    print("\(key)")

}

print("输出字典的值(value)")

for (value) in dictValues {

    print("\(value)")

}

以上程序执行输出结果为：

输出字典的键(key)

2

3

1

输出字典的值(value)

Two

Three

One

count 属性

我们可以使用只读的 count 属性来计算字典有多少个键值对：

import Cocoa

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

var someDict2:[Int:String] = [4:"Four", 5:"Five"]

print("someDict1 含有 \(someDict1.count) 个键值对")

print("someDict2 含有 \(someDict2.count) 个键值对")

以上程序执行输出结果为：

someDict1 含有 3 个键值对

someDict2 含有 2 个键值对

isEmpty 属性

Y我们可以通过只读属性 isEmpty 来判断字典是否为空，返回布尔值:

import Cocoa

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

var someDict2:[Int:String] = [4:"Four", 5:"Five"]

var someDict3:[Int:String] = [Int:String]()

print("someDict1 = \(someDict1.isEmpty)")

print("someDict2 = \(someDict2.isEmpty)")

print("someDict3 = \(someDict3.isEmpty)")

以上程序执行输出结果为：

someDict1 = false

someDict2 = false

someDict3 = true