2016年2月2日 星期二

ios app 的一些學習報落格



Reference : http://www.slideshare.net/sysheen/ios-25194974


張貼者： 於 沒有留言:
標籤：

swift 字串浮和字符


本页包含内容：




張貼者： 於 沒有留言:
標籤：

在自己的iPhone 上面 測試你寫的app



看起來蠻簡單的....簡言之就是找到你的iphone 的UUID....然後填到 code...再安裝即可..

有空來試試



找你的UUID 也可以從手機的app 來尋找 badmin uuid app

https://www.google.com.tw/#q=bafmin+uuid+viewer

安裝上面的 app就可以找到自己的UUID....同時可以寄信給自己

然後就是在你的MAC上面把這個UUID填上去

在Mac上建立Login Certification
1. 開啟應用程式 → 工具程式


2. 點選鑰匙圈存取 (keychain)

3. 開啟 keychain 程式後，由鑰匙圈存取 → 憑證輔助程式 → 從憑證授權要求憑證

4. 輸入你的Email及名稱，然後勾選儲存到磁碟及指定密鑰配對資訊
5. 完成之後就會看到多了一個 Public Key 及 Private Key，並會在桌面上產出一個名為
CertificateSigningRequest.certSigningRequest 的檔案

接下來就是建立開發用憑證....

建立開發用憑證及App Provision
首先連到iPhone Provision Portal頁面
1. 建立開發用憑證。點選Certificates → Development → Request Certificate
若還沒裝過WWDR憑證(Apple Worldwide Developer Relations Certification)的話，下面那個Download連結也要點。點了之後會下載一個名為 AppleWWDRCA.cer 的檔案。
註: 如果是要正式發佈到App Store，則改成點選 Distribution頁籤



2. 點取”選擇檔案”，將剛剛在Mac上利用Keychain做出來的 CertificateSigningRequest.certSigningRequest 檔匯入


3. 匯入成功之後，就會看到已經產出了一個開發者憑證了，點選Download會下載一個名為 developer_identity.cer 的檔案
4. 建立測試Device清單。點選Devices → Add Devices，輸入你想取的名字及Device ID。Device ID即要靠一開始提到的badmin uuid app得到


5. 建立App ID。點選App IDs → New App ID，照著表格填寫即可。請注意! 一旦建立一個App ID後，將永遠不能刪掉 (不知道以後會不會開放，Apple的說法是因為他們要留下來做記錄)。所以請不要建立太多App ID以免造成自己的困擾 (像我一樣… =.,=)

6. 建立Provision Profile。點選 Provisioning → Development → New Profile。照著表格填寫即可，建好之後點選Download會下載一個名為 [Profile Name].mobileprovision 的檔案
註: 如果是要正式發佈到App Store，則改成點選 Distribution頁籤
全部的動作完成之後，總共會得到如以下三個檔(或後兩個檔)。

7. double click developer_identity.cer 檔會開啟keychain，會看到已經多了一個iPhone Development的憑證。注意到上面有個Apple Worldxxx的憑證，即是 AppleWWDRCA.cer 憑證寫入的


點選Key，會看到Private Key已經與iPhone Development憑證做關聯了
8. 將你的iPhone用傳輸線接好Mac。double click [Profile Name].mobileprovision 檔，即會開啟XCode的Organizer畫面，並將Provision安裝至iPhone裡。

9. Okay! 一切都準備完了，接下來就是開啟XCode將App Upload到你的iPhone上去囉。執行環境選擇 Device → Run! 等它跑完… 恭喜!! 你終於可以在你的iPhone上Run你的程式囉! :smile:

Reference : http://open.mymy.tw/index-traitshow.html?id=121

Reference : http://fstoke.me/blog/?p=1805
張貼者： 於 沒有留言:

Learn swift : 基本運算浮號


本页包含内容：

术语

运算符有一元、二元和三元运算符。
  • 一元运算符对单一操作对象操作（如-a）。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操作对象之前（如!b），后置运算符需紧跟在操作对象之后（如i++）。
  • 二元运算符操作两个操作对象（如2 + 3），是中置的，因为它们出现在两个操作对象之间。
  • 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三目运算符（a ? b : c）。
