Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00323 005845 19006875 na godz. na dobę w sumie
React 16. Framework dla profesjonalistów - książka
React 16. Framework dla profesjonalistów - książka
Autor: Liczba stron: 712
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-6246-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> javascript - programowanie
Porównaj ceny (książka, ebook (-30%), audiobook).

W ostatnich latach JavaScript stał się pełnoprawnym i pełnowartościowym językiem programowania. Jest wszechstronny, elastyczny i pozwala na tworzenie znakomitego kodu. Uzyskanie dobrych efektów wymaga jednak od programisty sporych umiejętności. Wyjątkowo przydatnym rozwiązaniem okazują się frameworki, które ułatwiają pisanie nawet bardzo złożonych aplikacji. Na szczególną uwagę zasługuje React - popularny framework do tworzenia dynamicznych aplikacji w JavaScripcie. React jest narzędziem, które w stosunkowo prosty sposób pozwala w pełni wykorzystać możliwości nowoczesnych przeglądarek i urządzeń mobilnych.

W książce przystępnie wyjaśniono zasady i techniki programowania w tym frameworku. Opisano szczegóły jego architektury oraz przedstawiono korzyści płynące z pracy z Reactem. Sporo miejsca poświęcono projektowaniu aplikacji oraz korzystaniu zarówno z samego frameworka, jak i towarzyszących mu narzędzi i najpopularniejszych bibliotek. Poszczególne zagadnienia są tu omawiane od podstaw, które następnie płynnie przechodzą do najbardziej zaawansowanych i wyszukanych technik programowania. Wszystkie informacje przedstawiono bardzo starannie, z zachowaniem ważnych szczegółów, dzięki czemu łatwo uzyskać wiedzę niezbędną do pisania aplikacji na wysokim, profesjonalnym poziomie. Nie zabrakło również wskazówek, dzięki którym można łatwo zdiagnozować najczęściej występujące problemy i skutecznie je rozwiązywać.

W książce między innymi:

