Swift язык программирования: строки и символы

Строка является упорядоченным набором символов, такой как "hello, world" или "albatross". Строки Swift представлены String введите, который поочередно представляет набор значений Character ввести.

Swift String и Character типы обеспечивают быстрый, совместимый Unicode способ работать с текстом в Вашем коде. Синтаксис для строкового создания и манипулирования легок и читаем с синтаксисом строкового литерала, который подобен C. Конкатенация строк так же проста как добавляющий вместе две строки с + оператором и строковой переменчивостью управляют путем выбора между константой или переменной, точно так же, как любое другое значение в Swift.

Несмотря на эту простоту синтаксиса, Swift String тип является быстрой, современной строковой реализацией. Каждая строка составлена из независимых от кодирования символов Unicode и предоставляет поддержку для доступа к тем символам в различных представлениях Unicode.

Можно также использовать строки для вставки констант, переменных, литералов и выражений в более длинные строки, в процессе, известном как строковая интерполяция. Это упрощает создавать ценности пользовательской строки для дисплея, хранения и печати.

Примечание:

Swift String тип соединяется мостом с Основой NSString класс. Если Вы работаете с платформой Основы в Какао, всем NSString API доступен для обращения к любому String ценность, которую Вы создаете, когда тип бросал к NSString, как описано в AnyObject. Можно также использовать a String значение с любым API, требующим NSString экземпляр.

Для получения дополнительной информации об использовании String с Основой и Какао, посмотрите Используя Swift с Какао и Objective C.

Строковые литералы

Можно включать предопределенный String значения в Вашем коде как строковые литералы. Строковый литерал является фиксированной последовательностью текстовых символов, окруженных парой двойных кавычек ("").

Используйте строковый литерал в качестве начального значения для константы или переменный:

      let someString = "Some string literal value"

Обратите внимание на то, что Swift выводит тип String для someString постоянный, потому что это инициализируется со значением строкового литерала.

Инициализация пустой строки

Создать пустое String оцените как начальная точка за создание более длинной строки, или присвойте литерал пустой строки переменной или инициализируйте новое String экземпляр с синтаксисом инициализатора:

      var emptyString = ""               // empty string literal
var anotherEmptyString = String()  // initializer syntax
// these two strings are both empty, and are equivalent to each other

Узнайте ли a String значение пусто путем проверки его булевской переменной isEmpty свойство:

      if emptyString.isEmpty {
    println("Nothing to see here")
}
// prints "Nothing to see here"

Строковая переменчивость

Вы указываете ли деталь String может быть изменен (или видоизменен) путем присвоения его переменной (когда это может быть изменено), или к константе (когда это не может быть изменено):

      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

Строки являются типами значения

Swift String тип является типом значения. Если Вы создаете новое String значение, это String значение копируется, когда оно передается функции или методу, или когда оно присваивается константе или переменное. В каждом случае, новой копии существующего String ценность создана, и новая копия передается или присваивается, не исходная версия. Типы значения описаны в Структурах, и Перечисления Являются Типами Значения.

Копия по умолчанию Swift String когда функция или метод передают Вас a, поведение гарантирует это String значение, ясно, что Вам принадлежит это точное String значение, независимо от того, куда это прибыло из. Можно быть уверены, что строка, Вы передаетесь, не будет изменена, если Вы не измените ее сами.

Негласно, компилятор Swift оптимизирует строковое использование так, чтобы фактическое копирование имело место только при необходимости. Это означает, что Вы всегда получаете высокую эффективность при работе со строками как типы значения.

Работа с символами

Swift String тип представляет набор Character значения в указанном порядке. Можно получить доступ к частному лицу Character значения в строке путем итерации по той строке с a for-in цикл:

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




  

for-in цикл описан в Для Циклов.

Также создайте автономное Character постоянный или переменный от односимвольного строкового литерала путем обеспечения a Character аннотация типа:

      let exclamationMark: Character = "!"

String значения могут быть созданы путем передачи массива Character значения как параметр его инициализатору:

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

Конкатенация строк и символов

String значения могут быть добавлены вместе (или связаны) с оператором сложения (+) создать новое String значение:

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

Можно также добавить a String оцените существующему String переменная с дополнительным оператором присваивания (+=):

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

Можно добавить a Character оцените a String переменная с String тип append() метод:

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

