refirio.org

Memo

■基本の文法

※基本的にPlaygroundsで試したもの

■コメント// これは一行のコメントです

/*
 * これは複数行のコメントです
 */
■デバッグ// デバッグ用の出力
print("TEST")

let greeting1 = "おはよう"
let greeting2 = "こんにちは"
let greeting3 = "こんばんは"

// デバッグ用の出力
print(greeting1, greeting2, greeting3, separator: "/")
■ステートメント// 命令文の区切りは改行もしくはセミコロン
let number1 = 1 + 2 + 3
print(number1)

// 改行やスペースは原則無視される
let number2
    = 1
        + 2
        + 3
print(number2)
■特殊なキーワードprint("現在のファイル名: ", #file)
print("現在の行数: ", #line)
print("現在のカラム数: ", #column)
print("現在のメソッド・関数名: ", #function)
■変数// 定数を宣言
let name1: String
let width1: Int, height1: Int

name1 = "山田"
width1 = 56
height1 = 75

// 定数を宣言（型推論）
let name2 = "山田"
let width2 = 56, height2 = 75

// 変数を宣言
var name3: String
var width3: Int, height3: Int

name3 = "山田"
width3 = 56
height3 = 75

// 変数を宣言（型推論）
var name4 = "山田"
var width4 = 56, height4 = 75
■タプル// タプルを宣言
let product: (String, Int)
product = ("Swift", 2014)

// タプル（型推論）
let guest = ("山田", "やまだ", 18)

// タプル（値の取得）
print(guest.0, guest.1)

let (guest_name, _, guest_age) = guest
print(guest_name, guest_age)

// タプル（ラベル）
let book = (name: "Xcode", price: 2200)
print(book.name, book.price)
■演算// 演算子
let a = 1 + 3 * 2
let b = 10 / (4 - 2)
let c = 10 % 3
print(a, b, c)

// 三項演算子
let bigger = a > b ? a : b
print(bigger)

// 型変換
let price = 2200
let tax = 0.08
let total = Double(price) + Double(price) * tax
■条件分岐if a >= 10 {
    print("aは10以上です")
} else if a >= 5 {
    print("aは9より小さく5以上です")
} else {
    print("aは5より小さいです")
}

if a >= 5, b >= 5 {
    print("aとbは5以上です")
}

switch a {
case (10 ... 20):
    print("aは10以上20以下です")
case (0 ... 9):
    print("aは0以上9以下です")
default:
    print("条件に一致しません")
}
■繰り返しfor num in 5...9 {
    print(num)
}

for num in stride(from: 10, to: 30, by: 3) {
    print(num)
}

var power = 0
while power < 10 {
    power += 3
}
print(power)

repeat {
    power += 3
    print(power)
    
} while (power < 20)
■関数// 戻り値のない関数
func hello() {
    print("ハロー")
}
/*
// 戻り値が無いことを明示
func hello() -> Void {
    print("ハロー")
}
*/
hello()

// 戻り値のある関数
func dice() -> Int {
    let number = 1 + arc4random_uniform(6)
    return Int(number)
}
print(dice())

// 引数のある関数
func price(price: Int, number: Int) -> Int {
    let total = price * number
    return total
}
print(price(price: 1200, number: 3))

// 引数を省略できる関数
func tax_included_price(price: Int, number: Int, tax: Double = 0.08) -> Int {
    let total_price = price * number
    let tax_price = Double(total) * tax
    return total_price + Int(tax_price)
}
print(tax_included_price(price: 1200, number: 3))

// 引数の数を固定しない関数
func sum(numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}
let number = sum(numbers: 2, 4, 6, 8)
print(number)

// 複数の戻り値がある関数（タプル）
func getResult(test1: Int, test2: Int, test3: Int) -> (total: Int, average: Double) {
    let total = test1 + test2 + test3
    let average = Double(total) / 3
    return (total, average)
}
let result = getResult(test1: 10, test2: 20, test3: 30)
print(result.total, result.average)

// 関数の多重定義（オーバーロード）
func calc(a: Int, b: Int) -> Int {
    return a + b
}
func calc(c: Int, d: Int) -> Int {
    return a - b
}
func calc(a: Int, b: Int, c: Int) -> Int {
    return (a + b) * c
}
func calc(a: Double, b: Double) -> Double {
    return a / b
}
let ans1 = calc(a: 2, b: 3)
let ans2 = calc(c: 2, d: 3)
let ans3 = calc(a: 2, b: 3, c: 4)
let ans4 = calc(a: 2.0, b: 3.0)

print(ans1)
print(ans2)
print(ans3)
print(ans4)

// 外部引数名を付けた関数
func bmi(weight kg: Double, height cm: Double) -> Double {
    if cm == 0 {
        return -1
    }

    // 体重を身長の2乗で割る
    var result = kg / pow(cm * 0.01, 2)
    // 小数点以下1位で四捨五入する
    result = round(result * 10) / 10.0

    return result
}
let mybmi = bmi(weight: 56, height: 172.5)
print(mybmi)

// 引数名なしで値だけを指定できる関数
func triangleArea(_ width: Double, _ height: Double) -> Double {
    let result = width * height / 2
    return result
}
let area = triangleArea(30, 16.5)
■文字列// 文字列
let message1 = "こんにちは"

let message2 = String("さようなら")

var message3: String
message3 = "こんばんは"

let message4 = """
こんにちは。
今日はいい天気ですね。
"""

print(message1.count)
print("挨拶「\(message1)」の文字数は「\(message1.count)」です。")

print(message1 + message2)

// 文字列と数値の変換
let convert1: String = "123"
let convert2: Int = 456

let convert3 = Int(convert1)! + convert2
print(convert3)

let convert4 = convert1 + String(convert2)
print(convert4)

// 文字列の比較
let string1 = "iOS16"
let string2 = "ios16"

if string1 == string2 {
    print("string1とstring2は同じです。")
} else {
    print("string1とstring2は同じではありません。")
}

if string1.lowercased() == string2.lowercased() {
    print("string1とstring2は同じです。")
} else {
    print("string1とstring2は同じではありません。")
}

// 文字列のパターンマッチ
let string3 = "iOS16"

if string3.hasPrefix("i") {
    print("string1は「i」から始まります。")
}
if string3.hasSuffix("16") {
    print("string1は「OS」で終わります。")
}
if string3.contains("OS") {
    print("string1には「iOS」が含まれています。")
}
■配列// 配列を宣言
var strArray1: [String] = []
var intArray1 = [Int]()
var doubleArray1 = Array<Double>()

strArray1 = ["a", "b", "c"]
intArray1 = [1, 2, 3]
doubleArray1 = [0.1, 0.2, 0.3]

// 配列を宣言（型推論）
var strArray2 = ["a", "b", "c"]
var intArray2 = [1, 2, 3]
var doubleArray2 = [0.1, 0.2, 0.3]
var boolArray2 = [true, false, true]
var tupleArray2 = [(1, 2), (10, 20), (100, 200), ]

// 配列の操作
var intArray = [Int]()

if intArray.isEmpty {
    print("intArray3は空の配列です。")
}

intArray = [1, 2, 3]

print(intArray.count)

intArray = [Int](repeating: 0, count: 5)

print(intArray)

intArray = [Int](-3...5)

print(intArray)

intArray += [6, 7]

print(intArray)

// 配列からの取り出し
print(intArray[0])
print(intArray[1])
print(intArray[2...6])
print(intArray.first!)
print(intArray.last!)
print(intArray.firstIndex(of: 2)!)

// 配列への値追加と値削除
intArray.append(8)
intArray.append(contentsOf: [9, 10])
intArray.remove(at: 1)

print(intArray)
■辞書// 辞書を宣言
var sizeTable = Dictionary<String, Int>()
var userDic = [String: String]()
var pointDic = [String: (Int, Int)]()

sizeTable = ["S": 47, "M": 52, "L": 55]
userDic = ["Taro": "B", "Hanako": "A", "Kenta": "B"]
pointDic = ["p1": (10,30), "p2": (30,50), "p3": (20,40)]

// 辞書を宣言（型推論）
let resultDic = ["A": true, "B": false, "C": true]

// 辞書の操作
var prefCode = ["東京都": 13, "大阪府": 27, "福岡県": 40]
if prefCode.isEmpty {
    print("prefCodeは空です。")
} else {
    let num = prefCode.count
    print("prefCodeの要素は\(num)個です。")
}

prefCode.removeValue(forKey: "福岡県")

print(prefCode)

let data = (key: "大阪府", value: 27)
if prefCode.keys.contains(data.key) {
    print("含まれています。")
} else {
    print("含まれていません。")
}

// 辞書からの取り出し
print(String(prefCode["東京都"]!))

// 辞書への値追加と値削除
prefCode["北海道"] = 1
prefCode["青森県"] = 2

print(prefCode)

for code in prefCode {
    print(code)
}

for code in prefCode.keys {
    print(code)
}

for code in prefCode.values {
    print(code)
}

prefCode.removeAll()

print(prefCode)
■セット// セットの宣言
let aSet: Set<String> = ["リンゴ", "みかん", "桃", "イチゴ"]
let bSet: Set<String> = ["イチゴ", "スイカ", "みかん", "バナナ"]

// aSetとbSetの要素を合わせたセット
let cSet = aSet.union(bSet)
print(cSet)

// aSetとbSetの共通した要素のセット
let dSet = aSet.intersection(bSet)
print(dSet)

// aSetからbSetの要素を取り除いたセット
let eSet = aSet.subtracting(bSet)
print(eSet)

// aSetとbSetの一方のみに含まれている要素のセット
let fSet = aSet.symmetricDifference(bSet)
print(fSet)

// セットの比較
if aSet == bSet {
    print("セットの持つ要素は同じです")
} else {
    print("セットの持つ要素は同じではありません")
}

if aSet.isDisjoint(with: bSet) {
    print("セットに共通した値はありません")
} else {
    print("セットに共通した値はあります")
}

if aSet.isSubset(of: bSet) {
    print("aSetはbSetに含まれています")
} else {
    print("aSetはbSetに含まれていません")
}

if aSet.isSuperset(of: bSet) {
    print("aSetはbSetを含んでいます")
} else {
    print("aSetはbSetを含んでいません")
}
■オプショナルlet nums = [2, 4, 6]
let lastNum = nums.last
//let ans1 = lastNum * 2
let ansNum1 = lastNum! * 2
print(ansNum1)

let ansNum2 = lastNum ?? 0
print(ansNum2)

if let ansNum3 = lastNum {
    print(ansNum3)
}
■クラス// 基本的なクラス
class MyClass {
    var msg = "Hello!"
    func hello() {
        print(msg)
    }
}

let myObj = MyClass()
myObj.hello()

myObj.msg = "ハロー！"

myObj.hello()

// イニシャライザを使用したクラス
class MyClass2 {
    let msg: String
    init(msg: String = "Hello!") {
        self.msg = msg
    }
    func hello() {
        print(msg)
    }
}

let myObj2 = MyClass2(msg: "こんにちは")
myObj2.hello()

// 複数のイニシャライザを使用したクラス
class MyClass3 {
    let msg: String
    let name: String?
    init(msg: String = "Hello!") {
        self.msg = msg
        self.name = nil
    }
    init(msg: String = "Hello!", name: String = "Swift") {
        self.msg = msg
        self.name = name
    }
    func hello() {
        if let name = self.name {
            print(name + "さん、" + msg)
        } else {
            print(msg)
        }
    }
}

let myObj3 = MyClass3(msg: "こんにちは", name: "太郎")
myObj3.hello()

// 指揮を介して読み書きするプロパティ（Computedプロパティ）
class Circle {
    // 半径
    var radius: Double = 1.0
    // 面積
    var area: Double {
        // 面積を返す
        get {
            return radius * radius * Double.pi
        }
        // 面積を設定する（半径を設定する）
        set (menseki) {
            radius = sqrt(menseki / Double.pi)
        }
    }
}

let myCircle = Circle()
// 初期値の半径と面積
print("半径: " + String(myCircle.radius))
print("面積: " + String(myCircle.area))
// 面積を2倍にする
myCircle.area *= 2
print("半径: " + String(myCircle.radius))
print("面積: " + String(myCircle.area))

// 半径を3にする
myCircle.radius = 3.0
print("半径: " + String(myCircle.radius))
print("面積: " + String(myCircle.area))

// クラスプロパティとインスタンスプロパティ
class Car {
    // クラスプロパティ
    static var count = 0
    // インスタンスプロパティ
    var moving = false
    // インスタンスメソッド
    func start() {
        Car.count += 1
        moving = true
    }
    func stop() {
        if Car.count > 0 {
            Car.count -= 1
            moving = false
        }
    }
}

let car1 = Car()
let car2 = Car()
print("動いている車は" + String(Car.count) + "台です。")
car1.start()
car2.start()
print("動いている車は" + String(Car.count) + "台です。")
car2.stop()
print("動いている車は" + String(Car.count) + "台です。")

// エクステンションを使ったクラス拡張
class Player {
    var name: String = ""
    func hello() {
        print("こんにちは、" + name + "さん。")
    }
}
extension Player {
    // 新しいメソッドを追加
    func bye() {
        print("さようなら、" + name + "さん。")
    }
}
let player = Player()
player.name = "山田太郎"
player.hello()
player.bye()

// 継承を使ったクラス拡張
class Person {
    var name: String = ""
    func hello() {
        print("Hello, " + name + ".")
    }
}
class Japanese: Person {
    func bye() {
        print("さようなら、" + name + "さん。")
    }
}
let japanese = Japanese()
japanese.name = "山田太郎"
japanese.hello()
japanese.bye()

// プロトコルでの実装強制
protocol GameProtocol {
    var gamePoint: Int { get }
    func hit()
    func miss()
}
class MyGame: GameProtocol {
    private var total = 0
    var gamePoint: Int {
        get {
            return total
        }
    }
    func hit() {
        total += 10
    }
    func miss() {
        total -= 10
    }
}
■列挙型// 基本的な列挙型
enum Size {
    case S, M, L
}
let size = Size.M
if size == Size.S {
    print("サイズはSです。")
} else if size == Size.M {
    print("サイズはMです。")
} else if size == Size.L {
    print("サイズはLです。")
}

// 値を割り当てた列挙型
enum Season: Int {
    case Spring = 1
    case Summer = 2
    case Autom = 3
    case Winter = 4
}
let spring = Season.Spring
let summer = Season.Summer
print(spring)
print(spring.rawValue)
print(summer)
print(summer.rawValue)
■構造体// 基本的な構造体
struct ColorBox {
    var width: Int
    var height: Int
    var color: String
}
let blueBox = ColorBox(width: 20, height: 30, color: "blue")
let redBox = ColorBox(width: 30, height: 40, color: "red")

// クラスプロパティ（タイププロパティ）を持った構造体
struct Ball {
    // クラスプロパティ（タイププロパティとも呼ぶ）
    static let madein = "日本"
    static var material = "紙"
    // インスタンスプロパティ
    var radius: Double = 10.0
}
Ball.material = "木"
let ball1 = Ball(radius: 15)
let ball2 = Ball()
print(ball1.radius)
print(ball2.radius)
print(Ball.madein)
print(Ball.material)

// メソッドを持った構造体
struct Goods {
    let price: Int
    let count: Int
    // 価格
    func total() -> Int {
        return price * count
    }
}
let myGoods = Goods(price: 700, count: 4)
print(myGoods.total())
Memo

Advertisement
