Swift Language
문자열 및 문자

통사론

• String.characters // 문자열에있는 문자 배열을 반환합니다.
• String.characters.count // 문자 수를 반환합니다.
• String.utf8 // String.UTF8View는 문자열에서 UTF-8 문자 점을 반환합니다.
• String.utf16 // String.UTF16View는 String에서 UTF-16 문자 포인트를 반환합니다.
• String.unicodeScalars // String.UnicodeScalarView는 문자열에서 UTF-32 문자 포인트를 반환합니다.
• String.isEmpty // 문자열에 텍스트가 포함되어 있지 않으면 true를 반환합니다.
• String.hasPrefix (String) // 문자열 앞에 인수가 있으면 true를 반환합니다.
• String.hasSuffix (String) // 문자열에 인수가 붙은 경우 true를 반환합니다.
• String.startIndex // 문자열의 첫 번째 문자에 해당하는 인덱스를 반환합니다.
• String.endIndex // 문자열의 마지막 문자 뒤의 자리에 해당하는 인덱스를 반환합니다.
• String.components (separatedBy : String) // 지정된 구분 문자열로 구분 된 부분 문자열을 포함하는 배열을 반환합니다.
• String.append (Character) // 문자열에 인자를 추가합니다.

비고

문자열 및 문자 리터럴

