初探swift语言的学习笔记一(基本数据类型)

作者：fengsh998

原文地址：http://blog.csdn.net/fengsh998/article/details/28258805

转载请注明出处

如果觉得文章对你有所帮助，请通过留言或关注微信公众帐号fengsh998来支持我，谢谢！

3号，端午刚过，回到公司第一个早上的两小时便贡献给了apple的ios 8 发布会，在看完后，感觉操作系统越来越离我们的生活更近了，更多的应用支持了人们的日常生活，健康，娱乐，旅游等领域，相信以后的生活也更加人工智能化，在发布会的最后，提到了swift的全新开发语言，据发布会上的介绍，更新安全，快捷，编码高效。因此也对此进行了第一阶段的初探与学习。

语言语法笔记：

1.常量和变量的定义。

常量使用let 进行约束， 变量使用var来约束，相信大家对var并不陌生，如早期的ＶＢ， pascal,js等都会有这样的定义。但根据书中介绍，swift对常量，和变量的约束，编译更加精确，有时候用户可以不需要声明某个常量是什么类型，像通常 声明一个变量 int b = 0; 而 在swift中使用var b=0 即可，swift可根据初始化的值进行判断是变量是什么类型，如果var 中没有指定足够的信息（当然是机算判断变量类型的信息时，）可以使用分号进行加以说明，如书中的例子：

let implicitInteger = 70 //会自动识别为integer

let implicitDouble = 70.0

let explicitDouble: Double = 70 //加上类型说明

变量的声明与使用

var myVariable = 42

myVariable = 50

var explicitVariable:Double = 60

还有一点有意思是变量或常量的命名名称，几呼支持各种字符，包知unicode字符。

[cpp] view
plaincopy





let constvalue = 70 ;let 我爱你中国 = "我要写中国的操作系统" ;println(constvalue) ;println(我爱你中国);

上面代码写在一行时，需要用分隔号分开，如果不使用分号，可以使用换行符：

[cpp] view
plaincopy





let constvalue = 70

let 我爱你中国 = "我要写中国的操作系统"

println(constvalue)

println(我爱你中国)

运行后输出：

[html] view
plaincopy





70

我要写中国的操作系统

2.字符串串接及类型转换

大家可能用ＯＣ都有一个想骂人的串接问题，如 在nsstring *a = "hello" 串接 " world",常常使用stringbyappendstring ，或使用stringWithFormat:"%@,%@" 来串接，有没有？而不能使用"+"操作符。真难过，实在难过，特别是对于C/C++,PASCAL,JAVA 甚至更多高级语言都是支持“＋”号操作符。唯有ＯＣ特别，搞得我一个同事说，想学习一下ＩＯＳ，但语言太另类了，其实啥语言都大差不差，习惯就好。现在好了,swift来了，他也支持“＋”号操作符了。如：

“let label = "The width is "

let width = 94

let widthLabel = label + String(width)”

同时大家也可能发现了，width是整型，在这里被显式的强制类型转换为字符型，这里有个疑问，就是 如果没有进行强制类型转换，这let widthLabel = label + width这样是否可以编译过呢？编译器会不会隐式的进行转换呢，我也好期待，因为没有操作环境，只是在看swift官方学习文档中的，因此留在这里，后续有环境进行验证一下。

接下来说说这个类型转换，咋看又像在抄pascal 或java 的语法， c/c++ 的风格的都是(类型)变量，如(char *) var ，(double) var,而不会写成double(var)，oc的写法，与c/C＋＋的很像。没太搞明白为毛，即整合c/c++的，又特地搞个风格别致的，当然，什么都不要紧，习惯就好。对吧，大伙说。

不过swift似呼也嗅到了什么，也提提供了另一种参变量使用"\()" 操作符，其中括号中的还支持表达式操作。至于反斜扛操作嘛，就有点像大家在C/C++ 中的换行串接时，在行尾加上的\的含议差不多。看一下官方给出的例子：

“let apples = 3

let oranges = 5

