[Swift]기본, 데이터 타입

Swift

1장 스위프트

클래스와 객체

클래스(Class) : 같은 종류의 집단에 속하는 속성과 행위를 정의한 것

객체(Object) : 클래스의 인스턴스(실제로 메모리에 할당되어 동작하는 모양을 갖춘 것,instance)

Swift는 클래스의 인스턴스, 구조체의 인스턴스, 열거형의 인스턴스 이렇게 여러 인스턴스가 있기 때문에 객체 == 인스턴스 라는 말을 사용할 수 없다. 단지 객체는 클래스의 인스턴스의 다른 말일뿐.

함수형

함수형 프로그래밍의 장점은 대규모 병렬처리가 굉장히 쉽다는 점, 프로그램이 상태의 변화 없이 데이터 처리를 수학적 함수 계산으로 취급하고자 하는 패러다임. 명령형 함수와 수학적 함수가 있는데 이 둘의 차이점은 다음과 같다. 명령형 함수는 과거 절차지향 프로그래밍 패러다임이 포함되어 있어서 함수 실행시 전달받은 전달인자 외에도 포인터, 레퍼런스 값 등 객체의 상태 값(프로퍼티 값) 또는 메모리 참조 값 등이 변경될 수 있으며 함수 내부의 처리에도 영향을 미칠 수 있다. 수학적 함수는 순수하게 함수에 전달된 인자 값만 결과에 영향을 주므로 상태 값을 갖지 않고 순수하게 함수만으로 동작한다.

2장 스위프트 처음시작하기

변수 var[변수명]: [데이터타입] = [값]

var name: String = "Napster17"
​
var age: Int = 100
​

상수 let[변수명]: [데이터타입] = [값]

let name: String = "Napster17"

스위프트는 기본적으로 타입추론을 한다. 그래서 변수명 뒤에 데이터 타입을 넣지 않아도 값에 따라 타입이 정해진다.

3장 데이터 타입 기본

스위프트의 기본 데이터 타입은 모두 구조체를 기반으로 구현되어있다.

Int , Bool, Float, Double, Character, String

Any는 스위프트의 모든 데이터 타입을 사용할 수 있다는 뜻

AnyObject는 Any보다 한정된 의미로 클래스의 인스턴스만 할당할 수 있다.

nil은 특정타입이 아니라 '없음'을 나타내는 스위프트 키워드, 변수, 상수에 값을 넣지 않고 비어있음을 나타냄

4장 데이터 타입 고급

타입별칭

typealias MyInt = Int
​
typealias YourInt = Int
​
typealias Mydouble = Double

튜플

지정된 제이터의 묶음

var person: (String, Int, Double) = ("yagom", 100, 182.5)
​
person.0 //yagom
​
person.1 //100
​
person.2 //182.5
​
//요소마다 이름을 지을 수 있다.
​
var person1: (name: String, age: Int, height: Double) = ("yagom", 100, 182.5)
​
person1.name //yagom
​
person1.0 //yagom
​
person1.age //100
​
//튜플 별칭 지정
​
typealias PersonTuple = (name: String, age: Int, height: Double)
​
let yagom: PersonTuple = ("yagom", 100, 182.5)
​
yagom.name //yagom
​
yagom.age //100

컬렉션 타입

스위프트는 배열(Array), 딕셔너리(Dictionary), 세트(Set) 등의 컬렉션 타입이 있다.

배열

배열은 같은 타입의 데이터를 일렬로 순서대로 저장하는 형태의 컬렉션 타입, 각기 다른 위치에 같은 값이 들어 갈 수 있음.

let을 사용하면 변경할 수 없는 배열이 되고 var로 선언하면 변경 할 수 있다.

