ch01基础--The Basics

1.0声明常量和变量

//声明常量用关键字 let, 声明变量用关键字 var
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
//声明多个常量和变量以逗号隔开
var x = 0.0, y = 0.0, z = 0.0
//说明：如果在代码里一个值是不变的，那么声明它作为常量，用关键字let,变量仅仅是用来存储变的值

1.1类型注释

//当你在声明一个常量和变量的时候，为其提供一个类型注释，可以清楚的表明常量或者变量可以存什么值
//类型注释，在常量或变量名后放冒号，然后跟一个空格， 最后跟使用的类型名字
//给变量welcomeMessage提供一个类型注释，表明变量可以存储字符串类型的值
var welcomeMessage: String
//冒号意味着什么类型的什么，声明一个变量，变量名是welcomeMessage，他是String类型的
welcomeMessage = "Hello"
//你可以声明多个相同类型的变量，以逗号隔开，在最后一个变量名后加上类型注释
var red, green, blue: Double
//说明：实际当中，你没必要写类型注释，如果你为常量或变量提供一个初始值的话，swift总是可以推断出常量或变量的类型来，在上面welcomeMessage的例子中，没有提供初始值，因此welcomeMessage的类型是一个特别的类型注释

1.2变量和常量命名

//变量和常量命名可以包含任何字符，包括没有编码的字符
let 你好 = "hello"
let π = 3.14159
let ? = "dog"
//变量和常量命名不能包含空格，数学符号，箭头，等等，他们也可以以数字开头，数字也可以被包括在名字中的其他地方
//说明：如果你以swift保留的关键字来给常量或变量命名，那么用反引号`将关键字括起来。但是，可以避免使用关键字命名

//你可以改变一个变量的值为另一个兼容类型的值
var friendlyWelcome = "Hello"
friendlyWelcome = "Bonjour!"
//和变量不一样，已但设置值，常量就不可改变

1.3打印变量和常量--Constants and Variables

//你可以打印当前常量或变量的值用print(_:separator:terminator:)
//print(friendlyWelcome)
//print(你好)
//print("The current value of friendlyWelcome is \(friendlyWelcome)")
//print("hello")
//print("\n")
//print("world")

1.4注释--Comments

//单行注释，
/*  多行
    注释
*/

1.5分号--Semicolons

//不像其它语言，swift没有要求你在每一句后面加分号(;),当然你也可以这样做，然而，如果你要在一行里写多个语句，分号是必须要写的
//let cat = "?"; print(cat)

1.6整型--Integers

//用min和max属性你可以获得每种整型类型最大值和最小值
let minValue = UInt8.min
let maxValue = UInt8.max
//print(minValue,maxValue)//0,255

//swift提供了另外一种整型类型，Int
//On a 32-bit platform, Int is the same size as Int32.
//On a 64-bit platform, Int is the same size as Int64
//swift也提供了一种无符号整型类型，UInt
//On a 32-bit platform, UInt is the same size as UInt32.
//On a 64-bit platform, UInt is the same size as UInt64.

1.7浮点类型--Floating-Point Numbers

//浮点数是带小数点的数，swift提供了两种带符号的浮点数
//Double represents a 64-bit floating-point number.
//Float represents a 32-bit floating-point number.
//说明：Double是15位小数，Float是6位小数,两种类型都合适的情况下推荐使用Double

1.8类型安全和类型推断--Type Safety and Type Inference

//如果你没有指定值的类型，swift会用类型推断来推断出合适的类型来
let meaningOfLife = 42//meaningOfLife is inferred to be of type Int
//同样的，如果你没有为浮点数指定类型，swift会推断出为Double类型
let pi = 3.14159//pi is inferred to be of type Double
//当推断一个浮点数的类型的时候，swift总是会选择Double，而不是Float类型
//如果一个表达式是整型和浮点型的组合，那么结果是Double类型
let anotherPi = 0.14159//anotherPi is also inferred to be of type Double

1.9数字常量--Numeric Literals

