[Swift] Docs_(1) The Basics

요즘 매일 책상에 앉아 공부를 한다고 하는데,

이것도 해야할 것 같고, 저것도 해야할 것 같은 마음에 자료를 찾는 데에만 많은 시간을 쓰고

정작 제대로 된 공부는 못하고 있다는 생각이 들었습니다.

 

그래서, 하나를 정하고

처음부터 끝까지 진행해보고자 합니다.

 

공부할 것은 바로, Swift 문법에 대해서 공부하고 싶어,

Swift 공식 분서를 정독하고자 정했습니다.

(문법을 계속 다시 찾아보자니.. 다시 제대로된 공부를 하고자 합니다.😭)

 

아마, 다른 것들도 함께 공부를 하고 있어

완독하는 것이 쉽지는 않겠지만, 꾸준히 다! 올려보겠습니다

---

이번 글은 아래 Swift 공식 문서의 첫 번째 단원인 <The Basics>를 보고

전체적인 내용과 저의 생각을 기록해보려 합니다.

 

Swift 공식 문서 <The Basics>

 

중간 중간 저의 생각이 포함될 수 있어

혹시나 잘못된 내용이 있으면 댓글로 훈수 부탁드립니다. 🤓🤓🤓

---

Swift는 다양한 기본 데이터 타입을 제공합니다.

• 정수에 대한 Int
• 부동 소수점 값에 대한 Double
• 불린 값(참, 거짓)을 위한 Bool
• 텍스트에 대한 String
• Collection Type  (Array, Set, Dictionary)

Swift는 구분되는 이름으로 값을 저장하고 참조하기 위해 변수(Variables)를 사용합니다.

또한, 값이 변하지 않는 상수(Constansts)를 사용하여, 작업을 할 때 더 안전하고 분명하게 코드를 작성할 수 있습니다.

 

또, 튜플(Tuple)과 같이 더 발전된 타입을 도입했습니다.

튜플은 여러 값들을 그룹화하여 만들고, 전달할 수 있습니다. 또한 함수에서 다양한 값들을 단일 복합 값으로 리턴할 수 있습니다.

(❗️여러 값들을 하나의 데이터 묶음으로 전달할 수 있다는 말입니다!)

 

Swift는 값이 존재하지 않음을 다루기 위해 옵셔녈 타입(Opteional Type)을 도입했습니다.

옵셔널은 '값이 있고, x와 같다' 또는 '값이 없다'를 알려줍니다.

 

Swift는 타입-세이프 (type-safe)언어입니다.

이것은 우리가 작업하는 코드에서 다루는 값들의 타입을 분명히 하는데 도움을 준다는 의미입니다..

 

만약, 코드에서 String을 요구한다면, 타입 세이프는 우리가 실수로 Int타입을 전달하는 것을 막아줍니다.

마찬가지로, 타입 세이프는 우리가 옵셔널이 아닌 String을 요구하는 코드에 옵셔널 Stirng을 전달하려고 하는 것을 막아줍니다.

 

타입 세이프는 개발 단계에서 가능한 빠르게 에러를 찾고 고칠 수 있게 도와줍니다.

---

상수와 변수 (Constants and Variables)

상수와 변수는 이름(maximumNumberOfLoginAttempts 또는 welcomeMessage)과

특정 타입(숫자 10 또는 문자열 "Hello"와 같은 타입)의 값을 연결합니다.

 

상수의 값은 한 번 설정되면 바꿀 수 없지만, 반면에 변수는 다른 값으로 변경이 가능합니다.

let maximumNumberOfLoginAttempts = 10
var wellcomeMessage = "Hello

 

---

상수와 변수 선언 (Declaring Constants and Variables)

상수와 변수는 사용 전에 선언이 되어야 합니다.

상수는 let 키워드로, 변수는 var 키워드로 선언할 수 있습니다.

 

아래 예시는 상수와 변수를 사용하여 어떻게 사용자 로그인 시도 횟수를 추적하는지를 보여줍니다.

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

 

이 코드는 'maximumNumberOfLoginAttempts'인 새로운 상수를 선언하고 10이라는 값을 전달하고,

'currentLoginAttempt'인 새로운 변수를 선언하고 0이라는 값으로 전달 합니다.

 

변수나 상수를 선언할 때, 값을 선언부에서 넣어줄 수도 있지만,

아래 'maximumNumberOfLoginAttemps'처럼 초기 값을 나중에 할당할 수도 있습니다.

var environment = "development"
let maximumNumberOfLoginAttempts: Int
// maximumNumberOfLoginAttempts has no value yet.

 

 

컴마(,)를 사용하여 여러 상수나 변수를 한 줄에  선언할 수 있습니다.

var x = 0.0, y = 0.0, z = 0.0

---

타입 명시 (Type Annotaions)

변수나 상수를 사용할 때 type annotaion을 사용할 수 있습니다. 이는 값을 저장하는 변수나 상수의 타입을 분명하게 해줍니다.

콜론(:)을  변수나 상수 이름 뒤에 두고, 한 칸 띄고 사용할 타입의 이름을 쓰면 됩니다. 

(❗️이건 코드 규칙입니다)

var welcomeMessage: String

 

아래 코드는 에러없이 특정 Stirng 값을 넣어줄 수 있습니다. 

(❗️위에서 타입을 명시해주고, 변수를 선언했기 때문입니다.)

welcomeMessage = "Hello"

 

같은 타입의 여러 변수의 경우 콤마(,)를 사용하여 한 줄로 선언 가능합니다.

var red, green, blue: Double

 

하지만, 실전에서 우리가 type annotaion을 사용하는 일은 거의 없습니다.

 

초기에 변수나 상수를 선언하면서 초기 값을 전달해준다면, Swift는 타입을 추론하기 때문입니다. 이는 뒤에서 더 자세히 보겠습니다.

 

위의 예시의 경우 선언 부에서 초기 값을 넣어주지 않았기 때문에 type anootation을 사용한 겁니다.

