Урок 2. Базовые типы данных

1 Ноября 2022

Swift имеет несколько базовых типов:

1. String (текстовая строка)

2. Int (целое число)

3. Float (32-битное число с плавающей точкой)

4. Double (64-битное число с плавающей точкой для более длинных переменных)

5. Bool (логическое значение «true» или «false»).

6. Character

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

Это единственное что в языке Swift пишется с большой буквы.

Прописать тип явно – это тот случай когда мы после имени ставим двоеточие и прописываем тип данных: let name: String, let number: Int … Переопределение свойства – задаем новое значение для свойства, которое ранее уже было инициализировано. Инициализировать свойство – присвоить значение свойству в момент его создания.

Тип String

Мы уже познакомились с типом String когда присвоили текстовое значение свойству:
				
					let nameOfNeighbor = "Tom"
				
			
Swift знает что свойство nameOfNeighbor содержит строку, поскольку мы поместили ее значение в кавычки. Когда мы присваиваем нашему свойству значение и записываем его в кавычках, система понимает, что данная константа имеет тип String, и мы даже можем в этом убедится. Зажмите option  и наведите на свойство, после того как увидите вопросительный знак, кликайте по свойству. Перед вами откроется следующее окно:

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

Что означает “Я не могу определить тип данных”. Системе нужно понимать что за тип данных она будет хранить в ячейке памяти, для того, что бы работать с информацией более эффективно. Когда мы присваивали значение свойству, то система смотрела на значение и понимала какой тип данных хранится в ячейки, но если не присвоить значения, то система не сможет определить тип свойства. В этом случае его придется задать явно:
				
					let country: String
				
			

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

Обратите внимание на синтаксис, перед двоеточием не ставится пробела, а после только один! 

Не инициализированное свойство мы не можем никак использовать в коде, система только зарезервировала для этой переменной ячейку в памяти, но не выделила место, а это значит что этого свойства в памяти пока еще нет, и соответсвенно использовать его мы не можем. Давайте посмотрим на примере:
				
					var biggestCountry = "" // 1
let country: String // 2

biggestCountry = country // 3
				
			

1. Мы объявили переменную biggestCountry и инициализировали ее пустой строкой (между кавычек пусто, поэтому это считается пустой строкой).

2. Мы объявили константу country, но никак ее не инициализировали.

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

которая гласит: “Переменная country используется до ее инициализации”. Давайте используем ее после ее инициализации:
				
					var biggestCountry = ""
let country: String
country = "Russia"

biggestCountry = country
				
			

Прежде чем к ней обратиться, мы ее инициализировали и все ошибки нас покинули, а свойство biggestCountry теперь имеет значение “Russia”, вы можете в этом убедится, если запустите компилятор и посмотрите на правую часть окна.

Компилятор читает код с верху вниз, на первой строке мы создаем свойства потом инициализируем свойство country и только потом используем. 

Вы наверняка спросите, как это мы константе country присвоили на следующей строке новое значение, это же вроде не изменяемое свойство? Но никаких противоречий нет, на первой строке мы объявили свойство, но ни как его не инициализировали, то есть по факту у него нет значения, а значит, на второй строке мы его не переопределяем а инициализируем. Конечно, нет смысла на первой строке прописывать не инициализированное свойство, а на следующей его инициализировать. Если вам известно начальное значение, то задавайте его сразу:
				
					var biggestCountry = ""
let country = "Russia"

biggestCountry = country
				
			

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

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

				
					var biggestCountry = ""
var country = ""
				
			

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

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

Тип Integer

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

Давайте все удалим из нашего playground и объявим два свойства:

				
					var country = "Andorra"
var countryArea = 468
				
			

Первое свойство имеет тип данных String, система определила этот тип из значения. Второе свойство имеет тип Intger, то есть целое число, давайте в этом убедимся (option + клик)

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

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

Что я имею в виду:

				
					var country = "Andorra"
var countryArea = 468

countryArea = country
				
			

Код выше выдаст ошибку:

Которая говорит нам что мы не можем присвоить значение типа String, свойству с типом Int

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

				
					var country = "Andorra"
var countryArea = 468

country = 468
				
			

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

Если вы не знаете какое значение присвоить свойству, то по умолчанию можно написать 0, которое в дальнейшем переопределить на реальные данные.

Типы Double и Float

Типы Float и Double в Swift используются для хранения чисел с плавающей запятой. И отличаются они только количеством чисел после запятой. Тип данных Float способен содержать до 6 чисел после запятой, а тип данных Double способен содержать до 15 чисел

Для начала удалим весь код, который вызывает ошибки и оставим только два свойства country и countryArea

				
					var country = "Andorra"
var countryArea = 468

country = "Vatican"

let areaOfSmallestCountry = 0.44
				
			

На четвертой строчке мы переопределили значение переменной country, а на пятой объявили новую константу с значением плавающей точки, давайте посмотрим на его тип данных:

По умолчанию, Xcode, когда видит значение с плавающей точкой, определяет для свойства тип Double

Тип Double может принимать так же целые числа, но в таком случае нужно прописать тип явно:

				
					var country = "Andorra"
var countryArea = 468

country = "Vatican"

let areaOfSmallestCountry = 0.44
var randomArea: Double = 316
				
			

Но в тоже время мы не сможем сделать так:

				
					var country = "Andorra"
var countryArea = 468

country = "Vatican"

let areaOfSmallestCountry = 0.44
var randomArea: Double = 316

randomArea = countryArea
				
			

Если мы запустим компилятор, то мы получим ошибку не соответствия типов данных:

Переменная countryArea является типом Int, а свойство randomArea типом Double, то есть это разные типы данных.

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

Давайте удалим строку, которая вызывает ошибку и перейдем к типу Float.

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

Давайте посмотрим на код который у нас получился. Нас интересует два свойства:

				
					let areaOfSmallestCountry = 0.44
var randomArea: Double = 316
				
			

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

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

Тип Float тоже является числом с плавающей точкой, но как нам создать свойство с этим типом?

Ответ напрашивается сам собой, мы должны прописать тип явно:

				
					let areaOfSmallestCountry: Float = 0.44
var randomArea: Double = 316
				
			

Таким образом наше свойство areaOfSmallestCountry является типа Float. 

 Для чего вообще нужно это разделение на Float и Doubl

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

Компания Apple рекомендует всегда использовать тип Double по умолчанию. 

Если вы не знаете какое значение присвоить свойству, то по умолчанию можно написать 0.0

Тип Boolean

У языка Swift есть базовый тип данных, который используется для хранения значений false и true

				
					var isFederalState = false
				
			

Давайте посмотрим на его аннотацию:

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

На следующих уроках мы познакомимся с ним подробней.

Тип Character

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

Давайте создадим свойство:

				
					let symbol = "$" 
				
			

По умолчанию компилятор определит это свойство как тип String, и если мы хотим что бы это свойство было типа Character, то мы должны тип прописать явно:

				
					let symbol: Character = "$"
				
			

Таким образом мы не сможем прописать в эту строку больше одного символа:

Даже дополнительный пробел будет вызывает ошибку. 

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

Поддержите наш проект, и помогите изменить подход к обучению!

Развивайся вместе с нами

Поддержите наш проект, и помогите изменить подход к обучению!

Address List

Social Networks

Поддержите наш проект, и помогите изменить подход к обучению!