Swift 기본 문법 (1)
1) 이름 짓기 규칙
Lower Camel Case
→ function, method, variable, constant
ex) sameVariableName
Upper Camel Case
→ type (class, struct, enum, extensions ...)
대소문자를 구분!!
2) 콘솔로그
•
단순 문자열 출력할 때 사용
dump
•
인스턴스의 자세한 설명(description 프로퍼티)까지 출력
3) 문자열 보간법
•
String Interpolation
•
프로그매 실행 중에 문자열 내에 변수 또는 상수의 실질적인 값을 표현하기 위해 사용
•
\( )
let age: Int = 10
"안녕하세요! 저는 \(age)살입니다."
print("안녕하세요! 저는 \(age+5) 살입니다.")
Swift
복사
4) 변수와 상수
상수 선언 키워드
•
let
변수 선언 키워드
•
var
상수의 선언
let 이름: 타입 = 값
Swift
복사
변수의 선언
var 이름: 타입 = 값
Swift
복사
값의 타입이 명확하다면 타입은 생략이 가능!
let 이름 = 값
var 이름 = 값
Swift
복사
let constant: String = "차후에 변경이 불가능한 상수 let"
let variable: String = "차후에 변경이 가능한 변수 var"
variable = "변수는 이렇게 차후에 변경이 가능하다"
Swift
복사
나중에 할당하려고 하는 상수나 변수는 타입을 꼭 명시해 주어야 한다.
let sum: Int
let inputA: Int = 100
let inputB: Int = 200
sum = inputA + inputB // sum = 300
sum = 1 // Error
Swift
복사
5) 기본 데이터 타입
Bool, Int, UInt, Float, Double, Character, String
Bool
var someBool: Bool = true
someBool = false
someBool = 1 // Error
someBool = 0 // Error
Swift
복사
Int
var someInt: Int = -100
someInt = 100.1 // Error
Swift
복사
UInt (Unsigned Integer : 양의 정수)
var someUInt: UInt = 100
someUInt = -100 // Error
Swift
복사
Float
•
32 bit
var someFloat: Float = 3.14
someFloat = 3 // (o)
Swift
복사
Double
•
64 bit
var someDouble: Double = 3.14
someDouble = 3
someDouble = someFloat // Error
Swift
복사
Character
•
unicode
var someCharacter: Character = "🇰🇷"
someCharacter = "😃"
someCharacter = "가"
someCharacter = "A"
someCharacter = "하하하" // Error
Swift
복사
String
var someString: String = "하하하 😝 "
someString = someString + "웃으면 복이와요"
print(someString) // 하하하 😝 웃으면 복이와요
someString = someCharacter // Error
Swift
복사
→ 다른 데이터 타입과 자료 교환은 암시적으로 절대 불가능!
6) Any, AnyObject, nil
Any
•
Swift의 모든 타입을 지칭하는 키워드
var someAny: Any = 100
someAny = "어떤 타입도 가능하다"
someAny = 123.12
let someDouble: Double = someAny // Error
Swift
복사
AnyObject
•
모든 클래스 타입을 지칭하는 프로토콜
class SomeClass {}
var someAnyObject: AnyObject = SomeClass()
someAnyObject = 123.12 // Error
Swift
복사
nil
•
없음을 의미하는 키워드
someAny = nil // Error
someAnyObject = nil // Error
Swift
복사
•
빈 값은 들어올 수 없다.
7) 컬렉션 타입 Array, Dictionary, Set
Array
•
순서가 있는 리스트 컬렉션
// 빈 Int Array 생성
var integers: Array<Int> = Array<Int>()
integers.append(1)
integers.append(100)
integers.append(100.1) // Error
integers.contains(100) // true
integers.contains(99) // false
integers.remove(at: 0) // 0번 인덱스 요소 제거
integers.remove() // 맨 마지막 인덱스 요소 제거
integers.removeAll() // 전체 삭제
integers.count // 0
integers[0] // Error
Swift
복사
•
Array<Double>과 [Double]은 동일한 표현
// 빈 Double Array 생성
var doubles: Array<Double> = [Double]()
// 빈 String Array 생성
var strings: [String] = [String]()
// 빈 Character Array 생성
// []는 새로운 빈 Array
var characters: [Character] = []
// let을 사용하여 Array를 선언하면 불변 Array
let immutableArray = [1, 2, 3] // [1, 2, 3]
immutableArray.append(4) // Error
immutableArray.removeAll() // Error
Swift
복사
Dictionary
•
키와 값의 쌍으로 이루어진 컬렉션
•
key가 String 타입이고, value가 Any인 빈 Dictionary 생성
var anyDictionary: Dictionary<String, Any> = [String : Any]()
anyDictionary["someKey"] = "value"
anyDictionary["anotherKey"] = 100
anyDictionary // ["someKey":"value", "anotherKey": 100]
anyDictionary["someKey"] = "dictionary" // 값 바꾸기
anyDictionary.removeValue(forKey: "anotherKey") // key에 따른 value 삭제
anyDictionary["someKey"] = nil
anyDictionary // [:]
let emptyDictionary: [String: String] = [:]
let initializedDictionary: [String: String] = ["name": "yagom", "gender": "male"]
emptyDictionary["key"] = "value" // Error
let someValue: String = initializedDictionary["name"] // Error
Swift
복사
Set
•
순서가 없고, 멤버가 유일한 컬렉션
// 빈 Int Set 생성
var integerSet: Set<Int> = Set<Int>()
integerSet.insert(1);
integerSet.insert(100);
integerSet.insert(99);
integerSet.insert(99);
integerSet.insert(99);
integerSet // { 100, 99, 1 }
integerSet.contains(1) // true
integerSet.contains(0) // false
integerSet.remove(10) // 100
integerSet.removeFirst() // 99
integerSet.count // 1
let setA: Set<Int> = [1, 2, 3, 4, 5]
let setB: Set<Int> = [3, 4, 5, 6, 7]
let union: Set<Int> = setA.union(setB) // { 2, 4, 5, 6, 7, 3, 1 }
let sortedUnion: [Int] = union.sorted() // { 1, 2, 3, 4, 5, 6, 7 }
let intersection: Set<Int> = setA.intersection(setB) // { 5, 3, 4 }
let subtracting: Set<Int> = setA.subtracting(setB) // { 2, 1 }
Swift
복사
8) 함수
함수의 선언
func 함수이름 (매개변수1이름: 매개변수1타입, 매개변수2이름: 매개변수2타입...) -> 반환타입 {
함수구현부
return 반환값
}
Swift
복사
func sum (a: Int, b: Int) -> Int {
return a+b
}
sum(a: 3, b: 5)
Swift
복사
반환값이 없는 함수
func 함수이름 (매개변수1이름: 매개변수1타입, 매개변수2이름: 매개변수2타입...) -> void {
함수구현부
return
}
Swift
복사
func printMyName (name: String) -> void {
print(name)
}
printMyName(name: "yagom")
Swift
복사
→ void는 생략 가능하다!
매개변수가 없는 함수
func 함수이름 () -> 반환타입 {
함수구현부
return 반환값
}
Swift
복사
func maximumIntegerValue() -> Int {
return Int.max
}
maximumIntegerValue()
Swift
복사
매개변수와 반환값이 없는 함수
func 함수이름() -> void {
함수구현부
return
}
Swift
복사
func hello() -> void { print("hello") }
hello()
Swift
복사
9) 함수 고급
매개변수 기본값
•
기본값을 갖는 매개변수는 매개변수 목록 중에 뒤쪽에 위치하는 것이 좋다.
func 함수이름 (매개변수1이름: 매개변수1타입, 매개변수2이름: 매개변수2타입=매개변수2기본값) -> 반환타입 {
함수구현부
return 반환값
}
Swift
복사
func greeting(friend: String, me: String = "yagom") {
print("Hello \(friend)! I'm \(me)")
// -> 매개변수 기본ㄱ밧을 가지는 매개변수는 생갹이 가능하다!
greeting(friend: "haha") // Hello haha! I'm yagom
greeting(friend: "john", me: "eric") // Helll john! I'm eric
Swift
복사
전달인자 레이블
•
함수를 호출할 때, 매개변수의 역할을 좀 더 명확하게 하거나 함수 사용자의 입장에서 표현하고자 할 때 사용한다.
func 함수이름 (전달인자 레이블 매개변수1이름: 매개변수1타입, 전달인자 레이블 매개변수2이름: 매개변수2타입) -> 반환타입 {
함수구현부
return
}
Swift
복사
•
함수 내부에서 전달인자를 사용할 때에는 매개변수 이름을 사용한다.
func greeting(to friend: String, from me: String) {
print("Hello \(friend)! I'm \(me)")
}
Swift
복사
•
함수를 호출할 때에는 전달인자 레이블을 사용해야 한다.
greeting(to: "hana", from: "yagom") // Hello hana! I'm yagom
Swift
복사
가변 매개변수
•
전달 받을 값의 개수를 알기 어려울 때 사용할 수 있다.
•
가변 매개변수는 함수당 하나만 가질 수 있다.
func 함수이름 (매개변수1이름: 매개변수1타입, 전달인자 레이블 매개변수2이름: 매개변수2타입...) -> 반환타입 {
함수 구현부
return
}
Swift
복사
func sayHelloToFriends(me: String, friends: String...) -> String {
return "Hello \(friends)! I'm \(me)!"
}
print(sayHelloToFriends(me: "yagom", friends: "haha", "eric", "wing"))
// Hello ["hana", "eric", "wing"]! I'm yagom!
print(sayHelloToFriends(me: "yagom"))
// Hello []! I'm yagom!
Swift
복사
→ 위에 설명한 함수의 다양한 모양은 모두 섞어서 사용 가능하다.
데이터 타입으로서의 함수
•
스위프트는 함수형 프로그래밍 패러다임을 포함하는 다중 패러다임 언어이다.
•
스위프트의 함수는 일급객체 이므로 변수, 상수 등에 저장이 가능하고, 매개변수를 통해 전달할 수도 있다.
함수의 타입 표현
•
반환타입을 생략할 수 없다.
(매개변수1타입, 매개변수2타입 ...) -> 반환타입
Swift
복사
var someFunction: (String, String) -> Void = greeting(to:from:)
someFunction("eric", "yagom") // Hello eric! I'm yagom
someFunction = greeting(friend:me:)
someFunction("eric", "yagom") // Hello eric! I'm yagom
Swift
복사
•
타입이 다른 함수는 할당할 수 없다
someFunction = sayHelloToFriends(me: friends:) // Error
Swift
복사
func runAnother(function: (String, String) -> Void) {
function("jenny", "mike")
}
runAnother(function: greeting(friend:me:)) // Hello jenny! I'm mike
runAnother(function: someFunction) // Hello jenny! I'm mike
Swift
복사
10. 조건문
if-else
if condition {
statements
}
else if condition {
statements
}
else {
statements
}
Swift
복사
•
() 써도 되고, 안써도 된다.
•
스위프트의 조건에는 항상 Bool 타입이 들어와야 한다.
switch
switch value {
case pattern:
code
default:
code
}
Swift
복사
•
범위 연산자를 활용하면 더욱 쉽고 유용하다.
switch someInteger {
case 0:
print("Zero")
case 1.. < 100:
print("1~99")
case 100:
print("100")
case 101...Int.max:
print("over 100")
defulat:
print("unknown")
}
Swift
복사
•
정수 외의 대부분의 기본 타입 사용하다.
switch "yagom" {
case "jake":
print("jake")
case "mina":
print("mina");
case "yagom":
print("yagom!!")
default:
printf("unknown")
}
Swift
복사
→ default 구문은 꼭 넣어야 한다.
11) 반복문
var integers = [1, 2, 3]
let people = ["yagom": 10, "eric": 15, "mike": 12]
Swift
복사
for-in
for item in items {
code
}
for integer in integers {
print(integer)
}
Swift
복사
•
Dictionary의 item은 key와 value로 구성된 튜플 타입이다.
for (name, age) in people {
print("\(name): \(age)")
}
Swift
복사
while
while condition {
code
}
while integers.count > 1 {
integers.removeLast()
}
Swift
복사
•
조건에는 꼭 Bool 타입만!
repeat-while
•
do-while 과 비슷
repeat {
code
} while condition
repeat {
integers.removeLast()
} while integers.count > 0
Swift
복사
12) Optional (옵셔널)
값이 ‘있을 수도, 없을 수도 있다’
왜 필요할까?
→ nil의 가능성을 명시적으로 표현
•
nil의 가능성을 문서화하지 않아도 코드 만으로 충분히 표현이 가능
◦
문서/주석 작성 시간을 절약
•
전달 받은 값이 옵셔널이 아니라면, nil 체크를 하지 않더라도 안심하고 사용.
◦
효율적인 코딩
◦
예외 상황을 최소화하는 안전한 코딩
// someOptionalParam can be nil
func someFunction(someOptionalParam: Int?) {
// ...
}
// someParam must not be nil
func someFunction(someParam: Int) {
// ...
}
someFunction(someOptionalParam: nil)
someFunction(someParam: nil) // Error
Swift
복사
enum + general (열거형 + general)
enum Optional<Wrapped>: ExpressibleByNilLiteral {
case none
case some(Wrapped)
}
let optionalValue: Optional<Int> = nil
let optionalValue: Int? = nil
Swift
복사
•
Int? → Int의 옵셔널 타입이다 라고 표현
! Implicitly Unwrapped Optional 암시적 추출 옵셔널
var optionalValue: Int! = 100
switch optionalValue {
case .none:
print("This Optional variable is nil")
case .some(let value):
print("value is \(value)")
}
Swift
복사
•
기존 변수처럼 사용 가능
optionalValue = optionalValue + 1
Swift
복사
•
nil 할당 가능
optionalValue = nil
Swift
복사
•
잘못된 접근으로 인한 런타임 에러 발생할 수도 있다.
optionalValue = optionalValue + 1
Swift
복사
?
var optionalValue: Int? = 100
switch optionalValue {
case .none:
print("This Optional variable is nil")
case .some(let value):
print("value is \(value)")
}
Swift
복사
•
nil 할당 가능
optionalValue = nil
Swift
복사
•
기존 변수처럼 사용 불가 - 옵셔널과 일반 값은 다른 타입이므로 연산이 불가
optionalValue = optionalValue + 1
Swift
복사
13) Optional Unwrapping (옵셔널 추출)
옵셔널을 어떻게 꺼낼까?
•
Optional Binding - 옵셔널 바인딩
•
Force Unwrapping - 강제 추출
Optional Binding
•
옵셔널의 값을 꺼내오는 방법 중 하나
•
nil 체크 + 안전하게 값을 추출
→ 옵셔널은 값들을 보호해주는 보호막이 하나씩 있다고 생각
→ 값이 있는지 물어보기 → 값이 있으면 꺼내오고, 없으면 꺼내오지 않고 지나친다.
func printName(_ name: String) {
print(name)
}
var myName: String? = nil
printName(myName) // 전달되는 값의 타입이 다르기 때문에 컴파일 오류 발생
Swift
복사
→ 그래서
if-let 방식을 통해, 옵셔널 바인딩을 진행!
func printName(_ name: String) {
print(name)
}
var myName: String! = nil
if let name: String = myName {
printName(name)
}
else {
print("myName == nil")
}
printName(name)
// name 상수는 if-elt 구문 내에서만 사용 가능
// 상수 허용범위를 벗어났기 때문에 컴파일 오류 발생
Swift
복사
•
한번에 꼭 하나만 할 필요 없다 → 여러 옵셔널 변수들을 한꺼번에 바인딩 가능!
var myName: String? = "yagom"
var yourName: String? = nil
// , 를 이용해 여러 옵셔널 변수들 바인딩 가능
if let name = myName, let friend = yourName {
print("\(name) and \(friend)")
}
// yourName이 nil이기 때문에 실행되지 않는다.
yourName = "hana"
if let name = myName, let friend = yourName {
print("\(name) and \(friend)")
}
// 실행 가능
// yagom and hana
Swift
복사
Force Unwrapping
•
옵셔널의 값을 강제로 추출
•
강제로 깨부수고 꺼내온다고 생각!
func printName(_ name: String) {
print(name)
}
var myName: String? = "yagom"
printName(myName!) // yagom
// 강제로 꺼내와서 ? 벗겨지고 다시 값이 넘어온다.
myName = nil
print(myName!) // 강제 추출시 값이 없으므로 런타임 오류 발생
var yourName: String! = nil
printName(yourName) // nil 값이 전달되기 떄문에 런타임 오류 발생한다.
Swift
복사
→ Force Unwrapping 방식은 그다지 추천되지 않는 방식이므로, 안전한 Optional Binding 방식을 주로 사용하자!
14) Struct (구조체)
•
타입을 정의 → 대문자 Camel Case 사용
struct 이름 {
구현부
}
Swift
복사
프로퍼티 및 메서드
•
프로퍼티 : 구조체 안에 들어있는 인스턴스 변수
•
메서드 : 구조체 안에 들어있는 함수
struct Sample {
var mutableProperty: Int = 100 // 가변 프로퍼티
var immutableProperty: Int = 100 // 불변 프로퍼티
static var typeProperty: Int = 100 // 타입 프로퍼티
// 인스턴스 메서드
func instanceMethod() {
print("instance method")
}
// 타입 메서드
static func typeMethod() {
print("type method")
}
}
Swift
복사
Struct Town {
let name: String
var citizens: [String]
var resources: [String, Int]
init(townName: String, people: [String], stats: [String: Int]) {
self.name = name
self.citizens = citizens
self.resources = resources
}
func fortify() {
print("Defences increased!")
}
}
var oneTown = Town(name: "Hj Island", citizens: ["KHJ"], resources: ["Coconuts": 100])
oneTown.citizens.append("LSY")
var ghostTown = Town(name: "Ghosty Mcghostface", citizens: [], rewources: ["Tunbleweed": 1])
Swift
복사
구조체 사용
// 가변 인스턴스
var mutable: Sample = Sample()
mutable.mutableProperty = 200 // (o)
mutable.immutableProperty = 200 // (x)
// 불변 인스턴스
let immutable: Sample = Sample()
immutable.mutableProperty = 200 // (x)
immutable.immutableProperty = 200 // (x)
// 타입 프로퍼티 및 메서드
Sample.typeProperty = 400
Sample.typeMethod() // type method
mutable.typeProperty = 400 // (x)
mutable.typeMethod() // (x)
Swift
복사
예제)
struct Student {
var name: String = "unknown"
var `class`: String = "Swift"
static func selfIntroduce() {
print("학생 타입 입니다")
}
func selfIntroduce() {
print("저는 \(self.class)반 \(name)입니다 ")
}
}
Student.selfIntroduce() // 학생 타입 입니다
var yagom: Student = Student()
yagom.name = "yagom"
yagom.class = "스위프트"
yagom.selfIntroduce() // 저는 스위프트반 야곰입니다
let jina: Student = Student()
// 불변 인스턴스이므로 프로퍼티 값 변경 불가
// 컴파일 오류 발생
// jina.name = "jina" // error
jina.selfIntroduce() // 저는 Swift반 unknown입니다
Swift
복사
15) Class (클래스)
•
구조체와 매우 유사하다
•
구조체는 값 타입인 반면, 클래스는 참조 타입이다.
•
다중 상속이 이루어지지 않는다.
클래스의 정의
class 이름 {
구현부
}
Swift
복사
프로퍼티 및 메서드
class Sample {
var mutableProperty: Int = 100 // 가변 프로퍼티
let immutableProperty: Int = 100 // 불변 프로퍼티
static var typeProperty: Int = 100 // 타입 프로퍼티
// 인스턴스 메서드
func instanceMethod() {
print("instance method")
}
// 타입 메서드
// 상속 받았을 때, 재정의가 불가능한 타입 메서드 - static
static func typeMethod() {
print("type method - static")
}
// 상속 받았을 때, 재정의가 가능한 타입 메서드 - class
class func classMethod() {
print("type method - class")
}
}
Swift
복사
클래스 사용
var mutableReference: Sample = Sample()
mutableReference.mutableProperty = 200 // (o)
mutableReference.immutableProperty = 200 // (x)
let immutableReference: Sample = Sample()
immutableReference.mutableProperty = 200 // (o)
immutableReference.immutableProperty = 200 // (x)
immutableReference = mutabelReference // (x)
// 타입 프로퍼티 및 메서드
Sample.typeProperty = 300
Sample.typeMethod() // type method
mutableReference.typeProperty = 400
mutableReference.typeMethod()
Swift
복사
예제)
class Student {
var name: String = "unknown"
var `class`: String = "Swift"
class func selfIntroduce() {
print("학생타입입니다")
}
func selfIntroduce() {
print("저는 \(self.class)반 \(name)입니다")
}
}
Student.selfIntroduce() // 학생타입입니다
var yagom: Student = Student()
yagom.name = "yagom"
yagom.class = "스위프트"
yagom.selfIntroduce() // 저는 스위프트반 yagom입니다
let jina: Student = Student()
jina.name = "jina"
jina.selfIntroduce() // 저는 Swift반 jina입니다
Swift
복사
16) enum (열거형)
•
swift의 강력한 기능 중 하나
•
enum은 타입이므로 대문자 Camel Case를 사용하여 이름을 정의
•
각 case는 소문자 Camel Case로 정의
•
각 case는 그 자체가 고유의 값이다
enum 이름 {
case 이름1
case 이름2
case 이름3, 이름4, 이름5
...
}
Swift
복사
1. 열거형 사용
enum Weekday {
case mon
case tue
case wed
case thr, fri, sat, sun
}
var day: Weekday = Weekday.mon
day = .tue
print(day)
Swift
복사
switch day {
case .mon, .tue, .wed, .thu:
print("평일입니다")
case Weekday.fri:
print("불금 파티!!")
case .sat, .sun:
print("신나는 주말!!")
}
Swift
복사
2. 원시값
•
C 언어의 enum처럼 정수값을 가질 수도 있다.
•
rawValue를 사용하면 된다.
•
case 별로 각각 다른 값을 가져야 한다.
enum Fruit: Int {
case apple = 0
case grape = 1
case peach // 자동으로 1이 채워진다
case mongo = 0
}
print("Fruit.peach.rawValue == \(Fruit.peach.rawValue)")
// Fruit.peach.rawValue == 2
Swift
복사
•
정수 타입 뿐만 아니라, Hashable 프로토콜을 따르는 모든 타입이 원시값의 타입으로 지정될 수 있다.
enum School: String {
case elementary = "초등"
case middle = "중등"
case high = "고등"
case university
}
print("School.middle.rawValue == \(School.middle.rawValue)")
// School.middle.rawValue == 중등
print("School.university.rawValue == \(School.university.rawValue)")
// School.university.rawValue == university
Swift
복사
3. 원시값을 통한 초기화
•
rawValue를 통해 초기화 할 수 있다.
•
rawValue가 case에 해당하지 않을 수 있으므로, rawValue를 통해 초기화 한 인스턴스는 옵셔널 타입이다.
// let apple: Fruit = Fruit(rawValue: 0) // error
let apple: Fruit? = Fruit(rawValue: 0)
// 옵셔널 타입이므로, case가 없으면 생성되지 않고, nil이 나올 수도 있다 -> 옵셔널 타입으로 반환
if let orange: Fruit = Fruit(rawValue: 5) {
print("rawValue 5에 해당하는 케이스는 \(orange)입니다")
}
else {
print("rawValue 5에 해당하는 케이스가 없습니다")
} // rawValue에 해당하는 케이스가 없습니다
Swift
복사
4. 메서드
•
swift의 열거형에는 메서드도 추가할 수 있다.
enum Month {
case dec, jan, feb
case mar, apr, may
case jun, jul, aug
case sep, oct, nov
func printMessage() {
switch self {
case .mar, .apr, .may:
print("Spring")
case .jun, .jul, .aug:
print("Summber")
case .sep, .oct, .nov:
print("Fall")
case .dec, .jan, .feb:
print("Winter")
}
}
}
Month.mar.printMessage()
Swift
복사
17) 값 타입과 참조 타입 (value type / reference type)
1. class
•
전통적인 OOP 관점에서의 클래스
•
단일 상속
•
(인스턴스/타입) 메서드
•
(인스턴스/타입) 프로퍼티
•
참조 타입
•
Apple 프레임워크의 대부분의 큰 뼈대는 모두 클래스로 구성
2. struct
•
C언어 등의 구조체보다 다양한 기능
•
상속 불가
•
(인스턴스/타입) 메서드
•
(인스턴스/타입) 프로퍼티
•
값 타입
•
Swift의 대부분의 큰 뼈대는 모두 구조체로 구성
3. Enum
•
다른 언어의 열거형과는 많이 다른 존재
•
상속 불가
•
(인스턴스/타입) 메서드
•
(인스턴스/타입) 연산 프로퍼티
•
값 타입
•
Enumeration
•
유사한 종류의 여러 값을 유의미한 이름으로 한 곳에 모아 정의
◦
ex) 요일, 상태값, 월(Month) 등
•
열거형 자체가 하나의 데이터 타입
•
열거형의 case 하나하나 전부 하나의 유의미한 값으로 취급
•
선언 키워드 - enum
구조체는 언제 사용하나?
•
연관된 몇몇의 값들을 모아서 하나의 데이터 타입으로 표현하고 싶을 때
•
다른 객체 또는 함수 등으로 전달될 때, 참조가 아닌 복사를 원할 때
•
자신을 상속할 필요가 없거나, 자신이 다른 타입을 상속받을 필요가 없을 때
•
Apple 프레임워크에서 프로그래밍을 할 때에는 주로 클래스를 많이 사용
Value VS Reference
value
•
데이터를 전달할 때, 값을 복사하여 전달
Reference
•
데이터를 전달할 때, 값의 메모리 위치를 전달
클래스, 구조체/열거형 비교
import Swift
// Class vs Struct/Enum
struct ValueType {
var property = 1
}
class ReferenceType {
var property = 1
}
let firstStructInstance = ValueType()
var secondStructInstance = firstStructInstance
secondStructInstance.property = 2
print("first struct instance property : \(firstStructInstance.property)") // 1
print("second struct instance property : \(secondStructInstance.property)") // 2
let firstClassReference = ReferenceType()
var secondClassReference = firstClassReference
secondClassReference.property = 2
print("first class reference property : \(firstClassReference.property)") // 2
print("second class reference property : \(secondClassReference.property)") // 2
Swift
복사
예제)
struct SomeStruct {
var someProperty: String = "Property"
}
var someStructInstance: SomeStruct = SomeStruct()
func someFunction(structInstance: SomeStruct) {
var localVar: SomeStruct = structInstance
localVar.someProperty = "ABC"
}
someFunction(someStructInstance)
print(someStructInstance.someProperty) // "Property"
// 값 타입이 전달되는 방식
Swift
복사
class SomeClass {
var someProperty: String = "Property"
}
var someClassInstance: SomeClass = SomeClass()
func someFunction(classInstance: SomeClass) {
var localVar: SomeClass = classInstance
localVar.someProperty = "ABC"
}
someFunction(someClassInstance)
print(someClassInstance.someProperty) // "ABC"
// 참조 타입이 전달되는 방식
Swift
복사
Data types in Swift
public struct Int
public struct Double
public struct String
public struct Dictionary<Key : Hashable, Value>
public struct Array<Element>
public struct Set<Element : Hashable>
Swift
복사
•
스위프트는 구조체, 열거형 사용을 선호
•
Apple 프레임워크는 대부분 클래스 사용
•
Apple 프레임워크 사용시 구조체/클래스 선택은 우리의 몫