Swift - Basic

var greeting: String = "Hello, Playground." var age: Int = 26 age = 27 age = 28 ...

let name: String = "John" // 변하지 않음

let screentHeight: Float = 560 print(type(of: screenHeight)) let character: Character = "A" let string = "A" print(type(of: character), type(of: string))

var httpError = (statusCode: 404, value: "Page Not Found") httpError.statusCode httpError.value var title = ("메인화면", "mainIcon.png") title.0 // 메인화면 title.1 // mainIcon.png

// 값이 있을 수도 있고, 없을 수도 있다. // 0은 값이 없는 것이 아닌, 다 쓴 값으로 생각 // 값이 없는 것은 nil var myAge: Int? if myAge == nil { // Do Something. }

// 1. Coalesce - ?? var a: Int? = 10 var b: Int? = 20 var c = (a ?? 0) + (b ?? 0) // 2. Force Unwrapping - ! // Runtime Error가 발생할 수 있기 때문에, 값이 있다는 확신이 있을 때 사용하는 것을 권고 var d = a! + b! // 3. Optional Binding // if Statements // if let // if var // guard let // guard var if let hansNumber = a { // Do Something. } if var hasNumber = a { // Do Something. } func functionA() -> Void { guard let hasNumber = a else { return } } func functionB() -> Void { guard var hasNumber = a else { return } }

// +, -, *, /, % var someNumber: Int = 20 someNumber += 2 someNumber -= 2 someNumber *= 2 someNumber /= 2 someNumber %= 2 // Swift는 Type Safe한 Programming Language let number1: Int = 20 let number2: Int = 30 let number3 = number1 / number2 // Integer let number4: Double = 20 let number5: Double = 30 let number6 = number4 / number5 // Double let number7: Int = 20 let number8: Double = 30 // let sum = number7 + number8 // Error let sum = number7 + Int(number8) let str1: String = "Hi" let str2: String = " Hello" let str3: String = str1 + str2 // Comparison Operator number1 == number2 number1 != number2 number1 > number2 number1 < number2 number1 >= number2 number1 <= number2 if number1 > number2 { // Do Something. } else { // Do Something. }

// 숫자만 입력 받아야 하는 경우 let inputValue = "19" if inputValue >= "\u{30}" && inputValue <= "\u{39}" { print("숫자") } else { print("숫자가 아님") }

