Крайне короткая глава, о том как получить информацию из консоли.

Для того что бы получить информацию от пользователя существует функция readLine. Достаточно вызвать ее, что бы программа начала ожидать вводит пользователя в консоли.

let stringFromConsole = readLine()
print(stringFromConsole)

Запустив этот код, можно будет ввести какую нибудь строку и увидеть ее обратно на экране(Рис. 1).

Рис. 1

Правда мы видим в консоли какой то Optional и предупреждение компилятора. Мы разберемся с тем что это такое в следующей главе. А пока, просто перепишем код таким образом.

let stringFromConsole = readLine() ?? ""
print(stringFromConsole)

Что конкретно делает ?? "" опустим. Но главное что ошибка пропала, и в консоли мы видим ту же строки что и ввели (Рис. 2).

Рис. 2

Последнее что можно сюда добавить, это сообщение для пользователя что он должен что то ввести. Это можно сделать через print.

print("Введите ваше имя:")
let name = readLine() ?? ""

print("Введите вашу фамилию:")
let surname = readLine() ?? ""

print("Привет:", name, surname)

В этом случае, сначала будет выводиться наш текст в консоль, пользователь, поймет что от него требуется и он введет текст (Рис. 3).

Рис. 3

В этой главе мы наконец попробуем совершить первые операции с нашими данными.

Оператор

Оператор это специальная конструкция языка, как правило один или два символа, которая позволяет выполнить операцию с данными. В Swift есть возможность создавать любые операторы, но это считается дурным тоном и в основном все пользуются базовым набором:

Их не так уж и много и на самом деле они все простые.

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

Самые распространенные операторы — бинарные. Например оператор сложения бинарный и записывается как 4 + 3. Как мы видим он ставится между двумя числами. Число слева и число справа в контексте этого выражения являются операндами. Бинарные операторы имеют два операнда, левый и правый и обязательно оба записываются от них через пробелы либо оба без пробелов с обеих сторон.

4 + 3    // корректное выражение, равно 7
4+4      // корректное выражение, равно 7
4 +      // не корректное выражение, приведет к ошибке сборки
+ 3      // не корректное выражение, ошибка сборки
4 +4     // не корректно
4+ 4     // не корректно

Правило с пробелами нужно для того, что бы отличать бинарные операторы от унарных. Унарный оператор имеет один операнд, слева или справа и записывается без пробела.

+4        // корректное выражение равно 4
-4        // корректное выражение равно -4
4 + -4    // корректное выражение равно 0
+ 4       // не корректное выражение
- 4       // не корректное выражение

В swift выражения многострочные, то есть могут располагаться на нескольких строках, будте аккуратны с этим. Перенос строки засчитывается за обычный пробел.

4 +
4
+ 3
+
5
// все эти 5 строк корректное выражение которое равно 4 + 4 + 3 + 5 = 16

Однострочное выражение отличается от многострочного отличается как раз висящим оператором (то есть оператором без одного из аргументов). Когда компилятор натыкается на выражение 4 +, котом не корректное с его точки зрения, он ищет продолжение выражения на следующей строке, если у него выйдет составить корректное выражение из двух или более строк, то он это сделает.
В swift по умолчанию (мы самостоятельно можем ввести в язык свои тернарные операторы) есть только один тернарный оператор (работающий с тремя операндами), выглядит он так 4 == 5 ? 1 : 0. Не очень очевидно, но сам оператор это ?:, а 4 == 5, 1, 0 это его операнды. По сути он работает по тем же правилам что и бинарные операторы, слева и справа от символов оператора располагаются операнды отделенные через пробел. О самом операторе ?: мы поговорим через несколько глав.

Математические операторы

Почти все эти операторы знакомы любому человеку и не сложно догадаться что они делают. Вот пример использования:

2 + 2   // 4
2 - 2   // 0
2 * 2   // 4
2 / 2   // 1
2 % 2   // 0

Что бы увидеть результат мы напишем эти выражения внутри функции print. Так же изменим немного примеры, что бы увидеть другой результат(Рис. 1).

Рис. 1

Переменные и константы вместо значений

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

let weight = 10
let height = 12
let square = weight * height // (10 * 12) = 120

Переменные и константы можно использовать абсолютно везде где можно использовать литералы.

Составные оператор присваивания

Иногда при работе с переменными бывает необходимо провести вычисление со значением переменной и результат положить в эту же переменную.

var age = 25     // 25
age = age + 1    // 26

Пример выше полностью корректный и рабочий, но можно записать то же самое короче с помощью составных операторов присваивания.

var age = 25      // 25
age += 1          // 26
age -= 10         // 16
age *= 2          // 32
age /= 4          // 8
age %= 3          // 2

age += 1 делает то же самое что и age = age + 1. То есть берется значение переменной age к нему прибавляется значение правого операнда, в данном случае единицы и результат присваивается обратно в переменную.

Деление на 0

В целом все ожидаемо и работает как в математике. Даже проблема деления на 0 имеется. Если при использовании оператора деления, мы разделим на 0, мы получим ошибку. В нашей простой программе, где все значения расставлены сразу рядом с оператором, компилятор легко найдет эту ошибку и предупредит (Рис. 2). В реальных приложениях, где значения меняются во время использования программы, такую ошибку предсказать не возможно и ваша программа будет закрываться с ошибкой прямо во время операции деления. Мы еще вернёмся к этой теме позже, что бы разобраться как и когда стоит защищаться от такой ошибки.

Рис. 2

Остаток от деления

Возможно тебя смущает оператор % (остаток от деления). Давай разберемся что он делает. Он берет число которое находится слева, делит его на цело на число которое находится справа и все что осталось и есть результат работы оператора. Пара примеров:

Целые и дробные числа

Swift очень строго относится к типам и не позволяет использовать разные типы в одном выражении. Но для математических операторах с использованием литералов он делает исключение и если в качестве операндов использовать литералы разных типов, просто считается что все числовые данные с дробной частью. Так как дробные литералы в swift это только Double то все превращается в Double, включая результат (Рис. 3).

Рис. 3

Исключением является только остаток от деления. Он просто не работает с Double и мы получим ошибку компиляции.

Автоматическое округление

Кстати, из за строго соблюдения типов, вас может удивить деление в котором участвуют только целые Int данные. При применении математических операторов Int данным, результат всегда будет Int. Тут возникает проблема — Int это целые числа, что тогда будет результатом деления 5 / 2? По идеи должно быть 2.5, но на деле результат просто округлится что бы стать целым. Округление всегда идет в меньшую сторону.

Рис. 4

Операторы сравнения

Операторы сравнения позволяют сравнить два своих операнда. Их выражением будет логическое значение (Bool).

