Переменные в Swift - Start iOS | Уроки по iOS разработке

Мы написали наше первое приложение и кажется что разработка для iOS это просто. Но в «Привет, Мир!» было слишком мало кода и хотелось бы для начала понять как создаются переменные в Swift. Как раз этим мы и займемся в данном уроке.

Для начала хотелось бы рассказать, что же за язык программирования — Swift. В книге «The Swift Programming Language» Apple описывает его следующим образом:

Swift — это новый язык программирования для IOS, OS X, watchOS и tvOS приложений, который опирается на лучшие традиции C и Objective-C, без ограничений совместимости C. Swift принимает безопасные модели программирования и добавляет современные функции, чтобы сделать программирование проще, более гибким и более увлекательным. — перевод WOOPSS.com

Несмотря на то, что язык программирования (далее ЯП) вышел в свет всего в 2013 году (к примеру, язык Objective-C был создан еще в 1983), он уже покорил миллионы iOS разработчиков, которые, в свою очередь, начинают потихоньку отказываться от Obj-C.

Внимание! Данный урок рассчитан на тех, кто имеет хотя бы отдаленное представление о программировании в целом, но не знает синтаксис языка Swift. В прочем, если Вы новичок в програмировании, мы советуем изучить этот урок, а также перейти к изучению книги «The Swift Programming Language» от компании Apple.

Для удобства изучения базовых вещей в Swift, откройте окно приветствия Xcode (нажмите shift+cmd+1 или с помощью контекстного меню — Window->Welcome to Xcode) и создайте новый Playground подобно тому, как мы создавали новый проект в знакомстве с Xcode. Playground представляет собой интерактивную среду кодирования для языка Swift, которая оценивает каждый созданный объект, переменную, функцию и тут же отображает результаты, без необходимости создания проекта.

Откройте только что созданный плейграунд и Вы увидите следующий код:

//: Playground - noun: a place where people can play

import UIKit

var str = "Hello, playground"

//: Playground - noun: a place where people can play

import UIKit

var str = "Hello, playground"

Apple тоже чтит традицию программирования «Hello World». В левой секции плейграунда располагается редактор, в котором разработчик пишет код. В правой части сразу же отображается текущее состояния переменных и результаты работы функций, вычислений и т.д.

Переменные и функции в Swift

Окно Playground

Строковые переменные

В Swift есть три основных вида переменных — числа, строки и булевы переменные. Для их объявления используется оператор var, а для создания константы — let. Добавьте следующий код после стандартной заготовки Apple:

let myName = "My name is"
var name: String

name = "WOOPSS.com"

let myName = "My name is"

var name: String

name = "WOOPSS.com"

В строке #1 мы создаём константу под именем myName и тут же задаём ей значение «My name is». Мы больше не сможем изменить её значение. На следующей строке мы создаём переменную с именем name и даём компилятору понять, что в будущем это будет строковый объект (String). В следующей строке уже задаём ей значение. Мы можем изменять эту переменнцю в любой строчке кода, так как она была создана с помощью оператора var.

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

let myNameIs = myName + " " + name
let myNameInOneString = "\(myName) \(name) in different way"

1 2	let myNameIs = myName + " " + name let myNameInOneString = "\(myName) \(name) in different way"

Здесь мы создаём две строковые константы двумя способами. Первый способ — это конкантенация, которая встречается в других ЯП. Здесь с помощью оператора «+» строки соединяются воедино.

Во втором способе мы обернули наши переменные внутри строки в оператор «\( )». Здесь можно указывать не только строковые виды данных, но также числа и булевы переменные — компилятор сам их преобразует в строковый тип без каких либо танцев с бубном от разработчика.

Также Вы можете создавать строковые переменные с помощью инициализации класса String. Ниже приведены несколько вариантов:

// Создание строковой переменной с определенным форматом
// На примере других стрингов
let stringWithFormat = String(format: "%@ %@", myName, name)

// На примере целочисленной переменной
let stringWithInt   = String(format: "Int value: %i", 26)

// На примере численной переменной с плавающей запятой
let stringWithFloat = String(format: "Float value: %f", 22.1345)

// Создание строковой переменной с определенным форматом

// На примере других стрингов

let stringWithFormat = String(format: "%@ %@", myName, name)

// На примере целочисленной переменной

let stringWithInt = String(format: "Int value: %i", 26)

