Swift (プログラミング言語)

出典: フリー百科事典『ウィキペディア(Wikipedia)』
移動: 案内検索
Swift (プログラミング言語)
パラダイム マルチパラダイム(オブジェクト指向関数型命令型ブロックジェネリック)
登場時期 2014年6月2日 (2014-06-02)
設計者 Chris Lattner英語版[1]アップル インコーポレイテッド / Apple Inc.
最新リリース 1.0 (Xcode 6.0.1) / 2014年9月17日(3か月前) (2014-09-17
評価版リリース 1.1 (Xcode 6.1 GM seed) / 2014年9月29日(2か月前) (2014-09-29
型付け 強い静的型付け型推論
影響を受けた言語 Objective-C, Rust, Haskell, Ruby, Python, C#, D言語,[2] CLU[1]
プラットフォーム iOSOS X
ライセンス プロプライエタリ
ウェブサイト developer.apple.com/swift
拡張子 .swift

Swift(スウィフト)は、アップルiOSおよびOS Xのためのプログラミング言語Worldwide Developers Conference (WWDC) 2014で発表された。アップル製OS上で動作するアプリケーションの開発に従来から用いられていたObjective-CやObjective-C++、C言語と共存することが意図されている[3]

Swiftは、マルチパラダイムのコンパイラプログラミング言語であるが、XcodeのPlaygroundsの上やターミナルでインタラクティブにデバッグする事が可能である。

LLVMコンパイラが使われており、ライブコーディングに対応していることが特徴[4]

並列スクリプト言語のSwift英語版とは名称を同じくするが、別言語。


目次

歴史[編集]

Swiftは2010年にLLVMの始祖であるChris Lattner英語版によって開発が始められた。その後Apple社内での4年間の開発期間を経て、2014年のWWDCにおいて一般に発表され、同時にAppleに開発者登録している開発者に対してベータ版の提供が開始された。


特徴[編集]

AppleはSwiftの発表に際して「モダン、安全、高速、インタラクティブ」を大きな特徴として挙げた。

モダン
クロージャやタプル、ジェネリックプログラミング、Optional型の採用などが挙げられる。
安全
静的な型チェック、変数の初期化の強制、数値型のオーバーフローの検査、自動参照カウントによるメモリ管理などが挙げられる。
また、if文のブレースの省略禁止、switch-case文は明示的に指定されない限りフォールスルーしないなど、既存のプログラミング言語において記述ミスによるバグが発生しやすかった部分を文法的に解決している。
インタラクティブ
Swiftはコンパイラ言語でありながら、インタプリタとしてスクリプトを実行することも可能で、対話実行環境(REPL英語版)も用意されている。
Swiftと同時に発表されたXcodeバージョン6では、コードの実行結果をグラフィカルに確認しながら開発できるPlaygroundsが実装された。

サンプルコード[編集]

Hello World[編集]

println( "Hello, World!" )  // これだけで動いて、Hello, World! と出力される。

[編集]

/* 
 * コメントはCスタイルの複数行コメントと…
 */
// C++スタイルの一行コメントの双方をサポートしている
 
// var name:Type = value でType型の変数nameを宣言し、valueで初期化する
var explicitDouble:Double = 70 // 70.0
 
/// 型が省略された場合は、型推論により初期値の型が適用される
var implicitInteger = 70    // Int
var implicitDouble = 70.0   // Double
 
// let name:Type = value でType型の定数nameにvalueを設定する。
// 型推論可能な場合、型の表記は省略できる。
let theAnswer = 42
 
// 識別子にはたいていのUnicode文字を用いることができる。
let リンゴの数 = 3
let みかんの数 = 5
 
// 文字列リテラル"..."の中にある\(expr)には、式exprの内容が展開される
let リンゴ説明 = "私は\(リンゴの数)個のリンゴを持っている。"  // ”私は3個のリンゴを持っている。"
let 果物説明 = "私は\(リンゴの数 + みかんの数)個の果物を持っている。" //"私は8個の果物を持っている。"
 
// Swiftでは辞書も組み込みでサポートされている。
// 以下は Dictionary<String, Int> 型の定数辞書の定義の一例である。
let people = ["Anna": 67, "Bety": 8, "Jack": 33, "Sam": 25]
 
// 辞書の内容の列挙は for (key, value) in dict { ... }
for (name, age) in people {
    println("\(name) is \(age) years old.")
}
 
// メソッドや関数は "func"文法を使って宣言する。
// パラメータ名の付け方に注意。-> で戻り値の型を宣言する
func sayHello(personName: String) -> String {
    let greeting = "こんにちは、" + personName + "さん"
    return greeting
}
// "こんにちは、花子さん"を出力
println(sayHello("花子"))

文法[編集]

定数と変数[編集]

定数はletキーワードで、変数はvarキーワードによって宣言する。変数は値の再代入が可能だが、定数は後から値を変更することはできない。

let 定数名:=var 変数名:=

Swiftでは型推論が可能な場合には型の記述を省略できる。

let pi: Double = 3.141592
let pi = 3.141592  // 型名を省略する

基本データ型[編集]

真偽値[編集]

Swiftの真偽値はBool型であり、truefalseどちらかの値をとる。

数値[編集]

符号付き整数の型には、IntInt8Int16Int32Int64がある。Intは、32ビット環境ではInt32と同じサイズ、64ビット環境ではInt64と同じサイズである。

符号無し整数の型には、UIntUInt8UInt16UInt32UInt64がある。UIntは、32ビット環境ではUInt32と同じサイズ、64ビット環境ではUInt64と同じサイズである。

浮動小数点の型には、IEEE 754 単精度Floatと、倍精度Doubleがある。


数値リテラルのプレフィックスは"0b"で2進数、"0o"で8進数、"0x"で16進数を表す。

let dec = 29
let bin = 0b11101  // 2進数で29
let oct = 0o35     // 8進数で29
let hex = 0x1D     // 16進数で29

浮動小数点リテラルは、通常の十進数表記に加え16進数表記もサポートしている。

let π = 3.1415926535897931
let pi = 0x1.921fb54442d18p+1 // NSString(format:"%a", π) の出力と同様

整数型と浮動小数点型のどちらでも、コードの見やすさのためにアンダースコア _ を桁の区切りとして挿入できる。また、数値の右側(プレフィックスの後ろ)をゼロで埋めて表記できる。

let threeHundledMillion = 300_000_000
let bitMask: UInt8 = 0b0010_0000

いかなる数値型の変数についても暗黙の型変換(cast)が行われることはなく、型の違う数値同士の演算、右辺と左辺で型の異なる代入は全てコンパイルエラーとなる。Int32型からInt64型への変換や、64ビット環境におけるInt64型からInt型への変換など、非破壊的な変換においても暗黙の型変換が行われることはない。一方、数値リテラルについては、整数型から浮動小数点型への暗黙の型変換が行われることがある。

let intValue: Int = 1
let uintValue: UInt = intValue          // コンパイルエラー (IntからUIntへの暗黙の型変換は行われない)
let intValue2: Int = intValue + 1.0     // コンパイルエラー (浮動小数点型の数値リテラルは整数型に変換されない)
 
let floatValue: Float = 1.0
let doubleValue: Double = floatValue    // コンパイルエラー (FloatからDoubleへの暗黙の型変換は行われない)
let floatValue2: Float = floatValue + 1 // エラー無し (整数型の数値リテラルは浮動小数点型に変換される)

文字列[編集]

Swiftの文字列はString型、文字はCharacter型であり、Unicode文字一つを格納する。Objective-CJavaJavaScriptと異なり、UTF-16表現ではサロゲートペアを要する拡張領域の文字も一文字としてして扱う。

文字列リテラルはダブルクォーテーションで囲む。

let hello = "こんにちは"
 
let emptyString = ""  // 空の文字列
let anotherEmptyString = String()  // 空の文字列を作る別の方法

文字列は+演算子および+=演算子で連結できる。

let name = "太郎"
println("こんにちは" + name + "さん")
// こんにちは太郎さん

文字列リテラル内で\()に囲まれた式は文字列補間英語版によって展開される。

let celsius = 30.0
println("今日の気温は摂氏\(celsius)度、華氏\(celsius * 1.8 + 32)度です。")
// 今日の気温は摂氏30.0度、華氏86.0度です。

文字列中のエスケープはバックスラッシュによって行う。

\0 ヌル文字
\\ バックスラッシュ
\t 水平タブ
\n ラインフィード
\r キャリッジリターン
\" ダブルクォーテーション
\' シングルクォーテーション
\u{n} Unicode文字(nは16進数1〜8桁のUnicodeスカラ値)

for-in文で1文字ずつCharacter型で取り出せる。

for character in "aαあ𪚲" {
    println(character)
}
// a    \u{61} (1 byte in UTF-8, 1 char in UTF-16)
// α    \u{03B1} (2 bytes in UTF-8, 1 char in UTF-16)
// あ   \u{3042} (3 bytes in UTF-8, 1 char in UTF-16)
// 𪚲   \u{0001f423} (4 bytes in UTF-8, 2 chars in UTF-16)

String型の変数は内部的にはCocoa (Foundation) のNSStringクラスのインスタンスと互換性があり、キャストもしくは_bridgeToObjectiveC()関数を用いることによりNSStringクラスのインスタンスメソッドを呼び出すことができる。

let str = "aαあ𪚲"
println(countElements(str))  // 4
println(str.utf16Count)      // 5
println((str as NSString).length)         // 5 = length in UTF-16
println(str._bridgeToObjectiveC().length)  // 5

配列[編集]

Swiftではあるの要素の配列を、Array<型>ないし[型]と宣言する。どちらも同じ意味であるが、より直感的な後者が推奨されている。 配列内に型が混在する複合型配列は[Any]型となる

var arrayOfChars: [Character]    // 宣言のみ
var arrayOfInts = [Int]()        // 空の配列として初期化

配列リテラルは[ elem0, elem1 ...]と表記され、型は各要素の型より推論される

let fibs =              [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]          // [Int]
let transcendentals =   [ 2.7182818284590451, 3.1415926535897931 ]  // [Double]
let falsies =           [false, 0, 0.0, ""]                         // [Any] 型の混在

なお、[]は空の配列リテラルであるが、要素の型を何らかの形で指定する必要がある

var ints: [Int] =        []
var doubles: [Double] =  []
var any: [Any] =         []
var unknown =            [] // compile error

配列の結合、代入

var ints1        =      [10,20,30]
var ints2        =      [40,50]
ints1 = ints1 + ints2       // [10,20,30,40,50]
ints2[1] = 55               // [40,55]
ints1[1...2] = ints2        // [10,40,55,40,50]
ints1 = ints2               // [40,55]

辞書(Dictionary)[編集]

Swiftにおける連想配列辞書(Dictionary)と呼ばれる。C++などと同様、Swiftの辞書は総称型であり、キーの型KeyType、値の型ValueTypeを持つ辞書はDictionary<KeyType,ValueType>または[KeyType: ValueType]と宣言する。Array同様、より直感的な後者が推奨されている。

var name2num = [String:Int]()
name2num["zero"] = 0
name2num["one"]  = 1

リテラルは[k0:v0, k1:v1 ...]と表記する。配列の場合と同様、型推論が効く

let name2num  = ["zero":0, "one":1, "two":2] // Dictionary<String, Int>

[:]が空の辞書リテラルであるが、キーの型および値の型が指定されている必要がある点は配列と同様である。

var dict: [String: Int] = [:] // OK
var unknowndict = [:] // compile error

複合型[編集]

通常のクラス、構造体、列挙型、プロトコルの型は名前付き型(named type)と呼ばれ、型の定義と同時にその型名が与えられる。標準ライブラリのIntやStringなども名前付き型である。
それに対して複合型(compound type)とは、それ自体に名前はついておらず、他の型の組み合わせから成り立つ型のことである。複合型にはタプル型と関数型の二種類がある。

タプル[編集]

タプルは複数の値を一時的にひとつにまとめて扱うための簡易的なデータ構造である。タプルは関数の多値返却などに利用される。
タプル型は括弧"()"を使って(型1, 型2, ...)の形式で定義し、どのような型同士でも組み合わせることが可能である。
HTTPステータスコードを表現するために、Int型とString型をひとまとめにした(Int, String)型のタプルを使用する例を以下に示す。

let errorStatus: (Int, String) = (404, "Not Found")

これは型推論によって以下のようにも書ける。

let errorStatus = (404, "Not Found")

代入式で定数または変数に分解することができる。このとき定数/変数名にアンダースコアを指定すると、その値を無視することができる。

let (_, message) = errorStatus  // ひとつ目の値は無視する
println(message)
// Not Found

タプルの各要素にはあらかじめ名前をつけることができ、その名前によって値に直接アクセスすることができる。また、インデックスを指定することでも値にアクセスできる。

let okStatus = (code: 200, message: "OK")
println("\(okStatus.code): \(okStatus.message)")
println("\(okStatus.0): \(okStatus.1)")
// 200: OK
// 200: OK

タプル以外の変数も1個のみの値をもつタプルとして設計されている。例えば以下はaの値を正しく表示する。

let a = 10
println( a.0 )

関数型[編集]

関数型は引数の型 -> 返り値の型で表される。例えば、Int型とDouble型の引数を1つずつ受け取りString型の値を返す関数は、(Int, Double) -> String型と表される。詳細は#関数の項を参照。

型エイリアス[編集]

型エイリアス(type alias)によって、既存の型に別名をつけることができる。型エイリアスの宣言はtypealiasキーワードによって行う。

typealias 新しい型名 = 既存の型名

演算子[編集]

算術演算子[編集]

二項演算子
文法 意味
+ 加算
- 減算
* 乗算
/ 除算(整数型のゼロ除算はエラーとなる)
% 剰余(整数型のゼロでの剰余演算はエラーとなる)
&+ 加算(オーバーフローを無視する)
&- 減算(オーバーフローを無視する)
&* 乗算(オーバーフローを無視する)
&/ 除算(オーバーフローを無視し、ゼロ除算の結果は0となる)
&% 剰余(オーバーフローを無視し、ゼロでの剰余演算の結果は0となる)
単項演算子(前置)
文法 意味
+ 単項プラス
- 単項マイナス(符号反転)
++ インクリメント(式はインクリメントされたの値を返す)
-- デクリメント(式はデクリメントされたの値を返す)
単項演算子(後置)
文法 意味
++ インクリメント(式はインクリメントされるの値を返す)
-- デクリメント(式はデクリメントされるの値を返す)

比較演算子[編集]

文法 意味
< より小さい
<= 以下
> より大きい
>= 以上
== 等しい
!= 等しくない
=== 同じオブジェクトへの参照
!== 別のオブジェクトへの参照
~= パターンマッチ(左辺の範囲内に右辺が有ればtrue)

論理演算子[編集]

文法 意味
&& 論理AND
|| 論理OR
! 論理NOT

三項演算子[編集]

文法 意味
条件 ? 式1 : 式2 条件が真のとき式1の値を、偽のとき式2の値を返す

nil結合演算子(Nil Coalescing Operator)[編集]

文法 意味
?? 左オペランドにはT?型、右オペランドにはT型の値をとり、
左オペランドに値が存在していればアンラップしてその値を返し、左オペランドがnilであれば右オペランドの値を返す
"x".toInt() ?? 0  // 0
"5".toInt() ?? 0  // 5

ビット演算子[編集]

文法 意味
<< 左シフト
>> 右シフト(左オペランドが符号付き整数の場合は算術シフト、符号無し整数の場合は論理シフト)
& AND
| OR
^ XOR
~ NOT(ビット反転)

代入演算子[編集]

文法 意味
= 代入
+= 加算と代入
-= 減算と代入
*= 乗算と代入
/= 除算と代入
%= 剰余演算と代入
<<= 左ビットシフトと代入
>>= 右ビットシフトと代入
&= ビット演算ANDと代入
|= ビット演算ORと代入
^= ビット演算XORと代入
&&= 論理ANDと代入
||= 論理ORと代入

範囲演算子(Range operators)[編集]

文法 意味
..< 半分開いた範囲(終端を含まない):半開区間
... 閉じた範囲(終端を含む):閉区間

キャスト演算子[編集]

文法 意味
is 型検査
as 型キャスト
as? Optional型へのキャスト キャストできない場合はnilとなる
var a: Any = "x"
var b: Any = 42
 
var i = a as? Int  // i は Int? 型
println(i)  // nil(Int 型へダウンキャストできないので nil)
i = b as? Int
println(i)  // Optional(42)

中置演算子の優先順位と結合性[編集]

優先度 演算子 結合性
160 <<   >> 非結合
150 *   /   %   &*   &/   &%   & 左結合
140 +   -   &+   &-   |   ^ 左結合
135 ..<   ... 非結合
132 is   as 非結合
130 <   <=   >   >=   ==   !=   ===   !==   ~= 非結合
120 && 左結合
110 || 左結合
?? 右結合
100 ?: 右結合
90 =   +=   -=   *=   /=   %=   <<=   >>=   &=   |=   ^=   &&=   ||= 右結合

特にビット演算子の優先順位がC言語などとは異なっているので注意が必要である。
C言語の場合:

5 << 1 + 2  // 40
// 5 << (1 + 2) の意味となる

Swiftの場合:

5 << 1 + 2  // 12
// (5 << 1) + 2 の意味となる

制御構造[編集]

if文[編集]

条件式を囲む括弧は不要である。コードブロックを囲むブレースを省略することはできない。
条件式に書けるのはBool型かBool型を返す式のみである。(ただしBooleanTypeプロトコルを実装する型はboolValueプロパティが呼ばれ、そのBool値が評価される。これはfor文やwhile文の条件式においても同様である。)

if 条件式1 {
    文1
} else if 条件式2 {
    文2
} else {
    文3
}

switch文[編集]

C言語と違い、数値だけでなくあらゆるオブジェクトによって分岐することができる。また暗黙的にブレークされ、fallthroughキーワードがある場合に限り、次のcase文にフォールスルーする。

switch{
case パターン1:
    println("case 1")
    //暗黙的にbreakされる
case パターン2, パターン3:  //複数の条件をコンマで区切って指定可能
    println("case 2 or 3")
case パターン4 where 条件式: // where 条件式でパターンに制限を加える事が出来る
    println("case 4")
    fallthrough  //fallthroughがある場合のみ次のcase文にフォールスルー
case パターン5: // let x の様にswitch式の値をcase本文内で使う変数に割り当てる事が出来る。 バリューバインディング(value binding)
    println("case 5")
default:
    println("default")
}

for/for-in文[編集]

for-in文によってコレクションや範囲の要素をイテレートできる。

let names = ["太郎", "花子", "一郎"]
for name in names {
    println("\(name)さん、こんにちは!")
}

C言語風のfor文も使用できる

for var index = 0; index < 5; index++ {
     println("index: \(index)")
 }

上記のコードは範囲(Range)を使ったfor-in文で次のようにも書ける

 for index in 0..<5 {
     println("index: \(index)")
 }

while/do-while文[編集]

while 条件式 {
    文
}

do {
    文
} while 条件式

Optional型[編集]

Swiftでは安全性のため、ある型の定数や変数にnilを代入することは禁止されている。
ある値が存在しないことを示すため変数にnilを代入可能にしたい場合には、Optional型でラップする。
任意の型のOptional型は、ラップしたい型名の後ろに"?"を付けて表す。

var n: Int = nil  // コンパイルエラー
var m: Int? = nil // Optional型でラップすればnilを代入可能
var l: Optional<Int> = nil // Int? は Optional<Int> の略記である
// 文字列の配列の中から指定した文字列を探し、
// 見つかればそのインデックスを、見つからなければnilを返す関数。
// nilを返し得るので戻り値の型はInt型ではなくInt?型である。
func findString(data: [String], key: String) -> Int? {
    for index in 0..<data.count {
        if data[index] == key {
            return index
        }
    }
    return nil
}
 
let fruits = ["apple", "banana", "orange"]
 
let bananaIndex = findString(fruits, "banana")
println("bananaIndex: \(bananaIndex)")
 
let mangoIndex = findString(fruits, "mango")
println("mangoIndex: \(mangoIndex)")
 
// bananaIndex: 1
// mangoIndex: nil

Optional<Type>型の値からType型の値を取り出すことを、アンラップするという。

Optional型の値をアンラップするには、値のうしろに"!"を付ける。

アンラップする場合には、値が確かに存在すること(nilではないこと)を確認しなければならない。

let possibleKiwiIndex = find(fruits, "kiwi")  // possibleKiwiIndexはInt?型
 
if possibleKiwiIndex != nil {
    let kiwiIndex = possibleKiwiIndex!
    // possibleKiwiIndexがnilでないことを確認したので、安全にアンラップできる
    // kiwiIndexはInt型であり、nilでないことが保証されている
 
    println("キウイは\(kiwiIndex)番目に見つかりました")
} else {
    println("キウイは見つかりませんでした")
}

if文とwhile文ではOptional束縛(optional binding)を記述できる。
上のコードをOptional束縛を利用して書くと次のようになる。

if let kiwiIndex = find(fruits, "kiwi") {
    // もしfindからのInt?型の戻り値に値が入っていれば、kiwiIndexにその値を代入する
 
    println("キウイは\(kiwiIndex)番目に見つかりました")
} else {
    println("キウイは見つかりませんでした")
}

while文で使用するOptional束縛の例を下に示す。

// 1行づつ読み出す関数のダミー
// 呼び出すごとに行を進めていき、最後の行まで到達するとnilを返す
let readLine: () -> String? = {
    let lines = [
        "Lorem ipsum dolor sit amet,",
        "consectetur adipisicing elit,",
        "sed do eiusmod tempor incididunt",
        "ut labore et dolore magna aliqua."
    ]
    var idx = -1
 
    return { return ++idx < lines.count ? lines[idx] : nil }
}()
 
// readLineの戻り値に値が存在していれば
// lineに代入してブロックの中を実行する
while let line = readLine() {
    println(line)
}
// Lorem ipsum dolor sit amet,
// consectetur adipisicing elit,
// sed do eiusmod tempor incididunt
// ut labore et dolore magna aliqua.

関数とクロージャ[編集]

Swiftにおける関数とクロージャは第一級関数であり、普通のオブジェクトと同じように変数に入れたり、引数として受けとったり、戻り値として返すことができる。

関数[編集]

関数の定義はfuncキーワードを使って以下のように行う。

// 体重と身長からBMI値を計算する関数
func calcBMI(weight: Double, height: Double) -> Double {
    return weight / (height * height) * 10000
}
 
calcBMI(60, 160)  // 23.4375

上の関数は(Double, Double) -> Double型のオブジェクトとして扱うことができる。

let myFunc: (Double, Double) -> Double = calcBMI
myFunc(60, 160)  // 23.4375

関数の引数はデフォルトで定数であり、関数内でその値を変更することはできない。しかしvarキーワードを付けて引数を宣言すると、その引数は関数内で値を変更できるようになる。なお、デフォルト(let)、varどちらで宣言した場合も、引数は値渡し(参照型の引数は参照の値渡し)である。varで宣言した引数に別の値を再代入しても、呼び出し元の変数の値は変わらない。

func someFunction(a: Int, let b: Int, var c: Int) {
//  a = 99  // 引数はデフォルトで定数であり、再代入不可
//  b = 99  // 明示的に let を指定してもよい
    c = 99  // var で引数を宣言すれば、関数内で値を変更できる
}
外部引数名[編集]

関数の引数には外部引数名(external parameter name)を指定することができる。対して関数内部のみで使用できる引数名はローカル引数名(local parameter names)と呼ぶ。外部引数名が指定された関数を呼び出すときは、明示的にその名前を記述しなければならない。外部引数名を使うことによって、関数を呼び出す側のコードで引数の意味を明確にすることができる。

func calcBMI(weight w: Double, height h: Double) -> Double {
    return w / (h * h) * 10000
}
 
calcBMI(weight: 60, height: 160)  // 23.4375

外部引数名とローカル引数名が同じならば、引数名の前に"#"を付けた短縮形を使うことができる。

func calcBMI(#weight: Double, #height: Double) -> Double {
    return weight / (height * height) * 10000
}
 
calcBMI(weight: 60, height: 160)  // 23.4375
関数のネスト[編集]

関数の中で関数を定義することが可能である。

func calcBMI(weightInPounds w: Double, heightInInches h: Double) -> Double {
 
    func poundsToKilograms(val: Double) -> Double { return val * 0.45359237 }
    func inchesToMeters(val: Double) -> Double { return val * 2.54 }
 
    let convertedWeight = poundsToKilograms(w)
    let convertedHeight = inchesToMeters(h)
 
    return convertedWeight / (convertedHeight * convertedHeight) * 10000
}
 
calcBMI(weightInPounds: 130, heightInInches: 65) // 21.6329101427434
可変長引数[編集]

引数の型に続けて"..."(ピリオド3つ)を記述すると可変長引数(variadic parameter)となる。可変長引数は関数内では配列として扱うことができる。可変長引数にできるのは一番最後の引数だけである。

func maxInt(first: Int, rest: Int...) -> Int {
    var max = first
 
    // Int型の可変長引数restは、Int型の配列として扱える
    for num in rest {
        if max < num {
            max = num
        }
    }
 
    return max
}
 
maxInt(7, 3, 5, 9, 2)  // 9
maxInt(6)  // 6
デフォルト引数[編集]

引数には個別にデフォルト値を設定でき、デフォルト値が設定された引数は呼び出す際に省略することが可能となる。
デフォルト値が設定された引数は自動的に名前付き引数となる。

func sayHello(name: String = "world") {
    println("Hello, \(name)!")
}
 
sayHello()               // Hello, world!
sayHello(name: "Swift")  // Hello, Swift!
in-out引数[編集]

inoutキーワードを付けて引数を宣言すると、引数に値のコピーが渡り、関数を実行した結果の値がコピーされて呼び出し元に書き戻される、いわゆる値呼びの結果返し(call-by-value-result)となる。Swiftではこれをin-out引数と呼ぶ。呼び出し側ではin-out引数に渡す変数名の前に&を付ける。なおin-out引数にデフォルト値を設定することはできず、また定数やリテラルなどの値を変更できないものを渡すこともできない。in-out引数はコンパイラによって参照呼び(call-by-reference)に最適化される場合がある。

func swapInts(inout a: Int, inout b: Int) {
    let tmp = a
    a = b
    b = tmp
}
 
var x = 42, y = 99
swapInts(&x, &y)
println("x = \(x), y = \(y)")  // x = 99, y = 42
 
var arr = [1,2,3]
swapInts(&arr[0], &arr[2])
println(arr)  // [3, 2, 1]

クロージャ[編集]

Swiftでは中括弧{}で囲まれたコードブロックは事実上全てクロージャとなる。 このとき、引数・戻り値と、本体の処理の間に「in」を書くことで、この2つの部分を区別する。 以下の例は、整数型引数numberを持ち、整数の結果(ここではnumberの3倍の値)を返すクロージャが使われている。 配列のメソッドmapは、関数もしくはクロージャを引数に持ち、 配列要素の一つ一つにこの関数またはクロージャを適用する機能を持つ。 この例では、membersの配列要素がそれぞれ3倍され、[1, 2, 3][3, 6, 9]となる。

[1, 2, 3].map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
    })