4 > 2   // true
4 < 2   // false
4 >= 2  // true
4 <= 2  // false
4 > 4   // false
4 >= 4  // true
4 < 4   // false
4 <= 4  // true
4 == 4  // true
4 != 4  // false
4 == 2  // false
4 != 2  // false

Что бы понять как они работают, можно представить, что каждый оператор это вопрос, который задает программист, а логический результат это ответ на этот вопрос:

4 > 2   // 4 больше 2? да, больше
4 < 2   // 4 меньше 2? нет, не больше
4 >= 2  // 4 больше или равно 2? да, больше
4 <= 2  // 4 меньше или равно 2? нет, не меньше и не равно
4 > 4   // 4 больше 4? нет, не больше
4 >= 4  // 4 больше или равно 4? да, равно
4 < 4   // 4 меньше 4? нет, не меньше
4 <= 4  // 4 меньше или равно 4? да, равно
4 == 4  // 4 равно 4? да, равно
4 != 4  // 4 не равно 4? нет, они равны
4 == 2  // 4 равно 2? нет, они не равны
4 != 2  // 4 не равно 2? да, они не равны

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

Сравнивать можно не только числа, но и строки, и в целом разработчики могут с помощью специальных приемов сделать сравниваемым все что угодно при необходимости. Но пока мы говорит только о базовых типах, разберемся как сравниваются строки.

"a" == "a"              // true
"привет" == "привет"    // true
"привет" == "Привет"    // false
"a" != "a"              // false
"привет" != "Привет"    // true
"a" > "a"               // false
"a" > "A"               // true
"b" > "a"               // true
"b" > "ab"              // false

При сравнении на равенство, все просто, если строки содержат идентичные символы то строки равны, если хотя бы один символ отличается, то не равны. Важно понимать что прописные и строчные буквы это разные буквы. Так же некоторые символы могут выглядеть одинаково, но быть разными. Например кириллическая «а» и латинская «a» выглядят идентично, но они не равны.

При сравнении на больше меньше результат уже не столько предсказуем. Дело в том что сравнивается номер символа в его таблице кодировки. Чем этот больше, чем больше считается символ. Сам алгоритм выглядит следующим образом: сращиваются первые символы в строке, если они не равны, то результат сравнения становится результат сравнения. Если же первые символы равны, происходит сравнение следующих символов и так далее, пока не найдется не равная пара. В общем случае выяснять какая строка больше или меньше крайне бесполезно и ничего не дает. Все ограничиваются сравнением строк на равенство. Вообще сравнение на равенство очень популярная операция для разных типов данных.

Логические операторы

Это особые операторы которые работают только с логическими значениями (Bool). И нужны для их преобразования.

&& — логическое «И». Проверяет два соседних операнда и если оба равны true. То и результат равен true.

true && true    // true
true && false   // false
false && true   // false
false && false  // false

|| — логическое «Или». Проверяет два соседних операнда и если хотя бы один из них равен true. То и результат равен true.

true || true    // true
true || false   // true
false || true   // true
false || false  // false

! — логическое «не» или отрицание. Это унарный оператор, который применяется к логическому значению и меняет его на противоположное.

!true   // false
!false  // true

Оператор конкатенации

Оператор + применяется не только для сложения двух чисел, но и для конкатенации значений. Как правило строк. Другими словами он просто объединяется две строки в одну.

"Привет" + "Мир!" // "ПриветМир!"
"Привет" + " Мир!" // "Привет Мир!"
"Привет" + " " + "Мир!" // "Привет Мир!"

Составные выражения

Несколько операторов могут объединятся в одно выражение.

let result = 45 + 18 * 6 / 3 - 4

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

Каждый из операторов имеет приоритет, то есть порядок в котором будут выполняться эти операторы, все как в математике. Давайте посмотрим на приоритеты:

  1. *, /, %
  2. +, —
  3. < > <= >=
  4. ==, !=
  5. &&
  6. ||
  7. ?:
  8. =, +=, -=, *=, /=, %=

В этом списке, на первой строчке самые приоритетные операторы, на последнее наименее приоритетные. Приоритет определяет порядок вычисления операторов в выражении. Операторы с большим приоритетом вычисляются раньше. Операторы в одной строке имеют одинаковый приоритет, то есть выполняются слева на право. Слева на право как записаны в коде, а не в списке.

По этому списку приоритетов, можно самостоятельно разобрать как будет выполняться пример выше.

45 + 18 * 6 / 3 - 4  // исходное выражение
18 * 8 = 108         // сначала выполнится умножение
45 + 108 / 3 - 4     // результат умножения займет место в выражении
108 / 3 = 36         // затем выполнится деление
45 + 36 - 4          // результат деления займет место в выражении
45 + 36 = 81         // теперь выполнится сложение
81 - 4 = 77          // результат сложения займет место в выражении
77                   // выполнится последний оператор, результат равен 77

В выражении можно использовать круглые скобки для изменения приоритетов операторов, как в математике. Давайте перепишем пример, с круглыми скобками, пока что расставим их в соотвествии с приоритетами по умолчанию, просто что бы подчеркнуть эти приоритеты.

(45 + ((18 * 6) / 3) - 4) = 77

При использовании круглых скобок, всегда в начале будет вычисляться выражение в скобках. Пример выше, аналогичен первому примеру. Но мы можем это изменить. Давайте расставим скобки, так что бы все операторы в выражении вычислялись по порядку.

((((45 + 18) * 6) / 3) - 4)   // исходное выражение
(45 + 18) = 63                // вычисляем первые скобки
(((63 * 6) / 3) - 4)          // заменяем скобки на результат вычисления
(63 * 6) = 378                // вычисляем следующие скобки
((378 / 3) - 4)               // заменяем скобки на результат вычисления
(378 / 3) = 126               // вычисляем следующие скобки
(126 - 4) = 122               // заменяем скобки на результат вычисления

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

let age = 28
let name = "иван"
let isGoodCandidat = age >= 25 && name == "петр" || name == "иван"
print(isGoodCandidat)   // true

Примере выше, мы сначала выполним все сравнения, замет применим логически операторы, в итоге получим утвердительный ответ true. Давайте рассмотрим по шагам, как будут происходить вычисления.

Наивысший приоритет имеет оператор >=. Значит изначально будет вычисляться выражение age >= 25. Константа age равна 28, 28 больше 25. Значит результат равен true.

Следующие по приоритету идут два оператора ==. Первым будет вычисляться тот что слева — name == "петр". Константа name равна «иван», строка «иван» не равна строке «петр». Значит результат false. Теперь будет вычисляться name == "иван". В этом случае значение константы name равно литералу «иван», результат равен true.

Давайте расставим результаты вычислений вместо самих выражений.

age >= 25  = true
name == "петр" = false
name == "иван" = true
true && false || true

Оператор && имеет больший приоритет, чем ||, значит сначала вычистится выражение true && false, так как один из операндов равен false, все выражение будет равно false. Последний шаг вычислений будет таким false || true. Так как один из операндов равен true, результат выражения равен true.

