swift 문법 기초 1/7

코드 출처 - iOS 프로그래밍을 위한 Swift 기초 강의

 

 

 

1. 이름짓기 규칙

• Camel Case: 낙타의 등 모양 같은 표기법
• Lower Camel Case: function, method, variable, constant, ... ex) someVariableName
• Upper Camel Case: types, class, struct, enum, extension, ... ex) Person, Point, Week
• 대소문자를 구분한다.

 

 

2. 콘솔로그와 문자열 보간법

• 콘솔로그: console log. 디버깅 중 디버깅 콘솔에 보여줄 로그. Swift에서는 print()와 dump() 함수를 사용해 출력한다.
• print(): 단순 문자열 출력
• dump(): 인스턴스의 자세한 설명까지 출력
• 문자열 보간법: String Interpolation. 프로그램의 실행 중 문자열 내에 변수나 상수의 실질적인 값을 표현하기 위하여 사용한다. \( )
• 보간법 = 두 점을 연결하는 방법

// 콘솔로그와 문자열 보간법
// console log & string interpolation

import UIKit

let age: Int = 10

"안녕하세요! 저는 \(age)살 입니다"
// == 안녕하세요! 저는 10살 입니다

"안녕하세요! 저는 \(age + 5)살 입니다"
// 안녕하세요! 저는 15살 입니다

print("안녕하세요! 저는 \(age)살 입니다")
print("---------------------------")

class Person {
    var name: String = "마자용"
    var age: Int = 10
}

let 마자용: Person = Person()

print(마자용)
print("---------------------------")
dump(마자용)

 

 

3. 상수와 변수

• Swift → 함수형 pl → '불변객체' 중요시 여김 → 상수 표현을 많이 사용함
• let 상수이름: 타입 = 값
• var 변수이름: 타입 = 값
• 값의 타입이 명확하다면 타입 생략 가능
• 선언을 한 뒤 나중에 값을 할당하려면 반드시 타입을 명시해두어야 함

import UIKit

// 상수와 변수 활용
let constant: String = "차후에 변경이 불가능한 상수 let"
var variable: String = "차후에 변경이 가능한 변수 var"

variable = "변수는 이렇게 차후에 다른 값을 할당할 수 있지만"
// constant = "상수는 차후에 값을 변경할 수 없습니다" // 오류발생

let sum: Int
let inputA: Int = 100
let inputB: Int = 200

// 선언 후 첫 할당
sum = inputA + inputB

// sum = 1 // 그 이후에 다시 값을 바꾸려고 하면 오류 발생

// 변수도 차후에 할당할 수 있음
var nickName: String

nickName = "majayong"

nickName = "마자용" // 변수는 차후에 다시 값을 할당해도 문제 없음

 

 

4. 기본 데이터 타입

• Bool
• Int, UInt
• Float, Double
• Character, String
• Swift는 자료형에 매우 엄격한 언어임 → 다른 자료형과의 교환에 주의해야 함

import UIKit

// Bool
var someBool : Bool = true
someBool = false
// someBool = 0 // 컴파일 오류 발생
// someBool = 1 // 컴파일 오류 발생

// Int
var someInt: Int = -100
// someInt = 100.1 // 컴파일 오류 발생

// UInt
var someUInt: UInt = 100
// someUInt = -100 // 컴파일 오류 발생
// someUInt = someInt // 컴파일 오류 발생

// Float
var someFloat: Float = 3.14
someFloat = 3

// Double
var someDouble: Double = 3.14
someDouble = 3
// someDouble = someFloat // 컴파일 오류 발생

// Character
var someCharacter: Character = "☂️"
someCharacter = "가"
someCharacter = "A"
// someCharacter = "하하하" // 컴파일 오류 발생
print(someCharacter)

// String
var someString: String = "비온다 ☂️"
someString = someString + "우산을 써요"
print(someString)
// someString = someCharacter // 오류 발생

 

 

5.  Any, AnyObject, Nil

• Any: 모든 값이 올 수 있음 (모든 타입을 지칭하는 키워드)
• AnyObject: 모든 클래스 타입을 지칭하는 프로토콜
• nil: 빈 값. ('없음'을 의미하는 키워드)

import UIKit

// Any
var someAny: Any = 100
someAny = "어떤 타입도 수용 가능합니다"
someAny = 123.12

// let someDouble: Double = someAny // 컴파일 오류 발생
// Any 타입에 Double 자료를 넣어두었더라도, Any는 Double 타입이 아니기 때문에 할당할 수 없음
// 명시적으로 타입을 변환해 주어야 함

// AnyObject
class SomeClass {}
var someAnyObject: AnyObject = SomeClass()

// someAnyObject = 123.12 // 컴파일 오류 발생
// AnyObject는 클래스의 인스턴스만 수용 가능하기 때문에 클래스의 인스턴스가 아니면 할당할 수 없기 때문

// nill
// 다른 언어의 NULL, Null, null 등과 유사한 표현