Строковая интерполяция

Строковая интерполяция является способом создать новое String значение от соединения констант, переменных, литералов и выражений включением их значений в строковом литерале. Каждый элемент, который Вы вставляете в строковый литерал, обертывается в пару круглых скобок, снабженных префиксом наклонной чертой влево:

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

В примере выше, значение multiplier вставляется в строковый литерал как \(multiplier). Этот заполнитель заменяется фактическим значением multiplier когда строковая интерполяция оценена для создания фактической строки.

Значение multiplier также часть большего выражения позже в строке. Это выражение вычисляет значение Double(multiplier) * 2.5 и вставляет результат (7.5) в строку. В этом случае выражение записано как \(Double(multiplier) * 2.5) когда это включено в строковом литерале.

Unicode

Unicode является международным стандартом для кодирования, представления и обработки текста в различных системах письменности. Это позволяет Вам представлять почти любой символ с любого языка в стандартизированной форме, и считать и записать те символы в и из внешнего источника, такие как текстовый файл или веб-страница. Swift String и Character типы полностью совместимы Unicode, как описано в этом разделе.

Скаляры Unicode

Негласно, собственный компонент Swift String тип создается из скалярных значений Unicode. Скаляр Unicode является уникальным 21-разрядным числом для символа или модификатора, такой как U+0061 для LATIN SMALL LETTER A ("a"), или U+1F425 для FRONT-FACING BABY CHICK (" ").

Обратите внимание на то, что не все 21-разрядные скаляры Unicode присваиваются символу — некоторые скаляры резервируются для будущего присвоения. Скаляры, присвоенные символу обычно также, имеют имя, такой как LATIN SMALL LETTER A и FRONT-FACING BABY CHICK в примерах выше.

Специальные символы в строковых литералах

Строковые литералы могут включать следующие специальные символы:

Завершенные специальные символы \0 (нулевой символ), \\ (наклонная черта влево), \t (горизонтальная вкладка), \n (перевод строки), \r (возврат каретки), \" (двойная кавычка) и \' (одинарная кавычка)
Произвольный скаляр Unicode, записанный как \u{n}, где n является цифрой 1–8 шестнадцатеричное число со значением, равным допустимой кодовой точке Unicode

Код ниже шоу четыре примера этих специальных символов. wiseWords постоянный содержит два завершенных символа двойной кавычки. dollarSign, blackHeart, и sparklingHeart константы демонстрируют формат скаляра Unicode:

      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

Расширенные кластеры графемы

Каждый экземпляр Swift Character тип представляет единственный расширенный кластер графемы. Расширенный кластер графемы является последовательностью одного или более скаляров Unicode, (когда объединено) производящих единственный человекочитаемый символ.

Вот пример. Буква é может быть представлен как единственный скаляр Unicode é (LATIN SMALL LETTER E WITH ACUTE, или U+00E9). Однако та же буква может также быть представлена как пара скаляров — типовое письмо e (LATIN SMALL LETTER E, или U+0065), сопровождаемый COMBINING ACUTE ACCENT скаляр (U+0301). COMBINING ACUTE ACCENT скаляр графически применяется к скаляру, предшествующему ему, поворачиваясь e в é когда это представляется осведомленной о Unicode представляющей текст системой.

В обоих случаях, буква é представлен как единственный Swift Character значение, представляющее расширенный кластер графемы. В первом случае кластер содержит единственный скаляр; во втором случае это - кластер двух скаляров:

      let eAcute: Character = "\u{E9}"                         // é
let combinedEAcute: Character = "\u{65}\u{301}"          // e followed by ́
// eAcute is é, combinedEAcute is é

Расширенные кластеры графемы являются гибким способом представлять много сложных символов сценария как сингл Character значение. Например, слоги Хангула от корейского алфавита могут быть представлены или как предсоставленная или как анализируемая последовательность. Оба из этих представлений квалифицируют как сингл Character значение в Swift:

      let precomposed: Character = "\u{D55C}"                  // 한
let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
// precomposed is 한, decomposed is 한

Расширенные кластеры графемы включают скаляры для включения меток (такой как COMBINING ENCLOSING CIRCLE, или U+20DD) включить другие скаляры Unicode как часть сингла Character значение:

      let enclosedEAcute: Character = "\u{E9}\u{20DD}"
