TypeScript jest typowanym nadzbiorem j

Osoby które kupowały "TypeScript: Skuteczne programowanie, wyd. II. 83 sposoby ulepszania kodu TypeScript", wybierały także:

• Superinteligencja. Scenariusze, strategie, zagro 67,89 zł, (12,90 zł -81%)
• Poradnik design thinking - czyli jak wykorzysta 49,62 zł, (12,90 zł -74%)
• F# 4.0 dla zaawansowanych. Wydanie IV 96,45 zł, (29,90 zł -69%)
• Systemy reaktywne. Wzorce projektowe i ich stosowanie 65,31 zł, (20,90 zł -68%)
• GameMaker. Kurs video. Kompleksowy przewodnik tworzenia gier platformowych 154,58 zł, (55,65 zł -64%)

Spis treści

TypeScript: Skuteczne programowanie, wyd. II. 83 sposoby ulepszania kodu TypeScript eBook -- spis treści

• Spis treści
• Przedmowa do drugiego wydania
• Przedmowa do pierwszego wydania
  • Poznajemy TypeScript
    • Element 1: Relacja między TypeScript a JavaScript
    • Element 2: Które opcje TypeScript wykorzystujemy
    • Element 3: Generowanie kodu jest niezależne od typów
    • Element 4: Przyzwyczaj się do strukturalnego typowania
    • Element 5: Ograniczanie użycia typu any
  • System typowania TypeScript
    • Element 6: Używanie edytora do sprawdzania i eksploracji systemu typowania
    • Element 7: Typy jako zbiory wartości
    • Element 8: Ustalanie, czy symbol należy do przestrzeni typu czy do przestrzeni wartości
    • Element 9: Deklarujmy typy zamiast stosować asercje typów
    • Element 10: Unikajmy typów opakowujących obiekty (String, Number, Boolean, Symbol, BigInt)
    • Element 11: Limity testowania dodatkowych właściwości
    • Element 12: Stosujmy typy w całych wyrażeniach funkcyjnych, gdy jest to możliwe
    • Element 13: Odróżniajmy typ od interfejsu
    • Element 14: Używajmy readonly, aby uniknąć błędów związanych z mutowaniem
    • Element 15: Używajmy operacji typów i typów generycznych, aby uniknąć powtórzeń
    • Element 16: Korzystajmy z sygnatur indeksów dla danych dynamicznych
    • Element 17: Unikanie liczbowych sygnatur indeksów
  • Wnioskowanie typów i analiza przepływu sterowania
    • Element 18: Unikajmy zaśmiecania kodu typami, które można wywnioskować
    • Element 19: Używajmy różnych zmiennych dla różnych typów
    • Element 20: Rozszerzanie typów
    • Element 21: Tworzenie całych obiektów od razu
    • Element 22: Zawężanie typów
    • Element 23: Zachowajmy spójność w używaniu aliasów
    • Element 24: Jak wykorzystuje się kontekst podczas wnioskowania typów
    • Element 25: Ewolucja typu any
    • Element 26: Korzystajmy z konstrukcji funkcyjnych i bibliotek, aby ułatwić przepływ typów
    • Element 27: Używajmy funkcji asynchronicznych zamiast wywołań zwrotnych
    • Element 28: Używanie klas i rozwijania funkcji do tworzenia nowych punktów wnioskowania
  • Projektowanie typów
    • Element 29: Preferujmy typy, które zawsze reprezentują poprawne stany
    • Element 30: Liberalne podejście do akceptowanych wartości i surowe do zwracanych danych
    • Element 31: Nie powtarzajmy informacji o typie w dokumentacji
    • Element 32: Unikajmy dołączania null lub undefined w aliasach typu
    • Element 33: Przenośmy wartości null poza obręb swojego typu
    • Element 34: Używajmy unii interfejsów zamiast interfejsów z uniami
    • Element 35: Preferujmy bardziej precyzyjne alternatywy typów łańcuchowych
    • Element 36: Używanie oddzielnego typu dla wartości specjalnych
    • Element 37: Ograniczanie użycia właściwości opcjonalnych
    • Element 38: Unikajmy wielokrotnych parametrów o tym samym typie
    • Element 39: Preferujmy typy ujednolicone do modelowania różnic
    • Element 40: Używajmy typów niekompletnych zamiast nieprecyzyjnych
    • Element 41: Nazywajmy typy zgodnie z językiem dziedziny swojego projektu
    • Element 42: Unikajmy typów opartych na danych anegdotycznych
  • Niesolidność i typ any
    • Element 43: Używanie możliwie najwęższego zakresu dla typów any
    • Element 44: Preferujmy warianty bardziej precyzyjne od zwykłego typu any
    • Element 45: Ukrywajmy nie gwarantujące bezpieczeństwa asercje typów w dobrze typowanych funkcjach
    • Element 46: Korzystajmy z typu unknown zamiast any dla wartości nieznanego typu
    • Element 47: Stosujmy bezpieczne pod kątem typów podejście do małpiego łatania
    • Element 48: Unikanie pułapek (nie)solidności
    • Element 49: Śledźmy pokrycie typami, aby zapobiec regresji bezpieczeństwa typów
  • Generyki i programowanie na poziomie typów
    • Element 50: Traktujmy typy generyczne jak funkcje pomiędzy typami
    • Element 51: Unikajmy niepotrzebnych parametrów typów
    • Element 52: Używajmy typów warunkowych zamiast przeciążonych deklaracji
    • Element 53: Jak kontrolować rozkład unii przez typy warunkowe
    • Element 54: Używanie szablonów typów literałów do modelowania DSL i zależności pomiędzy ciągami
    • Element 55: Piszmy testy swoich typów
    • Element 56: Zwróćmy uwagę na to, jak typy są pokazywane
    • Element 57: Preferujmy typy generyczne z rekurencją ogonową
    • Element 58: Rozważmy generowanie kodu jako alternatywę dla złożonych typów
  • Przepisy dla TypeScript
    • Element 59: Używanie typów never do sprawdzania kompletności
    • Element 60: Iterowanie po obiektach
    • Element 62: Korzystajmy z typów mapowanych, aby zapewnić synchronizację wartości
    • Element 62: Używajmy parametrów resztowych i typów krotek do modelowania funkcji o zmiennej liczbie argumentów
    • Element 63: Używajmy opcjonalnych właściwości never do modelowania alternatywy wykluczającej
    • Element 64: Rozważmy stosowanie etykiet dla typowania nominalnego
  • Deklaracje typów i składnia @types
    • Element 65: Umieszczanie kodu TypeScript i @types w deklaracjach devDependencies
    • Element 66: Trzy numery wersji w deklaracjach typów
    • Element 67: Eksportujmy wszystkie typy obecne w publicznych API
    • Element 68: Używajmy TSDoc do tworzenia komentarzy API
    • Element 69: Zdefiniujmy typ dla this w wywołaniach zwrotnych
    • Element 70: Używajmy typów lustrzanych dla oddzielania zależności
    • Element 71: Używajmy rozszerzania modułu do ulepszania typów
  • Pisanie i uruchamianie kodu
    • Element 72: Korzystajmy z funkcjonalności standardu ECMAScript zamiast TypeScript
    • Element 73: Korzystajmy z map kodu źródłowego do debugowania kodu TypeScript
    • Element 74: Rekonstruowanie typów w czasie działania
    • Element 75: Hierarchia DOM
    • Element 76: Tworzenie dokładnego modelu środowiska
    • Element 77: Zależności pomiędzy sprawdzaniem typów a testami jednostkowymi
    • Element 78: Zwracajmy uwagę na wydajność kompilatora
  • Modernizacja i migracja
    • Element 79: Pisanie nowoczesnego kodu JavaScript
    • Element 80: Używajmy @ts-check oraz JSDoc do eksperymentowania z TypeScript
    • Element 81: Używajmy allowJs, aby połączyć kod TypeScript z JavaScript
    • Element 82: Przekształcajmy moduły po kolei, wędrując w górę grafu zależności
    • Element 83: Nie uważajmy migracji za zakończoną przed włączeniem opcji noImplicitAny
  • Odwzorowanie elementów pomiędzy pierwszym i drugim wydaniem
• Indeks
• O autorze
• Polecamy także: