💡 Swift 기본 문법 (2)

정나영·2022년 10월 7일

📎 함수와 클로저

함수: func 키워드를 사용하여 정의, -> 를 사용해서 함수의 반환 타입 지정

func hello(name: String, time: Int) -> String {
	var string = ""
    for _ in 0.. < time {
    	string += "\(name)님 안녕하세요!\n"
    }
    return string
}

함수 호출 시, 파라미터 이름을 함께 써주어야 함

hello(name: "nang", time: 4)

함수 호출 시, 파라미터 이름과 함수 내부에서 사용하는 파라미터 이름을 다르게 사용할 경우

func hello(to name: String, numberOfTimes time: Int) {
	//함수 내부에서는 name과 time을 사용
	for _ in 0.. < time {
    	print(name)
    }
}

hello(to: "nang", numberOfTimes:4) //to와 numberOfTimes 사용

파라미터 이름을 _로 정의하면 함수 호출 시, 파라미터 이름 생략 가능

func hello(_ name: String, time: Int) {
	// ...
}

hello("nang", time:4)

파라미터의 기본값 지정 가능, 기본 값이 지정된 파라미터는 함수 호출시 생략 가능

func hello(name: String, time: Int = 1) {
	// ...
}

hello("nang")

...을 사용하면 개수가 정해지지 않은 파라미터를 받을 수 있음

func sum(_numbers: Int...) -> Int {
	var sum = 0
    for number in numbers {
    	sum += number
    }
    return sum
}

sum(1,2)
sum(3,4,5)

함수 안에 함수 작성 가능

func hello(name: String. time: Int) {
	func message(name: String) -> String {
    	return "\(name)님 안녕하세요!"
    }
    
    for _ in 0.. < time {
    	print(message(name: name))
    }
}

함수 안에 정의한 함수 반환 가능

helloGenerator() 함수의 반환 타입은 (String) -> String
-> 문자열을 받아서 문자열을 반환하는 함수

func helloGenerator(message: String) -> (String) -> String {
	func hello(name: String) -> String {
    	return name + message
    }
    return hello
}

let hello = helloGenerator(message: "님 안녕하세요!")
hello("낭")

함수 안에 정의한 함수가 여러 개의 파라미터를 받는 경우

(String, String) -> String
: 문자열 두 개를 받아서 문자열을 반환하는 의미

func helloGenerator(message: String) -> (String,String) -> String {
	func hello(firstName: String, lastName: String) -> String {
    	return lastName + firstName + message
    }
    return hello
}

let hello = helloGenerator(message: "님 안녕하세요!")
hello("나영","정")

📎 클로저 (Closure)

클로저: 중괄호( {} )로 감싸진 '실행 가능한 코드 블럭'

func helloGenerator(message: String) -> (String, String) -> String {
	return { (firstName: String, lastName: String) -> String in
    	return lastName + firstName + message
    }
}

함수와는 다르게 함수 이름 정의가 따로 존재하지 않음
but, 파라미터를 받을 수 있고, 반환 값이 존재
=> 함수는 이름이 있는 클로저

func helloGenerator(message: String) -> (String, String) -> String {
	return { firstName, lastName in
    	return lastName + firstName + message
    }
}

🟰

func helloGenerator(message: String) -> (String, String) -> String {
	return {
    	return $1 + $0 + message
    }
}

클로저 내부의 코드가 한 줄이라면, return 생략 가능

func helloGenerator(message: String) -> (String, String) -> String {
	return { $1 + $0 + message }
}

클로저는 변수처럼 정의 가능

let hello: (String, String) -> String = { $1 + %0 + "님 안녕하세요!" }
hello("나영","정")

옵셔널로도 정의 가능

let hello: ((String, String) -> String)?
hello?("나영", "정")

클로저를 변수로 정의하고 함수에서 반환할 수도 있는 것처럼, 파라미터도 받을 수 있음

func manipulate(number: Int, using block: Int -> Int) -> Int {
	return block(number)
}

manipulate(number: 10, using: { (number: Int) -> Int in
	return number * 2
}) 
🟰
manipulate(number: 10, using: {
	$0 * 2
})

(먄약 함수의 마지막 파라미터가 클로저라면, 괄호와 파라미터 이름 생략 가능)
manipulate(number: 10) {
	$0 * 2
}

📌 sort() 와 filter()
함수가 클로저 하나만을 파라미터로 받는다면, 괄호를 아예 쓰지 않아도 됨

let numbers = [1,3,2,6,7,5,8,4]

let sortedNumbers = numbers.sort { $0 < $1 }
print(sortedNumbers) //[1,2,3,4,5,6,7,8]

let evens = numbers.filter { $0 % 2 == 0 }
print(evens) //[2,6,8,4]

📎 클래스와 구조체

클래스는 class 로, 구조체는 struct 로 정의

class Dog {
	var name: String?
    var age: Int?
    
	func simpleDescription() -> String {
    	if let name = self.name {
        	return "🐶 \(name)"
        } else {
        	return "🐶 No name"
        }
    }
}

struct Coffee {
	var name: String?
    var size: String?
    
    func simpleDescription() -> String {
    	if let name = self.name {
        	return "☕️ \(name)"
        } else {
        	return "☕️ No name"
        }
    }
}

var myDog = Dog()
myDog.name = "룽지"
myDog.age = 3
print(myDog.simpleDescription()) 

var myCoffee = Coffee()
myCoffee.name = "아메리카노"
myCoffee.size = "Tall"
print(myCoffee.simpleDescription())

클래스는 상속 가능, 구조체는 불가능

class Animal {
	let numberOfLegs = 4
}

class Dog: Animal {
	var name: String?
    var age: Int?
}

var myDog = Dog()
print(myDog.numberOfLegs) //Animal 클래스로부터 상속받은 값 (4)

클래스는 참조 (Reference),
구조체는 복사 (Copy)

var dog1 = Dog() //dog1은 새로 만들어진 Dog()를 참조
var dog2 = dog1 //dog2는 dog1을 참조하는 Dog()를 똑같이 참조
dog1.name = "룽지" /dog1의 이름을 바꾸면 Dog()의 이름이 바뀜
print(dog2.name) //dog2의 이름을 가져와도 바뀐 이름 출력

var coffee1 = Coffee() //coffee1은 새로 만들어진 Coffee() 그 자체
var coffee2 = coffee1 //coffee2는 coffee1을 복사한 값
coffee1.name = "아메리카노" 
coffee2.name //coffee1의 이름을 바꿔도 coffee2는 별개이기 때문에 바뀌지 않음 (nil)

📎 생성자 (Initializer)

클래스와 구조체 모두 생성자를 가지고 있음.
생성자에서는 속성의 초기값 지정 가능

class Dog {
	var name: String?
    var age: Int?
    
    init() {
    	self.age = 0
    }
}

struct Coffee {
	var name: String?
    var size: String?
    
    init() {
    	self.size = "Tall"
    }
}

속성이 옵셔널이 아니라면 항상 초기값을 가져야 한다.
옵셔널이 아닌 속성이 초기값을 가지고 있지 않으면 컴파일 에러 발생

class Dog {
	var name: String?
    var age: Int //컴파일 에러
}

class Dog {
	var name: String?
    var age: Int = 0 //속성 정의할 때 초기값 지정
}

속성을 정의할 때,
1) 초기값을 지정해 주는 방법

class Dog {
	var name: String?
    var age: Int = 0
}

2) 생성자에서 초기값을 지정해 주는 방법

class Dog {
	var name: String?
    var age: Int
    
    init() {
    	self.age = 0
    }
}

함수와 마찬가지로 파라미터를 받을 수 있음

class Dog {
	var name: String?
    var age: Int
    
    init(name: String?, age: Int) {
    	self.name = name
        self.age = age
    }
}

var myDog = Dog(name: "룽지", age: 3)