クロージャを書く場合に、いくつかのオプションがある。 delegateのコールバックのようにクロージャの型が推論可能な場合、 引数の型やクロージャの戻り値の型のいずれかもしくは両方の表記を省略することができる。 例えば上記の例では、引数も戻り値も配列の要素(型はInt)であるので、下のように型の指定を省略できる。

[1, 2, 3].map({
    number in
    let result = 3 * number
    return result
    })

また、クロージャの本体に1文しかない場合は、その値を返すものと考えられ、 以下のように、return文に関係する記述を省略する事ができる。

[1, 2, 3].map({ number in 3 * number })

さらに、引数を文字ではなく数字で表す事でさらに短く表現できる。 クロージャに渡される引数は、順番に$0$1、…で示すこともできる。そこで、以下のようにできる。

[1, 2, 3].map({ 3 * $0 })

また、関数の最後の引数がクロージャであった場合、それを括弧の外に出してもよい。

[1, 2, 3].map(){ 3 * $0 }

さらに、この場合、空の括弧、()は省略可能である。

[1, 2, 3].map{ 3 * $0 }

もう一つ別の例を示す。 sorted関数は、第1引数に配列を、第2引数に並べ替えルールを示す関数もしくはクロージャを書くことで、 配列の要素を並べ替えた新しい配列を返す。 並べ替えルールは、隣接する要素がルールに従っている場合にtrueを返す関数である。 配列要素がIntである場合、たとえば、以下のルール関数により、 [1, 5, 3, 12, 2]という整数配列を昇順に並べ替えることができる。

