O autorze (11)

O recenzencie technicznym (12)

Wprowadzenie (13)

Rozdział 1. Pierwsze kroki w języku Swift (17)

• Czym jest Swift? (18)
  • Funkcje języka Swift (19)
• Plik typu playground (21)
  • Rozpoczęcie pracy z plikiem typu playground (21)
  • Typ pliku playground (24)
  • Wyświetlanie obrazu w pliku playground (25)
  • Tworzenie i wyświetlanie wykresu w pliku playground (28)
  • Czym nie jest plik typu playground? (29)
  • Składnia języka Swift (29)
  • Komentarze (30)
  • Średniki (32)
  • Nawiasy okrągłe (33)
  • Nawiasy klamrowe (33)
  • Operator przypisania nie zwraca wartości (34)
  • Białe znaki w konstrukcjach warunkowych i poleceniach przypisania są opcjonalne (35)
• Program wyświetlający komunikat Witaj, świecie! (35)
• Podsumowanie (37)

Rozdział 2. Zmienne, stałe, ciągi tekstowe i operatory (39)

• Zmienne i stałe (40)
  • Definiowanie zmiennych i stałych (41)
  • Bezpieczeństwo typu (42)
  • Inferencja typu (43)
  • Jawne określenie typu (43)
  • Typy liczbowe (44)
  • Wartości boolowskie (48)
  • Ciąg tekstowy (48)
  • Zmienne typu opcjonalnego (52)
  • Dołączanie wartości typu opcjonalnego (54)
  • Łączenie wartości typu opcjonalnego (55)
  • Typy wyliczeniowe (57)
• Operatory (61)
  • Operator przypisania (61)
  • Operatory porównania (61)
  • Operatory arytmetyczne (62)
  • Operator reszty z dzielenia (62)
  • Złożone operatory przypisania (63)
  • Trójargumentowy operator warunkowy (63)
  • Operator logiczny NOT (63)
  • Operator logiczny AND (64)
  • Operator logiczny OR (64)
• Podsumowanie (64)

Rozdział 3. Krotki i kolekcje (67)

• Typy kolekcji w Swifcie (67)
• Modyfikowalność (68)
• Tablica (68)
  • Tworzenie oraz inicjalizacja tablicy (69)
  • Uzyskanie dostępu do elementu tablicy (70)
  • Zliczanie elementów tablicy (71)
  • Czy tablica jest pusta? (72)
  • Dodawanie elementu do tablicy (72)
  • Wstawienie wartości do tablicy (73)
  • Zastępowanie elementu tablicy (73)
  • Usunięcie elementu z tablicy (73)
  • Połączenie dwóch tablic (74)
  • Pobranie podtablicy z tablicy (74)
  • Wprowadzenie wielu zmian w tablicy (75)
  • Algorytmy dla tablic (75)
  • Iteracja przez tablicę (78)
• Słownik (79)
  • Utworzenie oraz inicjalizacja słownika (79)
  • Uzyskanie dostępu do wartości słownika (80)
  • Zliczanie kluczy lub wartości w słowniku (80)
  • Czy słownik jest pusty? (80)
  • Uaktualnienie wartości klucza (81)
  • Dodanie pary klucz-wartość (81)
  • Usunięcie pary klucz-wartość (82)
• Zbiór (82)
  • Inicjalizacja zbioru (82)
  • Wstawianie elementów do zbioru (83)
  • Określenie liczby elementów w zbiorze (83)
  • Sprawdzenie, czy zbiór zawiera dany element (84)
  • Iteracja przez zbiór (84)
  • Usunięcie elementu zbioru (84)
  • Operacje na zbiorze (84)
• Krotka (86)
• Podsumowanie (87)

Rozdział 4. Funkcje programu i sterowanie przebiegiem ich działania (89)

• Czego nauczyłeś się dotąd z książki? (90)
  • Nawias klamrowy (90)
  • Nawias okrągły (90)
• Sterowanie przebiegiem działania programu (91)
  • Konstrukcje warunkowe (91)
  • Pętla for-in (94)
  • Pętla while (96)
  • Konstrukcja switch (97)
  • Używanie bloków case i klauzul where w konstrukcjach warunkowych (101)
  • Polecenia transferu kontroli (105)