(❗️다시 말해, 아래와 같이 코드를 작성했다면 type annotation 없이 코드를 작성해도 된다는 말입니다.)

var welcomeMessage = "Hello"

---

상수와 변수의 이름 짓기 (Naming Constants and Variables)

상수와 변수 이름은 유니 코드(Unicode)문자를 포함하여 대부분의 문자를 포함할 수 있습니다.

(❗️한자, 이모티콘, 파이 등을 이름으로 사용할 수 있습니다.)

let π = 3.14159
let 你好 = "你好世界"
let 🐶🐮 = "dogcow"

 

상수와 변수 이름은 공백, 수학적 기호, 화살표, 내부에서 사용하는 유니코드 스칼라 값, 또는 선과 박스를 그리는 문자를 포함할 수 없습니다.

 

숫자는 이름의 다른 곳에는 포함될 수 있지만 숫자로 시작하는 이름을 선언할 수는 없습니다.

 

Swift 키워드와 동일한 이름의 상수 또는 변수를 사용하려면, 백틱(`)으로 묶어야 합니다. 그러나 선택의 여지가 없을 때까지는 키워드를 사용하면 안됩니다.

(❗️Swift에서 자체적으로 정해둔 키워드(예를 들어 var, let)을 변수나 상수 이름으로 사용하려면 아래와 같이 적어야 됩니다.)

(❗️혹시나 백틱이 뭔지 모르시는 분들을 위해.. 키보드에서 ₩를 찾으신 뒤, 영문 키로 바꿔서 해당 키를 누르면 백틱(`)이 나옵니다!)

var `var` = "var"
let `let` = "let"

print(`var`)
print(`let`)

/* - 출력
var
let
*/

 

변수는 초기값을 같은 타입의 다른 값으로 바꿀 수 있지만, 상수는 바꾸려고 하면 에러가 발생합니다.

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome is now "Bonjour!"

let languageName = "Swift"
languageName = "Swift++"
// This is a compile-time error: languageName cannot be changed.

---

변수와 상수 프린트하기 (Printing Constants and Variables)

상수와 변수의 현재 값을 print(_:separator:terminator:) 함수를 사용하여 프린트 할 수 있습니다.

print(friendlyWelcome)
// Prints "Bonjour!"

 

print 함수는 Xcode의 "console"창에 하나 이상의 결과를 프린트 해주는 함수입니다.

 

separator와 terminator는 default 값이 있어 함수 호출 시 값을 넣지 않아도 함수가 실행됩니다.

terminator의 default 값으로 인해, 프린트가 끝나면 기본적으로 줄 바꿈이 됩니다.

이를 바꾸고 싶다면 파라미터에 직접 값을 넣어서 실행하면 됩니다. 

print("Hello", terminator: " ") // 한 칸 띄어쓰기만 하고 print문을 종료한다.
print("Leo")

/* - 출력
Hello Leo
*/

 

Swift는 변수나 상수의 이름을 값으로 대체하여 표시하기 위해 문자열 보간법(Stirng Interploation)을 사용합니다.

(❗️변수나 상수의 이름을 \()의 괄호 사이에 작성하면, 해당 자리에 변수나 상수 이름에 저장되어 있는 값으로 대체되어 프린트됩니다.)

print("The current value of friendlyWelcome is \(friendlyWelcome)")
// Prints "The current value of friendlyWelcome is Bonjour!"

---

주석 (Comments)

코드에서 실행되지 않는 텍스트를 포함하기 위해 주석을 사용할 수 있습니다.

코드가 컴파일될 때, 주석은 무시됩니다.

 

한 줄 주석은 //을 사용합니다.

// This is a comment.

 

여러 줄의 주석은 \*, *\ 사이에 작성합니다.

/* This is also a comment
but is written over multiple lines. */

 

C언어와는 다르게, 주석 안에 다른 주석을 중첩할 수 있습니다.

/* This is the start of the first multiline comment.
    /* This is the second, nested multiline comment. */
This is the end of the first multiline comment. */

(❗️사실 이걸 언제 쓸까 싶었지만, 예를 들어, 함수 내부 중간 쯤 주석으로 코드 설명이 써있는데, 주석 앞 뒤로 잠깐 다른 코드들을 주석 처리를 하고 싶을때 아주 유용하게 한 번에 드래그해서 사용할 수 있는 겁니다!!)

 

(❗️ 추가 꿀팁, 주석 처리하고 싶은 코드를 한 번에 드래그 하고 cmd +/ 누르면 한 번에 주석 처리 됩니다~)

---

세미클론 (Semicolons)

다른 언어와 달리, Swift는 코드 문장 마지막에 세미클론(;)을 요구하지 않습니다.

만약 한 줄에 여러 실행문을 쓰고 싶다면 세미클론으로 구분하면 됩니다.

let cat = "🐱"; print(cat)
// Prints "🐱"

---

정수 (Integers)

정수는 42와 -23과 같이 분수가 아닌 전체 숫자입니다. 또한, 부호가 있는 정수 (signed) (양수, 0, 또는 음수) 또는 부호가 없는 정수 (unsigned) (양수 또는 0)이 있습니다.

Swift는 8, 16, 32, 64비트 형식의 정수를 제공하고, C와 유사하게 8비트의 부호 없는 정수는 UInt8, 32비트의 부호 있는 정수는 Int32로 표시합니다. Swift의 모든 타입과 마찬가지로 정수 타입도 대문자로 시작합니다.

(❗️부호가 없는 정수는 UInt로 표시, 부호가 있다면 Int로 표시하고, 뒤에 비트 수를 붙여주면 됩니다.)

---

정수 범위 (Integer Bounds)

각 정수 타입의 max, min프로퍼티를 이용하여 최소 값과 최대 값에 접근할 수 있습니다.

let minValue = UInt8.min  // minValue is equal to 0, and is of type UInt8
let maxValue = UInt8.max  // maxValue is equal to 255, and is of type UInt8

