SwiftでAndroidアプリを作る!!?


今年のAdvent Calendar、Swiftで申し込んでいましたが最近はもっぱらAndroid開発をしていました。
そこで無理やりAndroid関連の記事に持ち込んでしまおうと思います。

## SwiftでAndroid??

今年の6月に発表されたSwift、個人的な所感としては色々な言語の良いとこ取りで、良い意味で特徴がなくすんなりと書き始められるとても良い言語だと思います。

そんなSwiftでAndroidが書ける？？
さすがにそこまで都合よくはいきません...。

今回ご紹介するのがKotlin（ことりん）という言語です。
Swiftと細かな記述方法の違いこそあるものの、色々な言語の良いとこ取りでありとても似ているように感じています。

## Kotlinってどんな言語？

ホームページは[こちら](http://kotlinlang.org/)です。

IntelliJの開発元であるジェットブレーンズ社で開発された言語です。

型推論やクロージャ、パターンマッチングなど関数型の特徴も随所に取り入れたオブジェクト思考言語です。

## KotlinでAndroidアプリを作るには

ものすっごい簡単に説明するとこんな感じです。

1. （初めてなら）[Android Studio](http://developer.android.com/sdk/index.html)をダウンロードする
2. Android Studioを立ち上げてNew Projectする
3. [Kotlinの導入方法](http://kotlinlang.org/docs/reference/using-gradle.html)を参考に、build.gradleに数行の設定を書き足す
4. Kotlinを書いて実行！！

## 言語の比較

それではSwiftとの違いを見ていきましょう。
[The Swift Programming Language](https://itunes.apple.com/jp/book/swift-programming-language/id881256329?mt=11)の流れに沿って比較していってみようと思います。

------------

### 変数宣言

不変の値の宣言が`let`か`val`かの違いです。

* Swift

```swift
var myVariable = 42
myVariable = 50
let myConstant = 42
```

* Kotlin

```kotlin
var myVariable = 42
myVariable = 50
val myConstant = 42
```

------------

### 文字列内での変数展開

`\`か`$`の違いですね

* Swift

```swift
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
```

* Kotlin

```kotlin
val apples = 3
val oranges = 5
val appleSummary = "I have $apples apples."
val fruitSummary = "I have ${apples + oranges} pieces of fruit."
```

------------

### 配列と辞書配列

少しだけ違いますね。

* Swift

```swift
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
 
var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations”
```

* Kotlin

```kotlin
var shoppingList = array("catfish", "water", "tulips", "blue paint")
shoppingList[1] = "bottle of water"

var occupations = hashMapOf(
    "Malcolm" to "Captain",
    "Kaylee" to "Mechanic"
)
occupations["Jayne"] = "Public Relations"
```
------------

### for

Swiftは場所によっては`()`を省略できますがKotlinだと基本的には必須です。

* Swift

```swift
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
teamScore
```

* Kotlin

```kotlin
val individualScores = listOf(75, 43, 103, 87, 12)
var teamScore = 0
for (score in individualScores) {
    if (score > 50) {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
teamScore
```
------------


### Optinal Value

このあたりから言語の特徴が出てきますね。
nullに対する対応としてどちらも`?`を使った文法を採用しています。

* Swift

```swift
var optionalString: String? = "Hello"
optionalString == nil

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

* Kotlin

```kotlin
var optionalString: String? = "Hello"
optionalString == null

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if (optionalName != null) {
    greeting = "Hello, $optionalName"
}
```
------------

### 値の束縛

どちらもほぼ同じです

* Swift

```swift
let interestingNumbers = [
    "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 interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
largest
```

* Kotlin

```kotlin
val interestingNumbers = mapOf(
    "Prime" to array(2, 3, 5, 7, 11, 13),
    "Fibonacci" to array(1, 1, 2, 3, 5, 8),
    "Square" to array(1, 4, 9, 16, 25)
)
var largest = 0
for ((kind, numbers) in interestingNumbers) {
    for (number in numbers) {
        if (number > largest) {
            largest = number
        }
    }
}
largest
```
------------

### Range

全く一緒です

* Swift

```swift
var firstForLoop = 0
for i in 0..3 {
    firstForLoop += i
}
firstForLoop
```

* Kotlin

```kotlin
var firstForLoop = 0
for (i in (0..3)) {
    firstForLoop += i
}
firstForLoop
```
------------

### Function

返却値周りがわずかに違いますがほぼ一緒ですね。

* Swift

```swift
func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")
```

* Kotlin

```kotlin
fun greet(name: String, day: String):String {
    return "Hello $name, today is $day."
}
greet("Bob", "Tuesday")
```

------------

### Functionのネスト

* Swift

どちらの言語もfunctionの中にfunctionを宣言できます

```swift
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()
```

* Kotlin

```kotlin
fun returnFifteen():Int {
    var y = 10
    fun add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()
```

------------

### Functionオブジェクト

書き方は色々と違ってきますが、基本的な考え方は同じです

* Swift

```swift
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, lessThanTen)
```

* Kotlin

```kotlin
fun hasAnyMatches(list: Array<Int>, condition:(Int) -> Boolean): Boolean {
    for (item in list) {
        if (condition(item)) {
            return true
        }
    }
    return false
}
val lessThanTen:(Int) -> Boolean =  { number ->
    number < 10
}
var numbers = array(20, 19, 7, 12)
hasAnyMatches(numbers, lessThanTen)
```

------------

### 無名関数

ほぼ一緒ですね

* Swift

```swift
var numbers = [20, 19, 7, 12]
numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})
```

* Kotlin

```kotlin
var numbers = array(20, 19, 7, 12)
numbers.map({
    val result = 3 * it
    result
})
```

------------

### 単純なクラス

* Swift

```swift
class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
```

* Kotlin

```kotlin
class Shape {
    var numberOfSides = 0
    fun simpleDescription():String {
        return "A shape with $numberOfSides sides."
    }
}
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
```

------------

### コンストラクタ付きクラス

Kotlinはコンストラクタはクラス名の直後に書けるので簡単なものであれば短くなります

* Swift

```swift
class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
```

* Kotlin

```kotlin
class NamedShape(var name:String) {
    var numberOfSides: Int = 0

    fun simpleDescription():String {
        return "A shape with $numberOfSides sides."
    }
}
```

## まとめ

とりあえずこのあたりまでとしておきます。

いかがでしたでしょうか。

SwiftとKotlin、利用シーンはiOSとAndroidとなっており違っていますが非常に似たような特徴を持った言語でした。

今回は省きましたが継承周りやFunctionのもう少し込み入ったところでも考え方はほぼ一緒なのですんなりと入っていけます。

この記事を機にiOSなみなさまがAndroidにもどんどんと手を広げていっていただけると嬉しいです。

***それではみなさま良いお年を！！(╹◡╹)***