The Swift Programming Language-官方教程精译Swift（1）小试牛刀

1 println("hello, world")

1 let apples = 3 
2 let oranges = 5 
3 let appleSummary = "I have \(apples) apples." 
4 let fruitSummary = "I have \(apples + oranges) pieces of fruit." 

1 var shoppingList = ["catfish", "water", "tulips", "blue paint"] 
2 shoppingList[1] = "bottle of water" 
3   
4 var occupations = [ 
5     "Malcolm": "Captain", 
6     "Kaylee": "Mechanic", 
7 ] 
8 occupations["Jayne"] = "Public Relations" 

1 shoppingList = []   // 去逛街并买点东西 

1 var optionalString: String? = "Hello" 
2 optionalString == nil 
3   
4 var optionalName: String? = "John Appleseed" 
5 var greeting = "Hello!" 
6 if let name = optionalName { 
7     greeting = "Hello, \(name)" 
8 } 

 1 var n = 2 
 2 while n < 100 { 
 3     n = n * 2 
 4 } 
 5 n 
 6   
 7 var m = 2 
 8 do { 
 9     m = m * 2 
10 } while m < 100 
11 m 

 1 var firstForLoop = 0 
 2 for i in 0..3 { 
 3     firstForLoop += i 
 4 } 
 5 firstForLoop 
 6   
 7 var secondForLoop = 0 
 8 for var i = 0; i < 3; ++i { 
 9     secondForLoop += 1 
10 } 
11 secondForLoop   

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

1 class Shape { 
2     var numberOfSides = 0 
3     func simpleDescription() -> String { 
4         return "A shape with \(numberOfSides) sides." 
5     } 
6 } 

1 var shape = Shape() 
2 shape.numberOfSides = 7 
3 var shapeDescription = shape.simpleDescription() 

 1 class NamedShape { 
 2     var numberOfSides: Int = 0 
 3     var name: String 
 4   
 5     init(name: String) { 
 6         self.name = name 
 7     } 
 8   
 9     func simpleDescription() -> String { 
10         return "A shape with \(numberOfSides) sides." 
11     } 
12 } 

 1 class Square: NamedShape { 
 2     var sideLength: Double 
 3   
 4     init(sideLength: Double, name: String) { 
 5         self.sideLength = sideLength 
 6         super.init(name: name) 
 7         numberOfSides = 4 
 8     } 
 9   
10     func area() ->  Double { 
11         return sideLength * sideLength 
12     } 
13   
14     override func simpleDescription() -> String { 
15         return "A square with sides of length \(sideLength)." 
16     } 
17 } 
18 let test = Square(sideLength: 5.2, name: "my test square") 
19 test.area() 
20 test.simpleDescription() 

 1 class EquilateralTriangle: NamedShape { 
 2     var sideLength: Double = 0.0 
 3   
 4     init(sideLength: Double, name: String) { 
 5         self.sideLength = sideLength 
 6         super.init(name: name) 
 7         numberOfSides = 3 
 8     } 
 9   
10     var perimeter: Double { 
11     get { 
12         return 3.0 * sideLength 
13     } 
14     set { 
15                 sideLength = newValue / 3.0 
16     } 
17     } 
18   
19     override func simpleDescription() -> String { 
20         return "An equilateral triagle with sides of length \(sideLength)." 
21     } 
22 } 
23 var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle") 
24 triangle.perimeter 
25 triangle.perimeter = 9.9 
26 triangle.sideLength 

 1 class TriangleAndSquare { 
 2     var triangle: EquilateralTriangle { 
 3     willSet { 
 4         square.sideLength = newValue.sideLength 
 5     } 
 6     } 
 7     var square: Square { 
 8     willSet { 
 9         triangle.sideLength = newValue.sideLength 
10     } 
11     } 
12     init(size: Double, name: String) { 
13         square = Square(sideLength: size, name: name) 
14         triangle = EquilateralTriangle(sideLength: size, name: name) 
15     } 
16 } 
17 var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape") 
18 triangleAndSquare.square.sideLength 
19 triangleAndSquare.triangle.sideLength 
20 triangleAndSquare.square = Square(sideLength: 50, name: "larger square") 
21 triangleAndSquare.triangle.sideLength 

1 class Counter { 
2     var count: Int = 0 
3     func incrementBy(amount: Int, numberOfTimes times: Int) { 
4         count += amount * times 
5     } 
6 } 
7 var counter = Counter() 
8 counter.incrementBy(2, numberOfTimes: 7) 

 1 enum Rank: Int { 
 2     case Ace = 1 
 3     case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten 
 4     case Jack, Queen, King 
 5     func simpleDescription() -> String { 
 6         switch self { 
 7         case .Ace: 
 8             return "ace" 
 9         case .Jack: 
10             return "jack" 
11         case .Queen: 
12             return "queen" 
13         case .King: 
14             return "king" 
15         default: 
16             return String(self.toRaw()) 
17         } 
18     } 
19 } 
20 let ace = Rank.Ace 
21 let aceRawValue = ace.toRaw() 

1 if let convertedRank = Rank.fromRaw(3) { 
2     let threeDescription = convertedRank.simpleDescription() 
3 } 

 1 enum Suit { 
 2     case Spades, Hearts, Diamonds, Clubs 
 3     func simpleDescription() -> String { 
 4         switch self { 
 5         case .Spades: 
 6             return "spades" 
 7         case .Hearts: 
 8             return "hearts" 
 9         case .Diamonds: 
10             return "diamonds" 
11         case .Clubs: 
12             return "clubs" 
13         } 
14     } 
15   
16 } 
17 let hearts = Suit.Hearts 
18 let heartsDescription = hearts.simpleDescription() 

 1 enum ServerResponse { 
 2     case Result(String, String) 
 3     case Error(String) 
 4 } 
 5   
 6 let success = ServerResponse.Result("6:00 am", "8:09 pm") 
 7 let failure = ServerResponse.Error("Out of cheese.") 
 8   
 9 switch success { 
10 case let .Result(sunrise, sunset): 
11     let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)." 
12 case let .Error(error): 
13     let serverResponse = "Failure...  \(error)" 
14 } 

 1 class SimpleClass: ExampleProtocol { 
 2     var simpleDescription: String = "A very simple class." 
 3     var anotherProperty: Int = 69105 
 4     func adjust() { 
 5         simpleDescription += "  Now 100% adjusted." 
 6     } 
 7 } 
 8 var a = SimpleClass() 
 9 a.adjust() 
10 let aDescription = a.simpleDescription 
11   
12 struct SimpleStructure: ExampleProtocol { 
13     var simpleDescription: String = "A simple structure" 
14     mutating func adjust() { 
15         simpleDescription += " (adjusted)" 
16     } 
17 } 
18 var b = SimpleStructure() 
19 b.adjust() 
20 let bDescription = b.simpleDescription 

1 // Reimplement the Swift standard library‘s optional type 
2 enum OptionalValue<T> { 
3     case None 
4     case Some(T) 
5 } 
6 var possibleInteger: OptionalValue<Int> = .None 
7 possibleInteger = .Some(100)