// enclosedEAcute is é⃝

Скаляры Unicode для региональных символов индикатора могут быть объединены в парах для создания сингла Character значение, такое как эта комбинация REGIONAL INDICATOR SYMBOL LETTER U (U+1F1FA) и REGIONAL INDICATOR SYMBOL LETTER S (U+1F1F8):

      let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
// regionalIndicatorForUS is

Подсчет символов

Получать количество Character значения в строке, вызовите глобальную переменную count(_:) функция и передача в строке как единственный параметр функции:

      let unusualMenagerie = "Koala  , Snail  , Penguin  , Dromedary  "
println("unusualMenagerie has \(count(unusualMenagerie)) characters")
// prints "unusualMenagerie has 40 characters"

Обратите внимание на то, что использование Swift расширенных кластеров графемы для Character значения означают, что конкатенация строк и модификация могут не всегда влиять на счетчик символов строки.

Например, если Вы инициализируете новую строку со словом с четырьмя символами cafe, и затем добавьте a COMBINING ACUTE ACCENT (U+0301) до конца строки, получившая строка будет все еще иметь счетчик символов 4, с четвертым символом é, нет e:

      var word = "cafe"
println("the number of characters in \(word) is \(count(word))")
// prints "the number of characters in cafe is 4"
 
word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
 
println("the number of characters in \(word) is \(count(word))")
// prints "the number of characters in café is 4"

Примечание:

Расширенные кластеры графемы могут быть составлены из одного или более скаляров Unicode. Это означает, что различные символы — и различные представления того же символа — могут потребовать, чтобы различные объемы памяти сохранили. Из-за этого символы в Swift каждый не приводят тот же объем памяти в рабочее состояние в представлении строки. В результате число символов в строке не может быть вычислено, не выполняя итерации через строку для определения ее расширенных границ кластера графемы. Если Вы работаете со значениями особенно длинной строки, знают что count(_:) функция должна выполнить итерации по скалярам Unicode во всей строке для вычисления точного счетчика символов для той строки.

Счетчик символов, возвращенный count(_:) функция является не всегда тем же как length свойство NSString это содержит те же символы. Длина NSString основывается на числе 16-разрядных элементов кода в представлении строки UTF-16, а не число Unicode расширил кластеры графемы в строке. Отразить этот факт, length свойство от NSString вызывается utf16Count когда к этому получают доступ на Swift String значение.

Доступ и изменение строки

Вы получаете доступ и изменяете строку через ее методы и свойства, или при помощи нижнего синтаксиса.

Индексы строк

Каждый String значение имеет связанный индексный тип, String.Index, который соответствует позициям каждого Character это содержит.

Как упомянуто выше, различные символы могут потребовать, чтобы различные объемы памяти сохранили, поэтому для определения который Character в определенной позиции, необходимо выполнить итерации по каждому скаляру Unicode от запуска или конца этого String. Поэтому строки Swift не могут быть индексированы целочисленными значениями.

Используйте startIndex свойство для доступа к позиции первого Character из a String, и endIndex свойство для доступа к позиции последнего. Если String пусто, startIndex и endIndex равны.

      let greeting = "Guten Tag"
// prints "greeting: String = "Guten Tag""
println(greeting.startIndex)
// 0
println(greeting.endIndex)
// 9

Можно использовать нижний синтаксис для доступа Character в детали String индекс:

      greeting[greeting.startIndex]
// G

A String.Index значение может получить доступ к своему сразу предыдущему индексу путем вызова predecessor() метод и его сразу последующий индекс путем вызова successor() метод. Любой индекс в a String может быть получен доступ от любого другого индекса путем объединения в цепочку этих методов вместе, или при помощи глобальной переменной advance(start:n:) функция. Попытка получить доступ к индексу за пределами диапазона строки инициирует ошибку периода выполнения.

      greeting[greeting.startIndex.successor()]
// u
greeting[greeting.endIndex.predecessor()]
// g
let index = advance(greeting.startIndex, 7)
greeting[index]
// a
greeting.endIndex.successor() // fatal error: can not increment endIndex




  

Используйте глобальную функцию indicies(_:) создать a Range изо всех индексов, используемых для доступа к отдельным символам в строке.

      for index in indices(greeting) {
    print("\(greeting[index]) ")
}
println("\n")
// prints "G u t e n   T a g"