---

Int

대부분의 경우, 우리가 코드에서 사용하는 정수의 사이즈를 구체적으로 정할 필요는 없습니다. 

Swift에서 현재 네이티브 크기와 같은 사의즈의 Int타입을 제공해주기 때문입니다.

• 32-bit 플랫폼에서 Int 는 Int32 와 같은 크기를 갖습니다.
• 64-bit 플랫폼에서 Int 는 Int64 와 같은 크기를 갖습니다.

우리는 구체적인 사이즈의 정수로 작업을해야하는 게 아니라면, 그냥 Int타입을 사용하면 됩니다.

32-bit플랫폼에서 사용되는 Int(Int32)는 -2,147,483,648 ~ 2,147,483,647 사이의 값을 저장할 수 있으므로 충분히 큰 값을 저장할 수 있습니다.

(❗️왜 32비트가 저런 숫자를 표현할 수 있는 지 궁금하시다면, 메모리와 이진법에 대해서 찾아보세요!!)

---

UInt

Swift는 부호가 없는 정수, UInt 타입을 제공합니다. 위와 마찬가지로 플랫폼에 따라 알아서 사이즈가 정해집니다.

 

⭐️ UInt가 특별하게 필요한 경우가 아니라면, 양수로 알려진 값이 저장되더라도 Int를 사용하는 것이 좋습니다.

Int 타입의 일관된 사용은 코드 상호 운용성(interoperability)를 지원하고, 다른 숫자 타입으로 변환할 필요가 없습니다.

 

(❗️상호 운용성은 특별한 노력 없이도 상호 간의 교환을 효과적으로 할 수 있게 하는 능력을 의미합니다.

예를 들어, 대부분이 Int 타입을 사용하는데 혼자 Int8 타입을 사용한다면 다른 사람과의 원활한 현업을 하지 못하며, 이는 상호 운용성이 깨졌다고 표현할 수 있습니다.)

 

(❗️더 쉽게 설명하자면, 대부분이 Int 쓰니까 너도 Int 써! 라고 말하는 것입니다.)

---

부동 소수점  숫자(Floating-Point Numbers)

부동 소수점 숫자는 3.141592, 0.1, -231.13와 같은 분수 성분을 갖는 숫자입니다.

Int 타입의 값보다 더 넓은 범의의 값을 표현할 수 있고, 더 크고 작은 값을 저장할 수 있습니다.

 

Swift는 Double과 Float의 두 가지 부동 소수점 타입을 제공하고,

 

Double은 64비트의 부동 소수점 숫자, Float는 32비트의 부동 소수점 숫자를 표현합니다.

Double 타입은 최소 15자리의 소수점 정확도를 갖고, Float 타입은 최소 6자리의 소수점 정확도를 갖습니다.

var b: Float = 3.123456//실수, 부동소수(6자리):
var c: Double = 3.123456789012345//실수, 부동소수(15자리)

print(b)
print(c)

 

(❗️더 쓰면 어떻게 나오나 궁금해서, playground에서 직접 프린트 해봤는데..

저 상태에서 뒤에 숫자를 더 쓴 뒤 프린트를 하면, 소수점 뒤로 7, 16자리까지 보이지만, 맨 뒤에 숫자는 정확하지 않습니다!)

 

상황에 따라 두 개의 부동 소수점 타입 중 적절한 것을 골라야 하겠지만, 둘 다 괜찮다면 Double을 사용합니다.

---

타입 세이프티와 타입 추론 (Type Safety and Type Inference)

Swift는 타입 세이프(type-safe) 언어입니다. 코드를 컴파일 할 때 타입 검사를 하고 일치하지 않는 타입은 오류로 표시를 해줍니다.

이를 통해 개발 단계에서 가능한 빨리 오류를 찾고 수정할 수 있습니다.

 

그러나 이것이 선언하는 모든 상수와 변수의 타입을 type-annotaion으로 지정해줘야 한다는 것은 아닙니다. 

Swift는 필요한 값의 특정 타입이 지정되어 있지 않다면 적절한 타입 추론 (Type inference)을 사용합니다.

 

타입 추론을 통해 코드를 컴파일 할 때 제공한 값을 검사하여 특정 식의 타입을 자동으로 추론할 수 있는 것입니다.

 

따라서 Swift는 C나 Objective-C와 같은 언어보다 타입 선언을 더 적게 요구합니다.

 

예를 들어, 42의 값을 타입 선언 없이 리터럴 값만 할당해준다면 Swift는 type infernce를 통해 Int형으로 추론을 합니다.

let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int

 

마찬가지로, 특별하게 타입 명시가 없지만, 알아서 Double로 추론합니다.

(❗️ Float 타입으로 추론할 수도 있겠지만, 아까 위에서 언급한 것처럼 Swift도 상호 운용성을 위해 Double 타입을 즐겨 쓰는 것 같습니다.)

let pi = 3.14159
// pi is inferred to be of type Double

 

정수와 부동 소수점을 더하는 표현식을 써도, 뒤에 부동 소수점을 보고 Double 타입으로 추론합니다.

다시 말해, 표현식의 결과 (output)을 보고 타입을 추론합니다.

let anotherPi = 3 + 0.14159
// anotherPi is also inferred to be of type Double

---

숫자 리터럴 (Numeric Literals)

정수 리터럴은 아래와 같이 쓸 수 있습니다.

• 0진수는 접두사 없이 표현

• 2진수는 0b를 접두사로 표현 (b = binary)

• 8진수 0o를 접두사로 표현 (o = octal)

• 16진수 0x를 접두사로 표현 (x = hexadecimal)

let decimalInteger = 17
let binaryInteger = 0b10001       // 17 을 2진수로 표현
let octalInteger = 0o21           // 17 을 8진수로 표현
let hexadecimalInteger = 0x11     // 17 을 16진수로 표현

---

