[Swift] 공식문서 01 - The Basics (기본)

 

공식문서 정리하기 01 탄

의역과 요약이 조금씩 들어가있습니다.

 

The Basics — The Swift Programming Language (Swift 5.5)

 

1차 수정 (2022 / 02 / 24) : 의역 및 오타 수정

 

The Basics

Swift는 iOS, macOS, watchOS, 그리고 tvOS 앱 개발을 위한 새로운 프로그래밍 언어이다. 그럼에도 불구하고 Swift의 많은 부분은 C와 Objective-C에서 개발한 경험과 비슷할 것입니다. 

 

 

Swift는 모든 기본 C 및 Objective-C 유형의 자체 버전을 제공합니다.

- 정수를 위한 Int, 소수점 값을 위한 Double 과 Float, Boolean 값을 위한 Bool, 텍스트 데이터를 위한 String.

Swift는 또한 3가지 기본 Collection types의 강력한 버전을 제공합니다.

- Array, Set, Dictionary

 

 

C와 마찬가지로 Swift는 변수를 사용하여 식별 이름으로 값을 저장하고 참조합니다. 또한 Swift는 값을 변경할 수 없는 변수를 전범위적으로 사용합니다. 이 변수는 Constant(상수)라고 잘 알려져 있는데 C에서의 Constant 보다 훨씬 강력합니다. Swift에서는 변경할 필요가 없는 값을 사용하여 작업할 때 의도된 코드를 더 안전하고 명확하게 하기 위해 Constant 를 사용합니다. 

 

 

Swift는 익숙한 유형 외에도 튜플과 같은 Objective-C에는 없는 고급 유형을 도입합니다. 튜플을 사용하면 값 그룹을 만들고 전달할 수 있습니다. 튜플을 사용하여 함수에서 여러 값을 단일 복합 값으로 반환할 수 있습니다.

 

또한 Swift는 값의 부재를 처리하는 Optional types 를 도입합니다. 옵션에서는 "값이 있고 x와 같다" 또는 "값이 전혀 없다"라고 말합니다. 옵션을 사용하는 것은 Objective-C에서 포인터와 함께 nil을 사용하는 것과 유사하지만 클래스뿐만 아니라 모든 type 에서 작동합니다. 옵션들이 Objective-C의 제로 포인터보다 안전하고 표현력이 뛰어날 뿐만 아니라 스위프트의 가장 강력한 기능들 중 많은 부분에 있습니다.

 

 

Swift는 안전한 유형 언어이며, 이는 언어가 코드가 사용할 수 있는 값의 유형을 명확하게 하는 데 도움이 된다는 것을 의미합니다. 코드의 일부에서 String 이 필요한 경데 Int 를 전달할 경우, Type Saftey가 이를 막아 전달되지 않습니다. 마찬가지로, Type Safety는 non-optional String 이 필요한 곳에  optional String이 실수로 전달되는 것을 방지합니다. Type Safety는 개발 프로세스에서 오류를 최대한 빨리 포착하고 수정하는 데 도움이 됩니다.

 

요약

Swift의 가장 큰 장점이자 특징은 안정성이라고 할 수 있다. Optional Types 와 Type Safety를 통해 안정성을 추구한다.

 

 

 

Constants and Variables (상수와 변수)

Constant(상수)와 Variables(변수)는 이름(예: maximumNumberOfLoginAttempts 또는 welcomeMessage)을 특정 유형 값(예: 숫자 10 또는 문자열 "Hello")과 연결합니다. Constant의 값은 일단 설정되면 변경할 수 없지만 Variable은 나중에 다른 값으로 설정할 수 있습니다.

 

 

상수와 변수 선언

Constant와 Variable 은 사용하기 전에 선언해야 합니다.  let 을 사용하여 Constant 를 선언하고 var 를 사용하여 Variable을 선언합니다. 다음은 상수와 변수를 사용하여 사용자가 시도한 로그인 횟수를 추적하는 방법에 대한 예입니다.

 

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

이 코드는 다음과 같이 읽을 수 있습니다.

"maximumNumberOfLoginAttempts라는 새 Constant 를 선언하고 값을 10으로 지정합니다. 그런 다음 currentLoginAttempt라는 새 Variable 을 선언하고 초기 값을 0으로 지정합니다."

이 예시에서는 최대값은 변경되지 않기 때문에 허용되는 '최대 로그인 시도 횟수'가 Constant 로 선언됩니다. 로그인 시도 실패 시마다 값을 증가시켜야 하므로 '현재 로그인 시도 카운터'가 Variable 로 선언됩니다.

 

아래와 같이 여러 상수 또는 여러 변수를 쉼표로 구분하여 한 줄에 선언할 수 있습니다.

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

 

요약

저장된 값이 변하지 않는다       - Constant -> let 으로 선언

변경할 수 있는 값을 사용한다   - Variable -> var로 선언

 

 

Type Annotations (타입 표시하기)

상수 또는 변수를 선언할 때 상수 또는 변수가 저장할 수 있는 값의 종류를 명확히 하기 위해 Type Annotations 을 사용할 수 있습니다. 상수 또는 변수 이름 뒤에 : (콜론)을 배치하고 공백 뒤에 사용할 타입 이름을 작성하여 Type Annotations을 작성합니다.

 

아래 예시는 welcomeMessage 라는 변수가 String 값을 저장 할 수 있는 변수라는 것을 알려준다.

var welcomeMessage: String

 

선언문의 : 은 "…무슨 무슨 type" 을 의미한다. 위 코드는 다음과 같이 읽을 수 있다.

"String 이라는 type을 가진 welcomeMessage 변수를 선언한다"

 

쉼표로 구분된 동일한 유형의 관련 변수를 한 줄에 여러 개 정의할 수 있으며, 최종 변수 이름 뒤에 단일 유형 주석을 사용할 수 있습니다.

var red, green, blue: Double

 

