В чем разница между строгой и динамической типизациями?

# Строгая (Static) vs Динамическая (Dynamic) типизация

Определение

Строгая типизация — тип переменной проверяется на этапе компиляции. Динамическая типизация — тип проверяется во время выполнения программы.

Строгая типизация (Static Typing)

Тип переменной определяется в момент объявления и не может измениться.

// Java — строгая типизация
int number = 42;        // тип int
String text = "Hello";  // тип String

// Ошибка компиляции — нельзя присвоить String числу
// int value = "123"; // compile error: cannot assign String to int

// Необходимо явное преобразование типа
int value = Integer.parseInt("123");

Преимущества:

• Ошибки находятся на этапе компиляции, а не в runtime
• IDE помогает с автодополнением (знает тип переменной)
• Производительность выше (оптимизация во время компиляции)
• Самодокументирующийся код (ясно какой тип передаём)
• Рефакторинг безопаснее (переименование переменных, изменение сигнатур)

Недостатки:

• Больше кода (нужно везде указывать типы)
• Менее гибко (нельзя быстро передать данные другого типа)
• Медленнее разработка (больше времени на типизацию)

Динамическая типизация (Dynamic Typing)

Тип переменной определяется во время выполнения, можно менять в любой момент.

# Python — динамическая типизация
value = 42          # целое число
value = "Hello"     # теперь строка
value = [1, 2, 3]   # теперь список

# Ошибка будет найдена только при выполнении
result = value + 10 # TypeError: can only concatenate str (not "int") to str

// JavaScript — динамическая типизация
let data = 123;
data = "строка"; // OK
data = { key: "value" }; // OK
data = null; // OK

Преимущества:

• Быстрая разработка (не нужно явно писать типы)
• Гибкость (легко передать разные типы данных)
• Меньше кода (нет описания типов)
• Идеален для прототипирования и скриптов

Недостатки:

• Ошибки типов находятся только в runtime
• Сложнее дебажить (ошибка может проявиться не сразу)
• IDE помощь минимальна (не знает тип до выполнения)
• Медленнее выполнение (нужны проверки типов при выполнении)
• Рефакторинг опаснее (легко сломать что-то незаметно)

Сравнение

Пример с Java (строгая типизация)

public void processData(String input) {
    // input должен быть String — это гарантирует компилятор
    int length = input.length();
    
    // Ошибка компиляции
    // int length = input.length("wrong"); // compile error
}

// Вызов
processData("Hello");      // OK
processData(123);          // compile error: int cannot be assigned to String

Пример с Python (динамическая типизация)

def process_data(value):
    # value может быть любого типа
    print(len(value))  # работает для строк, списков, словарей
    
process_data("Hello")   # OK — выведет 5
process_data([1,2,3])   # OK — выведет 3
process_data(123)       # Runtime error: object of type int has no len()

Промежуточное решение: Type Hints в Python

Современные языки предлагают компромисс — type hints в Python:

# Type hints — опциональное указание типов
def process_data(value: str) -> int:
    return len(value)

process_data("Hello")  # OK
process_data(123)      # IDE предупредит, но code запустится

Это помогает IDE, но не строгая проверка типов.

Вывод

Строгая типизация (Java, C#, C++) лучше для:

• Больших проектов
• Критичного по надёжности кода
• Долгосрочного поддержания кода
• Когда важна безопасность типов

Динамическая типизация (Python, JavaScript) лучше для:

• Быстрого прототипирования
• Скриптов и утилит
• Когда гибкость важнее безопасности
• Начального разработки прототипа