Этому же порядку соответствуют скобки и с ними читать как то попроще.

((age >= 25) && (name == "петр")) || (name == "иван")

Сложные выражения лучше разделять на несколько более простых

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

let age = 28
let name = "иван"
let isGoodCandidat = age >= 25 && name == "петр" || name == "иван"
print(isGoodCandidat)   // true

Возьмем наше изначальное выражение и разобьём его на несколько.

let age = 28
let name = "иван"
let isAdult = age >= 25
let hasRightName = name == "петр" || name == "иван"
let isGoodCandidat = isAdult || hasRightName
print(isGoodCandidat)   // true

Так проще читать, теперь смысл проверок стал более понятным. А еще мы выяснили, что не смотря на верный результат, наше первое выражение не соответствовало нашим намериниям. Так как сначала происходила проверка на возраст и первый вариант имени и только потом проверка на второе имя, при разделении на несколько выражений, стало очевидно, что возраст нужно проверять отдельно от имен, а потом уже объединять два результата.

Мы разобрались какие основные типы данных есть у нас есть в языке и как выводить значения в консоль, теперь разберемся как их сохранять в коде, во время выполнения программы. Для этого в языке есть две вещи: переменные и константы.

Объявление констант

Для того что бы использовать в коде константы их нужно объявить. Давайте объявим константы всех известных типов. Это делается следующем образом.

let a: Int // let %имя константы%: %тип константы%
let b: Double
let c: Float
let d: String
let e: Character
let f: Bool

Как вы видите это не сложно. Синтаксис объявления выглядит как добавление ключевого слова let в начале выражения, потом нужно написать имя константы, затем через двоеточие указать ее тип. Константа будет объявлена.

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

let user: Int      // хороше имя
let b: Int         // плохое имя
let 1user: Int     // некоректное имя, приложение не скомпилиируется
let User: Int      // плохое имя
let myuser: Int    // плохое имя, слова сливаются
let my_user: Int   // плохое имя, в iOS разрабоке обычно не используют нижнее подчеркивание для разделения слов
let myUser: Int    // хороше имя

Каждую константу стоит объявлять на отдельной строке, так как это законченное синтаксическое выражение, то код вида let user: Int let b: Int просто не будет компилироваться. Можно указывать несколько выражений в одной строке, отделяя их точкой с запятой: let user: Int; let b: Int, но это считается дурным тоном.

Присвоение значения константе

Мы можем запустить приложение с примерами выше и приложение будет запускаться. Но использовать объявленные константы без присвоено значения нельзя. Давайте просто попробуем вывести константу в консоль и увидим ошибку компиляции (Рис. 1).

Рис. 1

Присвоение значения константе называется инициализацией.

Для того что бы использовать константу, нужно ее инициализировать. Для этого нужно использовать оператор присваивания =(Рис. 2). Он работает очень просто. Берет константу, указанную слева от него и присватает значение указаное справа от него. И да, нельзя поменять их местами. Всегда происходит присвоение того что находится с права, в то что указано слева.

Рис. 2

Инициализированной константой можно свободно пользоваться в коде. Можно ее выводить в консоль, присваивать ее значение другим константам и переменным, передавать в функции или использовать в качестве операнд для операторов. Но об этом мы поговорим в следующей главе.

Присваивать значение константе можно только один раз. Если попытаться присвоить значение повторно, то мы получим ошибку компиляции (Рис. 3).

Рис. 3

Объявление и инициализация в одном выражении

В примерах выше, мы отдельно объявляли константы, а затем присваивали им значения. Но можно сделать это все за один раз. И более того, обычно так и делается в коде.

let a: Int = 1
let b: Double = 2.3
let c: Float = 3.14
let d: String = "Привет мир!"
let e: Character = "d"
let f: Bool = true

Обратите внимание, что для присвоения значения константам c и e мы использовали литералы, не смотря на то что их типы Float и Character у которых нет литералов. Это сработало потому что компилятор видит указанный тип константы и может автоматически преобразовать литерал в нужный тип.

Строгая типизация

Swift строго типизированный язык. Это означает что типы всегда совпадать во всем выражении. И нельзя в константу типа Int положить строку или наоборот (Рис. 4). Единственное что компилятор может нам простить это если мы попытаемся сохранить во Float или Double константы целые числа, он автоматически их приведет к нужному типу.

Рис 4.

Более того, такие поблажки с типами возможны только для литералов. Если мы буем присваивать константе зачине другой константы то типы должны совпадать полностью (Рис. 5).

Рис. 5

Автоматический вывод типов

Выше мы писали типы везде. Но swift умеет выводить типы если ему достаточно информации и если мы инициализируем константу сразу присваивая значения то он автоматически выведет ей тип этого значения.

let a = 1               // Int
let b = 2.3             // Double
let c: Float = 3.14     // Float
let d = "Привет мир!"   // String
let e: Character = "d"  // Character
let f = true            // Bool

В примере выше у нас получилось опустить все типы кроме Float и Character. Как раз потому что у них нет своих литералов и если доверить вывод типов компилятору то он будет считать что там Double и String.

То же самое справедливо если инициализировать с помощью других констант.

let a0 = 1
let a = a0               // Int
let b0 = 2.3
let b = b0              // Double
let c0: Float = 3.14
let c = c0              // Float
let d0 = "Привет мир!"
let d = d0              // String
let e0: Character = "d"
let e = e0              // Character
let f0 = true
let f = f0              // Bool

Теперь, как видите, мы даже не указали типы для c и e, потому что c0 и e0 нужного нам типа.

Обычно при написании кода, считается что не стоит указывать типы, там где их может вывести компилятор. Но если тебе сложно в начале определять где какой тип, то можешь ставить типы везде.

Переменные

var a: Int // var %имя переменной%: %тип переменной%
a = 1
var b: Double = 2.4
var c: Float = 3.14
var d = "Привет мир"
var e: Character = "e"
var f = true

Все что было сказано выше про константы, справедливо и для переменных. Их можно так же объявлять, но только с использование ключевого слова var вместо let, так же использовать, так же присваивать значения, они так же выводят типы и так далее. Единственная разница кроме ключевого слова — для переменных можно присваивать значения несколько раз, а для констант только один раз (Рис. 6).

Рис. 6

Зачем вообще нужны переменные и константы

Можно было бы конечно везде использовать просто литералы, но переменные и константы намного удобнее. Они решают множество задач:

Когда использовать переменные, а когда константы

Кажется что переменные удобнее констант, ведь они делают все то же самое, но еще и позволяют изменять значения. Но в реальной разработке, переменные часто служат источником путаницы. Из за того что в любой момент, можно поменять значение переменной, в ней может оказаться не то значение которое мы ожидаем увидеть. Кроме того существуют различные технические проблемы о которых мы поговорим позже. Пока просто возьми за правило, использовать константы везде где это возможно. Я продемонстрирую этот подход в следующих главах.