만약 상속받은 클래스라면 생성자에서 상위 클래스의 생성자를 호출해주어야 함
만약 생성자의 파라미터가 상위 클래스의 파라미터와 같다면 override 키워드 사용

super.init() 은 클래스 속성들의 초기값이 모두 설정 된 후에 해야한다.
후에 자기 자신에 대한 self 키워드 사용 가능

class Dog: Animal {
	var name: String?
    var age: Int
    
    override init() {
    	self.age = 0 // 초기값 설정
        super.init() //상위 클래스 생성자 호출
        print(self.simpleDescription()) //여기서부터 self 접근 가능
    }
    
    func simpleDescription() -> String {
    	if let name = self.name {
        	return "🐶 \(name)"
        } else {
        	return "🐶 No name"
        }
    }
}

-> super.init() 을 하기 전에 self 에 접근한다면 컴파일 에러!

📎 속성 (Properties)

분류
1) Stored Property (값을 가지는 속성)
-속성이 값 자체를 가지고 있음
2) Computed Property (계산되는 속성)
-연산을 수행한 뒤 그 결과를 반환

struct Hex {
	var decimal: Int?
    var hexString: String? {
    	get {
        	if let decimal = self.decimal {
            	return String(decimal, radix: 16)
            } else {
            	return nil
            }
       	}
        
        set {
        	if let newValue = newValue {
            	self.decimal = Int(newValue, radix: 16)
            } else {
            	self.decimal = nil
            }
        }
    }
}

var hex = Hex()
hex.decimal = 10
hex.hexString //"a"

hex.hexString = "b"
hex.decimal //11

decimal: Stored Property
hexString: Computed Property

get,set 과 비슷한 willSet, didSet 을 이용하면
속성에 값이 지정되기 직전과 직후에 원하는 코드 실행 가능

struct Hex {
	var decimal: Int? {
    	willSet {
        	print("\(self.decimal)에서 \(newValue)로 값이 바뀔 예정입니다.")
        }
        didSet {
        	print("\(oldValue)에서 \(self.decimal)로 값이 바뀌었습니다.")
        }
    }
}

willSet : 새로운 값을 newValue로 얻어옴
didSet : 예전 값을 oldValue 라는 예약어를 통해 얻어옴

📎 튜플 (Tuple)

: 값들의 묶음
값에 접근할 때에는 . 사용

var coffeeInfo = ("아메리카노", 5100)
coffeeInfo.0 //아메리카노
coffeeInfo.1 //5100

파라미터에 이름을 붙일 수 있음

var namedCoffeeInfo = (coffee: "아메리카노", price: 5100)
namedCoffeeInfo.coffee //아메리카노
namedCoffeeInfo.price //5100
namedCoffeeInfo.price = 5100

튜플의 타입 어노테이션

var coffeeInfo: (String, Int)
var namedCoffeeInfo: (coffee: String, price: Int)

여러 변수에 값 지정

let (coffee, price) = ("아메리카노", 5100)
coffee //아메리카노
price //5100

튜플이 가진 값으로 변수에 값을 지정할 때, 무시할 값은 _ 키워드를 사용

let (_, latteSize, lattePrice) = ("라떼", "Venti", 5600)
latteSize //Venti
lattePrice //5600

튜플을 반환하는 함수

//커피 이름에 맞는 커피 가격 정보 반환. 일치하는 이름이 없다면 'nil' 반환

func coffeeInfo(for name: String) -> (name: String, price: Int)? {
	let coffeeInfoList: [(name: String, price: Int)] = [
    	("아메리카노", 5100),
        ("라떼", 5600),
    ]
    for coffeeInfo in CoffeeInfoList {
    	if coffeeInfo.name == name {
        	return coffeeInfo
        }
    }
    return nil
}

coffeeInfo(for: "아메리카노")?.price //5100
coffeeInfo(for: "에스프레소")?.price //nil

let (_, lattePrice) = coffeeInfo(for: "라떼")!
lattePrice //5600

정나영

이전 포스트

💡 Swift 기본 문법 (1)

다음 포스트