func rule(a:Int, b:Int) -> Bool {
  return a < b
}
 
sorted([1, 5, 3, 12, 2],rule)

sorted関数は[1, 2, 3, 5, 12]という配列を返す。ルール関数の部分をクロージャで書くと以下のようになる。

sorted([1, 5, 3, 12, 2], {(a:Int, b:Int) -> Bool in return a < b })

これも、上記のmapメソッドの例と同様に、以下のように簡潔に記述する事ができる。

sorted([1, 5, 3, 12, 2]) { return $0 < $1 }

列挙型[編集]

タイプセーフの共通型を列挙する

enum SomeEnumeration {
//列挙の定義がここに入る
}
//例 方角を定義
enum CompassPoint {
    case North
    case South
    case East
    case West
}
var directionToHead = CompassPoint.West
directionToHead = .East
enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

クラスと構造体 /class struct[編集]

Swiftの構造体はC言語の構造体から大きく強化されており、クラスと同様にメソッドやコンピューテッド・プロパティを実装することができる。

クラスと構造体の宣言は、それぞれclassキーワードとstructキーワードを使って次のように行う。

class クラス名 {
    // 実装…
}
 
struct 構造体名 {
    // 実装…
}

クラスは参照型/ reference typeで、アサインされる時には参照ポインタが渡される。 構造体は値型/ value typeでletやvarでアサインされる時にコピーされる。これに属する物としては、 String Array Dictionary が有る。