부동 소수점 리터럴은 아래와 같이 표현됩니다.

• 10진수는 접두사 없이 표현
  • e,E로 지수를 표시 (지수가 x인 10진수는 10^가 곱해짐)
  • 1.25e2 = 1.25 x 10²
• 16진수는  0x를 접두사로 표현
  • p, P로 지수를 표시  (지수가 x인 16진수는 2^가 곱해짐)
  • 0xFp2 = 15 x 2²

아래는 모두 12.1875를 표현하는 리터럴입니다.

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

 

숫자 리터럴을 읽기 쉽게 표현하기 위해 추가 포맷을 포함할 수 있습니다.

정수와 부동 소수점 모두 추가적인 0으로 채워질 수 있고, 가독성을 위한 밑줄을 포함할 수 있습니다.

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

 

(❗️이 부분은 외운다기보다.. 필요할 때마다 다시 봐야할 듯 합니다 😅)

---

숫자 타입 변환 (Numeric Type Conversion)

음수를 사용하지 않더라도 상수와 변수가 정수로 사용이 되면 Int 타입을 사용해야 합니다. 이는 코드에서 즉시 상호 운용 가능하며 정수 리터럴 값의 유추된 타입이 일치할 것입니다.

 

외부 소스에서 특별히 사이즈가 지정된 데이터나 선은, 메모리 사용, 또는 최적화가 필요한 특별한 경우에만 다른 정수 타입을 사용합니다.

이러한 상황에서 사이즈가 지정된 타입을 사용하는 것은 특정 사건으로 인한 값의 오버플로우를 포착하고, 사용중인 데이터의 특성을 알 수 있습니다.

---

정수 변환 (Integer Conversion)

정수를 저장할 수 있는 상수 또는 변수의 숫자 범위는 각 숫자 타입에 따라 다릅니다.

Int8 상수 또는 변수는 -128 과 127 사이의 숫자를 저장할 수 있지만, UInt8 상수 또는 변수는 0 과 255 사이의 숫자를 저장할 수 있습니다. 크기가 지정된 정수 타입의 상수 또는 변수에 맞지않는 숫자는 컴파일 시 오류가 발생합니다.

let cannotBeNegative: UInt8 = -1
// UInt8 can't store negative numbers, and so this will report an error
let tooBig: Int8 = Int8.max + 1
// Int8 can't store a number larger than its maximum value,
// and so this will also report an error

 

각 숫자 타입은 다른 범위의 값을 저장할 수 있으므로 숫자 타입 변환을 각 타입 별로 진행해야 합니다.

이는 숨겨진 타입 변환 에러를 막고 타입 전환 의도를 명시하는데 도움을 줍니다.

 

특정 숫자 타입을 다른 타입으로 변환하려먼 원하는 타입의 새 숫자로 초기화 해야 합니다.

(❗️ 기존에 있던 숫자의 타입을 change 하는게 아니라, 완전히 새로운 숫자를 만들어 낸다는 의미입니다!)

 

UInt16 타입과 UInt8 타입의 값들은 함께 더해질 수 없습니다. 따라서 UInt8의 값인 1을 UInt16 타입으로 새롭게 초기화 해서 계산을 진행해야 합니다. 계산의 결과인 twoThousandAndOne 상수도 타입 추론에 의해 UInt16 타입이 됩니다.

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)

 

SomeType(ofInitialValue)는 Swift 타입의 생성자를 호출하고 초기 값을 전달해주는 것 입니다. 

(❗️다시 말해, 특정 타입의 값을 생성자의 파라미터로 전달 해주면 해당 타입의 생성자가 새로운 값을 생성해내는 것 입니다.)

 

any type은 전달할 수 없지만, 확장을 통해 구현해준다면 커스텀 타입으로도 해당 타입의 값을 초기화할 수 있습니다.

(❗️이 내용은 뒤에 내용을 알면 이해가 되실거에요.)

---

정수와 부동 소수점 변환 (Integer and Floating-Point Conversion)

정수와 부동 소수점 숫자 타입의 변환은 명시적으로 작성되어야 합니다.

 

상수 three는 Double 타입과 계산될 수 없기 때문에, Double(three)로 타입 변환을 해주고 계산을 해줍니다.

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi는 3.14159이고, Double 타입으로 추론이 됩니다.

 

부동 소수점의 값이 정수로 변환이 될 때 소수점 아래를 버림합니다. 

이것은 4.75는 4, 그리고 -3.9는 -3이 된다는 의미입니다.

let integerPi = Int(pi)
// 정수로 변환되면서 0.14159를 버림합니다.

 

숫자 상수와 변수를 결합하는 규칙 (같은 타입끼만 계산 가능)은 숫자 리터럴 규칙과 다릅니다.

(❗️아래 예시를 보면 무슨 말인지 이해되실겁니다.)

 

아래와 같은 경우는, 이미 컴파일러가 3과 3.141592 리터럴을 평가하고 해당 상수에 타입을 추론한 뒤,

다른 타입의 상수끼리 결합하고 있기 때문에 규칙에 위배가 되는 것입니다.

let three = 3
let pi = 3.141592

let num = three + pi 
//Error: Binary operator '+' cannot be applied to operands of type 'Int' and 'Double'

 

그러나, 아래 경우는 3은 숫자 리터럴에 명시적인 타입이 없기 때문에 리터럴 값 0.14159에 직접 추가할 수 있습니다.

이것의 타입은 컴파일러가 실행되는 시점에서만 추론됩니다.

(❗️아마.. 3을 추론하려고 보니 뒤에 Double 타입과 결합이 되어야 하는 상황이니, 리터럴 3을 Double 타입으로 추론한다는 말 같아요.)

let pi = 3 + 0.141592

---

타입 별칭 (Type Aliases)

타입 별칭은 존재하는 타입의 이름을 다른 방식으로 정의할 수 있고, typealias 키워드를 사용하여 정의합니다.

