Основы Swift / 6.5. Строки и символы 2 - Взаимодействие со строками и символами


Видео


Мутабельность строк
Вы указываете, что конкретная строка может быть изменена (или мутирована) присвоив её переменной (в том случае, если она может быть модифицирована) или константе (в том случае, если она не может быть изменена):
@{6.5\1}
var variableString = "Лошадь"
variableString += " и морковка"

let constantString = "Возвышенность"
constantString += " и ещё одна Возвышенность"
//Это приведёт к ошибке времени компиляции - константная строка не может быть модифицирована
                
О Cocoa
Этот подход отличается от строковой мутабельности в Objective-C и Cocoa, где Вы выбираете между двумя классами (NSString и NSMutableString) для определения того, может ли строка быть изменена.
Строки как типы-по-значению
Строка в Swift - это тип-значение. Если Вы создадите новое значение типа String, то оно будет скопировано при использовании. Будет создана новая копия существующего значения типа String, и именно она будет передана или присвоена.

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

За кулисами компилятор Swift оптимизирует использование строк так, что на самом деле копирование произойдёт только в случае абсолютной необходимости. Это значит, что Вы всегда получаете высокую производительность при работе со строками в качестве типов-значений.
Работа с символами
Вы можете получить доступ к отдельным значениям Character для String, пройдя сквозь строку с помощью цикла for-in:
@{6.5\2}
for character in "Пёс!🐶" {
    print(character)
}
// П
// ё
// с
// !
// 🐶
В этом примере мы обходим строку "Пёс!🐶" и выводим все её символы по одному.
Создание отдельного символа
Вы можете создать отдельную константу или переменную типа Character из односимвольного строкового литерала, предоставив аннотацию типа Character:
@{6.5\3}
let exclamationMark: Character = "!"
В данном примере мы создаём символ восклицательного знака.
Создание строковых значений из символов
Строковые значения могут быть получены путём передачи массива значений типа Character в качестве аргумента конструктора:
@{6.5\4}
let catCharacters: [Character] = ["К", "о", "т", "!", "🐱"]
let catString = String(catCharacters)
print(catString)
// Печатает "Кот!🐱"
Здесь мы создаём массив символов, из которых мы создаём строку "Кот!🐱".
Конкатенация строк и символов
Значения типа String могут быть сложены вместе (или сконкатенированы) с помощью оператора сложения (+) для создания нового строкового значения:
@{6.5\5}
let string1 = "Здравия"
let string2 = " желаю"
var welcome = string1 + string2
// welcome теперь равен "Здравия желаю"
В этом же примере мы создаём две строки с фразами "Здравия" и " желаю" и складываем их в единое приветствие welcome.
Составной оператор сложения/присваивания
Вы также можете добавить значение типа String к существующей строковой переменной с помощью оператора сложения/присваивания (+=):
@{6.5\6}
let string2 = " внимательно"
var instruction = "смотрите здесь"
instruction += string2
//instruction теперь равна "смотрите здесь внимательно"
Мы складываем в этом примере строки по аналогии с прошлым, однако мы делаем это с помощью оператора (+=).
Добавление символа в строку
Вы можете добавить значение типа Character в строковую переменную с помощью метода append() типа String:
@{6.5\7}
var welcome = "Здравия желаю"
let exclamationMark: Character = "!"
welcome.append(exclamationMark)
// welcome теперь равен "Здравия желаю!"
В текущем примере мы прибавляет символ восклицательного знака к строке приветствия, которую мы уже видели ранее.

Вы не можете добавить значения типа String или Character существующей переменной типа Character, так как символьная величина должна содержать лишь один символ.
Строковая интерполяция
Строковая интерполяция - это способ создать новое значение типа String из смеси констант, переменных, литералов и выражения, путём включения их значений внутрь строкового литерала. Вы можете использовать строковую интерполяцию и в однострочных и многострунных строковых литералах. Каждый элемент, который Вы хотите вставить в строковый литерал, Вы оборачиваете в пару круглых скобок, предваряемых обратным слэшем (\):
@{6.5\8}
let multiplier = 3
let message = "\(multiplier) умножить на 2.5 равно \(Double(multiplier) * 2.5)"
// message равно "3 умножить на 2.5 равно 7.5"
В примере значение multiplier вставляется внутрь строкового литерала с помощью \(multiplier). Этот плейсхолдер заменяется настоящим значением multiplier, когда вычисляется строковая интерполяция для получения итоговой строки.

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