//整型常量可以被写成一下形式
//十进制数，没有前缀
//二进制数，以0b开头
//八进制数，以0o开头
//十六进制数，以0x开头
//比如十进制数17
let decimalInteger = 17
let binaryInteger = 0b10001//二进制表示
let octalInteger = 0o21//八进制表示
let hexadecimalInteger = 0x11//16进制表示

//浮点数可以用十进制或十六进制表示，
//对于十进制数来说，exp是基于10exp；
//1.25e2意味着 1.25 x 102，或者125.0
//1.25e-2意味着 1.25 x 10-2，或者0.0125
//对于十六进制来说，exp是基于2exp
//0xFp2意味着，15 x 22，15*4=60.0
//0xFp-2意味着，15 x 2-2，或者3.75
//比如浮点数12.1875
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

let oneMillion = 1_000_000//一百万

1.10数字类型转换--Numeric Type Conversion

//Int8类型的常量或变量可以是-128到127，
//UInt8类型的常量或变量可以是0到255
//let cannotBeNegative: UInt8 = -1//编译报错，UInt8不可能为负数
//let tooBig: UInt8 = UInt8.max+1//编译报错，超出了UInt8的范围

//常量twoThousand是UInt16类型，常量one是UInt8类型，二者不能直接相加，因为他们不是同一个类型，相反，会调用UInt16(one)产生一个新的UInt16类型来初始化one,用这个值代替原来的值
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)//现在加号两边都是UInt16类型，所以可以相加，结果被推断出为UInt16类型，因为他是两个UInt16类型值的和
//SomeType(ofInitialValue)是一个默认的方式，来调用一个swift类型的初始值
//print(twoThousandAndOne)

//整形和浮点的转换
//let three = 3
//let pointOneFourOneFiveNine = 3.14159
//let pi = Double(three) + pointOneFourOneFiveNine// pi equals 3.14159, and is inferred to be of type Double
//常量three被用做转换为一个Double类型的新值，没有这个转换，加法不被允许

//浮点到整型转换一定要明确，Double或Float类型值可以被初始化为一个整型
let integerPi = Int(pi)// integerPi equals 3, and is inferred to be of type Int
//当被初始化一个新的整型值的时候，小数点会被抛弃，比如4.75变成4，-3.9变成-3
//说明：数字常量和数字变量组和规则是不同于数字转换规则的，The literal value 3 can be added directly to the literal value 0.14159, because number literals do not have an explicit type in and of themselves. Their type is inferred only at the point that they are evaluated by the compiler.

1.11类型别名--Type Aliases

//类型别名可以为一个已经存在的类型定义一个别名，使用关键字typealias
typealias AudioSample = UInt16//一旦定义别名，你可以在任何地方使用这个别名
var maxAmplitudeFound = AudioSample.min// maxAmplitudeFound is now 0

1.12布尔值--Booleans

//swift有个布尔类型，Bool,swift提供了连个布尔值常量，true/false
let orangesAreOrange = true
let turnipsAreDelicious = false
//orangesAreOrange和turnipsAreDelicious的类型被推断为Bool类型，
//和Int和Double一样，如果当你创建他们的时候，你设置了true或者false,你没必要创建常量或变量为Bool类型，因为类型推断会帮助swift代码更简洁和易读，当初始化常量或变量为类型已知的值
//Bool主要用在条件判断
//if turnipsAreDelicious {
//    print("Mmm, tasty turnips!")
//} else {
//    print("Eww, turnips are horrible.")
//}
// prints "Eww, turnips are horrible."

//swift的类型安全会防止非Bool值被取代成Bool类型，下面的例子会报错
let i = 1
//if i {
//    // this example will not compile, and will report an error
//}

//下面的是合法的
if i==1 {
     // this example will compile successfully
}

1.13元组--Tuples