기존 타입을 더 맞는 맥락에서 사용하기 위해 새로운 이름으로 참조할 때 유용합니다. 특히 외부 소스에서 특정 크기의 데이터를 다룰 때 유용합니다.

typealias AudioSample = UInt16

새롭게 정의한 타입은 원래 타입이 사용될 수 있는 위치에서 모두 사용가능합니다.

AudioSample은 UInt16을 대신하여 정의된 것입니다.

(❗️간단하게 생각해서 수학에서 흔히 사용하는 치환을 생각하면 되고, 코드에 가독성을 높이기 위해 사용되는 것 입니다.!)

var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0

---

추가적인 typealias 사용 예제입니다.

1. Bytes 타입 별칭 예시:

   typealias Byte = UInt8
   

   이렇게 정의된 Byte 타입은 UInt8의 별칭으로, 이제 바이트 단위의 데이터를 다룰 때 Byte를 사용하여 코드를 읽기 쉽게 만들 수 있습니다.
   
   가령, 외부 데이터 소스에서 바이트(Byte) 단위로 데이터를 읽어오는 경우가 있습니다. 이때, 바이트 단위의 데이터를 더 의미있는 이름으로 참조하기 위해 타입 별칭을 사용할 수 있습니다.
2. 배열 타입 별칭 예시:

   typealias StringArray = [String]
   

   이제 StringArray는 [String]의 별칭으로 사용될 수 있으며, 코드에서 더 의미 있게 사용할 수 있습니다.
   
   배열을 사용하여 데이터를 저장하고 처리할 때 타입 별칭을 사용할 수 있습니다. 예를 들어, 문자열 배열을 더 명시적으로 표현하고자 할 때 사용합니다.
   
   
3. 튜플 타입 별칭 예시:

   typealias Coordinate = (x: Double, y: Double)
   

   이제 Coordinate는 (x: Double, y: Double)의 별칭으로 사용됩니다.
   
   튜플을 사용하여 여러 데이터 유형을 묶어 표현할 때도 타입 별칭을 활용할 수 있습니다. 예를 들어, 좌표를 나타내는 튜플을 정의할 때 사용합니다.

타입 별칭은 기존 타입에 의미 있는 이름을 부여하여 코드를 읽기 쉽게 만들고, 특히 특정 맥락에서 더 적합한 이름을 사용할 수 있도록 도와줍니다.

---

부울 (Booleans)

Swift는 Bool이라 불리는 기좀 Boolean type을 갖습니다. 또한 2개의 Bool 값인 true, false를 제공하고, 참과 거짓으로 표현되기 때문에 논리적인 값으로 참조됩니다.

let orangesAreOrange = true
let turnipsAreDelicious = false

 

위에서 설명한 것과 마찬가지로, Bool 타입도 타입 추론이 되기 때문에 true나 false 값을 미리 추가해준다면 Bool 타입을 선언할 필요가 없습니다.

부울 값은 if문과 같은 조건문에서 유용하게 사용됩니다.

if turnipsAreDelicious {
    print("Mmm, tasty turnips!")
} else {
    print("Eww, turnips are horrible.")
}
// Prints "Eww, turnips are horrible."

 

Swift의 타입 세이프티는 부울이 아닌 값이 Bool로 대체되는 것을 방지하기 위해 컴파일 시 에러를 발생시킵니다.

let i = 1
if i {
    // this example will not compile, and will report an error
}

 

아래와 같이 해주면 동작합니다.

i == 1 비교 결과는 Bool 타입이므로, if문의 조건 절에 사용될 수 있습니다.

(❗️계속해서 타입 세이프티를 강조하는 느낌..😅)

let i = 1
if i == 1 {
    // this example will compile successfully
}

---

튜플 (Tuples)

튜플은 여러 값을 단일 복합 값으로 그룹화 합니다. 또한 튜플 안에 값은 어떠한 타입도 가능하며 서로 같은 타입일 필요는 없습니다.

아래 예시는 HTTP 상태 코드를 나타내는 튜플로, Int와 String 타입의 값을 함께 그룹화하여 제공합니다.

해당 상수의 튜플 타입은 (Int, Stirng)으로 설명할 수 있습니다.

let http404Error = (404, "Not Found")

 

모든 타입의 튜플을 만들 수 있으며, 원하는 만큼 다른 타입을 포함할 수 있습니다.

(❗️왜 여기서 permutation(: 순열) 단어를 썼는지 의문이었는데, 찾아보니 permutation이 여러 가지 유형을 조합하여 만들 수 있는 다양한 조합을 나타낸다고 합니다!)

 

(❗️다시 말해, 여러 가지 유형의 타입들을 조합하여 튜플을 만들 수 있다!)

 

튜플의 값들을 별도로 상수와 변수로 분해하여 사용할 수도 있습니다.

statusCode에 404가, statusMessage에는 “Not Found”가 저장된 겁니다.

let (statusCode, statusMessage) = http404Error
print("The status code is \\(statusCode)")
// Prints "The status code is 404"
print("The status message is \\(statusMessage)")
// Prints "The status message is Not Found"

 

만약 튜플의 값들 중 일부만 필요하다면 **밑줄(_)**을 사용하면 됩니다.

튜플의 두 번째 값이 필요가 없기 때문에 (_)을 사용하여 분해할 때 무시합니다.

(❗️언더바를 쓰는 것을 wildcard pattern이라고 부른대요!)

// 밑줄(_)로 튜플의 일부 무시
let (justTheStatusCode, _) = http404Error
print("The status code is \\(justTheStatusCode)")
// Prints "The status code is 404"

 

또는, 0으로 시작하는 인덱스를 사용하여 튜플의 개별 요소 값에 접근 가능합니다.

print("The status code is \\(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \\(http404Error.1)")
// Prints "The status message is Not Found"

 

튜플을 정의할 때, 각각의 요소에 이름을 정할 수 있습니다.

let http200Status = (statusCode: 200, description: "OK")

 

