Что означает, что язык программирования статически или динамически типизирован?

Статическая и динамическая типизация: что это означает

Это фундаментальное различие в том, как язык проверяет типы. Разберу подробно с примерами.

Основное определение

Статическая типизация — типы проверяются во время компиляции (до запуска).

• Java, C++, C#, TypeScript (при включенном strict mode)
• Ошибки типов находятся ДО запуска программы
• Производительность часто лучше

Динамическая типизация — типы проверяются во время выполнения (при запуске).

• Python, JavaScript, Ruby, PHP
• Ошибки типов находятся КОГДА программа уже работает
• Гибче, быстрее писать, медленнее выполнять

Практические примеры

Java (статическая типизация)

public class StaticExample {
    public static void main(String[] args) {
        int x = 5;           // Тип int
        String name = "Алиса"; // Тип String
        
        // ❌ ОШИБКА ВО ВРЕМЯ КОМПИЛЯЦИИ
        // x = "hello";  // Type mismatch: cannot convert from String to int
        // print(name + x);  // ОК: String + int → String
    }
    
    public static int add(int a, int b) {
        return a + b;  // Обязательно вернуть int
    }
    
    // ❌ Компилятор не позволит это
    // public static void process(unknownType data) {...}
}

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

# Типы определяются во время выполнения
x = 5           # x это int
x = "hello"     # x это строка (переопределили)
x = [1, 2, 3]   # x это list

# ✅ Работает во время создания
def add(a, b):
    return a + b

print(add(5, 3))           # 8 — работает
print(add("Hello", " World"))  # Hello World — тоже работает!
print(add([1], [2]))       # [1, 2] — работает!

# ❌ Ошибка появляется только во время выполнения
result = add(5, "3")       # TypeError: unsupported operand type(s) for +: 'int' and 'str'
# Эта ошибка произойдёт только если код исполнится до этой строки

Сравнение на конкретных ошибках

Сценарий: функция ожидает число, но получает строку

# Python (динамическая)
def calculate_discount(price: float, discount: float) -> float:
    return price - discount  # Без type checking!

result = calculate_discount(100, "20")  # ❌ TypeError при выполнении

# Java (статическая)
public static double calculateDiscount(double price, double discount) {
    return price - discount;
}

// ❌ ОШИБКА ВО ВРЕМЯ КОМПИЛЯЦИИ
// calculateDiscount(100, "20");  // Type mismatch!
// Программа даже не запустится

Проверка типов во время разработки vs выполнения

# Python БЕЗ type hints
def process_user(user):
    return user.name + " " + str(user.age)

# ✅ Это работает, если user это объект с name и age
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

user = User("Alice", 25)
print(process_user(user))  # "Alice 25"

# ❌ Но если передать None, ошибка только при выполнении
process_user(None)  # AttributeError: 'NoneType' object has no attribute 'name'

# Python С type hints (но это не обязательно!)
def process_user_typed(user: User) -> str:
    return user.name + " " + str(user.age)

# mypy скажет об ошибке ДО запуска
# process_user_typed(None)  # error: Argument 1 to "process_user_typed" has incompatible type "None"
# Но Python её проигнорирует и выполнит код!

Временная шкала проверки

# Статическая типизация (Java)
javac Main.java          # КОМПИЛЯЦИЯ: проверка типов
                         # ❌ Если ошибка — не скомпилируется
java Main               # ВЫПОЛНЕНИЕ: логические ошибки

# Динамическая типизация (Python)
python main.py          # ВЫПОЛНЕНИЕ: проверка типов И выполнение
                        # ❌ Если ошибка типа — программа упадёт во время работы

Производительность: статическая vs динамическая

# Динамическая типизация требует проверок во время выполнения

# Python интерпретатор внутри делает что-то вроде:
def add(a, b):
    # Проверить, какие это типы
    if isinstance(a, int) and isinstance(b, int):
        return a + b
    elif isinstance(a, float) and isinstance(b, float):
        return a + b
    elif isinstance(a, str) and isinstance(b, str):
        return a + b
    # ... и так далее
    else:
        raise TypeError(f"Can't add {type(a)} and {type(b)}")