Swift의 문자열 리터럴은 큰 따옴표 ( " )로 구분됩니다.

let greeting = "Hello!"  // greeting's type is String

문자가 문자열 리터럴로 초기화 할 수 있습니다, 한 리터럴은 하나의 자소 클러스터를 포함로 :

let chr: Character = "H" // valid
let chr2: Character = "😊" // valid
let chr3: Character = "abc" // invalid - multiple grapheme clusters

문자열 보간법

문자열 보간법을 사용하면 표현식을 문자열 리터럴에 직접 삽입 할 수 있습니다. 문자열, 정수, 부동 소수점 숫자 등 모든 유형의 값을 사용하여이 작업을 수행 할 수 있습니다.

구문은 백 슬래시 다음에 괄호로 묶여 값 : \(value) 래핑합니다. 유효한 호출은 함수 호출을 포함하여 괄호 안에 나타날 수 있습니다.

let number = 5
let interpolatedNumber = "\(number)"  // string is "5"
let fortyTwo = "\(6 * 7)"             // string is "42"

let example = "This post has \(number) view\(number == 1 ? "" : "s")"
// It will output "This post has 5 views" for the above example.
// If the variable number had the value 1, it would output "This post has 1 view" instead.

사용자 정의 유형의 경우 문자열 보간의 기본 동작 은 "\(myobj)" 이 print(myobj) 와 동일한 표현 인 String(myobj) 과 동일하다는 것입니다. 사용자 유형에 맞게 CustomStringConvertible 프로토콜 을 구현하여이 동작을 사용자 정의 할 수 있습니다.

특수 문자

특정 문자는 문자열 리터럴에서 특수 이스케이프 시퀀스 를 사용해야합니다.

예:

let message = "Then he said, \"I \u{1F496} you!\""

print(message) // Then he said, "I 💖 you!"

문자열 연결

문자열을 + 연산자로 연결하여 새 문자열을 만듭니다.

let name = "John"
let surname = "Appleseed"
let fullName = name + " " + surname  // fullName is "John Appleseed"

+= 복합 대입 연산자 를 사용하거나 메소드를 사용하여 변경 가능한 문자열에 추가 :

let str2 = "there"
var instruction = "look over"
instruction += " " + str2  // instruction is now "look over there"

var instruction = "look over"
instruction.append(" " + str2)  // instruction is now "look over there"

변경 가능한 String에 단일 문자를 추가합니다.

var greeting: String = "Hello"
let exclamationMark: Character = "!"
greeting.append(exclamationMark) 
// produces a modified String (greeting) = "Hello!"

mutable 문자열에 여러 문자 추가

var alphabet:String = "my ABCs: "
alphabet.append(contentsOf: (0x61...0x7A).map(UnicodeScalar.init)
                                         .map(Character.init) )
// produces a modified string (alphabet) = "my ABCs: abcdefghijklmnopqrstuvwxyz"

joinWithSeparator(_:) 사용하여 일련 의 문자열을 결합하여 새 문자열을 joinWithSeparator(_:) .

let words = ["apple", "orange", "banana"]
let str = words.joinWithSeparator(" & ")

print(str)   // "apple & orange & banana"

문자열 검사 및 비교

문자열이 비어 있는지 확인하십시오.

if str.isEmpty {
    // do something if the string is empty
}

// If the string is empty, replace it with a fallback:
let result = str.isEmpty ? "fallback string" : str

두 개의 문자열이 같은지 확인하십시오 ( Unicode 표준과 동일 ).

"abc" == "def"          // false
"abc" == "ABC"          // false
"abc" == "abc"          // true

// "LATIN SMALL LETTER A WITH ACUTE" == "LATIN SMALL LETTER A" + "COMBINING ACUTE ACCENT"
"\u{e1}" == "a\u{301}"  // true

문자열이 다른 문자열로 시작 / 끝나는 지 확인하십시오.

"fortitude".hasPrefix("fort")      // true
"Swift Language".hasSuffix("age")  // true

문자열 인코딩 및 분해

Swift String 은 유니 코드 코드 포인트로 구성됩니다. 여러 가지 방법으로 분해되고 인코딩 될 수 있습니다.

let str = "ที่👌①!"

문자열 분해

문자열의 characters 는 유니 코드 확장 된 제자 클러스터입니다 .

Array(str.characters)  // ["ที่", "👌", "①", "!"]

unicodeScalars 는 문자열을 구성하는 유니 코드 코드 포인트 입니다 ( ที่ 은 하나의 grapheme 클러스터이지만 3 개의 코드 포인트 - 3607, 3637, 3656 - 결과 배열의 길이는 characters 와 같지 않습니다).

str.unicodeScalars.map{ $0.value }  // [3607, 3637, 3656, 128076, 9312, 33]

문자열을 UTF-8 ( UInt8 시퀀스) 또는 UTF-16 ( UInt16 시퀀스)으로 인코딩하고 분해 할 수 있습니다.

Array(str.utf8)   // [224, 184, 151, 224, 184, 181, 224, 185, 136, 240, 159, 145, 140, 226, 145, 160, 33]
Array(str.utf16)  // [3607, 3637, 3656, 55357, 56396, 9312, 33]

문자열 길이 및 반복

문자열의 characters 인 unicodeScalars , utf8 및 utf16 은 모두 Collection 이므로 count 가져 와서 반복 할 수 있습니다.

// NOTE: These operations are NOT necessarily fast/cheap! 

str.characters.count     // 4
str.unicodeScalars.count // 6
str.utf8.count           // 17
str.utf16.count          // 7

for c in str.characters { // ...
for u in str.unicodeScalars { // ...
for byte in str.utf8 { // ...
for byte in str.utf16 { // ...

유니 코드

설정 값

유니 코드 직접 사용

var str: String = "I want to visit 北京, Москва, मुंबई, القاهرة, and 서울시. 😊"
var character: Character = "🌍"

16 진수 값 사용

var str: String = "\u{61}\u{5927}\u{1F34E}\u{3C0}" // a大🍎π
var character: Character = "\u{65}\u{301}" // é = "e" + accent mark

Swift Character 는 여러 유니 코드 코드 포인트로 구성 될 수 있지만 단일 문자로 보입니다. 이것을 Extended Grapheme Cluster라고합니다.

전환 수

문자열 -> 16 진수

// Accesses views of different Unicode encodings of `str`
str.utf8
str.utf16
str.unicodeScalars // UTF-32

Hex -> String

let value0: UInt8 = 0x61
let value1: UInt16 = 0x5927
let value2: UInt32 = 0x1F34E

let string0 = String(UnicodeScalar(value0)) // a
let string1 = String(UnicodeScalar(value1)) // 大
let string2 = String(UnicodeScalar(value2)) // 🍎

// convert hex array to String
let myHexArray = [0x43, 0x61, 0x74, 0x203C, 0x1F431] // an Int array
var myString = ""
for hexValue in myHexArray {
    myString.append(UnicodeScalar(hexValue))
}
print(myString) // Cat‼🐱

UTF-8 및 UTF-16의 경우 이모티콘 같은 것이 단일 UTF-16 값으로 인코딩 될 수 없으므로 변환이 항상 쉽지는 않습니다. 서로 게이트 쌍을 취합니다.

반전 문자열

let aString = "This is a test string."

// first, reverse the String's characters 
let reversedCharacters = aString.characters.reverse()

// then convert back to a String with the String() initializer
let reversedString = String(reversedCharacters)

print(reversedString) // ".gnirts tset a si sihT"

let reversedCharacters = aString.characters.reversed()
let reversedString = String(reversedCharacters)

대문자와 소문자 문자열

String의 모든 문자를 대문자 또는 소문자로 만들려면 :

let text = "AaBbCc"
let uppercase = text.uppercaseString // "AABBCC"
let lowercase = text.lowercaseString // "aabbcc"

let text = "AaBbCc"
let uppercase = text.uppercased() // "AABBCC"
let lowercase = text.lowercased() // "aabbcc"

문자열에 정의 된 집합의 문자가 포함되어 있는지 확인

편지

let letters = CharacterSet.letters

let phrase = "Test case"
let range = phrase.rangeOfCharacter(from: letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
   print("letters not found")
}

let letters = NSCharacterSet.letterCharacterSet()

let phrase = "Test case"
let range = phrase.rangeOfCharacterFromSet(letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
  print("letters not found")
}

Objective-C NSCharacterSet 클래스에도 연결되어있는 새로운 CharacterSet 구조체는 다음과 같이 미리 정의 된 여러 집합을 정의합니다.

• decimalDigits
• capitalizedLetters
• alphanumerics
• controlCharacters
• illegalCharacters
• NSCharacterSet 참조에서 더 많이 찾을 수 있습니다.

또한 자신 만의 문자 세트를 정의 할 수 있습니다.

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive) {
   print("yes") 
}
else {
   print("no")
}

let charset = NSCharacterSet(charactersInString: "t")

if let _ = phrase.rangeOfCharacterFromSet(charset, options: .CaseInsensitiveSearch, range: nil) {
   print("yes")
}
else {
    print("no")
}

범위를 포함 할 수도 있습니다.

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive, range: phrase.startIndex..<phrase.endIndex)) {
   print("yes") 
}
else {
   print("no")
}

문자열에있는 문자의 발생 수 계산

주어진 String 과 Character

let text = "Hello World"
let char: Character = "o"

우리는 Character 가 String 나타나는 횟수를 세 어서 계산할 수 있습니다.

let sensitiveCount = text.characters.filter { $0 == char }.count // case-sensitive
let insensitiveCount = text.lowercaseString.characters.filter { $0 == Character(String(char).lowercaseString) } // case-insensitive

세트에 정의되지 않은 문자열에서 문자 제거

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
   return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text, set: chars) // "SwiftComeOut"

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
  return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text: text, set: chars)