let appleSummary = "I have \(apples) apples."

let fruitSummary = "I have \(apples + oranges) pieces of fruit.”

可能用文字表达不出\()的意思，其实就是参数变量 把上面四句翻译为oc 则为

NSInteger apples = 3;

NSInteger oranges = 5;

NSString *appleSummary = [NSString stringWithFormat:@"I have %d apples",apples];

经试验：

[cpp] view
plaincopy





let constvalue = 70

let 我爱你中国 = "我要写中国的操作系统"

let ok = String(constvalue)+我爱你中国

let okgood = "字符串串接\(我爱你中国)"

println(okgood)

输出为：

字符串串接我要写中国的操作系统

数据类型别名：

oc /c/c++都使用typedef 来约束新的类型别名

而swift 则使用typealias

typealias AudioSample = UInt16

字符串常量可以包括下面这些特殊字符：

空字符\0，反斜杠\，制表符\t，换行符\n，回车符\r，双引号\”和单引号\’

单字节Unicode字符，\xnn，其中nn是两个十六进制数

双字节Unicode字符，\unnnn，其中nnnn是四个十六进制数

四字节Unicode字符，\Unnnnnnnn，其中nnnnnnnn是八个十六进制数



[cpp] view
plaincopy





let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"

// "Imagination is more important than knowledge" - Einstein

let dollarSign = "\x24" // $, Unicode scalar U+0024

let blackHeart = "\u2665" // ♥, Unicode scalar U+2665

let sparklingHeart = "\U0001F496" // , Unicode scalar U+1F496

初始化一个空字串

[cpp] view
plaincopy





var emptyString = "" // empty string literal

var anotherEmptyString = String() // initializer syntax

同时可以使用isEmpty来判断字符串是否为空，这点真的很像pascal,delphi就是这样检测的。

[cpp] view
plaincopy





if emptyString.isEmpty {

println("Nothing to see here")

}

在swift中字符串不是指针，而是实际的值，因此，在Swift中，一个String类型就是一个实际的值，当定义一个新的String，并且将之前的String值拷贝过来的时候，是实际创建了一个相等的新值，而不是仅仅像指针那样指向过去。同样在函数传递参数的时候，也是传递的实际值，并且创建了一个新的字符串，后续的操作都不会改变原有的String字符串。

单个字符的声明，像c/c++中使用 char ,而swift中则使用：

[cpp] view
plaincopy





let yenSign: Character = "￥"

通过for-in循环，可以遍历字符串中的每一个字符

[cpp] view
plaincopy





for character in "Dog!" {

println(character)

}

字符串长度的统计，可以使用全局函数countElements可以计算一个字符串中字符的数量，这点与其它语言length好像有点不同。

[cpp] view
plaincopy





let unusualMenagerie = "Koala , Snail , Penguin , Dromedary "

println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")

// prints "unusualMenagerie has 40 characters"

字符串与单个字符，可以使用+,+=操作将字符串和字符串接在一起。这点与其它语言稍先进一点。

字符串的比较使用 ＝＝

[cpp] view
plaincopy





let quotation = "We're a lot alike, you and I."

let sameQuotation = "We're a lot alike, you and I."

if quotation == sameQuotation {

println("These two strings are considered equal")

}

// prints "These two strings are considered equal"

//输出”These two strings are considered equal”

swift还保留了oc中的前后缀函数hasPrefix和hasSuffix

大小写字符串使用uppercaseString 和 lowercaseString

unicode :

Swift 支持多种不同的方式取得Unicode字符串.

你可以使用for-in语句遍历字符串，来获得每一个字符的Unicode编码值。这个过程已经在字符（Working with Characters）描述过了。

或者，下面三个描述中使用合适的一个来获得一个字符串的值

UTF-8字符编码单元集合使用String类型的utf-8属性

UTF-16字符编码单元集合使用String类型的utf-16属性

21位Unicode标量集合使用String类型的unicodeScalars属性

如例子：

[cpp] view
plaincopy