let myName: String = "lee" for character in myName { // Do Something. } let myLongStr: String = """ hi hello welcome """ let isOn: Bool = true print(isOn.description) // "true\n" let myNumber: Int = 123 print(String(myNumber)) // "123\n" print("My number is \(myNumber)") // "My number is 123\n"

var myNames: Array<String> = Array() var myAges: [Int] = [] myNames.append("kim") myNames.append("lee") myNames.append("jin") // myNames[3] // Index out of range // 방어적 코드 // 안전한 코딩 스타일 let index: Int = 2 if myNames.count > index { print(myNames[index]) } myNames.append(contentsOf: ["hi", "hello"]) if myNames.count == 0 { // Do Something. } if myNames.isEmpty { // Do Something. } myNames.insert("hahaha", at: 2) for name in myNames { print(name + "님") } for (index, name) in myNames.enumerated() { print(index, name) }

// Array와 달리 순서가 없음 var names: Set<String> = Set() names.insert("kim") names.insert("min") // 중복된 값은 추가 되지 않음 names.insert("lee") names.insert("lee") names.insert("lee") var names2: Set = ["lee", "kim", "min"] var numbers1: Set = [1, 2, 3, 4, 5] var numbers2: Set = [4, 5, 6, 7, 8] // 교집합 numbers1.intersection(numbers2) // 합집합 numbers1.union(numbers2) // 합집합 - 교집합 numbers1.symmetricDifference(numbers2) // 여집합 numbers1.subtracting(numbers2)

// 순서적인 개념이 없음 // Key-Value 형태 var namesOfStreet: Dictionary<String, Any> = Dictionary() namesOfStreet["302ro"] = "1st Street" namesOfStreet["303ro"] = "2nd Street" namesOfStreet["304ro"] = 3 namesOfStreet.keys for (key, value) in namesOfStreet { print(key, value) }

let name: String = "anna" for char in name { // Do Something. } let numberOfLegs = ["ant" : 6, "dog" : 4] for dic in numberOfLegs { // Do Something. } for index in 0...5 { // Do Something. } var some: Int = 0 while some < 10 { print("계속 실행") some += 1 } // Switch // 조건에 케이스를 만들어서 분기 let someAlpha: String = "b" switch someAlpha { case "b": // Do Something. default: // Do Something. }

func simpleFunc() -> Void { print("Simple Func") } func plus(num1: Int, num2: Int) -> Int { return num1 + num2 } func minus(_ num1: Int, _ num2: Int) -> Int { return num1 - num2 } func multiply(_ num1: Int, _ num2: Int) -> Int { return num1 * num2 } // 반환 타입이 없는 경우(Void)는 생략 가능 func calc(result: (Int, Int) -> Int) { print("연산 결과", result(10, 20)) } var inputButtonType = "+" if inputButtonType == "+" { calc(result: plus) } else if inputButtonType == "-" { calc(result: minus) } else if inputButtonType == "*" { calc(result: multiply) }

// Closure - 코드의 블럭이라고도 하며, 이름이 없고 함수와 유사 // Function Version func myScore(a: Int) -> String { return "\(a)점" } // Closure Version let myScore2: (Int) -> String = { (a: Int) -> String in return "\(a)점" } // Closure 축약 // 1. return 생략 - body가 한 줄일 경우 let myScore3: (Int) -> String = { (a: Int) -> String in "\(a)점" } // 2. 반환 값을 추론하여 반환 타입 생략 let myScore4: (Int) -> String = { (a: Int) in "\(a)점" } // 3. 파라미터 타입 생략 let myScore5: (Int) -> String = { a in "\(a)점" } // 4. 단축 인자 이름, in 키워드 생략 let myScore6: (Int) -> String = { "\($0)점" } // Closure 실전 let someNames = ["apple", "air", "brown", "red", "orange", "blue", "candy", "hobby"] let isContainsSomeText: (String, String) -> Bool = { name, find in if name.contains(find) { return true } return false } let isStartSomeText: (String, String) -> Bool = { name, find in if name.first?.description == find { return true } return false } // Function Version func findByFunction(find: String) -> [String] { var newNames: [String] = [] for name in someNames { if name.contains(find) { newNames.append(name) } } return newNames } // Closure Version func findByClosure(findString: String, _ condition: (String, String) -> Bool) -> [String] { var newNames: [String] = [] for name in someNames { if condition(name, findString) { newNames.append(name) } } return newNames } findByFunction(find: "a") findByClosure(findString: "a", isContainsSomeText) findByClosure(findString: "a", isStartSomeText) let result = findByClosure(findString: "y") { $0.last?.description == $1 ? true : false } print(result) var someArr = ["Chris", "Alex", "Ewa", "Barry", "Daniella"] someArr.sort { $0 < $1 } someArr.sort(by: { $0 < $1 } ) someArr.sort(by: < )

// Enum // Value Type(값 타입) - 값이 복사돼서 전달됨, 타입 분류를 더 쉽게 하기 위해 사용 enum BookType { case fiction(title: String, price: Int, year: Int), comics(title: String, price: Int, year: Int), workbook(title: String, price: Int, year: Int) } var bookStyle: BookType? var books: [BookType] = [] func saveBook(book: BookType) { books.append(book) } saveBook(book: .fiction(title: "aaa", price: 5000, year: 2020)) saveBook(book: .comics(title: "bbb", price: 6000, year: 2021)) saveBook(book: .comics(title: "ccc", price: 7000, year: 2010)) saveBook(book: .workbook(title: "ddd", price: 7000, year: 2010)) saveBook(book: .fiction(title: "eee", price: 4000, year: 202)) saveBook(book: .fiction(title: "fff", price: 8000, year: 2015)) for book in books { if case let BookType.workbook(_, _, year) = book { print(year) } switch book { case let .comics(_, price, _): print(price) case let .fiction(title, _, _): print(title) default: break } }

// Class // Reference Type(참조 타입) - 참조가 전달됨 class MyInfo { enum GenderType { case male case female } var genderType: GenderType? var name: String = "" var age: Int = 0 func isAdult() -> Bool { return self.age > 19 } init(gender: GenderType) { self.genderType = gender } } // 참조 예시 var myInfo: MyInfo = MyInfo(gender: .female) myInfo.age = 20 var myInfo2: MyInfo = myInfo print(myInfo2.age) myInfo2.age = 30 print(myInfo.age) print(myInfo2.age)

// 단일 상속 class SportsInfo { var homeScore: Int = 0 var awayScore: Int = 0 func presentScore() -> String { return homeScore.description + " : " + awayScore.description } } class Soccer: SportsInfo { var time: Int = 0 override func presentScore() -> String { return "\(super.presentScore()), \(time)" } } class Baseball: SportsInfo { var round: Int = 30 override func presentScore() -> String { return "\(super.presentScore()), \(round)" } } class Football: SportsInfo { } let soccer: Soccer = Soccer() soccer.time = 45 soccer.homeScore = 1 soccer.presentScore() // "1 : 0, 45" let baseball: Baseball = Baseball() baseball.presentScore() // "0 : 0, 30" let football: Football = Football() football.homeScore // 0

class MyInfoClass { // Stored Property(저장 프로퍼티) var name: String = "" var age: Int = 0 // Lazy Stored Property(Class가 메모리에 적재될 때 같이 되는 것이 아니고, 사용하려고 할 때 메모리에 load됨.) lazy var myProfiles: [UIImage?] = [UIImage(named: "n") ?? nil, UIImage(named: "a") ?? nil] // Computed Property(연산 프로퍼티) var isAdult: Bool { return age > 19 } private var _email: String = "" var email: String { get { return _email } set { _email = newValue.hash.description } } } let myInfoClass: MyInfoClass = MyInfoClass() myInfoClass.age = 27 myInfoClass.name = "lee" myInfoClass.email = "lyJ@vaultmicro.com" myInfoClass.myProfiles print(myInfoClass.isAdult) print(myInfoClass.email)

class SomeClass { var name: String var id: String init(name: String, id: String) { self.name = name self.id = id } // convenience initializer, 다른 init을 반드시 실행해야 함 convenience init() { self.init(name: "", id: "") } } var someClass: SomeClass = SomeClass(name: "lee", id: "abcd")

var someInteger: Int? = 10 a = nil class Game { var score: Int = 0 var name: String = "" var round: Round? init() { print("game init") } deinit { print("game deinit") } } class Round { weak var gameInfo: Game? //메모리 누수(Memory Leak) 방지 var lastRound: Int = 10 var roundTime: Int = 20 deinit { print("round deinit") } } var game: Game? = Game() var round: Round? = Round() round?.gameInfo = game game?.round = round game = nil round = nil

// Struct - 구조체 // Value Type(값 타입) - 값이 복사돼서 전달됨 struct SomeStruct { var name: String = "" } var someStruct1: SomeStruct = SomeStruct() var someStruct2: SomeStruct = someStruct1 someStruct1.name = "lee" someStruct2.name = "kim" print(someStruct1) print(someStruct2)

// struct, class, enum, protocol 과 같은 // type들의 기능을 확장함, 이미 정의되어 있는 기능은 extension을 통해 재정의할 수 없음 extension Int { var oddOrEven: String { return self % 2 == 0 ? "짝수" : "홀수" } } 3.oddOrEven 4.oddOrEven extension UIColor { var mainColor1: UIColor { UIColor(red: 50/255, green: 70/255, blue: 120/255, alpha: 1) } } var button: UIButton = UIButton() button.titleLabel?.textColor = UIColor().mainColor1

// 규격, 규약, 규칙 protocol UserInfo { var name: String { get set } var age: Int { get set } func isAdult() -> Bool } // 프로토콜 지향 프로그래밍(Protocol Oriented Programming, POP) extension UserInfo { func isAdult() -> Bool { return self.age > 19 } } // protocol 채택 class Guest: UserInfo { var name: String = "kim" var age: Int = 20 } class Member: UserInfo { var name: String var age: Int init(name: String, age: Int) { self.name = name self.age = age } } class VIPMember: UserInfo { var name: String = "jane" var age: Int = 10 } class UserInfoPresenter { func present() { let guest: Guest = Guest() let member: Member = Member(name: "lee", age: 27) let vip: VIPMember = VIPMember() let members: [UserInfo] = [guest, member, vip] for element in members { print(element.name) } } } let presenter: UserInfoPresenter = UserInfoPresenter() presenter.present()

// Generic <Type> // 타입을 여러가지 사용할 때 사용 // 타입에 제한을 둘 때 제네릭 명 옆에 where 키워드 사용 struct Stack<SomeType> { var items: [SomeType] = [] mutating func push(item: SomeType) { self.items.append(item) } mutating func pop() -> SomeType? { if items.isEmpty { return nil } return items.removeLast() } } var myStack: Stack<Int> = Stack() myStack.push(item: 4) myStack.push(item: 5) myStack.push(item: 6) myStack.pop() myStack.pop() myStack.pop() myStack.pop() var myStack2: Stack<String> = Stack() myStack2.push(item: "4") myStack2.push(item: "5") myStack2.push(item: "6") myStack2.pop() myStack2.pop() myStack2.pop() myStack2.pop()

// 고차함수를 사용하면 코드를 편리하고 간결하게 작성할 수 있는 장점이 있음 // 1. Map let nameArr: [String] = ["kim", "lee", "min", "john"] let nameArrMap = nameArr.map { $0 + " 님" } // ["kim 님", "lee 님", "min 님", "john 님"] let nameArrSMap2 = nameArr.map { name in name.count // [3, 3, 3, 4] } // 2. Filter let filterNames = nameArr.filter { name -> Bool in name.count > 3 // ["john"] } // 3. Reduce let reduceNames = nameArr.reduce("") { $0 + $1 } // "kimleeminjohn" let numberArr = [1, 2, 3, 4, 5, nil, 6, nil, 8] let sumNum = numberArr.reduce(0) { $0 + ($1 ?? 0) } // 29 // 4. CompactMap - nil을 제외함 let compactMap = numberArr.compactMap { $0 } // [1, 2, 3, 4, 5, 6, 8] // 5. FlatMap let numberArr2 = [[1, 2, 3], [4, 5, 6]] let flatNum = numberArr2.flatMap { $0 } // [1, 2, 3, 4, 5, 6]