受运算符影响的值叫操作数，在表达式1 + 2中，加号+是二元运算符，它的两个操作数是值1和2。

赋值运算符

赋值运算（a = b），表示用b的值来初始化或更新a的值：
let b = 10
var a = 5
a = b
// a 现在等于 10
如果赋值的右边是一个多元组，它的元素可以马上被分解成多个常量或变量：
let (x, y) = (1, 2)
// 现在 x 等于 1, y 等于 2

与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的：
if x = y {
    // 此句错误, 因为 x = y 并不返回任何值
}

浮点数求余计算

不同于 C 语言和 Objective-C，Swift 中是可以对浮点数进行求余的。
8 % 2.5   // 等于 0.5
这个例子中，8除于2.5等于3余0.5，所以结果是一个Double值0.5。
Art/remainderFloat_2x.png

  • 当++前置的时候，先自増再返回。
  • 当++后置的时候，先返回再自增。
例如：
var a = 0
let b = ++a // a 和 b 现在都是 1
let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1

空合运算符(Nil Coalescing Operator)

空合运算符(a ?? b)将对可选类型a进行空判断，如果a包含一个值就进行解封，否则就返回一个默认值b.这个运算符有两个条件:
  • 表达式a必须是Optional类型
  • 默认值b的类型必须要和a存储值的类型保持一致
空合运算符是对以下代码的简短表达方法
a != nil ? a! : b
上述代码使用了三目运算符。当可选类型a的值不为空时，进行强制解封(a!)访问a中值，反之当a中值为空时，返回默认值b。无疑空合运算符(??)提供了一种更为优雅的方式去封装条件判断和解封两种行为，显得简洁以及更具可读性。
下文例子采用空合运算符，实现了在默认颜色名和可选自定义颜色名之间抉择：
let defaultColorName = "red"
var userDefinedColorName: String?   //默认值为 nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 的值为空，所以 colorNameToUse 的值为 "red"
serDefinedColorName变量被定义为一个可选String类型，默认值为nil。由于userDefinedColorName是一个可选类型，我们可以使用空合运算符去判断其值。在上一个例子中，通过空合运算符为一个名为colorNameToUse的变量赋予一个字符串类型初始值。 由于userDefinedColorName值为空，因此表达式userDefinedColorName ?? defaultColorName返回defaultColorName的值，即red。
闭区间运算符（a...b）定义一个包含从a到b(包括a和b)的所有值的区间，b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在for-in循环中：
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25

半开区间运算符

半开区间（a..<b）定义一个从a到b但不包括b的区间。 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。
半开区间的实用性在于当你使用一个从0开始的列表(如数组)时，非常方便地从0数到列表的长度。
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("第 \(i + 1) 个人叫 \(names[i])")
}
// 第 1 个人叫 Anna
// 第 2 个人叫 Alex
// 第 3 个人叫 Brian
// 第 4 个人叫 Jack

逻辑运算

逻辑运算的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
  • 逻辑非（!a）
  • 逻辑与（a && b）
  • 逻辑或（a || b）

逻辑运算符组合计算

我们可以组合多个逻辑运算来表达一个复合逻辑：
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 输出 "Welcome!"

使用括号来明确优先级

为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使它看起来逻辑更明确：
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 输出 "Welcome!"


Reference : http://wiki.jikexueyuan.com/project/swift/chapter2/02_Basic_Operators.html
張貼者： 於 沒有留言:
標籤：

Learn swift basic


先從簡單的觀念開始....

let   是  常數
var  是  變數

例子如下:

var myVariable = 42
myVariable = 50
let myConstant = 42

myVariable 可以被改變....但是  myConstant 卻不能被改變了

你可以在一行中聲明多個常數或是多個變數...用逗號隔開

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

remark  -> //  或是  /*  */
// 这是一个注释


/* 这是第一个多行注释的开头
/* 这是第二个被嵌套的多行注释 */
这是第一个多行注释的结尾 */