В прошлой главе мы познакомились с основными типами данных и даже написали их в коде программы, но это не повиляло никак на нашу программу. То есть при ее запуске ничего не изменилось. В этой статье я расскажу, про один из видов взаимодействия с пользователем из кода программы — выводом информации в консоль.

Рис. 1

Консоль это вот это черный (или любого другого цвета в зависимости от настройки Xcode) прямоугольник (Рис. 1). Я упомнил о нем в статье Интерфейс Xcode. Сегодня я расскажу об одной из ее функций — выводе текстовой информации от программы.

Функция print

Что бы не создавать по файлу на каждую статью, я просто буду писать код в файле «main.swift». Давайте напишем такой код:

print("Привет мир")

В нем мы используем функцию print. Опять же, до функций мы еще дойдем, пока нужно просто запомнить, что для вывод информации в консоль нужно написать в коде программы print() и внутри круглых скобок указать то что будет выведено.

Рис. 2

После запуска программы мы увидим в консоле две строки: «Привет мир» и «Program ended with exit code: 0» (Рис. 2). Первая это результат выполнения нашего кода, а вторая это стандартное сообщение которое выводится перед завершением программы по умолчанию.

Какой тип данных можно вывести в консоль

В консоль можно выводить только строки (String), но к счастью функция print умеет самостоятельно превращать любые значения в строки.

Рис. 3

Если мы напишем print шесть раз, передавая уже знакомые нам с прошлой главы типы данных, то увидим в консоле шесть строк которые были автоматически получены из этих значений (Рис. 3).

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

Вывод нескольких значений за один print

print умеет выводить несколько значений раз один раз, для этого достаточно перечислить все значения внутри скобок через запятую.

Рис. 4

Итог

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

Данные основа программирования

Все программирование строится на различных операциях над данными. По сути работа программиста это получать, создавать, передавать и изменять данные. Звучит не слишком сложно. Но на самом деле это зависит от задачи. Сложить два числа и правда просто, на столько просто, что для этого даже не нужно уметь программировать, достаточно разобраться как запустить код. Но иногда это похоже на попытку слепить Диснейленд из песка. При этом все что у вас есть, это лопатка, ведерко и пустыня полная песчинок. И да, аттракционы в Диснейленде должны работать и быть надежными. Конечно чаще всего истина лежит где то по середине.

Все состоит из атомов

Не совсем корректное сравнение, но тем не менее, как все в нашем мире стоит из атомов, так и все в программировании состоит из нулей и единиц. Это не очень удобно, но человечество смогло научить компьютеры понимать только есть где то электричество или его там нет. На этой простой бинарной системе (бинарной значит состоящей из двух значений) и построены все наши программы. Другими словами все для компьютера выглядит примерно вот так — 1010111010101010101. К счастью современным разработчикам не приходится писать нули и единицы что бы объяснить компьютеру, что от него требуется.

Шесть основных типа данных в Swift.

Современные языки умеет представлять данные в привычном для простого человека виде и Swift не исключение. В нем есть шесть основных типа данных:

Довольно просто и интуитивно знакомо любому человеку и можете верить, а можете нет, но из этих 6 типов можно построить все что угодно, банковскую систему, GTA 6 или программное обеспечение для марсохода. Можешь считать это песчинками из которых иногда программисты лепят куличики, а иногда и правда строят Диснейленд.

👨‍🏫Забегая вперед

Я немного слукавил и на самом деле некоторые программы требуют дополнительных базовых типов. Например в банковских системах не хватает одних лишь Int и Double. При работе с большими суммами, возникают погрешность которые никак нельзя допустить, ведь каждая погрешность это буквально потеря настоящих денег.

Но опять же, эти особые типы данных мало чем отличаются от Int с точки зрения разработчика. Они просто поддерживают большие значение, а в замен приходится платить тем что математические операции с ними медленные.

Создание нового файла в проекте

Давай создадим новый файл для этой темы. Я уже говорил что для этого достаточно нажать по нужной группе правой кнопкой мыши и выбрать «New File». Затем перейди на вкладку macOS и выбери «Swift File» (Рис. 1) и нажми «Next».

Рис. 1

В открывшемся окне введи название «BaseSatatypesAndLiterals». Помни о том, что не надо использовать русские буквы и проблемы (больше предупреждать не буду) (Рис. 2).

Поле «Where» указывает папку где будет сохранен файл, а поле «Group» группу (Рис. 2). По умолчанию они совпадают и не рекомендую их менять. Но технически они могут и не совпадать, ты можешь сохранить файл где угодно, при этом в Xcode он будет отображаться так как если бы он находился в группе «swiftBase». Рекомендую прочитать Интерфейс Xcode, где я подробно объяснил что папка и группа может не совпадать.

Поле «Targets» содержит таргет (или приложение) к которому относится данный файл и в сборке которого он будет участвовать (Рис. 2). Сейчас в нашем приложении только один таргет, и он выбран по умолчанию. Опять же, его не нужно трогать, иначе код из этого файла не будет учитываться при запуске приложения. Рекомендую прочитать Основные настройки проекта, где я более подробно объяснил про то, что такое таргеты.

Рис. 2

Обычно в этом окне не меняется ничего кроме названия файла, реже меняется таргет. После того как введешь название, нажми «Create».

Начальная функция

По умолчанию просто так код можно писать только в файле «main.swift», в остальных файлах что бы вызвать какой то код, его нужно написать как минимум в функции. Я расскажу о том что это такое позже. Пока что просто напиши в новой файле код как на листинге ниже. Весь остальной код этой статьи мы будем писать внутри этой функции, между «{» и «}».

func dataTypeTest() {

}

Теперь в файле «main.swift» просто напиши

dataTypeTest()

Для начала этого будет достаточно.

Рис. 3

Пробуем первые четыре типа

Просто введи по одному значению на строку внутри функции «dataTypeTest» как показано ниже. Все, ты смог только что добавить в программу пару значений. Правда это несколько бессмысленно, ведь мы с тобой ничего с ними не сделали, даже не сохранили. Но тем не менее, это работает. Можно запустить программу, и убедиться что она работает, хотя ничего и не делает с нашими данными.

func dataTypeTest() {
    1         // Int
    3.14      // Double
    "привет"  // String
    true      // Bool
    false     // Bool
}

Остался вопрос как ввести в программу Float и Char. Ведь они выглядят точно так же как Float и String.

6.78789.  // Double
"п"       // String

Особенное это не очевидно со строкой. Казалось бы можно понять, что один символ это один символ, но из за того что Char используется крайне редко, удобнее считать строками все что находится в двойных кавычках.