React: dynamiczne aplikacje w profesjonalnym wydaniu!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Pro React 16 Tłumaczenie: Piotr Rajca ISBN: 978-83-283-6246-8 First published in English under the title Pro React 16 by Adam Freeman, edition: 1 Copyright © Adam Freeman, 2019 This edition has been translated and published under licence from APress Media, LLC, part of Springer Nature. APress Media, LLC, part of Springer Nature takes no responsibility and shall not be made liable for the accuracy of the translation. Polish edition copyright © 2020 by Helion SA All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Helion SA ul. Kościuszki 1c, 44-100 Gliwice tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/reac16 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści O autorze ..................................................................................................... 17 O recenzencie technicznym ......................................................................... 18 Część I Rozdział 1. Rozpoczynanie prac z frameworkiem React .............................19 Twoja pierwsza aplikacja Reacta ................................................................. 21 Przygotowanie środowiska programistycznego ..................................................................21 Instalacja Node.js ..............................................................................................................21 Instalacja pakietu create-react-app ................................................................................22 Instalacja Git ......................................................................................................................23 Instalacja edytora ..............................................................................................................23 Instalacja przeglądarki .....................................................................................................23 Tworzenie projektu .................................................................................................................24 Prezentacja struktury projektu .......................................................................................25 Dodanie frameworka CSS Bootstrap .............................................................................26 Uruchamianie narzędzi dla programistów ...................................................................27 Usuwanie treści zastępczej .....................................................................................................28 Wyświetlanie treści dynamicznych .......................................................................................29 Wyjaśnienie zmian danych stanu ...................................................................................30 Dodawanie możliwości aplikacji listy zadań .......................................................................33 Wyświetlanie zadań do zrobienia ...................................................................................35 Wprowadzanie dodatkowych komponentów .....................................................................38 Stosowanie komponentów podrzędnych ......................................................................40 Ostatnie szlify ...........................................................................................................................41 Zarządzanie prezentacją zakończonych zadań .............................................................42 Trwałe przechowywanie danych ....................................................................................44 Podsumowanie .........................................................................................................................47 Poleć książkęKup książkę SPIS TREŚCI Rozdział 2. Zrozumieć React .......................................................................................... 49 Czy powinienem używać Reacta? ......................................................................................... 50 Aplikacje z komunikacją dwukierunkową .................................................................... 50 Aplikacje jednostronicowe .............................................................................................. 50 Problem złożoności aplikacji .......................................................................................... 51 Co muszę wiedzieć? ................................................................................................................. 52 Jak skonfigurować środowisko programistyczne? .............................................................. 52 Jaka jest struktura tej książki? ................................................................................................ 52 Część 1. Początki stosowania frameworka React ......................................................... 52 Część 2. Praca z frameworkiem React ........................................................................... 52 Część 3. Tworzenie złożonych aplikacji Reacta ........................................................... 53 Czy w książce jest dużo przykładów? ................................................................................... 53 Skąd pobrać kody źródłowe przykładów? ........................................................................... 54 Gdzie szukać informacji o poprawkach? ............................................................................. 55 Podsumowanie ......................................................................................................................... 55 Rozdział 3. Podstawy HTML, JSX i CSS ........................................................................... 57 Przygotowania do prac w tym rozdziale .............................................................................. 57 Przygotowanie pliku HTML i komponentu ................................................................. 58 Uruchamianie przykładowej aplikacji ........................................................................... 59 Język HTML i elementy DOM .............................................................................................. 60 Treść elementu .................................................................................................................. 61 Atrybuty ............................................................................................................................. 63 Dynamiczne zmienianie elementów HTML ................................................................ 63 Dynamiczne tworzenie elementów przy użyciu klasy Component .......................... 65 Stosowanie wyrażeń w elementach Reacta .......................................................................... 66 Łączenie wyrażeń i treści statycznych ........................................................................... 67 Wykonywanie obliczeń w wyrażeniach ........................................................................ 67 Dostęp do właściwości i metod komponentu .............................................................. 69 Stosowanie wyrażeń do ustawiania wartości właściwości .......................................... 70 Stosowanie wyrażeń do obsługi zdarzeń ....................................................................... 71 Prezentacja frameworka Bootstrap ....................................................................................... 72 Stosowanie klas frameworka Bootstrap ........................................................................ 72 Stosowanie frameworka Bootstrap do tworzenia siatek ............................................. 74 Stosowanie frameworka Bootstrap w tabelach ............................................................. 75 Stosowanie frameworka Bootstrap w formularzach ................................................... 77 Podsumowanie ......................................................................................................................... 78 Rozdział 4. Podstawy JavaScriptu .................................................................................. 79 Przygotowania do lektury tego rozdziału ............................................................................ 79 Stosowanie instrukcji .............................................................................................................. 82 Definiowanie i stosowanie funkcji ........................................................................................ 82 Definiowanie funkcji z parametrami ............................................................................. 83 Definiowanie funkcji zwracających wyniki .................................................................. 85 Stosowanie funkcji jako argumentów innych funkcji ................................................. 86 Stosowanie zmiennych i typów ............................................................................................. 87 Stosowanie typów prostych ............................................................................................. 89 6 Poleć książkęKup książkę SPIS TREŚCI Stosowanie operatorów JavaScriptu .....................................................................................91 Stosowanie instrukcji warunkowych .............................................................................92 Porównanie operatorów równości i identyczności ......................................................93 Jawna konwersja typów ...................................................................................................94 Stosowanie tablic .....................................................................................................................95 Stosowanie literału tablicowego .....................................................................................96 Odczyt i modyfikacja zawartości tablic .........................................................................96 Wyliczanie zawartości tablic ...........................................................................................97 Stosowanie operatora rozproszenia ...............................................................................97 Stosowanie wbudowanych metod tablicowych ............................................................98 Stosowanie obiektów .............................................................................................................100 Stosowanie literałów obiektowych ...............................................................................101 Stosowanie funkcji jako metod .....................................................................................102 Stosowanie klas ...............................................................................................................103 Kopiowanie właściwości z jednego obiektu do drugiego .........................................104 Przechwytywanie nazw parametrów z obiektów .......................................................106 Tworzenie i stosowanie modułów JavaScript ....................................................................107 Tworzenie i użycie modułu JavaScript ........................................................................107 Eksportowanie z modułów możliwości nazwanych ..................................................109 Definiowanie wielu możliwości nazwanych w jednym module ..............................110 Obietnice języka JavaScript ..................................................................................................112 Wyjaśnienie problemu operacji asynchronicznych ...................................................112 Stosowanie obietnic ........................................................................................................113 Upraszczanie kodu asynchronicznego ........................................................................114 Podsumowanie .......................................................................................................................115 SportsStore — prawdziwa aplikacja Reacta .............................................. 117 Przygotowanie projektu ........................................................................................................118 Instalacja dodatkowych pakietów NPM ......................................................................118 Dodanie do projektu arkuszy stylów CSS ...................................................................120 Przygotowanie usługi internetowej ..............................................................................121 Uruchomienie przykładowej aplikacji .........................................................................123 Tworzenie magazynu danych ..............................................................................................123 Tworzenie akcji magazynu danych oraz kreatorów akcji .........................................124 Tworzenie możliwości funkcjonalnych sklepu .................................................................126 Tworzenie komponentów produktu i kategorii .........................................................127 Połączenie magazynu danych z mechanizmem trasowania .....................................130 Dodanie komponentu Shop do aplikacji ....................................................................132 Poprawa przycisków wyboru kategorii .......................................................................133 Dodawanie koszyka ...............................................................................................................135 Rozbudowa magazynu danych .....................................................................................135 Tworzenie komponentu CartSummary ......................................................................137 Dodawanie komponentu szczegółów koszyka ...........................................................141 Dodanie koszyka do konfiguracji trasowania ............................................................143 Podsumowanie .......................................................................................................................145 7 Rozdział 5. Poleć książkęKup książkę SportsStore — REST i kasa ........................................................................ 147 Przygotowania do prac w tym rozdziale ............................................................................147 Korzystanie z internetowej usługi typu RESTful ..............................................................147 Tworzenie pliku konfiguracyjnego ..............................................................................149 Tworzenie źródła danych ..............................................................................................149 Rozszerzanie możliwości magazynu danych ..............................................................150 Aktualizacja kreatorów akcji .........................................................................................151 Podział danych na strony .....................................................................................................151 Wyjaśnienie wsparcia dla stronicowania w usłudze internetowej ..........................153 Zmiana żądania HTTP oraz akcji ................................................................................155 Tworzenie komponentu wczytującego dane ..............................................................156 Aktualizacja komponentu konektora sklepu .............................................................157 Aktualizacja przycisku kategorii Wszystkie ...............................................................159 Tworzenie kontrolek stronicowania ............................................................................160 Dodanie obsługi składania zamówienia .............................................................................165 Rozbudowa usługi typu RESTful i źródła danych .....................................................166 Tworzenie formularza zamówienia .............................................................................168 Uproszczenie komponentu konektora sklepu ..................................................................175 Podsumowanie .......................................................................................................................176 SportsStore — administracja ..................................................................... 177 Przygotowania do lektury tego rozdziału ..........................................................................177 Uruchamianie aplikacji .................................................................................................178 Tworzenie usługi GraphQL .................................................................................................179 Definiowanie schematu GraphQL-a ...........................................................................179 Definiowanie resolwerów GraphQL-a ........................................................................180 Aktualizacja serwera ......................................................................................................182 Tworzenie narzędzi administracyjnych do zarządzania zamówieniami .......................184 Definiowanie tabeli zamówień .....................................................................................185 Zdefiniowanie komponentu konektora ......................................................................186 Konfiguracja klienta GraphQL-a .................................................................................189 Konfigurowanie mutacji ................................................................................................191 Tworzenie narzędzi zarządzania produktami ...................................................................192 Połączenie komponentu tabeli produktów .................................................................194 Tworzenie komponentów do edycji ............................................................................197 Aktualizacja konfiguracji trasowania ..........................................................................199 Podsumowanie .......................................................................................................................202 SportsStore — uwierzytelnianie i wdrażanie ............................................ 203 Przygotowania do prac w tym rozdziale ............................................................................203 Dodanie uwierzytelniania do żądań GraphQL-a ..............................................................206 Przedstawienie systemu uwierzytelniania ..................................................................207 Tworzenie kontekstu uwierzytelniania .......................................................................208 Tworzenie formularza uwierzytelniającego ................................................................211 Zabezpieczanie narzędzi administracyjnych ..............................................................212 Dodanie odnośników do narzędzi administracyjnych .............................................213 SPIS TREŚCI Rozdział 6. Rozdział 7. Rozdział 8. 8 Poleć książkęKup książkę SPIS TREŚCI Przygotowanie aplikacji do wdrożenia ...............................................................................214 Umożliwienie leniwego wczytywania narzędzi administracyjnych ........................214 Tworzenie pliku danych ................................................................................................216 Konfiguracja adresów URL żądań ................................................................................217 Budowanie aplikacji .......................................................................................................217 Tworzenie serwera aplikacji ..........................................................................................217 Testowanie produkcyjnej wersji aplikacji i serwera ..................................................218 Umieszczanie aplikacji w kontenerze .................................................................................219 Instalowanie Dockera .....................................................................................................219 Przygotowanie aplikacji .................................................................................................220 Tworzenie kontenera Dockera .....................................................................................220 Uruchamianie aplikacji ..................................................................................................221 Podsumowanie .......................................................................................................................222 Część II Praca z Reactem .....................................................................223 Rozdział 9. Prezentacja projektów Reacta ................................................................... 225 Przygotowania do prac w tym rozdziale ............................................................................226 Opis struktury projektów Reacta ........................................................................................227 Katalog kodów źródłowych ...........................................................................................229 Katalog pakietów ............................................................................................................230 Stosowanie narzędzi programistycznych Reacta ..............................................................233 Proces kompilacji i przekształcania .............................................................................234 Serwer HTTP do prac programistycznych .................................................................238 Treści statyczne ...............................................................................................................239 Wyświetlanie błędów .....................................................................................................242 Linter ................................................................................................................................245 Konfiguracja narzędzi programistycznych .................................................................248 Debugowanie aplikacji Reacta .............................................................................................249 Badanie stanu aplikacji ..................................................................................................251 Stosowanie debugera przeglądarki ...............................................................................252 Podsumowanie .......................................................................................................................254 Rozdział 10. Komponenty i właściwości props .............................................................. 255 Przygotowania do prac w tym rozdziale ............................................................................256 Komponenty ...........................................................................................................................258 Renderowanie treści HTML ..........................................................................................258 Renderowanie innych komponentów .........................................................................260 Właściwości props .................................................................................................................263 Definiowanie właściwości props w komponencie nadrzędnym ..............................263 Odbieranie właściwości props w komponencie podrzędnym .................................265 Łączenie kodu JavaScript i właściwości props w celu renderowania treści ..................266 Selektywne renderowanie treści ...................................................................................266 Renderowanie tablic .......................................................................................................267 Renderowanie wielu elementów ...................................................................................271 Brak renderowanych treści ............................................................................................273 Próba zmiany wartości właściwości props ..................................................................274 9 Poleć książkęKup książkę SPIS TREŚCI Stosowanie funkcyjnych właściwości props ......................................................................275 Wywoływanie funkcyjnych właściwości props z argumentami ..............................277 Przekazywanie właściwości props do komponentów podrzędnych ..............................280 Określanie domyślnych wartości właściwości props ................................................283 Sprawdzanie typów wartości właściwości props ...............................................................284 Podsumowanie .......................................................................................................................287 Rozdział 11. Komponenty ze stanem ............................................................................. 289 Przygotowania do prac w tym rozdziale ............................................................................290 Różne typy komponentów ...................................................................................................291 Komponenty bezstanowe ..............................................................................................292 Komponenty ze stanem .................................................................................................292 Tworzenie komponentów ze stanem ..................................................................................293 Klasa komponentu .........................................................................................................294 Instrukcja import ...........................................................................................................294 Metoda render ................................................................................................................294 Właściwości props komponentów ze stanem ............................................................295 Dodawanie danych stanu .....................................................................................................295 Odczytywanie danych stanu .........................................................................................297 Modyfikacja danych stanu ...................................................................................................297 Unikanie problemów z modyfikowaniem danych stanu ..........................................299 Definiowanie komponentów ze stanem przy użyciu hooków ........................................304 Podnoszenie danych stanu ...................................................................................................306 Dalsze podnoszenie danych stanu ...............................................................................309 Definiowanie typów i wartości domyślnych właściwości props ....................................311 Podsumowanie .......................................................................................................................314 Rozdział 12. Stosowanie zdarzeń .................................................................................. 315 Przygotowania do prac w tym rozdziale ............................................................................316 Przedstawienie zdarzeń ........................................................................................................318 Wywoływanie metody w celu obsługi zdarzenia .......................................................319 Pobieranie obiektu zdarzenia .......................................................................................323 Wywoływanie metod obsługi zdarzeń z niestandardowymi argumentami ..........328 Zapobieganie domyślnej obsłudze zdarzeń ................................................................330 Zarządzanie propagacją zdarzeń .........................................................................................332 Faza elementu docelowego i faza propagacji w górę .................................................332 Faza przechwytywania ...................................................................................................336 Określanie fazy zdarzenia ..............................................................................................337 Zatrzymywanie propagacji zdarzeń .............................................................................340 Podsumowanie .......................................................................................................................341 Rozdział 13. Rekoncyliacja i cykl życia ........................................................................... 343 Przygotowania do prac w tym rozdziale ............................................................................344 Tworzenie przykładowych komponentów .................................................................345 Wyjaśnienie sposobu renderowania treści ........................................................................347 Wyjaśnienie procesu aktualizacji .................................................................................349 Wyjaśnienie procesu rekoncyliacji ..............................................................................351 Rekoncyliacja list ............................................................................................................354 10 Poleć książkęKup książkę SPIS TREŚCI Jawne wyzwalanie procesu rekoncyliacji ...........................................................................355 Cykl życia komponentów .....................................................................................................357 Faza montowania ............................................................................................................358 Faza aktualizacji ..............................................................................................................361 Faza odmontowywania ..................................................................................................362 Hook efektów .........................................................................................................................363 Stosowanie zaawansowanych metod cyklu życia ..............................................................366 Unikanie niepotrzebnych aktualizacji komponentu .................................................366 Ustawianie danych stanu na podstawie właściwości props ......................................369 Podsumowanie .......................................................................................................................371 Rozdział 14. Konstruowanie aplikacji ............................................................................ 373 Przygotowania do prac w tym rozdziale ............................................................................374 Tworzenie przykładowych komponentów .................................................................375 Podstawowe zależności pomiędzy komponentami ..........................................................377 Stosowanie właściwości props children .............................................................................377 Operacje na właściwości props children .....................................................................379 Tworzenie komponentów wyspecjalizowanych ................................................................382 Tworzenie komponentów wyższego rzędu ........................................................................385 Tworzenie komponentów wyższego rzędu ze stanem ..............................................388 Łączenie komponentów wyższego rzędu ....................................................................390 Stosowanie renderującej właściwości props ......................................................................392 Stosowanie renderującej właściwości props z argumentem .....................................394 Stosowanie kontekstu do przechowywania danych globalnych .....................................396 Definiowanie kontekstu .................................................................................................399 Tworzenie konsumentów kontekstu ...........................................................................400 Tworzenie dostawcy kontekstu ....................................................................................401 Modyfikowanie wartości danych kontekstu w konsumencie ..................................403 Stosowanie uproszczonego API konsumentów kontekstu .......................................406 Definiowanie granic błędów ................................................................................................408 Tworzenie komponentu granicy błędów ....................................................................409 Podsumowanie .......................................................................................................................412 Rozdział 15. Formularze i walidacja .............................................................................. 413 Przygotowania do prac w tym rozdziale ............................................................................414 Tworzenie przykładowych komponentów .................................................................415 Uruchamianie narzędzi programistycznych ..............................................................416 Stosowanie elementów formularzy .....................................................................................417 Stosowanie elementów select ........................................................................................419 Stosowanie przycisków opcji ........................................................................................421 Stosowanie pól wyboru ..................................................................................................423 Użycie pól wyboru do zapisywania wartości w tablicy .............................................424 Stosowanie wielowierszowych pól tekstowych ..........................................................426 Walidacja danych z formularzy ...........................................................................................427 Definiowanie reguł walidacji ........................................................................................428 Tworzenie komponentu kontenera .............................................................................430 Wyświetlanie komunikatów o błędach .......................................................................432 Zastosowanie walidacji ..................................................................................................432 11 Poleć książkęKup książkę SPIS TREŚCI Walidacja innych elementów i typów danych ...........................................................434 Przeprowadzanie całościowej walidacji formularza ..................................................439 Podsumowanie .......................................................................................................................443 Rozdział 16. Referencje i portale ................................................................................... 445 Przygotowania do prac w tym rozdziale ............................................................................446 Tworzenie referencji .............................................................................................................450 Użycie referencji do tworzenia niekontrolowanych komponentów formularzy .........452 Tworzenie referencji przy użyciu funkcji zwrotnych ................................................454 Walidacja niekontrolowanych komponentów formularzy ......................................457 Referencje a cykl życia ..........................................................................................................461 Stosowanie referencji z innymi bibliotekami lub frameworkami ..................................467 Dostęp do zawartości komponentów podrzędnych .........................................................470 Stosowanie przekazywania referencji ..........................................................................472 Stosowanie portali .................................................................................................................473 Podsumowanie .......................................................................................................................476 Rozdział 17. Testy jednostkowe .................................................................................... 477 Przygotowania do prac w tym rozdziale ............................................................................478 Tworzenie komponentów .............................................................................................480 Uruchamianie przykładowej aplikacji .........................................................................481 Uruchamianie zastępczego testu jednostkowego .............................................................482 Testowanie komponentów z wykorzystaniem renderowania płytkiego .......................484 Testowanie komponentów z użyciem pełnego renderowania ........................................488 Testowanie z użyciem właściwości props, stanu, metod i zdarzeń ................................490 Testowanie efektów działania metod ..........................................................................491 Testowanie efektów zdarzeń .........................................................................................491 Testowanie interakcji pomiędzy komponentami ......................................................492 Podsumowanie .......................................................................................................................494 Część III Tworzenie kompletnych aplikacji ...........................................495 Rozdział 18. Tworzenie kompletnych aplikacji .............................................................. 497 Tworzenie przykładowego projektu ...................................................................................498 Uruchamianie narzędzi programistycznych ..............................................................499 Tworzenie przykładowej aplikacji ......................................................................................499 Implementacja możliwości funkcjonalnych związanych z produktami ................500 Implementacja możliwości funkcjonalnych związanych z dostawcami ................504 Dokańczanie aplikacji ....................................................................................................508 Wyjaśnienie ograniczeń przedstawionej aplikacji ............................................................511 Podsumowanie .......................................................................................................................511 Rozdział 19. Stosowanie magazynu danych Redux ....................................................... 513 Przygotowania do prac w tym rozdziale ............................................................................514 Tworzenie magazynu danych ..............................................................................................515 Definiowanie typów danych .........................................................................................516 Definiowanie początkowych danych ...........................................................................516 Definiowanie typów akcji danych modelu .................................................................517 12 Poleć książkęKup książkę SPIS TREŚCI Definiowanie kreatorów akcji danych modelu ..........................................................517 Definiowanie reduktora .................................................................................................518 Tworzenie magazynu danych .......................................................................................520 Stosowanie magazynu danych w aplikacji Reacta ............................................................521 Użycie magazynu danych w komponencie najwyższego poziomu .........................521 Podłączanie danych produktów ...................................................................................522 Podłączanie danych dostawców ...................................................................................524 Rozszerzanie magazynu danych ..........................................................................................527 Dodawanie stanu do magazynu danych ......................................................................527 Definiowanie typów i kreatorów akcji dla danych stanu ..........................................528 Definiowanie reduktora danych stanu ........................................................................529 Dodawanie nowych opcji obsługi danych do aplikacji .............................................529 Podłączanie komponentów Reacta do danych stanu w magazynie ........................531 Rozsyłanie wielu akcji ...........................................................................................................535 Wyjaśnienie potrzeby użycia referencji ..............................................................................537 Podsumowanie .......................................................................................................................539 Rozdział 20. Stosowanie API magazynu danych ............................................................... 541 Przygotowania do prac w tym rozdziale ............................................................................542 Stosowanie API magazynu danych Redux .........................................................................542 Pobieranie stanu magazynu danych ............................................................................543 Obserwowanie zmian w magazynie danych ...............................................................546 Rozsyłanie akcji ...............................................................................................................547 Tworzenie komponentu konektora .............................................................................549 Rozszerzanie możliwości reduktorów ................................................................................552 Stosowanie komponentów warstwy pośredniej magazynu danych ...............................555 Rozszerzanie magazynu danych ..........................................................................................558 Zastosowanie funkcji rozszerzenia ...............................................................................560 Stosowanie API pakietu React-Redux ................................................................................562 Zaawansowane możliwości metody connect ..............................................................562 Podsumowanie .......................................................................................................................568 Rozdział 21. Trasowanie adresów URL .......................................................................... 569 Przygotowania do prac w tym rozdziale ............................................................................570 Rozpoczynanie korzystania z mechanizmu trasowania .......................................................571 Wprowadzenie do użycia komponentu Link .............................................................573 Wprowadzenie do użycia komponentu Route ...........................................................573 Reagowanie na nawigację .....................................................................................................574 Wybieranie komponentów i treści ...............................................................................574 Dopasowywanie adresów URL .....................................................................................576 Dopasowywanie pojedynczej trasy ..............................................................................581 Użycie przekierowań jako trasy awaryjnej ..................................................................583 Generowanie odnośników nawigacyjnych ........................................................................585 Wskazywanie aktywnej trasy ........................................................................................587 Wybór i konfiguracja mechanizmu trasowania ................................................................589 Stosowanie komponentu HashRouter .........................................................................590 Podsumowanie .......................................................................................................................591 13 Poleć książkęKup książkę SPIS TREŚCI Rozdział 22. Zaawansowane zagadnienia trasowania adresów URL ............................. 593 Przygotowania do prac w tym rozdziale ............................................................................594 Tworzenie komponentów świadomych trasowania .........................................................595 Prezentacja właściwości props match ..........................................................................596 Prezentacja właściwości props location ......................................................................598 Stosowanie parametrów adresów URL .......................................................................599 Dostęp do danych trasowania w innych komponentach ................................................605 Bezpośredni dostęp do danych mechanizmu trasowania w komponencie ...........605 Dostęp do danych mechanizmu trasowania przy użyciu komponentu wyższego rzędu ...............................................................607 Programowe prowadzenie nawigacji ..................................................................................609 Nawigacja programowa z użyciem komponentów ...................................................610 Pytanie użytkownika przed wykonaniem nawigacji .................................................611 Programowe generowanie tras ............................................................................................615 Trasowanie z komponentami podłączonymi do magazynu danych .............................617 Zastępowanie komponentów ProductDisplay i SupplierDisplay ...........................618 Aktualizacja podłączonego komponentu edytora .....................................................619 Aktualizowanie komponentu tabeli podłączonej do magazynu danych ...............620 Dokończenie konfiguracji trasowania .........................................................................622 Podsumowanie .......................................................................................................................624 Rozdział 23. Korzystanie z usługi internetowej typu RESTful ......................................... 625 Przygotowania do prac w tym rozdziale ............................................................................626 Dodanie pakietów do projektu .....................................................................................626 Przygotowanie usługi internetowej .............................................................................627 Dodanie komponentu i trasy ........................................................................................628 Uruchamianie usługi internetowej i aplikacji ............................................................629 Opis usług internetowych typu RESTful ...........................................................................631 Korzystanie z usługi internetowej .......................................................................................632 Tworzenie komponentu źródła danych ......................................................................633 Pobieranie danych w komponencie .............................................................................635 Zapisywanie, aktualizacja i usuwanie danych ............................................................636 Obsługa błędów ..............................................................................................................642 Korzystanie z usługi internetowej w magazynie danych .................................................647 Tworzenie nowego komponentu warstwy pośredniej ..............................................647 Dodanie komponentu warstwy pośredniej do magazynu danych ..........................648 Dokańczanie zmian w aplikacji ....................................................................................649 Podsumowanie .......................................................................................................................651 Rozdział 24. Przedstawienie GraphQL-a ........................................................................ 653 Przygotowania do prac w tym rozdziale ............................................................................654 Omówienie GraphQL-a ........................................................................................................655 Tworzenie serwera GraphQL-a ...........................................................................................656 Tworzenie schematu ......................................................................................................657 Tworzenie resolwerów ...................................................................................................658 Tworzenie serwera .........................................................................................................658 Wykonywanie zapytań GraphQL-a ....................................................................................660 Pytania dotyczące powiązanych ze sobą danych .......................................................661 Tworzenie zapytań z argumentami .............................................................................664 14 Poleć książkęKup książkę SPIS TREŚCI Wykonywanie mutacji GraphQL-a ....................................................................................669 Inne możliwości GraphQL-a ...............................................................................................672 Stosowanie zmiennych żądania ....................................................................................672 Wykonywanie wielu żądań ...........................................................................................673 Stosowanie fragmentów do wybierania pól ................................................................675 Podsumowanie .......................................................................................................................676 Rozdział 25. Korzystanie z GraphQL-a ........................................................................... 677 Przygotowania do prac w tym rozdziale ............................................................................677 Dodanie niezbędnych pakietów ...................................................................................677 Zmiana danych dla serwera GraphQL-a .....................................................................678 Aktualizacja schematu i resolwerów ............................................................................678 Integracja serwera GraphQL-a z narzędziami programistycznymi Reacta ...........681 Korzystanie z usługi GraphQL ............................................................................................682 Zdefiniowanie zapytań i mutacji ..................................................................................682 Definiowanie źródła danych .........................................................................................684 Konfiguracja komponentów izolowanych ..................................................................685 Używanie GraphQL-a z magazynem danych ....................................................................687 Dostosowanie do formatu danych GraphQL-a ..........................................................689 Stosowanie frameworka klienta GraphQL .........................................................................693 Konfiguracja klienta .......................................................................................................693 Tworzenie komponentów korzystających z GraphQL-a ..........................................694 Stosowanie mutacji .........................................................................................................698 Dodanie obsługi danych dostawców oraz edycji danych .........................................702 Podsumowanie .......................................................................................................................707 15 Poleć książkęKup książkę Poleć książkęKup książkę R O Z D Z I A Ł 1 .    Twoja pierwsza aplikacja Reacta Najlepszym sposobem, by rozpocząć korzystanie z Reacta, jest zakasać rękawy i wziąć się do pracy. W tym rozdziale przedstawię prosty proces tworzenia aplikacji zarządzającej listą rzeczy do zrobienia. W rozdziałach od 5. od 8. opiszę tworzenie bardziej złożonej i realistycznej aplikacji, lecz jak na razie prosty przykład w zupełności wystarczy, by pokazać sposób tworzenia aplikacji Reacta oraz wyjaśnić sposób ich działania i podstawowe możliwości. Nie przejmuj się, jeśli nie zrozumiesz wszystkiego, o czym będę pisał w tym rozdziale — jego głównym celem jest, byś poznał sposób działania Reacta. Wszelkie szczegóły wyjaśnię dokładnie w kolejnych rozdziałach.  Uwaga Jeśli szukasz zwyczajnego opisu możliwości frameworka React, zajrzyj do drugiej części tej książki, w której rozpocznę szczegółową prezentację jego poszczególnych możliwości. Jednak zanim przejdziesz dalej, upewnij się, że masz zainstalowane wszelkie niezbędne narzędzia programistyczne i pakiety opisane w tym rozdziale. Przygotowanie środowiska programistycznego Korzystanie z frameworka React wymaga pewnych przygotowań. W kolejnych punktach tego rozdziału opiszę, jak przygotować się do utworzenia pierwszej aplikacji Reacta. Instalacja Node.js Narzędzia używane do tworzenia aplikacji Reacta bazują na Node.js — określanym także jako Node — utworzonym w 2009 roku jako proste i wygodne środowisko do tworzenia aplikacji serwerowych w języku JavaScript. Node.js bazuje na silniku JavaScript używanym w przeglądarce Chrome i udostępnia API służące do wykonywania kodu JavaScript poza środowiskiem przeglądarki WWW. Node.js odniósł duży sukces jako serwer aplikacji, a w kontekście tej książki jest on interesujący, gdyż stanowi podstawę dla nowej generacji wieloplatformowych aplikacji i narzędzie do ich budowania. Duże znaczenie ma to, byś zainstalował tę samą wersję Node.js, której używam w tej książce. Choć Node.js jest stosunkowo stabilnym środowiskiem, to jednak od pewnego czasu w jego API są wprowadzane zmiany, które mogłyby doprowadzić do problemów w działaniu prezentowanych przeze mnie przykładów. W tej książce będę używał Node.js w wersji 10.14.1, która w czasie prac Poleć książkęKup książkę REACT 16. FRAMEWORK DLA PROFESJONALISTÓW nad książką miała status wersji LTS1 (ang. Long-Term Support). Może się zdarzyć, że kiedy będziesz czytać tę książkę, będą dostępne nowsze wersje Node, jednak pracując nad prezentowanymi przykładami, powinieneś używać wersji 10.14.1. Kompletny zestaw zasobów związanych z tą wersją Node, w tym także programy instalacyjne dla systemów Windows i macOS oraz pakiet dla innych platform systemowych, można znaleźć na stronie https://nodejs.org/dist/v10.14.1/. Podczas instalowania Node.js koniecznie zaznacz opcję pozwalającą na dodanie do ścieżki plików wykonywalnych środowiska. Po zakończeniu instalacji wykonaj polecenie przedstawione na listingu 1.1. Listing 1.1. Sprawdzanie wersji Node node -v Jeśli instalacja przebiegła pomyślnie, to wykonanie powyższego polecenia powinno spowodować wyświetlenie następującego komunikatu: v10.14.1 Zainstalowane środowisko Node.js zawiera Node Package Manager (NPM) — program służący do zarządzania pakietami wchodzącymi w skład projektu. Wykonaj polecenie przedstawione na listingu 1.2, aby upewnić się, że NPM działa prawidłowo. Listing 1.2. Sprawdzanie działania NPM npm -v Jeśli wszystko poszło, jak należy, to powinien zostać wyświetlony poniższy numer wersji: 6.4.1 Instalacja pakietu create-react-app Pakiet create-react-app jest standardowym sposobem tworzenia złożonych pakietów Reacta i zarządzania nimi oraz dostarcza programistom kompletny zestaw narzędziowy (ang. toolchain). Są także inne sposoby rozpoczynania pracy z frameworkiem React, jednak korzystanie z pakietu create-react-app najlepiej odpowiada potrzebom większości projektów i właśnie jego będę używał w tej książce. Aby zainstalować ten pakiet, należy otworzyć nowe okno wiersza poleceń i wykonać polecenie przedstawione na listingu 1.3. W systemach Linux lub macOS konieczne może być użycie polecenia sudo. Listing 1.3. Instalowanie pakietu create-react-app npm install --global create-react-app@2.1.2 1 LTS to wersje, które są aktualnie wspierane przez twórców Node.js i które są zalecane do stosowania w rozwiązaniach produkcyjnych — przyp. tłum. 22 Poleć książkęKup książkę ROZDZIAŁ 1.  TWOJA PIERWSZA APLIKACJA REACTA Instalacja Git System kontroli wersji Git jest narzędziem wymaganym do zarządzania niektórymi pakietami niezbędnymi do tworzenia aplikacji Reacta. Użytkownicy systemów Windows i macOS mogą pobrać programy instalacyjne dla swoich platform ze strony https://git-scm.com/downloads. (W przypadku systemu macOS uruchomienie programu instalacyjnego, który nie został cyfrowo podpisany przez twórców, wymaga zmiany ustawień bezpieczeństwa). Większość dystrybucji systemu Linux jest domyślnie wyposażona w program Git. Jeśli jednak ktoś chce zainstalować jego nowszą wersję, to powinien przejrzeć instrukcje instalacji dla używanej dystrybucji dostępne na stronie https://git-scm.com/download/linux. Listing 1.4 przedstawia polecenie pozwalające zainstalować Git w systemie Ubuntu, który jest używaną przeze mnie dystrybucją Linuksa. Listing 1.4. Instalacja Git sudo apt-get install git Po zainstalowaniu można otworzyć nowe okno wiersza poleceń i sprawdzić numer zainstalowanej wersji programu Git, wykonując polecenie przedstawione na listingu 1.5. Listing 1.5. Sprawdzanie wersji Git git --version Wykonanie tego polecenia spowoduje wyświetlenie wersji zainstalowanego pakietu Git. W czasie przygotowywania niniejszej książki najnowsza dostępna wersja miała numer 2.23.0. Instalacja edytora Aplikacje Reacta można tworzyć, używając dowolnego edytora dla programistów, a tych jest niemal nieskończenie wiele. Niektóre z nich dysponują rozbudowanymi mechanizmami wspierającymi tworzenie aplikacji Reacta, takimi jak podświetlanie słów kluczowych oraz wyrażeń. Jeśli jeszcze nie masz swojego ulubionego edytora do tworzenia aplikacji internetowych, to możesz rozważyć użycie jednego z popularnych programów przedstawionych w tabeli 1.1. Pisząc tę książkę, nie korzystałem z żadnego konkretnego z nich, a Ty możesz wybrać ten, który będzie Ci najbardziej odpowiadać. Instalacja przeglądarki Ostatnią decyzją, jaką należy podjąć, jest wybór przeglądarki używanej podczas pracy do sprawdzania tworzonej aplikacji. Wszystkie nowoczesne przeglądarki mają świetne narzędzia dla programistów, które dobrze współdziałają z frameworkiem React; niemniej jednak istnieje użyteczne rozszerzenie dla przeglądarek Chrome i Firefox, react-devtools, które zapewnia możliwość przeglądania stanu aplikacji Reacta i jest szczególnie przydatne w przypadku tworzenia złożonych projektów. Szczegółowe informacje o tym rozszerzeniu oraz sposobie jego instalacji można znaleźć na stronie https://github.com/facebook/react-devtools. Podczas prac nad tą książką używałem przeglądarki Google Chrome i polecam korzystanie z niej podczas prac nad prezentowanymi przykładami. 23 Poleć książkęKup książkę REACT 16. FRAMEWORK DLA PROFESJONALISTÓW Tabela 1.1. Popularne edytory dla programistów Nazwa Sublime Text Opis Sublime Text to komercyjny edytor działający na wielu platformach systemowych, dysponujący pakietami wspierającymi programowanie w większości używanych języków programowania, frameworkach i platformach. Szczegółowe informacje na jego temat można znaleźć na stronie http://www.sublimetext.com. Atom to edytor rozpowszechniany jako oprogramowanie open-source, działający na wielu platformach, którego twórcy zwracają szczególną uwagę na rozszerzalność i możliwości konfiguracji. Szczegółowe informacje na jego temat można znaleźć na stronie https://atom.io. Brackets to edytor stworzony przez firmę Adobe i rozpowszechniany jako oprogramowanie open-source. Informacje na jego temat można znaleźć na stronie http://brackets.io. To edytor stworzony przez firmę Microsoft i udostępniany jako oprogramowanie open-source; działa on na wielu platformach systemowych i zapewnia duże możliwości rozszerzania. Informacje na jego temat można znaleźć na stronie https://code.visualstudio.com. Visual Studio jest flagowym narzędziem dla programistów stworzonym przez firmę Microsoft. Jest ono dostępne zarówno w wersji darmowej, jak i w komercyjnych. Visual Studio jest dostarczane wraz z szerokim zestawem narzędzi dodatkowych, które zapewniają jego integrację z ekosystemem firmy Microsoft. Atom Brackets Visual Studio Code Visual Studio Tworzenie projektu Projekty są tworzone i zarządzane z poziomu wiersza pleceń. Aby utworzyć nowy projekt, otwórz nowe okno wiersza poleceń, przejdź do wybranego katalogu i wykonaj polecenie przedstawione na listingu 1.6.  Wskazówka Przykładowy projekt przedstawiony w tym rozdziale można znaleźć w przykładach dołączonych do książki, które można pobrać z serwera FTP wydawnictwa Helion:ftp://ftp.helion.pl/przyklady/reac16.zip. Listing 1.6. Tworzenie projektu npx create-react-app zadania Polecenie npx zostało zainstalowane w poprzednim podrozdziale wraz z Node.js i NPM. Służy ono do wykonywania pakietów Node.js. Argument create-react-app informuje program npx, że należy wykonać pakiet create-react-app służący do tworzenia nowych aplikacji Reacta i zainstalowany przy użyciu polecenia z listingu 1.3. Ostatni argument polecenia, zadania, określa nazwę tworzonego projektu. Wykonanie tego polecenia spowoduje utworzenie projektu oraz
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

React 16. Framework dla profesjonalistów
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: