10 главных конструкций языка Swift

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

Мы уже писа­ли про Swift — что уме­ет этот язык и для чего он нужен. Теперь посмот­рим, из чего он состо­ит и как мож­но быст­ро вник­нуть в код на Свифте.

О чём пойдёт речь

Пере­мен­ные

Ком­мен­та­рии

Ввод дан­ных с клавиатуры

Вывод дан­ных в терминал

При­сва­и­ва­ние и сравнение

Услов­ный опе­ра­тор if

Опе­ра­тор мно­же­ствен­но­го выбо­ра case

Цикл с пред­усло­ви­ем for-in

Цик­лы с посту­сло­ви­ем while и repeat-while

Функ­ции

Клас­сы

Объ­ек­ты

🤔 Мы обе­ща­ли 10 кон­струк­ций, но в ито­ге полу­чи­лось 12. Про­сти­те :-)

Переменные

В Swift исполь­зу­ют две основ­ных команды: 

  1. var — для обо­зна­че­ния переменной;
  2. let — для того, что­бы задать константу.

Тип дан­ных мож­но не ука­зы­вать, язык сам раз­бе­рёт­ся, что к чему:

var myVar = 42

let myConst = 42

Если нуж­но ука­зать, что пере­мен­ная долж­на иметь дроб­ную часть, то дела­ют так:

var myVar: Double = 40

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

var s = 20; let q = ‘string’

Комментарии

Ком­мен­та­рии оформ­ля­ют­ся так же, как и в JavaScript — двой­ным слешем:

// привет, это комментарий

Ввод данных с клавиатуры

Что­бы вве­сти дан­ные с кла­ви­а­ту­ры, при­ме­ня­ют коман­ду readLine(). С её помо­щью мож­но вве­сти любые зна­че­ния в какую угод­но пере­мен­ную, если ей подой­дёт то, что мы написали.

// запрашиваем число у пользователя
print("Введите число: ")
// вводим число с клавиатуры
var num = readLine()
// теперь в переменной num хранится то, что мы ввели

Вывод данных в терминал

Для стан­дарт­но­го выво­да дан­ных мож­но исполь­зо­вать коман­ду print() или println(). Они отли­ча­ют­ся тем, что в пер­вой коман­де кур­сор оста­ёт­ся на той же стро­ке, а во вто­рой кур­сор после выво­да перей­дёт на новую строчку.

// После вывода «Привет» курсор останется на этой же строке, сразу после буквы «т»
print("Привет")
// а после этой команды курсор перейдёт на новую строку
println("Это журнал Код")
// в итоге у нас получится надпись «ПриветЭто журнал Код»

Присваивание и сравнение

При­сва­и­ва­ние обо­зна­ча­ет­ся одним зна­ком рав­но, а про­вер­ка на равен­ство — двумя:

// это присваивание
var s = 2
s = 5
// а это — сравнение
s == 1

Ещё есть дру­гие, тоже при­выч­ные всем опе­ра­то­ры сравнения:

  • рав­но (a == b)
  • не рав­но (a != b)
  • боль­ше (a > b)
  • мень­ше (a < b)
  • боль­ше или рав­но (a >= b)
  • мень­ше или рав­но (a <= b)

Коман­ды срав­не­ния чаще все­го исполь­зу­ют­ся в цик­лах и услов­ных операторах.

Условный оператор if

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

// если условие выполняется — выводим сообщение
if team > 50 {
        print("Вы превысили допустимое число команд")
// в противном случае увеличиваем групповой счёт на единицу
} else {
       groupScore += 1
}

Услов­ные опе­ра­то­ры мож­но вкла­ды­вать друг в дру­га сколь­ко угод­но раз, а внут­ри писать сколь­ко угод­но команд. Ино­гда для упро­ще­ния кода исполь­зу­ют опе­ра­тор мно­же­ствен­но­го выбора.

Оператор множественного выбора case

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

let menu = readLine()
switch menu {
// если введена единица
case 1:
    visibleComment = "Пользователь добавлен в список"
// если пользователь ввёл 2 или 3
case 2, 3:
    accessLevel = true
// если ввёл 4
case 4:
    print("Не хватает прав доступа")
// если ввёл любое другое значение
default:
     print("Такой команды нет в меню")
     accessCounr += 1
}

Цикл с предусловием for-in

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

// переменная цикла
var i = 0;
// делаем цикл от 1 до 5, включая 1 и 5
for i in 1...5 {
     // выводим текущее значение переменной цикла
    println(i)
}

Ещё вари­ант — исполь­зо­вать коман­ду where, кото­рая опре­де­ля­ет усло­вия выбор­ки из последовательности:

// берём последовательность от 0 до 10 и используем для цикла только те числа, которые делятся на 2 без остатка
for i in 0...10 where i % 2 == 0 {
    // получается, что на экране будут только чётные числа
    println(i)
}

Циклы с постусловием while и repeat-while

Если мы не зна­ем, сколь­ко раз будет выпол­нять­ся наш цикл, но зна­ем, что пока усло­вие вер­ное, цикл дол­жен рабо­тать, — то в этом слу­чае исполь­зу­ют цикл while:

// переменная цикла
var i = 10
// пока переменная больше ноля — цикл выполняется
while i > 0 {
    // выводим текущее значение переменной
    print(i)
    // уменьшаем значение переменной на единицу
    i -= 1
}

С этим цик­лом есть один нюанс: если усло­вие сра­зу не выпол­ня­ет­ся, то цикл вооб­ще не запу­стит­ся и то, что напи­са­но внут­ри, тоже ни разу не сра­бо­та­ет. Если же нам нуж­но, что­бы цикл выпол­нил­ся как мини­мум один раз, а потом уже запус­кал все про­вер­ки, исполь­зу­ют цикл repeat-while. Он как бы пере­во­ра­чи­ва­ет цикл вверх нога­ми: сна­ча­ла коман­ды, а потом проверка:

// переменная цикла
var i = 10
// сразу запускаем цикл, на первом шаге без проверки
repeat {
    // выводим текущее значение переменной
    print(i)
    // уменьшаем значение переменной на единицу
    i -= 1
// пока переменная больше ноля — цикл продолжает выполняться
} while i > 0

Функции

Как и в боль­шин­стве язы­ков про­грам­ми­ро­ва­ния, в Swift функ­ция может воз­вра­щать какое-то зна­че­ние, а может и рабо­тать сама по себе. Самая про­стая функ­ция выгля­дит так:

func hello(){

    print("Привет, это журнал Код")

}

Эта функ­ция ниче­го не воз­вра­ща­ет, а при вызо­ве hello() про­сто выво­дит на экран нуж­ную фразу. 

Если мы хотим пере­дать в функ­цию какие-то пара­мет­ры, то их нуж­но про­пи­сать в круг­лых скоб­ках при объявлении:

func hello(name: String){

    print("Привет, \(name) ; , это журнал Код")
}
// вызываем функцию
hello(name: "Миша") 
// Привет, Миша, это журнал Код

Что­бы функ­ция воз­вра­ща­ла какое-то зна­че­ние, мы долж­ны ука­зать тип это­го зна­че­ния, напри­мер, что функ­ция вер­нёт стро­ку или число:

func hello(name: String) -> String{
	// возвращаем новую строку с именем внутри
	return("Привет, \(name) ; , это журнал Код")
}
// вызываем функцию  с помощью команды вывода на экран
print(hello(name: "Миша"))
// Привет, Миша, это журнал Код

Классы

Клас­сы опре­де­ля­ют­ся так, как это при­ня­то в ООП — сна­ча­ла идёт назва­ние клас­са, потом пере­мен­ные (свой­ства клас­са) и функ­ции (мето­ды клас­са, если они нужны):

// объявляем новый класс
class User {
    // определяем возраст пользователя по умолчанию
    var age: Int = 18
    // переменная для хранения имени пользователя
    var name: String = ""
    
    // метод внутри класса
    func newUser(){
        print("Это новый клиент, предложите ему бонусную карту")
    }
}

Объекты

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

// создаём объект класса User
// теперь клиент mike — это наш новый объект со всеми свойствами класса
var mike: User = User()
// задаём возраст клиента
mike.age = 22
// и его имя
mike.name = "Миша"
// выводим имя клиента на экран
print(mike.name) 
// вызываем метод класса
mike.new()  
// на экране появится надпись "Это новый клиент, предложите ему бонусную карту"

👉 Если пока не зна­е­те, зачем нуж­ны клас­сы и объ­ек­ты, про­чи­тай­те наш цикл ста­тей про объектно-ориентированное про­грам­ми­ро­ва­ние.

Что ещё

Мож­но почи­тать офи­ци­аль­ную доку­мен­та­цию по Swift на сай­те Apple.com — на английском. 

Или оста­вай­тесь у нас, мы будем рас­ска­зы­вать про тех­но­ло­гии и про­грам­ми­ро­ва­ние на русском 🙂

Текст:

Миха­ил Полянин

Редак­ту­ра:

Мак­сим Ильяхов

Худож­ник:

Даня Бер­ков­ский

Кор­рек­тор:

Ири­на Михеева

Вёрст­ка:

Мария Дро­но­ва

Соц­се­ти:

Олег Веш­кур­цев