[Swift] 공식 문서 정리 (3) - Strings and Characters (문자열과 문자)

시작하며

swift 공부를 시작한지 3일차... 요즘 공부가 뜸하다. 내 소중한 친구가 하늘나라로 간지 일주일이 지났다. 이제 나도 정신을 차리고 내 미래를 위해, 친구와 약속한 대로 성공적인 2022년을 위해 공부에 온 정신을 매진해야겠다. 친구야 하늘에서는 꼭 행복하길. 우리 이제 원하는 것을 하고 살자. 그런 의미로 스위프트 공식문서 3회차 정리 go

Swift 공식 Documents (3) strings and characters 

반응형

Strings and Characters — The Swift Programming Language (Swift 5.5)

 

Strings and Characters (문자열과 문자)

String(문자열) 은 "Hello, World" 와 같은 일련의 character(문자)들이 묶여진 것이다. Swift에서 문자와 문자열은 코드에서 텍스트 유니코드 호환방법으로 제공하며, 문자열 및 문자의 생성 문법은 C언어와 비슷하다. 문자열 연결은 + 연산자로 구현할 수 있고, 다른 변수 및 상수처럼 선언하고 사용하면 된다. 

---

String Literals (문자열 리터럴)

개발자는 코드 내에 미리 정의 된 String 값으로 문자열을 생성할 수 있다. 문자열을 " " 안에 써주면 된다.

let someString = "Some string literal value"

위 코드처럼 상수를 선언하면, someString은 Swift는 문자열 리터럴 값으로 초기화 된다.

 

Multiline String Literals (여러 줄 문자열 리터럴)

만약 문자열을 여러 줄에 쓰고 싶다면 """ 를 활용해라.

let quotation = """
The White Rabbit put on his spectacles.  "Where shall I begin,
please your Majesty?" he asked.

"Begin at the beginning," the King said gravely, "and go on
till you come to the end; then stop."
"""

▲ 위처럼 멀티 라인 문자열 리터럴은 시작하는 """와 마지막의 """ 사이의 모든 줄을 포함한다. 

멀티라인 문자열 리터럴 내부에 줄바꿈이 포함된 경우, 해당 줄 바꿈은 문자열의 값에도 적용된다. 소스코드를 읽기 쉽게 하기 위해 줄바꿈을 사용하고, 실제로는 줄바꿈을 사용하지 않으려면 문자 뒤에 백슬래시 (\)를 작성하면 된다. ▼

let softWrappedQuotation = """
The White Rabbit put on his spectacles.  "Where shall I begin, \
please your Majesty?" he asked.

"Begin at the beginning," the King said gravely, "and go on \
till you come to the end; then stop."
"""

 

여러 줄을 사용할 때는 아래처럼 첫줄과 마지막 줄을 비워놓고 사용하는 것이 좋다. (그냥 통상적인 예의?인듯?)

let lineBreaks = """

This string starts with a line break.
It also ends with a line break.

"""

 

멀티라인 문자열 리터럴에서 앞의 공백은 첫줄이 시작할 때의 공백만큼은 무시되지만, 그 이후의 줄에서는 첫줄 공백만큼은 무시되고, 앞에 띄워진 다른 공백은 무시되지 않는다. 아래의 사진을 보면 무슨 말인지 이해가 될 것이다.

 

Special Characters in String Literals (문자열 리터럴 내의 특수 문자)

문자열 리터럴은 아래와 같은 특수문자를 포함할 수 있다.

• \0 : null character
• \\ : back slash 백슬래쉬는 이렇게 표현할 수 있다.
• \t : 탭 키 한 번 누른 것
• \n : 줄바꿈
• \r : carriage return으로 커서의 위치를 줄의 맨 처음으로 보내 줌
• \" : 문자열에서 큰 따옴표
• \' : 문자열에서 작은 따옴표
• \u(n) : 문자열에서 유니코드를 스고 싶을 때 (n에는 1-8자리의 16진수를 써주면 됨)

let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
// "Imagination is more important than knowledge" - Einstein
let dollarSign = "\u{24}"        // $,  Unicode scalar U+0024
let blackHeart = "\u{2665}"      // ♥,  Unicode scalar U+2665
let sparklingHeart = "\u{1F496}" // 💖, Unicode scalar U+1F496

만약 멀티 라인 문자열 리터럴 내부에서 따옴표를 사용하고 싶다면 그냥 써도 된다.(", "") 하지만 멀티라인 문자열 리터럴은 (""")를 사용하므로, 만약 문자열 내부에 """ 를 포함하고 싶다면 다음과 같이 백슬래쉬와 함께 사용하면 된다.

let threeDoubleQuotationMarks = """
Escaping the first quotation mark \"""
Escaping all three quotation marks \"\"\"
"""

 