プロパティ[編集]

ストアド・プロパティ(Stored Property)[編集]

プロパティはletまたはvarを使って、ローカル定数/変数と同じように定義できる。プロパティにアクセスする時はドット記法により行う。
ストアド・プロパティは他言語のインスタンス変数に近いが、遅延初期化や値の監視(後述)など、より高機能である。

class SomeClass {
    var val1 = 0   // 宣言時に初期化する場合は、型推論により型を省略できる
    var val2: Int  // 宣言時ではなくイニシャライザで初期化する場合は、型を明示する
 
    let val3 = 0
    let val4: Int
 
    init() {
        // 宣言時に初期化せずにイニシャライザ内で初期化してもよい
        val2 = 0
        val4 = 0
    }
}
let obj = SomeClass()
println(obj.val1)  // プロパティにはドット記法でアクセスする
obj.val2 = 1
//obj.val3 = 1  // letで宣言したプロパティには再代入不可

ストアド・プロパティは定義の前にlazy修飾子を付けることで、初めてアクセスされる時まで初期化の実行を遅らせることができる。

class HeavyClass {
    init() { println("HeavyClassをインスタンス化") }
    func method() { println("HeavyClassのメソッド") }
}
 
class SomeClass {
    lazy var heavy: HeavyClass = HeavyClass()
 