Есть множество способов указать какой конкретно тип нужно использовать, о них я расскажу буквально в следующих статьях. Пока что используем преобразование типов, что бы преобразовать один тип в другой показано в примере ниже.

Character("f")  // Character
Float(3.44)     // Float

Не будем вдаваться в подробности как это работает, но теперь типы точно верные и мы получили Character и Float.

Зачем нужно столько типов

Наверное тебя может смутить, зачем нужно столько похожих типов данных. Почему бы не обойтись просто числом с плавающей точкой и строкой? На это есть разные причины, где то это техническое ограничение, где то дополнительный контроль над кодом, а где то просто для выразительности, что бы другой разработчик лучше понял что конкретно тут написано

Int vs Double

Давай для начала разберемся зачем нужно деление на числа с дробной частью и без нее. Для человека почти нет разницы между «4» и «4.0» и то и то равно четырем. Но для компьютера разница есть, ему проще работать с целыми числами, то есть эти операции выполняются быстрее. А еще Double не точное, то есть проведя ряд математических операций вы можете получить не совсем то число которое ожидали, да погрешность может быть где то на уровне миллионного знака после запятой, что в обычной жизни никого не волнует, но для компьютера это уже разные числа и это приводит к проблемам.

Пока что, просто возьми за правило, использовать Int там где не предполагается дробных значений и это будет достаточно. В дальнейшем я вернусь к проблеме операций с Double.

Float vs Double

Ок, если целые числа и числа с дробной частью это не одно и тоже, то чем отличаются эти два типа? Все просто, Double занимает в два раза больше места в памяти, но в целом это единственный его минус. Современные компьютеры и работают с ним побыстрее чем с Float и погрешность у него меньше, да и числа он хранит большие.

В общем, если у тебя нет цели написать программу для умного выключателя, смело использую Double.

String

Строки невероятно сложный тип данных и о их голубой сложности я буду говорить позже. Пока что достаточно понять основное — строка хранит не только буквы, все что написано между кавычек это символы строки:

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

Но iOS разработчикам редко приходится самостоятельно делать что то сложное со строками. Мы используем готовые решения, о которых я расскажу позже. Пока что достаточно запомнить:

Character vs String

А вот тут все просто. Character это та же String в которую технически нельзя записать больше одного символа. Character используется для того что бы один разработчик мог объяснил другому разработчику что вот тут используется буквы, а не строки. Например строка «привет» состоит из букв «п» «р» «и» «в» «е» «т» и я могу использовать Character что бы подчеркнуть что это не просто строки из одной буквы, а именно буквы.

Если мы попытаемся создать Character из нескольких символов, то получим ошибку компиляции (сборки) и запуска приложения (Рис. 4). Таким образом используя данный тип мы на 100% уверены, что значение содержит только один символ.

Рис. 4

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

Bool

Готов поспорить, что это самый загадочный тип для тебя. Числа были на математике, слова мы писали на русском языке, а вот логических значений нигде не было. Но если подумать, то мы постоянно пользуемся ими в жизни.

Например ты можешь спросить живу ли я в одном с тобой городе. Ответ будет либо «да» либо «нет» в зависимости от того где ты живешь. в этом случае «да» и «нет» являются логическими значениями, обозначающие верно ли утверждение что мы живем в одном городе или оно ложно.

В программировании мы тоже очень часто что проверяем или сравниваем:

В результате всех этих сравнений мы будем получать логическое значение — «да» или «нет». И мы могли бы хранить эти значения в строках. Но тут много вопросов, например на каком языке? А что если один разработчик решит обозначать их как «конечно» и «неа». Да и представь, попросил ты компьютер что то сравнить, а он ответил тебе строкой «да», если ты не выведешь ее пользователю что бы он ее прочел, как ты узнаешь что он тебе ответил? «да» это просто строка и что бы узнать что она содержит «да» нужно сравнить ее с о строкой «да», а в результате снова будет строка, так мы просто попадем в замкнутый круг.

Для решения всех этих проблем на свет появился логический тип данных Bool. И он может иметь два значения true утверждение верно и false — утверждение ложно (в коде пишется без кавычек). Что бы точно понять что такое эти true и false сравним Bool и Int. И то и другое тип данных, и то и другое имеет конкретные значения. Значения для Int это 1, 2, 3, 999 и так далее. Значение для Bool либо true либо false. Вот и все.

В общем используй Bool когда нужно проверить какое то логическое утверждение (сравнение). Пока может быть не очень понятно, но когда мы дойдем до работы с данными ты увидишь что все просто.

Литералы

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

1        // литерал типа Int
4.4      // литерал типа Double
"hdfjh"  // литерал типа String
true     // литерал типа Bool

Литерал означает «буквально», то есть 1 это буквально 1.

И как ты надеюсь уже понял литералов для Character и Float не существует. Что бы получить эти типы мы должны использовать вспомогательные конструкции языка, например явно указывать тип.

Character("f")  // Character но не литерал
Float(3.44)     // Float но не литерал

Итог

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

И так, мы познакомились с основными элементами интерфейса Xcode и прежде чем приступить к изучению языка, осталось только ознакомиться с основными настройками. В целом, эти настройки не очень нужны, что бы изучать язык и изменять мы их не будем. Но, хочется, что бы ты понимал(а) что за таинственные письмена открываются при клике на название проекта.

Настройки разбросаны по разным частям интерфейса еще и комбинируются в разных вариантах. Но традиционно, об этом пока не будем)

Что бы увидеть настройки, нужно в project navigator выбрать файл проекта, после этого в редакторе откроется меню настроек. В колонке слева видно две секции «project» и «targets» (Рис 1).

Рис 1

Project — настройки собственно всего проекта, а targets того что из него можно собрать. Как я уже говорил из одного проекта можно собрать разные приложения, библиотеки и прочее прочее. Например я могу собрать приложение для iPhone, Mac, iWatch, библиотеку которую буду использовать во всех этих приложения и стикер пак. Пока что у нас только один target — наше приложение для консоли, собственно нам больше и не нужно.

Сразу хочется сказать про то что все файлы с кодом и некоторые другие файлы в проекте принадлежат к одному и нескольким target (Рис 2). Это значит, что при добавлении новых файлов или при работе со старыми нужно обращать на это внимание.

Рис 2

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

Настройки проекта

Вернемся к настройкам. Если выбрать проект (Рис 1) то появится три вкладки:

Info

Часть самых часто изменяемых параметров сборки

Deployment target — минимальная версия операционной системы как которую можно установить приложение. Чем она ниже, тем больше пользователей, включая пользователей старых устройств смогут воспользоваться этим приложением. Но за это прийдется платить, более старой версией языка Swift, отсутствием более современных библиотек и возможностей приложения.