let testUncode = "Dog!狗"

for codeUnit in testUncode.utf8 {

print("\(codeUnit) ")

}

print("\n")

// 68 111 103 33 231 139 151

for codeUnit in testUncode.utf16 {

print("\(codeUnit) ")

}

print("\n")

// 68 111 103 33 29399

for scalar in testUncode.unicodeScalars {

print("\(scalar.value) ")

}

print("\n")

// 68 111 103 33 29399

在utf-8中，中文的"狗"占三个字节，而在utf-16 及标量（utf-32）中正好可以一个字节就装得下。

3.数组，字典

在swift的书中说，数组和字典都使用“［］”中括符，并可以通过索引或KEY /VALUE的方式存储。见官方例子：

“var shoppingList = ["catfish", "water", "tulips", "blue paint"] //声明一个四元素的数组变量

shoppingList[1] = "bottle of water" //重新将元素2的进行赋值

var occupations = [

"Malcolm": "Captain",

"Kaylee": "Mechanic",

]

occupations["Jayne"] = "Public Relations” //动太的添加一个jayne的key值为Public Relations

这个k/V的数组是否长的有点像JOSN啊。反正我看像，还可以动太的添加哦，

创建一个空的数组如： let emptyArray = String[]() //又是中括号又是圆括符的，看得真让人眼花。不过swift中说了，如果不需要指字类型，则数组可以直接使用"[ ]"

进行。如： shoppingList = [] ，字典则使用 “ ［ ：］” 来设为空字典。

另外字典增加了一个定议模式，有点像C++中的vector 或map之类的，可以指字 k/v的类型吧。见例：

“let emptyDictionary = Dictionary<String, Float>()”

整体感觉上还是比较像C++吧。

[cpp] view
plaincopy





//数组使用

//初始化时指定长度 确定类型的

var threeDoubles = Double[](count: 3, repeatedValue: 0.0)

println(threeDoubles)

//不确定类型的

var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)

println(anotherThreeDoubles)

//var computerList = String[]() //创建一个空的数组

var computerList: String[] = ["lenovo", "dell"]

//var computerList = ["lenovo", "dell"] //与上等效

if !computerList.isEmpty //判断是否为空数组

{

//数组长度

println("数组共有 \(computerList.count) 元素.")

println("元素分别为 \(computerList.description)") //使用description访问

}

//直接置空

computerList = []

println("空数组 \(computerList)")

//动态追加元素

computerList.append("sony")

println("追加后为:\(computerList)") //真接访问

computerList += "acer"

println("追加后为:\(computerList.description)")

//可以一次追加一个数组

computerList += ["HP", "samsung", "Apple"]

println("追加数组后为:\(computerList)")

var items = ["Haier","东之"]

computerList += items

println("追加数组后为:\(computerList)")

//下标访问

println("你访问索引3的元素\(computerList[3])")

//使用下标进行修改元素值

println("修改前为:\(computerList[2])")

computerList[2]="SONY"

println("修改后为:\(computerList[2])")

//通过闭包访问一次修改多个值

//注意[4..6]是半闭包即只包括改修4,5而不包括6

//使用[4...6]是全闭包，可以修改4,5,6

computerList[4...6] = ["惠普", "三星","a","b","c"]//元素超出部分会直接追加在末尾

println("修改后为:\(computerList)")

//插入元素

computerList.insert("computer", atIndex: 0)

println("插入后为:\(computerList)")

//通过索引进行删除元素

let del = computerList.removeAtIndex(0)

println("删除的元素为:\(del)")

//移除最后一个元素

let dellast = computerList.removeLast()

println("最后的元素为:\(dellast)")

//遍历数组

for item in computerList

{

println(item)

}

//如果需要每一个元素的整形的索引值，使用enumerate函数代替会更方便

//enumerate函数对于每一个元素都会返回一个包含元素的索引和值的元组

for (index, value) in enumerate(computerList)

{

println("Item \(index + 1): \(value)")

}

