프로그래밍 언어 Swift 기초 다지기 2

{ (매개변수 목록) -> 타입 in
	/* 내부 코드 */
} // 클로져

let add: (Int, Int) -> Int = { (a: Int, b: Int) in
	return a + b
} // 클로져로 생성한 add
    
let result: Int = add(1, 2) // result = 3

let sub: (Int, Int) -> Int = { (a: Int, b: Int) in
	return a - b
} // 클로져로 생성한 sub
let caculate(a: Int, b: Int, method: (Int, Int) -> Int) -> Int {
	return method(a, b)
} // 클로져로 생성한 caculate
    
var caculated1 = caculate(a: 3, b: 2, method: sub) // caculated1 = 1
var caculated2 = caculate(a: 3, b: 2, method: {(left: Int, right: Int) -> Int in
	return left * right
}) // 클로져로 구현한 multiply, caculated2 = 6

result = caculate(a: Int, b: Int) { (left: Int, right: Int) -> Int in
	return left + right
} // 후행 클로져

result = caculate(a: Int, b: Int) { (left: Int, right: Int) in
	return left + right
} // 반환타입이 생략된 클로져

result = caculate(a: Int, b: Int, method: {
	return $0 + $1
} // $0 은 첫번째 인자, $1 은 두번째 인자를 의미합니다.

result = caculate(a: Int, b: Int) {
	return $0 + $1
} // 단축인자 + 후행 클로져

result = caculate(a: Int, b: Int) {
	$0 + $1
} // 암시적으로 $0 + $1 값이 반환값이 됩니다.

result = caculate(a: Int, b: Int) { $0 + $1 }

struct Student {
	// 인스턴스 저장 프로퍼티
	var name: String = ""
	var `class`: String = "Swift"
	var koreanAge: Int = 0
    
	// 인스턴스 연산 프로퍼티
	var westernAge: Int {
		get {
			return koreanAge - 1
		}
		set(inputValue) {
			koreanAge = inputValue + 1
		}
	}
    
	// 타입 저장 프로퍼티
	static var typeDescription: String = "학생"
    
	// 연산 저장 프로퍼티 (읽기전용)
	var selfIntroduce: String {
		get {
			return "저는 \(self.class)반 \(self.name)입니다."
		}
	} // 인스턴스 메서드를 대체합니다.
    
	// 타입 연산 프로퍼티 (읽기전용)
	static var selfIntroduce: String {
		return "학생타입입니다."
	} // 타입 메서드를 대체합니다.
} // 구조체 생성
    
print(Student.selfIntroduce) // 학생타입입니다.
    
var steve: Student = Student()
steve.koreanAge = 10
    
steve.name = "Steve"
print(steve.name) // Steve
    
print(steve.selfIntroduce) // 저는 Swift반 Steve입니다.
    
print("제 한국나이는 \(steve.koreanAge)살이고 미국 나이는 \(steve.westernAge)살입니다.")

struct Money {
	var currencyRate: Double = 1100 {
		willset (newRate){
			print("환율이 \(currencyRate)에서 \(newRate)으로 변경될 예정입니다")
		}
		didset (oldRate) {
			print("환율이 \(oldRate)에서 \(currencyRate)으로 변경되었습니다")
		}
	}
}

class 클래스이름 : 상속받을클래스이름 {
	/* 내부 코드 */
}

class Person {
	var name: String
	var age: Int! // 기본값이 필수이지만 기본값을 할당하지는 않을 때, 암시적 추출 옵셔널을 사용합니다.
	var nickname: String? // 기본값이 필수는 아닐 때, 옵셔널을 사용합니다.
    
	init(name: String) {
		self.name = name
	} // 이니셜라이져
	convenience init(name: String, nickname: String) {
		self.init(name)
		self.nickname = nickname
	} // convenience 키워드는 init 이 자기 자신의 클래스 내부에 있다는 의미입니다.
    	
} // 클래스 생성
    
var steve: Person = person(name: "steve", age: 20, nickname: "jobs")
var ive: Person = person(name: "ive") // age 가 없으므로 에러입니다.
ive.age = 22
var ive: Person = person(name: "ive")

class Person {
	var name: String
	var age: Int
	var nickname: String? // 기본값이 필수는 아닐 때, 옵셔널을 사용합니다.
    
	init?(name: String, age: Int) {
		if (0...120)contains(age) == false {
			return nil
		} // 만약 나이가 0 에서 120 중에 없다면 nil 을 반환합니다.
		self.name = name
		self.age = age
	} // nil 을 반환할 수 있는 이니셜라이져
    	
} // 클래스 생성
    
var steve: Person = person(name: "steve", age: 20) // 옵셔널 타입이 아니므로 에러입니다.
var steve: Person? = person(name: "steve", age: 150) // 나이가 너무 많으므로 nil 입니다.
print(steve) // nil 이므로 에러입니다.
    
var ive: Person? = person(name: "ive", age: 20)
print(ive)

class Person {
	var name: String
	var pet: String?
	var child: String
    
	init(name: String, child: String) {
		self.name: String = name
		self.child: String = child
	}
    	
	deinit {
		if let petname = pet?.name {
			print("\(name)가 \(pet)을 \(child)에게 양도합니다.")
		}
	} // 인스턴스가 소멸할 때 pet 이 있으면 child 에게 pet 을 양도하는 소멸자입니다.
}

func person1(owner: Person) {
	if let myjob = owner?.home?.name?.job {
		print("나의 직업은 \(myjob)입니다.")
	}
} // 옵셔널 체이닝

func person2(owner: Person) {
	if let owner = owner {
		if let home = owner.home {
			if let `name` = home.name {
				if let myjob = `name`.job {
					print("나의 직업은 \(myjob)입니다.")
				}
			}
		}
	}
} // 옵셔널 체이닝을 사용하지 않은 코드

var job: String = nil
steve?.home?.name?.job // nil
steve?.home?.name?.job ?? 무직 // 무직

var number1: Int = 10
var number2: Double = (Double)number1

class Person {
    /* 내부코드 */
}
class Student: Person {
	/* 내부코드 */
}
class UniversityStudent: Student {
	/* 내부코드 */
}
    
var steve: Student = Student()
var ive: UniversityStudent = UniversityStudent()
    
steve is Person // true
steve is Student // true
steve is UniversityStudent // false

var tim: Person = UniversityStudent as Person()
var gates: Any = Person() // as Any 는 암시적으로 생략할 수 있습니다.

var lisa: Person?
    
lisa = ive as? UniversityStudent
lisa = ive as? Student // ive 가 UniversityStudent 이므로 nil
lisa = steve as? UniversityStudent // steve 가 Person 이므로 nil

lisa = ive as! UniversityStudent
lisa = ive as! Student // ive 가 UniversityStudent 이므로 런타임 에러
lisa = steve as! UniversityStudent // steve 가 Person 이므로 런타임 에러

var number: Int = 1
    
assert(number == 1) // 조건이 일치하므로 지나갑니다.
assert(number == 0, "number 가 0 이 아닙니다.") // 조건이 다르므로 메세지를 출력하고 중지합니다.

var number: Int = 1
    
guard let mynumber = number,
	mynumber < 100 else {
		print("100 보다 큰 숫자입니다.")
		return
	} // else 구문 내에 반드시 return 이나 break 가 있어야 합니다.
    
print("나이는 \(mynumber)입니다.") // guard 에 쓴 mynumber 변수는 밖에서도 사용 가능합니다.

protocol Talkable {
	// 프로퍼티 요구
	var topic: String { get set } // 읽기 쓰기 모두 되어야 함
	var language: String { get } // 읽기 전용이어야 함
    
	// 메서드 요구
	func talk()
    
	// 이니셜라이져 요구
	init(topic: String, language: String)
} // 프로토콜 선언
    
struct Person: Talkable {
	/* 내부 코드 */
} // 프로토콜을 채택한 구조체

protocol Readable {
	func read()
} // 프로토콜 선언
protocol Writeable {
	func write()
} // 프로토콜 선언
protocol ReadSpeakable : Readable {
	func speak()
} // 프로토콜 상속
protocol ReadWriteSpeakable : Readable, Writeable {
	func speak()
} // 프로토콜 다중 상속

extension 확장할타입이름: 프로토콜 {
	/* 추가할 기능 */
}

extension Int {
	var isEven: Bool {
		return self % 2 == 0
	}
	var isOdd: Bool {
		return self % 2 == 1
	}
} // 익스텐션 선언
    
1.isEven // false
2.isEven // true

enum VendingMachineError: Error {
	case invalidInput
	case insufficientFunds(moneyNeeded: Int)
	case outOfStock
} // 오류 표현
    
func vendingMachine {
	/* 내부 코드 */
	guard money > 0 else {
		throw VendingMachineError.invalidInput
	} // 오류 처리
} 

do {
	try machine.reviewMoney(0)
} catch VendingMachineError.invalidInput {
	print("입력이 잘못되었습니다.")
} // do-catch 구문
    
do {
	try machine.reviewMoney(0)
} catch {
	switch error {
		case VendingMachineError.invalidInput:
			print("입력이 잘못되었습니다.")
		case VendingMachineError.outOfStock:
			print("재고가 부족합니다.")
	}
} // switch-case 를 활용한 do-catch 구문
    
do {
	try machine.reviewMoney(0)
} catch {
	print(error)
} // 케이스별로 에러처리할 필요가 없는 경우

do {
	try machine.reviewMoney(0)
} // 케이스별로 에러처리할 필요가 없는 경우 2

var result = try? machine.vend(numberOfItems: 2)
// 만약 에러일 경우 nil
    
result = try! machine.vend(numberOfItems: 2)
// 만약 에러일 경우 런타임 에러

let numbers: [Int] = [0, 1, 2, 3, 4]
let doubleNumbers: [Int]
    
doubleNumbers = numbers.map({ (number: Int) -> Int in
	return number * 2
}) // [0, 2, 4, 6, 8]
    
doubleNumbers = numbers.map { $0 * 2 } // 후행 클로져, [0, 4, 8, 12, 16]

let numbers: [Int] = [0, 1, 2, 3, 4]
    
let evenNumbers: [Int] = numbers.filter { (number: Int) -> Bool in
	return number % 2 == 0
} // [0, 2, 4]
    
let oddNumbers: [Int] = numbers.filter { $0 % 2 == 1 } // [1, 3]

let numbers: [Int] = [0, 1, 2, 3, 4]
    
let sum1: Int = numbers.reduce(0, { (first: Int, second: Int) -> Int in
	return first + second
}) // 10
    
let sum2: Int = numbers.reduce(0) { $0 + $1 } // 10