Swift Language
Tekenreeksen en tekens

Syntaxis

• String.characters // Retourneert een array van de tekens in de string
• String.characters.count // Retourneert het aantal tekens
• String.utf8 // A String.UTF8View, retourneert de UTF-8-tekenpunten in de String
• String.utf16 // A String.UTF16View, retourneert de UTF-16-tekenpunten in de String
• String.unicodeScalars // A String.UnicodeScalarView, retourneert de UTF-32-tekenpunten in de tekenreeks
• String.isEmpty // Retourneert true als de tekenreeks geen tekst bevat
• String.hasPrefix (String) // Retourneert true als de String wordt voorafgegaan door het argument
• String.hasSuffix (String) // Retourneert true als de String wordt gevolgd door het argument
• String.startIndex // Retourneert de Index die overeenkomt met het eerste teken in de tekenreeks
• String.endIndex // Retourneert de Index die overeenkomt met de vlek na het laatste teken in de tekenreeks
• String.components (separateBy: String) // Retourneert een array met de substrings gescheiden door de opgegeven scheidingstekenreeks
• String.append (Character) // Voegt het karakter (gegeven als argument) toe aan de String

Opmerkingen

String- en lettertekens

String literals in Swift worden gescheiden door dubbele aanhalingstekens ( " ):

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

Tekens kunnen worden geïnitialiseerd vanuit stringliterals, zolang het letterlijke maar één grapheme-cluster bevat:

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

Stringinterpolatie

Stringinterpolatie maakt het mogelijk om een uitdrukking rechtstreeks in een letterlijke string te injecteren. Dit kan met alle soorten waarden, inclusief tekenreeksen, gehele getallen, getallen met drijvende komma en meer.

De syntaxis is een backslash gevolgd door haakjes met de waarde: \(value) . Elke geldige uitdrukking kan tussen haakjes worden weergegeven, inclusief functieaanroepen.

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.

Voor aangepaste typen is het standaardgedrag van stringinterpolatie dat "\(myobj)" gelijk is aan String(myobj) , dezelfde weergave die wordt gebruikt door print(myobj) . U kunt dit gedrag aanpassen door het CustomStringConvertible protocol voor uw type te implementeren.

Speciale tekens

Bepaalde tekens vereisen een speciale escape-reeks om ze in stringliterals te gebruiken:

Voorbeeld:

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

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

Tekenreeksen samenvoegen

Combineer strings met de operator + om een nieuwe string te produceren:

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

Voeg een mutable string toe met behulp van de += samengestelde toewijzingsoperator of gebruik een methode:

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"

Voeg een enkel karakter toe aan een veranderlijke string:

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

Voeg meerdere tekens toe aan een veranderlijke tekenreeks

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

Voeg een reeks strings samen om een nieuwe string te vormen met joinWithSeparator(_:) :

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

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

Onderzoek en vergelijk strings

Controleer of een string leeg is:

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

Controleer of twee strings gelijk zijn (in de zin van canonieke equivalentie van 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

Controleer of een string begint / eindigt met een andere string:

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

Stringcodering en ontleding

Een Swift- reeks bestaat uit Unicode- codepunten. Het kan op verschillende manieren worden ontleed en gecodeerd.

let str = "ที่👌①!"

Strings ontbindend

De characters een string zijn Unicode extended grapheme clusters :

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

De unicodeScalars zijn de Unicode- codepunten waaruit een string bestaat (merk op dat ที่ één grapheme cluster is, maar 3 codepunten - 3607, 3637, 3656 - dus de lengte van de resulterende array is niet hetzelfde als bij characters ):

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

U kunt strings coderen en ontleden als UTF-8 (een reeks van UInt8 s) of UTF-16 (een reeks van UInt16 s):

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]

Stringlengte en herhaling

De characters een string, unicodeScalars , utf8 en utf16 zijn allemaal Collection- s, dus je kunt hun count en ze herhalen:

// 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 { // ...

Unicode

Waarden instellen

Unicode rechtstreeks gebruiken

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

Hexadecimale waarden gebruiken

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

Merk op dat de Swift Character kan worden samengesteld uit meerdere Unicode-code punten, maar lijkt een enkel teken zijn. Dit wordt een Extended Grapheme Cluster genoemd.

conversies

String -> Hex

// 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‼🐱

Merk op dat voor UTF-8 en UTF-16 de conversie niet altijd zo eenvoudig is omdat dingen zoals emoji niet kunnen worden gecodeerd met een enkele UTF-16-waarde. Er is een surrogaatpaar voor nodig.

Omkerende snaren

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)

