func 関数名 (引数1:引数1の型, ...) -> 戻り値の型 {
	return 戻り値
}

func getArea ( r: Double ) -> Double {
	let pi = 3.14
	return pi * r * r
}

print( getArea( r:2 ) )

func someFunction1(firstParam: String, secondParam: String) {
    print("First=\(firstParam), Second=\(secondParam)")
}

someFunction1(firstParam: "AAA", secondParam: "BBB")

// 関数ラベルに別名をつける
func someFunction2(first firstParam: String, second secondParam: String) {
    print("First=\(firstParam), Second=\(secondParam)")
}

someFunction2(first: "AAA", second: "BBB")

// 関数ラベルと省略する.
func someFunction3(_ firstParam: String, _ secondParam: String) {
    print("First=\(firstParam), Second=\(secondParam)")
}

someFunction3("AAA", "BBB")

//宣言方法
var 変数名 = 値
let 定数名 = 値


var str = "Hello Objective-C"
str = "Hello Swift"

let str = "Hello, playground"

// 文字列
var member: String = "Yamada Taro"
 
// 整数
var age: Int = 26
 
// Double: 64bitサイズの浮動小数点型
var height: Double = 182.4
 
// Float: 32bitサイズの浮動小数点型
var weight: Float = 88.3
 
// 真偽値
var isMan: Bool = true

var member: String
member = "Yamada"
 
var age: Int
age = 26
 
var height: Double
height = 182.4
 
var weight: Float
weight = 88.3
 
var isMan:Bool
isMan = true

var piyo: String
println(piyo)
# => エラーして実行できない
//Variable 'piyo' used before being initialized

// OK
var str01 = "Hello Swift"
var str02="Hello Swift"
        
// Errors
var str03= "Hello Swift"
var str04 ="Hello Swift"

let maxOfint64 = Int64.max
print(maxOfint64) //9223372036854775807
 
let minOfint64 = Int64.min
print(minOfint64) //-9223372036854775808
 
let maxOfuint64 = UInt64.max
print(maxOfuint64) //18446744073709551615

        let a: Int8 = 100
        let b: Int8 = 100
        
        let c =  a * b // overflow

// bit演算
let a: UInt8 = 252 // 1111 1100
let b: UInt8 = 63 　// 0011 1111
let c: UInt8 = a & b  // AND
        
print(c) // 60 = 0011 1100

var text: String?

var text2: String = nil
// nil cannot be assigned to type
// 非オプショナルにはnilを代入できない

//オプショナル型の配列を宣言
var fruits1: Array<String>?
fruits1 = ["apple", "orange", "melon"]
print(fruits1)
 
//オプショナル型のディクショナリを宣言
var fruits2: Dictionary<String, Int>?
fruits2 = ["apple": 100, "orange": 80, "melon": 500]
print(fruits2)

Optional(["apple", "orange", "melon"])
Optional(["melon": 500, "apple": 100, "orange": 80])

var num1: Int = 1
var num2: Int? = 2
 
print(num1 + 1); // 2
print(num2 + 1); // エラー
//error: value of optional type 'Int?' not unwrapped; did you mean to use '!' or ‘?’?

//オプショナル型を宣言
var num: Int?
 
num = 100
 
print("num：\(num!)")

//オプショナル型の宣言
var num: Int?
 
//Binding
if let sum = num {
    print("sum：\(sum)")
} else {
    print("値が設定されていません。")
}

値が設定されていません。

var text: String!

//暗黙的なオプショナル型の宣言
var num: Int!
print(num) // null
 
num = 100
print(num) // 100
 
num = nil
print(num + 10) // エラー

var hoge: String?
hoge = "Hello World"
println(hoge)
// => Optional("Hello World")

var hoge: Int? = 10
println(hoge)
// => Optional(10)

var optional: Int? = 10 // オプショナル型
// そのまま出力
println(optional)
// => Optional(10)

// 強制的アンラップ("!"をつけて)で出力
println(optional!)
// => 10

var a: Int  = 10 // 非オプショナル型
var b: Int? = 10 // オプショナル型
a + b!
# => 20

var hoge: Int?
hoge!
# => オプショナル型の変数hogeはnilなのでアンラップするとエラーする

var hobby: String? // オプショナル型

if let unwrappedHobby = hobby {
    println(unwrappedHobby)
}
else {
    println("趣味はありません")
}

var hobby: String? = "プログラミング"

# unwrappedHobbyに"プログラミング"が代入される
if let unwrappedHobby = hobby {
    # hobbyがnilではないため、ここの処理が呼ばれる
    println(unwrappedHobby)
    # => "プログラミング"
}

var hobby: String?

if let unwrappedHobby = hobby {
    println(unwrappedHobby)
}
else {
    # hobbyがnilのため、ここの処理が呼ばれる
    println("趣味はありません")
    # => "趣味はありません"
}

var human: Human? = Human()

// nilでないためプロパティが取得できる
human?.name
// => "Optional(シンボ)"

// nilでないためメソッドを呼び出せる
human?.hello()
// => "Optional(こんにちは)"

var human: Human?