문자열 서식 지정

선행 0

let number: Int = 7
let str1 = String(format: "%03d", number) // 007
let str2 = String(format: "%05d", number) // 00007

10 진수 이후의 숫자

let number: Float = 3.14159
let str1 = String(format: "%.2f", number) // 3.14
let str2 = String(format: "%.4f", number) // 3.1416 (rounded)

십진수를 16 진수로

let number: Int = 13627
let str1 = String(format: "%2X", number) // 353B
let str2 = String(format: "%2x", number) // 353b (notice the lowercase b)

또는 동일한 작업을 수행하는 특별한 초기화 프로그램을 사용할 수도 있습니다.

let number: Int = 13627
let str1 = String(number, radix: 16, uppercase: true) //353B
let str2 = String(number, radix: 16) // 353b

임의의 기수가있는 숫자에 대한 소수

let number: Int = 13627
let str1 = String(number, radix: 36) // aij

기수는 [2, 36] 에서 Int 입니다.

빠른 문자열을 숫자 형식으로 변환

Int("123") // Returns 123 of Int type
Int("abcd") // Returns nil
Int("10") // Returns 10 of Int type
Int("10", radix: 2) // Returns 2 of Int type
Double("1.5") // Returns 1.5 of Double type
Double("abcd") // Returns nil

이 작업을 수행하면 Optional 값이 반환되므로 사용하기 전에 언 래핑 해야합니다.

