TypeScript vs Python: typowanie, szybkość i zastosowania

TypeScript i Python to języki wysokiego poziomu z garbage collectorem, funkcjami jako wartościami pierwszej klasy i dużymi ekosystemami pakietów. Główna różnica to typowanie: typy w TypeScript sprawdza kompilator przed uruchomieniem programu, a type hints w Pythonie to opcjonalne adnotacje, które interpreter ignoruje. Oba działają też na innych silnikach i dominują w innych rodzajach oprogramowania: TypeScript w webie, Python w pracy z danymi i skryptach.

Oto mały program w TypeScript. Kliknij Run:

interface Order {
    customer: string;
    amount: number;
    paid: boolean;
}

function totalPaid(orders: Order[]): number {
    return orders.filter((o) => o.paid).reduce((sum, o) => sum + o.amount, 0);
}

const orders: Order[] = [
    { customer: "Ada", amount: 120, paid: true },
    { customer: "Grace", amount: 80.5, paid: false },
    { customer: "Linus", amount: 42.25, paid: true },
];

const byAmount = [...orders].sort((a, b) => b.amount - a.amount).map((o) => o.customer);
console.log(totalPaid(orders));
console.log(byAmount);

Wynik:

162.25
[ 'Ada', 'Grace', 'Linus' ]

Ten sam program w Pythonie, z type hints:

from dataclasses import dataclass


@dataclass
class Order:
    customer: str
    amount: float
    paid: bool


def total_paid(orders: list[Order]) -> float:
    return sum(o.amount for o in orders if o.paid)


orders = [
    Order("Ada", 120.0, True),
    Order("Grace", 80.5, False),
    Order("Linus", 42.25, True),
]

by_amount = [o.customer for o in sorted(orders, key=lambda o: o.amount, reverse=True)]
print(total_paid(orders))
print(by_amount)

162.25
['Ada', 'Grace', 'Linus']

Kształt jest podobny: typ dla rekordu, funkcja z otypowanymi parametrami, lista wartości. Widoczne różnice to składnia (nawiasy klamrowe i średniki kontra wcięcia), interface kontra @dataclass oraz funkcje strzałkowe z filter/reduce kontra wyrażenie generatora.

TypeScript vs Python w skrócie

Składnia obok siebie

Jeśli znasz type hints w Pythonie, większość adnotacji w TypeScript ma bezpośredni odpowiednik:

Typy statyczne a type hints

Oba języki pozwalają napisać tę samą adnotację, a: number albo a: int. To, co dzieje się dalej, jest różne.

W TypeScript kompilator sprawdza każde wywołanie, zanim cokolwiek się wykona. Zły argument zatrzymuje budowanie:

// This does not compile: TypeScript checks the call before running it.
function add(a: number, b: number): number {
    return a + b;
}

console.log(add(2, 3));
console.log(add("2", "3"));

index.ts(7,17): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

W Pythonie type hints to metadane. Interpreter wykonuje wywołanie i zwraca string:

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


print(add(2, 3))      # 5
print(add("2", "3"))  # 23, the hints are not enforced

Sprawdzanie to osobny krok z narzędziem takim jak mypy:

$ mypy hints.py
hints.py:6: error: Argument 1 to "add" has incompatible type "str"; expected "int"  [arg-type]
hints.py:6: error: Argument 2 to "add" has incompatible type "str"; expected "int"  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

Typowanie w Pythonie jest więc z założenia stopniowe: kod bez adnotacji po prostu nie jest sprawdzany, a type hints dodajesz tam, gdzie pomagają. TypeScript też może być luźny (any wyłącza sprawdzanie dla wartości), ale przy włączonym strict, co jest ustawieniem domyślnym, parametr bez adnotacji to błąd, a nie darmowa przepustka.

Jedno mają wspólne: żaden nie sprawdza typów podczas działania programu. TypeScript usuwa swoje typy, a Python ignoruje swoje type hints. Dane, które przychodzą w czasie wykonania, na przykład JSON z API, wymagają walidacji w obu językach (robią to na podstawie schematu biblioteki takie jak Zod w TypeScript i Pydantic w Pythonie).

Liczby zachowują się inaczej

TypeScript ma liczby z JavaScriptu: number to 64-bitowa wartość zmiennoprzecinkowa zarówno dla liczb całkowitych, jak i ułamków, a bigint to osobny typ dla dużych liczb całkowitych. int w Pythonie sam rośnie do dowolnego rozmiaru.