Extended String Delimiters (확장 문자열 구분 기호)

아까와 같이 특수문자를 쓰는 것이 귀찮거나 \n 과 같은 문자를 쓰고 싶다면 # 안에 문자열을 넣어주면 된다. 그러면 그냥 그 문자열 그대로를 사용할 수 있다. 근데 만약 #를 쓰고 그 안에 \n과 같은 기능을 쓰고 싶다면 #개수와 같은 수의 #를 \n에 써주면 되는데 아래 예시를 통해 이해해보자.

let threeMoreDoubleQuotationMarks = #"""
Here are three more double quotes: """
"""#

 

---

Initializing an Empty String (빈 문자열 초기화)

긴 문자열을 작성하기 위한 시작점으로 빈 문자열 값을 만드려면 변수에 빈 문자열 리터럴을 할당하거나 Initializing 구문을 사용하여 새 문자열 인스턴스를 초기화 할 수 있다. 

즉, 빈 문자열을 만드는데 두 가지 방법이 있는데 아래와 같이 쓸 수 있다.

var emptyString = ""               // empty string literal
var anotherEmptyString = String()  // initializer syntax
// these two strings are both empty, and are equivalent to each other

또한 이렇게 정의하면 , String 값은 isEmpty 라는 프로퍼티를 가지는데, 이것을 if문을 활용하여 확인해볼 수 있다. (아래)

if emptyString.isEmpty {
    print("Nothing to see here")
}
// Prints "Nothing to see here"

---

String Mutability (문자열 변형성)

개발자가 String '변수'로 선언하였다면 문자열은 변형할 수 잇고, 상수로 선언하였다면 변형 할 수 없다.

var variableString = "Horse"
variableString += " and carriage"
// variableString is now "Horse and carriage"

let constantString = "Highlander"
constantString += " and another Highlander"
// this reports a compile-time error - a constant string cannot be modified

---

Strings Are Value Types

swift의 String 타입은 Value , 즉 값 타입이다. 개발자가 새로운 string값을 만들어 내면 그 값이 함수나 매서드에서 사용될 때 복사되어 사용된다. 즉 기존의 다른 값들과는 다르게 아예 새로운 값이 생성된다고 생각하자. 물론 복사를 하기 때문에 내용은 같다.

---

Working with Characters

String에서 charcacter는 한 글자씩을 의미한다. 따라서 아래 for-in 구문을 활용하여 한 글자씩 추출할 수 있다.

for character in "Dog!🐶" {
    print(character)
}
// D
// o
// g
// !
// 🐶

만약 한 char만 사용하고 싶다면 아래와 같이 선언할 수 있다.

let exclamationMark: Character = "!"
print(exclamationMark)
// !

아래와 같이 String 값은 character의 배열로도 만들 수 있다.

let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// Prints "Cat!🐱"

---

Concatenating Strings and Characters (문자연결과 문자)

string은 더하기 연산자 (+)를 활용하여 새로운 문자열을 만들 수 있다. (concat)

let string1 = "hello"
let string2 = " there"
var welcome = string1 + string2
// welcome now equals "hello there"

더하기 연산자 뿐만 아니라 += 연산자도 사용할 수 있다.

var instruction = "look over"
instruction += string2
// instruction now equals "look over there"

Character값을 String에 추가하고 싶을 때 String 타입간의 append() 메서드를 사용하자. (Character는 한 글자만 존재하는 '문자'이므로, character변수에는 append할 수 없다는 것은 당연하다!)

let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome now equals "hello there!"

만약 멀티 라인 문자열 리터럴을 사용할 때에는 마지막 줄에서 개행이 일어나지 않기 때문에 아래와 같이 해줘야 원하는 문자열을 합칠 수 있을 것이다.

let badStart = """
one
two
"""
let end = """
three
"""
print(badStart + end)
// Prints two lines:
// one
// twothree

let goodStart = """
one
two

"""
print(goodStart + end)
// Prints three lines:
// one
// two
// three

---

String Interpolation (문자열 보간)

문자열 보간은 String에 상수, 변수 , 리터럴, 연산 등의 값을 넣는 것을 말한다. 문자열 보간을 사용할 때에는 \()를 문자열에 넣어주면 된다. 아래 예시를 봐라.

let multiplier = 3
let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
// message is "3 times 2.5 is 7.5"