字典的使用

[cpp] view
plaincopy





//字典

//Dictionary<KeyType,ValueType> 唯一的限制就是KeyType必须是可哈希的（hashable）

//var namesOfIntegers = Dictionary<Int, String>() //创建空字典

var airport :Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]

var airports = ["TYO": "Tokyo", "DUB": "Dublin"]

//字典元素

println("字典包函元素有 \(airports.count) ")

//使用key添加 value

airports["LHR"] = "London"

println("添加元素后\(airports)")

//使用key修改

airports["LHR"] = "London Heathrow"

println("修改元素后\(airports)")

/*updateValue(forKey:) 方法如果键不存在则会设置它的值，如果键存在则会更新它的值, 和下标不一样是

updateValue(forKey:) 方法 如果更新时，会返回原来旧的值rThis enables you to 可以使用这个来判断是否发生了

updateValue(forKey:) 方法返回一个和字典的值相同类型的可选值. 例如，

如果字典的值的类型时String，则会返回String? 或者叫“可选String“，

这个可选值包含一个如果值发生更新的旧值和如果值不存在的nil值。

*/

if let oldValue = airports.updateValue("Dublin International", forKey: "DUB")

{

println("The old value for DUB was \(oldValue).")

println("最新值\(airports)")

}

//判空

if let airportName = airports["DUB"]

{

println("The name of the airport is \(airportName).")

}

else

{

println("That airport is not in the airports dictionary.")

}

//字典移除

airports["APL"] = "Apple International"

println("当前字典:\(airports)")

airports["APL"] = nil

println("移除后字典:\(airports)")

//也可以使用removeValueForKey 移除

if let removedValue = airports.removeValueForKey("DUB")

{

println("The removed airport's name is \(removedValue).")

}

else

{

println("The airports dictionary does not contain a value for DUB.")

}

//遍历字典

for (airportCode, airportName) in airports

{

println("\(airportCode): \(airportName)")

}

//遍历key

for airportCode in airports.keys

{

println("Airport code: \(airportCode)")

}

//遍历value

for airportName in airports.values

{

println("Airport name: \(airportName)")

}

//获取所有key 转为数组

let airportCodes = Array(airports.keys)

println("所有keys 为:\(airportCodes)")

//获取所有value 转为数组

let airportNames = Array(airports.values)

println("所有values 为:\(airportNames)")

4.枚举类型

枚举在swift中可胃得到了很高的提升。不单单只简单的支持Int数据类型，还扩展了支持其它数据类型，一起来探究一下吧

基本语法：

[cpp] view
plaincopy





enum CompassPoint {

case North

case South

case East

case West

}

每个case 为一个成员，但多个成员也可以写在一个case里，用逗号分隔

[cpp] view
plaincopy





enum Planet {

case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune

}

声明及使用

[cpp] view
plaincopy





//一旦指定了类型就可以使用.操作

var dicection : CompassPoint

dicection = .East

var directionToHead = CompassPoint.West

directionToHead = .South

与 switch配合使用

[cpp] view
plaincopy





var directionToHead = CompassPoint.West

switch directionToHead {

case .North:

println("Lots of planets have a north")

case .South:

println("Watch out for penguins")

case .East:

println("Where the sun rises")

case .West:

println("Where the skies are blue")

// default: //如果不需要各个都配置时，可以使用defult

// println("no what");

}

枚举的关联值支持
Swift的枚举类型可以由一些数据类型相关的组成，如果需要的话，这些数据类型可以是各不相同的。枚举的这种特性跟其它语言中的奇异集合

如：

[cpp] view
plaincopy





enum Barcode {

case UPCA(Int, Int, Int)

case QRCode(String)

}

然后可以使用任何一种类型来创建如：

[cpp] view
plaincopy





var productBarcode = Barcode.UPCA(8, 85909_51226, 3)

此示例创建一个名为productBarcode新的变量，并与相关联的元组值赋给它Barcode.UPCA的值（8，8590951226，3）。