만약 튜플 요소에 이름이 있다면, 요소의 이름으로 접근이 가능합니다.

print("The status code is \\(http200Status.statusCode)")
// Prints "The status code is 200"
print("The status message is \\(http200Status.description)")
// Prints "The status message is OK"

 

튜플은 함수의 반환 값으로 특히 유용합니다. 웹 페이지를 검색하는 함수는 성공이나 실패를 전달하기 위해 (Int, String) 튜플 타입을 반환합니다. 이 함수는 각각 다른 타입의 2가지 고유 값을 같는 튜플을 리턴하여 단일 값만 리턴하는 함수보다 유용하게 사용할 수 있습니다.

 

튜플은 복잡한 데이터 구조에는 적합하지 않고, 관련된 값의 간단한 그룹을 만들 때 유용합니다.

만약 데이터 구조가 복잡한 경우에는 튜플이 아닌 클래스나 구조체를 사용해야 합니다.

---

옵셔널 (Optionals)

값이 없는 경우에 옵셔널을 사용합니다.

옵셔널은 두 가지 경우가 있는데, 하나는 지정된 타입의 값이 있어 옵셔널을 언래핑해서 값에 접근하는 것이고, 다른 하나는 값이 없는 것 입니다.

 

아래 예시는 String을 Int로 초기화는 코드입니다. 그러나 String 타입의 값이 Int로 초기화 될 때 실패할 가능성이 있기 때문에 Int 타입이 아닌 옵셔널 Int타입을 반환하는 겁니다.

(❗️만약 Stirng 타입의 값이 “Hello”라면 초기화가 실패될 것입니다.)

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// The type of convertedNumber is "optional Int"

---

nil

옵셔널 변수에 값이 없음을 나타내기 위해 nil로 지정할 수 있습니다.

var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value

 

기본값 없이 옵셔널 타입의 변수가 지정이 된다면 기본적으로 nil 값이 선언됩니다.

var surveyAnswer: String?
// surveyAnswer is automatically set to nil

 

if 문으로 같음 연산자 (==) 또는 같지 않은 연산자 (! =)을 사용하여 옵셔널이 값을 갖는지를 확인할 수 있습니다.

nil과 같지 않다면 옵셔널은 값을 갖고 있는 겁니다.

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)

if convertedNumber != nil {
    print("convertedNumber contains some integer value.")
}
// Prints "convertedNumber contains some integer value."

 

옵셔널 타입이 아닌 변수나 상수에는 nil을 사용할 수 없습니다. 만약 옵셔널이 아닌 값에 nil을 할당한다면 컴파일 오류가 발생합니다.

옵셔널과 옵셔널이 아닌 값의 부리는 누락된 정보를 누락된 정보를 분명히 표시할 수 있고, 이런 실수는 컴파일 시간에 오류를 발생하므로 옵셔널을 옵셔널이 아닌 것처럼 사용할 수 없습니다.

 

옵셔너 값에 접근할 때, nil과 nil이 아닌 것에 대해 모두 다뤄야 합니다. 값이 없을 때 할 수 있는 방식이 몇 가지가 있습니다.

• nil일 때 해당 값에 대한 동작을 스킵합니다.
• nil을 리턴하거나, 옵셔널 체인에서 설명할 ? 연산자를 사용하여 nil을 전파합니다.
• ?? 연산자를 사용하여 대체 값(fallback value)을 제공합니다.
• ! 연산자를 사용하여 프로그램 실행을 멈춥니다.

Objective-C에서 nil은 객체가 존재하지 않는 포인터이지만, Swift에서는 포인터가 아닙니다.

특정 타입의 값이 없음을 나타내고, 모든 옵셔널 타입은 객체 타입 뿐만 아니라 모두 nil로 설정할 수 있습니다.

---

옵셔널 바인딩 (Optional Binding)

옵셔널 바인딩은 옵셔널이 값을 포함하고 있는지를 확인하고, 값이 있다면 일시적으로 상수나 변수로 사용할 수 있게 하는 방식입니다.

if, guard, while문을 통해 내부에 값이 있는지 체크하고 단일 동작의 일부로 상수나 변수로 추출할 수 있습니다.

아래 예시 코드를 보면 옵셔널 타입의 someOptional이 값을 갖고 있다면 contantName으로 바인딩이 되어

if 구문 내에서 그 값을 사용할 수 있습니다.

if let <#constantName#> = <#someOptional#> {
   <#statements#>
}

 

값에 접근한 후에 기존 옵셔널 상수 또는 변수를 참조할 필요가 없다면 같은 이름으로 새로운 상수 또는 변수를 사용할 수 있습니다.

if let myNumber = myNumber {
    // Here, myNumber is a non-optional integer
    print("My number is \\(myNumber)")
}

 

위의 코드를 더 짧게 사용하여 옵셔널 값을 언래핑할 수 있습니다.

if let myNumber {
    print("My number is \\(myNumber)")
}
// Prints "My number is 123"

 

위에 예제코드에서 계속 let을 사용하여 바인딩하고 있는데, var를 쓰면 변수로 바인딩해서 사용할 수 있습니다.

만약 해당 변수를 if문 내에서 값을 바꾼다면 이는 지역 변수에만 적용이되고, 기존 언패링된 옵셔널 상수 또는 변수에 적용되지 않습니다.

let myName: String? = "Leo"

if var myName {
    myName = "홍길동"
    print("지역 변수: \\(myName)")
}

// 강제 언래핑
print(myName!)

 

if 구문에 쉼표로 구분하여 옵셔널 바인딩과 조건 판단을 여러 개 포함할 수 있습니다.

옵셔널 바인딩 값 중 nil이 있거나, 조건 문에 false가 하나라도 있다면 전체 if문의 조건은 fasle로 간주됩니다.

if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
    print("\\(firstNumber) < \\(secondNumber) < 100")
}
// Prints "4 < 42 < 100"