不需要打分號....這點跟C語言不同

let cat = "🐱"; print(cat)
// 输出 "🐱"

整數的範圍....    .min  和 .max
let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型

Int

一般来说，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int，长度与当前平台的原生字长相同：
  • 在32位平台上，Int和Int32长度相同。
  • 在64位平台上，Int和Int64长度相同。

UInt

Swift 也提供了一个特殊的无符号类型UInt，长度与当前平台的原生字长相同：
  • 在32位平台上，UInt和UInt32长度相同。
  • 在64位平台上，UInt和UInt64长度相同。

浮点数

浮点数是有小数部分的数字，比如3.14159，0.1和-273.15。
浮点类型比整数类型表示的范围更大，可以存储比Int类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：
  • Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
  • Float表示32位浮点数。精度要求不高的话可以使用此类型。
注意：
Double精确度很高，至少有15位数字，而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围

数值型字面量

整数字面量可以被写作：
  • 一个十進制数，没有前缀
  • 一个二進制数，前缀是0b
  • 一个八進制数，前缀是0o
  • 一个十六進制数，前缀是0x

let decimalInteger = 17
let binaryInteger = 0b10001       // 二进制的17
let octalInteger = 0o21           // 八进制的17
let hexadecimalInteger = 0x11     // 十六进制的17
如果一个十进制数的指数为exp，那这个数相当于基数和10^exp的乘积：
  • 1.25e2 表示 1.25 × 10^2，等于 125.0。
  • 1.25e-2 表示 1.25 × 10^-2，等于 0.0125。
如果一个十六进制数的指数为exp，那这个数相当于基数和2^exp的乘积：
  • 0xFp2 表示 15 × 2^2，等于 60.0。
  • 0xFp-2 表示 15 × 2^-2，等于 3.75。
下面的这些浮点字面量都等于十进制的12.1875：
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：
let paddedDouble = 000123.456
let oneMillion = 1_000_000 
let justOverOneMillion = 1_000_000.000_000_1

整数转换

不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：
let cannotBeNegative: UInt8 = -1
// UInt8 类型不能存储负数，所以会报错
let tooBig: Int8 = Int8.max + 1
// Int8 类型不能存储超过最大值的数，所以会报错

要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是UInt8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算：
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi 等于 3.14159，所以被推测为 Double 类型

let integerPi = Int(pi)
// integerPi 等于 3，所以被推测为 Int 类型
当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说4.75会变成4，-3.9会变成-3。

类型别名 aliases

类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。
当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：
typealias AudioSample = UInt16

布尔值

Swift 有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift 有两个布尔常量，true和false：
let orangesAreOrange = true
let turnipsAreDelicious = false

如果你在需要使用Bool类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：
let i = 1
if i {
    // 这个例子不会通过编译，会报错
}
然而，下面的例子是合法的：
let i = 1
if i == 1 {
    // 这个例子会编译成功
}

元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
下面这个例子中，(404, "Not Found")是一个描述 HTTP 状态码（HTTP status code）的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个404 Not Found状态码。
let http404Error = (404, "Not Found")
// http404Error 的类型是 (Int, String)，值是 (404, "Not Found")

(404, "Not Found")元组把一个Int值和一个String值组合起来表示 HTTP 状态码的两个部分：一个数字和一个人类可读的描述。这个元组可以被描述为“一个类型为(Int, String)的元组”。

你可以将一个元组的内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：
let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// 输出 "The status code is 404"
print("The status message is \(statusMessage)")
// 输出 "The status message is Not Found"

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：
let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")
// 输出 "The status code is 404"

此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：
print("The status code is \(http404Error.0)")
// 输出 "The status code is 404"
print("The status message is \(http404Error.1)")
// 输出 "The status message is Not Found"

你可以在定义元组的时候给单个元素命名：
let http200Status = (statusCode: 200, description: "OK")
给元组中的元素命名后，你可以通过名字来获取这些元素的值：
print("The status code is \(http200Status.statusCode)")
// 输出 "The status code is 200"
print("The status message is \(http200Status.description)")
// 输出 "The status message is OK"