• Funkcje (107)
  • Funkcja z pojedynczym parametrem (107)
  • Funkcja z wieloma parametrami (109)
  • Zdefiniowanie wartości domyślnych parametrów (109)
  • Zwrot wielu wartości przez funkcję (110)
  • Zwrot wartości typu opcjonalnego (111)
  • Dodawanie zewnętrznych nazw parametrów (112)
  • Używanie parametrów wariadycznych (113)
  • Parametr inout (114)
• Zebranie wszystkiego w całość (114)
• Podsumowanie (115)

Rozdział 5. Klasy i struktury (117)

• Czym są klasy i struktury? (118)
  • Podobieństwa między klasami i strukturami (118)
  • Różnice między klasami i strukturami (118)
  • Przekazywanie przez wartość kontra przez referencję (119)
• Utworzenie klasy lub struktury (120)
  • Właściwość (120)
  • Właściwość przechowywana (120)
  • Właściwość obliczana (122)
  • Obserwator właściwości (125)
  • Metoda (126)
• Własna metoda inicjalizacyjna (128)
  • Wewnętrzne i zewnętrzne nazwy parametru metody inicjalizacyjnej (130)
  • Metoda inicjalizacyjna, której działanie może zakończyć się niepowodzeniem (130)
• Kontrola dostępu (132)
• Dziedziczenie (133)
• Nadpisanie metody lub właściwości (135)
  • Nadpisywanie metody (136)
  • Nadpisywanie właściwości (137)
  • Uniemożliwianie nadpisywania (138)
• Protokoły (138)
• Składnia protokołu (139)
  • Wymagania właściwości (139)
  • Wymagania metody (140)
• Rozszerzenie (142)
• Zarządzanie pamięcią (143)
  • Sposób działania mechanizmu ARC (143)
  • Cykl silnych odwołań (145)
• Podsumowanie (149)

Rozdział 6. Protokoły i rozszerzenia protokołów (151)

• Protokół jako typ danych (152)
• Polimorfizm za pomocą protokołów (154)
• Rzutowanie typu i protokół (154)
• Rozszerzenie protokołu (156)
• Czy trzeba używać protokołów? (163)
• Biblioteka standardowa Swifta (164)
• Podsumowanie (165)

Rozdział 7. Projekt oparty na protokołach (167)

• Wymagania (168)
• Projekt zorientowany obiektowo (168)
• Projekt zorientowany na protokoły (174)
  • Dziedziczenie protokołu (174)
  • Kompozycja protokołu (175)
  • Programowanie zorientowane na protokoły (176)
  • Używanie klauzuli where z protokołem (179)
• Struktura kontra klasa (180)
• Struktura tablicy (181)
• Podsumowanie (182)

Rozdział 8. Tworzenie bezpiecznego kodu za pomocą atrybutu available i obsługi błędów (183)

• Natywna obsługa błędów (184)
  • Przedstawienie błędu (184)
  • Zgłaszanie błędu (185)
  • Przechwytywanie błędu (187)
• Atrybut available (191)
• Podsumowanie (192)

Rozdział 9. Niestandardowe indeksy (193)

• Wprowadzenie do indeksów (194)
• Indeks w tablicy Swifta (194)
• Tworzenie i używanie niestandardowego indeksu (195)
• Niestandardowy indeks tylko do odczytu (196)
• Indeks obliczany (197)
• Wartość indeksu (197)
• Nazwa zewnętrzna dla indeksu (198)
• Indeks wielowymiarowy (198)
• Kiedy nie należy używać niestandardowego indeksu? (201)
• Podsumowanie (202)

Rozdział 10. Typy opcjonalne (203)

• Wprowadzenie do typu opcjonalnego (203)
• Potrzeba istnienia typów opcjonalnych w Swifcie (205)
  • Definiowanie wartości typu opcjonalnego (206)
  • Używanie wartości typu opcjonalnego (206)
• Łączenie wartości typu opcjonalnego (211)
  • Operator koalescencji nil (213)
• Podsumowanie (214)

Rozdział 11. Typy generyczne (215)

• Wprowadzenie do typu generycznego (215)
• Funkcja generyczna (216)
• Typ generyczny (220)
• Indeks generyczny (223)
• Typ powiązany (224)
• Podsumowanie (226)