也可以使用：

[cpp] view
plaincopy





productBarcode = .QRCode("ABCDEFGHIJKLMNOP")

不同的条码类型像以前一样可以使用一个switch语句来检查，但是这一次相关的值可以被提取作为switch语句的一部分。您提取每个相关值作为常数（let前缀）或变量（var前缀）不同的情况下，在switch语句的case代码内使用

[cpp] view
plaincopy





switch productBarcode {

case .UPCA(let numberSystem, let identifier, let check):

println("UPC-A with value of \(numberSystem), \(identifier), \(check).")

case .QRCode(let productCode):

println("QR code with value of \(productCode).")

}

如果所有的枚举成员的关联值的提取为常数，或者当所有被提取为变量，为了简洁起见，可以放置一个var，或let标注在成员名称前

[cpp] view
plaincopy





switch productBarcode {

case let .UPCA(numberSystem, identifier, check):

println("UPC-A with value of \(numberSystem), \(identifier), \(check).")

case let .QRCode(productCode):

println("QR code with value of \(productCode).")

}

别外也可以有给成员设置指定值：

[cpp] view
plaincopy





enum ASCIIControlCharacter: Character {

case Tab = "\t" //这里设置值要与<span style="font-family: Arial, Helvetica, sans-serif;">Character 类型相对应</span>

case LineFeed = "\n"

case CarriageReturn = "\r"

}

[cpp] view
plaincopy





enum ASCIIControlCharacter: Int {

case Tab = 10

case LineFeed = 20

case CarriageReturn = 30

}

同样还可以使枚举跟c/C++,java,pascal phyon等高级语言的效果一样。只需要设置第一个值后，后面的值会类推。

[cpp] view
plaincopy





enum Planet: Int {

case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune

}

后面的成员会自增。

同时swift还提供了访问枚举成中中的原始值，使用toRaw()如：

[cpp] view
plaincopy





let earthsOrder = Planet.Earth.toRaw()

// earthsOrder is 3

另外，还提供了一个检查访问，fromRaw()

[cpp] view
plaincopy





let possiblePlanet = Planet.fromRaw(7)

// possiblePlanet is of type Planet? and equals Planet.Uranus

使用枚举的fromRaw方法来试图找到一个特定的原始值枚举成员。这个例子识别Uranus的位置通过原始值为7：然而，并非所有可能的Int值都会找到一个匹配的星球。正因如此，该fromRaw方法返回一个可选的枚举成员。在上面的例子中，是possiblePlanet类型Planet？或“可选的Planet”。

如果你试图找到一个Planet为9的位置，通过fromRaw返回可选的Planet值将是无：因此在配合switch时可以这样：

[cpp] view
plaincopy





let positionToFind = 9

if let somePlanet = Planet.fromRaw(positionToFind) {

switch somePlanet {

case .Earth:

println("Mostly harmless")

default:

println("Not a safe place for humans")

}

} else {

println("There isn't a planet at position \(positionToFind)")

}

// prints "There isn't a planet at position 9"

5.条件表达式。

if/swicth

“let individualScores = [75, 43, 103, 87, 12]

var teamScore = 0

for score in individualScores {

if score > 50 {

teamScore += 3

} else {

teamScore += 1

}

}”

teamScore

为什么都不加括号了？对于多个表达式，还是这样长蛇阵么？

另外书中有这一段“In an if statement, the conditional must be a Boolean expression—this means that code such as if score { ... } is an error, not an implicit comparison to zero.”

个人理解是，如果在一个条件语句中，条件值必须是BOOL表达式的，因为非BOOL表达式不会隐式的与0进行比较，这点可能与传统的if有点不同吧。

经验证：多个条件也不需要用括号的。不过，如果你想要表达式正确，还是要按照运算优先级。

[cpp] view
plaincopy





var constvalueB = 200

let constvalue = 70

if constvalueB == 0 && constvalue > 60 || constvalue != 20

{

println("true")

}

else

{

println("false")

}

别外像：