// humanがnilのため、nilが返る
human?.name
// => nil

// humanがnilのため、nilが返る
human?.hello()
// => nil

let item = ("りんご", 100, 0.08)
print(item.0, item.1, item.2 * 100) // りんご, 100, 8

let item(name, price, tax) = ("りんご", 100, 0.08)
print(name, price, tax * 100) // りんご, 100, 8

let item = (name: "りんご", price: 100, tax: 0.8)
print(name, price, tax * 100) // りんご, 100, 50

class Hoge {
    func getName() -> String {
        //処理内容
    }
}

class Hoge {
    class func getName() -> String{
        //処理内容
    }
}

// メンバ関数
let name = Hoge()
name.getName()

// クラスメソッド
let name = Human.getName()

class Monster {
    var name: String
    var level: Int

    init(name: String, level: Int) {
        self.name = name
        self.level = level
    }

    func attackMonster(enemy: Monster) {
        print("\(self.name)は\(enemy.name)を攻撃した。");
    }
}

/* Slimeクラス(Monsterクラスを継承) */
class Slime: Monster {
    func escapeFromMonster(enemy: Monster) {
        print("\(self.name)は\(enemy.name)から逃げた。");
    }
}

let monster = Monster(name: "モンスター", level:3)
let slime = Slime(name: "スライム", level:2)
monster.atackMonster(slime)        // モンスターはスライムを攻撃した。
slime.atackMonster(monster)        // スライムはモンスターを攻撃した。
slime.escapeFromMonster(monster)   // スライムはモンスターから逃げた。

class Monster {
    var name: String
    var level: Int

    init(name: String, level: Int) {
        self.name = name
        self.level = level
    }

    func attackMonster(enemy: Monster) {
        print("\(self.name)は\(enemy.name)を攻撃した。");
    }
}

/* Slimeクラス(Monsterクラスを継承) */
class Slime: Monster {
    override func attackMonster(enemy: Monster) {
        print("\(self.name)は\(enemy.name)をおちょくった。");
    }
}

let monster = Monster(name: "モンスター", level:3)
let slime = Slime(name: "スライム", level:2)
monster.atackMonster(slime)        // モンスターはスライムを攻撃した。
slime.atackMonster(monster)        // スライムはモンスターをおちょくった。
slime.super.atackMonster(monster)  // スライムはモンスターを攻撃した。

// パーソン
struct Person {
    let name: String        // 名前
    var age: Int            // 年齢
}

let taro = Person(name: "山田太郎", age: 35)

extension Person{
 func show(){
  print(self.name,":",self.age)
 }
}

taro.show()

山田太郎：35

extension Int {
    static var zero: Int { return 0 }
    mutating func inverse() {
        self = -self
    }
}
// Intのzeroプロパティを表示する
print(Int.zero)
// nに３を代入し、符号を逆転させる
var n = 3;
n.inverse();
print(n);

0
-3

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

var reference1: Person? = Person(name: "John Appleseed")
// Prints "John Appleseed is being initialized
var reference2: Person? = reference1
var reference3: Person? = reference1

reference2 = nil
reference3 = nil

reference1 = nil
// Prints "John Appleseed is being deinitialized"

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

var john: Person? = Person(name: "John Appleseed")
var unit4A: Apartment? = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil
unit4A = nil

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

var john: Person? = Person(name: "John Appleseed")
var unit4A: Apartment? = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil
// Prints "John Appleseed is being deinitialized

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

var john: Customer? = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

john = nil
// Prints John Appleseed is being deinitialized
// Prints Card #1234567890123456 is being deinitialized

typealias MyInt = Int

let int: MyInt = 1
print(int)
print(int.value)

typealias MyInt = Int

extension Int {
    func myMethod() {
        print("My Method")
    }
}

let int: MyInt = 1
print(int.myMethod())

typealias MyInt = Int

let int: MyInt = 1
print(int.dynamicType) // → Int

typealias MyBlock = () -> ()

func method(block: MyBlock) {
   block()
}

typealias User = (id: Int, name: String)
let users = [
    User(id: 1, name: "Name1"),
    User(id: 2, name: "Name2"),
    User(id: 3, name: "Name3"),
]
print(users.first!.id)

class ClassForAlias {
    typealias MyInt = Int
}
class MyClass {
    func method() {
        ClassForAlias.MyInt.max
    }
}

struct ContentView: View {
    @State private var isPowerOn = false    // 電源の状態を保持するプロパティ
 
    var body: some View {
        VStack {
            /// 電源ボタン
            Button(action: {
                self.isPowerOn.toggle()     // クリックでisPowerOnの値を反転
            }) {
                Image(systemName: "power")  // 電源ボタンの画像
            }
            
            /// 電源状態表示
            Text(isPowerOn ? "電源ON" : "電源OFF")
        }
        .font(.largeTitle)
    }
}
 

class Cat {
  static let sex: String = "male"

  func eat() {}
  static func meow() {}
}

// メソッド呼び出し時にCatクラスのインスタンスが毎回生成される。Cat().eat()

// Catクラスのインスタンスを生成せずに参照する。Cat.meow()