//元组群可以将多个值变成一个复合值，一个元组值可以是任何类型，没有必要是相同的类型
//下面的例子中，(404,"Not Found")是一个元组，用来描述http状态码,
let http404Error = (404,"Not Found")//http404Error is of type (Int, String), and equals (404, "Not Found")
//元组(404,"Not Found")是Int和String的组合，用于描述http状态码,
//你可以产生类型的任何排列，只要你喜欢，可以包括多个类型，比如，(Int,Int,Int),(String,Bool)
//你可以将元组分解为常量和变量
let (statusCode,statusMessage) = http404Error
//print("The status code is \(statusCode)")// prints "The status code is 404"
//print("The status Message is \(statusMessage)")// prints "The status message is Not Found"
//如果你需要元组值中的某几个，当你分解元组时，可以用下划线_忽略元组的部分
let (justTheStatusCode,_) = http404Error
//print("The status code is \(justTheStatusCode)")// prints "The status code is 404"
//另外，你也可以通过索引来获取元组值，索引从0开始
//print("The status code is \(http404Error.0)")// prints "The status code is 404"
//print("The status message is \(http404Error.1)")// prints "The status message is Not Found"
//你也可以这样定义元组
let http200Status = (statusCode: 200,description: "OK")
//print("The status code is \(http200Status.statusCode)")// prints "The status code is 200"

1.14可选的--Optionals

//当一个值缺失的时候你可以使用optionals
//optionals这样解释：这儿有个值，它等于x ，或者这儿根本没有值
//c或者oc里是没有可选值的概念，比较接近的是，oc里方法的返回值，要么返回一个对象，要么返回nil，然而这个只适用于对象，不适应于结构体等基本的c类型，
//下面的例子告诉你optionals是怎样接近值缺失的
//Swift的Int类型有一个初始化，尝试初始化一个String类型值为Int类型值。可视，并不是每个字符串都能被转换的，字符串"123"可以被转换为123，但是字符串"Hello,World"没有明显对应的数字可以转换
let possibleNumber = "123"
//let convertedNumber = Int(possibleNumber)
//convertedNumber is inferred to be of type "Int?", or "optional Int"
//因为初始化可能失败，所以它返回一个optional Int，而不是 Int,一个optional Int写成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不能用于必选的常量或者变量，如果一个常量或者变量在某些情况下可能需要一个缺失的值，那么声明这个常量或者变量为可选的
//如果你声明了一个可选的变量，而没有给她提供一个默认的值，那么变量被自动设置为nil
var surveyAnswer: String?//surveyAnswer is automatically set to nil
//说明，swift的nil不同于oc中的nil,oc里nil指的是一个指针，一个不不存在的对象，在swift里nil不是指针，他是某个确切类型的缺失值，任何类型的Optionals都可以被设置为nil,不仅仅是对象类型
//强制解耦
//你可以用if语句将一个可选的值和nil比较，判断可选的值是不是有值
//if convertedNumber != nil {
//    print("convertedNumber contains some integer value.")
//}// prints "convertedNumber contains some integer value."
//一旦你知道这个可选的有值，你可以使用这个值通过在可选的名字后加感叹号!
//if convertedNumber != nil {
//    print("convertedNumber has an integer value of \(convertedNumber!).")
//}// prints "convertedNumber has an integer value of 123."
//说明：在使用!强制使用这个值之前一定要确保这个可选的不为nil
//可选绑定--Optional Binding
//可选绑定，可以用来确定可选的是否有值，如果有值，使值可以被或得，作为短暂的常量或者变量
//可选绑定可以用在if和while语句中，来检查一个可选的值
//可选绑定的if语句格式如下:
//if let <#constName#> = <#someOptional#> {
//    <#statements#>
//}
//ni可以用可选绑定重写上面的possibleNumber例子，而不用强制解缠
//if let actualNumber = Int(possibleNumber) {
//    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
//}else {
//    print("\'\(possibleNumber)\' could not be converted to an integer")
//}
//prints "'123' has an integer value of 123"
//代码可以这样理解，如果Int(possibleNumber)返回的可以Int类型有值，那么设置一个新的常量叫做actualNumber来存储这个可选的值
//如果转换成功，actualNumber常量变成了一个可获得值，使用第一个if分支,因此没必要是!去转换
//常量和变量都可以使用可选绑定，如果你想在第一个if分支中操作actualNumber值，那么判断条件你应该写成if var actualNumber，而且这个值被当作变量使用，而非常量
//你可一个在if条件中包括多个可选绑定，使用where关键字来检查条件
//if let firstNumber = Int("4"), secondNumber = Int("42") where firstNumber < secondNumber {
//     print("\(firstNumber) < \(secondNumber)")
//}
// prints "4 < 42"
//模糊解耦可选操作
//正如上面所描述的那样，可选暗示常量或变量允许没有值，可选值可以通过if语句来判断是否有值，如果存在值，可以使用可选绑定来或去该值
//有时在代码里,当一个可选值第一次被设置是，可以肯定 这个可选 有一个确定值的时候，那么模糊解耦可选是有用的，用来去除必要的检查和解耦操作，因为他很安全的被确定一直有值，这种可选操作被定义为模糊解耦可选，在你想要的可选类型后面，你可以写一个模糊解耦可选通过放置一个!而不是?(比如，String!而不是String?)
//例子
//let possibleString: String? = "An optional string."
//let forcedString: String = possibleString!
//print(forcedString)//An optional string.
//模糊解耦可选
let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString
//print(implicitString)//An implicitly unwrapped optional string.
//说明：如果模糊解耦可选是nil，你尝试或得他的值，那么编译会报错，这和你放置一个!在一个没有值的可选后面报的错一样
//你也可以向其他可选那样使用if语句来判定模糊解耦可选是否有值
if assumedString != nil {
//     print(assumedString)//An implicitly unwrapped optional string.
}
//你也可以使用可选绑定来检查模糊解耦可选的值
//if let definiteString = assumedString {
//    print(definiteString)//An implicitly unwrapped optional string.
//}
//说明：当一个变量值在稍后可能为nil的时候，不要用使用模糊解耦可选，如果你想检查一个变量是否为nil,可以使用其他可选

