2.Swift快速浏览

时间:2022-03-01 10:48:11

传统认为,在一个新的语言的第一个程序要在屏幕上显示“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查看