[Swift] 문자열과 문자 (Strings and Characters)

Swift 의 String 유형은 Foundation 프레임워크의 NSString이 연결된 타입이기 때문에,

Foundation을 import하면 String에서 NSString 메소드에 접근할 수 있습니다. 

 

---

문자열 리터럴 (String Literals)

문자열은 큰 따옴표 (" ")로 묶어서 표현 합니다.

let something = "Some string literal value"

 

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

여러줄의 문자열을 사용하고 싶은 경우 큰 따옴표 3개 (""" """) 를 묶어서 사용할 수 있습니다. 

let multiineString = """
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."
"""

""" 로 시작하여 줄바꿈 후 내용을 적은 다음 다시 줄을 바꿔  """ 로 끝 맺음을 하면 됩니다. (아래 예시 참고!)

같은 String 타입이기 때문에 아래 내용도 같습니다.

 

let singleLineString = "These are the same."
let multilineString = """
These are the same.
"""

type(of: singleLineString)   // String.Type
type(of: multilineString)    // String.Type

// multiline literal의 나쁜 예
let multilineString = """These are the same."""  // error

 

줄바꿈

1. 여러줄 문자열을 사용하여 줄바꿈을 하고싶으면 백슬래쉬 ( \ )를 사용합니다. (playground에서 안됨..) 확인이 필요할것 같다.

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

2. 한줄을 띄어서 문자열을 입력.

let lineBreaks = """

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

"""

 

 

들여쓰기

들여쓰기의 기준은 마지막 """ 을 기준으로 합니다.

let linesWithIndentation = """
들여쓰기를 해보자
    들여쓰기를 해보자