Hoofdletters en kleine letters

Alle tekens in een tekenreeks in hoofdletters of kleine letters maken:

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"

Controleer of String tekens uit een gedefinieerde set bevat

Brieven

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")
}

De nieuwe CharacterSet structuur die ook is NSCharacterSet aan de Objective-C NSCharacterSet klasse definieert verschillende vooraf gedefinieerde sets als:

• decimalDigits
• capitalizedLetters
• alphanumerics
• controlCharacters
• illegalCharacters
• en meer die u kunt vinden in de referentie NSCharacterSet .

U kunt ook uw eigen tekenset definiëren:

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")
}

U kunt ook bereik opnemen:

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")
}

Tel exemplaren van een teken in een tekenreeks

Gegeven een String en een Character

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

We kunnen het aantal keren dat de telling van de Character verschijnt in de String met behulp van

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

Verwijder tekens uit een tekenreeks die niet is gedefinieerd in Set

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)

Tekenreeksen opmaken

Toonaangevende nullen

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

Getallen achter de komma

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

Decimaal tot hexadecimaal

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

Als alternatief kan men gespecialiseerde initialisatie gebruiken die hetzelfde doet:

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

Decimaal naar een getal met willekeurige radix

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

Radix is Int in [2, 36] .

Swift-tekenreeks naar een getaltype omzetten

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

Houd er rekening mee dat dit een Optional waarde retourneert, die dienovereenkomstig moet worden uitgepakt voordat deze wordt gebruikt.

String Iteratie

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)
}

En als u bijvoorbeeld de andere kant op wilt:

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
    }
}

Opmerking, Index is een objecttype en geen Int . U hebt als volgt geen toegang tot een tekenreeks:

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

Maar u kunt als volgt een specifieke index krijgen:

index = string.startIndex.advanceBy(2)

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

En kan zo achteruit gaan:

index = string.endIndex.advancedBy(-2)

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

Als u de grenzen van de tekenreeks overschrijdt of als u een limiet wilt opgeven die u kunt gebruiken:

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

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

Als alternatief kan men gewoon door de karakters in een string bladeren, maar dit kan minder nuttig zijn, afhankelijk van de context:

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

Verwijder leidende en achterlopende WhiteSpace en 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  "

Opmerking: al deze methoden behoren toe aan Foundation . Gebruik import Foundation als Foundation nog niet is geïmporteerd via andere bibliotheken zoals Cocoa of UIKit.

Converteer String naar en van Data / NSData

Om String van en naar Data / NSData te converteren, moeten we deze string coderen met een specifieke codering. De meest bekende is UTF-8 , een 8-bits weergave van Unicode-tekens, geschikt voor verzending of opslag door op ASCII gebaseerde systemen. Hier is een lijst met alle beschikbare String Encodings

String naar Data / NSData

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

let data = string.dataUsingEncoding(NSUTF8StringEncoding)

Data / NSData naar String

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

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

Een string splitsen in een array

In Swift kunt u een string eenvoudig in een array scheiden door deze op een bepaald karakter te plakken:

let startDate = "23:51"

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

let startDate = "23:51"

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

Of wanneer het scheidingsteken niet aanwezig is:

let myText = "MyText"

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

let myText = "MyText"

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