- add more examples; update examples

- now runs in the Xcode 6 b6 playground
- add MARK sections
This commit is contained in:
C. Bess 2014-08-23 22:48:10 -05:00
parent 83b63aab54
commit 328a4f1bab

View File

@ -2,6 +2,7 @@
language: swift language: swift
contributors: contributors:
- ["Grant Timmerman", "http://github.com/grant"] - ["Grant Timmerman", "http://github.com/grant"]
- ["Christopher Bess", "http://github.com/cbess"]
filename: learnswift.swift filename: learnswift.swift
--- ---
@ -11,21 +12,34 @@ See also Apple's [getting started guide](https://developer.apple.com/library/pre
```js ```js
// //
// Basics // MARK: Basics
// //
println("Hello, world") println("Hello, world")
var myVariable = 42 var myVariable = 42
//let fƒ∆ = "value" // unicode in variable names
let myConstant = 3.1415926 let myConstant = 3.1415926
let convenience = "keyword" // contextual variable name
let weak = "keyword"; let override = "another keyword" // statements can be separated by a semi-colon
let `class` = "keyword" // backticks allow keywords to be used as variable names
let explicitDouble: Double = 70 let explicitDouble: Double = 70
let intValue = 0007 // 7
let largeIntValue = 77_000 // 77000
let label = "some text " + String(myVariable) // Casting let label = "some text " + String(myVariable) // Casting
let piText = "Pi = \(myConstant)" // String interpolation let piText = "Pi = \(myConstant)" // String interpolation
var optionalString: String? = "optional" // Can be nil var optionalString: String? = "optional" // Can be nil
optionalString = nil optionalString = nil
/*
Comment here
/*
Nested comment here
*/
*/
// //
// Arrays and Dictionaries // MARK: Collections
// //
// Array // Array
@ -35,65 +49,66 @@ let emptyArray = [String]()
// Dictionary // Dictionary
var occupations = [ var occupations = [
"Malcolm": "Captain", "Malcolm": "Captain",
"kaylee": "Mechanic" "kaylee": "Mechanic"
] ]
occupations["Jayne"] = "Public Relations" occupations["Jayne"] = "Public Relations"
let emptyDictionary = Dictionary<String, Float>() let emptyDictionary = Dictionary<String, Float>()
// //
// Control Flow // MARK: Control Flow
// //
// for loop (array) // for loop (array)
let myArray = [1, 1, 2, 3, 5] let myArray = [1, 1, 2, 3, 5]
for value in myArray { for value in myArray {
if value == 1 { if value == 1 {
println("One!") println("One!")
} else { } else {
println("Not one!") println("Not one!")
} }
} }
// for loop (dictionary) // for loop (dictionary)
var dict = ["one": 1, "two": 2]
for (key, value) in dict { for (key, value) in dict {
println("\(key): \(value)") println("\(key): \(value)")
} }
// for loop (range) // for loop (range)
for i in -1...1 { // [-1, 0, 1] for i in -1...1 { // [-1, 0, 1]
println(i) println(i)
} }
// use ..< to exclude the last number // use ..< to exclude the last number
// while loop // while loop
var i = 1 var i = 1
while i < 1000 { while i < 1000 {
i *= 2 i *= 2
} }
// do-while loop // do-while loop
do { do {
println("hello") println("hello")
} while 1 == 2 } while 1 == 2
// Switch // Switch
let vegetable = "red pepper" let vegetable = "red pepper"
switch vegetable { switch vegetable {
case "celery": case "celery":
let vegetableComment = "Add some raisins and make ants on a log." let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress": case "cucumber", "watercress":
let vegetableComment = "That would make a good tea sandwich." let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"): case let x where x.hasSuffix("pepper"):
let vegetableComment = "Is it a spicy \(x)?" let vegetableComment = "Is it a spicy \(x)?"
default: // required (in order to cover all possible input) default: // required (in order to cover all possible input)
let vegetableComment = "Everything tastes good in soup." let vegetableComment = "Everything tastes good in soup."
} }
// //
// Functions // MARK: Functions
// //
// Functions are a first-class type, meaning they can be nested // Functions are a first-class type, meaning they can be nested
@ -101,31 +116,31 @@ default: // required (in order to cover all possible input)
// Function // Function
func greet(name: String, day: String) -> String { func greet(name: String, day: String) -> String {
return "Hello \(name), today is \(day)." return "Hello \(name), today is \(day)."
} }
greet("Bob", "Tuesday") greet("Bob", "Tuesday")
// Function that returns multiple items in a tuple // Function that returns multiple items in a tuple
func getGasPrices() -> (Double, Double, Double) { func getGasPrices() -> (Double, Double, Double) {
return (3.59, 3.69, 3.79) return (3.59, 3.69, 3.79)
} }
// Args // Variadic Args
func setup(numbers: Int...) {} func setup(numbers: Int...) {}
// Passing and returning functions // Passing and returning functions
func makeIncrementer() -> (Int -> Int) { func makeIncrementer() -> (Int -> Int) {
func addOne(number: Int) -> Int { func addOne(number: Int) -> Int {
return 1 + number return 1 + number
} }
return addOne return addOne
} }
var increment = makeIncrementer() var increment = makeIncrementer()
increment(7) increment(7)
// //
// Closures // MARK: Closures
// //
var numbers = [1, 2, 6] var numbers = [1, 2, 6]
@ -135,93 +150,142 @@ var numbers = [1, 2, 6]
// `->` separates the arguments and return type // `->` separates the arguments and return type
// `in` separates the closure header from the closure body // `in` separates the closure header from the closure body
numbers.map({ numbers.map({
(number: Int) -> Int in (number: Int) -> Int in
let result = 3 * number let result = 3 * number
return result return result
}) })
// When the type is known, like above, we can do this // When the type is known, like above, we can do this
numbers = numbers.map({ number in 3 * number }) numbers = numbers.map({ number in 3 * number })
//Or even this // Or even this
//numbers = numbers.map({ $0 * 3 }) //numbers = numbers.map({ $0 * 3 })
print(numbers) // [3, 6, 18] print(numbers) // [3, 6, 18]
// Trailing closure
numbers = sorted(numbers) { $0 > $1 }
print(numbers) // [18, 6, 3]
// Super shorthand, since the < operator infers the types
numbers = sorted(numbers, < )
print(numbers) // [3, 6, 18]
// //
// Classes // MARK: Classes
// //
class Shape {
func getArea() -> Int {
return 0;
}
}
// All methods and properties of a class are public. // All methods and properties of a class are public.
// If you just need to store data in a // If you just need to store data in a
// structured object, you should use a `struct` // structured object, you should use a `struct`
// A simple class `Square` extends `Shape` // A simple class `Square` extends `Shape`
class Rect: Shape { class Rect: Shape {
var sideLength: Int = 1 var sideLength: Int = 1
// Custom getter and setter property // Custom getter and setter property
var perimeter: Int { var perimeter: Int {
get { get {
return 4 * sideLength return 4 * sideLength
}
set {
sideLength = newValue / 4
}
} }
set {
sideLength = newValue / 4 // If you don't need a custom getter and setter,
// but still want to run code before and after getting or setting
// a property, you can use `willSet` and `didSet`
var identifier: String = "defaultID" {
willSet(someIdentifier) {
print(someIdentifier)
}
} }
}
init(sideLength: Int) {
init(sideLength: Int) { super.init()
super.init() self.sideLength = sideLength
self.sideLength = sideLength }
}
func shrink() {
func shrink() { if sideLength > 0 {
if sideLength > 0 { --sideLength
--sideLength }
}
override func getArea() -> Int {
return sideLength * sideLength
} }
}
override func getArea() -> Int {
return sideLength * sideLength
}
} }
var mySquare = new Square(sideLength: 5)
class Square: Rect {
convenience init() {
self.init(sideLength: 5)
}
}
var mySquare = Square()
print(mySquare.getArea()) // 25 print(mySquare.getArea()) // 25
mySquare.shrink() mySquare.shrink()
print(mySquare.sideLength) // 4 print(mySquare.sideLength) // 4
// If you don't need a custom getter and setter,
// but still want to run code before and after getting or setting
// a property, you can use `willSet` and `didSet`
// //
// Enums // MARK: Enums
// //
// Enums can optionally be of a specific type or on their own. // Enums can optionally be of a specific type or on their own.
// They can contain methods like classes. // They can contain methods like classes.
enum Suit { enum Suit {
case Spades, Hearts, Diamonds, Clubs case Spades, Hearts, Diamonds, Clubs
func getIcon() -> String { func getIcon() -> String {
switch self { switch self {
case .Spades: return "♤" case .Spades: return "♤"
case .Hearts: return "♡" case .Hearts: return "♡"
case .Diamonds: return "♢" case .Diamonds: return "♢"
case .Clubs: return "♧" case .Clubs: return "♧"
}
} }
}
} }
// //
// Other // MARK: Other
// //
// `protocol`: Similar to Java interfaces. // `protocol`: Similar to Java interfaces.
// `extension`s: Add extra functionality to an already created type protocol ShapeGenerator {
func buildShape() -> Shape
}
// `extension`s: Add extra functionality to an already existing type
extension Square: Printable {
var description: String {
return "Area: \(self.getArea()) - ID: \(self.identifier)"
}
}
println("Square: \(mySquare)")
// Generics: Similar to Java. Use the `where` keyword to specify the // Generics: Similar to Java. Use the `where` keyword to specify the
// requirements of the generics. // requirements of the generics.
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
``` ```