はじめに
某プログラミング学習サイトの学習記録を記します。
共通操作
・範囲選択：Shiftを押しながらクリック
・複数行コメントアウト：Command /
01
・Xcodeでplaygraoundを新規作成する
・種類はBlankを選ぶ (他にはGame, Map, Single Viewがある)
02
・下記について、C言語と同じ
・コメント
・print関数
・文字列を""で囲むこと
・文末が;であること
・実行形式の選択は、□または△を長押しすることで変更できる
短く押すと実行される。
・右ペインに実行結果が表示される
03：変数と定数
・変数：var
・定数：let
・例
let msg:String; // 文字列型の定数msgを宣言
msg = "hello"; // msgに"hello"を代入
let msg = "hello"; // 型推論が行われmsgは文字列型となる
※：C言語と違い、
04：データ型
・下記はC言語と同じ
・Int：整数型
・Float, Double
・キャスト(型変換)
・Bool型：true / false
05：演算
・下記はC言語と同じ
・四則演算
・単項演算子(+=, *= /= -=)
・論理演算(&&, ||, !)
・文字列
・+で連結 "hello " + "world" → "hello world"
・()で数値を文字に変換できる。()の中で演算できる。
(例) 変数yが15の時
"y is (y)" → "y is 15"
"2*y is (2*y)" → "2*y is 30"
06：分岐
・下記はC言語と同じ
・分岐(if, else, if else)
・比較(>, >=, <=, ==, !=)
・条件演算子(条件文 ? 真 : 偽)
07：switch
・switchの構文はC言語と同じ
・default, breakもC言語と同じ
・caseの作り方
・単一： (例) case 0:
・複数： (例) case 1, 2, 3:
・範囲： (例) case 4...6:
・範囲： (例) case 7..<9: 9を含まない
・比較： (例) case let n where n > 20; 20超の場合
08：while
・whileの構文はCと同じ
・C言語のdo whileと同じ機能が repeat whileで実現される
repeat {
実行文;
} while (条件)
09：for
・構文 for 変数 in データ範囲 {処理}
・例 for i in 0...5 {print(i); }
・break, continueはC言語と同じ。
10：オプショナル型
・nil：空白の値
・nilを代入可能とするには、Optinal型とする必要がある
(例) let s:String = nil; // ×
(例) let s:Optinal = nil; // ○
(例) let s:String? = nil; // ○
・nilの判定
(例)if (s != nil) {
print(s!); // unwrap
}
・unwrap：変数の後ろに!を付けてOptinal型から値を取り出すこと
・Optinal Binding：unwrapを行う別の方法
(例) if let value = s { 処理}
sがnilでない場合だけunwrapしてvalueに代入する
・さらに別の方法
(例) print(s ?? "this is nnil");
sがnilでなければsを、nilであれば文字列を表示する
11：配列
・データの型を[]で囲う
(例) var scores:[Int] = [50, 40]; // 型を指定
(例) var scores2 = [50, 40]; // 型推論して省略
・配列の要素を制御する
(例) score[0] = 30;
・配列の要素数を数える：count関数
(例) score.count
・配列が空かどうかを調べる：isEmpty関数
(例) score.isEmpty
・空の配列を作成する
(例) var names = String;
・末尾への要素追加
(例) names.append = "abc";
(例) names += ["def"];
12：タプル(異なる型のデータを扱える)
・(例) var items = ("apple", 5):
・(例) 読出：print(items.0);
・(例) 書込；items.1 = 3;
・変数名を宣言する
(例) var items = ("apple", 5);
let (product, amount) = items;
・一部だけを変数宣言する
(例) var items = ("apple", 5);
let (product, _) = items;
・初期化時に名前を付ける
(例) var items = (product:"apple", amount:5);
print(items.product);
13：集合
・集合は、順序を持たず、値の重複を許さない
・宣言方法
(例) var winners:Set = [3, 5, 8, 8];
(例) var winners:Set = [3, 5, 8, 8]; // 型推論
print(winners); // [3, 5, 8]
・データを含むか判定する
(例) winners.contais(3); // 3を含むならtrueを返す
・データを追加
(例) winners.insert(10); // 10を追加
・データを削除
(例) winners.remove(5); // 5を削除
・データ数を数える
(例) winners.count; // データ数を返す
・空集合の作成
(例) let s = Set();
print(s.isEmpty); // trueを返す
・演算
(例) let a:Set = [1, 3, 5, 8]
let b:Set = [3, 5, 8, 9]
print(a.union(b)); // 和集合：[5,8,3,1,9]を返す
print(a.intersection(b)) // 直積 ：[5,3,8]を返す
print(a.subtracting(b)); // 差 ：[1]を返す
14：辞書(キーと値で管理するデータ)
・(例)キーが文字列、値が整数の場合
var sales:Dictionary = ["MrA":300, "MrB":400]
var sales = ["MrA":300, "MrB":400]; // 型推論
・値の代入
(例) sales["MrB"] = 500;
・値の取出し
(例) print("sales["MrB"] ?? "n.a.") // MrBが存在しなければ"n.a."
// キーに対する値が存在しない場合はOptional型のnilが返ってくる
・データの追加
(例) sales["MrC"] = 100; // MrCを追加(代入と同じ)
・データ数を数える
(例) print(sales.count)
・一覧を出力
(例) for (key, value) in sales {
print("(key):(value)")
}
・空の辞書を作成する
(例) let d = String:Int; // キー：String, 値：Intの空の辞書
print(d.isEmpty); // trueを返す
15：関数
・引数と戻り値がなければC言語と同じ
・戻り値がある場合
(例)
func sayHi() -> String { // 文字列を返す関数の宣言
return "hi" // 戻り値
}
print(sayHi()); // 戻り値を印字
16：引数
・関数名の後に(変数名：型)の形式で指定する
(例) func sayHi(name: String) {
print("hi (name)")
}
sayHi(name: "A") // 結果："hi A"
・変数名にラベルを付けることで、宣言時と違う変数名で実行する
(例) func sayHi(from name: String) { // 変数nameにfromというラベルを付ける
print("hi (name)")
}
sayHi(from: "B") // 結果："hi B"
・変数名のラベルを省略する
(例) func sayHi(_ name: String) {
print("hi (name)")
}
sayHi("C") // 結果："hi C"
・変数の初期値を決める
(例) func sayHi(_ name: String = "D") {
print("hi (name)")
}
sayHi() // 結果："hi D", 引数は初期値を使用する
17：inoutキーワード
・引数を渡す際、アドレスを渡す場合にinoutキーワードが必要になる
(例)
func add10(x:inout Int) { // アドレス渡し
x = x + 10; // inoutキーワードがなければエラーとなる
print(x)
}
var i = 10;
add10(x : &i); // アドレス渡し
print(i); // 20
18：class
・宣言
(例) class User { // classの宣言
let name:String 1/ propertyの定義
var score:Int
init() { // propertyの初期化
self.name = "me" // selfを使って代入
self.score = 20
}
}
・インスタンス化して利用
(例)
let user:User = User(); // クラスUserのインスタンスuserを定義して初期値代入
print(user.name); // インスタンスuserのnameを印字
19：イニシャライザ
・インスタンス毎に違う値を持たせる
(例) class User {
let name:String;
var score:Int
init (name:String, score:Int) { // 引数：String型のnameとInt型のScore
self.name = name; // 引数nameをclassのnameに代入
self.score = score;
}
}
let tom = User(name:"tom", score:20);
print(tom.name); // 結果：tom
print(tom.score); // 結果：20
・変数名を省略
イニシャライザ：init(_ name :String, _ score:Int)
インスタンス化：let tom = User("tom", 23);
・引数が渡されなかったときのイニシャライザを作成
(例) class User {
let name:String;
var score:Int
init (name:String, score:Int) {
self.name = name; // 引数nameをclassのnameに代入
self.score = score;
}
init () { // 引数を指定しない場合のイニシャライザ
self.name = "no name"; // 引数nameをclassのnameに代入
self.score = 0;
}
}
let noname = User(); // 引数を指定しない
print(noname.name); // "no name"
print(noname.score
20：計算プロパティ(動的に計算可能なプロパティ)
・クラス内の変数にはget関数とset関数を追加できる
(例)
class User {
let name:String;
var score:Int
var level:Int {
get {
return Int(self.score/10) // levelの取得時、scoreの1/10を返す
// return Int(score/10) // 自明な場合は、selfを省略可能
}
set {
if newValue >= 0 { // 値をnewValueで受け取る
score = newValue * 5; // 5倍してscoreに入力する
}
}
}
// 戻り値だけの場合(getだけ)の場合の記述方法
//var Int {
// return Int(score/10);
//}
let u = User("MrA", 2);
u.level = 5;
print(u.score) // 結果：50
21：プロパティの値の変化前後
・willSet関数で変化前、didSet関数で変化後を監視できる
・(例)
class User {
var score:Int {
willSet { // 変化前
print("(score) -> (newValue)")
}
didSet { // 変化後
print("Changed: (score - oldValue)")
}
}
let tom = User("tom", 2)
tom.score = 53 // "2 -> 53, Changed:51
tom.score = 20 // "53 -> 20, changed:-33
22：メソッド
・func 関数名(引数)
・例
class User {
let name:String
var score:Int
init(_ name : String, _ score:Int) {
self.name = name;
self.score = score;
}
func sayHi(_ msg:String) { // データ型の省略ｆｓ
print("(msg) (name)")
}
}
let tom = User("tom", 2)
tom.sayHi("hola"); // 結果："hola tom"
23：クラスの継承
// 親クラス(スーパークラス)
Class User {
let name:String;
var score :Int;
init(_ name:String, _ score:Int) {
self.name = name;
self.score = score;
}
func sayHi() { // overrideを禁止したい場合は、「final func 関数名」とする
print("hi (name)")
}
}
// 子クラス(サブクラス)
class AdminUser:User { // class 子クラス名：親クラス名
func sayHello() {
print("hello (name)")
}
override func sayHi() { // override：親クラスのメソッドを上書き
print("admin hi (name)")
}
}
let tom = User("tom", 23);
let bob = AdminUser("bob", 30);
print(bob.name); // 結果：bob
print(bob.score); // 結果：30
bob.sayHi(); // 結果：admin hi bob
bob.sayHello(); // 結果：hello bob
24：型プロパティ、型メソッド
・インスタンスではなく、クラスに直接関連するプロパティやメソッドはstaticを先頭に付ける
・(例)
Class User {
let name:String;
var score:Int;
static var count = 0; // クラスから直接扱う
init(_ name:Stirng, _ score:Int) {
self.name = name;
self.score = score;
User.count += 1; // イニシャライザはインスタンスから呼ばれるので、型プロパティへのアクセスにはクラス名を付ける
}
class func getInfo() {
// static funcにするとoverrideを禁止できる
print("(count) instances);
}
class AdminUser:User {
override class func getInfo() {
print("admin (count) instances")
}
}
User.getInfo(); // 結果：0
let a = User("a", 1);
User.getInfo(); // 結果：1
AdminUser.getInfo(); // 結果：1
let b = AdminUser("b", 2);
AdminUser.getInfo(); // 結果：2
25：型キャスト
・(例)
class User {
let name : String;
init(_ name : String) {
self.name = name;
}
}
class AdminUser : User{}
let tom = User("tom")
let bob = AdminUser("bob")
// 配列として扱う
let users:[User] = [tom, bob];
// 「:[User]」は記述しなくても型推論してくれる
// 親子クラスのため同じ種類として扱ってくれる
for user in users {
// AdminUserの場合だけ表示する(1)
if let u = user as? AdminUser // 「as?」で一語(スペース挿入禁止)
// as?で変換可能か調べる。失敗ならnilが返ってくる
// optional bindingを使う
// 成功時はAdminUser型のuserがuに代入される
print(u.name); // 結果：bob
}
// AdminUserの場合だけ表示する(2)
if user is AdminUser { // userがAdminUser型であるか確かめる
let u = user as! AdminUser // as!でunwarpしてくれる
// AdminUser型のuserが返ってくる
print(u.name); // 結果：bob
}
}
// unwrap：optional型からデータを取り出すこと
// optional型：nilを格納できる型
// optional Binding：値がnilで内場合だけ値を取り出す
#26：プロトコル
・クラスに対して、実装が必須なプロパティやメソッドを定義する
・(例)
protocol Printable { // プロトコル定義
var type:String { get } // 読み取り専用
var count:Int {get set} // 読み書き可能
func printout() // 実装はクラスで行うので定義は不要
// イニシャライザは不要
}
class User:Printable {
let type = "Laser"
let count = 0;
let name:String;
init(_ name:String) {
self.name = name
}
func printout() {
count += 1;
print("(type) : (count)")
}
}
let a = User("a")
a.printout(); // 結果「Laser:1」
a.printout(); // 結果「Laser:2」
a.printout(); // 結果「Laser:3」
a.printout(); // 結果「Laser:4」
27:エクステンションによる拡張
・既存の型に新しいプロパティやメソッドを追加する
・(例)
// String型を拡張し、文字列長を返す変数を追加する
extension String { // String型を拡張
var length :Int { // lengthという変数を追加
return self.characters.count // プロパティの一つであるcountを返す
}
}
let msg = "hello"
print(msg.characters.count) // String型の元々の文字列長の取得
print(msg.length); // 新規に追加したlength変数による文字列長の取得
(例)
protocol Printable { // Printableのプロトコル(実装必須関数の定義)
func printout()
}
extension Printable { // 既存のPrintableに
func printout() { // 関数printoutを追加
print("printing)
}
}
// PrintableをUserクラスに適合させる
class User:Printable { // Printableのインスタンス
let name:String
init(_ name:String) {
self.name = name;
}
} // インスタンス内にprintout関数の実装が不要
let tom = User("tom")
tom.printout()
28：参照型と値型
・Int, doubleなどは値型
・Classは参照型
(例)
class User {
var name:String;
init(_ name:String) {
self.name = name;
}
}
var org = User("A)
var copy = org;
org.name = "B"
print(org.name) // 結果：B
print(copy.name) // 結果：B
29：構造体
・classと、ほぼ同じ機能を持つ。
・classが参照型であるのに対して構造体は値型である。
・classと違って継承が出来ない
・extension, protocolは使える
・メソッドでプロパティを変更するには、funcの前にmutatingを付ける
30：：列挙型
・enum (型名) {
case 値1
case 値2
}
・例
enum Direction :Int {
case right = 1
case left = -1
}
print(Direction.rihgt.rawValue); // 値を取り出す
var dir:Direction
dir = .right // Direction.rightの省略形
switch (dir) {
case .right: print("right");
case .left: print("left");
}
31：ジェネリクス型
・データ型を汎用化させる
関数名の後にを追加し、データ型をTとする。
・func getData(x:Int) { // 通常の書き方
・func getData(x:T) { // ジェネリクス型を使用
print(x)
}
getData(x:"Hello") // 結果："Hello"
getData(x:2.3) // 結果："2.3"
32：サブスクリプト
・サブスクリプト：インスタンスに対して、配列と同じようにインデックスを付ける
class Teams {
var memvers = ["A", "B", "C"]; // サブスクリプトのアクセス対象のデータを用意
subscript (index : Int) -> String { // indexに使う値の型と返値の型を指定
get { // サブスクリプトで取得する時の処理
return members[index]
}
set { // サブスクリプトで設定する時の処理
members.insert(newValue, at:index) // 設定値をnewValueで取得できる
}
}
}
var t = Team()
print(t[1]) // 結果："B"
t[3] = "D"
print(t[3]) // 結果："D"
33:guard
・異常処理を分かりやすく書くための仕組み
・guardを使わない書き方
func test(_ msg:String?) { // StringのOptional型
if let s = msg { // nil判定
print(s)
} else {
print("nil")
}
}
・early return , early exitを使用する
func test(_ msg:String?) {
if msg == nil {
print("nil")
return
}
print(msg!) // unwrapする
}
・guardを使う
func test(_ msg:String?) {
// msgがnilでなければsに代入、sならelse以下を処理する
guard let s = msg else {
print("nil")
return // guardの中では、returnを忘れるとエラーを出してくれる
}
print(s)
}
34：例外処理
// 例外の種類を列挙型で定義
enum LoginError:Error { // プロトコルを使用する
case emptyName
case shortName
}
class User {
let name:String
init(_ name:String) {
self.name = name
}
// 例外が発生する可能性がある場合は関数名の後にthrowsを付ける
func login() throws {
// nameが空でないときは無処理。空の時の処理を定義する
guard name != "" else {
throw LoginError.emptyName // 例外を投げる
}
guard name.count > 5 else {
throw LoginError.shortName
}
print("success")
}
}
let a = User("AAAAA") // 結果：short
let a = User("AAAAAA") // 結果：Success
let a = User(") // 結果：enter
// 例外が発生するときの書法
do {
try a.login()
} catch LoginError.emptyName {
print("enter")
} catch LoginError.shortName {
print("short")
}
35：Optional Chaining
・Optinal型が連続する場合に安全にnilチェックする
class User {
var name:String? = "" // nameがoptional型の場合
}
let user:User? // Userがoptional型の場合(Optional型を短く宣言する)
user = User()
user?.name = "a" // ※1
if let s = user?.name?.uppercased() { // ※1 ※2
print(s)
}
// ※1：Optional Chaining:optional変数の後に?を付ける。
// nilの場合はnilを、nilでなければその値を含むOptional型を返す
// ※2：Optional Binding
36：暗黙的アンラップオプショナル (Implicity Unwarpped Optional)
・通常のOptinal型
var msg:String? // Optional型(nilを取ることができる)
msg = "a"
if msg != nil { // nilチェック
print(msg!) // Optional型をUnwap
}
・暗黙的アンラップオプショナル(UnWrap不要)
var msg:String! // 末尾を「?」ではなく「!」にする
msg = "a"
print(msg) // Unwrap不要(末尾の「!」不要)