swift-tour-1.swift

print("HelloWorld!") // "HelloWorld!"

/*
    データ型
*/
// 変数
var myVariable = 42
myVariable = 50
print(myVariable) // 50

// 定数（代入は１度のみ）
let myConstant = 42
print(myConstant) // 42

// 変数の型は明示する必要はなし。値を代入した時点で、コンパイラが型を知る。
// 上記の例では、myVariableはinteger型であると推論される。
// 変数宣言時に型を指定するには以下のとおり。
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

// ex
let explicitFloat: Float = 4

// 変数は決して暗黙的に型変換されない。もし変換したいなら、明示的に欲しい型のインスタンスを作る。
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
print(widthLabel) // The width is 94

// ex
// let widthLabelNoConvert = label + width -> error

// 文字列の中に変数を組み込むには、以下の方法でもOK
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

// ex
let englishTest = 5.0
let mathTest = 3.2
let myName = "chuck"
print("Hello, I'm \(myName). My score is \(englishTest + mathTest).")
// Hello, I'm chuck. My score is 8.2.

// 配列とディクショナリは、[]で作成する。添字で要素を取得できる。最後の要素の後にコンマを入れてOK
var shoppingList = ["fish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
    "Malcolm": "Captain",
    "Keylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

// 空配列、空ディクショナリを作成するにはイニシャライザシンタックスを使う。
let emptyArray = [String]()
let emptyDictionaly = [String: Float]()

// もし型が推論可能ならば、空配列と空ディクショナリは以下のようにも作成可能。
let ShoppingList = []
let Occupations = [:]



/*
    制御文
*/
// 条件文にはifかswitchを使う。ループにはfor-in, for, while, repeat-whileを使う。
// 条件文やループ分のカッコは任意。式を{}で囲うのは必須。
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore) // 11

// if文の条件式は必ずBoolean式でないといけない。if code {...}みたいなのは不可。数値がBoolになったりはしない。

// ifの条件式の中でlet代入が可能。varだとerrorではないけど、warningが出る。
// この場合の値はオプショナルの値となる。オプショナルの値とは、値かnilが入る。
var optionalString: String? = "Hello"
print(optionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Heloo!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}
print(greeting)

// ex: optionalをnilとして使ってみる。
var optionalThing: String? = nil
if let thing = optionalThing {
    print("optionalThing is not nil") // 表示されない。＝条件式はfalse。
}
// もちろん、条件式の中で代入した値は、条件文で使用可能。

// オプショナル値を利用するもう１つの方法は、??を使ってデフォルト値を与えること。
// もし、オプショナル値が空なら、デフォルト値が使われる。
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"

// switch文はどんなデータ型でも扱うことができ、色々な比較が可能。
// break文のようなものがなくとも、それぞれの処理が次の処理に流れることはない。
let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}

// ex: defaultを消すと…？
// errorになる。

// ディクショナリで要素をイテレートするには、for-in文を使う。その際、２つの値を渡すことでキーと値が取得できる。
let interstingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interstingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest) // 25

// 条件が変わるまでコードをリピートするにはwhileを使う。
// repeat分は条件を末尾に書く。最低限１回は処理が実行される。いわゆるdo-while文か。
var n = 2
while n < 100 {
    n = n * 2
}
print(n) // 128

var m = 2
repeat {
    m = m * 2
} while m < 100
print(m) // 128

// ..< を使えばindexの範囲を作成できる。
var total = 0
for i in 0..<4 {
    total += i
}
print(total) // 6

// 0..<4 : 4を含まない。
// 0...4 : 4を含む。


/*
    関数とクロージャ
*/
// 関数の定義にはfuncを使う。
// カッコ内に引数をとり、関数名を書くことで関数を実行できる。
// func 関数名(引数) -> 返り値の型 {...}
func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", day: "Tuesday")

// タプルを使って、まぜこぜの値を作れる。例えば複数の値を返す関数を作る。
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores {
        if score > max {
            max = score
        } else if score > max {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])
// タブルの要素は名前か数値で参照可能。
print(statistics.sum)// 120
print(statistics.2)  // 120

// 関数の引数には、複数の値を渡して、配列にまとめることも可能。
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)

// ex: 引数の平均値を算出する関数。
func getAvg(numbers: Int...) -> Float {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return Float(sum / numbers.count)
}
print(getAvg(10, 20, 30, 40)) // 25.0

// 関数はネスト可能。内部の関数は外部の関数の変数にアクセス可能。
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

// 関数は第一級の型。関数は関数を返り値として設定できる。
func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

// 引数に関数をとることも可能。
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 < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, condition: lessThanTen)

// 関数はクロージャ。実行時ではなく定義時のスコープをもとに、変数や関数へのアクセス権が決まる。
// map({}) 内で、配列を展開して、無名関数の型 (number: Int) -> Int の第一引数に値を渡し、in 以降がnumberとうローカル変数に3を掛けてInt型の値を返している(訳：http://qiita.com/kiyotaman/items/dab98d5a0466d628a14a)
print(numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})) // [60, 57, 21, 36]

// ex: 偶数には０を返すクロージャを作成する。
print(numbers.map({
    (number: Int) -> Int in
    if number % 2 == 0 {
        return 0
    } else {
        return number
    }
})) // [0, 19, 7, 0]

// クロージャの作成には、複数の方法がある。クロージャの型が決まっているとき、引数か返り値か、あるいは両方の型は省略できる。例：コールバック、デリゲート
// 以下のような書き方も可能。
let mappedNumbers = numbers.map({ number in 3 * number})
print(mappedNumbers) // [60, 57, 21, 36]

// 数値でパラメータを参照することも可能。
// また、クロージャのみが関数の引数であるとき、()すら省略可能。
let sortedNumbers = numbers.sort { $0 > $1 }
print(sortedNumbers) // [20, 19, 12, 7]