[cpp] view
plaincopy





var constvalueB = 200

let constvalue = 70

if constvalueB

{

println("true")

}

else

{

println("false")

}

对

[cpp] view
plaincopy





constvalueB

这样的条件，在swift中已经通不过了，对条件判断也更别严格了。

再来看一下switch，这个总算有点点进步了，以前的switch大多只支持int或枚举类型，现在swift中把switch语句的表达式判断类型上进行了扩展。其次，每个case不再需要写break;这点不错。

“let vegetable = "red pepper"

switch vegetable {

case "celery":

let vegetableComment = "Add some raisins and make ants on a log."

case "cucumber", "watercress":

let vegetableComment = "That would make a good tea sandwich."

case let x where x.hasSuffix("pepper"):

let vegetableComment = "Is it a spicy \(x)?"

default:

let vegetableComment = "Everything tastes good in soup."

}”

哈哈，看到没有，没有break哦。。。冒似少了几个Ｂ的代码。

switch语句的case中可以匹配一个数值范围

[cpp] view
plaincopy





let count = 3_000_000_000_000

let countedThings = "stars in the Milky Way"

var naturalCount: String

switch count {

case 0:

naturalCount = "no"

case 1...3:

naturalCount = "a few"

case 4...9:

naturalCount = "several"

case 10...99:

naturalCount = "tens of"

case 100...999:

naturalCount = "hundreds of"

case 1000...999_999:

naturalCount = "thousands of"

default:

naturalCount = "millions and millions of"

}

println("There are \(naturalCount) \(countedThings).")

case中还可以直接测试元组是否符合相应的条件，_可以匹配任意值

[cpp] view
plaincopy





let somePoint = (1, 1)

switch somePoint {

case (0, 0):

println("(0, 0) is at the origin")

case (_, 0):

println("(\(somePoint.0), 0) is on the x-axis")

case (0, _):

println("(0, \(somePoint.1)) is on the y-axis")

case (-2...2, -2...2):

println("(\(somePoint.0), \(somePoint.1)) is inside the box")

default:

println("(\(somePoint.0), \(somePoint.1)) is outside of the box")

}

// prints "(1, 1) is inside the box"

在case匹配的同时，可以将switch语句中的值绑定给一个特定的常量或者变量，以便在case的语句中使用。比如

[cpp] view
plaincopy





let anotherPoint = (2, 0)

switch anotherPoint {

case (let x, 0):

println("on the x-axis with an x value of \(x)")

case (0, let y):

println("on the y-axis with a y value of \(y)")

case let (x, y):

println("somewhere else at (\(x), \(y))")

}

// prints "on the x-axis with an x value of 2"

思考：如果没有defalut:会是什么样的？有环境验证一下。

验证后有几个有意思的地方：

一，对成员具有完整性检测：如：

[cpp] view
plaincopy





enum CompassPoint :Int {

case North

case South

case East

case West

}

var directionToHead = CompassPoint.West //预先指定为West

switch directionToHead {

case .North:

println("Lots of planets have a north")

case .South:

println("Watch out for penguins")

case .East:

println("Where the sun rises")

}

这里编译期会报错，提示未找到West。

可以通过以下两种方式进行修正：

[cpp] view
plaincopy





switch directionToHead {

case .North:

println("Lots of planets have a north")

case .South:

println("Watch out for penguins")

case .East:

println("Where the sun rises")

case .West:

println("Where the west");

}

[cpp] view
plaincopy





switch directionToHead {

case .North:

println("Lots of planets have a north")

case .South:

println("Watch out for penguins")

case .East:

println("Where the sun rises")

default:

println("Where the west");

}

别外还遇到一个告警问题：

如果switch的条件声明在同一个函数内，这时会提示Switch condition evaluates to a constant

要去除这个，只需要将声明的变量放在函数外就可以

var directionToHead : CompassPoint = .West

6.循环

for - in,for, while, do-while

在for-in 中使用k/v数组，

“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

}

}

}

largest”