들여쓰기를 해볼까
"""

 

 

문자열 리터럴의 특수 문자

문자열 리터럴은 다음과 같은 특수 문자를 포함할 수 있습니다.

• 줄바꿈: \n, \, \r
• 들여쓰기: \t 
• 문자열 내 따옴표 \", \'
• \u{n} n은 1-8자리 십진수 형태로 구성된 유니코드

let dollaSign = "\u{24}"            // $, 유니코드 U+0024
let blackHeart = "\u{2665}"         // ♥, 유니코드 U+2665
let sparklingHeart = "\u{1F496}" // 💖,유니코드 U+1F496

---

빈 문자열 초기화

문자열 초기화를 할 때는 아래와 같이 합니다.

var emptyString = ""
// 또는 
var anotherEmptyString = String()

 

문자열이 비어있는지 확인하려면 isEmpty 프로퍼티를 사용합니다.

var emptyString = ""

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

 

문자열 수정

변수로 지정된 문자열을 수정할 수도 있습니다.

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

let constantString = "Highlander"
constantString += " and another Highlander"
// 문자열 상수(let)로 선언돼 있어 에러!!

 

---

값 타입 문자열

Swift의 String은 값 타입으로 , 다른 메소드에서 할당 받은 문자열은 그 문자열을 수정해도 원본 문자열이 변하지 않습니다. 

 

---

문자 (Characters)

문자열의 개별 문자를 for - in 루프를 통해 접근할 수 있습니다.

for character in "강아지🐶" {
    print(character)
}

// 강
// 아
// 지 
// 🐶

 

다음과 같이 문자 상수를 선언할 수 있습니다. 

let exclamationMark: Character = "!"
// "!"

 

문자 배열을 이용해서 문자열의 초기화 메소드에 인자로 넣어 문자열을 생성할 수 있습니다.

let catCharacters: [Character] = ["고", "양", "이", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// Prints "고양이!🐱"

---

문자열과 문자의 결합 (String + Characters)

문자열 끼리 결합 할 수 있습니다. 

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

변수로 지정된 문자열과 새로운 문자열을 연산자 (+=)를 이용하여 결합 할 수도 있습니다.

let string2 = " there"

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

변수로 지정된 문자열에 append() 메소드를 사용해 문자를 추가도 할 수 있습니다.

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

 

여러줄 문자열끼리의 결합일 경우엔 결합되어 들어올 문자열의 칸을 비워줘야 합니다.

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

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

---

문자열 삽입

백슬래쉬 ( \ )를 사용해 상수, 변수, 리터럴 값을 문자열에 추가할 수 있습니다.

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

---

유니코드 

전 세계의 모든 문자를 컴퓨터에서 일관되게 표현하고 다룰 수 있도록 설계된 국제 표준코드 입니다. 

표준화된 형식으로 거의 모든 언어를 표현할 수있으며, Swift의 문자열과 문자 타입은 유니코드를 준수 합니다.

 

유니코드 스칼라

Swift의 String 타입은 유니코드 스칼라 값으로 만들어 졌습니다. 하나의 유니코드는 21비트의 숫자로 구성되어 있습니다. 

예를들어 

U+0061는 라틴어의 소문자 a를 나타내고 U+1F425는 병아리 🐥 를 나타냅니다.

 

문자단위의 확장

유니코드를 결합하여 사용할 수 있습니다.

  let precomposed: Character = "\u{D55C}"                        // 한
  let decomposed: Character = "\u{1112}\u{u1161}\u{11AB}"    // ㅎ, ㅏ,ㄴ
  // precomposed : 한, decomposed 한

 

문자 세기 (counting)

문자열의 문자 순서를 세기 위해서는 문자열의 count 프로퍼티를 사용합니다.

let animalsStringCount = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
print("animalsStringCount의 문자갯수는 \(animalsStringCount.count) 개 입니다.")
// animalsStringCount의 문자갯수는 40 개 입니다.

 

문자열의 접근과 수정

문자열의 접근과 수정은 메소드 혹은 프로퍼티, 서브스크립트(subscript) 문법을 이용해서 할 수 있습니다.

 

문자열 인덱스

startIndex, endIndex, index(before:), index(after:), index(_:offsetBy:) 메소드등을 이용하여 문자열에서 특정 문자에 접근할 수 있습니다.

let stringIndex = "영일이삼사 육칠팔구"
stringIndex[stringIndex.startIndex]
// 영
stringIndex[stringIndex.index(before: stringIndex.endIndex)]
// 구
stringIndex[stringIndex.index(after: stringIndex.startIndex)]
// 일
let index = stringIndex.index(stringIndex.startIndex, offsetBy: 3)
stringIndex[index]
// 삼

 

문자열의 인덱스를 벗어나는 문자를 가져오려고 하면 런타임 에러가 발생합니다.

// endIndex는 마지막 인덱스 +1 이라고 생각하면 됩니다.
stringIndex[stringIndex.endIndex] // error

 

문자열의 개별 문자에 접근하기 위해서는 indices 프로퍼티를 사용합니다.

for index in stringIndex.indices {
    print("\(stringIndex[index])", terminator: "")
}
// 영일이삼사 육칠팔구

 

문자의 삽입과 삭제 

문자를 삽입할 때에는 insert(:at:), insert(contentsOf:at:)를

var welcome = "hello"
welcome.insert("!", at: welcome.endIndex)  // welcome의 마지막 Index '뒤'에 삽입
// hello!
welcome.insert(contentsOf: " there", at: welcome.index(before: welcome.endIndex)) // welcome의 마지막 index '앞'에 삽입
// hello there!

 

문자를 삽입할 때에는 remove(at:), removeSubrange(:) 를 사용합니다.

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

let range = welcome.index(welcome.endIndex, offsetBy: -6) ..< welcome.endIndex
// there 까지의 범위
welcome.removeSubrange(range)
// hello

---

부분 문자열 (Substrings)

문자열에서 부분문자를 얻기 위해 prefix (_:)와 같은 서브스크립트 메소드를 이용할 수 있는데, 이렇게 얻은 문자열은 부분문자열(SubString) 인스턴스 입니다. 

만약 부분 문자열을 오랜기간 또는 영구적으로 사용한다면 문자열 인스턴스로 바꿔 사용하는게 좋습니다.

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

type(of: beginning)                   // Substring.Type
let newString = String(beginning)     // Hello
type(of: newString)                   // String.Type

위 예시와 같은 상황일 경우 newString 부분을 보면 String 타입으로 바꿔주는데, 이유는 메모리 관리 때문입니다.

부분 문자열(Substring)은 문자를 원본 String의 메모리를 참조하기 때문에 SubString을 계속 사용하는이상 원본 String이 계속 메모리에 남아있기 때문입니다.

Substring을 계속쓸것 같으면 String으로 바꿔주자.

 

---

문자열 비교

Swift에서는 문자열과 문자, 접두사, 접미사를 비교하는 방법을 제공합니다.

 

문자열과 문자 비교

문자열과 문자 비교에는 == 혹은 != 연산자를 사용합니다.

let strings = "We're same."
let sameStrings = "We're same."
if strings == sameStrings {
    print("same strings")
}
// same strings

 

접두사와 접미사 비교 

접두사와 접미사 비교를 위해선 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"
]

 

아래 코드는 romeoAndJuliet 배열에서 접두어 Act 1 가 몇개 들어있는지 확인하는 코드 입니다.

 

hasPrefix(:)

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

 

다음은 문자열 배열에서 접미어 mansion과 cell이 각각 몇개 들어있는지 확인하는 코드 입니다. 

 

hasSuffix(:)

var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
    if scene.hasSuffix("mansion") {
        mansionCount += 1
    } else if scene.hasSuffix("cell") {
        cellCount += 1
    }
}

print("mansionCount: \(mansionCount), cellCount: \(cellCount)")
// mansionCount: 6, cellCount: 2

// 질문: map으로 나타낼순 없을까.