이러한 문자열 보간도 앞에서 배운 것과 같이 #을 쓰면 무효화 된다. #를 문자 앞에 붙이면 사용할 수도 있긴 하다.

print(#"Write an interpolated string in Swift using \(multiplier)."#)
// Prints "Write an interpolated string in Swift using \(multiplier)."

print(#"6 times 7 is \#(6 * 7)."#)
// Prints "6 times 7 is 42."

---

Unicode (유니코드)

유니코드는 텍스트를 인코딩, 표현하기 위한 국제 표준이다. 어떠한 문자와 언어도 표준화된 형식으로 표현할 수 있으며 외부 소스나 웹에서도 읽고 쓸 수 있다. Swift의 String, Character타입도 유니코드 형식을 사용한다.

Unicode Scalar Values

swift의 native String타입은 유니코드 스칼라 값으로 구성된다. 유니코드 스칼라 값은 고유한 21비트 수이다. 모든 21비트 유니코드 스칼라 값이 문자에 할당되는 것은 아니고 향후 추가가 되거나 UTF-16인코딩에 사용되도록 예약되어 있다. 간단하게 예를 들어 보면, U+0061dms ("a") 나타내며, U+1F425는 ("🐥")를 나타낸다. 

Extended Grapheme Clusters

Swift의 Character타입은 하나의 grapheme클러스터를 나타낸다. 확장된 Grapheme Cluster는 유니코드 스칼라 시퀀스로 사람이 읽을 수 있는 문자를 생성한다. (아래 코드에 대해서 유니코드가 어떻게 형성되고 어떻게 변형되는지? 자세하게 설명되어 있는데 자세한 설명은 생략하고 코드만 첨부해 놓음)

let eAcute: Character = "\u{E9}"                         // é
let combinedEAcute: Character = "\u{65}\u{301}"          // e followed by ́
// eAcute is é, combinedEAcute is é

한글은 어떻게 표현될까?
"한"이라는 글자로 예를 들면 "한"이라고 표현할 수도 있고 "ㅎ" + "ㅏ" + "ㄴ" 으로도 표현할 수 있다. (공식문서에 이렇게 한글이 설명되어 있으니까 뭔가 뿌듯하고 신기하다 히히히)

let precomposed: Character = "\u{D55C}"                  // 한
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
// precomposed is 한, decomposed is 한

즉, Extended Grapheme Clusters를 사용하면 단일 스칼라에 다른 스칼라 값을 묶어서 보여줄 수 있다.

---

Counting Characters (문자열 길이 count)

String은 Count라는 프로퍼티를 활용하여 해당 String이 포함하는 문자의 수(string의 길이) 를 나타낼 수 있다.

let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
print("unusualMenagerie has \(unusualMenagerie.count) characters")
// Prints "unusualMenagerie has 40 characters"

아까 본 Extended grapheme clusters에서 é는 두개의 스칼라로 이루어 졌다고 했는데 이런 문자가 포함된 String의 count 프로퍼티의 값은 얼마일까?

var word = "cafe"
print("the number of characters in \(word) is \(word.count)")
// Prints "the number of characters in cafe is 4"

word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301

print("the number of characters in \(word) is \(word.count)")
// Prints "the number of characters in café is 4"

유니코드로 쓰여진 string도 알기 쉽게 출력된 문자의 길이를 출력해준다. 이런 경우에서 볼 수 있듯이 문자들이 다른 양의 메모리를 가질 수도 있다는 것이다. 즉, count 프로퍼티에 의해 반환되는 문자수는 NSString의 length 프로퍼티와는 동일하지 않을 수 있다는 것이다. NSString 의 length프로퍼티는 UTF-16 표현 내 16비트 코드 단위 수로 문자의 수를 센다.

---

 

Accessing and Modifying a String (문자열 접근 및 수정)

String의 메서드와 프로퍼티를 활용하여 문자열에 접근하고 수정할 수 있다.

String Indices (문자열 인덱스)

string타입은 index타입이다. String.index 프로퍼티를 활용하여 해당 위치에 있는 character에 접근할 수 있다. 그런데 위에서 배웠듯이, 각각의 문자가 다른 양의 메모리를 가질 수 있기 때문에 swift문자열은 정수 값으로 Index를 생성할 수 없다.

우선 startIndex는 string의 첫 character에 접근하는 위치이며, endIndex는 마지막 character에 접근하는 위치이다. 만약 빈 String이라면 startIndex와 endIndex의 값은 같다.
String의 index(before:), index(after:)을 사용해서 인덱스에 접근할 수 있고, index(_:offsetBy:)메소드를 이용해서 여러 문자를 한 번에 뛰어넘을 수 도 있다.

let greeting = "Guten Tag!"
greeting[greeting.startIndex]
// G
greeting[greeting.index(before: greeting.endIndex)]
// !
greeting[greeting.index(after: greeting.startIndex)]
// u
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]
// a

만약 String 범위에서 벗어난 인덱스에 접근하려고 하면 에러를 발생시킨다.

greeting[greeting.endIndex] // Error
greeting.index(after: greeting.endIndex) // Error

indices 프로퍼티를 사용한다면 문자열의 모든 index에 접근 할 수 있다.

for index in greeting.indices {
    print("\(greeting[index]) ", terminator: "")
}
// Prints "G u t e n   T a g ! "

 

Inserting and Removing (문자열 삽입 및 삭제) : string.insert(), sring.remove()

String의 특정 인덱스에 Character를 삽입하거나 삭제할 수 있다. 특정 인덱스에 하나의 문자만 넣을 때는 insert(_:at:)메소드를 사용하고, 특정 인덱스에 '문자열'을 넣으려면 insert(contentsOf:at:)을 사용한다.

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)
// welcome now equals "hello!"