// На примере численной переменной с плавающей запятой

let stringWithFloat = String(format: "Float value: %f", 22.1345)

Одним из преимуществ языка Swift является возможность дополнять строковые переменные с помощью оператора «+=«, как это делается с числовыми данными. Добавьте следующий код и посмотрите что из этого получится:

name += " Start iOS - Уроки по разработке iOS приложений"

1	name += " Start iOS - Уроки по разработке iOS приложений"

Численные переменные

Известно, что численные переменные разбиваются на подгруппы: целочисленные и числа с плавающей запятой. В Swift чаще других используется следующий ряд численных типов:

Int — это целые числа без дробной компоненты, такие как 42 и -23.
Double — это числа с дробным компонентом, такие как 3.14159, 0,1, и -273.15. Представляет собой 64-битное число с плавающей точкой.
Float — также дробные числа, но они представляют с собой 32-битное число с плавающей точкой.

Ниже показан пример инициализации таких чисел:

let float: Float    = 0.8999999
let double: Double  = 0.89999999
let int: Int        = 1

let float: Float = 0.8999999

let double: Double = 0.89999999

let int: Int = 1

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

// При создании переменной с точкой компилятор определит тип как Double
let pi = 3.14159

// При создании целочисленной переменной - определит тип как Int
let randomInt = 22

// При компановке целочисленной и переменной с плавающей точкой - определит как Double, 
// так как последний результат будет также с плавающей точкой
let myValue = 3 + 0.14159

// При создании переменной с точкой компилятор определит тип как Double

let pi = 3.14159

// При создании целочисленной переменной - определит тип как Int

let randomInt = 22

// При компановке целочисленной и переменной с плавающей точкой - определит как Double,

// так как последний результат будет также с плавающей точкой

let myValue = 3 + 0.14159

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

// Здесь в результате хотим получить Int
let resultInt = Int(pi) + randomInt

// А здесь Double
let resultDouble = pi + Double(randomInt)

// Здесь в результате хотим получить Int

let resultInt = Int(pi) + randomInt

// А здесь Double

let resultDouble = pi + Double(randomInt)

В первом случае переменная resultInt будет равна 25, так как компилятор автоматически отбросит Всё что после запятой у pi. Во втором же случае мы получим 25.14159, так как переменная resultInt была преобразована в тип Double.

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

var myInt = 23

// Первый способ модификации одной и той же переменной на примере суммы
myInt = myInt + 23
// Более упрощенный способ модификации той же переменной. Является аналогом способа #1
myInt += 23

// Вычитание
myInt = myInt - 23
myInt -= 23

// Умножение
myInt = myInt * 2
myInt *= 2

// Деление
myInt = myInt / 2
myInt /= 2

var myInt = 23

// Первый способ модификации одной и той же переменной на примере суммы

myInt = myInt + 23

// Более упрощенный способ модификации той же переменной. Является аналогом способа #1

myInt += 23

// Вычитание

myInt = myInt - 23

myInt -= 23

// Умножение

myInt = myInt * 2

myInt *= 2

// Деление

myInt = myInt / 2

myInt /= 2

Заметьте! Если при инициализации переменной Вы укажите число в двойных кавычках (к примеру, «22») — компилятор автоматически воспримет это строковым типом. Тогда при расчетах Вам прийдется преобразовывать её в численный тип.

Логический (булевы) тип

Swift имеет базовый логический тип, называемый Bool. Логические значения могут быть только истинными или ложными. Соответсвенно Swift обеспечивает две логические постоянные значения: true (истина) и false (ложь).

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

// Переменная содержит значение true
// компилятор выведет в лог то что внутри скобок
if orangesAreOrange
{
    print("Wow, I love oranges!")
}

// Здесь же условие ложно, поэтому Вы ничего не увидите в логе
// и компилятор не войдет внутрь скобок
if tomatosAreBrown
{
    print("How is it possible?")
}

// Переменная содержит значение true

// компилятор выведет в лог то что внутри скобок

if orangesAreOrange

{

print("Wow, I love oranges!")

}

// Здесь же условие ложно, поэтому Вы ничего не увидите в логе

// и компилятор не войдет внутрь скобок

if tomatosAreBrown

{

print("How is it possible?")

}

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

var foo = 22

// foo и вправду равно 22, поэтому компилятор зайдет внутрь скобок
if foo == 22
{
    foo *= 2
}