문자열 반복

let string = "My fantastic string"
var index = string.startIndex

while index != string.endIndex {
    print(string[index])
    index = index.successor()
}

let string = "My fantastic string"
var currentIndex = string.startIndex

while currentIndex != string.endIndex {
    print(string[currentIndex])
    currentIndex = string.index(after: currentIndex)
}

예를 들어, 다른 방향으로 가고 싶다면 :

var index:String.Index? = string.endIndex.predecessor()

while index != nil {
    print(string[index!])
    if index != string.startIndex {
        index = index.predecessor()
    }
    else {
        index = nil
    }
}

var currentIndex: String.Index? = string.index(before: string.endIndex)

while currentIndex != nil {
    print(string[currentIndex!])
    if currentIndex != string.startIndex {
        currentIndex = string.index(before: currentIndex!)
    }
    else {
        currentIndex = nil
    }
}

Index 는 객체 유형이며 Int 아닙니다. 다음과 같이 문자열의 문자에 액세스 할 수 없습니다.

let string = "My string"
string[2] // can't do this
string.characters[2] // and also can't do this

그러나 다음과 같이 특정 색인을 얻을 수 있습니다.

index = string.startIndex.advanceBy(2)

currentIndex = string.index(string.startIndex, offsetBy: 2)

다음과 같이 뒤로 이동할 수 있습니다.

index = string.endIndex.advancedBy(-2)

currentIndex = string.index(string.endIndex, offsetBy: -2)

문자열의 범위를 초과하거나 제한을 지정하려는 경우 다음을 사용할 수 있습니다.

index = string.startIndex.advanceBy(20, limit: string.endIndex)

currentIndex = string.index(string.startIndex, offsetBy: 20, limitedBy: string.endIndex)

다른 방법으로 문자열의 문자를 반복 할 수 있지만 상황에 따라 덜 유용 할 수 있습니다.

for c in string.characters {
    print(c)
}

선행 및 후행 WhiteSpace 및 NewLine 제거

let someString = "  Swift Language  \n"
let trimmedString = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
// "Swift Language"

let trimmedWhiteSpace = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
// "Swift Language  \n"

let trimmedNewLine = someString.stringByTrimmingCharactersInSet(NSCharacterSet.newlineCharacterSet())
// "  Swift Language  "

let someString = "  Swift Language  \n"

let trimmedString = someString.trimmingCharacters(in: .whitespacesAndNewlines)
// "Swift Language"

let trimmedWhiteSpace = someString.trimmingCharacters(in: .whitespaces)
// "Swift Language  \n"

let trimmedNewLine = someString.trimmingCharacters(in: .newlines)
// "  Swift Language  "

참고 :이 모든 방법은 Foundation 속합니다. Foundation이 Cocoa 나 UIKit 같은 다른 라이브러리를 통해 아직 가져 import Foundation 되지 않은 경우 import Foundation 사용하십시오.

문자열을 Data / NSData와 변환

String과 Data / NSData를 변환하려면이 문자열을 특정 인코딩으로 인코딩해야합니다. 가장 유명한 것은 ASCII 기반 시스템에 의한 전송 또는 저장에 적합한 유니 코드 문자의 8 비트 표현 인 UTF-8 입니다. 다음은 사용 가능한 모든 String Encodings 목록입니다.

String to Data / NSData

let data = string.data(using: .utf8)

let data = string.dataUsingEncoding(NSUTF8StringEncoding)

String Data / NSData

let string = String(data: data, encoding: .utf8)

let string = String(data: data, encoding: NSUTF8StringEncoding)

문자열을 배열로 분할하기

Swift에서는 문자열을 특정 문자로 분리하여 문자열을 배열로 쉽게 분리 할 수 ​​있습니다.

let startDate = "23:51"

let startDateAsArray = startDate.components(separatedBy: ":") // ["23", "51"]`

let startDate = "23:51"

let startArray = startDate.componentsSeparatedByString(":") // ["23", "51"]`

또는 구분 기호가 없을 때 :

let myText = "MyText"

let myTextArray = myText.components(separatedBy: " ") // myTextArray is ["MyText"]

let myText = "MyText"

let myTextArray = myText.componentsSeparatedByString(" ") // myTextArray is ["MyText"]