welcome.insert(contentsOf: " there", at: welcome.index(before: welcome.endIndex))
// welcome now equals "hello there!"

remove(삭제)도 마찬가지로 한글자만 삭제할 경우 remove(:at:)을 사용하면 되고, 문자열이나 특정한 범위를 삭제하고 싶을 때는 removeSubragne(_:) 메소드를 사용하면 된다.

welcome.remove(at: welcome.index(before: welcome.endIndex))
// welcome now equals "hello there"
// hello there!에서 !가 삭제됨 (마지막 인덱스 before)

let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// welcome now equals "hello"
// 보통 맨 뒤의 인덱스가 -1 이니까, -6부터 (공백) endindex before까지 삭제하면된다. (끝까지)
// swift에서는 마지막을 endindex before 로 인식하나보다.

---

SubStrings (부분 문자열)

String에서 prefix(_:)와 같은 메소드로 substring을 가지고 오면 결과는 Substring 인스턴스가 된다. swift에서 substring과 같은 string은 거의 비슷하기 때문에 개발자는 그냥 동일하게 사용할 수 있다.

하지만 substring은 string과 다르게 string에 대한 작업을 수행하는 아주 짧은 시간 동안만 사용한ㄷ. 만약 더 길게 사용하고 싶다면 substring을 아예 새로운 string으로 만들어 줘야 한다.

let greeting = "Hello, world!"
let index = greeting.firstIndex(of: ",") ?? greeting.endIndex
let beginning = greeting[..<index]
// beginning is "Hello"

// Convert the result to a String for long-term storage.
let newString = String(beginning)

문자열과 마찬가지로 substring도 메모리를 가지게 되는데 여기서 string과 substring의 차이를 발견할 수 있다. substring은 기존의 string이 사용하고 있는 메모리를 재사용하거나 다른 substring이 사용하는 메모리를 사용할 수 있다. 이는 기존의 string이나 substring을 수정하지 않으면 메모리 복사를 하지 않기 때문에 낭비를 하지 않을 수 있다. 하지만 substring은 기존의 string의 메모리를 재사용하는데 이러한 방식 때문에 substring을 사용하는 동안에는 기존의 string을 메모리에 보관해야 한다. 즉, substring을 오래 지속하기에는 적합하지 않다.

출처: Swift 공식문서 3단원

---

Comparing Strings (문자열 비교)

swift는 텍스트 값을 비교할 수 있는 세 가지 방법을 제공한다 : 문자열과 문자 동일성 판단, 접두사 동일성 판단, 접미사 동일성 판단.

String and Character Equality (문자 및 문자열 동일성) : ==, !==

문자열 및 문자 동일성은 비교 연산자와 동일하게  동일 연산자 (==) 같지않음 연산자 (!=)를 활용한다.

let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
	print("These two strings are considered equal")
}
// Prints "These two strings are considered equal"

 

extended grapheme clusters가 동일한 경우 두 문자열도 동일한 것으로 간주한다. 아까 본é와 같이 두 개의 스칼라로 이루어 진 문자인 경우에도 e와 동일한 문자로 간주한다.

// "Voulez-vous un café?" using LATIN SMALL LETTER E WITH ACUTE
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"

// "Voulez-vous un café?" using LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"

if eAcuteQuestion == combinedEAcuteQuestion {
    print("These two strings are considered equal")
}
// Prints "These two strings are considered equal"

 