# Это медленнее, чем статическая типизация,
# где компилятор ВСЁ знает во время компиляции

# Java просто инструкция ADD, готовая на машинном коде
// public static int add(int a, int b) {
//     return a + b;  // Одна инструкция CPU
// }

Плюсы и минусы

Статическая типизация (Java, C++, TypeScript)

✅ Плюсы:

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

❌ Минусы:

• Дольше писать (больше кода на типы)
• Меньше гибкости
• Кривая обучения крутая

Динамическая типизация (Python, JavaScript)

✅ Плюсы:

• Быстро писать (меньше boilerplate)
• Гибче (duck typing)
• Проще учить новичкам
• Можно менять типы на лету

❌ Минусы:

• Ошибки типов в production (пользователи видят)
• Сложнее большие проекты поддерживать
• IDE помощь слабее (до недавна)
• Медленнее

Python: попытка лучшего из обоих миров

# Python 3.5+ имеет type hints, но они опциональны
from typing import List, Dict, Optional

# БЕЗ type hints
def old_style(items):
    return items[0]

# С type hints (статическая информация, но динамическая проверка)
def new_style(items: List[int]) -> int:
    return items[0]

# Type hints НЕ проверяются Python интерпретатором
result = new_style(["a", "b"])  # ✅ Работает! (Python игнорирует hint)

# Но внешние инструменты (mypy) проверяют:
# mypy new_style(["a", "b"])  # error: List item 0 has incompatible type "str"; expected "int"

# Optional — значение может быть None
def find_user(user_id: int) -> Optional[Dict[str, str]]:
    if user_id == 1:
        return {"name": "Alice"}
    return None  # ✅ Тип включает None

# Union — один из нескольких типов
from typing import Union

def process(data: Union[int, str, List[int]]) -> str:
    if isinstance(data, int):
        return f"Number: {data}"
    elif isinstance(data, str):
        return f"String: {data}"
    else:
        return f"List: {data}"

Практический пример реальной ошибки

# Динамическая типизация — ошибка в production
def calculate_total(items: list):
    total = 0
    for item in items:
        total += item["price"] * item["quantity"]  # Может упасть!
    return total

# Если случайно передать список чисел вместо словарей:
total = calculate_total([10, 20, 30])  # TypeError: list indices must be integers or slices, not str
# Пользователь видит ошибку

# Со статической типизацией:
from typing import TypedDict, List

class Item(TypedDict):
    price: float
    quantity: int

def calculate_total_typed(items: List[Item]) -> float:
    total = 0.0
    for item in items:
        total += item["price"] * item["quantity"]
    return total

# mypy перехватит ошибку ДО запуска:
# calculate_total_typed([10, 20, 30])  # error: List item 0 has incompatible type "int"; expected "Item"

Проверка типов в runtime (для Python)

# Если реально нужна проверка типов в runtime
from typing import get_type_hints

def validate_types(func):
    def wrapper(*args, **kwargs):
        hints = get_type_hints(func)
        arg_names = list(hints.keys())[:-1]  # Исключить возвращаемый тип
        
        for arg_name, arg_value in zip(arg_names, args):
            if arg_name in hints:
                expected_type = hints[arg_name]
                if not isinstance(arg_value, expected_type):
                    raise TypeError(
                        f"{arg_name} должен быть {expected_type}, получил {type(arg_value)}"
                    )
        
        return func(*args, **kwargs)
    return wrapper

@validate_types
def add(a: int, b: int) -> int:
    return a + b

print(add(5, 3))  # ✅ 8
print(add(5, "3"))  # ❌ TypeError

Вывод

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

• Типы проверяются ДО запуска
• Ошибки видны сразу
• Java, C++, TypeScript, Go

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

• Типы проверяются ВО ВРЕМЯ выполнения
• Ошибки видны при запуске
• Python, JavaScript, Ruby

Python с type hints:

• Гибридный подход
• Hints не обязательны (динамическая)
• Но mypy может проверять как статическая
• Лучшее из обоих миров

Выбор между ними зависит от проекта. Для production систем я предпочитаю strict type checking (mypy в Python или TypeScript), потому что ошибки типов очень дорогие в production.