Создание приложений и программирование в целом - это работа с данными.
Как разработчик, вы должны понимать, как обрабатывать и хранить данные, используя четко определенные типы.
В этом уроке вы узнаете, как константы и переменные позволяют называть фрагменты данных, чтобы их можно было использовать позже в вашей программе. Вы научитесь определять константы для значений, которые не изменяются, и определять переменные для значений, которые изменяются.
Вы также узнаете о типах, которые похожи на шаблоны для работы с данными. Различные типы могут использоваться и храниться в константах или переменных. Вы узнаете, какие типы включены в Swift и как типы Swift могут помочь вам писать лучший код.
Чему Ты Научишься
- Как представлять числа, строки и логические значения с использованием собственных типов данных Swift
- Когда использовать константу, а когда использовать переменную
- Как присваивать значения константам и переменным
- Как вывод типов помогает вам писать чистый код
- Как безопасность типов помогает вам писать безопасный код
Терминология
Связанные ресурсы
Константы и переменные связывают имя (например, age или name) со значением определенного типа (например, число 29 или строка “John”). Затем вы можете использовать это имя для многократной ссылки на это значение в вашей программе. Как только оно установлено, значение константы становится неизменным, что означает, что оно не может быть изменено. Напротив, значение переменной является изменяемым, что означает, что оно может быть изменено в любое время.
Определяя константу или переменную, вы просите компилятор выделить место для значения в памяти устройства, на котором будет выполняться программа. Вы также просите его связать имя константы или переменной с присвоенным значением, чтобы вы могли получить доступ к этому значению позже.
Константы
Если вы хотите присвоить значение, которое не изменится в течение срока службы программы, вы будете использовать константу.
Вы определяете константы в Swift с помощью ключевого слова let.
let name = “John”
Приведенный выше код создает новую константу с именем name и присваивает константе значение “John”. Если вы хотите получить доступ к этому значению в последующих строках кода, вы можете использовать name для прямой ссылки на константу. Эта краткая ссылка особенно полезна, когда у вас есть одно значение, которое вы используете много раз в программе.
let name = “John”
print(name)
Этот код выведет “John” на консоль.
Поскольку name является константой, вы не можете присвоить ему новое значение после его присвоения. Например, следующий код не будет выполняться:
let name = “John”
name = “James”
Переменные
Если вы хотите присвоить значение, которое может измениться в течение срока службы приложения, вы будете использовать переменную.
Переменные определяются с помощью ключевого слова var.
var age = 29
print(age)
Приведенный выше код выведет 29 на консоль.
Поскольку age является переменной, вы можете присвоить новое значение в последующих строках кода. Следующий код компилируется без ошибок.
var age = 29
age = 30
print(age)
Этот код выведет 30 на консоль.
Вы можете назначать константы и переменные из других констант и переменных. Эта функция полезна, когда вы хотите скопировать значение в одну или несколько других переменных.
let defaultScore = 100
var playerOneScore = defaultScore
var playerTwoScore = defaultScore
print(playerOneScore)
print(playerTwoScore)
playerOneScore = 200
print(playerOneScore)
Console Output:
100
100
200
Константа или Переменная?
Вы только что научились использовать константу, когда значение не изменится, и переменную, когда значение может измениться.
Но здесь есть один нюанс, который стоит изучить. Несмотря на то, что определенные значения могут быть переменными, вы можете представить их с помощью константы, потому что они не изменятся в течение всего срока службы одного выполнения кода.
Представьте, что вы вычисляете информацию о расстоянии, пройденном в поездке. Программу можно использовать повторно для отслеживания многих поездок с течением времени, но она отслеживает одну поездку за раз. Как бы вы представили следующие данные в своем коде?
- Начальное местоположение — это GPS-координаты того места, где вы начали свое путешествие. Как только вы начнете отслеживать поездку в своей программе, местоположение не изменится. Вы будете представлять это значение с помощью константы.
- Пункт назначения — Эта GPS-координата указывает, куда вы хотите прибыть. Ваше приложение может использоваться для многих направлений, поэтому вы можете подумать, что это будет представлено переменной. Но как только ваша программа начнет отслеживать поездку, пункт назначения не изменится. Вы будете представлять это значение с помощью константы.
- Текущее местоположение — GPS-координаты вашего текущего местоположения будут меняться всякий раз, когда вы перемещаетесь. Таким образом, вы будете представлять это значение с помощью переменной.
- Пройденное расстояние — Как далеко вы продвинулись от своей отправной точки? Это значение меняется по мере перемещения. Вы представите его с помощью другой переменной.
- Оставшееся расстояние — Как далеко вы должны проехать, чтобы прибыть в пункт назначения? Оставшееся расстояние меняется по мере вашего перемещения. Вы представите это значение с помощью переменной.
Константы и переменные выполняют очень похожие задачи. Вы можете подумать, что было бы проще использовать переменные для всего и вообще игнорировать константы. Технически ваш код может работать таким образом. Так зачем вам вообще использовать константы?
Во-первых, если вы устанавливаете значение в константу, компилятор понимает, что его никогда не следует изменять. Это означает, что вы не сможете создать или запустить свою программу, если попытаетесь изменить значение константы. Таким образом, компилятор обеспечивает безопасность.
Во-вторых, существуют специальные оптимизации, которые компилятор может выполнить для постоянных значений. Когда вы используете константы для значений, которые не изменятся, компилятор может делать низкоуровневые предположения о том, как сохранить значение. Эти настройки позволяют вашей программе выполняться быстрее.
В-третьих, это идиоматический, или общепринятый, способ делать что-то в Swift.
По мере того, как вы узнаете больше о создании программного обеспечения, вы начнете ценить лучшие практики для последовательного написания чистого, читаемого кода. Это особенно важно при работе в команде с другими разработчиками. Вы также обнаружите, что, следуя рекомендациям, вам будет легче запоминать, что делает ваш код, особенно если вы захотите внести изменения позже.
Если вы хотите стать отличным разработчиком, вам нужно следовать общим шаблонам и соглашениям. Этот курс познакомит вас с лучшими практиками написания Swift.
Присвоение имен константам и переменным
Существуют правила для присвоения имен константам или переменным. Компилятор применяет правила, поэтому вы не сможете создать и запустить свою программу, если нарушите их.
- Имена не могут содержать математических символов.
- Имена не могут содержать пробелов.
- Имена не могут начинаться с цифры.
Помимо этих трех правил, вы можете называть константу или переменную как вам заблагорассудится.
let π = 3.14159
let 一百 = 100
let 🎲 = 6
let mañana = “Tomorrow”
let anzahlDerBücher = 15 // numberOfBooks
let упячка = "Попячься" // Жывотное
В дополнение к правилам, существуют некоторые рекомендации по именованию констант и переменных:
- Имена констант и переменных должны быть четкими и описательными, чтобы облегчить понимание кода, когда вы вернетесь к нему позже. Например, firstName лучше, чем n, а restaurantsNearCurrentCity лучше, чем nearby.
- Чтобы быть ясным и описательным, вам часто захочется использовать несколько слов в названии. Когда вы соединяете два или более слова вместе, принято использовать "верблюжий регистр" camel case. Строчную первую букву в названии, а затем заглавную первую букву каждого нового слова. Вы, вероятно, заметили примеры этого: defaultScore - это обработка верблюжьего случая для объединения значений по умолчанию и оценки. Camel case легче читать, чем все слова, сжатые вместе. Например, defaultScore понятнее, чем defaultscore, а restaurauntsNearCurrentCity понятнее, чем restaurantsnearcurrentcity. Camel case также позволяет вспомогательным устройствам лучше очерчивать границы слов.
Комментарии
Вы заметили, что сбоку для anzahlDerBücher был написан перевод? По мере усложнения кода может быть полезно оставлять небольшие заметки для себя, а также для других разработчиков, которые могут прочитать ваш код. Эти комментарии создаются путем размещения двух косых черт перед текстом. Когда ваш код будет скомпилирован, комментарии будут проигнорированы, поэтому пишите столько, сколько сочтете полезным.
// Setting pi to a rough estimate
let π = 3.14
Если вам нужно несколько строк для вашего комментария, вы также можете поместить столько текста, сколько захотите, между /* и */, и он будет проигнорирован компилятором Swift.
/* The digits of pi are infinite,
so instead I chose a close approximation.*/
let π = 3.14
Комментарии чаще всего используются для объяснения сложных разделов кода, предоставления информации об авторских правах в верхней части файла и для предоставления информации о дате (когда файл был создан и/или изменен).
Типы
Каждая константа или переменная в Swift имеет тип, который описывает ее тип значения. В примерах, которые вы видели, 29 - это целое число, представленное типом Swift Int. Аналогично, "John" - это символьная строка, представленная типом Swift String.
Swift включает в себя множество предопределенных типов, которые вы можете использовать для более легкого написания чистого кода. Независимо от того, требуется ли вашей программе содержать числа, строки или логические значения (true или false), вы можете использовать типы для представления определенного вида информации.
Вот несколько наиболее распространенных типов в Swift.
| Наименование | Тип | Назначение | Пример |
| Integer | Int | Представляет целое число | 4 |
| Double | Double | Представляет числа, требующие десятичных знаков или действительне числа | 13.45 |
| Boolean | Bool | Представляет значения true или false | true |
| String | String | Представляет текст | "Once upon a time..." |
Swift также поддерживает типы коллекций, которые группируют несколько значений в одну константу или переменную. Один тип коллекции называется массивом (Array), в котором хранится упорядоченный список значений. Другой тип коллекции называется словарём, (Dictionary) в котором есть ключи, которые помогают вам искать определенные значения. Вы узнаете больше о коллекциях в следующем уроке.
Стандартная библиотека Swift включает в себя все вышеперечисленные типы, так что вы всегда можете их использовать.
Кроме того, вы можете определить свои собственные типы в Swift, создав определение типа. Рассмотрим простой тип Person:
struct Person {
let firstName: String
let lastName: String
func sayHello() {
print(”Hello there! My name is \(firstName) \(lastName).”)
}
}
Вы можете думать об определении типа как о схеме. Чертеж определяет, как построить здание, но не является самим зданием. Однако вы можете создать множество зданий по одному чертежу.
Определение типа объявляет информацию, которую оно хранит (свойства), и его возможности или действия (методы). В этом случае Person хранит строковую информацию (String) в двух свойствах, FirstName и LastName, и выполняет одно действие, метод sayHello(). Вы, вероятно, не знакомы со всем приведенным выше синтаксисом, но это нормально.
Приведенный выше пример описывает, как должен выглядеть и действовать типичный человек. Когда вы создаете тип и присваиваете его переменной или константе, вы создаете версию или экземпляр (instance) этого типа. Таким образом, экземпляр - это значение. Рассмотрим следующий код:
let aPerson = Person(firstName: “Jacob”, lastName: “Edwards”)
let anotherPerson = Person(firstName: “Candace”, lastName: “Salinas”)
aPerson.sayHello()
anotherPerson.sayHello()
Console Output:
Hello there! My name is Jacob Edwards.
Hello there! My name is Candace Salinas.
Этот код создает два экземпляра типа Person. Один экземпляр представляет Person по имени Джейкоб Эдвардс, а другой экземпляр представляет человека по имени Кэндис Салинас.
Вы узнаете больше об определении типов в следующем уроке.
Безопасность типа
Swift считается типобезопасным языком. Типобезопасные языки поощряют или требуют от вас четкого представления о типах значений, с которыми может работать ваш код. Например, если часть вашего кода ожидает значение Int, вы не можете передать ему значение Double или String.
При компиляции вашего кода Swift выполняет проверку типов для всех ваших констант и переменных и помечает любые несоответствующие типы как ошибки. Если типы не соответствуют, вы не сможете запустить свою программу.
let playerName = “Julian”
var playerScore = 1000
var gameOver = false
playerScore = playerName
// Будет помечен как несоответствующие типы, не будет компилироваться.
Поскольку безопасность типов обеспечивает соблюдение типа, который может содержать константа или переменная, присвоение String переменной, которая содержит только Int, не имеет смысла. Вскоре вы узнаете, как Swift определил эти типы.
Безопасность типов также применяется к переменным, константам и литеральным значениям, которые представляют данные, которые могут показаться совместимыми. Например, Swift распознает Int и Double как совершенно разные типы, хотя они оба представляют числа.
var wholeNumber = 30
var numberWithDecimals = 17.5
wholeNumber = numberWithDecimals
// Будет помечен как несоответствующие типы, не будет компилироваться.
В приведенном выше случае обе переменные являются числовыми типами, но wholeNumber будет Int, а numberWithDecimals будет Double. В Swift вы не можете присвоить значение одного типа переменной другого типа.
При работе с числами вы можете обнаружить, что вам нужно присвоить переменной или константе очень большое значение. Это может быть трудно прочитать, так как трудно увидеть, сколько нулей содержится в 1000000000. К счастью, Swift позволяет вам ставить подчеркивания в ваших числах в качестве способа форматирования для облегчения чтения.
var largeUglyNumber = 1000000000
var largePrettyNumber = 1_000_000_000
Вывод типа
Возможно, вы заметили, что вам не нужно указывать тип значения при объявлении константы или переменной. Это называется выводом типа. Swift использует вывод типа для создания предположений о типе на основе значения, присвоенного константе или переменной.
let cityName = “San Francisco”
// “Сан-Франциско”, очевидно, является `String`, поэтому компилятор
автоматически присваивает тип имени города `String`
let pi = 3.1415927
// 3.1415927 - это число с десятичными точками, поэтому компилятор
автоматически присваивает типу `pi` значение `Double`.
Как только вы присваиваете значение константе или переменной, тип устанавливается и не может быть изменен. Это верно даже для переменных. Значение переменной может измениться, но не ее тип.
Вы можете обнаружить случаи, когда полезно или даже требуется явно указать тип константы или переменной. Это называется аннотацией типа. Чтобы указать тип, добавьте двоеточие (:), пробел и имя типа после имени константы или переменной.
let cityName: String = “San Francisco”
let pi: Double = 3.1415927
Вы можете использовать аннотацию типа с различными типами чисел. Компилятор Swift скорректирует значение в соответствии с типом.
let number: Double = 3
print(number)
Console Output:
3.0
Существует три распространенных случая использования аннотации типа:
- Когда вы создаете константу или переменную, но еще не присвоили ей значение.
let firstName: String
//...
firstName = “Layne”
- Когда вы создаете константу или переменную, которые могут быть выведены как более чем один тип.
let middleInitial: Character = “J”
// “J” было бы выведено как `String`, но мы хотим, чтобы был `Character`
var remainingDistance: Double = 30
// `30` будет выведено как `Int`, но переменная должна
поддерживать десятичные числа для обеспечения точности по мере уменьшения числа.
- Когда вы пишете свое собственное определение типа.
struct Car {
var make: String
var model: String
var year: Int
}
Требуемые значения
Всякий раз, когда вы определяете константу или переменную, вы должны либо указать тип с помощью аннотации типа, либо присвоить ему значение, которое компилятор может использовать для определения типа.
var x
// Это приведет к ошибке.
Даже когда вы используете аннотацию типа, ваш код не может работать с константой или переменной, если вы еще не присвоили ей значение.
var x: Int
print(x)
// Это приведет к ошибке.
Как только значение присвоено, константа или переменная становятся доступными.
var x: Int
x = 10
print(x)
Лабораторная работа
Откройте и выполните упражнения в Lab—Constants and Variables.playground.
Связь с дизайном
Откройте свою рабочую книгу по разработке приложений и просмотрите разделы в "Описании", которые вы завершили. Хотя вы еще не перешли к этапу планирования, вы можете начать думать о своем плане приложения уже сейчас. Добавьте комментарии к разделам "Описания", которые вы завершили, или в новый пустой слайд в конце документа. Подумайте о том, какая информация может потребоваться для использования вашего приложения. Существуют ли различные типы, которые вы предполагаете использовать — числа, строки, логические значения?
Попробуйте классифицировать информацию как константы или переменные. Какие данные будут меняться по мере использования приложения, а какие останутся постоянными?
В примере приложения Go Green для рабочей книги приложению может потребоваться использовать переменные String для отслеживания элементов, которые пользователь перерабатывает. Он также может использовать константу Double для представления эквивалента 1 фунта пластика в фунтах углекислого газа.
Отрывок из книги
Develop in Swift Fundamentals
Apple Education
https://books.apple.com/ru/book/develop-in-swift-fundamentals/id1581182804