Swift学习笔记－教程学习一基础篇

Posted 2020-07-30

1.1 常量和变量（Constants and Variables）

常量和变量把一个名字和一个指定类型的值关联起来。常量（不需要改变的值）值一旦设定就不能改变，而变量的值可以随意更改。如果可能，尽量使用常量。

声明Declaring Constants and Variables

常量和变量必须在使用前声明，用 let 来声明常量，用 var 来声明变量。

let maximumNumberOfLoginAttempts = 10

var currentLoginAttempt = 0

你可以在一行中声明多个常量或者多个变量，用逗号隔开：

var x = 0.0, y =0.0, z = 0.0

类型标注Type Annotations

说明常量或者变量中要存储的值的类型。

var welcomeMessage:String //变量welcomeMessage是字符串类型

var red, green, blue: Double

命名Naming Constants and Variables

不能包含空白字符（whitespace空格、Tab和回车键）、数学符号，箭头，私用及非法的Unicode 码，封装字符（line- and box-drawing characters）。也不能以数字开头，不能重复定义同一个名称。

let π = 3.14159

let 你好 = "你好世界"

let ???? = "dogcow" //狗和牛的头像

var friendlyWelcome = "Hello!"

friendlyWelcome = "Bonjour!"

1.2 语句、分号与注释（Comment）

一般一行一条语句，结尾无分号。

//单行注释 

/*   */多行注释，可以嵌套。通过运用嵌套多行注释，你可以快速方便的注释掉一大段代码，即使这段代码之中已经含有了多行注释块

/*A complete Swift command is a statement. The typical layout of a program is one statement, one line:*/

print("Hello, ")

print("world!")

print("hello, "); print("world!")

1.3 类型安全和类型推断Type Safety and Type Inference

类型安全：帮助你清楚地知道代码要处理的值的类型，如果代码希望的是String，当你不小心使用或传入Int，或其它类型，编译时类型安全检查会提醒你。常量、变量、函数都有类型。

整数integers：Swift 提供了8，16，32和64位的有符号和无符号整数类型。

Int

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

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

UInt

在32位平台上， UInt 和 UInt32 长度相同。

在64位平台上， UInt 和 UInt64 长度相同

浮点数Floating-Point Numbers

Double 表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。

Float 表示32位浮点数。精度要求不高的话可以使用此类型。

类型推断：如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。

当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个字面量（literal value 或 literal）即可触发类型推断。

let meaningOfLife =42

// meaningOfLife 会被推测为 Int 类型

let pi = 3.14159

// pi 会被推测为 Double 类型

当推断浮点数的类型时，Swift 总是会选择 Double 而不是 Float 。

如果表达式中同时出现了整数和浮点数，会被推断为 Double 类型：

let anotherPi = 3 +0.14159

// anotherPi 会被推测为 Double 类型。

1.4 数值型字面量Numeric Literals

字面量就是会直接出现在你代码中的值 (Aliteral value is a value that appears directly in your source code)。

let decimalInteger =17

let binaryInteger =0b10001       // 二进制的17，以0b开头

let octalInteger =0o21           // 八进制的17，以0o开头

let hexadecimalInteger = 0x11     // 十六进制的17，以0x开头

指数为exp的十进制即基数乘以10^exp ：

1.25e2 means 1.25 x10², or 125.0.

1.25e-2 means 1.25 x10^-2, or 0.0125.

指数为exp十六进制即基数乘以2^exp:

0xFp2 means 15 x 2², or 60.0.

0xFp-2 means 15 x2^-2, or 3.75.

let paddedDouble =000123.456

let oneMillion =1_000_000

let justOverOneMillion = 1_000_000.000_000_1

1.5 数值型类型转换Numeric Type Conversion

整数尽量使用 Int 类型，可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断。

整数转换Integer Conversion

不同整数类型的变量和常量可以存储不同范围的数字。

Int8数字范围是 -128 ~ 127 ， UInt8数字范围是 0 ~ 255 。