    init() { println("SomeClassをインスタンス化") }
    func method() { println("SomeClassのメソッド") }
}
 
var obj = SomeClass()
obj.method()
obj.heavy.method()  // ←ここで初めてheavyプロパティが初期化される
 
// 実行結果:
// SomeClassをインスタンス化
// SomeClassのメソッド
// HeavyClassをインスタンス化
// HeavyClassのメソッド
遅延ストアド・プロパティ(Lazy Stored Property)[編集]

初期値は最初に使われる時まで計算されない。

コンピューテッド・プロパティ(Computed Property)[編集]

ゲッター/セッターを介してアクセスするプロパティを定義できる。
他言語の一般的なプロパティに近い。

class Square {              // 正方形クラス
    var sideLength: Double  // 一辺の長さ(ストアド・プロパティ)
 
    var area: Double {      // 面積(コンピューテッド・プロパティ)
    get {  // ゲッター
        return sideLength * sideLength
    }
    set {  // セッター
        sideLength = sqrt(newValue)
    }
    }
 
    init(sideLength: Double) {
        self.sideLength = sideLength
    }
}
 
let sq = Square(sideLength: 5)
println(sq.area)  // 25.0
 
sq.area = 36
println(sq.sideLength)  // 6.0

ゲッターのみを定義すれば読み出し専用のコンピューテッド・プロパティとなる。この場合、getキーワードを省略できる。