Configuration — приложение может иметь разные конфигурации сборки, каждая из которых имеет свои собственные настройки. По умолчанию предоставлено две конфигурации «debug» и «release». Первая для разработки, вторая для конечно приложения что будет доставлено пользователю. Они отличаются набором оптимизаций, то есть приложение в релизной сборке будет работать быстрее, возможностью отладки, которая доступна в дебаг режиме и еще кучей разных настроек. У нас даже есть возможность добавлять тот или иной код в зависимости от сборки. В реальной жизни, конфигураций добавлю больше, для разработчиков, для тестировщиков, для тестирования на сервере и так далее.

Localizations — языки которые поддерживает приложение. По умолчанию там только английский. А это значит что все стандартные элементы интерфейса будут в приложении на английском. Обычно добавляются несколько языков, в зависимости от того где планируется публиковаться. Это позволит системе подбирать нужный язык для стандартных элементов, а разработчикам указывать несколько вариантов переводом для своих собственных надписей.

Build settings

Основные настройки проекта. Тут находится почти все что можно настроить. Все настройки разбиты по группам, а так же у каждой конфигурации имеется свой вариант той или иной настройки.

Рис 3

Опять же, пока что я не буду рассказывать про эти настройки ничего. Просто знай, что они тут есть и трогать их в большинстве случаев тебе не надо) Тут мало что меняется даже на серьезных проектах.

Package Dependencies

Это вкладка управления внешними зависимостями. То есть библиотеками с кусками кода, которые подключают к разным проектам. Это полезная и часто используемая опция. Но пока разберем ее попозже.

Настройки таргета

При выборе таргета можно увидеть конкретно его настройки:

Итог

Мы обзорно посмотрели на настройки проекта. Пока что они не очень для тебя важны. Главное что тут нужно запомнить это про принадлежность файлов к таргетам, что бы случайно не отвязать файл с кодом от приложения или не привязать к какому нибудь другому таргету.

В этой статье я расскажу, об основных элементах нашей IDE.

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

Давай для начала верхнеуровнево разберемся с зонами:

  1. Панель навигаторов — Служит для показа различных сущностей в проекте и навигации по ним.
  2. Редактор — позволяет редактировать файлы. Имеет несколько режимов для редактирования кода, настроена проекта, визуального интерфейса и прочего. Автоматически подстраивается под тип открытого файла.
  3. Инспектор — отображает различные свойства выбранного файла.
  4. Панель состояния проекта — отображает режимы и сотояние запуска приложения.
  5. Список значений в режиме отладки — показывает различные значения в текущий момент времени запущенной программы
  6. Консоль — имеет два назначения. В режиме обычного выполнения программа может выводить в нее текстовую информацию или наоборот запрашивать текстовую информацию от пользователя/разработчика. В режиме отладки позволяет выполнять отладочные команды.
  7. Кнопка показа/скрытия панели навигатора
  8. Кнопка запуска/остановки программы.
  9. Кнопка показа/скрытия панели инспектора.
  10. Копка показа/скрытия нижней зоны отладки которая содержит панели 5 и 6.
  11. Кнопки показа/скрытия панелей 5 и 6 в нижней зоне отладки.

1 — Навигатор (Navigator)

Может отображать в зависимости от нажатой кнопки (самый верхний ряд кнопок слева на право):

В самом низу навигатор, в каждой из вкладок обязательно находится текстовое поле для нитрации содержимого. Если в него вбить текст, то он отфильтрует результаты так, что бы отображались только те варианты что содержат этот текст. Дополнительно имеет кнопки которые зависят от текущей вкладки и позволяет применять специфические фильтры.

Не торопись впадать в панику, пока что достаточно только первой вкладки — списка файлов. Остальные вкладки я расскажу постепенно, объясняя что они делают и как ими пользоваться. Для изучения языка, они не обязательны.

Со списком файлов все довольно просто, он отображает список файлов и групп. Каждая группа может содержать в себе список дочерних файлов и групп и так до бесконечности.

Ты можешь просматривать этот список, показывать/скрывать содержимое групп, выбирать кликом левой кнопки мыши файл, для того что бы увидеть его содержимое и свойства. Кстати содержимое группы в реакторе не отображается, но вот свойства в панели инспектора можно посмотреть и изменить.

Естественно ты можешь перемещать файлы и группы из одного места в другое, для этого нужно нажать и удерживать левую кнопку мыши во время перемещения. Положение файлов и групп никак не влияют на сборку или работу приложения. Они нужны для того что бы разработчику было проще ориентироваться в большом количестве кода.

👨‍🏫 Забегая вперед

Из этого правила есть исключение. При использования SPM в определённых случаях крайне важно, в какой группе находится тот или иной файл.

Конечно ты можешь добавлять или удалять файлы и группу. Для того что бы добавить файл или группу, нужно выбрать группу в которую ты хочешь добавить новый элемент, или любой файл внутри этой группы. Затем нажать на него правой кнопкой мыши и выбрать «Add File» для добавления файла (как выбрать нужный тип файла я расскажу позже) или «New Group» для добавления группы.

⌨️ Горячие клавиши

cmd + N — добавить новый файл
option + cmd + N — добавить новую группу

Пришло время поговорить о группах. Хотя я часто и называю группы папками это не аналоги как могло показаться. Дело в том, что структура групп и файлов в навигатор не обязательно совпадает со структурой файлов и папок. Группы это виртуальные папки которые существуют только в проекте Xcode. При этом они могут быть связаны с папки, а могут нет. То есть, технически все файлы могут быть находиться в одной папке, но быть разбиты на множество групп в проекте. Наоборот, находиться во множестве разных папок, но быть в одной группе.

Я не рекомендую использовать группы не привязанные к папкам и поддерживать структуру в проекте, аналогично структуре папок. Сделать это очень просто. Нужно только всегда создавать обычные группы, а не использовать вариант «New Group without Folder»

2 — Редактор

На первый взгляд ректор не требует никаких объяснений. Если выбрать текстовый файл, то он будет отображать обычный текстовый редактор, с которым думаю ты знаком. При выбор других сущностей реактор измениться, но лучше рассказывать уже не в контексте редактора, а конкретных сущностей, что я обязательно сделаю в будущем.

С другой стороны нюансы все же есть. Уже при написании текста, у нас появляется автодополнение, подсказки и прочее. О чем я расскажу опять же потом. Но кроме этого сам редактор имеет и другие особенности.

Вкладки

Редактор имеет механизм вкладок. Который по началу может несколько удивить. Но сейчас мы в нем разберемся.

Если открыть файл в навигаторе, то он откроется в редакторе и мы увидим, вверху соответствующую вкладку.

Обрати внимание на то что заголовок вкладки выделен курсивом. Это значит что вкладка тут временно. При открытии другого файла, он откроется в этой же вкладке. То есть если прямо сейчас, я не производя никаких других действий открою файл — «Second» то содержимое файла «main» из редактора пропадет.