Вставка и удаление

Для вставки символа в строку в указанном индексе используйте insert(_:atIndex:) метод.

      var welcome = "hello"
welcome.insert("!", atIndex: welcome.endIndex)
println(welcome)
// prints "hello!"

Для вставки другой строки в указанном индексе используйте splice(_:atIndex:) метод.

      welcome.splice(" there", atIndex: welcome.endIndex.predecessor())
println(welcome)
// prints "hello there!"

Для удаления символа из строки в указанном индексе используйте removeAtIndex(_:) метод.

      welcome.removeAtIndex(welcome.endIndex.predecessor())
// !
println(welcome)
// prints "hello there"

Для удаления подстроки в указанном диапазоне используйте removeRange(_:) метод:

      let range = advance(welcome.endIndex, -6)..<welcome.endIndex
welcome.removeRange(range)
println(welcome)
// prints "hello"

Сравнение строк

Swift обеспечивает три способа сравнить текстовые значения: строка и символьное равенство, снабдите префиксом равенство и суффиксное равенство.

Строка и символьное равенство

Со строкой и символьным равенством сверяются “равный” оператору (==) и “не равняются” оператору (!=), как описано в Операторах сравнения:

      let quotation = "We're a lot alike, you and I."
let sameQuotation = "We're a lot alike, you and I."
if quotation == sameQuotation {
    println("These two strings are considered equal")
}
// prints "These two strings are considered equal"

Два String значения (или два Character значения), считаются равными, если их расширенные кластеры графемы канонически эквивалентны. Расширенные кластеры графемы канонически эквивалентны, если у них есть то же лингвистическое значение и появление, даже если они составлены из различных скаляров Unicode негласно.

Например, LATIN SMALL LETTER E WITH ACUTE (U+00E9) канонически эквивалентно LATIN SMALL LETTER E (U+0065) сопровождаемый COMBINING ACUTE ACCENT (U+0301). Оба из этих расширенных кластеров графемы являются допустимыми способами представлять символ é, и таким образом, они считаются канонически эквивалентными:

      // "Voulez-vous un café?" using LATIN SMALL LETTER E WITH ACUTE
let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
 
// "Voulez-vous un café?" using LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"
 
if eAcuteQuestion == combinedEAcuteQuestion {
    println("These two strings are considered equal")
}
// prints "These two strings are considered equal"

С другой стороны, LATIN CAPITAL LETTER A (U+0041, или "A"), как используется на английском языке, не эквивалентно CYRILLIC CAPITAL LETTER A (U+0410, или "А"), как используется на русском языке. Символы визуально подобны, но не имеют того же лингвистического значения:

      let latinCapitalLetterA: Character = "\u{41}"
 
let cyrillicCapitalLetterA: Character = "\u{0410}"
 
if latinCapitalLetterA != cyrillicCapitalLetterA {
    println("These two characters are not equivalent")
}
// prints "These two characters are not equivalent"

Префиксное и суффиксное равенство

Чтобы проверить, имеет ли строка определенный строковый префикс или суффикс, вызовите строку 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"
]




  

Можно использовать hasPrefix(_:) метод с romeoAndJuliet выстройте для подсчета числа сцен в законе 1 игры:

      var act1SceneCount = 0
for scene in romeoAndJuliet {
    if scene.hasPrefix("Act 1 ") {
        ++act1SceneCount
    }
}
println("There are \(act1SceneCount) scenes in Act 1")
// prints "There are 5 scenes in Act 1"




  

Точно так же используйте hasSuffix(_:) метод для подсчета числа сцен, имеющих место в или вокруг особняка Кэпулета и ячейки Монаха Лоуренса:

      var mansionCount = 0
