Strings and Characters

iamgroot1231·2022년 6월 7일
0

Swift Language Guide

목록 보기
3/10
post-thumbnail

Swift Language Guide - Strings and Characters

Strings and Characters

  • 문자열은 "hello, world" 또는 "albatross"와 같은 일련의 문자입니다. Swift 문자열은 String 유형으로 표현됩니다.
  • 문자열은 간단하게 +로 결합이 가능합니다.
  • 문자열을 사용하여 문자열 보간이라고 하는 프로세스에서 상수, 변수, 리터럴 및 표현식을 더 긴 문자열에 삽입할 수도 있습니다.

📌 String Literals

  • 코드 내에 미리 정의된 문자열 값을 문자열 리터럴로 포함할 수 있습니다. 문자열 리터럴은 큰따옴표(")로 묶인 일련의 문자입니다.
  • 상수 또는 변수의 초기 값으로 문자열 리터럴을 사용합니다.
    let someString = "Some string literal value"

📍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.
    
    """
  • 주변 코드와 일치하도록 여러 줄 문자열을 들여쓸 수 있습니다. 닫는 따옴표 앞의 공백(""")은 Swift에 다른 모든 줄 앞에서 무시할 공백을 알려줍니다. 닫는 따옴표 앞에 추가하여 줄 시작 부분에 공백을 쓰면 해당 공백이 포함됩니다.

  • 위의 예에서 전체 여러 줄 문자열 리터럴이 들여쓰기가 되더라도 문자열의 첫 번째 줄과 마지막 줄은 공백으로 시작하지 않습니다. 하지만 중간 줄은 공백으로 시작합니다.