1.15错误处理--Error Handling

//在执行代码的时候，你可以用错误处理来响应你可能会遇到的错误
//当函数遇到错误条件的时候，会抛出一个错误，函数的条用者可以捕获这个错误，在合适的时机响应它，
//使用关键字throw来声明一个函数可以抛出错误
//func canThrowhAnError() throws {
//    // this function may or may not throw an error
//}
//当你调用一个可以抛出错误的函数时候，使用前者关键字try来表达
//swift会自动的传递错误，直到错误被catche捕获并处理
//do {
//    try canThrowAnError()
//    // no error was thrown
//} catch {
//
//    // an error was thrown
//}
//下面的例子，说明了错误处理是怎样响应不同的错误条件：
//func makeASandwich() throws {
//    //...
//}
//
//do {
//    try makeASandwich()
//    eatASandwich()
//} catch Error.OutOfCleanDishes {
//    washDishes()
//} catch Error.MissingIngredients(let ingredients) {
//    buyGroceries(ingredients)
//}
//在这个例子中，如果盘子不干净，或者没有原料，那么makeASandwich()会抛出一个错误，如果没有错误被抛出，eatASandwich()函数会被调用，

1.16断言--Assertions

//如果一个特定的条件不符合，那么你的代码不可能会继续被执行，这是，会触发在你的代码里会触发断言来结束执行，并且提供一个机会来调试
//用断言调试
//断言是一个运行检查，来检查Bool条件是不是true,如果条件是true，代码会正常执行，相反，如果条件是false，那么代码会停止执行，app会终止
//断言会提供给你一个合适的调试信息
//你可以写断言，通过调用 assert(_:_file:line:)函数，给这个函数提供一个表达式用来评估是true还是false，如果被评估为fasle，那么message会被调用
//let age = -2
//assert(age >= 0,"A person's age cannot be less than zero")
// this causes the assertion to trigger, because age is not >= 0
//在这个例子中，代码仅仅会执行，当age>=0成立。
//print(age)
//若干有需要，断言message可以省略，
//assert(age >= 0)

转载于:https://my.oschina.net/u/2493045/blog/626189