// Сейчас foo = 44, поэтому компилятор пропустит скобки if и перейдет в тело else
if foo == 22
{
    print("It's not possible")
}
else
{
    print("That's right. foo = \(foo)")
}

var foo = 22

// foo и вправду равно 22, поэтому компилятор зайдет внутрь скобок

if foo == 22

{

foo *= 2

}

// Сейчас foo = 44, поэтому компилятор пропустит скобки if и перейдет в тело else

if foo == 22

{

print("It's not possible")

}

else

{

print("That's right. foo = \(foo)")

}

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

Массивы и словари

По-мимо простых переменных, Swift еще поддерживает объекты типа array (массив) и dictionary (словарь). Оба объекта являются «контейнерами», которые могут хранить любое количество переменных и других объектов внутри себя.

Для инициализации массива необходимо объявлять переменные «обернув» их в квадратные скобки ([]). Чтобы получить вложенный объект нужно сослаться на его индекс. Ниже показан пример объявления массива и способ получить нужный элемент из него:

// Array
// Объявляем массив, содержащий строковые переменные
var myArray = ["Apple", "Orange", "Tomato", "Potato", "Cherry"]

// Создаём новую переменную и в качестве значения
// берем объект из массив под индексом #1
let orange  = myArray[1]

// Добавляем нувую переменную в массив
myArray += ["Blackberry"]

// Печатаем переменную из массива в лог
print(myArray[5])

// Array

// Объявляем массив, содержащий строковые переменные

var myArray = ["Apple", "Orange", "Tomato", "Potato", "Cherry"]

// Создаём новую переменную и в качестве значения

// берем объект из массив под индексом #1

let orange = myArray[1]

// Добавляем нувую переменную в массив

myArray += ["Blackberry"]

// Печатаем переменную из массива в лог

print(myArray[5])

Вот как можно объявить пустой массив (к примеру, Вам может понадобиться хранить в нем объекты в будущем):

// Создаём пустой массив со строковыми переменными
let emptyArray = [String]()

1 2	// Создаём пустой массив со строковыми переменными let emptyArray = [String]()

Вместо типа String можно указывать любой тип, который Вы захотите добавить. Если же Ваш массив должен хранить несколько типов данных или Вы не знаете какой тип получите (к примеру, когда получаете ответ от сервера), то вместо String можно указать AnyObject.

Главным отличием словарей от массивов заключается в том, что значения в нём хранятся на по индексам, а по ключам. Рассмотрим пример ниже:

// Dictionary
// Объявляем пустой словарь
// String - ключ, AnyObject - любой объект
var emptyDictionary = [String : AnyObject]()

// Добавим 2 объекта под ключами "Start" и "Year"
emptyDictionary["Start"] = "iOS"
emptyDictionary["Year"]  = 2016

// Получаем объект под ключем "Start"
let dictValue = emptyDictionary["Start"]

// Объявляем словарь с заранее заданными объектами
// Структура массива: [Ключ : Значение]
// Ключ - String, Объект - String
let myDictionary = [
    "Site"  : "Start iOS",
    "Theme" : "Переменные в Swift",
    "Group" : "WOOPSS.com"
]

// Также получим объект под ключем "Theme"
let theme = myDictionary["Theme"]

// Dictionary

// Объявляем пустой словарь

// String - ключ, AnyObject - любой объект

var emptyDictionary = [String : AnyObject]()

// Добавим 2 объекта под ключами "Start" и "Year"

emptyDictionary["Start"] = "iOS"

emptyDictionary["Year"] = 2016

// Получаем объект под ключем "Start"

let dictValue = emptyDictionary["Start"]

// Объявляем словарь с заранее заданными объектами

// Структура массива: [Ключ : Значение]

// Ключ - String, Объект - String

let myDictionary = [

"Site" : "Start iOS",

"Theme" : "Переменные в Swift",

"Group" : "WOOPSS.com"

]

// Также получим объект под ключем "Theme"

let theme = myDictionary["Theme"]

На этом наш урок подошел к концу. Пишите в комментариях, если Вам что-либо было не понятно, а также следите за обновлениями на ресурсе Start iOS — Уроки по разработке iOS приложений.

Строковые переменные

Численные переменные

Логический (булевы) тип

Массивы и словари

Vladislav Kovalyov