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

안녕하세요. 이번에는 Swift에서 텍스트 데이터를 다루는 핵심 요소인 문자열(String)과 문자(Character)에 대해 자세히 알아보겠습니다. Swift는 유니코드를 완벽하게 지원하는 문자열 처리 기능을 제공합니다.

📌 문자열과 문자 소개

Swift에서 문자열은 String 타입으로, 개별 문자는 Character 타입으로 표현됩니다.

let greeting = "Hello, world!"  // String 타입
let firstChar: Character = "H"  // Character 타입

String: 문자들의 연속으로 이루어진 텍스트를 표현하는 타입

Character: 하나의 문자(확장된 문자소 클러스터)를 표현하는 타입

Swift의 문자열은 유니코드 호환성, 빠른 성능, 메모리 효율성을 갖추고 있으며, Foundation 프레임워크의 NSString과도 연결되어 있습니다.

📌 문자열 리터럴 (String Literals)

기본 문자열 리터럴

let someString = "Some string literal value"

여러줄 문자열 리터럴

3개의 쌍따옴표(""")로 여러 줄의 문자열을 표현할 수 있습니다:

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

여러줄 문자열 리터럴: 3개의 쌍따옴표로 둘러싸인 여러 줄에 걸친 문자열로, 줄바꿈과 들여쓰기를 보존합니다.

특수 문자 포함하기

let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
// "Imagination is more important than knowledge" - Einstein

// 유니코드 스칼라를 사용한 특수 문자
let dollarSign = "\u{24}"        // $,  유니코드 U+0024
let blackHeart = "\u{2665}"      // ♥,  유니코드 U+2665
let sparklingHeart = "\u{1F496}" // 💖, 유니코드 U+1F496

이스케이프 문자: 백슬래시(\)로 시작하는 특수 시퀀스로, 문자열 내에서 특별한 의미를 갖습니다.

유니코드 스칼라: \u{n} 형식으로 표현되는 유니코드 문자 코드 포인트

확장된 문자열 구분기호

# 기호로 둘러싸인 문자열은 특수 문자의 처리를 제어할 수 있습니다:

let normalString = "Line 1\nLine 2"  // 줄바꿈이 적용됨
let rawString = #"Line 1\nLine 2"#    // 원시 텍스트 그대로 표시: "Line 1\nLine 2"

// 확장 구분기호 내에서 이스케이프 활성화하기
let escapedString = #"Line 1\#nLine 2"#  // 줄바꿈 활성화

확장된 문자열 구분기호: 문자열을 #"..."# 형태로 감싸서 특수 문자의 처리 방식을 제어하는 기능

📌 문자열 초기화와 변경

빈 문자열 생성

var emptyString = ""                // 빈 문자열 리터럴
var anotherEmptyString = String()   // 초기화 구문

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

문자열 변경 가능성

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

let constantString = "Highlander"
// constantString += " and another Highlander"  // 오류! 상수는 변경 불가

isEmpty: 문자열이 비어있는지 확인하는 프로퍼티

변수(var)와 상수(let): 변수는 값을 변경할 수 있고, 상수는 한 번 할당하면 변경할 수 없습니다.

문자열은 값 타입

Swift에서 문자열은 값 타입(value type)으로, 다른 함수나 메서드에 전달될 때 복사됩니다. 이는 원본이 변경되지 않도록 보호합니다.

값 타입: 할당이나 함수 호출 시 값이 복사되는 타입

📌 문자 작업 (Working with Characters)

문자열의 개별 문자 접근하기

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

Character 타입 명시적 선언

let exclamationMark: Character = "!"

문자 배열로 문자열 생성

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

for-in 루프: 문자열의 각 문자를 순회하는 방법

타입 명시: 콜론(:)과 타입 이름을 사용하여 변수나 상수의 타입을 명시적으로 지정

📌 문자열 연결과 삽입

문자열 연결

let string1 = "hello"
let string2 = " there"
let welcome = string1 + string2  // "hello there"

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

문자 추가

var welcome = "hello"
welcome.append(" there")         // "hello there"
welcome.append(exclamationMark)  // "hello there!"

문자열 삽입 (String Interpolation)

문자열 안에 변수, 상수, 표현식 등을 포함시키는 방법:

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

확장된 구분기호 내에서 문자열 삽입 사용:

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

문자열 삽입: \(표현식) 형태로 문자열 내에 값을 포함시키는 방법

append(): 문자열 끝에 다른 문자열이나 문자를 추가하는 메서드

📌 유니코드와 문자 표현

Swift의 문자열과 문자는 유니코드를 완벽하게 지원합니다. 하나의 문자(Character)는 여러 유니코드 스칼라로 구성될 수 있는 "확장된 문자소 클러스터"로 표현됩니다.

// 같은 문자 "é"를 표현하는 두 가지 방법
let eAcute: Character = "\u{E9}"                // é (단일 유니코드 스칼라)
let combinedEAcute: Character = "\u{65}\u{301}" // e + ́  -> é (두 개의 유니코드 스칼라)
// eAcute와 combinedEAcute는 동일하게 취급됨

유니코드: 전 세계의 다양한 문자를 일관되게 표현하기 위한 국제 표준

유니코드 스칼라: 단일 유니코드 코드 포인트, 21비트 숫자

확장된 문자소 클러스터: 사람이 읽을 수 있는 하나의 문자를 형성하는 유니코드 스칼라의 시퀀스

문자 카운팅

let greeting = "Hello, 세계!"
print(greeting.count)  // 9

count: 문자열 내의 문자(확장된 문자소 클러스터) 수를 반환하는 프로퍼티

📌 문자열 인덱스와 접근

문자열 인덱스

let greeting = "Hello, world!"

// 인덱스 접근
greeting[greeting.startIndex]                      // "H"
greeting[greeting.index(before: greeting.endIndex)]  // "!"
greeting[greeting.index(after: greeting.startIndex)]  // "e"

// 지정된 오프셋의 인덱스
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]  // "w"

indices 프로퍼티 사용

for index in greeting.indices {
    print("\(greeting[index]) ", terminator: "")
}
// "H e l l o ,   w o r l d ! "

startIndex: 문자열의 첫 번째 위치를 가리키는 인덱스

endIndex: 문자열의 마지막 위치 다음을 가리키는 인덱스(유효하지 않은 위치)

indices: 문자열의 모든 인덱스를 포함하는 범위

문자열 삽입과 삭제

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

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

welcome.remove(at: welcome.index(before: welcome.endIndex))
// "hello there"

let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
welcome.removeSubrange(range)
// "hello"

insert(_:at:): 지정된 위치에 문자를 삽입하는 메서드

insert(contentsOf:at:): 지정된 위치에 문자열을 삽입하는 메서드

remove(at:): 지정된 위치의 문자를 삭제하는 메서드

removeSubrange(_:): 지정된 범위의 문자들을 삭제하는 메서드

📌 부분 문자열 (Substrings)

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

// 부분 문자열을 문자열로 변환(장기 저장용)
let newString = String(beginning)

부분 문자열(Substring): 원본 문자열의 메모리를 재사용하는 임시 문자열로, 장기 저장에는 String으로 변환해야 함

firstIndex(of:): 지정된 요소가 처음 나타나는 위치의 인덱스를 반환하는 메서드

📌 문자열 비교

문자열과 문자 동등성

// 문자열 비교
let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
    print("두 문자열은 동일합니다")
}

// 다른 유니코드 표현이지만 같은 문자
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"
if eAcuteQuestion == combinedEAcuteQuestion {
    print("두 문자열은 동일합니다")
}

접두사와 접미사 확인

let romeoAndJuliet = [
    "Act 1 Scene 1: Verona, A public place",
    "Act 1 Scene 2: Capulet's mansion",
    "Act 2 Scene 1: Outside Capulet's mansion",
    "Act 2 Scene 2: Capulet's orchard"
]

// 접두사 확인
var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Act 1 ") {
        act1SceneCount += 1
    }
}
print("Act 1에는 \(act1SceneCount)개의 장면이 있습니다") // 2

// 접미사 확인
var mansionCount = 0
for scene in romeoAndJuliet {
    if scene.hasSuffix("Capulet's mansion") {
        mansionCount += 1
    }
}
print("Capulet's mansion에서 \(mansionCount)개의 장면이 일어납니다") // 2

hasPrefix(_:): 문자열이 지정된 접두사로 시작하는지 확인하는 메서드

hasSuffix(_:): 문자열이 지정된 접미사로 끝나는지 확인하는 메서드

📌 문자열의 유니코드 표현

Swift는 문자열의 유니코드 표현에 접근하는 여러 방법을 제공합니다:

UTF-8 표현

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

UTF-16 표현

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

유니코드 스칼라 표현

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

// 스칼라 자체를 출력
for scalar in dogString.unicodeScalars {
    print("\(scalar) ")
}
// D, o, g, ‼, 🐶

utf8: 문자열의 UTF-8 표현에 접근하는 프로퍼티

utf16: 문자열의 UTF-16 표현에 접근하는 프로퍼티

unicodeScalars: 문자열의 유니코드 스칼라 표현에 접근하는 프로퍼티

---

Swift의 문자열과 문자는 유니코드 호환성, 안전한 타입 처리, 메모리 효율성을 제공하면서도 사용하기 쉽게 설계되었습니다. 이러한 특성은 국제화된 앱을 개발하거나 복잡한 텍스트 처리가 필요한 경우에 특히 중요합니다.