실제로 Type Annotations 을 작성해야 하는 경우는 드뭅니다. 정의된 지점에서 상수 또는 변수에 대한 초기 값을 제공하는 경우 Swift는 Type Safety 과 Type Inference에 설명된 대로 거의 항상 해당 상수 또는 변수에 사용할 타입을 유추할 수 있습니다. 위의 welcomeMessage 예제에서는 초기 값이 제공되지 않으므로 welcomeMessage 변수의 유형은 초기 값에서 유추되지 않고 Type Annotations으로 지정됩니다.

요약

Type Annotations, 의역하면 타입에 대한 설명. 초기값을 제공하지 않는 상수 또는 변수에 Type Annotations을 사용해 안정성을 높인다. 초기값이 있으면 Swift 가 알아서 Type을 추론하므로 특정 경우에만 사용된다.

 

 

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

상수 및 변수 이름에는 유니코드 문자를 포함하여 거의 모든 문자가 포함될 수 있습니다.

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

상수 및 변수 이름에는 공백 문자, 수학 기호, 화살표, 전용 유니코드 스칼라 값, - , 상자-그리기(box-drawing) 문자를 사용할 수 없습니다. 숫자로 시작할 수도 없습니다. 다만 이름 안에 숫자가 포함될 수도 있습니다.

특정 유형의 상수 또는 변수를 선언했으면 같은 이름으로 다시 선언하거나 다른 유형의 값을 저장하도록 변경할 수 없습니다. 또한 상수를 변수로 변경할 수도 없고 변수로 상수로 변경할 수도 없습니다.

 