Это довольно удобно, когда ты просто бегло просматриваешь файлы и тебе не нужно с ними долго работать. Но так же часто нам нужно файл оставить, если мы собираемся редактировать его или просто переодически возвращаться к нему.

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

После этого заголовок вкладки перестанет быть курсивным. И если ты откроешь другой файл, то он откроется в соседней вкладке. На следующем изображении «main» закреплен, а «Second» нет и видно разницу в начертании.

🤓 Совет

Открывай файлы одиночным кликом, если ты хочешь быстро посмотреть что там. Открывай файлы двойным кликом если ты хочешь работать с ним продолжительное время. Так тебе проще будет управлять вкладками и не придётся удалять лишнее или наоборот постоянно искать нужное.

⌨️ Горячие клавиши

shift + cmd + [ — перейти к вкладки слева
shift + cmd + ] — перейти к вкладки справа

Навигация по истории действий

Слева от вкладками находятся две стрелки — «в право» и «в лево». Кликая по ним можно прыгать между файлами, в том порядке в котором ты их просматривал или редактировал. Очень полезно, что бы вернуться в то место где ты недавно был.

⌨️ Горячие клавиши

ctrl + cmd + стрелка влево — переход по истории назад
ctrl + cmd + стрелка вправо — переход по истории вперед

Хлебные крошки

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

Во-первых очень удобно, что бы понять в каком месте проекта ты находишься. Во-вторых это еще и дополнительное средство навигации.

При нажатии на любую секцию в хлебных крошках можно увидеть что находится рядом с ней в файловом редакторе и открыть нужный элемент в соседней или текущей вкладке.

Несколько редакторов в ряд

Область редактора можно поделить между несколькими отрытыми файлами или даже отображать один и тот же файл несколько раз. Это удобно, например, что бы одновременно держать перед глазами начало и конец длинного файла.

Открывать новый редактор можно с помощью самой правой кнопки на панели вкладок — «Add editor on right» или открыв новый файл из навигатора с жатой клавишей option.

3 — Инспектор

Может отображать в зависимости от нажатой кнопки (самый верхний ряд кнопок слева на право):

Пока разберем только первую вкладу — информацию о файле. Обычно тут никто ничего не трогает. И самая полезное это секция «Target Membership», но ней поговорим в следующей статье.

Остальное это:

Последние три параметра можно менять по своему вкусу. Но опять же я не рекомендую. Ниже показано о каком выравнивании идет речь.

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

Итог

Я рассказал об основных элементах интерфейса Xcode, но кроме них есть еще много менюшек, кнопок и панелей. О самых важных я расскажу позже. Остальное ты можешь исследовать сам. Особенно рекомендую посмотреть на список горячих клавиш (так называют сочетания славишь на клавиатуре, нажав которые можно сразу выполнить какое то действие в программе) в настройках Xcode или погуглить «Xcode hotkeys cheat sheet» что бы найти множество готовых шпаргалок.

Пришло время создать первое приложение, в котором я буду показывать как писать код на языке swift. Для этого нужно создать в xcode новый проект.

Что такое проект в Xcode

Как вы уже знаете Xcode не просто реактор где можно писать текст, а IDE которая содержит массу возможностей, которые облегчают процесс создания приложений. И сами по себе приложения состоят не только из листингов код.

Листинг кода — так принято называть какой то кусок текста на языке программирования, в данном случае на swift.

Как минимум там еще должны быть настройки, от которых будут зависеть, какое именно приложение будет собираться, что помимо кода оно будет содержать и многое другое. Пока что я не буду забивать тебе голову что там есть за настройки и зачем они нужны. Все эти вещи Xcode хранит в проектах.

Проект Xcode (Xcode project) это набор листингов кода, настроек, дополнительных ресурсов (изображений, строк переводов на разные языки и прочего), настроек публикации прилоежния в app store.

Из одного проекта можно даже собирать разные приложения, но опять же, не стоит пока об этом сильно задумываться. На данном этапе можно считать что Xcode проект это и есть приложение, которые мы разрабатываем и запускаем.

Как создать проект

Это можно сделать в Xcode, нажав на кнопку «Create a new project» на стартовом экране. Если ты уже создавал проект ранее, то его можно увидеть в списке последних открытых проектов в правой части экрана.

Create a new project

Какой тип проекта выбрать.

Xcode предлагает множество разных стартовых шаблонов для проекта. От выбора шаблона будут зависеть начальные настройки. И в большинстве случаев, достаточно выбрать правильный стартовый шаблон, чтобы не задумываться о настройках вообще.

Как я уже сказал, изучать язык и основы программирования лучше всего на приложении для командной строки — «Command line Tool». Я рекомендую именно его, потому что:

  1. в этом варианте доступны все возможности IDE в том числе сборка, запуск и отладка приложения с помощью дебаггер (о нем я расскажу позже)
  2. приложение будет запускаться на компьютере без симулятора iPhone, а значит быстрее и с меньшим потреблением оперативной памяти, что важно на слабых компьютерах
  3. там не будет ничего лишнего, чтобы отвлекало от обучения

Для того чтобы создать проект с типом «Command line Tool» переключись на вкладку «macOS» и выбери соответствующую кнопку.

Create a new project

Нужно заполнить базовую информацию

В открывшейся форме нужно указать:

Create a new project

Нужно выбрать где хранить проект

Осталось просто выбрать папку, где будет храниться проект. В целом нет никакой разницы, какую папку выбрать, но опять же рекомендую папку название которой не содержит пробелов и набран латиницей (аглийскими буквами).

Если ты не знаешь что такое git, проверь что галочка «create git repository on my mac» не установлена. В прочем, даже если ты знаешь что это такое, рекомендую создать git репозиторий самостоятельно, после создания проекта.

Create a new project

Проект создан.

Готово. Ты создал первый проект, осталось совсем немного до того момента когда мы начнем писать код.

Название проектов, папок и всего прочего

В этой статье я пару раз упоминал, о том что не стоит в названии проекта и папки использовать кириллицу (русские буквы) и пробелы. Вместо этого нужно использовать латиницу (английские буквы) и нижнее подчеркивание. Настоятельно рекомендую следовать этому правилу при именовании всего что имеет отношения к разработке. Потому что иначе ты будешь регулярно сталкиваться с различного рода проблемами.

Так например некоторые вспомогательные программы отказываются иметь дело с неправильно названными проектами и просто сообщают о неизвестной ошибке.

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

Если ты не знаешь английского, то можно воспользоваться переводчиком или даже писать на транслите (russkie slova, angliskimi bukvami).

Хорошо

SomeFile
Some_File
fome_file
kakoi_to_fail
users/you_name/develop/my_awesome_app/

Плохо

Some File
Какой то файл
users/Вася Пупкин/Разработка/Мое супер приложение/
users/Вася Пупкин/Разработка/my_awesome_app/