console.log(0.1 + 0.2);        // float rounding, same as Python
console.log(2 ** 53 + 1);      // beyond 2^53, not every integer fits in a number
console.log(7 / 2, Math.trunc(7 / 2));
console.log(2n ** 100n);       // bigint: exact, like Python's int

Wynik:

0.30000000000000004
9007199254740992
3.5 3
1267650600228229401496703205376n

Python wypisuje 9007199254740993 dla 2**53 + 1, bo jego liczby całkowite są dokładne przy każdym rozmiarze, i ma osobny operator dzielenia całkowitego, 7 // 2, który daje 3. W TypeScript nie ma typu int: liczba całkowita to number, który po prostu nie ma części ułamkowej.

Środowisko uruchomieniowe i wydajność

TypeScript działa jako JavaScript. V8 (w Chrome i Node.js), JavaScriptCore (w Safari i Bun) i SpiderMonkey (w Firefoksie) kompilują często wykonywany kod do kodu maszynowego w trakcie działania, więc ciasne pętle w TypeScript są zwykle dużo szybsze niż te same pętle w CPython, który wykonuje bytecode.

W wielu programach ta różnica znaczy mniej, niż się wydaje:

• Biblioteki numeryczne i do uczenia maszynowego w Pythonie (NumPy, pandas, PyTorch) wykonują ciężką pracę w skompilowanym kodzie C, C++ albo CUDA, więc program w Pythonie, który je wywołuje, nie wykonuje swoich wewnętrznych pętli w Pythonie.
• Serwery webowe w obu językach spędzają dużo czasu na czekaniu na bazy danych i sieć.

Oba języki używają jednego głównego wątku dla większości kodu. TypeScript w Node.js obsługuje współbieżność pętlą zdarzeń i async/await, a do równoległej pracy procesora używa worker threads. Python ma asyncio do tego samego stylu współbieżności oraz wątki i procesy.

Ekosystemy i zastosowania

TypeScript to domyślny wybór dla:

• Frontendu: React, Angular, Vue i Svelte go obsługują, a kompiluje się do JavaScriptu, który uruchamiają przeglądarki.
• Kodu serwerowego na Node.js, Deno i Bun: API z Express, Fastify, NestJS albo Hono.
• Aplikacji full-stack, w których serwer i przeglądarka współdzielą definicje typów, na przykład projektów Next.js.
• Narzędzi, programów wiersza poleceń i aplikacji desktopowych w Electronie.

Python to domyślny wybór dla:

• Analizy i wizualizacji danych (pandas, NumPy, Matplotlib, notatniki Jupyter).
• Uczenia maszynowego i AI (PyTorch, scikit-learn i większość kodu do trenowania modeli).
• Skryptów i automatyzacji: przetwarzania plików, administracji systemami, kodu łączącego systemy.
• Backendu webowego z Django, Flask albo FastAPI.
• Obliczeń naukowych i nauczania.

Backend webowy to obszar, w którym zachodzą na siebie najbardziej. Zespoły często wybierają według reszty stosu: TypeScript, żeby współdzielić kod z frontendem w TypeScript, Python, żeby być blisko kodu danych i ML.

Którego języka się uczyć?

• Budujesz dla webu? Naucz się JavaScriptu, a potem TypeScriptu. Wszystko, co działa w przeglądarce, to ostatecznie JavaScript, a w TypeScript pisze się większość profesjonalnego kodu frontendu.
• Pracujesz z danymi, AI albo automatyzacją? Naucz się Pythona. Jego biblioteki w tych obszarach nie mają prawdziwych odpowiedników w świecie JavaScriptu.
• Pierwszy język, bez określonego celu? Python ma mniej składni do nauczenia, zanim zaczniesz pisać przydatne programy. TypeScript dodaje system typów na JavaScript, co na początku jest dodatkowym materiałem, a opłaca się, gdy programy rosną.

Wielu programistów używa obu: Pythona do danych i skryptów, TypeScript do webowego kodu produktu. Jeśli znasz już type hints w Pythonie, adnotacje w TypeScript będą wyglądać znajomo. Nowe jest to, że kompilator domyślnie je egzekwuje, a pod spodem działa JavaScript.