Rozdział 12. Domknięcia (227)

• Wprowadzenie do domknięcia (227)
• Proste domknięcia (228)
• Skrócona składnia domknięcia (230)
• Używanie domknięcia wraz z algorytmem tablicy Swifta (233)
• Samodzielne domknięcia i wskazówki dotyczące dobrego stylu (237)
• Zmiana funkcjonalności (239)
• Wybór domknięcia na podstawie wyniku (242)
• Utworzenie cyklu silnych odwołań za pomocą domknięć (244)
• Podsumowanie (247)

Rozdział 13. Połączenie Swifta i Objective-C (249)

• Połączenie Swifta i Objective-C (249)
• Kiedy łączyć kod Swifta i Objective-C? (250)
• Użycie Swifta i Objective-C w tym samym projekcie (251)
  • Utworzenie projektu (251)
  • Dodawanie pliku Swifta do projektu Objective-C (253)
  • Plik Objective-C Bridging Header - część 1. (255)
  • Dodawanie pliku Objective-C do projektu (256)
  • Klasa Objective-C Messages (258)
  • Plik Objective-C Bridging Header - część 2. (259)
  • Klasa Swifta MessageBuilder - dostęp do kodu Objective-C z poziomu Swifta (259)
  • Klasa Objective-C - dostęp do kodu Swifta z poziomu Objective-C (260)
• Podsumowanie (261)

Rozdział 14. Programowanie równoległe i współbieżność (263)

• Równoległość i współbieżność (264)
  • Grand Central Dispatch (265)
  • Typ DoCalculations (266)
  • Użycie typów Operation i OperationQueue (272)
• Podsumowanie (277)

Rozdział 15. Formatowanie kodu Swifta i przewodnik po jego stylu (279)

• Czym jest styl programowania? (280)
• Twój styl programowania (281)
  • Nie używaj średnika na końcu polecenia (281)
  • Nie używaj nawiasu w konstrukcji warunkowej (281)
  • Konwencja nazw (282)
  • Komentarze (283)
  • Użycie słowa kluczowego self (284)
  • Stałe i zmienne (285)
  • Typy opcjonalne (285)
  • Użycie inferencji typu (286)
  • Użycie skróconych deklaracji kolekcji (287)
  • Użycie konstrukcji switch zamiast wielu poleceń if (287)
  • Nie pozostawiaj w aplikacji kodu umieszczonego w komentarzu (287)
• Podsumowanie (288)

Rozdział 16. Podstawowe biblioteki Swifta (289)

• System wczytywania adresów URL (290)
  • URLSession (291)
  • URLSessionConfiguration (291)
  • URLSessionTask (291)
  • URL (292)
  • URLRequest (292)
  • HTTPURLResponse (292)
  • Usługa sieciowa typu REST (292)
  • Wykonywanie żądania HTTP GET (293)
  • Wykonywanie żądania HTTP POST (296)
• Formatter (298)
  • DateFormatter (298)
  • NumberFormatter (300)
  • FileManager (301)
• Kodowanie i dekodowanie danych JSON (304)
  • Użycie JSONEncoder (305)
  • Użycie JSONDecoder (306)
• Podsumowanie (307)

Rozdział 17. Wzorce projektowe w Swifcie (309)

• Czym są wzorce projektowe? (310)
• Wzorce konstrukcyjne (311)
  • Wzorzec singleton (312)
  • Wzorzec budowniczego (315)
• Wzorce strukturalne (320)
  • Wzorzec mostu (320)
  • Wzorzec fasady (324)
  • Wzorzec pełnomocnika (327)
• Wzorce operacyjne (330)
  • Wzorzec polecenia (330)
  • Wzorzec strategii (333)
• Podsumowanie (335)

Skorowidz (337)

• Titel: Swift 4. Koduj jak mistrz. Wydanie IV
• Autor: Jon Hoffman
• Originaler Titel: Mastering Swift 4 - Fourth Edition
• Übersetzung: Robert Górczyński
• ISBN: 978-83-283-4795-3, 9788328347953
• Veröffentlichungsdatum: 2018-10-05
• Format: E-book
• Artikelkennung: sw4km4
• Verleger: Helion