class Person {
    var firstname, lastname: String
 
    var fullname: String { return firstname + " " + lastname }
 
    init(firstname: String, lastname: String) {
        self.firstname = firstname
        self.lastname = lastname
    }
}
 
var author = Person(firstname: "Jonathan", lastname: "Swift")
println(author.fullname)  // Jonathan Swift
プロパティ値の監視 (Property Observers)[編集]

プロパティの値がセットされる時に常に動くように監視している。
willset 値が格納される直前に呼ばれる。
didset 値が格納された直後に呼ばれる

型プロパティ[編集]

普通のプロパティが個々のインスタンスに属するのに対して、同じクラスの全てのインスタンスで共有するプロパティを、型プロパティ(type property)という。他の言語でいうクラス変数に近い。
型プロパティはクラスではclassキーワードを、構造体ではstaticキーワードを使って宣言する。

class MyClass {
    class var computedTypeProperty: Int {}
}
 
struct MyStruct {
    static var storedTypeProperty = 42
    static var computedTypeProperty: Int {}
}

メソッド[編集]

メソッドは特定の型に結びつけられた関数である。 クラス、構造体、列挙型のすべては、 そのインスタンスと共に実行するタスクや機能をカプセル化した インスタンスメソッドを定義することができる。 クラス、構造体、列挙型は、 型そのものと一緒に実行する 型メソッド(type method)を定義することができる。 型メソッドは他言語のクラスメソッドに近い。 Swiftにおいて構造体と列挙型がメソッドを定義できることは、C言語やObjective-Cとの大きな違いである。 Objective-Cにおいてはクラスがメソッドを定義できる唯一の型であった。 Swiftにおいては、クラス、構造代、列挙型でメソッドを定義できる。

インスタンスメソッド[編集]

インスタンスメソッドは、特定のクラス構造体列挙型インスタンスに属する関数である。
インスタンスメソッドは、 インスタンスプロパティを読み書きする機能や、 インスタンスの目的に関した機能を提供する。 インスタンスメソッドは、関数とまったく同一の文法で記述される。

インスタンスメソッドは、その型のすべてのインスタンスメソッドとプロパティにアクセスできる。 インスタンスメソッドは、それが記述されている型のインスタンスに対してのみ呼び出すことができる。 インスタンスの指定無しでメソッドだけを単独に呼び出すことはできない。

以下に、整数型の長さの辺を持つ三角形のクラスを定義している(あまり実用的ではないが)。 ここでは、3辺の長さを設定するインスタンスメソッドsetSidesと、 3辺の合計(perimeter)を返すインスタンスメソッドperimeterを定義している。 インスタンス内の変数には変数名だけでアクセス可能であるが、 とくに区別したい場合は自分自身を表すselfを使用する。 以下の例では、setSidesメソッドで、引数のabcとインスタンス変数のabcを区別するためにselfを使用している。

class Triangle {
    var a=0, b=0, c=0
    func setSides(a:Int, b:Int, c:Int) {
        self.a = a; self.b = b; self.c = c
    }
    func perimeter() -> Int {
        return a + b + c
    }
}

以下では、3辺に3、 4、 5を設定し、周囲長12を表示している。 他言語に対して特徴的な点は、 引数が2個以上のメソッドの呼び出し方法である(例ではsetSides)。 最初の引数は値のみを記述するが、 2番目以下の引数では、 メソッド定義で仮引数として書かれた変数名にコロンを付けてラベル付けする。 ここでは、第2、3引数に、b:c:のラベルを付けている。

let myTriangle = Triangle()
// 3辺の長さを設定する
myTriangle.setSides( 3, b:4, c:5 )
// 周囲の長さを表示する(12が表示される)
println( myTriangle.perimeter() )

メソッドの2番目以下の引数にラベルを付記する方式は、 セレクタを使用したメッセージ渡しを行うObjective-Cとの整合性を高めるためである。 Smalltalkの流れを汲むObjective-Cでは、これに相当するメソッドは

[ myTriangle setSideA:3 B:4 C:5 ]

というように、setSideA:B:C:の3個のセレクタで構成されるメッセージで呼び出されるのが通例である。 最初のセレクタをメソッド名に、以降のセレクタをラベルにすることで、 Objective-Cとの共存や、Objective-Cで構築されたフレームワークへのアクセスを実現している。

型メソッド[編集]

インスタンスメソッドがある型のインスタンス上で呼ばれるのに対し、型それ自身の上で呼ばれる型メソッドを定義できる。

型メソッドは、クラスの場合funcキーワードの前にclassを書いて定義する。

構造体列挙型の場合funcキーワードの前にstaticを書いて定義する。


class SomeClass {
    class func someTypeMethod() { // <<****** 型メソッド定義
    // 型メソッドの中身
    }
}
SomeClass.someTypeMethod() // <<****** 型メソッド呼び出し
 
struct LevelTracker {
    static var highestUnlockedLevel = 1
    static func unlockLevel(level: Int) { // <<****** 型メソッド定義
        if level > highestUnlockedLevel { highestUnlockedLevel = level }
    }
    static func levelIsUnlocked(level: Int) -> Bool { // <<****** 型メソッド定義
        return level <= highestUnlockedLevel
    }
    var currentLevel = 1
    mutating func advanceToLevel(level: Int) -> Bool {
        if LevelTracker.levelIsUnlocked(level) {
            currentLevel = level
            return true
        } else {
            return false
        }
    }
}


イニシャライザ(Initializer)[編集]

イニシャライザは、そのクラスのオブジェクトがインスタンス化される際に呼ばれる処理を記述する。他の言語で言うところのコンストラクタに相当する。
initに続けてブロックを記述する。メソッドの定義に似ているがfuncキーワードや戻り値の型、return文は書かない。

class SomeClass {
    init(引数…) {
        // 初期化処理…
    }
}

