Преобразование типов

Swift — язык со строгой типизацией, но он предоставляет способы преобразования между типами:

let integerNumber = 42
let doubleNumber = Double(integerNumber) // 42.0

let piValue = 3.14
let integerPi = Int(piValue) // 3 (отбрасывает дробную часть)

let stringNumber = "123"
if let number = Int(stringNumber) {
    print("Преобразованное число: \(number)")
} else {
    print("Невозможно преобразовать в число")
}

Содержимое статьи:

Основные операции с данными

Арифметические операции

Для операций с данными есть операторы:

  1. + сложение
  2. — вычитание
  3. * умножение
  4. / деление
  5. % остаток от деления
let sum = 5 + 3 // 8
let difference = 10 - 4 // 6
let product = 2 * 6 // 12
let quotient = 20 / 4 // 5
let remainder = 22 % 5 // 2 (остаток от деления)

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

Swift предоставляет составные операторы присваивания, которые объединяют операцию с присваиванием:

  • +=: Сложение и присваивание
  • -=: Вычитание и присваивание
  • *=: Умножение и присваивание
  • /=: Деление и присваивание
  • %=: Остаток от деления и присваивание

Примеры использования:

var number = 10
number += 5 // Теперь number равно 15
number -= 3 // Теперь number равно 12
number *= 2 // Теперь number равно 24
number /= 4 // Теперь number равно 6
number %= 4 // Теперь number равно 2 (остаток от деления 6 на 4)

Операции со строками

Строки можно объединять используя оператор +

Есть несколько способов сложения строк, рассмотрим ниже примеры:

//Сложение строк при помощи оператора +
let firstName = "Иван"
let lastName = "Иванов"
let fullName = firstName + " " + lastName // "Иван Иванов"

//Создание объекта типа String
let greeting = "Привет"
let repeatedGreeting = String(repeating: greeting, count: 3) // "ПриветПриветПривет"

//Конкатенация строки
let name = "Swift"
let programmingLanguage = "Я изучаю \(name)" // "Я изучаю Swift"

Логические операции

Никакой современный язык программирования не обходится без логических операций. Логические операции — это те операции, которые возвращают результатом булево значение (true/false).

Есть следующие варианты логических операторов:

  1. &&: Логическое И
  2. ||: Логическое ИЛИ
  3. !: Логическое НЕ

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

Логический оператор НЕ ставится перед выражением и меняет его значение с true на false и наоборот. Рассмотрим несколько примеров ниже:

let isTrue = true
let isFalse = false

let andResult = isTrue && isFalse // false
let orResult = isTrue || isFalse // true
let notResult = !isTrue // false

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

Swift предоставляет стандартный набор операторов сравнения, которые возвращают значение типа Bool:

  • ==: Равно
  • !=: Не равно
  • >: Больше
  • <: Меньше
  • >=: Больше или равно
  • <=: Меньше или равно

Примеры использования:

let a = 5
let b = 10

print(a == b) // false (5 равно 10)
print(a != b) // true (5 не равно 10)
print(a > b)  // false (5 больше 10)
print(a < b)  // true (5 меньше 10)
print(a >= b) // false (5 больше или равно 10)
print(a <= b) // true (5 меньше или равно 10)

let name1 = "Alice"
let name2 = "Bob"

print(name1 == name2) // false
print(name1 != name2) // true
print(name1 > name2)  // false (лексикографическое сравнение)
print(name1 < name2)  // true

// Сравнение с использованием переменных разных типов
let intValue = 5
let doubleValue = 5.0

print(intValue == Int(doubleValue)) // true
// Прямое сравнение Int и Double не допускается без явного приведения типов

Когда мы сравниваем строки с помощью операторов <, >, <=, >=, Swift использует лексикографическое сравнение. Это метод сравнения, который основан на алфавитном порядке символов.

Вот как это работает:

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

В случае с «Alice» и «Bob»:

Так как «A» < «B» в Unicode, Swift определяет, что «Alice» < «Bob».

Первый символ «A» в «Alice» имеет меньшее числовое значение в Unicode, чем «B» в «Bob».

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