// someAny = nil // 컴파일 오류 발생
// someAnyObject = nil // 컴파일 오류 발생
// someAny는 Any 타입이고, someAnyObject는 AnyObject 타입이므로 nil을 할당할 수 없기 때문

// nil을 다루는 방법은 옵셔널 파트에서 배움

 

 

6. 컬렉션 타입

• Array - 순서가 있는 리스트 컬렉션
• Dictionary - '키'와 '값'의 쌍으로 이루어진 컬렉션
• Set - 순서가 없고, 멤버가 유일한 컬렉션
  • 집합과 유사

import UIKit

// ---- Array ----

// 1. Array 선언 및 생성
var integers: Array<Int> = Array<Int>()
// 위와 동일한 표현
// var integers: Array<Int> = [Int]()
// var integers: Array<Int> = []
// var integers: [Int] = Array<Int>()
// var integers: [Int] = [Int]()
// var integers: [Int] = []
// var integers: [Int]()

// 2. Array 활용
integers.append(1)
integers.append(100)

// integers.append(100.1) // 컴파일 오류
// Int 타입이 아니므로 Array에 추가할 수 없음

print(integers) // [1, 100]

// 멤버 포함 여부 확인
print(integers.contains(100)) // true
print(integers.contains(99)) // false

// 멤버 교체
integers[0] = 99

// 멤버 삭제
integers.remove(at: 0)
integers.removeLast()
integers.removeAll()

// 멤버 수 확인
print(integers.count)

// 인덱스를 벗어나 접근하려면 익셉션 런타임 오류 발생
// integers[0]

// 3. 불변 Array: let을 사용하여 Array 선언
let immutableArray = [1, 2, 3]

// 수정이 불가능한 Array이므로 멤버를 추가하거나 삭제할 수 없음
// immutableArray.append(4) // 컴파일 오류
// immutableArray.removeAll() // 컴파일 오류


// ---- Dictionary ----

// 1. Dictionary의 선언과 생성
// Key가 String 타입이고 Value가 Any인 빈 Dictionary 생성
var anyDictionary: Dictionary<String, Any> = [String:Any]()
// 위와 동일한 표현
// var anyDictionary: Dictionary<String, Any> = Dictionary<String, Any>()
// var anyDictionary: Dictionary<String, Any> = [:]
// var anyDictionary: [String:Any] = Dictionary<String, Any>()
// var anyDictionary: [String:Any] = [String:Any]()
// var anyDictionary = [String:Any]()

// 2. Dictionary 활용
// 키에 해당하는 값 할당
anyDictionary["someKey"] = "value"
anyDictionary["anotherKey"] = 100

print(anyDictionary) // ["someKey":"value", "anotherKey":100]

// 키에 해당하는 값 변경
anyDictionary["someKey"] = "dictionary"
print(anyDictionary) // ["someKey":"dictionary", "anotherKey":100]

// 키에 해당하는 값 제거
anyDictionary.removeValue(forKey: "anotherKey")
anyDictionary["someKey"] = nil
print(anyDictionary)

// 3. 불변 Dictionary: let을 사용하여 Dictionary 선언
let emptyDictionary: [String: String] = [:]
let initializedDictionary: [String: String] = ["name":"majayong", "gender":"female"]

// 불변 Dictionary이므로 값 변경 불가
// emptyDictionary["key"] = "value"

// 키에 해당하는 값을 다른 변수나 상수에 할당하고자 하는 경우는 옵셔널, 타입 캐스팅 파트에서 다룸
// let someValue: String = initializedDictionary["name"] // 컴파일 오류
// "name"이라는 키에 해당하는 값이 없을 수 있으므로 String 타입의 값이 나올 것이라는 보장이 없기 때문


// ---- Set ----

// 1. Set 생성 및 선언
var integerSet: Set<Int> = Set<Int>()
// Set은 축약형이 없음에 주의

// insert: 새로운 멤버 입력
// 동일한 값은 여러 번 insert해도 한 번만 저장된다.
integerSet.insert(1)
integerSet.insert(99)
integerSet.insert(99)
integerSet.insert(99)
integerSet.insert(100)

print(integerSet) // {100, 1, 99}

// contains: 멤버 포함 여부 확인
print(integerSet.contains(1)) // true
print(integerSet.contains(2)) // false

// remove: 멤버 삭제
integerSet.remove(99) // {100, 1}
integerSet.removeFirst() // {1}

// count: 멤버 개수
print(integerSet.count) // 1

// 2. Set의 활용
// 멤버의 유일성이 보장되기 때문에 집합 연산에 활용하면 유용하다.
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)
print(union) // [2, 4, 5, 6, 7, 3, 1]

// 합집합 오름차순 정렬
let sortedUnion: [Int] = union.sorted()
print(sortedUnion) // [1, 2, 3, 4, 5, 6, 7]

// 교집합
let interSection: Set<Int> = setA.intersection(setB)
print(interSection) [5, 3, 4]

// 차집합
let subtracting: Set<Int> = setA.subtracting(setB)
print(subtracting) // [2, 1]