ひとつのクラスに複数のイニシャライザを記述することができる。
初期化が必要なプロパティのすべてが初期化されることを保証するイニシャライザのことを、指定イニシャライザ(designated initializer)と呼ぶ。さらに、クラスを継承している場合は、指定イニシャライザはスーパークラスのイニシャライザを呼び出さなければならない。
それに対して、プロパティの初期化を他のイニシャライザに委譲するイニシャライザを、コンビニエンス・イニシャライザ(convenience initializer)と呼ぶ。
コンビニエンス・イニシャライザはinitキーワードの前にconvenienceキーワードを置く。
コンビニエンス・イニシャライザの中からコンビニエンス・イニシャライザを呼び出すことは可能だが、最終的には指定イニシャライザが呼び出されるようにしなければならない。

class Color {
    var red, green, blue: Int  // 宣言時に初期化していないので、指定イニシャライザでの初期化が必要。
 
    // 指定イニシャライザ
    init(red: Int, green: Int, blue: Int) {
        // 全ての初期化が必要なプロパティを初期化する。
        self.red = red
        self.green = green
        self.blue = blue
    }
 
    convenience init(white: Int) {
        // コンビニエンス → 指定イニシャライザ
        self.init(red: white, green: white, blue: white)
    }
 
    convenience init() {
        // コンビニエンス → コンビニエンス → 指定イニシャライザ
        self.init(white: 0)
    }
}
 
var brown = Color(red: 0xA5, green: 0x2A, blue: 0x2A)
var gray = Color(white: 0x80)
var black = Color()

Objective-Cでは指定イニシャライザは規約でしかなかったが[5]、Swiftでは文法として厳密に検査される。 なお、Objective-Cにおいてコンビニエンス・コンストラクタと呼ばれているものは、例えばNSStringのインスタンス生成に[[[NSString alloc] initWithFormat:...] autorelease]と呼ぶところを、[NSString stringWithFormat:...]のように短く便利に呼べるようにしたもののことであり、Swiftのコンビニエンス・イニシャライザとは別物である。


引数の無いイニシャライザはデフォルト・イニシャライザ(default initializer)と呼ばれ、明示的に定義されていなくても自動で生成される。

class Note {
    var title = "No Title"  // 初期化済
    var body: String?       // Optional型なので暗黙的にnilで初期化される
}
var newNote = Note()

構造体はデフォルト・イニシャライザに加えて、メンバをすべて引数に受けとるイニシャライザ(memberwise initializer)が自動で生成される。

struct Point{
    var x = 0.0, y = 0.0
}
var p1 = Point()              // {x 0.0, y 0.0}
var p2 = Point(x: 10, y: 50)  // {x 10.0, y 50.0}

デイニシャライザ(deinitializer)[編集]

デイニシャライザ(deinitializer)にはインスタンスが破棄される際に実行されるべき処理を記述する(開いたファイルを閉じるなど)。他言語のデストラクタに相当する。
deinitに続けて処理ブロックを記述する。引数、戻り値はともに無い。
イニシャライザと違いデイニシャライザは自動で呼びだされるものであり、自分で呼び出すことはできない。
デイニシャライザはクラスにだけ存在し、構造体には無い。

class SomeClass {
    deinit {
        // 後処理…
    }
}

継承[編集]

クラス名の後に":"を挟んでスーパークラスの名前を記述する。
Swiftは多重継承はサポートしない。
メソッドをオーバーライドする場合は、メソッドの定義にoverride属性の指定が必須である。これは意図しないオーバーライドを予防するためである。

class クラス名: スーパークラス名 {
}

なお、Objective-CではNSObjectが全てのクラスの共通の基底クラスであったが、Swiftにはそのような全てのクラスに共通の基底クラスというものは存在しない。

プロトコル[編集]

Objective-Cのプロトコルと同様の概念であり、Java言語などのインタフェースに相当する機能である。

拡張|エクステンション[編集]

Swiftのクラスはエクステンション(extension)を用いて既存のクラスを拡張することができる。これはObjective-Cのカテゴリとよく似ている。

ジェネリック[編集]

ジェネリック(総称性)コードは、柔軟で再使用可能な関数や型を可能にする。
ジェネリックはSwiftの最も強力な機能の一つでSwiftの標準ライブラリは殆どジェネリックコードで作られている。 配列や辞書型もジェネリック集合である。 IntでもStringでも色んな型を入れる事が出来る。
ジェネリックにすることにより一つの定義であらゆるタイプを取扱う事が出来るようになる。

ジェネリックタイプ[編集]

自分用のジェネリックタイプを定義できる。 それには、カスタムClass、構造/structure、列挙/enumeration 等が配列や辞書と同じ様にどんなタイプとでも動く。

struct Stack<T> {
    var items = [T]()
    mutating func push(item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
}
var stackOfStrings = Stack<String>()
stackOfStrings.push("一")
stackOfStrings.push("二")
// スタックに2つの文字列が入った。

ジェネリック関数[編集]

下の例は、自由な型の2つの値を交換する関数である。 Tは架空の型名で実際にはどんな型でも動く。

func swapTwoValues<T>(inout a: T, inout b: T) {
  let temporaryA = a ; a = b ; b = temporaryA
}
 
var someInt = 3 ,  anotherInt = 107
swapTwoValues(&someInt, &anotherInt)
 
var someString = "hello" ,  anotherString = "world"
swapTwoValues(&someString, &anotherString)

型束縛[編集]

swapTwoValues関数と Stackタイプはどんな型でも動く。 しかしジェネリック関数やジェネリックタイプで使われるとき、型束縛をして制限した方が使いやすい事がしばしばある。

型パラメータリストの一部として、型パラメータの名前の後ろにコロン:で区切って単一クラスやプロトコル束縛を書いて型束縛とする。

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // 関数本体
}
型束縛例[編集]
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {/*略*/}
//
let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")

関連タイプ (typealias)[編集]

プロトコルを定義する時にいくつかの関連タイプ(別名:alias)を定義した方が使いやすい時が有る。 typealias を使って別名を定義する。

関連タイプ例[編集]

Container プロトコルが ItemTypeと言う関連タイプを持つ例

