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

# Статическая и динамическая типизация

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

Статическая типизация

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

Преимущества статической типизации:

• Безопасность - ошибки типов выявляются до запуска
• Производительность - оптимизация на этапе компиляции
• Самодокументирование - код явно показывает типы данных
• Refactoring - IDE может безопасно переименовывать и изменять код
• Автодополнение - IDE дает точные подсказки

Недостатки:

• Больше кода - нужно явно указывать типы
• Менее гибкий - сложнее писать универсальный код
• Время разработки - дольше проверка типов

Примеры статической типизации:

Java:

// Тип явно указан
int age = 25;  // int
age = "twenty-five";  // ошибка компиляции!

String name = "John";
List<String> names = new ArrayList<>();
names.add("Alice");
names.add(123);  // ошибка - ожидается String

TypeScript:

// Тип указан явно
let age: number = 25;
age = "twenty-five";  // ошибка: Type 'string' is not assignable to type 'number'

interface User {
  name: string;
  age: number;
}

const user: User = {
  name: "John",
  age: 30  // ✓ правильно
};

// Функции с типами
function calculateTotal(price: number, quantity: number): number {
  return price * quantity;
}

calculateTotal(10, 5);        // ✓ OK
calculateTotal("10", 5);      // ✗ Ошибка: Argument of type 'string' is not assignable to parameter of type 'number'

C#:

int count = 10;
count = "hello";  // ошибка компиляции

public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Динамическая типизация

При динамической типизации тип переменной определяется во время выполнения программы. Переменная может содержать значение любого типа, и этот тип может меняться во время работы программы. Ошибки типов обнаруживаются только во время runtime (во время работы программы).

Преимущества динамической типизации:

• Гибкость - можно писать более универсальный код
• Меньше кода - не нужно явно указывать типы
• Быстрое прототипирование - быстро писать и тестировать идеи
• Утиная типизация - объект работает, если ведет себя правильно

Недостатки:

• Ошибки в runtime - ошибки типов выявляются только при выполнении
• Сложнее отладка - непредсказуемое поведение
• Медленнее - нет оптимизации на этапе компиляции
• Автодополнение - IDE не знает тип переменной
• Сложный refactoring - легко сломать код при изменениях

Примеры динамической типизации:

Python:

# Тип не указан, определяется во время выполнения
age = 25        # int
age = "twenty-five"  # теперь это string (переприсвоение)
age = [1, 2, 3]     # теперь это list (переприсвоение)

def greet(name):
    return f"Hello, {name}"

greet("John")      # ✓ OK
greet(123)         # ✓ OK (переведется в строку)

def process(data):
    return data[0]  # Работает с любым типом с индексацией

process([1, 2, 3])     # ✓ OK
process("hello")       # ✓ OK (вернет 'h')
process(123)           # ✗ Runtime error: 'int' object is not subscriptable

JavaScript:

// Тип переменной может меняться
let value = 10;         // number
value = "hello";        // string
value = { id: 1 };      // object
value = [1, 2, 3];      // array

// Функции без типов
function add(a, b) {
  return a + b;
}

add(5, 3);           // ✓ OK: 8
add("5", 3);         // ✓ OK: "53" (конкатенация)
add(null, undefined) // ✓ OK: NaN (нет ошибки, но результат странный)

// Утиная типизация
const obj = {
  bark() { console.log('Woof!'); }
};

function makeSound(animal) {
  animal.bark();  // Работает, если есть метод bark
}

makeSound(obj);  // ✓ OK
makeSound({ bark: () => 'meow' });  // ✓ OK
makeSound({});   // ✗ Runtime error: animal.bark is not a function

Ruby:

# Динамическая типизация
name = "John"
name = 123
name = [1, 2, 3]

def process(value)
  value + 5  # Работает если value поддерживает +
end

process(10)      # ✓ OK: 15
process("10")    # ✓ OK: "105"
process([1, 2])  # ✗ Runtime error: can't convert Integer into Array

Сравнительная таблица

Гибридный подход: TypeScript

TypeScript добавляет статическую типизацию к JavaScript, сочетая преимущества обоих подходов:

// Статическая типизация
let age: number = 25;
age = "twenty-five";  // ✗ Ошибка во время разработки

// Но компилируется в JavaScript
const age = 25;
age = "twenty-five";  // ✓ Работает в runtime

Выводы

• Статическая типизация лучше для больших проектов, требующих безопасности и производительности
• Динамическая типизация удобна для быстрого прототипирования и небольших скриптов
• TypeScript/Flow предоставляют статическую типизацию для динамических языков
• Современные IDE могут компенсировать отсутствие статической типизации хорошим анализом кода