Swift 型と関数　メモ

# 変数

## 型指定の変数
```swift
var firstName:String = "Akiko" 
var SecondName:String = "Maejima"
print(firstName + " " + SecondName); //printは実行結果を出力
```

## 変数の型指定
```swift
var age:Int = 25 //ageという変数はint型でのみ使えるという指定
age = "24" //int型の変数にstring型を代入しているのでエラー
```

## 型推論 
型の指定をしなくても代入した値に応じて値の型を推論してくれる機能。
Swiftは変数の宣言時に型の指定を省略できる。

```swift
var calc = 25
print(calc * 5)
```


## 定数  
変更不可能な変数。letを使用する。

```swift
let fullname = "Akiko Maejima"
//fullname = "aaa" 定数には代入できないので、エラー
```
     
## タプル(tuple) 
複数のデータを一つにまとめる機能

```swift

//var (変数1,変数2) = (変数1の値,変数2の値)
var (a,b) = (5,7) //a = 5 , b = 7。
print(a + b) //12
```
   
## 変数の型変換(キャスト) 
```swift

var number:Int = 69
var numberString:String = String(number) //int型をString型に変換

var numberAnotherString:String = "96"
var numberAnother:Int = Int(numberAnotherString)! //String型をint型に変換
```

# 小数値と整数値の計算
```swift
var intVal = 3
var doubleVal = 3.14

print(Double(intVal) + doubleVal) //Int型をDouble型に変換して計算
```
         
# 配列
## 基本形
```swift
// 空配列の宣言(配列に格納する値の型を限定したい場合、末尾に型を追加)
var array:[String] = [] 
 
//letで不動配列を定義
let animalsArray = ["ウォンバット","たぬき","ぱんだ"]; 

//0番目の配列の値を取り出す(中身はウォンバット)
let animal = animalsArray[0]; 
print("\(animal)をモフりたい！") //ウォンバットをモフりたい！

//範囲を指定して取り出す(["たぬき","ぱんだ"])
let animal2 = animalsArray[1...2] 
print("\(animal2)もモフりたい！") //["たぬき", "ぱんだ"]もモフりたい！
```

## 配列の中身を書き換える

```swift

var fruitArray = ["いちご","メロン","青リンゴ"];
fruitArray[1] = "ぶどう"
print("中身は\(fruitArray)"); //中身は["いちご", "ぶどう", "青リンゴ"]
```

## 配列への追加

```swift

fruitArray.append("バナナ"); //appendで末尾に要素を追加。
print("中身は\(fruitArray)") //中身は["いちご", "ぶどう", "青リンゴ","バナナ"]

fruitArray += ["ドリアン"] //+=を使用することもできる
print("中身は\(fruitArray)") //中身は["いちご", "ぶどう", "青リンゴ", "バナナ", "ドリアン"]

var otherFruits = ["いちじく","チェリー"] //配列に別の配列の要素を追加することもできる
fruitArray.append(contentsOf: otherFruits) //["いちご", "ぶどう", "青リンゴ", "バナナ", "ドリアン", "いちじく","チェリー"]

//挿入するインデックスを指定して追加
fruitArray.insert("洋なし", at: 2); //中身は["いちご", "ぶどう", "洋なし", "青リンゴ", "バナナ", "ドリアン", "いちじく", "チェリー"]
```

## 要素を削除

```swift

//配列の中身から指定した場所の要素を削除
fruitArray.remove(at: 2);
print("中身は\(fruitArray)");

//要素の範囲を指定して削除
fruitArray[3...5] = []
print("中身は\(fruitArray)") //中身は["いちご", "ぶどう", "青リンゴ", "チェリー"

//配列の最後の要素を削除
fruitArray.removeLast()
print("中身は\(fruitArray)") //中身は["いちご", "ぶどう", "青リンゴ"]

//全て削除
fruitArray.removeAll()
print("中身は\(fruitArray)") //中身は[]
```

## 並びを逆順に変更
```swift

fruitArray.reverse()
```

## 配列の列挙
どちらの書き方でもできる。

```swift

for i in (0 ..< animalsArray.count) {
    print("\(animalsArray[i])かわいい！");
}

for anotherAnimal in animalsArray{
    print("\(anotherAnimal)かわいい！");
}
```

# SET
同じ値を複数入れることができない、順番が決まっていないという部分が配列と異なる。
Setは包含関係を調べたり、新しい集まりを作ったりするために使う。
以下ではwearGlassの中に含まれる要素がnewComerに入っているかどうか確認している。

