// Arrayvar shoppingList = ["catfish", "water", "lemons"]shoppingList[1] = "bottle of water"               // updateshoppingList.count                                // size of array (3)shoppingList.append("eggs")shoppingList += "Milk"// Array slicingvar fibList = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 5]fibList[4..6] // [3, 5]. Note: the end range value is exclusivefibList[0..fibList.endIndex] // all except last item// Subscripting returns the Slice type, instead of the Array type.// You may need to cast it to Array in order to satisfy the type checkerArray(fibList[0..4])// Variants of creating an array. All three are equivalent.var emptyArray1 = String[]()var emptyArray2: String[] = []var emptyArray3 = String[]()var emptyArray4 = [String]()

// Dictionaryvar occupations = ["Malcolm": "Captain","kaylee": "Mechanic"]occupations["Jayne"] = "Public Relations"var emptyDictionary = Dictionary<String, Float>()

Functions are special case closures ({})// Closure example.// `->` separates the arguments and return type// `in` separates the closure header from the closure bodyvar numbers = [1, 2, 3, 4, 5]numbers.map({(number: Int) -> Int inlet result = 3 * numberreturn result})// When the type is known, like above, we can do thisnumbers = [1, 2, 6]numbers = numbers.map({ number in 3 * number })println(numbers) // [3, 6, 18]// When a closure is the last argument, you can place it after the )// When a closure is the only argument, you can omit the () entirely// You can also refer to closure arguments by position ($0, $1, ...) rather than namenumbers = [2, 5, 1]numbers.map { 3 * $0 } // [6, 15, 3]

All methods and properties of a class are public. If you just need to store data in a structured object, you should use a struct“`js // A parent class of Square class Shape { init() { }func getArea() -> Int {return 0;} }// A simple class Square extends Shape class Square: Shape { var sideLength: Int// Custom getter and setter propertyvar perimeter: Int {get {return 4 * sideLength}set {sideLength = newValue / 4}}init(sideLength: Int) {self.sideLength = sideLengthsuper.init()}func shrink() {if sideLength > 0 {--sideLength}}override func getArea() -> Int {return sideLength * sideLength} } var mySquare = Square(sideLength: 5) print(mySquare.getArea()) // 25 mySquare.shrink() print(mySquare.sideLength) // 4// Access the Square class object, // equivalent to [Square class] in Objective-C. Square.self//example for ‘willSet’ and ‘didSet’ class StepCounter { var totalSteps: Int = 0 { willSet(newTotalSteps) { println(“About to set totalSteps to (newTotalSteps)”) } didSet { if totalSteps > oldValue { println(“Added (totalSteps – oldValue) steps to ‘totalSteps‘”) } } } } var stepCounter = StepCounter() stepCounter.totalSteps = 100 // About to set totalSteps to 100 \n Added 100 steps to ‘totalSteps’ stepCounter.totalSteps = 145 // About to set totalSteps to 145 \n Added 45 steps to ‘totalSteps’// If you don’t need a custom getter and setter, but still want to run code // before an after getting or setting a property, you can use willSet and didSet

Enums can optionally be of a specific type or on their own. They can contain methods like classes.enum Suit {case Spades, Hearts, Diamonds, Clubsfunc getIcon() -> String {switch self {case .Spades: return "?"case .Hearts: return "?"case .Diamonds: return "?"case .Clubs: return "?"}}}

protocol SomeProtocol {// protocol definition goes here}

Add extra functionality to an already created type// adds the methods first and rest to the array typeextension Array {func first () -> Any? {return self[0]}func rest () -> Array {if self.count >= 1 {return Array(self[1..self.endIndex])} else {return []}}}

// Overwrite existing types@infix func + (a: Int, b: Int) -> Int {return a - b}var x = 5 + 4 // x is 1

struct Vector2D {var x = 0.0, y = 0.0}@infix func + (left: Vector2D, right: Vector2D) -> Vector2D {return Vector2D(x: left.x + right.x, y: left.y + right.y)}

@assignment func += (inout left: Vector2D, right: Vector2D) {left = left + right}

// Generic function, which swaps two any values.func swapTwoValues<T>(inout a: T, inout b: T) {let temporaryA = aa = bb = temporaryA}

// Generic collection type called `Stack`.struct Stack<T> {var elements = T[]()mutating func push(element: T) {elements.append(element)}mutating func pop() -> T {return elements.removeLast()}}

// Generic function, which checks that the sequence contains a specified value.func containsValue<T where T: Sequence, T.GeneratorType.Element: Equatable>(sequence: T, valueToFind: T.GeneratorType.Element) -> Bool {for value in sequence {if value =http://www.mamicode.com/= valueToFind {"hljs-keyword">return true}}return false}