LoginSignup
68
66

More than 5 years have passed since last update.

@kiyotaman(清田 史和 Fumikazu Kiyota)

The Swift Programming Language - The Basics をまとめる

Last updated at Posted at 2014-06-04

The Swift Programming Language をまとめるトップ

The Basics

変数(vairable)と定数(constant)がある
var と let をつかって宣言できる
tuple も追加。tuple によって、異なる型の値を一つにまとめて function 戻り値に設定することができる

もう一つ大きな特徴があって、 optional types 不在値？（the absence of a value）というのがあって、nil pointer と似ている
オプションを使うと、"valueが存在して、かつ、 x と同等" or "valueが存在しない" を評価できる
クラスだけでなくて、全型に対して使える
nil より安全に使える。Optionals のセクションで後述してある

この optinals は、 type safe 言語として代表的な例とのこと

Constants と Variables（定数と変数）

  • 定数：一度しか定義できない
  • 変数：後に別の値を代入することができる

Declearing Contants と Variables (定数と変数の宣言）

  • let を使って定数を宣言する
// myAppName という名前の新しい定数を宣言して、"SnapDish" という値を代入
// myAppName は変わらない値
let myAppName = "SnapDish"

var を使って変数を宣言する

// counter という名前の新しい変数を宣言して、0 という値を代入
// counter なので値を増やす事ができる
var counter = 0

// ,（カンマ区切りで）一度に定義することもできる
var x = 0.0, y = 0.0, z = 0.0

NOTE
代入する値に変更が無い場合は、常に let を使って constant（定数）として宣言する
値が変わる場合は、 var を使う
let で宣言した定数を変更しようとしたら、コンパイル時にエラーになる

Type Annotations（注釈を入れる）

Annotation（注釈、型説明とでも言うのか）を定数と変数に指定することができる
どんな型の値が代入されるのか明確に分かるようにできる

// 今宣言した変数 myMessage は String（文字列）
var myMessage: String
...
myMessage = "私のアプリはSnapDish"

myMessage に自由に文字列を代入することができるようになる

NOTE
初期値を代入する時点で型が定義されるので、初期値を代入するときは type annotation をしなくてもよい
初期値が無い場合、type annotation を使う時がある

Contstants と Variables の命名規則

// unicode charactr を使う事ができる
let π = 3.14159
let アプリの名前 = "SnapDish"

使えないものもある。説明は割愛。

Printing Contants と Variables (定数と変数の宣言）

println 関数を使って値を出力する事が出来る

let myAppName = "SnapDish"
println(myAppName)
// prints "SnapDish"
// Xcode を使っている場合、Console に出力される
// print()関数は、改行無しで出力

Comments（コメント）

Cとほとんど同じ

// これはコメントだよ
/* これもコメントだよ
これもコメントだよ */

Semicolons（セミコロン）

; セミコロンも一応使える。ただ、あまり使う必要はないかも
以下のようのステートメントを一行にしたい時などに使う事が可能

let cat = "ねこ"; println(cat)
// prints "ねこ"

Integer（整数）

unsigned だったり 8, 16, 32, 64 bit によっても型がある。Cの命名規則に近い
例えば 8-bit unsigned と UInt8　、32-bit signed だと Int32
整数タイプの名前は大文字で始まる

Integer Bounds（整数の境界）

// 8-bit unsigned の整数最小値 0 を代入
let mixValue = UInt8.min
// 8-bit unsigned の整数最大値 255 を代入
let maxValue = UInt8.max

Int型

普段は基本的に、サイズを気にする必要はない
サイズを指定する必要がある場合を除き Int を使えうとよい
32-bit platform でも、-2,147,483,648 〜 2,147,483,647 と十分なサイズ

  • 32-bit platform の時 Int は Int32 と同じ
  • 64-bit platform の時 Int は Int64 と同じ

UInt型

UInt型もある
unsigned を指定したいときに使う

  • 32-bit platform の時 UInt は UInt32 と同じ
  • 64-bit platform の時 UInt は UInt64 と同じ

Floating-Point 数

Swift は、二種類の Floating-Point を提供する

  • Double は 64-bit floating-point number
  • Float は 32-bit floating-poing number

Type Safety と Type inference

Swift は type safe の言語で、型を明確にすることでコードを精度を高める
String に Int を代入するだの間違いを未然に防げる

type safe はコンパイル時に type のチェックをして compile time error を投げる
開発時に問題を特定して見つける事ができるようになる

とは言え、必ず型を指定する必要は無く、type inference（型推論）を使って適切な型を選んでくれる
代入する値を調べて適切な型をコンパイル時に選ぶ

let 整数 = 42 // Int 型と推論する

let pi = 3.14159 // Double と推論する

let anotherPi = 3 + 0.14159 // Doublue と推論する
// "3" は特定の型自体をもっていないので、最終的なアウトプットが Double と推論される

Numeric Literals（数字リテラル）

  • 十進数 プリフィックスなし
  • バイナリ（binary） 0b で始まる
  • 八進数（octal） 0o で始まる
  • 十六進数（hexademcimal）0x で始まる
// 値が十進数（decimal）17 の時
let decimalInteger = 17 // 十進数
let binaryInteger = 0b10001 // バイナリ
let octalInteger = 0o21 // 八進数
let hexadecimalInteger = 0x11 // 十六進数

大文字もしくは小文字の e と p も使える
* 1.25e2 は 1.25 x 102, or 125.0
* 1.25e-2 は 1.25 x 10-2, or 0.0125
* 0xFp2 は 15 x 22, or 60.0
* 0xFp-2 は 15 x 2-2, or 3.75

などなど

Numeric Type Conversion（数値型の変換）

基本的には、 Int を使うが、厳密にサイズを操作したい時などに必要。

例えば

let ネガティブはだめよ: UInt8 = -1
// エラーを返す

let 大きすぎるよ: Int8 = Int8.max + 1
// こちらもエラーを返す

let 二千: UInt16 = 2000
let 一: Uint8 = 1
let 二千と一 = 二千 + UInt16(一)
// 定数 "二千と一" は、UInt16 の定数を足したので、UInt16 と推論される

数値型(値）で型を初期化して新たに定義をし直す為の手法

その他の例

let three = 3
let pointOneFourOneFiveNice = 0.14159
let pi = Double(three) + pointOneFourOneFiveNice
// pi は Double と推論される

let integerPi = Int(pi)
// integerPi == 3 になる
// Int(4.75) は 4、Int(-3.9) は、-3

NOTE
リテラルと定数や変数で型の変換は多少違う
let pi = 3 + 0.14159 とした場合、Double になる
リテラルは明確な型指定が無いので、type inference （型推論）を作動して適切な型を推論し定義する

Type Aliases （エイリアス型指定）

型エイリアスを使うと自分で型名をつくることができ、可読性を高めるのに便利
また、外部の決まったサイズのデータなど扱う時など便利
※モデル部分で使うと良いのかな？

typealias AudioSample = UInt16
var maxAmplitudeFond = AudoSample.min
// maxAmplitudeFound は 0

Booleans （ブーリアン型）

let イチゴは赤い = true
let イチゴは青い = false

if イチゴは赤い {
   println("イチゴは赤いよ！")
}

if イチゴは青い {
   println("イチゴは青くない！")
}

let i = 1
if i {
    // エラーになるよ！
}

let i = 1
if i == 1 {
    // エラーにならないよ！
}

Tuples（タプル）

Tuples（タプル）は複数の値を一つの混合値として扱う事ができる
タプルの値には、異なる型の値を代入することが出来る

let http404Error = (404, "Not Found!")
// http404Error は (Int, String) の型を格納していて、値は、(404, "Not Found!")

上記は、 (Int, String)型のタプル と説明できる

例えば

  • 分解してそれぞれに代入することができる
let (statusCode, statusMessage = http404Error
println("ステータスコードは \(statusCode)")
println("ステータスメッセージは \(statusMessage)")
  • _ (アンダースコア）を使うと、その部分を無視して値を代入できる
let (ステータスコードだけ, _) = http404Error
println("ステータスコードは、\(ステータスコードだけ)")

  • index 番号を使うこともできる
    swift
    println("ステータスコードは、\(http404Error.0)")
    println("ステータスメッセージは、\(http404Error.1)")

  • それぞれのエレメントに命名も出来る

let http200Status = (statusCode: 200, description: "OK")
println("ステータスコードは、 \(http200Status.statusCode)")
println("ステータスメッセージは、 \(http200Status.description)")
  • 関数の戻り値としても使える。()を使って戻り値のエレメントを分解して代入することができ便利。

NOTE
タプルは一次てきにデータをグルーピングするのには向いているが、複雑なデータ構造を扱うのには向いていない
その場合、クラスや構造体を使ってモデルをつくるほうが望ましい

Optionals（オプショナル）

値が存在しているかしていないかを判断したりするもの（例をみたほうが良いかも）

例えば

以下のように、"123" 数字の文字列が入っているかもしれない、"数字が入っているかも" 定数を toInt メソッドを使って整数に変換する処理をした場合、 "123" 数字が入っていない場合がある

let 数字が入っているかも = "123"
let 整数に変換した値 = 数字が入っているかも.toInt()
// "整数に変換した値" は Int型と推論されるが、何も無い場合もあり、それが "Optional Int"
  • toInt()メソッドが、数字以外の場合だったら失敗する事もあるので、 optional Int として Int の変わりに返す
  • optional Int は、 Int? と記述することができる
  • "?" クエスチョンマークを使うと、上記の場合 Int か"何も無い"かのどちらか

If Statement and Fourced Unwarpping

If文を使って、オプショナルが値を持っているか、値があれば、 true と評価し、値が存在しない場合、 false を返す

オプショナルが値を保持している場合、 ! エクスクラメーションマークをオプショナルの名前の最後につけると、値があると見なし強制的に解除する
! を使う側で安全性を担保する必要がある

let 数字が入っているかも = "123"
let 整数に変換した値 = 数字が入っているかも.toInt()
if 整数に変換した値 {
    printlne("\(数字が入っているかも) は、\(整数に変換した値!) である")

} else {
    printlne("\(数字が入っているかも) の変換に失敗")

}

NOTE
! を使う時は、必ず optional に値が入っている事を確認するべき
値が無いとものに ! を付けるとエラーになる

Optional Binding

Optional Binding はオプショナルが値がある無いかを評価して、ある場合、Constant or Vairable 値を定義する
if や while 文で利用する事ができ、オプショナルがあれば、定数や変数を一時的に定義をする

if let constantName = someOptional {
   // statements
}

let possibleNumber = "123"
if let actualNumber = possibleNumber.toInt() {
    // possbleNumber は actualNumber 整数を持っている 
} else {
    // possbleNumber は整数に変換できなかった

}

この辺りの詳細は別のセクションで行いたい

nil

nilという特殊な値無しを設定する時

var serverResponseCode: Int? = 404
// serverResponseCode は 404整数を保持している
serverResponseCode = nil
// serverResponseCode は値無しなる

NOTE
nil はオプショナルでない定数 or 変数に利用できない
存在しない値を利用する場合、適切な型のオプショナルバリューとして宣言する必要がある

以下のように、宣言だけした場合、自動的に nil がセットされる

var surveyAnswer: String?
// surveyAnswer に nil が自動的にセットされる

NOTE
Swift の nil は、ObjC の nil とは違い、nil はポインターではなく、ある型の存在しない値
どんな型でも nil をセットすることができる

Implicitly Unwrapped Optionals

ここまで説明したように、オプショナルは "no value" を保持することができる
if文で存在を評価することもできる、などなど

  • 詳しくは別のセクションで

例えば

let possibleString: String? = "A optional string"
println(possibleString!) // (!) を使ってその値にアクセスする
// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optinal strings."
println(assumedString) // (!) を使わず、値にアクセスできる
// prints "An implicitly unwrapped optional string."

NOTE
Implicitly Unwrapped optional を使い、値を保持していない場合 runtime error が起こるの注意が必要

  • この辺りも別のセクションで、(!)が必要な理由なども含めて別途まとめる、結構重要な個所

Assertions（アサーション）

アサーションを使ってデバッグを効率的に行う事ができる
assert 関数を用いて、true or false と メッセージを使って表示させることができる

let age = -3
assert(age >= 0, "年齢は必ず0歳以上")
// assert(age >= 0) とも書く事ができる
68
66
4

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
68
66