可选类型

使用可选类型（optionals）来处理值可能缺失的情况。可选类型表示：
  • 有值，等于 x
或者
  • 没有值

下面的例子使用这种构造器来尝试将一个String转换成Int：
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
因为该构造器可能会失败，所以它返回一个可选类型（optional）Int，而不是一个Int。一个可选的Int被写作Int?而不是Int。问号暗示包含的值是可选类型，也就是说可能包含Int值也可能不包含值。（不能包含其他任何值比如Bool值或者String值。只能是Int或者什么都没有。）

nil

你可以给可选变量赋值为nil来表示它没有值：
var serverResponseCode: Int? = 404
// serverResponseCode 包含一个可选的 Int 值 404
serverResponseCode = nil
// serverResponseCode 现在不包含值

如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为nil：
var surveyAnswer: String?
// surveyAnswer 被自动设置为 nil

注意：
Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为nil，不只是对象类型。

if 语句和强制解析

你可以使用if语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。
如果可选类型有值，它将不等于nil:
if convertedNumber != nil {
    print("convertedNumber contains some integer value.")
}
// 输出 "convertedNumber contains some integer value."
当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）：
if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}
// 输出 "convertedNumber has an integer value of 123."

 可选绑定
使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中，这条语句不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量。if和while语句，请参考控制流。
像下面这样在if语句中写一个可选绑定：
if let constantName = someOptional {
    statements
}

你可以像上面这样使用可选绑定来重写possibleNumber这个例子：
if let actualNumber = Int(possibleNumber) {
    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
} else {
    print("\'\(possibleNumber)\' could not be converted to an integer")
}
// 输出 "'123' has an integer value of 123"
这段代码可以被理解为：
“如果Int(possibleNumber)返回的可选Int包含一个值，创建一个叫做actualNumber的新常量并将可选包含的值赋给它。”
如果转换成功，actualNumber常量可以在if语句的第一个分支中使用。它已经被可选类型 包含的 值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualNumber只被用来输出转换结果。

你可以包含多个可选绑定在if语句中，并使用where子句做布尔值判断。
if let firstNumber = Int("4"), secondNumber = Int("42") where firstNumber < secondNumber {
    print("\(firstNumber) < \(secondNumber)")
}
// prints "4 < 42"

隐式解析可选类型

如上所述，可选类型暗示了常量或者变量可以“没有值”。可选可以通过if语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。
有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型_总会_有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型。
当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考无主引用以及隐式解析可选属性。
一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型String和隐式解析可选类型String之间的区别：
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要驚嘆號来獲取值

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString  // 不需要感叹号

你可以把隐式解析可选类型当做一个可以自动解析的可选类型。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。
注意：
如果你在隐式解析可选类型没有值的时候尝试取值，会触发运行时错误。和你在没有值的普通可选类型后面加一个惊叹号一样。
你仍然可以把隐式解析可选类型当做普通可选类型来判断它是否包含值：
if assumedString != nil {
    print(assumedString)
}
// 输出 "An implicitly unwrapped optional string."
你也可以在可选绑定中使用隐式解析可选类型来检查并解析它的值：
if let definiteString = assumedString {
    print(definiteString)
}
// 输出 "An implicitly unwrapped optional string."

错误处理

你可以使用错误处理（error handling）来应对程序执行中可能会遇到的错误条件。
相对于可选中运用值的存在与缺失来表达函数的成功与失败，错误处理可以推断失败的原因，并传播至程序的其他部分。
当一个函数遇到错误条件，它能报错。调用函数的地方能抛出错误消息并合理处理。
func canThrowAnError() throws {
    // 这个函数有可能抛出错误
}

一个函数可以通过在声明中添加throws关键词来抛出错误消息。当你的函数能抛出错误消息时, 你应该在表达式中前置try关键词。
do {
    try canThrowAnError()
    // 没有错误消息抛出
} catch {
    // 有一个错误消息抛出
}

这里有一个错误处理如何用来应对不同错误条件的例子。
func makeASandwich() throws {
    // ...
}

