Merge changes from master into hyukhur

hyukhur authored
revision e978d49ae27e276d51c580ed98645ec4fc9c472c
# 10 열거형 (Enumerations)
> Translator : 이름 (메일주소)

An enumeration defines a common type for a group of related values and enables you to
work wi th those values in a type-safe way wi thin your code.
If you are fami l iar wi th C, you wi l l know that C enumerations assign related names to a
set of integer values. Enumerations in Swi ft are much more flexible, and do not have to
provide a value for each member of the enumeration. If a value (known as a “raw” value)
i s provided for each enumeration member, the value can be a string, a character, or a
value of any integer or floating-point type.
Al ternatively, enumeration members can speci fy associated values of any type to be
stored along wi th each di fferent member value, much as unions or variants do in other
languages. You can define a common set of related members as part of one enumeration,
each of whi ch has a di fferent set of values of appropriate types associated wi th i t.
Enumerations in Swi ft are fi rst-class types in thei r own right. They adopt many features
tradi tional ly supported only by classes, such as computed properties to provide addi tional
information about the enumeration’s current value, and instance methods to provide
functional i ty related to the values the enumeration represents. Enumerations can al so
define ini tial i zers to provide an ini tial member value; can be extended to expand thei r
functional i ty beyond thei r original implementation; and can conform to protocol s to
provide standard functional i ty.
For more on these capabi l i ties, see Properties, Methods, Ini tial i zation, Extensions, and
Protocol s.
Enumeration Syntax
You introduce enumerations wi th the enum keyword and place thei r enti re defini tion wi thin
a pai r of braces:
enum SomeEnumerati on {
// enumerati on defi ni ti on goes here
Here’s an example for the four main points of a compass:
enum CompassPoi nt {
case North
case South
case East
case West
The values defined in an enumeration (such as North, South, East, and West) are the member
values (or members) of that enumeration. The case keyword indi cates that a new l ine of
member values i s about to be defined.
Unl i ke C and Objecti ve-C, Sw i ft enumerati on members are not assi gned a defaul t i nteger val ue w hen they are
created. In the CompassPoi nts exampl e above, North, South, East and West do not i mpl i ci tl y equal 0, 1, 2
and 3. Instead, the di fferent enumerati on members are ful l y- fl edged val ues i n thei r ow n ri ght, w i th an
expl i ci tl y-defi ned type of CompassPoi nt.
Mul tiple member values can appear on a single l ine, separated by commas:
enum Pl anet {
case Mercury, Venus, Earth, Mars, Jupi ter, Saturn, Uranus, Neptune
Each enumeration defini tion defines a brand new type. Like other types in Swi ft, thei r
names (such as CompassPoi nt and Pl anet) should start wi th a capi tal letter. Give enumeration
types singular rather than plural names, so that they read as sel f-evident:
var di recti onT oHead = CompassPoi nt.West
The type of di recti onT oHead i s inferred when i t i s ini tial i zed wi th one of the possible values of
CompassPoi nt. Once di recti onT oHead i s declared as a CompassPoi nt, you can set i t to a di fferent
CompassPoi nt value using a shorter dot syntax:
di recti onT oHead = . East
The type of di recti onT oHead i s al ready known, and so you can drop the type when setting i ts
value. Thi s makes for highly readable code when working wi th expl i ci tly-typed
enumeration values.
Matching Enumeration Values with a Switch Statement
You can match individual enumeration values wi th a sw i tch statement:
di recti onT oHead = . South
sw i tch di recti onT oHead {
case . North:
pri ntl n("Lots of pl anets have a north")
case . South:
pri ntl n("Watch out for pengui ns")
case . East:
pri ntl n("Where the sun ri ses")
case .West:
ri ntl n("Where the ski es are bl ue")
i nts "Watch out for pengui ns"
You can read thi s code as:
“Consider the value of di recti onT oHead. In the case where i t equal s . North, print "Lots of pl anets
have a north". In the case where i t equal s . South, print "Watch out for pengui ns".”
…and so on.
As described in Control Flow, a sw i tch statement must be exhaustive when considering an
enumeration’s members. If the case for .West i s omi tted, thi s code does not compi le,
because i t does not consider the complete l i st of CompassPoi nt members. Requi ring
exhaustiveness ensures that enumeration members are not accidental ly omi tted.
When i t i s not appropriate to provide a case for every enumeration member, you can
provide a defaul t case to cover any members that are not addressed expl i ci tly:
l et somePl anet = Pl anet. Earth
sw i tch somePl anet {
case . Earth:
pri ntl n("Mostl y harml ess")
defaul t:
pri ntl n("Not a safe pl ace for humans")
// pri nts "Mostl y harml ess"
Associated Values
The examples in the previous section show how the members of an enumeration are a
defined (and typed) value in thei r own right. You can set a constant or variable to
Pl anet. Earth, and check for thi s value later. However, i t i s sometimes useful to be able to
store associated values of other types alongside these member values. Thi s enables you
to store addi tional custom information along wi th the member value, and permi ts thi s
information to vary each time you use that member in your code.
You can define Swi ft enumerations to store associated values of any given type, and the
value types can be di fferent for each member of the enumeration i f needed.
Enumerations simi lar to these are known as di scriminated unions, tagged unions, or
variants in other programming languages.
For example, suppose an inventory tracking system needs to track products by two
di fferent types of barcode. Some products are labeled wi th 1D barcodes in UPC-A format,
whi ch uses the numbers 0 to 9. Each barcode has a “number system” digi t, fol lowed by
ten “identi fier” digi ts. These are fol lowed by a “check” digi t to veri fy that the code has
been scanned correctly:
Other products are labeled wi th 2D barcodes in QR code format, whi ch can use any ISO
8859-1 character and can encode a string up to 2,953 characters long:
It would be convenient for an inventory tracking system to be able to store UPC-A
barcodes as a tuple of three integers, and QR code barcodes as a string of any length.
In Swi ft, an enumeration to define product barcodes of ei ther type might look l ike thi s:
enum Barcode {
case UPCA(Int, Int, Int)
case QRCode(Stri ng)
Thi s can be read as:
“Define an enumeration type cal led Barcode, whi ch can take ei ther a value of UPCA wi th an
associated value of type (Int, Int, Int), or a value of QRCode wi th an associated value of type
Stri ng.”
Thi s defini tion does not provide any actual Int or Stri ng values—i t just defines the type of
associated values that Barcode constants and variables can store when they are equal to
Barcode. UPCA or Barcode.QRCode.
New barcodes can then be created using ei ther type:
var productBarcode = Barcode. UPCA(8, 85909_51226, 3)
Thi s example creates a new variable cal led productBarcode and assigns i t a value of
Barcode. UPCA wi th an associated tuple value of (8, 8590951226, 3). The provided “identi fier”
value has an underscore wi thin i ts integer l i teral—85909_51226—to make i t easier to read as
a barcode.
The same product can be assigned a di fferent type of barcode:
productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
At thi s point, the original Barcode. UPCA and i ts integer values are replaced by the new
Barcode.QRCode and i ts string value. Constants and variables of type Barcode can store ei ther a
. UPCA or a .QRCode (together wi th thei r associated values), but they can only store one of
them at any given time.
The di fferent barcode types can be checked using a swi tch statement, as before. Thi s
time, however, the associated values can be extracted as part of the swi tch statement.
You extract each associated value as a constant (wi th the l et prefix) or a variable (wi th
the var prefix) for use wi thin the sw i tch case’s body:
sw i tch productBarcode {
case . UPCA(l et numberSystem, l et i denti fi er, l et check):
pri ntl n("UPC-A w i th val ue of \(numberSystem), \(i denti fi er), \(check). ")
case .QRCode(l et productCode):
pri ntl n("QR code w i th val ue of \(productCode). ")
// pri nts "QR code w i th val ue of ABCDEFGHIJKLMNOP. "
If al l of the associated values for a enumeration member are extracted as constants, or i f
al l are extracted as variables, you can place a single var or l et annotation before the
member name, for brevi ty:
sw i tch productBarcode {
case l et . UPCA(numberSystem, i denti fi er, check):
pri ntl n("UPC-A w i th val ue of \(numberSystem), \(i denti fi er), \(check). ")
case l et .QRCode(productCode):
pri ntl n("QR code w i th val ue of \(productCode). ")
// pri nts "QR code w i th val ue of ABCDEFGHIJKLMNOP. "
Raw Values
The barcode example in Associated Values shows how members of an enumeration can
declare that they store associated values of di fferent types. As an al ternative to
associated values, enumeration members can come prepopulated wi th defaul t values
(cal led raw values), whi ch are al l of the same type.
Here’s an example that stores raw ASCII values alongside named enumeration members:
enum ASCIIControl Character: Character {
case T ab = "\t"
case Li neFeed = "¶
case Carri ageReturn = "\r"
Here, the raw values for an enumeration cal led ASCIIControl Character are defined to be of type
Character, and are set to some of the more common ASCII control characters. Character
values are described in Strings and Characters.
Note that raw values are not the same as associated values. Raw values are set to
prepopulated values when you fi rst define the enumeration in your code, l ike the three
ASCII codes above. The raw value for a parti cular enumeration member i s always the
same. Associated values are set when you create a new constant or variable based on
one of the enumeration’s members, and can be di fferent each time you do so.
Raw values can be strings, characters, or any of the integer or floating-point number
types. Each raw value must be unique wi thin i ts enumeration declaration. When integers
are used for raw values, they auto-increment i f no value i s speci fied for some of the
enumeration members.
The enumeration below i s a refinement of the earl ier Pl anet enumeration, wi th raw integer
values to represent each planet’s order from the sun:
enum Pl anet: Int {
case Mercury = 1, Venus, Earth, Mars, Jupi ter, Saturn, Uranus, Neptune
Auto-incrementation means that Pl anet. Venus has a raw value of 2, and so on.
Access the raw value of an enumeration member wi th i ts toRaw method:
l et earthsOrder = Pl anet. Earth. toRaw ()
// earthsOrder i s 3
Use an enumeration’s fromRaw method to try to find an enumeration member wi th a
parti cular raw value. Thi s example identi fies Uranus from i ts raw value of 7:
l et possi bl ePl anet = Pl anet. fromRaw (7)
// possi bl ePl anet i s of type Pl anet? and equal s Pl anet. Uranus
Not al l possible Int values wi l l find a matching planet, however. Because of thi s, the
fromRaw method returns an optional enumeration member. In the example above,
possi bl ePl anet i s of type Pl anet?, or “optional Pl anet.”
If you try to find a Planet wi th a posi tion of 9, the optional Pl anet value returned by fromRaw
wi l l be ni l :
l et posi ti onT oFi nd = 9
i f l et somePl anet = Pl anet. fromRaw (posi ti onT oFi nd) {
sw i tch somePl anet {
case . Earth:
pri ntl n("Mostl y harml ess")
defaul t:
pri ntl n("Not a safe pl ace for humans")
} el se {
ri ntl n("T here i sn't a pl anet at posi ti on \(posi ti onT oFi nd)")
i nts "T here i sn't a pl anet at posi ti on 9"
Thi s example uses optional binding to try to access a planet wi th a raw value of 9. The
statement i f l et somePl anet = Pl anet. fromRaw (9) retrieves an optional Pl anet, and sets somePl anet to
the contents of that optional Pl anet i f i t can be retrieved. In thi s case, i t i s not possible to
retrieve a planet wi th a posi tion of 9, and so the el se branch i s executed instead.
inureyes (

열거형 _(Enumeration)_ 은 관련있는 값들의 그룹에 대한 일반적인 타입을 정의하며, 이를 이용하여 코드 안에서 타입에 안전한 방법으로 작업할 수 있습니다. C에 익숙한 사용자라면, C 열거형은 관련있는 이름을 정수값의 set에 할당하는 것을 알고 있을 것입니다. Swift의 열거형은 훨씬 더 유연하며, 열거형의 각 숫자마다 반드시 값을 제공할 필요가 없습니다. 만약 ("raw" 값으로 알려진) 값이 각 열거형 번호마다 제공될 경우, 그 값들은 문자열, 글자, 어떠한 정수나 부동 소수점 타입이 될 수 있습니다.

또한, 열거형 멤버들은 각각 다른 멤버 값에 대하여 다른 언어의 union및 비슷한 기능들이 하듯 연관된 값들을 어떤 타입이든 지정할 수 있습니다. 관련있는 멤머들의 일반적인 집합을 하나의 열거형의 부분으로 정의할 수도 있으며, 각각은 그에 연관된 적당한 타입의 값들의 다양한 집합을 가질 수 있습니다.

Swift의 열거형은 열거형의 현재 값에 대한 추가적인 정보를 제공하기 위한 계산된 프로퍼티나, 열거형이 표현하는 값들과 연관된 기능들을 제공하는 인스턴스 메소드 같이 전통적으로 클래스 등에서만 지원되는 많은 기능들을 차용하였습니다. 또한 열거형은 초기 멤버 값을 제공하는 initiailizer를 제공할 수 있고, 원래 구현을 넘어서 기능을 확장할 수도 있으며, 표준 기능을 제공하기 위한 프로토콜을 따를 수 있습니다.

이러한 기능에 대한 자세한 내용은 [속성](), [메소드](), [초기화](), [확장](), 및 [프로토콜]()을 참조하십시오.

### 열거형 문법 (Enumeration Syntax)
열거형은 `enum` 키워드로 작성하며, 중괄호 안에 모든 정의를 집어넣습니다.

enum SomeEnumeration {
// enumeration definition goes here
Here’s an example for the four main points of a compass:

enum CompassPoint {
case North
case South
case East
case West

(`North`, `South`, `East` 및 `West` 같이) 열거형에 정의된 값들은 이 열거형의 멤버 값들입니다. `case` 키워드는 멤버 값들의 새 줄이 정의될 것임을 나타냅니다.

> **노트**
> C 및 Objective-C 와는 다르게, Swift의 열거형 멤버들은 생성시 기본 정수값들에 할당되지 않습니다. 위의 `CompassPoints` 예제에서 보듯, `North`, `South`, `East` 및 `West`는 명시적으로 0, 1, 2 및 3에 대응되지 않습니다. 대신에, 기본 열거형 멤버들은 `CompassPoint`의 명시적으로 정의된 타입과 함께 정의된 완벽하게 갖춰진 값입니다.

여러 멤버 값들이 콤마(,) 로 구분되어 한 줄에 나올 수도 있습니다:

enum Planet {
case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune

각 열거형 정의들은 새로운 타입을 정의합니다. Swift의 다른 타입과 마찬가지로, 이름들 ( `CompassPoint` 및 `Planet`과 같은) 은 대문자로 시작해야 합니다. 열거형 타입에게 자명하게 읽힐 수 있도록 복수형 대신 단수형 이름을 주세요.

var directionToHead = CompassPoint.West

`directionToHead` 타입은 `CompassPoint`의 가능한 값들 중 하나가 초기화 될 때 유추됩니다. `directionToHead`가 `CompassPoint`로 선언되면, 짧은 닷 구문을 사용하여 그 값을 다른 `CompassPoint` 값으로 설정할 수 있습니다:

directionToHead = .East

`directionToHead`의 타입은 이미 알려져 있으므로, 값을 설정할 때 타입을 명기하지 않을 수 있습니다. 이러한 부분은 명시적으로 타입된 열거형 값들로 작업할 때 매우 읽기 편한 코드를 만들어줍니다.

## 열거형의 값들과 스위치 구문간의 대응 (Matching Enumeration Values with a Switch Statement)

각각의 열거형 값들을 `switch` 구문과 대응할 수 있습니다.

directionToHead = .South
switch directionToHead {
case .North:
println("Lots of planets have a north")
case .South:
println("Watch out for penguins")
case .East:
println("Where the sun rises")
case .West:
println("Where the skies are blue")
// prints "Watch out for penguins

이 코드는 다음과 같이 읽을 수 있습니다:
"`directionToHead`의 값을 봅시다. 만약 `.North`와 값이 같다면, `"Lots of planets have a north"` 를 출력합니다. 만약 `.South`와 값이 같다면, `"Watch out for penguins"` 를 출력합니다."

...식이 됩니다.

[제어 구문]() 에서 설명했듯이, `switch` 구문은 열거형 멤버를 고려할때 완벽하게 작성되어야 합니다. 만약 `.West`가 빠진 경우, 이 코드는 `CompassPoint` 멤버의 완벽한 리스트를 고려하지 않았기 때문에 컴파일되지 않을 것입니다. 완벽성 (exhaustiveness) 의 요구는 열거형 멤버가 실수로 생략되는 것을 방지합니다.

모든 열거형 멤버에 대한 케이스를 제공하기에 적당하지 않은 경우, 명시적으로 언급되지 않은 멤버들을 위한 기본 케이스를 제공할 수 있습니다.

let somePlanet = Planet.Earth
switch somePlanet {
case .Earth:
println("Mostly harmless")
println("Not a safe place for humans")
// prints "Mostly harmless”

## 관련된 값들 (Associated Values)

앞 섹션의 에제는 열거형의 멤버들이 각각의 어떻게 정의되었는지 보여줍니다. 상수 및 변수를 `Planet.Earth` 에 설정할 수 있으며, 나중에 값들을 확인할 수도 있습니다. 그렇지만, 종종 멤버 값들과 함께 연관된 다른 타입의 값들을 저장하는 것이 유용한 경우들이 있습니다. 이는 추가적인 사용자 지정 정보를 멤버 값들마다 저장할수 있게 하며, 코드 안에서 멤버를 사용할 때 마다 정보가 변경되는 것을 허용합니다.

어떤 특정한 타입의 관련 값을 저장하는 Swift 열거형을 정의 할 수 있으며, 필요한 경우에 열거형의 각 멤보에 따라 값의 형식은 다를 수 있습니다. 이러한 열거형과 유사한 경우들이 다른 언어에서는 차별된 공용체 (discriminated union), 태깅된 공용체 (tagged unions) 및 변형체 (variants) 로 알려져 있습니다.

예를 들어 재고 추적 시스템이 각 제품을 두가지 타입의 바코드로 추적할 필요가 있다고 해 봅시다. 어떤 제품들은 UPC-A 포맷의 0에서 9 사이의 숫자를 사용하는 1차원 바코드로 레이블링 되어 있습니다. 각 바코드는 열 개의 "확인 번호(identifier)" 숫자가 뒤따르는 "번호 시스템" 숫자를 갖고 있습니다. 이 숫자들 뒤에는 각 코드가 제대로 스캔되었는지를 검증하기 위한 "확인(check)" 숫자가 붙습니다.


다른 제품들은 모든 ISO 8859-1 문자를 사용할 수 있으며 2,953글자의 길이를 갖는 QR 코드 포맷의 2차원 바코드로 레이블링되어 있습니다.


재고추적 시스템이 UPC-A 바코드를 3개의 숫자 튜플로 저장하고, QR 코드는 임의의 길이의 문자열로 저장할 수 있다면 매우 편할 것입니다.

Swift에서, 각 유형의 제품의 바코드를 정의하는 열거형은 다음처럼 보일 것입니다:

enum Barcode {
case UPCA(Int, Int, Int)
case QRCode(String)

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

"`(Int, Int, Int)` 타입의 UPCA 값 또는 `String` 타입의 QRCode 값을 가질 수 있는 `Barcode`라는 열거형 타입을 정의합니다."


No preview for this file type

Deleted file
# 03 기초 다지기 (The Basics)
> Translator : 이름 (메일주소)

Write here...
FlashMaestro (

Swift는 iOS와 OS X 앱을 개발하기 위한 새로운 프로그래밍 언어 입니다. 그러나 많은 부분이 C나 Objective-C로 개발하면서 얻었던 경험들과 유사할 것입니다.

Swift는 정수형을 위한 `Int`, 부동소숫점 값을 위한 `Double`과 `Float`, 불리언값을 위한 `Bool`, 문자열 데이터를 위한 `String`을 포함해 C와 Objective-C의 기본적인 데이터 타입에서 약간 변형된 형태로 제공합니다. 또한 `컬랙션 타입`으로 통칭되는 `Array`와 `Dictionary` 이 두가지 주요한 컬랙션 타입 또한 강력한 형태로 제공합니다.

Swift도 C처럼 식별 가능한 이름을 가지고 값을 참조하거나 저장하기 위한 변수를 사용합니다. 또한 변경 불가능한 값들 또한 폭넓게 사용되도록 했습니다. 보통 상수라고 알려져 있는데, 이것은 C에서의 상수보다 훨씬 강력합니다. 상수는 변경될 필요가 없는 값을 가지고 작업하려고 할 때 코드를 조금 더 안전하고 깔끔하게 만들 수 있도록 Swift 전반에 걸쳐 쓰이게 됩니다.

Swift는 잘 알려진 타입들 뿐 아니라 Objective-C에는 없었던 고급 타입들도 선보이고 있습니다. 값들의 묶음을 만들고 전달할 수 있도록 하는 튜플도 이 고급 타입들 중에 하나입니다. 튜플은 함수의 반환값으로 여러개의 값을 하나로 결합해 돌려줄 수 있도록 합니다.

Swift는 어떤 값의 부재를 다룰 수 있는 선택형 타입도 제공 합니다. 이 선택형은 "값이 존재하고, 그 값은 x입니다." 혹은 "값이 존재 하지 않습니다."라고 할 수 있습니다. 선택형은 Objective-C의 포인터에서 `nil`을 사용하는 것과 비슷합니다. 하지만 클래스 뿐만 아니라 어떤 타입에도 사용할 수 있습니다. 선택형은 Objective-C의 `nil` 포인터보다 훨씬 안전하고 쓰임새 있습니다. 또 Swift의 강력한 기능들중 핵심적인 기능입니다.

선택형은 Swift가 `type safe`하다는 예시 입니다. Swift는 당신이 코드를 통해 다루는 값들의 타입을 확실히 하는 것을 돕습니다. 당신이 만든 코드중에 일부가 `String` 타입을 사용해야 할 때 타입 세이프는 `Int`같은 값을 전달하는 실수를 막아줍니다. 이를 통해 개발하는 동안 가능한한 빨리 에러는 인지하고 고치는 것이 가능합니다.

##상수(Constants)와 변수(Variables)
상수와 변수는 어떤 이름(`maximumNumberOfLoginAttempts`나 `welcomeMessage`)과 특정한 형태의 값(숫자 `10`이나 문자열 `Hello`)의 결합으로 구성됩니다. 상수의 값은 한번 지정되고 난 후에는 변경될 수 없고 변수는 값이 지정되고 난 이후에도 변경될 수 있습니다.

###상수와 변수의 선언
상수와 변수는 사용되기 전에 선언되어야 합니다. 상수는 let키워드, 변수는 var 키워드를 가지고 정의할 수 있습니다. 여기 사용자가 로그인을 시도한 횟수를 추적하는데 사용되는 변수와 상수를 만드는 예제가 있습니다.

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

이 코드는 다음과 같이 해석할 수 있습니다.

"maxiumNumberOfLoginAttempts라는 새로운 상수를 선언하고 값은 10으로 할당한다. 그리고 currentLoginAttempt라는 변수를 선언하고 0이라는 초기값을 할당한다."

예제에서 보면 최대값은 변하지 않기 때문에 로그인을 시도할 수 있는 최대 횟수가 상수에 정의되어 있습니다. 그리고 매번 로그인을 실패할 때마다 숫자가 증가해야 하기 때문에 현재 로그인 시도 횟수는 변수로 정의되어 있습니다.

콤마로 구분해서 한줄에 여러개의 상수나 변수를 선언하는 것도 가능합니다.

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

코드를 작성할 때 변경할 필요가 없는 값을 저장하는 경우 항상 `let` 키워드를 사용해 상수로 선언하라. 그리고 변경할 필요가 있을 경우에만 변수로 선언하라.

###타입 명시(Type Annotations)
상수나 변수를 만들 때 어떤 형태의 값이 저장될 지 명확하게 하기 위해 타입을 명시할 수 있습니다. 상수나 변수의 이름뒤에 콜론을 쓰고 한칸을 띄우고 사용하고 싶은 타입의 이름을 써서 타입을 명시할 수 있습니다.

다음 예시는 `welcomeMessage`라는 변수에 `String`값이 저장될 수 잇다는 것을 표시하기 위해 타입 명시를 하는 것입니다.

var welcomeMessage: String

콜론은 "~타입 의"라는 의미를 가집니다. 따라서 위의 코드는 다음과 같이 해석할 수 있습니다.

"`String`타입의 변수 welcomeMessage를 선언한다."

"`String`타입의" 라는 말은 "어떤 `String`값이든 저장할 수 있다."라는 의미 입니다. "어떤타입의"(혹은 "어떤 종류의") 라는 것은 그것이 저장될 수 있다 라는 의미로 생각하면 됩니다.

이제 `welcomeMessage`변수에는 오류없이 어떤 문자열 값이든 저장할 수 있습니다.

welcomeMessage = "Hello"

연습중에 타입 명시를 해야하는 경우는 드물다. 만약 상수나 변수를 정의하는 지점에 초기값을 지정한다면, Swift는 그 상수나 변수를 위해 사용할 타입을 추측한다. 이것이 바로 `타입 세이프`와 `타입 추정`이다. 위의 예제에서 `welcomeMessage`에 초기값을 지정하지 않았다. 그래서 초기값으로 부터 타입을 추정하기 힘들기 때문에 타입을 명시해준 것이다.

###상수와 변수 이름 짓기
상수와 변수의 이름을 지정하기 위해서 유니코드를 포함한 어떤 문자든지 사용할 수 있습니다.

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

상수와 변수의 이름에는 수학기호, 화살표, 개인용(혹은 유효하지 않은) 유니코드, -선, 상자 그리기용 문자 등을 사용할 수 없다. 또 숫자로 시작해서도 안되고 이름 중간에 숫자가 들어가서도 안됩니다.

특정 타입의 상수나 변수를 한번 선언 했다면, 같은 이름으로 다시 선언하는 것이나 다른 형태의 값을을 저장하도록 하는 것은 불가능 합니다. 또 변수에 상수를 저장하거나 상수에 변수를 저장하는 것 또한 불가능 합니다.

만약 Swift 예약어로 상수나 변수명을 만들고 싶다면 변수명을 ```표시로 묶어서 쓸 수 있다. 그러나 정말 다른 대안이 없는 경우가 아니면 사용하지 않는 것이 좋다.

기존 변수의 값을 호환 가능한 다른 값으로 변경할 수 있습니다.. 예를 들면 `friendlyWelcome`의 값은 `"Hello!"`에서 `"Bonjour!"`로 변경됩니다.

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

변수와는 다르게 상수는 한번 값이 정해지면 변경할 수 없습니다.. 컴파일할 때 에러가 발생하도록 시도해 봅시다.

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

### 상수와 변수의 출력