var names: Array<String> = ["yagom","napster"]
​
var names2: [String] = ["napster", "yagom"]
​
var emptyArray1: [Any] = Any
​
var emptyArray2: [Any] = []
​
var emptyArray3: [Any] = Array<Any>()
​
names.first
​
names.last
​
names.index(of: "yagome") //nil
​
names.index(of: "yagom") //0
​
names.append("elsa") //["yagom", "napster", "elsa"]
​
names.insert("max", at: 2) //["yagom", "napster", "max", "elsa"]
​
names.remove(at: 2) //"max"
​
names[0..<names.endIndex] //["yagom", "napster", "elsa"]
​
```
​

딕셔너리 [키: 값]

딕셔너리는 요소들이 순서 없이 키와 값의 쌍으로 구성되어있다, 딕셔너리에 저장되는 값은 항상 키와 쌍을 이루는데 딕셔너리 안에서는 키가 하나이거나 여러개 일 수 있습니다. 단, 하나의 딕셔너리 안의 키는 그 안에서 유일해야한다.

typealias StringIntDictionary = [String: Int] //[키:값]
​
var numberForName: Dictionary<String, Int> = Dictionary<String, Int>() //빈 딕셔너리 생성
​
var number: [String: Int] = [:] //빈 딕셔너리 생성
​
var number2: StringIntDictionary = StringIntDictionary() //빈 딕셔너리 생성
​
var number3: [String:Int] = ["yagom": 100, "elsa": 200, "napster": 300]
​
number3.count //3
​
number3.isEmpty //false
​
number.isEmpty //true
​

세트

세트는 순서 없이 하나의 묶음으로 저장하는 형태의 컬렉션 타입, 세트 내의 값은 모두 유일한 값을 가진다. 순서가 중요하지 않거나 각 요소가 유일한 값을 가져야 하는 경우 사용, 세트의 요소로는 해시 가능한 값이 들어와야함

var names1: Set<String> = Set<String>() //빈 세트 생성
​
var names2: Set<String> = [] //빈 세트 생성
​
var names3: Set<String> = ["yagom", "chulsoo", "napster", "yagom"] //중복된 값은 허용하지 않아서 사라짐
​
names3.count //3 (중복된 값 때문에 그렇다)
​
var numbers1 = [100,200,300] //타입 추론을 사용할 경우 배열로 기본 선언된다.
​
var numbers2: Set<Int> = [100,200,300]
​
print(type(of: numbers1)) //Array<Int>
​
print(type(of: numbers2)) //Array<Int>
​
names3.sorted() //["chulsoo", "napster", "yagom"] 정렬기능 사용 예시

세트 내부의 값은 유일함을 보장하기 때문에 집합 관계를 표현할 때 좋다.

열거형

열거형은 연관된 항복들을 묶어서 표현할 수 있는 타입, 스위프트의 열거형은 각항목 그 자체로 고유의 값이 될 수 있다.

enum School{
​
    case primary
​
    case elementary
​
    case middle
​
    case high
​
    case college
​
    case university
​
    case graduate
​
}
var highestEducationLevel: School = School.university
​
var highestEducationLevel2: School = .graduate
​
highestEducationLevel = .college //School 내부의 항목으로만 값으로 바꿔줄 수 있다!!!
​
// highestEducationLevel = "School" //error
​

원시 값을 설정해 줄 수 있다! 아주 편리하게 만약 원시값을 지정한 값을 가져오고 싶다면 rawValue라는 프로퍼티를 통해 가져올 수 있다고 합니다.

enum School: String{
​
    case primary = "유치원"
​
    case elementary = "초등학교"
​
    case middle = "중학교"
​
    case high = "고등학교"
​
    case college = "대학"
​
    case university = "대학교"
​
    case graduate = "대학원"
​
}
var highestEducationLevel: School = School.university
​
var highestEducationLevel2: School = .graduate
​
highestEducationLevel = .college //School 내부의 항목으로만 값으로 바꿔줄 수 있다!!!
​
// highestEducationLevel = "School" //error
​
highestEducationLevel.rawValue //대학
​
highestEducationLevel.hashValue //4
​
enum School2: String{
​
    case primary = "유치원"
​
    case elementary = "초등학교"
​
    case college
​
}
​
var highestEducationLevel3: School2 = .college
​
highestEducationLevel3.rawValue //college
​
enum Number: Int{
​
    case zero
​
    case one
​
    case two
    
    case ten = 10
​
}
​
var numtest: Number = .zero
​
numtest.rawValue
​
var numtest1: Number = .ten
​
numtest1.rawValue
​

열거형의 각 항목에 연관 값이란것을 가지게 되면, 기존 프로그래밍 언어의 공용체 형태를 띌 수 있다. 연관 값은 열거형 내부의 항목 옆에 ()로 표현하여 갖게 할 수 있습니다. 마치 열거형은 자료형 안에 자료형 자료형 자료형이 있는 기분이다. 신기하다.

import UIKit
​
enum MainDish{
​
    case pasta(taste: String)
​
    case pizza(dough: String, topping: String)
​
    case chicken(withSauce: Bool)
​
    case rice
​
}
​
var dinner: MainDish = MainDish.pasta(taste: "크림")
​
var dinner2: MainDish = .pasta(taste: "토마토")
​
dinner = .pizza(dough: "씬피자", topping: "페퍼로니")
​
dinner = .chicken(withSauce: false)
​
dinner = .rice
​
enum PastaTaste{
​
    case cream
​
    case tomato
​
}
​
enum PizzaDough{
 case cheeseCrust
​
    case thin
​
    case original
​
}
​
enum PizzaTopping{
​
    case pepperoni, cheese, bacon
​
}
​
enum MainDish1{
​
    case pasta(taste: PastaTaste)
​
    case pizza(dough: PizzaDough, topping: PizzaTopping)
​
    case chicken(withSauce: Bool)
​
    case rice
​
}
​
var dinner3: MainDish1 = .pasta(taste: PastaTaste.tomato)
​
dinner3 = .pizza(dough: PizzaDough.thin, topping: PizzaTopping.cheese)
​
​

열거형의 마지막은 순환 열거형이다. 순환 열거형은 말그대로 열거형 항목의 연관 값이 자기 자신의 값일때 사용한다.

import UIKit
​
enum ArithmeticExpression{
​
    case number(Int)
​
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
​
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
​
}
​
indirect enum ArithmeticExpression1{
​
    case number(Int)
​
    case addition(ArithmeticExpression1, ArithmeticExpression1)
​
    case multiplication(ArithmeticExpression1, ArithmeticExpression1)
​
}
​
let five = ArithmeticExpression1.number(5)
​
let four = ArithmeticExpression1.number(4)
​
let sum = ArithmeticExpression1.addition(five, four)
​
let final = ArithmeticExpression1.multiplication(sum, ArithmeticExpression1.number(2))
​
func evaluate(_ expression: ArithmeticExpression1) -> Int{
​
    switch expression {
​
    case .number(let value):
​
        return value
​
    case .addition(let left, let right):
​
        return evaluate(left) + evaluate(right)
​
    case .multiplication(let left, let right):
​
        return evaluate(left) * evaluate(right)
​
    }
​
}
​

코드에서 보면 스위치문과 사용이 환상적이다. 사용법은 알겟지만 아직은 잘 모르겠는 부분이다.