这个让我感慨的就是每个变量都没有进行显式的声明类型。这也许就是swift所宣存的精确，高效的一个原因之一吧。

另外for 也像pascal一样支持“..”范围操作符。可能熟释DELPHI的朋友一定很深的印象。像这样的for

procedure foroperation

var

char c;

begin

for (c in ['a'..'z']) do

begin

//do something.

end;

end;

官网的例子：

“var firstForLoop = 0

for i in 0..3 {

firstForLoop += i

}

firstForLoop

var secondForLoop = 0

for var i = 0; i < 3; ++i {

secondForLoop += 1

}

secondForLoop”

两个for 过程是一样的，即i都是从0-3. 其实delphi 中还有low() to high()操作的，这个swift应该没有吧，如果有的话，我想apple的工程师都应经历了pascal的时代。

值得注意的是：swift中不仅有".." 也有"..."，分别代表什么呢。两个点，相当于小于如0..3 等价于 0<=i<3 而使用...则相等于 "<=" 如 0..3 等价于 0<=i<=3

while / do while

“var n = 2

while n < 100 {

n = n * 2

}

n

var m = 2

do {

m = m * 2

} while m < 100

m”

7.函数的语法

“func greet(name: String, day: String) -> String {

return "Hello \(name), today is \(day)."

}

greet("Bob", "Tuesday")”

通过这个例子，可以看到使用func关键词进行声明，其次 输入参数 使用“变量：类型”的型式，这还真像pascal，你还别说。最有特色的就是这个返回值，参过->符号指定返回的类型。这个也许是C++的地址函问符的一个使用方式吧，每个函数返回的其实都是一个地址块。另外函数如果有多个返回（即传出参数）怎么处理呢？如C/C++ 的使用“**”指针的指针 如 func(char ** outstring) 但在 swift中则：

“func getGasPrices() -> (Double, Double, Double) {

return (3.59, 3.69, 3.79)

}

getGasPrices()”

其次swift中的函数参数为数组时的写法，也很特别：

“func sumOf(numbers: Int...) -> Int {

var sum = 0

for number in numbers {

sum += number

}

return sum

}

sumOf()

sumOf(42, 597, 12)”

内连函数的支持

很多高级语方中都有内连函数，内连函数的使用也是很常见的一种，不仅使得代码执行更加高效，同时也减少了内存碎片。

一起看一下swift的内连函数的写法：

“func returnFifteen() -> Int {

var y = 10

func add() {

y += 5

}

add()

return y

}

returnFifteen()”

还有一个特另的：就是swift还提供了在函数中返回函数来看一下，写法也比较另类：

“func makeIncrementer() -> (Int -> Int) {

func addOne(number: Int) -> Int {

return 1 + number

}

return addOne

}

var increment = makeIncrementer() //increment 可理解为addOne的函数指针

increment(7)”

把这段代码解读一下，首先红色部分是一个函数，入参为整型，返回一个整型的值。 再来看最外层的函数makeIncrementer 没有入参，有返回值，而返回值是使用"()"括起来。

int ->int 这个表示返回的为一个函数地址，该函数有一个int型的输入参数，同时还有一个int 型的返回值参数。这与c/c++的函数指很是有差别。

在swift中，函数也可以作为参数进行传递：（见红色部分）

“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, lessThanTen)”

最后还有三个没有理解透，等有ios 8 的环境再验证，好像是匿名函数的使用。

“numbers.map({

(number: Int) -> Int in

let result = 3 * number

return result

})”

“numbers.map({ number in 3 * number })”

“sort([1, 5, 3, 12, 2]) { $0 > $1 }”

写得有点粗，英文不怎么样，边看，边理解，边记录的。

好吧，今天就先学到到这，希望这个对你有所帮助。别还不知道是否为大小写敏感的，若是的话，还真有点蛋痛，看他的官方例子，某些关键词一会大写开头，一会小写开头。。。。。。。下一个学习，将是swift的对象和类（即面向对象编程）