let twoThousand:UInt16 = 2_000

let one: UInt8 = 1

let twoThousandAndOne = twoThousand + UInt16(one)

现在两个数字的类型都是 UInt16 ，可以进行相加。目标常量 twoThousandAndOne 的类型被推断为 UInt16 ，因为它是两个 UInt16 值的和。

整数和浮点数转换Integer and Floating-Point Conversion

整数和浮点数的转换必须显式指定类型：

let three = 3

let pointOneFourOneFiveNine = 0.14159

let pi =Double(three) + pointOneFourOneFiveNine

// pi 等于 3.14159，所以被推测为 Double 类型

这个例子中，常量 three 的值被用来创建一个 Double 类型的值，所以加号两边的数类型须相同。如果不进行转换，两者无法相加。

浮点数到整数的反向转换同样行，整数类型可以用Double 或者 Float 类型来初始化：

let integerPi =Int(pi)

// integerPi 等于 3，所以被推测为 Int 类型

当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说 4.75 会变成 4 ， -3.9 会变成 -3 。

1.6 类型别名Type Aliases

当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：

typealias Audiosample = UInt16

var maxAmplitudeFound = AudioSample.min

// maxAmplitudeFound现在是 0

1.7 布尔值Booleans

布尔值只能是真或者假。Swift有一个基本布尔类型Bool，有两个布尔常量，true和false：

let orangesAreOrange = true

let turnipsAreDelicious = false

1.8 元组Tuples

tuples把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

let http404Error =(404, "Not Found")

// http404Error 的类型是 (Int, String)，值是 (404, "Not Found")

你可以将一个元组的内容分解成单独的常量和变量：

let (statusCode, statusMessage) = http404Error

print("The status code is \(statusCode)")

// 输出 "The status code is404"

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（ _ ）标记：

let(justTheStatusCode, _) = http404Error

print("The status code is \(justTheStatusCode)")

// 输出 "The status code is404"

此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：

print("The status code is \(http404Error.0)")

// 输出 "The status code is404"

print("The status message is \(http404Error.1)")

// 输出 "The status message is NotFound"

你可以在定义元组的时候给单个元素命名：可以通过名字来获取这些元素的值：

let http200Status =(statusCode: 200, description: "OK")

print("The status code is \(http200Status.statusCode)")

// 输出 "The status code is200"

print("The status message is \(http200Status.description)")

// 输出 "The status message isOK"

1.9 可选类型Optionals

可选类型表示：有值等于 x 或者没有值。表示为：类型？

let possibleNumber ="123"

let convertedNumber = Int(possibleNumber)

// convertedNumberis inferred to be of type "Int?", or "optional Int"

因为该构造器可能会失败，所以它返回一个可选类型Int?，而不是一个Int。

nil

你可以给可选变量赋值为 nil 来表示它没有值：

var serverResponseCode: Int? = 404

// serverResponseCode contains an actual Int value of 404

serverResponseCode = nil

// serverResponseCode now contains no value

定义可选变量时如果没有同时赋值，则变量自动取值nil。

var surveyAnswer: String?

// surveyAnswer is automatically set to nil

if语句以及强制解析If Statements and Forced Unwrapping

可以使用 if 语句和nil比较（“相等”( == )或“不等”( != )）来判断一个可选值是否包含值。

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

if convertedNumber != nil {

print("convertedNumber has an integer value of\(convertedNumber!).")

}

// Prints "convertedNumber has an integer value of 123."

可选绑定Optional Binding

使用可选绑定来判断可选类型是否包含值，如果包含值就把这个值赋给一个临时常量或者变量。使用if 或 while

·  if let constantName = someOptional{

·      statements

·  }

if let actualNumber =Int(possibleNumber) {

print("\‘\(possibleNumber)\‘has an integer value of \(actualNumber)")

} else {

print("\‘\(possibleNumber)\‘ could not be converted to aninteger")

}

// 输出 "‘123‘ has an integer valueof 123"

actualNumber 只被用来输出转换结果。