상수 또는 변수에 기존의 Swift 키워드와 동일한 이름을 지정해야 하는 경우 키워드를 이름으로 사용할 때 백틱(' 숫자 1 옆에 있는 거)으로 둘러싸십시오. 그러나 키워드를 이름으로 사용하는 것은 선택사항이 전혀 없는 한 피하십시오.

 

기존 변수의 값을 호환되는 유형의 다른 값으로 변경할 수 있습니다. 

var Hello = "안녕"
Hello = "Bonjour"

Hello 가 "안녕" 에서 "Bonjour" 로 변경되었다.

 

변수와 달리 let으로 선언한 상수 값은 나중에 변경할 수 없습니다.

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

컴파일 에러가 발생합니다.

 

요약

상수와 변수 선언시 유니코드를 포함한 대부분의 문자 사용가능.

예외로는 공백 문자, 수학 기호, 화살표, 전용 유니코드 스칼라 값, - , 상자-그리기(box-drawing) 문자, 숫자로 시작하는 이름.

기존 Swift 키워드도 `(백틱) 을 붙이면 사용가능하나 가능하면 사용하지 말 것 (혼란을 일으킨다구~)

 

 

Printing Constants and Variables (상수와 변수 출력)

print(_:separator:terminator:) 함수를 사용해 상수와 변수의 현재 값을 출력할 수 있다.

위 예시의 Hello를 출력하면 다음과 같다.

print(Hello)
// Prints "Bonjour"

print 함수는 하나 혹은 그 이상의 값들을 정확히 출력해주는 전역 함수이다. 예를 들어 Xcode에서 print 함수는 Xcode의 "console" 창에 출력한다. print함수의 인자인 separator 와 terminator 는 default(기본) 값을 가지므로 생략이 가능하다. 기본적으로 함수는 줄 바꿈을 추가하여 출력한다. 줄 바꿈 없이 값을 출력하려면 빈 문자열을 종결자로 전달합니다

예시 : print(someValue, terminator: "")

 

Swift는 string interpolation(문자열 보간)을 사용하여 상수 또는 변수의 이름을 더 긴 문자열에 자리 표시자로 포함시키고 Swift가 상수 또는 변수의 현재 값으로 바꾸도록 요청합니다. 이름을 괄호로 묶고 여는 괄호 앞에 백슬래시로 이스케이프합니다.

print("Hello의 현재 값은 \(Hello)")
// "Hello의 현재 값은 Bonjour" 를 출력한다

 

요약

print 함수를 통해 출력을 한다. \()를 통해 변수와 상수를 출력한다.

 

 

 

 

Comments ( 주석 )

메모 또는 주의사항으로 코드에 존재하지 않는 텍스트를 포함하려면 주석을 사용합니다. 주석은 컴파일될 때 Swift 컴파일러에 의해 무시됩니다.

 

Swift의 주석은 C의 주석과 매우 유사하다. 한 줄 설명은 두 개의 슬래시로 시작합니다. 

// 를 앞에 붙이면 주석이 돼요

 

여러 줄의 주석은 앞에  /* 로 시작하고, 뒤에 */ 로 끝납니다.

/* 두줄 주석
사용법 */

 

Nested multiline comments (주석 중첩)

C의 여러 줄 주석과 달리, Swift의 여러 줄 주석은 다른 여러 줄 주석 안에 중첩될 수 있습니다. 

/* 주석
/* 안에 주석 */
이 가능해요 */

Nested multiline comments를 통해 이미 주석이 있어도 쉽게 주석 처리를 할 수 있다.

 

보통 주석처리를 단축키를 사용해서 하는데 중첩이 가능해서 편리한다.

 

요약

주석 달 때 단축키 cmd + / 사용. 주석 중첩가능

 

 

 

Semicolons

다른 언어와 달리, Swift는 코드에서 각 문 뒤에 세미콜론(;)을 쓸 필요가 없지만 원할 경우 세미콜론(;)을 쓸 수도 있습니다. 단 한 줄에 여러 개의 문을 쓰려면 세미콜론이 필요합니다.

let cat = "🐱"; print(cat)

요약

; 사용 안해도 됨. 1줄에 여러가지 Statement(문) 를 작성할 수 있음. (근데 이렇게 코딩 잘 안함)

 

 

 

 

Integers

정수는 42와 -23과 같이 소수점이 없는 정수입니다. 정수는 signed(양수, 0 또는 음수 처럼 부호가 있는) 또는 unsigned(양수 또는 0 처럼 부호가 없는)이다.

Swift는 8, 16, 32 및 64비트 형식으로 signed 와 unsigned 를 제공합니다. 이러한 정수는 8비트 부호 없는 정수는 UInt8 유형이고 32비트 부호 있는 정수는 Int32 유형이라는 점에서 C와 유사한 명명 규칙을 따릅니다. Swift의 모든 형식과 마찬가지로 이러한 정수 형식도 대문자로 된 이름을 가집니다.

 

Integer Bounds (정수 범위)

min과 max를 사용해 각 정수 유형의 최소 및 최대 값을 알 수 있습니다.

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는 현재 운영체제(platform)의 기본 단어 크기와 같은 크기를 가진 추가 정수 유형인 Int를 제공합니다.

32bit 운영체제 -> Int = Int32

64bit 운영체제 -> Int = Int64

 

특정 크기의 정수로 작업할 필요가 없는 경우 코드의 정수 값에 항상 Int를 사용합니다. 이는 코드 일관성과 상호 운용성을 지원합니다. 32비트 플랫폼에서도 Int는 -2,147,483,648과 2,147,483,647 사이의 값을 저장할 수 있어 충분히 큽니다.

 

UIntSwift는 또한 현재 운영체제(platform)의 기본 단어 크기와 같은 크기를 가진 unsigned 유형인 UInt를 제공합니다.

32bit 운영체제 -> UInt = UInt32

64bit 운영체제 -> UInt = UInt64

 

특별히 unsigned가 필요한 경우가 아니면 Int를 사용한다. (저장할 값에 양수만 있더라고) Type Safety and Type Inference 의  설명처럼 정수 값에 Int를 일관되게 사용하면 코드 상호 운용성에 도움이 되고, 다른 숫자 유형 간에 변환할 필요가 없다.

 

요약

정수 선언할 때 Int 사용.크기는 운영체제를 따라감(요즘은 보통 64bit, 아이폰도 i-phone 5s 부터 64bit)진짜 진짜 진짜 특별한 경우가 아니면 UInt 사용하지 않는다 -> Int 를사용 (Int를 일관되게 사용하면 코드 상호 운용성에 도움이 되고, 다른 숫자 유형 간에 변환할 필요가 없다.)

 

 

 

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

부동 소수점 숫자는 3.14159, 0.1 및 -273.15와 같이 소수점 성분이 있는 숫자입니다.

부동 소수점 숫자는 정수 타입(integer)보다 훨씬 넓은 범위의 값을 나타낼 수 있으며 Int에 저장할 수 있는 숫자보다 훨씬 크거나 작은 숫자를 저장할 수 있습니다. Swift는 두 가지 부호 부동 소수점 숫자 타입을 제공합니다.

Double - 64bit floating-point number

Float - 32bit floating-point number

 

Double  의 정확도는 소수점 15자리, Float은 소수점 6자리까지이다. 사용할 적절한 부동 소수점 유형은 코드에서 사용해야 하는 값의 특성과 범위에 따라 달라진다. 두 가지 유형 중 하나가 적절한 경우에는 Double이 선호된다.

 

요약

소수점 숫자를 표현하고 싶으면 Double과 Float 을 사용한다. 근데 더 많은 소수점 자리를 표현할 수 있는 Double이 선호된다.

 

Type Safety and Type Inference (타입 안전성과 타입 추론)

Swift 는 type-safe 언어이다. Type safe 언어는 코드를 작성할 때 사용할 수 있는 값의 타입을 명확히 할 수 있다. String을 써야할때 실수로 Int 가 사용되는 실수를 막아준다

 

Swift는 type safe 하므로 코드를 컴파일할 때 타입을 확인하고 일치하지 않는 타입을 오류로 나타낸다. 이를 통해 개발 과정에서 오류를 최대한 빨리 포착하고 수정할 수 있다. 

 

Type-Checking 은 다른 타입 값들을 다룰 때 에러를 피하게 도와준다. 그렇다고 해서 선언하는 모든 상수와 변수의 타입을 정확히 할 필요는 없다. 타입을 정확히하지 않아도  Swift는 type-inference를 통해 적절한 타입을 추론해낸다. type-inference를 사용하면 컴파일러가 코드를 컴파일할 때 사용자가 제공한 값을 검사하는 것만으로 특정 식의 타입을 자동으로 추론할 수 있습니다.

 

type-inference 로 인해, Swift는 C와 Objective-C에 비해 적은 타입 선언을 요구한다. 상수와 변수는 여전히 명시적으로 입력되어 있지만, 상수와 변수의 유형을 지정하는 작업은 대부분 사용자를 위해 수행된다.

 

type-inference는 상수 또는 변수를 초기 값과 함께 선언할 때 특히 유용하다. 이것은 종종 사용자가 선언하는 지점의 상수 또는 변수에 리터럴 값(또는 리터럴)을 할당하여 수행됩니다. (리터럴 값은 아래 예에서 42 및 3.14159와 같이 소스 코드에 직접 나타나는 값입니다.)

예를 들어, 어떤 유형인지 말하지 않고 리터럴 값을 새 상수에 할당하면, Swift는 상수를 정수처럼 보이는 숫자로 초기화했기 때문에 상수가 Int가 되기를 원한다고 추측합니다.

let meaningOfLife = 42
// meaningOfLife 은 Int 타입으로 추론된다
let pi = 3.14159
// pi 는 Double 타입으로 추론된다

Swift는 부동 소수점 숫자에 대해 항상 Double 을 선택한다. (Float 대신)

만약 Int 와 floating-point를 섞어서 표현하면 Double로 추론된다.

let anotherPi = 3 + 0.14159
// anotherPi 는 Double 타입으로 추론된다

 

요약

Swift는 타입을 정하지 않아도 초기값을 보고 알아서 타입을 추론해준다. 이를 통해 컴파일 시 일치하지 않는 타입을 오류로 나타내 안정성을 높일 수 있게 된다.

 

 

Numeric Literals (숫자 리터럴)

Integer Literals 는 다음과 같이 쓰인다

• 십진수 (decimal), 접두사 없이
• 2진수 (binary) , 0b 와 함께
• 8진수 (octal) , 0o 와 함께
• 16진수 (hexademical) , 0x와 함께

십진수 17을 예시로 들면

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

부동 소수점 숫자는 십진수 혹은 16진수로 쓸 수 있다. 대신 소수점 앞 뒤로 무조건 숫자가 있어야 한다. 십진수 float 은 e를 통해 선택적ㅇ으로 지수를 표현할 수 있다. 16진수 floats 도 p로 지수를 나타낼 수 있다

 

• 1.25e2 means 1.25 x 10^2, or 125.0.
• 1.25e-2 means 1.25 x 10^(-2), or 0.0125.

• 0xFp2 means 15 x 2^2, or 60.0.
• 0xFp-2 means 15 x 2^(-2), or 3.75.

십진수 12.875로 예를 들면 아래와 같다.

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

 

Numeric literals 는 읽기 쉽도록 추가 서식이 포함될 수 있다. 정수와 부동소수 모두 가독성을 위해 0을 추가할 수 있으며 밑줄_을 쓸

수 있다. 두 타입 모두 리터럴의 기본 값에 영향을 미치지 않는다.

 

let paddedDouble = 000123.456 // 123.456 임
let oneMillion = 1_000_000 // 1000000 암
let justOverOneMillion = 1_000_000.000_000_1 // 1000000.0000001 임
// 가독성을 위해 0과 _ 를 추가 할 수 있다

 

요약

이진수 - 0b, 8진수 - 0o, 16진수 - 0x

가독성을 위해 0과 _ 추가 가능

 

Numeric Type Conversion (숫자 타입 변환)

코드를 작성할 때 음수가 아닌 것이 확실하더라도 정수와 변수 타입으로 Int 타입을 사용합니다. Int를 사용함으로써 코드에서 즉시 상호운용가능(interperable) 하며 초기값이 없더라도 type-Inference 를 통해 추론한 값과 일치합니다. (정수는 무조건 Int 로 추론한다)

 

다른 integer 타입은 특별히 필요할 때만 사용합니다 -> 외부 소스에 의해 크기가 조정되거나 성능 최적화, 메모리 관리, 최적화가 필요할 경우

명시적으로 사이즈의 유형을 사용하면 우발적인 값 오버플로를 포착하고 사용 중인 데이터의 특성을 암시적으로 문서화하는 데 도움이 됩니다.

 

 

Integer Conversion (정수 전환)

Integer 상수와 변수는 숫자 타입에 따라 저장할 수 있는 범위가 다르다.

Int8 은 -128 ~ 127 사이의 숫자를 저장하고 UInt8은 0 ~ 255 사이의 숫자를 저장할 수 있다.

범위를 벗어나는 숫자는 컴파일될 때 오류가 난다.

 

let cannotBeNegative: UInt8 = -1
// UInt8 0 ~ 255 만 저장가능, 따라서 -1을 넣으면 에러가 발생한다
let tooBig: Int8 = Int8.max + 1
// Int8 의 최대값보다 큰 값을 넣으면 에러가 발생한다

 

각 숫자 타입은 서로 다른 범위의 값을 저장할 수 있으므로, 상황에 따라 타입 변환을 해야한다. 이 옵트 인(opt-in) 접근 방식은 숨겨진 변환 오류를 방지하고 타입 전환의 의도를 나타내는데 도움이 된다

 

특정 숫자 유형을 다른 숫자로 변환하려면 원하는 유형의 새 숫자를 기존 값으로 초기화합니다. 아래 예제에서 상수 2,000은 UInt16 유형이고 상수 1은 UInt8 유형입니다. 같은 유형이 아니기 때문에 직접 합칠 수 없습니다. 대신, 이 예제는 하나의 값으로 초기화된 새로운 UInt16을 만들기 위해 UInt16을 호출하고 원본 대신 이 값을 사용합니다.

 

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

 

UInt16 끼리의 연산이기 때문에 이 덧셈은 허락됩니다. UInt16 끼리의 덧셈이기 때문에 결과 twoThousandAndOne 상수는 UInt16으로 추론됩니다.

 

SomeType 은 Swift 타입 생성자와 초기값을 통과시키기 위한 기본 방법이다. 뒤에서 UInt16에는 UInt8 값을 받아들이는 이니셜라이저가 있으므로 이 이니셜라이저는 기존 UInt8에서 새 UInt16을 만드는 데 사용됩니다. 여기서는 어떤 타입도 전달할 수 없습니다. 그러나 이 타입은 UInt16에서 이니셜라이저를 제공하는 타입이어야 합니다. 기존 타입을 확장하여 새로운 타입(사용자 타입 정의 포함)을 허용하는 이니셜라이저를 제공하는 방법에 대해서는 Extensions에서 설명합니다.

 

 

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

정수와 부동 소수점 전환은 반드시 명시적이어야 한다.

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi 는 3.14159와 같으므로 Double 타입으로 추론된다

여기서 상수 three의 값은 새로운 Double 타입을 만드는데 사용이 되므로 덧셈의 양변은 같은 유형이다. 이 변환이 없으면 덧셈이 허용되지 않는다. (C 언어의 Type Casting을 생각하면 될 것 같다)

 

부동 소수점수를 정수로 변환 할 때도 명시적으로 표현해주어야 한다. 정수 타입은 Double, Float 을 초기화 할 수 있다.

let integerPi = Int(pi)
// integerPi 는  3 과 같기 때문에 Int 타입으로 추론된다

부동 소수점수는 정수 값으로 전환되면서 항상 소수점수가 잘린다. 4.75 -> 4, -3.9 -> -3

 

 

숫자 상수와 변수를 결합하는 규칙은 숫자 리터럴의 규칙과 다릅니다. 리터럴 값 3은 리터럴 값 0.14159에 직접 추가할 수 있습니다. 숫자 리터럴에는 자체적인 명시적 유형이 없기 때문입니다. 이러한 유형은 컴파일러가 평가하는 지점에서만 유추됩니다.

 

요약

Int( ) 처럼 감싸주어서 타입을 변환할 수 있다. (c언어에서의 Type casting 처럼)

float, double -> Int 로 변환할 경우 소수점이 잘린다. (버림이 아니고 소수점만 안나오는 거다!)

 

 

 

Type Aliases (타입 별칭)

Type aliases 은 기존 타입의 다른 이름을 정의한다. typealias 로 Type aliases을 정의한다

 

Type aliases 는 외보 소스의 특정 크기의 데이터로 작업할 때와 같이, 상황에 맞는 이름으로 기존 타입을 참조하려는 경우에 유용합니다.

typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min
// AudioSample 이 UInt16 이므로 maxAmplitudeFound 타입도 UInt16
// 따라서 maxAmplitudeFound 값은 0 이다.

 

요약

타입 별칭을 이용함으로써 타입을 지정할 때 가독성을 높일 수 있다

 

 

Booleans

Swift는 Bool이라는 기본 Boolean type을 가지고 있습니다. Boolean 값은 항상 true 또는 false일 수 있기 때문에 논리 값을 가리킵니다. Swift는 True와 False의 두 가지 Boolean 상수 값을 제공합니다.

let 커피는영어로coffee = true
let 커피는영어로cuffe = false

Int 와 Double 처럼 초기값으로 Boolean type 인 true, false 를 넣어주면 따로 Bool으로 선언할 필요가 없습니다. Type-Inference 는 Swift 코드가 타입이 이미 알려진 다른 값으로 상수나 변수를 초기화할 때 보다 간결하고 읽기 쉽게 만드는 데 도움이 됩니다.

 

Boolean 값은 특별히 if 문 같은 조건문을 작성할 때 유용합니다.

if 커피는영어로coffee {
    print("coffee")
} else {
    print("Not coffee")
}
// Prints "coffee"

 

Swift의 type safety는 Bool 이외의 값이 Bool 값으로 대체되는 것을 방지합니다. 아래 예시는 컴파일 오류를 보고합니다.

let i = 1
if i {
    // 컴파일 되지 않고 에러 발생! 
    }

 

Swift의 다른 type safety 예와 마찬가지로, 이러한 방식은 우발적인 오류를 방지하고 코드의 특정 영역의 의도가 항상 명확하도록 보장합니다.

 

요약

Boolean 값으로 true, false가 있다. c언어와는 다르게 1 과 0 을 Boolean 값으로 쓸 수 없다.

 

 

Tuples (튜플)

Tuple은 여러 값은 하나로 묶어 나타낸 값 입니다. Tuple 내의 값은 모든 타입일 수 있으며, 서로 같은 타입일 필요는 없습니다.

 

아래 예제에서 (404, "Not Found")는 HTTP 상태 코드를 설명하는 튜플입니다. HTTP 상태 코드는 웹 페이지를 요청할 때마다 웹 서버에서 반환되는 특수 값입니다. 존재하지 않는 웹 페이지를 요청하면 404 Not Found라는 상태 코드가 반환됩니다.

let http404Error = (404, "Not Found")
// http404Error 는 (Int, String) 타입이고, 이는 (404, "Not Found") 와 같다

(404, "Not Found") 튜플은 Int와 String을 함께 그룹화하여 HTTP 상태 코드에게 두 개의 개별 값, 즉 숫자와 사람이 읽을 수 있는 설명을 제공합니다. 이것을 "(Int, String)타입"의 튜플이라고 설명할 수 있다.

모든 타입의 조합으로 튜플을 만들 수 있으며 원하는 만큼 다양한 유형을 포함할 수 있습니다. 타입(Int, Int, Int) 또는 (String, Bool) 튜플이나 필요한 다른 조합을 사용하는 것을 막을 수는 없습니다.

튜플의 내용을 별도의 상수 또는 변수로 분해한 다음 평소처럼 액세스할 수 있습니다.

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"

 

튜플 값 중 일부만 필요한 경우 튜플을 분해할 때 _ 이 있는 부분은 무시합니다.

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"
// 배열처럼 0은 첫번째 값, 1 은 두번째 값을 접근한다

 

튜플을 정의할 때 튜플의 개별 요소의 이름과 값을 지정할 수 있습니다.

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) 튜플 타입을 반환할 수 있습니다. 각각 다른 유형의 두 개의 구별되는 값을 가진 튜플을 반환함으로써 함수는 단일 유형의 단일 값만 반환할 수 있는 경우보다 결과에 대한 더 유용한 정보를 제공합니다.

 

튜플은 관련된 값의 간단한 그룹에 유용합니다. 복잡한 데이터 구조를 만드는 데는 적합하지 않습니다. 데이터 구조가 더 복잡할 것 같으면 튜플이 아닌 Class나 Structure로 만듭니다.

 

요약

간단한 데이터 값을 묶어서 사용할 때 Tuple을 사용하자!

 

 

 

Optionals (옵셔널)

옵셔널은 값이 없을 수 있는 상황에서 사용합니다. 옵셔널은 두가지 가능성이 있습니다.

• 값이 있고 해당 값에 접근하기 위해 옵셔널을 unwrap(해제) 하는 것
• 아예 값이 없는 경우

 

Optionals 개념은 C 또는 Objective-C에 없습니다. Objective-C에서 가장 가까운 것은 "유효한 객체의 부재"를 의미하는 0을 반환하는 방법에서 0을 반환할 수 있는 기능이다. 그러나 이 기능은 개체에만 적용되며 구조체(structure), 기본 C 유형(basic C types) 또는 열거(enumeration) 값에는 적용되지 않습니다. 이러한 타입의 경우, Objective-C 메서드는 일반적으로 값의 부재를 나타내기 위해 특수 값(NSNotFound 등)을 반환합니다. 이 접근 방식은 메소드의 호출자가 테스트할 특별한 값이 있음을 알고 있는지 확인하는 것을 기억한다고 가정합니다. Swift의 옵션을 사용하면 특별한 상수가 필요 없이 모든 유형에 대한 값이 없음을 나타낼 수 있습니다.

 

 

여기에 값이 없을 때를 위해 옵셔널을 사용하는 예가 있다.  Swift의 Int 타입에는 String 값을 Int 값으로 변환하려는 이니셜라이저가 있습니다. 그러나 모든 문자열을 정수로 변환할 수 있는 것은 아닙니다. 문자열 "123"은 숫자 값 123으로 변환할 수 있지만 "hello, world" 문자열에는 변환할 명확한 숫자 값이 없습니다.

아래 예제에서는 이니셜라이저를 사용하여 문자열을 Int로 변환합니다.

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 는 "Int?" 혹은 "optional Int" 로 추론된다

이니셜라이저에 오류가 발생할 수 있으므로 Int가 아닌 optional Int를 반환합니다. optional Int는 Int가 아닌 Int?로 작성됩니다. 물음표는 포함된 값이 옵셔널임을 나타냅니다. 즉, 일부 Int 값을 포함하거나 값이 전혀 없을 수 있습니다. 

(? 는 Bool 값이나 String 값과 같은 다른 값을 포함할 수 없습니다. Int이거나 값이 없습니다.)

 

 

nil

옵셔널 변수를 특수값 nil로 할당하여 값이 없는 상태로 설정합니다.

var serverResponseCode: Int? = 404
// serverResponseCode 는 실제 Int 값 404 를 가진다
serverResponseCode = nil
// serverResponseCode 이제 no value 를 가진다

옵셔널이 아닌 상수 및 변수에는 nil을 사용할 수 없습니다. 코드의 상수 또는 변수가 특정 조건에서 값이 없는 경우 항상 해당 타입의 옵셔널값으로 선언합니다.

 

초기값을 제공하지 않고 optional 변수를 정의하는 경우 변수는 자동으로 nil 로 설정됩니다.

var surveyAnswer: String?
// surveyAnswer 는 자동적으로 nil 로 설정이 된다

 

If Statements and Forced Unwrapping (if 문과 강제 언래핑)

if 문을 사용하여 optional과 nil을 비교하여 옵셔널이 값을 포함하고 있는지 확인할 수 있습니다. 이 비교는 "같다" 연산자(==) 또는 "같지 않은" 연산자(!=)를 수행합니다.

 

만약 옵셔널이 값을 가지면, nil 과 같지 않다고 생각된다

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

옵셔널이 값을 가지는지 확인했으면 옵셔널 이름 끝에 느낌표(!)를 추가하여 기본 값에 액세스할 수 있습니다. 느낌표에는 "나는 이 옵셔널에는 확실히 값이 있다는 것을 알고 있습니다. 사용하십시오."라고 효과적으로 표시됩니다. 이를 옵셔널 값의 Forced Unwrapping(강제 언래핑)라고 합니다.

if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}
// Prints "convertedNumber has an integer value of 123."

! 를 사용하여 존재하지 않는 optional 값에 접근하려고 하면 런타임 오류가 트리거됩니다.  ! 를 사용해서 강제 언래핑을 하기 전에 항상 optional 항목에 nil이 아닌 값이 포함되어 있는지 확인해야 합니다.

 

 

Optional Binding (옵셔널 바인딩 = 선택적 바인딩)

옵셔널 바인딩을 사용하여 옵셔널 값에 값이 포함되는지 여부를 확인하고, 포함된 경우 해당 값을 임시 상수 또는 변수로 사용할 수 있도록 합니다. 옵셔널 바인딩은 if 및 while 문과 함께 사용하여 옵셔널 내부의 값을 확인하고 해당 값을 단일 작업의 일부로 상수 또는 변수에 추출할 수 있습니다.

 

if 문에 대한 옵셔널 바인딩을 다음과 같이 작성합니다.

if let constantName = someOptional {
    statements
}

 

Optionals 섹션에 있던 possibleNumber 예제를 다시 작성하여 강제 언래핑 하는 대신 옵셔널 바인딩을 사용할 수 있습니다.

if let actualNumber = Int(possibleNumber) {
    print("The string \"\(possibleNumber)\" has an integer value of \(actualNumber)")
} else {
    print("The string \"\(possibleNumber)\" couldn't be converted to an integer")
}
// Prints "The string "123" has an integer value of 123"

이 코드는 다음과 같습니다

"Int(possibleNumber)에서 반환한 옵셔널 Int에 값이 포함된 경우 actualNumber라는 새 상수를 옵셔널에 포함된 값으로 설정하십시오."

 

변환에 성공하면, if 문의 첫 번째 블럭 내에서 actualNumber 상수를 사용할 수 있습니다. 이 값은 옵셔널 내에 포함된 값으로 이미 초기화되었으므로 ! 를 사용하여 해당 값에 액세스하지 않습니다. 이 예제에서 actualNumber는 변환 결과를 출력하는 데 사용됩니다.

옵셔널 바인딩에는 상수와 변수를 모두 사용할 수 있습니다. if 문의 첫 번째 블럭 내에서 actualNumber 값을 조작하려는 경우 if var realNumber 를 대신 쓸 수 있으며 옵셔널 안에 포함된 값을 상수가 아닌 변수로 사용할 수 있습니다.

필요한 만큼 많은 수의 옵셔널 바인딩과 Boolean 조건을 필요한 경우 쉼표로 구분하여 단일 문에 포함할 수 있습니다. 옵셔널 바인딩의 값이 nil 이거나 Boolean 조건이 거짓으로 평가될 경우, 전체 if 문의 조건이 거짓으로 간주된다. 아래 예시의 2개의 if 문은 동일하다.

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문 안에서 옵셔널 바인딩과 함께 생성된 상수와 변수는 if문 안에서만 사용할 수 있다. 반대로 guard 문과 함께 생성된 변수와 상수는 guard 문을 뒤따라 오는 곳에서만 사용할 수 있다. Early Exit 에 설명이 있다. 

 

 

Implicitly Unwrapped Optionals (암시적으로 해제된 옵셔널)

위에서 설명한 대로 옵셔널에서는 상수 또는 변수가 "값 없음"을 가질 수 있음을 나타냅니다. 옵셔널은 if 문을 사용하여 값이 존재하는지 확인할 수 있으며, 옵션녈 바인딩으로 조건부 언래핑해서 옵셔널 값이 존재하는 경우 해당 값에 액세스할 수 있습니다.

때때로 프로그램 구조를 보면 해당 값이 처음 설정된 후 옵션 값이 항상 값을 갖는 것이 분명합니다. 이러한 경우에는 항상 값이 있다고 안전하게 가정할 수 있으므로 접근할 때마다 옵셔널 값을 확인하고 언래핑할 필요가 없습니다.

이러한 종류의 옵셔널은 암시적으로 해제된 옵셔널로 정의됩니다. 옵셔널로 만들고 싶은 타입 뒤에 물음표(String?)가 아닌 느낌표(String!)를 배치하여 암시적으로 해제된 옵셔널을 작성합니다. 사용할 때 느낌표를 옵셔널 이름 뒤에 사용하지 않고, 선언할 때 옵셔널 이름 뒤에 느낌표를 사용합니다.

암시적으로 해제된 옵셔널은 옵셔널이 처음 정의된 직후 옵셔널 값이 존재하는 것으로 확인될 때 유용하며, 이후 모든 지점에 분명히 존재하는 것으로 가정할 수 있습니다. Swift에서 암시적으로 해제된 옵셔널의 주된 용도는 클래스 초기화 중에 있습니다. (Unowned References and Implicitly Unwrapped Optional Properties 에 설명이 있다.)

 

암시적으로 해제된 옵셔널은 백그라운드에서 일반적인 옵셔널이지만 접근할 때마다 옵셔널 값을 언래핑할 필요 없이 non-optional 값처럼 사용할 수도 있습니다. 다음 예에서는 래핑된 값에 명시적 문자열로 액세스할 때 선택적 문자열과 암시적으로 해제된 옵셔널 문자열 간의 동작 차이를 보여 줍니다.

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // !를 필요로 한다

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // !가 필요가 없다

암시적으로 해제된 옵셔널이 필요한 경우 옵셔널에서 강제언래핑 권한을 부여하는 것이라고 생각할 수 있습니다. 암시적으로 해제된 옵셔널 값을 사용하면 먼저 Swift에서 일반 옵셔널 값으로 사용하려고 합니다. 옵셔널 값으로 사용할 수 없는 경우 Swift에서 값을 강제로 언래핑 합니다. 위의 코드에서는 implicitString이 명시적이고 비선택적인 유형의 String을 가지고 있기 때문에 값을 implicitString에 할당하기 전에 string이 강제 언래핑됩니다. 아래 코드에서 선택적 문자열은 명시적 유형이 없으므로 일반적인 옵션입니다.

 

let optionalString = assumedString
//  optionalString 의 타입은 "String?" 이므로 assumedString 는 강제언래핑되지 않는다

암시적으로 해제된 옵셔널이 nil이고 래핑된 값에 접근하려고 하면 런타임 오류가 트리거됩니다. 결과는 값이 포함되지 않은 일반 옵셔널 뒤에 느낌표를 넣는 경우와 동일합니다.

일반적인 옵셔널을 선택하는 것과 동일한 방법으로 암시적으로 해제된 옵셔널이 nil인지 여부를 확인할 수 있습니다.

if assumedString != nil {
    print(assumedString!)
}
// Prints "An implicitly unwrapped optional string."

 

또한 옵셔널 바인딩과 함께 암시적으로 해제된 옵셔널을 사용하여 단일 문에서 값을 확인하고 언래핑할 수 있습니다.

if let definiteString = assumedString {
    print(definiteString)
}
// Prints "An implicitly unwrapped optional string."

 

나중에 변수가 nil 이 될 가능성이 있는 경우 암시적으로 해제된 옵셔널을 사용하지 마십시오. 변수의 수명 동안 nil 값을 확인해야 하는 경우 항상 일반 옵셔널 타입을 사용하십시오.

 

요약

Optional 은 값을 가지고 있거나 nil 이다.

옵셔널 바인딩을 통해 사용한다

!를 사용해 강제 언래핑할 수 있지만 값이 nil일 때 !를 사용하면 런타임 에러가 발생하므로 주의해서 사용해야 한다.

선언할 때 ? 대신 ! 를 붙여 암시적으로 해제된 옵셔널을 사용할 수 있다. 나중에 변수가 nil 될 가능성이 있으면 사용하지 않는다.

 

 

Error Handling (에러 처리)

프로그램을 실행하는 동안 발생할 수 있는 에러 조건에 대응하기 위해 Error Handling을 사용합니다.

값의 유무를 사용하여 함수의 성공 또는 실패를 전달할 수 있는 옵셔널과는 대조적으로 Error Handling은 에러의 근본적인 원인을 결정하고 필요한 경우 에러를 프로그램의 다른 부분에 전달할 수 있도록 합니다.

함수에 에러 조건이 발생하면 에러가 발생합니다. 그러면 해당 함수의 호출자가 에러를 포착하고 적절하게 응답할 수 있습니다. ( 'it throws an error' 를 '에러가 발생합니다' 로 의역했지만 코드에서 throws라는 키워드를 사용하므로 '에러를 던진다'라고 표현하는게 직관적인 것 같다.)

func canThrowAnError() throws {
    // this function may or may not throw an error
}

 

함수는 선언에 throws 를 포함시켜 에러를 발생시킬 수 있음을 나타냅니다. 에러를 발생시킬 수 있는 함수를 호출할 때 try 키워드를 표현식 앞에 추가합니다.

Swift는 catch 절로 에러를 처리할 때까지 에러를 현재 범위(scope)에서 자동으로 밖으로 전달합니다.

do {
    try canThrowAnError()
    // 에러가 발생 안하면 do 문
} catch {
    // 에러가 발생하면 catch 문
}

 

do 문은 에러를 하나 이상의 catch 절로 전파할 수 있는 새로운 포함 범위를 만듭니다.

다음은 다양한 에러 조건에 대응하기 위해 Error Handling을 사용할 수 있는 방법의 예입니다.

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

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

이 예시에서 makeASandwich() 함수는 깨끗한 요리를 사용할 수 없거나 재료가 없는 경우 에러를 발생시킵니다. makeASandwich()가 에러를 발생시킨수 있으므로, 함수 호출은 try문으로 작성합니다. do 문 안에 함수 호출을 묶어둠으로써, 모든 에러는 catch 절로 전달됩니다.

 

만약 어떤 에러도 발생하지 않는다면, eatASandwich() 함수가 호출됩니다.

만약 에러가 발생하고 SandwichError.outOfCleanDishes 조건에 걸리면 washDishes() 함수가 호출됩니다.

만약 에러가 발생하고 SandwichError.missingIngredients 조건에 걸리면 buyGroceries() 함수는 catch 패턴으로 잡힌 [String] 값을 호출합니다

 

Throwing, cathcing, 그리고 propagating erros 는 Error Handling 에서 더 자세하게 다룬다.

 

요약

throws 를 통해 에러를 던진다. do catch 문을 통해 에러가 있을 때와 없을 때의 코드를 나눈다.

 

 

 

Assertions and Preconditions (주장과 전제 조건)

Assertions and Preconditions 은 런타임에서 발생하는 검사입니다. 추가 코드를 실행하기전 필수 조건을 충족하는지 확인하기 위해 사용합니다. Assertions and Preconditions 의 Boolean 조건이 true면 코드는 평상시처럼 동작합니다. 만약 Boolean 조건이 false면 프로그램의 현재 상태가 무효가 되어 코드실행이 종료되고 앱이 종료됩니다.

 

Assertions and Preconditions을 사용하여 코딩하는 동안의 가정과 예상치를 표현하므로, 이를 코드의 일부로 포함할 수 있습니다. Assertions은 개발 중에 오류와 잘못된 가정을 찾는 데 도움이 되며 Preconditions은 생산 단계에서 문제를 탐지하는 데 도움이 됩니다.

 

런타임 시 예상을 확인할 뿐만 아니라, Assertions and Preconditions도 코드 내에서 유용한 문서 형식이 됩니다. 위의 Error Handling에서 설명한 에러 조건과 달리, Assertions and Preconditions은 복구 가능하거나 예상되는 에러에 사용되지 않습니다. 실패한 Assertions and Preconditions 은 잘못된 프로그램 상태를 나타내기 때문에, 실패한 Assertions을 잡을 방법이 없습니다.

 

Assertions and Preconditions을 사용하는 것은 무효한 조건이 발생하지 않는 방식으로 코드를 설계하는 것을 대체할 수 없다. 그러나 유효한 데이터 및 상태를 적용하기 위해 이 설정을 사용하면 잘못된 상태가 발생할 경우 앱이 보다 예측 가능하게 종료되고 문제를 더 쉽게 디버깅할 수 있습니다. 잘못된 상태가 감지되는 즉시 실행을 중지하는 것도 잘못된 상태로 인한 손상을 제한하는 데 도움이 됩니다.

Assertions and Preconditions의 차이는 검사할 때 나타납니다. Assertions은 디버그 빌드에서만 검사되지만 Preconditions 은 디버그 및 프로덕션 빌드 모두에서 검사됩니다. 프로덕션 빌드에서는 Assertions 내부의 조건이 평가되지 않습니다. 즉, 프로덕션 성능에 영향을 미치지 않고 개발 프로세스 중에 원하는 만큼 Assertions을 사용할 수 있습니다.

 

Debugging with Assertions

Swift 기본 라이브러리에서 assert(_:_:file:line:) 함수를 호출함으로써 Assertion 을 사용할 수 있습니다. 

true, false를 평가하는 조건문에 함수를 통과시키고 창(display)에 조건이 false일 때의 보여줄 message를 설정합니다.

let age = -3
assert(age >= 0, "A person's age can't be less than zero.")
// 이 assertion 실패한다, 왜냐하면 -3 >= 0 은 거짓이기 때문이다.

 

위 예에서, age >= 0이 true로 평가될 경우 코드 실행이 계속됩니다. 위의 코드와 같이 age 값이 음수이면 age >= 0이 거짓으로 평가되고 Assertion이 실패하여 프로그램(application)이 종료됩니다.

 

Assertion message를 생략할 수 있습니다. 

코드가 이미 조건을 확인한 경우 AssertionFailure(_:file:line:) 함수를 사용하여 Assertion이 실패했음을 나타냅니다. 

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.")
}

 

Enforcing Preconditions

조건이 false 일 수도 있으면 Precondition을 사용하지만, 코드가 계속 실행하려면 반드시 true 여야 합니다. 예를 들어 아래첨자가 범위에서 벗어났는지 확인하거나 함수가 유효한 값을 전달했는지 확인하려면 Precondition을 사용합니다.

 

precondition(_:_:file:line:) 를 호출하여 Precondition을 사용합니다. 이 함수를 true 나 false로 평가할 식을 작성하고, false 일시 창에 보여줄 message를 작성합니다

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

preconditionFailure(_:file:line:) 함수를 호출하여 실패가 발생한 것을 나타낼 수도 있습니다. 예를 들어 switch의 기본 case가 사용되었지만 모든 유효한 입력 데이터는 스위치의 다른 case 중 하나에 의해 처리되어야 합니다.

 

 

만약 unchecked mode(-Ounchecked) 에서 컴파일을 하면 Precondition은 검사되지 않습니다. 컴파일러는 Precondition 이 항상 참이라고 가정하고, 이에 따라 코드를 최적화한다. 그렇지만 fatalError(_:file:line:) 함수는 최적화 설정과 상관없이 항상 실행을 중지시킨다.

 

프로토타이핑 및 초기 개발 중에 fatalError(_:file:line:) 함수를 사용하여 fatalError("구현되지 않음")를 중단점 구현으로 작성하여, 아직 구현되지 않은 기능에 대한 중단점을 만들 수 있습니다. Assertions or preconditions과 달리 fatalError는 최적화되지 않기 때문에 중단점을 맞이할 경우 실행이 항상 중지되도록 할 수 있습니다.

 

요약

Assertions and Preconditions을 사용해 런타임에서 검사를 한다.

앱을 강제로 정지시켜 디버깅을 진행한다.

개발 중 fatalError로 중단점을 만들 수 있다.

 

 

 

 

 

 

이렇게 첫 번째 The Basics 를 해석하면서 공부했습니다.

양이 어마어마하네요 😂 공식문서이다보니 최대한 자세히 설명해주려고 글이 길어지는 것 같습니다.다음부터는 요약해서 적어야 할지 고민이됩니다.Swift 공부에 도움이 됬길 바라며 Swift를 공부하는 분들 모두 화이팅입니다 😉