Простые синтаксические приёмы в Swift

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

В этой статье — несколько практических приёмов и особенностей Swift, которые помогают писать код проще, короче и понятнее. Здесь не будет абстрактной теории — только реальные примеры, которые можно сразу применять в проектах: от сопоставления с шаблоном и работы с optional до безопасной обработки строк и чисел. Если вы хотите, чтобы ваш Swift-код выглядел аккуратно и «по-свифтовски», эти советы точно пригодятся.

1. Паттерны читаются лучше, чем логика

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

if x == 0 || x == 1 || x == 2 {
    
}

Используйте синтаксис сопоставления с шаблоном в операторе switch следующим образом:

switch x {
case 0...2:
      // execute code...
default:
    break
}

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

2. Сопоставление опциональных значений без распаковки

Как мы все знаем, опциональные значения могут иметь значение или быть равными nil.

var age: Int? = 25  
var score: Int? = nil

Большинство разработчиков разворачивают optional данные следующим образом:

if let number = value {
    print(number)
} else {
    print("No value")
}

Это хорошо, но Swift предоставляет и другой способ сделать это.

В Swift Optional — это просто перечисление, которое определяет Optional следующим образом:

// this is an inbuilt code, no need to write it.
enum Optional<T> {
    case some(T)
    case none
}

Давайте развернем optional данные с помощью варианта some перечисления:

func getResult(){
    
    let value: Int? = 10
    
    switch value {
    case .some(let number):
        print("Number is \(number)")

    case .none:
        print("No value")
    }
}

В первом случае, если значение является любым числом, будет выполнен соответствующий case, в противном случае, будет применен второй case.

3. Используйте _ для явного игнорирования значений

_ (подчеркивание) означает игнорирование или безразличие к значению.

Предположим, у нас есть такое перечисление:

enum ApiResult {
    case success(data: String)
    case failure(error: String)
}

Нам не нужны значения data и error; мы хотим только проверить, был ли запрос успешным или нет.

Тогда мы можем использовать _ (подчеркивание) вместо data и error следующим образом:

func CheckResponse(result:ApiResult){
    
    switch result {
    case .success(_):
        print("Request succeeded")
    case .failure(_):
        print("Request failed")
    }
}

Если вас интересуют значения, пишите так:

func CheckResponse(result:ApiResult){
    
    switch result {
    case .success(let data):
        print("Request succeeded \(data)")
    case .failure(let error):
        print("Request failed \(error)")
    }
}

4. Сопоставление нескольких шаблонов в одном Case

Если несколько шаблонов дают одинаковый результат, лучше объединить их в один Case следующим образом:

enum Direction {
    case NORTH
    case SOUTH
    case EAST
    case WEST
}

func checkDirection(direction:Direction){
    
    switch direction {
    case .NORTH,.SOUTH:
        print("Vertical Direction")
        
    case .EAST, .WEST:
        print("Horizontal Direction")
    }
}

Как видите, «Север» и «Юг» имеют одну логику, а «Восток» и «Запад» — другую, поэтому поместите их в одинаковые кейсы.

5. Сопоставление с шаблоном с помощью условия WHERE

WHERE означает добавление дополнительного условия; если оно истинно, то будет выполнено условие.

Давайте разберемся на примере:

switch value {
    case let x where x > 100:
        print("Large number")
        
    case let x where x < 0:
        print("Negative number")
        
    default:
        print("Normal")
}

Здесь, в операторе switch, мы добавили условие where, которое проверяет дополнительные условия.

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

switch value {
case let x:
    if x > 100 {
        print("Large number")
    } else if x < 0 {
        print("Negative number")
    } else {
        print("Normal")
    }
}

Это делает код странным и затрудняет его чтение.

6. Подстрока без утечек памяти

Представьте, что у нас есть строка:

let text = "Hello, Swift"

Теперь возьмём часть этой строки:

let sub = text.prefix(5) // "Hello"

sub — это не новая строка; она указывает на исходную строку (текст).

Исходная строка (text) останется в памяти, пока вы её не освободите.

Swift не может освободить исходную строку (text), потому что sub всё ещё зависит от неё.

Это может привести к утечке памяти.

Чтобы избежать этого, используйте следующий способ:

let text = "Hello, Swift"
let sub = text.prefix(5)
let safeString = String(sub)

Функция string(sub) создает новую строку и копирует в нее текст «Hello».

Исходная строка (текст) теперь будет освобождена из памяти, что предотвратит утечки памяти.

7. Необработанная строка

Когда нам нужно записать данные JSON, мы обычно делаем это так:

let userData = "{\"name\":\"Jayant\"}"

Это приемлемо, но не очень читабельно и может вызвать путаницу.

Лучше сделать так:

let userData = #"{"name":"Jayant"}"#

Это гораздо более читабельно.

8. Безопасное преобразование строк в числа

Вот как можно безопасно преобразовать строку в число:

let value:String? = "123"

if let number = Int(value) {
    print(number + 10)
}

Этот код преобразует строку в целое число и выведет результат.

Если значение не является числом, блок if не будет выполнен.

Избегайте принудительного развертывания строк таким образом:

print(Int(value)! + 10) // this may cause crash

Если значение не является числом, это может привести к сбою.

Спасибо, что дочитали до конца.

Источник