do {
    try makeASandwich()
    eatASandwich()
} catch Error.OutOfCleanDishes {
    washDishes()
} catch Error.MissingIngredients(let ingredients) {
    buyGroceries(ingredients)
}
在此例中，makeASandwich()（做一个三明治）函数会抛出一个错误消息如果没有干净的盘子或者某个原料缺失。因为makeASandwich()抛出错误，函数调用被包裹在try表达式中。将函数包裹在一个do语句中,任何被抛出的错误会被传播到提供的catch从句中。
如果没有错误被抛出, eatASandwich()函数会被调用。如果一个匹配Error.OutOfCleanDishes的错误被抛出,washDishes函数会被调用。如果一个匹配Error.MissingIngredients的错误被抛出，buyGroceries(_:)函数会随着被catch所捕捉到的关联值[String]被调用。
assert(斷言)
你可以使用全局assert(_:_file:line:)函数来写一个断言。向这个函数传入一个结果为true或者false的表达式以及一条信息，当表达式的结果为false的时候这条信息会被显示：
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// 因为 age < 0，所以断言会触发

何时使用断言

当条件可能为假时使用断言，但是最终一定要_保证_条件为真，这样你的代码才能继续运行。断言的适用情景：
  • 整数类型的下标索引被传入一个自定义下标实现，但是下标索引值可能太小或者太大。
  • 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
  • 一个可选值现在是nil，但是后面的代码运行需要一个非nil值。


型別轉換...... 
let label = "The width is"
let width = 94
let widthLabel = label + String(width)

label  的形態是 string...
但是 width 的形態是 integer...
所以在 widthLabel 的運算必須要先把 width轉換成 String....

還有一種更簡單的轉換成字串的方式.... -> \()
  \(apple)  轉換成   "3"
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."


使用 [] 來建立陣列和字典(dictionary)

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
初始化的語法.... 使用 [type]()   ->  array
                                      [String: type] -> dictionary

let emptyArray = [String]()
let emptyDictionary = [String: Float]()

 空arrary 或是空 dictionary的語法
shoppingList = []
occupations = [:]


控制流  (Control flow)... 使用 if 和 switch

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)


可以使用if 和 let 來處理缺失的情形....這些值可以從 optional 而來

一個optional 的值可以是任意值或是nil
var optionalString: String? = "Hello"
print(optionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过。如果不是nil，会将值赋给let后面的常量，这样代码块中就可以使用这个值了。

另一种处理可选值的方法是通过使用 ?? 操作符来提供一个默认值。如果可选值缺失的话，可以使用默认值来代替。

 
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}


switch支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。

 
let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}

你可以使用for-in来遍历字典（dictionary），需要两个變數来表示每个键值对。字典是一个无序的集合，所以他们的键和值以任意顺序迭代结束。

 
let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

 使用while来重复运行一段代码直到不满足条件。循环条件也可以在结尾，保证能至少循环一次。

 
var n = 2
while n < 100 {
    n = n * 2
}
print(n)

var m = 2
repeat {
    m = m * 2
} while m < 100
print(m)

你可以在循环中使用..<来表示範圍，也可以使用传统的写法，两者是等价的：
var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)

var secondForLoop = 0
for var i = 0; i < 4; ++i {
    secondForLoop += i
}
print(secondForLoop)

函数（function）和闭包(closure)

func name() ->  String   
後面的String 代表 傳回的type
func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", day: "Tuesday")

使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。
  scores :[int] -> 代表int 的陣列
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

 函数可以带有可變個数的参数，这些参数在函数内表现为数组的形式：

 
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)

函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。  func 裡面再包了一個func... 裡面的func 可以取用外面的變數
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

函数是第一等类型，这意味着函数可以作为另一个函数的返回值。
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

函数也可以当做参数传入另一个函数
func hasAnyMatches(list: [Int], condition: Int -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, condition: lessThanTen)

函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用{}来创建一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。

 
numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})

Reference : http://leolinn.com/291/6-resources-of-apple-swift
張貼者： 於 沒有留言:
標籤：
訂閱： 文章 (Atom)