Что такое дженерики и зачем они нужны?

Дженерики — это мощный инструмент в арсенале любого разработчика программного обеспечения, работающего с строго типизированными языками, такими как Java, C#, TypeScript и другими. Они позволяют писать код, который можно использовать повторно, он более гибкий и, самое главное, типобезопасный. Но прежде чем углубляться в детали, давайте разберёмся на простом примере.

Представьте, что вы повар, которому нужно приготовить блюдо, которое понравится всем. Звучит невозможно, правда? Но что если бы вы могли создать рецепт, который работал бы с любыми ингредиентами? Именно это и делают дженерики для вашего кода: они делают его достаточно универсальным, чтобы работать с любым типом, обеспечивая при этом безопасность и эффективность.

Основы дженериков

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

class GenericStack<T> {
    private stack: T[] = [];

    public push(item: T) {
        this.stack.push(item);
    }

    public pop(): T | undefined {
        return this.stack.pop();
    }
}

// Использование GenericStack со строками
const stringStack = new GenericStack<string>();
stringStack.push("Hello");
console.log(stringStack.pop()); // Вывод: Hello

// Использование  GenericStack с числами
const numberStack = new GenericStack<number>();
numberStack.push(42);
console.log(numberStack.pop()); // вывод: 42

В этом примере GenericStack<T> — это класс, который может работать с любым типом T. Это означает, что вы можете создать стек строк, чисел или других типов без дублирования кода.

Обеспечение безопасности типов

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

const arr = new Array<string>();
arr.push("Hi There"); // Всё в порядке
// arr.push(123); // Это вызовет ошибку компилятора

В этом примере массив Array<string> гарантирует, что в массив можно добавить только строки. Если вы попытаетесь добавить число, компилятор TypeScript выдаст ошибку ещё до запуска кода.

Избегание упаковки и распаковки

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

// Без дженериков
ArrayList list = new ArrayList();
list.Add(42); // Происходит упаковка
int value = (int)list; // Распаковка

// С дженериками
List<int> genericList = new List<int>();
genericList.Add(42); // Никакой упаковки
int value = genericList; // Никакой распаковки

Используя List<int>, вы избегаете накладных расходов на упаковку и распаковку, делая свой код более эффективным.

Условное поведение на основе типа

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

class SmartPrinter<T> {
  print(data: T) {
    if (typeof data === "string") {
      console.log(`Я собираюсь напечатать: ${data.toUpperCase()}`);
    } else {
      console.log(`Я собираюсь напечать ${typeof data}`);
    }
  }
}

const stringPrinter = new SmartPrinter<string>();
stringPrinter.print("Hello"); // Выводит: Я собираюсь напечатать HELLO

const numberPrinter = new SmartPrinter<number>();
numberPrinter.print(42); // Выводит: Я собираюсь напечатить number

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

Рефакторинг с использованием дженериков

Дженерики особенно полезны при рефакторинге кода. Вот сценарий, в котором вы можете использовать дженерики для абстрагирования типов данных:

// До использования дженериков
class PersonStack {
    private stack: Person[] = [];

    public push(person: Person) {
        this.stack.push(person);
    }

    public pop(): Person | undefined {
        return this.stack.pop();
    }
}

class TeacherStack {
    private stack: Teacher[] = [];

    public push(teacher: Teacher) {
        this.stack.push(teacher);
    }

    public pop(): Teacher | undefined {
        return this.stack.pop();
    }
}

// После использования дженериков
class GenericStack<T> {
    private stack: T[] = [];

    public push(item: T) {
        this.stack.push(item);
    }

    public pop(): T | undefined {
        return this.stack.pop();
    }
}

const personStack = new GenericStack<Person>();
const teacherStack = new GenericStack<Teacher>();

С помощью дженериков вы устраняете необходимость в дублировании кода и делаете свои классы более гибкими и удобными в обслуживании.

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