if let firstNumber = Int("4") {
    if let secondNumber = Int("42") {
        if firstNumber < secondNumber && secondNumber < 100 {
            print("\\(firstNumber) < \\(secondNumber) < 100")
        }
    }
}
// Prints "4 < 42 < 100"

 

if문으로 옵셔널 바인딩한 상수나 변수는 해당 구문의 본문에서만 사용가능합니다. 그러나 guard 구문으로 옵셔널 바인딩을 한다면 guard 구문 밖에서 사용 가능합니다.

let myName: String? = "Leo"
let myAge: Int? = nil

func useGuardOptionalBinding() {
    guard let myName else {
        print("nil입니다.")
        return
    }
    
    // 바인딩된 myName을 guard문 밖에서 사용합니다.
    print(myName)
    
    guard let myAge else {
        // 값이 없으므로 guard문의 else 구문이 실행됩니다.
        print("nil입니다.")
     return
    }

    // 위에 guard문에서 해당 함수가 종료되어 실행되지 않습니다.
    print(myAge)
    
}

useGuardOptionalBinding()

---

대체값 제공 (provide a Fallback Value)

옵셔널 타입이 값이 없는 상황을 다루기 위해 nil-결합 연산자 (??)를 사용하여 디폴트 값을 제공할 수 있습니다.

옵셔널에서 ?? 의 왼편이 nil 이 아니면, 값은 언래핑되고 사용됩니다. 그렇지 않으면 ?? 의 오른편에 값이 사용됩니다.

let name: String? = nil
let greeting = "Hello, " + (name ?? "friend") + "!"
print(greeting)
// Prints "Hello, friend!"

---

강제 언래핑 (Force Unwrapping)

nil이 프로그래머의 에러나 원치않은 상태와 같이 회복할 수 없는 실패를 나타낼 때, 옵셔널의 뒤에 느낌표 (!)를 추가하여 접근할 수 있습니다. 이것을 강제 언래핑이라고 합니다. 또한 nil을 강제 언래핑한다면 런타임 에러를 유발합니다.

 

(❗️사실 처음에는 이 말이 이해되지 않았습니다만, 계속 고민해본 결과

이 말은 프로그래머의 실수나 회복할 수 없는 실패를 나타낸다는 것인데, 이는 해당 애플리케이션에서 심각한 문제가 발생하여 더 이상 앱을 지속하는 것이 부적절하고 프로그램을 강제 종료시켜야 한다는 것을 의미하는 것 같습니다.

따라서 이 상황에서는 강제 언래핑을 사용하여 nil을 확인하고, nil을 통해 심각한 문제가 확인되면 앱을 종료시켜버리는 것을 나타냅니다.)

 

(❗️하지만, 강제 종료는 사용자에게 좋은 경험을 제공하지 않기 때문에, 개발자는 이러한 상황에 대비하여 앱을 강제로 종료시키는 대신 또 다른 해결책을 마련하는 것이 필요합니다!!)

 

(❗️발생 할만한 문제를 미리 생각하고, 예외처리를 해둬야겠죠??)

 

느낌표(!)는 fatalError(_:file:line:)의 짧은 작성법입니다.

fatalError(_:file:line:) | Apple Developer Documentation

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)

let number = convertedNumber!

// converedNumber가 Nil일 경우 else 구문 실행
guard let number = convertedNumber else {
    fatalError("The number was invalid")
}

---

암시적으로 언래핑된 옵셔널 (Implicitly Unwrapped Optionals)

프로그램 구조상 옵셔널이 값을 처음 설정한 후에 항상 값을 갖는 것이 분명할 때가 있습니다.

이러한 경우 항상 값이 있다고 가정할 수 있기 때문에 접근할 때마다 옵셔널의 값을 확인하고 언래핑할 필요가 없습니다.

 

이러한 옵셔널을 암시적으로 언래핑 된 옵셔 (implicitly unwrapped optionals)로 정의합니다.

옵셔널 타입을 만들 때 물음표(?) 대신 느낌표(!)를 써서 암시적으로 언래핑 된 옵셔널을 작성합니다.

 

하지만, 암시적으로 언래핑된 옵셔널이 nil일 경우에 접근한다면 런타임 에러가 발생합니다.

사용할 때 옵셔널 이름의 뒤에 느낌표를 위치시키는 것보다 선언할 때 옵셔널 타입 뒤에 느낌표를 위치시키는 것이 더 좋습니다.

 

(❗️강제 언래핑을 하는 것보다, 처음부터 암시적으로 언래핑된 옵셔널 타입으로 선언하는 게 더 좋다는 말입니다.)

 

암시적으로 언래핑된 옵셔널은 처음 정의된 직후 값이 존재하는 것으로 확인되고 그 이후 모든 시점에 존재한다고 가정할 수 있는 경우에 유용합니다. 예를 들어 Swift에서는 클래스 초기화 중에 주로 사용합니다.

 

암시적으로 언래핑된 옵셔널 사용이 옵셔널을 강제로 언래핑을 허락하는 것으로 생각할 수 있지만 아닙니다.

 

Swift는 해당 값을 사용할 때 기존의 옵셔널 값으로 사용하려고 하고 사용이 불가능할 경우 Swift는 강제 언래핑을 합니다.

따라서 아래의 implicitString은 String 타입, optionalString은 String? 타입으로 서로 다릅니다.

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // Requires explicit unwrapping

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // Unwrapped automatically

let optionalString = assumedString
// The type of optionalString is "String?" and assumedString isn't force-unwrapped.

 

(❗️요건 처음 알았어요.. 무슨 말이냐면, 암시적으로 언래핑된 옵셔널 타입의 값을 사용하려고 할 때 해당 값을 옵셔널 타입의 값으로 사용해도 된다면 Swift는 옵셔널 값을 그대로 사용합니다. 하지만 옵셔널 값을 사용하면 안되는 경우에는 Swift가 언래핑을 해서 값을 사용한다는 말입니다.)