```swift

let newComer: Set = ["maejima", "watabe", "komoto"]
let wearGlass: Set = ["maejima"]
var isWearGlass:Bool = wearGlass.isSubset(of: newComer)
print("maejimaはメガネをかけているか？：\(isWearGlass)") //true
```

# 辞書(連想配列、ハッシュ)
## 定義
```swift

var wordCounts = Dictionary<String, Int>() // 空の辞書(String型がキーでInt型が値)

//初期値を入れて辞書を定義
var maejimaDict: [String:String] = [
    "age" : "25",
    "like" : "music",
    "born" : "Japan"
]
```

## 取得
```swift

print(maejimaDict["age"]) //ageというキーの中に入っている値(25)を取り出す

// keyの一覧を取得して配列に格納
let keys: Array = Array(maejimaDict.keys)  //  [age, like, born]

// valueの一覧を取得して配列に格納
let values: Array = Array(maejimaDict.values) //  [25, msuic, Gifu]
```

## 列挙
```swift

for (key,value) in maedaDict{
	println("\(key)の値は\(value)")
}

/*
出力結果
* likeの値はmusic
* ageの値は25
* bornの値はGifu
*/
```

## 追加
```swift

maejimaDict["height"] = "163"; //maedaDictに heigth:"163" を追加
```

## 削除
```swift

maejimaDict.removeValue(forKey: "height") //指定したキーのデータを削除
//maejimaDict["height"] = nil; //値にnilを代入することで削除することもできる(Optionalではないとき)
print(maejimaDict) //["like": music, "age": 25, "born": Gifu]
```

## 変更
```swift
maejimaDict.updateValue("27", forKey: "age") //ageキーの値を27に変更
print(maejimaDict) //["like": music, "age": 27, "born": Gifu]
```

# nilとOptional
## nil
「何も存在していない」状態を表す値。変数の初期値として使う。
Swiftでnilを代入するときはOptional型を使用する。

## Optinal型
プログラムがプログラマをサポートする安全機能。
値があるかもしれないしないかもしれない状態を表すためにオプショナル値を使う。

```swift
var opValue:String? = "あああ" //Optional型の変数を定義
opValue = nil //nilを入ることを考慮するのでnil入れてもオーケー
```

以下はoptinalを定義してないので、変数にnil代入するとエラー

```swift
var notOpVal:String = "いいい"
notOpVal = nil //エラー
```

## !：定義した変数にnilが絶対入らないことを保証する
```swift

var oEValue:Int! = 123 
```



# 関数
## 関数定義
基本形

```swift

func 関数名(引数名: 引数の型) -> 戻り値の型 {

}
```

## 引数ありの関数

```swift

func valFunc(val: Int) -> Int {
    //引数の値を2倍にして返す変数
    var resultVal = 0
    resultVal = val * 2
    return resultVal
}

//関数の呼び出し
valFunc(val: 3) //6
```

## 引数が複数あるとき
```swift

func メソッド名(引数名1:引数の型1,引数名2:引数の型2) -> 返り値の型 {
	処理
}
```

```swift
func plusNumbers(num1:Int ,num2:Int) -> Int {
    return num1 + num2
}

var addSum = plusNumbers(num1:10, num2: 5)
print("合計値は\(addSum)") //10 + 5
```

## 可変引数
カンマ(,)区切りで何個でも入れることが可能

```swift
func squareSum(numbers: Int...) -> Int {
    //...を付与することで無限個の引数を入れることができる。(可変引数)
    //無限個の引数は引数名の配列(この関数だとnumbers)として扱える
    var sum = 0
    
    //関数は入れ子にできる。入れ子の関数は、外側の関数で定義された変数にアクセスできる
    func addSquare(x:Int){
        sum += x * x
    }
    for number in numbers {
        addSquare(x:number)
    }
    return sum
}
let sum = squareSum(numbers: 2, 2, 2, 2, 2, 2)
print("合計値は\(sum)") //24 ((2^2)*6)
```

## クロ−ジャ
関数名のない関数。
一連の処理の塊をオブジェクトとして扱えるようにする。関数の引数で利用する。


```swift
//基本形
{ (引数名: 引数型) -> 戻り値型 in
    return 戻り値
}
```

```swift
//numbersという配列のそれぞれの要素に3をかけて返すクロージャー関数
var numberArray = [4, 6, 8, 9]
let threeTimes = numberArray.map({(number: Int) -> Int in
    return 3 * number
})
print("numberは：\(threeTimes)") //numberは：[12, 18, 24, 27]
```