반대로 영어에서 사용되는 라틴어 대문자 A (U+0041, or "A") 는 러시아에서 사용되는 키릴문자 A (U+0410, or "А")와는 같지 않다.

let latinCapitalLetterA: Character = "\u{41}"
let cyrillicCapitalLetterA: Character = "\u{0410}"

if latinCapitalLetterA != cyrillicCapitalLetterA {
    print("These two characters aren't equivalent.")
}
// Prints "These two characters aren't equivalent."

 

Prefix and Suffix Equality (접두사 및 접미사 동일성) : hasPrefix(), hasSuffix()

문자열에 특정 문자열 접두사 또는 접미사가 있는지 확인 하려면 문자열의 hasPrefix(_:) 및 hasSuffix(_:)메서드를 사용하면 된다. 두 메서드는 모두 문자열 유형의 단일 인수를 사용하고 부울 값을 반환한다.

let romeoAndJuliet = [
    "Act 1 Scene 1: Verona, A public place",
    "Act 1 Scene 2: Capulet's mansion",
    "Act 1 Scene 3: A room in Capulet's mansion",
    "Act 1 Scene 4: A street outside Capulet's mansion",
    "Act 1 Scene 5: The Great Hall in Capulet's mansion",
    "Act 2 Scene 1: Outside Capulet's mansion",
    "Act 2 Scene 2: Capulet's orchard",
    "Act 2 Scene 3: Outside Friar Lawrence's cell",
    "Act 2 Scene 4: A street in Verona",
    "Act 2 Scene 5: Capulet's mansion",
    "Act 2 Scene 6: Friar Lawrence's cell"
]

var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Act 1 ") {
        act1SceneCount += 1
    }
}
print("There are \(act1SceneCount) scenes in Act 1")
// Prints "There are 5 scenes in Act 1"

var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Act 1 ") {
        act1SceneCount += 1
    }
}
print("There are \(act1SceneCount) scenes in Act 1")
// Prints "There are 5 scenes in Act 1"

---

Unicode Representations of Strings

유니코드 문자열이 텍스트 파일이나 다른 저장소에 저장될 때 문자열의 유니코드 스칼라 값은 여러 가지 Unicode-defined encoding forms에 의해 인코딩 된다. 여기엔 UTF-8(8비트로 인코딩), UTF-16(16비트로 인코딩), UTF-32(32비트로 인코딩)가 있다.

Swift는 문자열의 유니코드 표현을 하는 방법으로 여러 가지를 제공한다. 세 가지의 유니코드 표현 방식으로 String 값에 접근할 수 있다.(UTF-8, UTF-16, UTF-32) 그럼 세 가지 유니코드 표현 방식의 차이를 살펴보자.

let dogString = "Dog‼🐶"

 

UTF-8 Representation (8비트)

이러한 코드의 세 가지 유니코드 표현 방식을 살펴보면 다음과 같다.

for codeUnit in dogString.utf8 {
    print("\(codeUnit) ", terminator: "")
}
print("")
// Prints "68 111 103 226 128 188 240 159 144 182 "

세 자리 십진수로 문자를 표현하는 것을 볼 수 있다. 이게 바로 UTF-8 표현이다.

 

UTF-16 Representation (16비트) : string.UTF16View()

개발자는 string.UTF16View 로 UTF-16 표현방식에 접근할 수 있고, 부호가 없는 16비트로 표현하게 된다.

for codeUnit in dogString.utf16 {
    print("\(codeUnit) ", terminator: "")
}
print("")
// Prints "68 111 103 8252 55357 56374 "

 

Unicode Scalar Representation

유니코드를 10진수로 바꿀 수 있다. 사실 유니코드가 16진수 이니 그냥 16진수를 10진수로 변환한다고 볼 수 있다.

for scalar in dogString.unicodeScalars {
    print("\(scalar.value) ", terminator: "")
}
print("")
// Prints "68 111 103 8252 128054 "

처음 세 개의 값은 D, o, g 문자를 나타낸다. 네번째 codeUnit 값 (8252)는 16진수 값 203C와 같은 십진법이며, 이는 U+203C를 나타낸다.

각 값들을 unicodeScalar 값을 사용하여 문자열 보간과 같이 새 문자열 값을 구성할 수 도 있다. (아래)

for scalar in dogString.unicodeScalars {
    print("\(scalar) ")
}
// D
// o
// g
// ‼
// 🐶

 

마무리하며

끝.. 길다.. 1월 이내로는 꼭 이 모든 문법 사항을 익히고 코딩테스트를 swift로 볼 수 있게 노력하자!