(❗️더 간단하게 말해서 암시적으로 언래핑된 옵셔널 타입의 값을 사용할 때, 값이 옵셔널 그대로 사용해도 되는 경우 그렇게 하고, 그렇지 않다면 강제 언래핑을 통해 해당 값을 사용합니다. 그 후에는 해당 값을 사용할 때 언래핑된 값으로 취급됩니다!)

(❗️아래 print문에서 assumedString의 값을 언래핑할 필요가 없기 때문에 옵셔널 값 그대로 프린트 되는 것입니다.)

let assumedString: String! = "An implicitly unwrapped optional string."

print(assumedString)
// 출력: Optional("An implicitly unwrapped optional string.")

---

에러 처리 (Error Handling)

프로그램이 실행되는 동안 에러가 발생할 때를 대응하기 위해 에러 처리를 사용합니다.

값의 존재 유무로 함수의 성공 여부를 알려주는 옵셔널과는 달리, 에러 처리는 실패의 원인을 알 수 있고 다른 곳으로 에러를 전파할 수도 있습니다.

 

함수가 에러 조건을 만나면 에러(error)를 던지고, 함수의 호출자는 에러를 포착(catch)하고 적절히 대응합니다.

함수의 선언에 throws 키워드를 포함시켜 에러가 발생할 수 있음을 나타내고, 해당 함수를 호출할 때는 표현식 앞에 try 키워드를 붙입니다(= 래핑합니다).

 

또한, do 구문은 에러를 하나 이상의 catch 절로 전파할 수 있는 새로운 번위를 만들고, Swift는 던져진 에러가 catch 절에 의해 처리될 때까지 에러를 자동으로 전파합니다.

func makeASandwich() throws {
    // ...
}

do {
    try makeASandwich()
    eatASandwich()
} catch SandwichError.outOfCleanDishes {
    washDishes()
} catch SandwichError.missingIngredients(let ingredients) {
    buyGroceries(ingredients)
}

---

역설과 전제 조건 (Assertions and Preconditions)

Assertion과 Precondition은 런타임에 발생하는 사항을 확인하는 도구입니다. 추가 코드를 실행하기 전에 필수 조건이 충족되었는지 확인할 수 있습니다.

 

만약 Assertion 또는 Precondition에서 false로 판단된다면 프로그램은 종료됩니다. Assertion은 개발 과정에서 실수나 잘못된 가정을 찾는 데 도움이 되며, Precondition은 프로덕션에서 이슈를 감지하는 데 도움이 됩니다.

 

에러 처리와는 달리 Assertion과 Precondition은 에러를 해결하기 위해 사용되지 않고, 문제가 발생하면 프로그램을 즉시 종료시킵니다. 이는 가정을 확인하지 않고 문제가 발생하여 사용자 데이터가 손상되기 전에 문제를 빠르게 감지하여 예방하는 데 도움이 됩니다.

 

Assertion과 Precondition의 주요 차이는 언제 체크되는지에 있습니다. Assertion은 주로 디버그 빌드에서만 확인되지만, Precondition은 디버그와 프로덕션 빌드에서 모두 검사됩니다.

 

Assertion은 프로덕션 빌드에서 확인되지 않기 때문에 성능에 영향을 미치지 않고 개발 단계에서만 사용할 수 있습니다.

---

역설을 통한 디버깅 (Debugging with Assertions)

Swift 표준 라이브러리에서 assert(_:_:file:line:) 함수를 사용하면 됩니다.

이 함수에 true 또는 false로 판단될 표현식과 false일 경우 출력할 메세지를 전달하면 됩니다.

let age = -3
assert(age >= 0, "A person's age can't be less than zero.")
// This assertion fails because -3 isn't >= 0.

assert(::file:line:) | Apple Developer Documentation

 

또한, 메시지를 생략하여 사용할 수도 있습니다.

assert(age >= 0)

 

코드가 이미 assertion 조건을 체크했다면 assertionFailure(_:file:line:) 함수를 사용합니다.

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}

assertionFailure(_:file:line:) | Apple Developer Documentation

---

강제 전제조건 (Enforcing Preconditions)

precondition은 코드가 실행되기 위해서 반드시 참인 경우에만 사용합니다. 예를 들어 사용하는 값들이 범위를 벗어나거나 유효 값이 전달되는지를 체크하기 위해 사용합니다.

precondition(::file:line:) 함수를 사용하여 실패를 알릴 수 있고, 만약 조건이 false라면 설정해둔 오류 구문을 출력합니다.

// In the implementation of a subscript...
precondition(index > 0, "Index must be greater than zero.")

 

(-Ounchecked) 모드를 체크하지 않고 컴파일을 한다면, precondition은 체크되지 않습니다.

컴파일러는 항상 precondition을 항상 true라고 가정하고 코드를 최적화합니다.

 

그러나 fatalError(_:file:line:) 함수는 최적화 설정과 무관하게 항상 실행을 중지시킵니다.

 

프로토타입과 초기 개발단계에서 아직 구현되지 않은 기능에서 fatalError(_:file:line:) 을 사용할 수 있으며 fatalError("Unimplemented") 와 같이 작성할 수 있습니다.

 

assertions과 preconditions와 달리, fatal error는 절대 최적화 되지 않기 때문에 해당 코드를 만나면 항상 프로그램이 중지됩니다.

 

---

마무리

이거 언제 다 보고, 언제 다 정리하죠..?

생각보다 엄청 길어요.. 그래도 새롭게 알게된 내용도 있고 머리에 정리도 잘 되는 느낌이라..

꾸준하게 작성해보겠습니다.😅

---

잘못된 내용이나 궁금하신 점이 있다면 댓글 남겨주세요. 🤓

읽어주셔서 감사합니다.

---

📝 참고 자료

Swift 공식 문서 - The Basics

공식 문서 (한글 버전) 기본 (The Basics)

https://didu-story.tistory.com/145

https://icksw.tistory.com/2