Установка и настройка Xcode

Что такое Xcode

Xcode это программа для разработки приложений. В основном для iPhone, iPad, MacOS. Реже используется для разработки других приложений. Xcode это не просто реактор кода, это IDE (айдэе) (Integrated development environment) интегрированная среда разработки. В ней можно писать код на разных языках програмирования, а так же:

Можно ли писать программы для iPhone без Xcode

И да и нет. У нас есть дургие IDE, например AppCode. Но они не пользуются особой популярность, имеют некоторые проблемы и платные. Технически можно написать приложение даже в блокноте. Но при этом прийдется выполнить много сложных и не очевидных действий для того что бы настроить сборку приложения и запустить его. Но, в любом случае на компьютере должен быть установлен Xcode.

На этом курсе я буду использовать только Xcode.

Платный ли Xcode

Нет, он полностью бесплатный

Нужно ли мне еще что нибудь кроме Xcode

В целом одного Xcode достаточно что бы написать любое приложение под iOS. Но есть множество других программ которые упрощают разработку, о них я расскажу позже.

Для установки Xcode нужен apple id

AppleID это учетная запись apple. Если вы активно используете iPhone, iPad или MacOS она у вас уже есть. В противном случае нужно ее зарегистрировать используя [эту официальную инструкцию](https://support.apple.com/en-ca/HT204316

Как установить Xcode

Есть два способа: установить через официальный магазин приложений или скачать с сайта developer.apple.com Я рекомендую устанавливать Xcode из официального магазина приложений. Это удобнее и проще.

Загрузка с сайта обычно происходит быстрее чем из магазина, но не существено. И к этому способу прибегают либо если очень торопятся, либо что бы иметь на компьютере две и более версий xcode. Это нужно не часто.

Как установить Xcode через официальный магазин приложений

Для начала нужно открыть магазин.

Для этого нажите на иконку яблока на панели задачь в верхнем левом углу. Нжмите в открывшемся меню на пункт “AppStore..”.

Найдите Xcode в магазине

Для этого в поисковой строке, расположенной слева вверху, введите “Xcode” и нажмите “enter”.

Загрузите Xcode

Для этого найдти в результах поиса Xcode и нажмите на кнопку “Загрузить”. На моем скришоте там находится кнопка “Открыть”, потому что у меня Xcode уже установленю

Дождитесь окончания загрузки и установки

После окончания загрузки, установка прозойдет автоматически. Рекомендую запастись терпением, это длительный процесс и может занимать до 6 часов времени.

Как скачать Xcode с официального сайта

Скачайте последнюю версию

Зайдите на сайт по url — https://developer.apple.com/download/applications/. Нажмите на ссылку “Download xcode …” и дождитесь загрузки архива.

Установите Xcode из архива

Найдите файл архива в папке загрузок и кликните по нему два раза мышкой. Начнется процесс распаковки и установки.

В Xcode обязательно нужно авторизоваться

Xcode требует авторизации под вашим appleID. Отдельную учетную запись регистировать не нужно.

Откройте Xcode

Для этого запустите Lauchpad.

Найдите среди программ иконку Xcode и запустите ее двойным кликом мыши.

Откройте настройки

В меню, в левом верхнем углу, нажмие на пункт “Xcode” и выберете пункт “Настройки”.

Добавьте аккаунт

В открывшемся окне перейдите на вкладку “Account” и нажмите кнопку “+” в левой нижней части экрана.

Выберете пункт “Apple ID”

Введите данные своей учетной записи

Оставлось только ввести вашь логин и пароль от AppleId. Теперь вы готовы к созданию первых приложенийю

Как правильно проходить этот курс

Часто сталкиваюсь с непониманием как проходить курс. Поэтому постарался собрать здесь основные вопросы, а также рассказать об основных проблемах с которыми сталкиваются слушатели курса.

Структура курса

Курс разделен на три части: основы разработки, регулярные знания, тайные знания

Основы разработки

Данный раздел рассчитан на людей которые не имеют никакого опыта в программировании. Но тем не менее разбираться в компьютере на уровне пользователя необходимо.

В первой половине модуля, я даю не столько знания iOS разработки, сколько разработки в целом. Ты познакомишься с базовыми концепциями программирования: переменными, коллекциями, операторами, управлением потоком, функциями и классами. Разберешься с тем что это такое, зачем оно может понадобиться и как этим пользоваться. Так же ты ознакомимся с основными инструментами iOS разработчика. Xcode, git, отладчик, консоль.

Во второй половине, ты разберешься с основами создания приложений под iOS. При этом произойдет резкий скачок сложности. Потому что помимо основных концепций разработки в целом, придется изучать готовые библиотеки, например SwiftUI.

Регулярные знания.

Этот блок будет идти больше года и состоять из отдельных кусочков. Каждый такой кусочек будет посвящен одному из аспектов разработки, например языку, UIKit (Библиотека для создания графического интерфейса), GCD (Библиотека для организации паралельных вычеслений) и так далее. В рамках этих кусочков, будут как простые так и сложные материалы.

Тайные знания

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

Пометки

Каждый урок будет иметь приблизительную маркировку сложности:

Важно — маркировка приблизительная, то есть расставляется на основе моих субъективных ощущений. Не надо переживать если не понял что то помеченное как “Джун” и наоборот радоваться если все понятно в уровне “Синьор”.

Кривая сложности

Не очень очевидно, но процесс изучения iOS разработки, как и в целом другой разработки имеет не равномерную сложность.Дело в том, что для того что бы создать даже простое мобильное приложение, нужно использовать множество незнакомых до этого веще разом. Обычно в этот момент людям кажется, что это слишком сложно и бросают. Но сдаваться не нужно. Нужно просто больше времени посвятить обучению основных вещей и только потом двигаться дальше.

Типичные контрольные точки:

Основные советы

По порядку

Просматривать уроки лучше всего по порядку.

Не паниковать

Во время обучения, часто будут возникать ситуации когда ничего не понятно. Не нужно думать что дело в тебе. С этим сталкиваются все. Кому то обучение дается проще, кому то сложнее, но никто не понимает все с первого раза.

Уделять практике и теории одинаковое количество времени

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

Не стоит бежать вперед

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

Лучшая стратегия продолжать смотреть новые в видео, но не стараться досконально в них разобраться. Вместо этого лучше прикладывать усилия к тому чтобы понять более ранние уроки.

Повторение мать учения

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

Нужно учится искать информацию самостоятельно

Каким бы подробным не был мой курс знаний в программировании во много раз больше. Поэтому необходимо искать информацию самостоятельно.

Очень рекомендую читать документацию, научиться пользоваться встроенной справкой в xcode и подружиться со stackoverflow. Все это можно использовать и как справочник если что то вылетело из головы и как учебник и даже как источник решения конкретной проблемы.