你可以包含多个可选绑定在 if 语句中，并使用 where 子句做布尔值判断。

If let firstNumber = Int("4"), secondNumber = Int("42") where firstNumber < secondNumber {

print("\(firstNumber) < \(secondNumber)")

}

//Prints "4 < 42"

隐式解析可选类型Implicitly Unwrapped Optionals

有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。这种类型的可选状态被定义为隐式解析可选类型（!）。基本类型后面为！，而不是？。

let possibleString: String? = "An optionalstring."

let forcedString: String = possibleString! //requires an exclamation mark

let assumedString: String! = "An implicitlyunwrapped optional string."

let implicitString: String = assumedString // no need for an exclamation mark

if assumedString != nil {

     print(assumedString)

}

// Prints "An implicitly unwrapped optionalstring."

if let definiteString = assumedString {

     print(definiteString)

}

// Prints "An implicitly unwrapped optionalstring."

注意：如果一个变量后来可能变成 nil 的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是 nil 的话，请使用普通可选类型。

1.10 基本运算符（Basic Operators）

Swift运算符有一元、二元和三元运算符。

1.10.1赋值运算符Assignment Operator =

let b = 10    //把等号左面的10 赋值给常量b

var a = 5

a = b   // a现在为10

let (x, y) = (1, 2)  // x is equal to 1, and y is equal to 2

1.10.2算术运算符Arithmetic Operators

• Addition (+)  Subtraction (-)  Multiplication (*)  Division (/)

加法运算符也可用于 String 的拼接：

"hello, " + "world"  // 等于 "hello, world"

求余运算符Remainder Operator

求余运算（a % b）计算b的多少倍刚刚好可以容入a，返回多出来的那部分（余数）

浮点数求余计算Floating-Point Remainder Calculations

8 % 2.5 // equals 0.5

一元负号运算符Unary Minus Operator

let three = 3

let minusThree = -three // -3

let plusThree = -minusThree

一元正号运算符Unary Plus Operator

let minusSix = -6

let alsoMinusSix = +minusSix

1.10.3组合赋值运算符（Compound Assignment Operators）

var a = 1

a += 2  // a is now equal to 3

1.10.4比较运算符Comparison Operators

• 等于（ a == b ）

• 不等于（ a != b ）

• 大于（ a > b ）

• 小于（ a < b ）

• 大于等于（ a >= b ）

• 小于等于（ a <= b ）

1.10.5三目运算符Ternary Conditional Operator

if question {

answer1

} else {

answer2

}

let contentHeight = 40

let hasHeader = true

let rowHeight = contentHeight + (hasHeader ? 50 : 20)

// rowHeight is equal to 90

1.10.6空合运算符Nil Coalescing Operator

空合运算符( a ?? b )对可选类型a进行空判断，如果a包含一个值就进行解封，否则就返回一个默认值b .这个运算符有两个条件:

• 表达式a必须是Optional类型

• 默认值b的类型必须要和a存储值的类型保持一致

1.10.7区间运算符Range Operators

闭区间运算符Closed Range Operator

闭区间运算符（a...b）定义一个包含从a到b (包括a和b)的所有值的区间，b必须大于等于a。

半开区间运算符Half-Open Range Operator

半开区间（a..<b）定义一个从a到b但不包括b的区间。之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。

1.10.8逻辑运算符Logical Operators

逻辑非Logical NOT Operator

逻辑非运算（!a）对一个布尔值取反，使得true变false，false变true。

逻辑与Logical AND Operator

逻辑与（a && b）表达了只有a和b的值都为true时，整个表达式的值才会是true。只要任意一个值为false，整个表达式的值就为false。

逻辑或Logical OR Operator

逻辑或（a || b）表示两个逻辑表达式的其中一个为true，整个表达式就为 true 。

逻辑运算符组合计算Combining Logical Operators

Swift 逻辑操作符&&和 || 是左结合的，&& 和 || 始终只能操作两个值。

使用括号来明确优先级Explicit Parentheses