[Swift] 기초 문법3

- assert, guard

assert
- 특정 조건을 체크하고, 조건이 성립되지 않으면 메시지를 출력하게 할 수 있는 함수
- assert 함수는 디버깅 모드에서만 동작하고 주로 디버깅 중 조건의 검증을 위하여 사용

guard
- 뭔가를 검사하여 그 다음에 오는 코드를 실행할지 말지 경정 하는 것
- guard 문에 주어진 조건문이 거짓일 때 구문이 실행됨


var value = 0
assert(value == 0)

value = 2
assert(value == 0, "값이 0이 아님")


func guardTest(value: Int) {
	guard value == 0 else { return }
    print("안녕하세요")
}

guardTest(value: 2) // 아무것도 안나옴
guardTest(value: 0) // 안녕하세요


func guardTest2(value: Int?) {
	guard let value = value else { return }
    print(value)
}

guardTest2(value: 2) // 2
guardTest2(value: nil) // 아무것도 안나옴

 

- 프로토콜

protocol SomeProtocol {
}
protocol SomeProtocol2 {
}

struct SomeStructure: SomeProtocol, SomeProtocol2 {
}

class SomeClass: SuperClass, SomeProtocol {
}

protocol FirstProtocol {
	var name: Int {get set}
    var age: Int {get}
}

protocol FullyName {
	var fullName: String {get set}
    func printFullyName() // 디폴트값을 설정할 수 없음, 채택된 곳에서 정의하도록
}

struct Person: FullyName {
	// FullyName 에서 정의한 요구사항을 정의해주지 않으면 에러
	var fullName: String
    func printFullName() {
    	print(fullName)
    }
}

protocol SomeProtocole4 {
	init(someParameter: Int)
}

protocol SomeProtocole5 {
	init()
}

class SomeClass: SomeProtocole5 {
	//class에서는 생성자 요구사항에 required 필요
	required init() {
    }
}

 

- 익스텐션

extension Int {
	var isEven: Bool {
    	return self % 2 == 0
    }
    
    var isOdd: Bool {
    	return self % 2 == 1
    }
}

var number = 3
number.isOdd // true
number.isEven // false

extension String {
	func convertToInt() -> Int? {
    	return Int(self)
    }
}

var string = "0"
string.convertToInt() // "0" -> 0

 

- 열거형

enum CompassPoint {
	case north
    case south
    case east
    case west
    // case notrh, south, east, west
}

var direction = CompassPoint.east
direction = .west

enum CompassPoint: String {
	case north = "북"
    case south = "남"
    case east = "동"
    case west = "서"
    // case notrh, south, east, west
}

switch direction {
	case .north:
    	print(direction.rawValue)
    case .south:
    	print(direction.rawValue)
}

let direction2 = CompassPorint(rawValue: "남")

enum PhoneError {
	case unknown
    case batteryLow(String) // 연관값
}

let error = PhoneError.batteryLow("배터리가 곧 방전됩니다")

switch error {
	case .batteryLow(let message):
    	print(message)
    case .unknown:
    	print("알 수 없는 에러")
}

 

- 옵셔널 체이닝

struct Developer {
	let name: String
}

struct Company {
	let name: String
    var developer: Developer?
}

var company = Company(name: "ked", developer: nil)
print(company.developer) // nil

var developer = Developer(name: "han")
var company = Company(name: "ked", developer: developer)
print(company.developer) // Optional()
print(company.developer.name) // 에러
print(company.developer?.name) // Optional(han)
print(company.developer!.name) // han

 

- try catch

enum PhoneError: Error {
	case unknown
    case batteryLow(batteryLevel: Int)
}

// throw PhoneError.batterLow(batteryLevel: 20) // 에러 던지기

// 쓰로잉 함수
func checkPhoneBatteryStatus(batteryLevel: Int) throws -> String {
	guard batteryLevel != -1 else { throw PhoneError.unknown }
    guard batteryLevel > 20 else { 
    	throw PhoneError.batteryLow(batteryLevel: 20)
    }
    return "배터리 상태가 정상입니다"
}

do {
	try checkPhoneBatteryStatus(batteryLevel: -1)
} catch PhoneError.unknown {
	print("알 수 없는 에러")
} catch PhoneError.batteryLow(let batteryLevel) {
	print("배터리 부족. 남은 배터리 : \(betteryLevel)")
} catch {
	print("그 외 오류 : \(error)")
}

let status = try? checkPhoneBatteryStatus(betteryLevel: nil)
print(status) // nil 
let status = try? checkPhoneBatteryStatus(betteryLevel: 30)
print(status) // Optional("배터리 상태 정상~~")

let status = try! checkPhoneBatteryStatus(betteryLevel: 30)
print(status) // "배터리 상태 정상~~"

 

-  클로저

/*
{ (매개 변수) -> 리턴 타입 in
	실행 구문
}
*/

let hello = { () -> () in
	print("hello")
}

hello()

let hello2 = { (name: String) -> String in
	return "Hello, \(name)"
}

hello(name: "ked") // 에러
hello("ked") // Hello, ked

func doSomething(closure: () ->()) {
	closure()
}

doSomething(closure: { () -> () in
	print("hello")
})
doSomething() {
	print("hello")
}
doSomething {
	print("hello")
}


func doSomething2() -> () -> () {
	return { () -> () in
    	print("hello4")
    }
}

doSomething2()()

func doSomething2(success: () -> (), fail: () -> ()) {
}

doSomething2 {
	code
} fail: {
	code
}

 

- 고차함수

// map
let numbers = [0,1,2,3]
let mapArray = numbers.map { (number) -> Int in
	return number * 2
}
print(mapArray) // [0,2,4,6]


// filter
let intArray = [10,5,20,13,4]
let filterArray = intArray.filter{ $0 > 5 }
print(filterArray) // [10,20,13]


// reduce
let someArray = [1,2,3,4,5]
let reduceResult = someArray.reduce(0) {
	(result: Int, element: Int) -> Int in
    print("\(result) + \(element)")
    // result : 초기값, element 요소값
    // 0 + 1
    // 1 + 2
    // 3 + 3
    // 6 + 4
    // 10 + 5
    return result + element
}
print(reduceResult) // 15