传统认为，在一个新的语言的第一个程序要在屏幕上显示“Hello world！”。在Swift，可以用一行代码来完成：
println("Hello, world!")
如果你已经在C或Objective-C中编写过代码，这个语法看起来对你来说应该很熟悉 - 在Swift中，这行代码就是一个完整的程序。你并不需要为输入/输出或字符串处理函数导入一个单独的库。写在全局范围内的代码作为切入点程序，所以你并不需要一个main函数。你也不必在每个语句结尾写分号。
这次浏览给你足够的信息来开始通过Swift编写代码来向您展示如何完成各种编程任务。如果你不明白的地方，在本书的其余部分都会详细的解释和介绍，请不要担心。
注：最好的经验，打开本章，Xcode的Playgrounds。Playgrounds允许你编辑代码列表，并立即看到结果。
简单的值
使用let来做一个常量，var来做一个变量。常量值并不需要在编译时已知，但你必须给他确切地分配一次值。这意味着你能使用常量来命名一个值，确定一次，多个地方使用。
var myVariable =
myVariable =
let myConstant =
一个常量或变量必须具有相同的类型作为你要分配给它的值。但是，你并不总是有明确的写入类型。你提供一个值，当你创建一个常量或变量让编译器推断出它的类型。在上面的例子中，编译器推断myVariable的是整数，因为它的初始值是一个整数。
如果初始值不提供足够的信息（或者如果不存在初始值），写入变量后可指定类型，由冒号分开后写它的指定类型。
let implicitInteger =
let implicitDouble = 70.0
let explicitDouble: Double =
值永远不会隐式转换为另一种类型。如果需要的值转换为不同的类型，明确地制造一个该类型的实例。
let label = "The width is "
let width =
let widthLabel = label + String(width)
像Java中直接label+width这种方式是不能用在Swift中的
还有一个更简单的方法，包括在字符串值：写在括号中的数值，并写在括号前添加一个反斜线（\）。例如：
let apples =
let oranges =
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
创建数组和字段使用使用方括号（[]），和通过写在括号内的索引或键访问元素。
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[] = "bottle of water" var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
要创建一个空数组或字典，使用初始化的语法如下。
let emptyArray = [String]()
let emptyDictionary = [String: Float]()
如果类型信息可以推断，你可以写一个空数组[]和一个空字典为[：] - 例如，当您为变量设定一个新值或参数传递给一个函数。
shoppingList = []
occupations = [:]
这种数组和字典只能使用静态复制方式shoppingList["ss",0]，因为他们没有指定类型
控制流
使用if和switch来写条件语句，使用for-in，for，while，do-while做循环。周围的条件或循环变量括号是可选的。围绕本体括号是必需的。
let individualScores = [, , , , ]
var teamScore =
for score in individualScores {
if score > {
teamScore +=
} else {
teamScore +=
}
}
println(teamScore)
在if语句，条件必须是布尔表达式，这意味着，这样的代码，if score{...}是一个错误，它没有隐式布尔条件。
你可以使用if和let一起工作来判断可能丢失的值。这些值被表示为可选。一个可选值包含一个值或包含无（nil）。在值的类型之后写一个问号（？），以标记这个值为可选。
var optionalString: String? = "Hello"
println(optionalString == nil) var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}
如果可选的值是nil，条件为false的，括号中的代码被跳过。否则，可选的值被解开并分配到常量let后面，这使得解包值可用于代码块内。
switch支持任何类型的数据和各种比较的操作，他们并不局限于整数。
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."
}
这里不能删掉default，不然编辑器会报错
注意let在这里只能一个模式分配一个值，也可以匹配一个模式的一部分
在执行完上面那段代码后，只要匹配到一个情况，switch就不会继续往下执行，所以这里不需要用到其他语言中的break语法，来跳出switch。当然在循环中，你还是可以使用break语法
你可以使用for-in来迭代每一个字典中的键值对，字典是一个无序的集合所以他们的键和值以任意顺序迭代。
let interestingNumbers = [
"Prime": [, , , , , ],
"Fibonacci": [, , , , , ],
"Square": [, , , , ],
]
var largest =
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
println(largest)
使用while重复一个代码块直到条件改变。一个循环的条件能在结束中替换，从而确保环运行至少一次。
var n =
while n < {
n = n *
}
println(n) var m =
do {
m = m *
} while m <
println(m)
你能使用索引来保持一个循环，通过使用..<来使用一个索引范围，或者使用显示的初始化，条件，自增。下面两个循环做的是同样的事情
var firstForLoop =
for i in ..< {
firstForLoop += i
}
println(firstForLoop) var secondForLoop =
for var i = ; i < ; ++i {
secondForLoop += i
}
println(secondForLoop)
使用..<做出一个范围，它忽略了上限值，你也可以使用...包含一个范围，包括了上限值。
函数和闭包
使用func来声明函数。通过名字和参数列表来调用函数。用 ->来获取函数的返回类型。
func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")
使用一个数组做一个复合值，例如，从一个函数返回多个值。一个元组的元素可以按名称或编号引用。
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
var min = scores[]
var max = scores[]
var sum =
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let statistics = calculateStatistics([, , , , ])
println(statistics.sum)
println(statistics.)
函数还可以带可变数量的参数，收集他们到一个数组。
func sumOf(numbers: Int...) -> Int {
var sum =
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(, , )
函数可以嵌套。嵌套函数可以访问到外部函数中声明的变量。您可以使用嵌套函数来组织很长或很复杂代码的函数。
func returnFifteen() -> Int {
var y =
func add() {
y +=
}
add()
return y
}
returnFifteen()
函数也是一种的类型。这意味着一个函数可以返回另一个函数作为其值。
func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int {
return + number
}
return addOne
}
var increment = makeIncrementer()
increment()
函数可以获取另一个函数作为它参数中的一员。（这个有点绕，就是函数中的某个参数是一个函数）
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 <
}
var numbers = [, , , ]
hasAnyMatches(numbers, lessThanTen)
函数实际上有一种特殊情况叫闭包：代码块可以在以后调用。在一个封闭的代码中可以访问像变量和函数这样的东西，并且是在创建封闭的范围内可用，即使在闭包在不同的范围内被执行时，您已经看见过这样的例子就是嵌套函数不同的范围。您可以通过使用括号（{}）并且不用写名字来封闭。在使用单独的参数和返回类型中使用。
numbers.map({
(number: Int) -> Int in
let result = * number
return result
})
你有几种更简洁的闭包写法可选。当一个封闭的类型是已知的，诸如委托回调，可以省略它的参数类型，它的返回类型，或两者的类型。单封语句隐式返回他们唯一的语句的值。
let mappedNumbers = numbers.map({ number in * number })
println(mappedNumbers)
你可以按编号，而不是按名称，这种方法是指参数是在很短的闭包内特别有用。
let sortedNumbers = sorted(numbers) { $ > $ }
println(sortedNumbers)
对象和类
使用class后面跟一个类的名字来创建一个类。属性和函数都写在类里面，这点和其他语言差不多
class Shape {
var numberOfSides =
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
通过在类名后接一对小括号来创建一个类的实例。使用点语法来访问属性和实例的方法。这里和其他语言不一样，它不需要new
var shape = Shape()
shape.numberOfSides =
var shapeDescription = shape.simpleDescription()
这个版本的Shape类缺少一些重要的东西：类的初始化。可使用init创建，类似Java，C++构造函数。
class NamedShape {
var numberOfSides: Int =
var name: String
init(name: String) {
self.name = name
}
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
var NamedShape=NamedShape(name:"myname")
注意self用于区分是类里面的属性还是init中的参数。如果你写了init函数，在实例化对象时，需要传入参数名加冒号，在接上参数值。这是swift的语法，和Java，C直接构造函数传值不太一样。
你还可以使用deinit代码块来处理，对象释放时的操作。如果你要写继承，类名后接冒号，在接上父类名，不会使用例如extends这样的关键字
如果你要覆盖子类的方法，请使用override关键字
class Square: NamedShape {
var sideLength: Double
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides =
}
func area() -> Double {
return sideLength * sideLength
}
override func simpleDescription() -> String {
return "A square with sides of length \(sideLength)."
}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()
属性除了能存储简单的值，它还可以有一个getter和一个setter。
class EquilateralTriangle: NamedShape {
var sideLength: Double = 0.0
init(sideLength: Double, name: String) {
self.sideLength = sideLength
super.init(name: name)
numberOfSides =
}
var perimeter: Double {
get {
return 3.0 * sideLength
}
set {
sideLength = newValue / 3.0
}
}
override func simpleDescription() -> String {
return "An equilateral triangle with sides of length \(sideLength)."
}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
println(triangle.perimeter)
triangle.perimeter = 9.9
println(triangle.sideLength)
对于perimeter有一个设置器，新的值可以隐式的使用newValue，当然你也可以显示的使用自定义的字段比如
set (arg) {
sideLength = arg / 3.0
}
请注意，初始化的是，EquilateralTriangle类有三个不同的步骤：
1.设置该子类声明属性的值。
2.调用父类的初始化。
3.通过改变父类中定义的属性值。你也可以使用getter，setter方法做任何额外的设置工作。
如果你不需要计算属性，但你仍然需要提供代码在执行之前或设置之后做一些处理的话，你可以使用willSet和didSet。例如，下面的类确保其三角形的边长总是和正方形的边长相同。
class TriangleAndSquare {
var triangle: EquilateralTriangle {
willSet {
square.sideLength = newValue.sideLength
}
}
var square: Square {
willSet {
triangle.sideLength = newValue.sideLength
}
}
init(size: Double, name: String) {
square = Square(sideLength: size, name: name)
triangle = EquilateralTriangle(sideLength: size, name: name)
}
}
var triangleAndSquare = TriangleAndSquare(size: , name: "another test shape")
println(triangleAndSquare.square.sideLength)
println(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: , name: "larger square")
println(triangleAndSquare.triangle.sideLength)
在类中的方法和外部函数有个重要区别。函数中的参数名称仅在函数中使用（局部参数名），但方法中的参数名字，能在你调用方法时，需要使用外部参数名。默认情况下类中方法的第一个参数名默认为局部参数，所以调用时，不需要显示输入参数名，
但第二和后续的参数名，要显示输入，并且同时作为局部参数名称和外部参数名称，当然你也可以分别指定第二个参数或之后的参数哪个为局部名，哪个为外部名称，中间用空格区分，空格前面为外部名，空格后面为内部名称
class Counter {
var count: Int =
func incrementBy(amount: Int, numberOfTimes times: Int) {
count += amount * times
}
}
var counter = Counter()
counter.incrementBy(, numberOfTimes: )
当你用可选值工作时，你可以在操作符之前使用？如果在？前的值为nil，那么在？后之后的一切都被忽略，并且整个表达式的值为nil。否则可选值被解包，在？后的一切将被展开。在这两种情况下，整个表达式的值都是可选值
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength
枚举和结构体
用enum来创建一个枚举。如类和所有其他命名类型，枚举可以有与它们相关联的方法。
enum Rank: Int {
case Ace =
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
case Jack, Queen, King
func simpleDescription() -> String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
case .King:
return "king"
default:
return String(self.rawValue)
}
}
}
let ace = Rank.Ace
let aceRawValue = ace.rawValue
在上面的例子中，枚举的原始值类型为Int，所以你只需要指定的第一个原始值。原始值的其余部分会按顺序分配。您还可以使用字符串或浮点数作为原始类型枚举。使用rawValue属性来访问枚举成员的原始值。
使用init？（rawValue:)初始化原始值的一个实例。Rank(rawValue: 3)表达式是一个可选值
if let convertedRank = Rank(rawValue: ) {
let threeDescription = convertedRank.simpleDescription()
}
枚举的成员都有实际值，写他们的原始值的方法不只一种。事实上，有些情况下，原始值是没有意义的，你不必非要提供它。
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func simpleDescription() -> String {
switch self {
case .Spades:
return "spades"
case .Hearts:
return "hearts"
case .Diamonds:
return "diamonds"
case .Clubs:
return "clubs"
}
}
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()
请注意，枚举Hearts成员上面提到的两种方法：当分配一个值到hearts常量时，枚举成员Suit.Hearts被提到了它的全名，因为这个常量没有指定明确的类型。在switch内部，枚举成员是指由缩写形式.Hearts因为self已经知道是suit。您可以使用缩写形式在任何已经的类型上。
使用struct来创建结构体。结构体和类相似支持许多相同的行为，包括方法和初始化。其中结构和类之间最重要的区别在于，当他们在你的代码各地的传递时，结构始终按副本（被复制）传递，而类按引用传递。
struct Card {
var rank: Rank
var suit: Suit
func simpleDescription() -> String {
return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
}
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()
一个枚举成员的实例可以与值的实例相关联。同一枚举成员的实例可以有不同的值与它们相关联。当你创建实例时，分配一个值。分配的值和原始值是不同的：一个枚举成员的原始值对于它的所有实例是相同的，并且在定义枚举时，提供了原始值。
例如，考虑从服务器请求关于日出和日落时间的情况。该服务器做出响应，正常的或错误的信息。
enum ServerResponse {
case Result(String, String)
case Error(String)
}
let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")
switch success {
case let .Result(sunrise, sunset):
let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
let serverResponse = "Failure... \(error)"
}
协议和扩展
使用protocol来声明一个协议
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
类，枚举，结构体都可以采用协议，协议可以理解为java的接口。例如上面的simpleDescription{get}表示只读
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int =
func adjust() {
simpleDescription += " Now 100% adjusted."
}
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
注意在SimpleStructure的声明使用了关键字mutating的标记修改结构体的方法。SimpleClass是一个类，它并不需要任何方法标记为mutating，因为在一个类中的方法可以随时修改他自己。但结构体不一样，它默认是不允许内部方法修改自己属性的，
所以加上mutating就表示，结构体也能修改他自己了
使用extension为现有的类型添加功能，如新方法并计算属性。您可以使用扩展添加协议一致性，用来在别处声明类型，甚至，你从库或框架中导入一个类型。
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self +=
}
}
println(.simpleDescription)
你能为协议命名其他的名字，例如创建一个有不同类型对象的集合都符合单一的协议，但你使用值类型的协议工作时，协议外部定义的方法不可用
let protocolValue: ExampleProtocol = a
println(protocolValue.simpleDescription)
// println(protocolValue.anotherProperty) // Uncomment to see the error
即使变量protocolValue具有运行时类型SimpleClass，编译器也会把他处理成ExampleProtocol类型，这意味着你不能访问实现了协议后的类，它里面的属性和方法。
泛型
在尖括号里面写一个名字，来生成一个泛型函数或类型
func repeat<Item>(item: Item, times: Int) -> [Item] {
var result = [Item]()
for i in ..<times {
result.append(item)
}
return result
}
repeat("knock", )
你能使用函数或方法的泛型格式，用于类，枚举和结构体
// Reimplement the Swift standard library's optional type
enum OptionalValue<T> {
case None
case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some()
类型名称后使用where来指定一个列表需求，例如需求这个类型实现一个协议，需求两个类型一样，或者需求类有一个指定的子类
func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool {
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
return true
}
}
}
return false
}
anyCommonElements([, , ], [])
在简单情况下，你能省略where，并且简单的在冒号后（:）写协议或类<T: Equatable>和 <T where T: Equatable>是一样的
对于Generator不理解的朋友可以去https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_SequenceType_Protocol/index.html#//apple_ref/swift/tdef/s:PSs12SequenceType9Generator查看