📍Special Characters in String Literals

  • 문자열 리터럴에는 다음과 같은 특수 문자가 포함될 수 있습니다.
  • \0(널 문자), \(백슬래시), \t(가로 탭), \n(줄 바꿈), \r(캐리지 리턴), \"(큰따옴표) 및 \'(작은 따옴표)
  • \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

  • 확장 구분 기호 내에 문자열 리터럴을 배치하여 특수 문자의 효과를 호출하지 않고 문자열에 특수 문자를 포함할 수 있습니다. 문자열을 따옴표(") 안에 넣고 숫자 기호(#)로 묶습니다.
  • #"Line 1\nLine 2#는 두 줄에 걸쳐 문자열을 인쇄하지 않고 줄 바꿈 (\n)를 인쇄합니다.
  • 문자열 리터럴에서 문자의 특수 효과가 필요한 경우 이스케이프 문자() 다음에 오는 문자열 내에서 숫자 기호의 수를 일치시키십시오.
  • 문자열이 #"Line 1\nLine 2#이고 줄바꿈을 하고싶다면 #"Line 1\#nLine 2"#를 사용할 수 있습니다. 마찬가지로 ###"Line1\###nLine2###도 줄바꿈을 실행합니다.
  • 확장 구분 기호를 사용하여 만든 문자열 리터럴은 여러 줄 문자열 리터럴일 수도 있습니다. 확장 구분 기호를 사용하여 리터럴을 종료하는 기본 동작을 재정의하여 여러 줄 문자열에 """ 텍스트를 포함할 수 있습니다.
    let threeMoreDoubleQuotationMarks = #"""
    Here are three more double quotes: """
    """#

📌Initializing an Empty String

  • 더 긴 문자열을 빌드하기 위한 시작점으로 빈 문자열 값을 만들려면 변수에 빈 문자열 리터럴을 할당하거나 이니셜라이저를 사용하여 새 문자열 인스턴스를 초기화합니다.
    var emptyString = ""               // empty string literal
    var anotherEmptyString = String()  // initializer syntax
    // these two strings are both empty, and are equivalent to each other
  • Boolean isEmpty 속성을 확인하여 String 값이 비어 있는지 확인합니다.
    if emptyString.isEmpty {
        print("Nothing to see here")
    }
    // Prints "Nothing to see here"

📌String Mutability

  • 특정 문자열을 변수(수정 가능한 경우) 또는 상수(수정할 수 없는 경우)에 할당하여 수정(또는 변경)할 수 있는지 여부를 나타냅니다.

    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

  • Swift의 String 타입은 값 타입입니다. 새 String 값을 생성하면 해당 String 값이 함수나 메서드에 전달될 때 복사됩니다.
  • 각각의 경우 기존 String 값의 새 복사본이 만들어지고 원본 버전이 아닌 새 복사본이 전달되거나 할당됩니다. 값 유형은 구조 및 열거형은 값 유형에 설명되어 있습니다.
  • Swift의 컴파일러는 실제 복사가 절대적으로 필요할 때만 발생하도록 문자열 사용을 최적화합니다.
  • 이는 문자열을 값 유형으로 사용할 때 항상 뛰어난 성능을 얻을 수 있음을 의미합니다.

📌Working with Characters

  • for-in 루프를 사용하여 문자열을 반복하여 문자열의 개별 문자 값에 액세스할 수 있습니다.
    for character in "Dog!🐶" {
        print(character)
    }
    // D
    // o
    // g
    // !
    // 🐶
  • 또는 Character Type을 선언해서 단일 문자 문자열 리터럴에서 독립 실행형 문자 상수 또는 변수를 만들 수 있습니다.
    let exclamationMark: Character = "!"
  • 문자열 값은 이니셜라이저에 인수로 Character 값의 배열을 전달하여 구성할 수 있습니다.
    let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
    let catString = String(catCharacters)
    print(catString)
    // Prints "Cat!🐱"

📌Concatenating Strings and Characters

  • 더하기 연산자(+)를 사용하여 문자열 값을 함께 추가(또는 연결)하여 새 문자열 값을 만들 수 있습니다.

    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"
  • 문자열 유형의 append()를 사용하여 문자열 변수에 문자 값을 추가할 수 있습니다.

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

    Character 값은 단일 문자만 포함해야 하므로 기존 Character 변수에 String 또는 Character를 추가할 수 없습니다.

  • 여러 줄 문자열 리터럴을 사용하여 더 긴 문자열의 줄을 작성하는 할때 문자열의 모든 줄이 마지막 줄을 포함하여 줄 바꿈으로 끝나기를 원하는 경우

    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

  • 문자열 보간은 문자열 리터럴 내부에 값을 포함하여 상수, 변수, 리터럴 및 표현식의 혼합에서 새 문자열 값을 구성하는 방법입니다.
    let multiplier = 3
    let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
    // message is "3 times 2.5 is 7.5"
  • 확장 구분 기호를 사용하는 문자열 내에서 문자열 보간을 사용하려면 백슬래시 뒤의 숫자 기호 수를 문자열의 시작과 끝에 있는 숫자 기호 수와 일치시키십시오.
    print(#"6 times 7 is \#(6 * 7)."#)
    // Prints "6 times 7 is 42."

📌Unicode

  • 유니코드는 다양한 쓰기 시스템에서 텍스트를 인코딩, 표현 및 처리하기 위한 국제 표준입니다.
  • 표준화된 형식으로 모든 언어의 거의 모든 문자를 나타내고 텍스트 파일이나 웹 페이지와 같은 외부 소스에서 해당 문자를 읽고 쓸 수 있습니다.
  • 이 섹션에 설명된 대로 Swift의 String 및 Character 유형은 완전히 유니코드와 호환됩니다.

📍Unicode Scalar Values

  • Swift의 기본 String 유형은 유니코드 스칼라 값에서 빌드됩니다.
  • 유니코드 스칼라 값은 소문자 a("a")의 경우 U+0061, 병아리 이모티콘("🐥")의 경우 U+1F425와 같이 문자 또는 수정자에 대한 고유한 21비트 숫자입니다.
  • 모든 21비트 유니코드 스칼라 값이 문자에 할당되는 것은 아닙니다. 일부 스칼라는 나중에 할당하거나 UTF-16 인코딩에서 사용하기 위해 예약되어 있습니다.
  • 문자에 할당된 스칼라 값에는 일반적으로 위의 예에서 LATIN SMALL LETTER A 및 FRONT-FACING BABY CHICK과 같은 이름도 있습니다.

📍Extended Grapheme Clusters

  • Swift의 문자 유형의 모든 인스턴스는 단일 확장 자소 클러스터를 나타냅니다. 확장 자소 클러스터는 (결합 시) 사람이 읽을 수 있는 단일 문자를 생성하는 하나 이상의 유니코드 스칼라 시퀀스입니다.
  • 문자 é는 단일 유니코드 스칼라 é(LATIN SMALL LETTER E WITH ACUTE 또는 U+00E9)로 나타낼 수 있습니다. 그러나 동일한 문자는 표준 문자 e(LATIN SMALL LETTER E 또는 U+0065) 다음에 COMBINING ACUTE ACCENT 스칼라(U+0301)가 오는 한 쌍의 스칼라로도 나타낼 수 있습니다.
  • COMBINING ACUTE ACCENT 스칼라는 그 앞에 오는 스칼라에 그래픽으로 적용되어 유니코드 인식 텍스트 렌더링 시스템에서 렌더링될 때 e를 é로 바꿉니다.
    let eAcute: Character = "\u{E9}"                         // é
    let combinedEAcute: Character = "\u{65}\u{301}"          // e followed by ́
    // eAcute is é, combinedEAcute is é
  • 이와같이 확장된 자소 클러스터는 많은 복잡한 스크립트 문자를 단일 문자 값으로 표현하는 유연한 방법입니다. 한글의 한글 음절은 사전 구성 또는 분해 시퀀스로 표시될 수 있습니다. 이 두 표현은 모두 Swift에서 단일 Character 값으로 간주됩니다.
    let precomposed: Character = "\u{D55C}"                  // 한
    let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
    // precomposed is 한, decomposed is 한

📌Counting Characters

  • 문자열에서 문자 값의 개수를 검색하려면 문자열의 count 속성을 사용합니다.

    let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
    print("unusualMenagerie has \(unusualMenagerie.count) characters")
    // Prints "unusualMenagerie has 40 characters"
  • 문자 값에 대한 Swift의 확장된 자소 클러스터 사용은 문자열 연결 및 수정이 문자열의 문자 수에 항상 영향을 주지는 않을 수 있음을 의미합니다.

  • 예를 들어, 4자로 된 단어 cafe로 새 문자열을 초기화한 다음 문자열 끝에 COMBINING ACUTE ACCENT(U+0301)를 추가하면 결과 문자열은 여전히 4의 문자 수를 가지며 네 번째 문자는 e가 아니라 é입니다.

    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"

    확장된 자소 클러스터는 여러 유니코드 스칼라로 구성될 수 있습니다. 즉, 다른 문자 및 동일한 문자의 다른 표현이 저장하는 데 필요한 메모리 양이 다를 수 있습니다. 이 때문에 Swift의 문자는 문자열 표현 내에서 동일한 양의 메모리를 차지하지 않습니다. 결과적으로 문자열의 문자 수는 확장된 자소 클러스터 경계를 결정하기 위해 문자열을 반복하지 않고 계산할 수 없습니다. 특히 긴 문자열 값으로 작업하는 경우 count 속성은 해당 문자열의 문자를 결정하기 위해 전체 문자열의 유니코드 스칼라를 반복해야 합니다. count 속성이 반환하는 문자의 개수는 동일한 문자를 포함하는 NSString의 length 속성과 항상 같지 않습니다. NSString의 길이는 문자열 내의 유니코드 확장 자소 클러스터 수가 아니라 문자열의 UTF-16 표현 내의 16비트 코드 단위 수를 기반으로 합니다.


📌Accessing and Modifying a String

  • 메서드 및 속성을 통해 또는 아래 첨자 구문을 사용하여 문자열에 액세스하고 수정합니다.

📍String Indices

  • 각 문자열 값에는 문자열의 각 문자 위치에 해당하는 연관된 색인 유형인 String.Index가 있습니다. 위에서 언급했듯이 다른 문자는 저장하는 데 다른 양의 메모리가 필요할 수 있으므로 특정 위치에 어떤 문자가 있는지 확인하려면 해당 문자열의 시작 또는 끝에서 각 유니코드 스칼라를 반복해야 합니다. 이러한 이유로 Swift 문자열은 정수 값으로 인덱싱할 수 없습니다.
  • startIndex 속성을 사용하여 문자열의 첫 번째 문자 위치에 액세스합니다.
    endIndex 속성은 문자열에서 마지막 문자 뒤의 위치입니다. 결과적으로 endIndex 속성은 문자열의 첨자에 대한 유효한 인수가 아닙니다. String이 비어 있으면 startIndex와 endIndex는 같습니다.
  • String의 index(before:) 및 index(after:) 메서드를 사용하여 주어진 인덱스 전후의 인덱스에 액세스합니다.
  • 지정된 인덱스에서 더 멀리 떨어진 인덱스에 액세스하려면 이러한 메서드 중 하나를 여러 번 호출하는 대신 index(_:offsetBy:) 메서드를 사용할 수 있습니다.
      ```swift=
      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
      ```
  • 문자열 범위 밖의 인덱스 또는 문자열 범위 밖의 인덱스에 있는 문자에 액세스하려고 하면 런타임 오류가 발생합니다.
    greeting[greeting.endIndex] // Error
    greeting.index(after: greeting.endIndex) // Error
  • indices 속성을 사용하여 문자열에 있는 개별 문자의 모든 인덱스에 액세스합니다.
    for index in greeting.indices {
        print("\(greeting[index]) ", terminator: "")
    }
    // Prints "G u t e n   T a g ! "

    Collection 프로토콜을 준수하는 모든 유형에서 startIndex 및 endIndex 속성과 index(before:), index(after:) 및 index(_:offsetBy:) 메서드를 사용할 수 있습니다. 여기에는 여기에 표시된 것처럼 문자열과 Array, Dictionary 및 Set과 같은 컬렉션 유형이 포함됩니다.

📍Inserting and Removing

  • 지정된 인덱스의 문자열에 단일 문자를 삽입하려면 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(at:) 메서드를 사용하고 지정된 범위의 하위 문자열을 제거하려면 removeSubrange(_:) 메서드를 사용합니다.

    welcome.remove(at: welcome.index(before: welcome.endIndex))
    // welcome now equals "hello there"
    
    let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
    welcome.removeSubrange(range)
    // welcome now equals "hello"

    RangeReplaceableCollection 프로토콜을 준수하는 모든 유형에서 insert(:at:), insert(contentsOf:at:), remove(at:) 및 removeSubrange(:) 메서드를 사용할 수 있습니다. 여기에는 여기에 표시된 것처럼 문자열과 Array, Dictionary 및 Set과 같은 컬렉션 유형이 포함됩니다.


📌Substrings

  • prefix(_:)와 같은 메서드를 사용하여 문자열에서 부분 문자열을 얻을 때 결과는 다른 문자열이 아니라 Substring의 인스턴스입니다.

  • Swift의 Substrings 문자열은 문자열과 거의 동일한 메서드를 가지고 있습니다. 즉, 문자열로 작업하는 것과 동일한 방식으로 부분 문자열을 사용할 수 있습니다.

  • 그러나 문자열과 달리 문자열에 대한 작업을 수행하는 동안에 부분 문자열을 짧은 시간 동안만 사용합니다. 더 오랜 시간 동안 결과를 저장할 준비가 되면 하위 문자열을 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)
  • String과 SubString의 차이점은 성능 최적화입니다. SubString이 원래String을 저장하는 데 사용된 메모리의 일부 또는 다른 SubString을 저장하는 데 사용된 메모리의 일부를 재사용할 수 있다는 것입니다. (문자열의 최적화도 비슷하지만 두 문자열이 메모리를 공유하면 동일합니다.) 이 성능 최적화는 문자열이나 부분 문자열을 수정할 때까지 메모리 복사의 성능 비용을 지불할 필요가 없음을 의미합니다.

  • 위에서 언급했듯이 SubString은 장기 저장에 적합하지 않습니다. 원래 String의 저장소를 재사용하기 때문에 SubString이 사용되는 한 전체 원본 String을 메모리에 보관해야 합니다.

  • 위의 예에서 greeting은 문자열입니다. 이는 greeting을 구성하는 문자가 저장되는 메모리 영역이 있음을 의미합니다. 시작은 인사말의 하위 문자열이기 때문에 인사말이 사용하는 메모리를 재사용합니다.대조적으로 newString은 문자열입니다. 하위 문자열에서 생성될 때 자체 저장소가 있습니다. 아래 그림은 이러한 관계를 보여줍니다.

    String과 Substring은 모두 StringProtocol 프로토콜을 따르므로 문자열 조작 함수가 StringProtocol 값을 받아들이는 것이 편리한 경우가 많습니다. String 또는 Substring 값을 사용하여 이러한 함수를 호출할 수 있습니다.

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

    Swift의 문자열 및 문자 비교는 로케일을 구분하지 않습니다.

> 로케일(Locale)이란?
로케일은 사용자 인터페이스에서 사용되는 언어, 지역 설정, 출력 형식 등을 정의하는 문자열입니다. 유닉스Unix와 리눅스Linux와 같은 POSIX 기반의 시스템에서는 같은 형식을 공유하고 있습니다. 애플의 맥OS를 비롯한 Darwin 계열 운영체제들도 POSIX 호환이 되기 때문에 같은 형식의 로케일 문자열을 사용합니다.
>로케일과 관련된 환경변수들을 설정함으로서 로케일 설정을 변경할 수 있으며, 이 설정값에 따라서 프로그램이 지원하는 경우 메시지, 시간 형식, 통화 형식 등의 출력이나 동작을 변경할 수 있습니다. 로케일 설정은 특정 언어의 입출력에 영향을 주는 경우가 있어서, 영어 이외의 언어를 사용하는 경우 적절한 값을 지정해야합니다.

📍Prefix and Suffix Equality

  • 문자열에 특정 문자열 접두사 또는 접미사가 있는지 확인하려면 문자열의 hasPrefix(:) 및 hasSuffix(:) 메서드를 호출합니다. 둘 다 String 유형의 단일 인수를 사용하고 부울 값을 반환합니다.
  • 아래 예는 셰익스피어의 로미오와 줄리엣의 처음 두 막에서 장면 위치를 나타내는 문자열 배열을 고려합니다.
    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 배열과 함께 hasPrefix(_:) 메서드를 사용하여 연극 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"
    • hasSuffix(_:) 메소드를 사용하여 Capulet의 저택과 Friar Lawrence의 감방에서 또는 그 주변에서 일어나는 장면의 수를 계산할 수 있습니다.
      var mansionCount = 0
      var cellCount = 0
      for scene in romeoAndJuliet {
          if scene.hasSuffix("Capulet's mansion") {
              mansionCount += 1
          } else if scene.hasSuffix("Friar Lawrence's cell") {
              cellCount += 1
          }
      }
      print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
      // Prints "6 mansion scenes; 2 cell scenes"

      hasPrefix(:) 및 hasSuffix(:) 메서드는 문자열 및 문자 평등에 설명된 대로 각 문자열의 확장된 자소 클러스터 간에 문자별 표준 동등성 비교를 수행합니다.

profile
행복을 주는 iOS 개발자입니다.

0개의 댓글