protocol Container {
    typealias ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

Where句[編集]

型束縛にwhereで更なる条件を付ける

func allItemsMatch<
    C1: Container, C2: Container
    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
    (someContainer: C1, anotherContainer: C2) -> Bool {
//略
}

アクセス制御[編集]

public, internal, private の3種類でアクセス制限をする。


public  どのソースファイルからも参照できる。

internal モジュール内のどのソースからも参照できる。 一つのアプリ内定義やフレームワーク内の内部構造定義

private  自分のソースファイル内だけの参照に制限する。

その他[編集]

演算子オーバーロード[編集]

Swiftでは任意の型に対して、既存の演算子をオーバーロードして独自の振る舞いを定義することができる。
演算子オーバーロードは通常の関数定義とほとんど同じ形式で定義するが、前置演算子をオーバーロードする場合はprefix修飾子を、後置演算子の場合はpostfix修飾子を、それぞれfuncキーワードの前に付ける。複合代入演算子をオーバーロードする場合は、左辺の値を変更するため左辺の引数をin-out引数とする。
なお = -> . // /* */ は予約されておりオーバーロードしたりカスタム演算子(後述)として定義することはできない。

struct Vector2D {
    var x = 0.0
    var y = 0.0
}
 
func + (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
    return Vector2D(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
}
 
prefix func - (rhs: Vector2D) -> Vector2D {
    return Vector2D(x: -rhs.x, y: -rhs.y)
}
 
func += (inout lhs: Vector2D, rhs: Vector2D) {
    lhs = lhs + rhs
}
 
prefix func ++ (inout rhs: Vector2D) -> Vector2D {
    rhs += Vector2D(x: 1.0, y: 1.0)
    return rhs
}
 
let vec1 = Vector2D(x: 2.0, y: 3.0)
let vec2 = Vector2D(x: 5.0, y: 1.0)
let vec3 = vec1 + vec2    // {x 7.0, y 4.0}
var vec4 = -vec1          // {x -2.0, y -3.0}
vec4 += vec2              // {x 3.0, y -2.0}
++vec4                    // {x 4.0, y -1.0}

カスタム演算子[編集]

Swift標準の定義済み演算子(+*%など)の他に、全く新しい演算子を定義することができる。新しく定義したカスタム演算子は、標準の演算子と同じように演算子オーバーロードを実装できる。
カスタム演算子の定義はoperatorキーワードで行う。さらに、前置演算子ならprefix、後置演算子ならpostfix、中置演算子ならinfix修飾子をoperatorキーワードの前につける。
演算子名に使用できる記号は + - * / % = < > ! & | ^ ~ . 及び数学記号等の一部のユニコード文字の組み合わせに限られる。

// 前置カスタム演算子
prefix operator 演算子名 {}
 
// 後置カスタム演算子
postfix operator 演算子名 {}
 
// 中置カスタム演算子
infix operator 演算子名 { precedence 優先度 associativity 結合性 }

中置カスタム演算子を定義する場合、任意でその優先度結合性を定義できる。
優先度の定義はprecedenceキーワードに続けて、0から255の範囲の整数値で設定する。優先度の定義を省略した場合のデフォルト値は100である。
結合性の定義はassociativityキーワードに続けて、左結合ならleftキーワード、右結合ならrightキーワード、非結合ならnoneキーワードを記述する。結合性の定義を省略した場合のデフォルト値はnone(非結合)である。

// 中置演算子 ** を定義する
infix operator ** { precedence 155 associativity right }
 
// ** 演算子を Double型のべき乗として実装する
func ** (lhs: Double, rhs: Double) -> Double {
    return pow(lhs, rhs)
}
 
2 ** 3  // 8.0(2の3乗)
 
0.5 * 2 ** 3 ** 2  // 256.0
// **演算子は *演算子よりも優先順位が高く、右結合として定義したので
// この式は 0.5 * (2 ** (3 ** 2)) の意味となる

カリー化関数[編集]

カリー化関数(Curried Function)は、複数のパラメータを持つ関数 f(a,b)を1つのパラメータを持つ関数 F(a)->g(b) に分解して再定義したF関数の事を言う。
カリー化した後の評価は右から左へ行われる。 カリー化は一つの引数のみを取る複数の関数のラムダ計算等に必要な機能となる

func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}
 
func addTwoIntsCurried(a: Int) -> (Int -> Int) {
    func addTheOtherInt(b: Int) -> Int {
        return a + b
    }
    return addTheOtherInt
}
addTwoInts(4,5) //9
addTwoIntsCurried(4)(5) //9
let plusOne = addTwoIntsCurried(1) //plusOne は Int->Int の関数
plusOne(10) //11


メモリ管理(Automatic Reference Counting)[編集]

Swiftでは自動参照カウント(Automatic Reference Counting)ARC でアプリが使うメモリを追跡管理をする。
ARCはクラスインスタンスが使われなくなった時に自動的にそれが使っていたメモリを開放する。

cocoa とObjective-Cと一緒に使う[編集]

SwiftはcocoaObjective-Cをシームレスに使えるように設計されている。[6]
SwiftとObjective-Cの間はどちらのAPIからでもお互いに使う事が出来る。

モジュールとしてアクセス可能などんなObjective-Cフレームワーク(又はCライブラリ)でもSwiftに直接インポートできる。
Swift

import Foundation


初期化の例

OBJECTIVE-C

UITableView *myTableView = [[UITableView alloc] initWithFrame:CGRectZero style:UITableViewStyleGrouped];

Swift

let myTableView: UITableView = UITableView(frame: CGRectZero, style: .Grouped)



C言語APIとの互換[編集]

基本型[編集]

Cの型 Swift型
bool CBool
char, signed char CChar
unsigned char CUnsignedChar
short CShort
unsigned short CUnsignedShort
int CInt
unsigned int CUnsignedInt
long CLong
unsigned long CUnsignedLong
long long CLongLong
unsigned long long CUnsignedLongLong
wchar_t CWideChar
char16_t CChar16
char32_t CChar32
float CFloat
double CDouble

SwiftからLibcを呼ぶ例

puts("Hello from libc")
let fd = open("/tmp/scratch.txt", O_WRONLY|O_CREAT, 0o666)
 
if fd < 0 {
    perror("could not open /tmp/scratch.txt")
} else {
    let text = "Hello World"
    write(fd, text, strlen(text))
    close(fd)
}

出典[編集]

  1. ^ a b Lattner, Chris (2014年6月3日). “Chris Lattner's Homepage”. Chris Lattner. 2014年6月3日閲覧。 “I started work on the Swift Programming Language in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013 [...] drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.”
  2. ^ Building assert() in Swift, Part 2: __FILE__ and __LINE__ - Swift Blog -”. Apple Developer. 2014年9月26日閲覧。 “Swift borrows a clever feature from the D language: these identifiers expand to the location of the caller when evaluated in a default argument list.”
  3. ^ Williams, Owen (2014年6月2日). “Apple announces Swift, a new programming language for iOS”. The Next Web. 2014年6月2日閲覧。
  4. ^ Introducing Swift”. Apple. 2014年6月2日閲覧。
  5. ^ Cocoa向け コーディングガイドライン (PDF)”. Apple Inc.. 2014年6月13日閲覧。
  6. ^ Using Swift with Cocoa and Objective-C (HTML)”. Apple Inc.. 2014年9月2日閲覧。

外部リンク[編集]