var cellCount = 0
for scene in romeoAndJuliet {
    if scene.hasSuffix("Capulet's mansion") {
        ++mansionCount
    } else if scene.hasSuffix("Friar Lawrence's cell") {
        ++cellCount
    }
}
println("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
// prints "6 mansion scenes; 2 cell scenes"




  

Представления Unicode строк

Когда строка Unicode записана в текстовый файл или некоторое другое хранение, скаляры Unicode в той строке кодируются в одной из нескольких определенных с помощью Unicode форм кодирования. Каждая форма кодирует строку в маленьких блоках, известных как элементы кода. Они включают UTF-8, кодирующий форму (который кодирует строку 8-разрядными элементами кода), UTF-16, кодирующий форму (который кодирует строку 16-разрядными элементами кода), и UTF-32, кодирующий форму (который кодирует строку 32-разрядными элементами кода).

Swift обеспечивает несколько различных способов получить доступ к представлениям Unicode строк. Можно выполнить итерации по строке с a for-in оператор, для доступа к его частному лицу Character значения как Unicode расширили кластеры графемы. Этот процесс описан в Работе с Символами.

Также доступ a String значение в одном из трех других совместимых Unicode представлений:

Набор элементов кода UTF-8 (получил доступ со строкой utf8 свойство)
Набор элементов кода UTF-16 (получил доступ со строкой utf16 свойство)
Набор 21-разрядных скалярных значений Unicode, эквивалентных UTF-32 строки, кодирующему форму (получил доступ со строкой unicodeScalars свойство)

Каждый пример ниже шоу различное представление следующей строки, составленной из символов D, o, g, ‼ (DOUBLE EXCLAMATION MARK, или скаляр Unicode U+203C), и символ (DOG FACE, или скаляр Unicode U+1F436):

      let dogString = "Dog‼ "

Представление UTF-8

Можно получить доступ к представлению UTF-8 a String путем итерации по utf8 свойство. Это свойство имеет тип String.UTF8View, который является набором 8-разрядных без знака (UInt8) значения, один для каждого байта в представлении строки UTF-8:

      for codeUnit in dogString.utf8 {
    print("\(codeUnit) ")
}
print("\n")
// 68 111 103 226 128 188 240 159 144 182

В примере выше, первые три десятичных числа codeUnit значения (68, 111, 103) представляйте символы D, o, и g, чье представление UTF-8 совпадает с их представлением ASCII. Следующие три десятичных числа codeUnit значения (226, 128, 188) трехбайтовое представление UTF-8 DOUBLE EXCLAMATION MARK символ. Последние четыре codeUnit значения (240, 159, 144, 182) четырехбайтовое представление UTF-8 DOG FACE символ.

Представление UTF-16

Можно получить доступ к представлению UTF-16 a String путем итерации по utf16 свойство. Это свойство имеет тип String.UTF16View, который является набором 16-разрядных без знака (UInt16) значения, один для каждого 16-разрядного элемента кода в представлении строки UTF-16:

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

Снова, первые три codeUnit значения (68, 111, 103) представляйте символы D, o, и g, чьи элементы кода UTF-16 имеют те же значения как в представлении строки UTF-8 (потому что эти скаляры Unicode представляют символы ASCII).

Четвертое codeUnit значение (8252) десятичный эквивалент шестнадцатеричного значения 203C, который представляет скаляр Unicode U+203C для DOUBLE EXCLAMATION MARK символ. Этот символ может быть представлен как единственный элемент кода в UTF-16.

Пятое и шестое codeUnit значения (55357 и 56374) представление суррогатной пары UTF-16 DOG FACE символ. Эти значения являются высоко-суррогатным значением U+D83D (десятичное значение 55357) и значение низкого заместителя U+DC36 (десятичное значение 56374).

Представление скаляра Unicode

Можно получить доступ к представлению скаляра Unicode a String значение путем итерации по unicodeScalars свойство. Это свойство имеет тип UnicodeScalarView, который является набором значений типа UnicodeScalar.

Каждый UnicodeScalar имеет a value свойство, возвращающее 21-разрядное значение скаляра, представленное в a UInt32 значение:

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

value свойства для первых трех UnicodeScalar значения (68, 111, 103) еще раз представляйте символы D, o, и g.

Четвертое codeUnit значение (8252) снова десятичный эквивалент шестнадцатеричного значения 203C, который представляет скаляр Unicode U+203C для DOUBLE EXCLAMATION MARK символ.

value свойство пятого и заключительного UnicodeScalar, 128054, десятичный эквивалент шестнадцатеричного значения 1F436, который представляет скаляр Unicode U+1F436 для DOG FACE символ.

Как альтернатива запросам их value свойства, каждый UnicodeScalar значение может также использоваться для построения нового String значение, такой как со строковой интерполяцией:

      for scalar in dogString.unicodeScalars {
    println("\(scalar) ")
}
// D
// o
// g
// ‼
//  




  