Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00155 009312 7431427 na godz. na dobę w sumie
Podstawy języka Swift. Programowanie aplikacji dla platformy iOS - ebook/pdf
Podstawy języka Swift. Programowanie aplikacji dla platformy iOS - ebook/pdf
Autor: , Liczba stron: 232
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1915-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> inne - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).
Język Swift, uważany za następcę Objective-C, bardzo szybko stał popularny wśród programistów tworzących aplikacje na platformę iOS. Dzieje się tak z wielu przyczyn: Swift w porównaniu ze swoim poprzednikiem charakteryzuje się dużo bardziej zwięzłą i przejrzystą składnią, a kod napisany w tym języku jest znacznie krótszy i czytelniejszy. Ponadto Swift łączy wiele elementów takich języków, jak: JavaScript, Python, Ruby czy C#, dzięki czemu osoby posługujące się tymi językami nie powinny mieć trudności z opanowaniem Swifta.

Swift jest językiem kompilowanym o dużej wydajności, z kompilatorem typu LLVM (ang. Low Level Virtual Machine). Oferuje on liczne funkcje wspomagające programowanie, przy tym jest elastyczny, jeśli chodzi o typy danych. Dzięki swej strukturze umożliwia wykorzystywanie paradygmatu programowania funkcyjnego.

Autor tej książki, uznany autorytet w dziedzinie programowania, w przystępny sposób przedstawił podstawy programowania w Swifcie i przygotował cały zestaw utrwalających tę wiedzę ćwiczeń i przykładów.
Z racji tego, że Swift jest bardzo nowym i bardzo obiecującym językiem programowania, umiejętność tworzenia w nim może wkrótce stać się Twoim atutem — zacznij naukę już dziś!

Dzięki tej książce:
Znajdź podobne książki

Darmowy fragment publikacji:

Tytuł oryginału: Swift Fundamentals: The Language of iOS Development Tłumaczenie: Robert Górczyński Projekt okładki: Studio Gravite / Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki ISBN: 978-83-283-1912-7 © 2014 by LearnToProgram.tv, Incorporated All rights reserved. No part of this document may be reproduced or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without prior written permission of LearnToProgram.tv, Incorporated. Polish edition copyright © 2016 by Helion S.A. 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 Wydawnictwo HELION 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 Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. Wydawnictwo HELION 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) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/pjswif.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/ 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 Rozdział 1. Rozpoczęcie pracy .................................................................................................. 9 1.1. Aplikacja typu „Witaj, świecie!” w języku Swift ...............................................................................9 1.2. Praca w środowisku Xcode ...............................................................................................................17 Ćwiczenia do rozdziału 1. .......................................................................................................................26 Podsumowanie .........................................................................................................................................27 Rozdział 2. Zmienne ............................................................................................................... 29 2.1. Tworzenie zmiennych i stałych ........................................................................................................29 2.2. Typy zmiennej ...................................................................................................................................35 2.3. Operatory arytmetyczne ...................................................................................................................39 2.4. Rzutowanie typu ...............................................................................................................................44 2.5. Interpolacja ciągu tekstowego ..........................................................................................................46 Ćwiczenia do rozdziału 2. .......................................................................................................................50 Podsumowanie .........................................................................................................................................50 Rozdział 3. Przepływ kontroli działania programu .............................................................. 53 3.1. Polecenie if .........................................................................................................................................53 3.2. Złożone i skomplikowane polecenia if .............................................................................................59 3.3. Konstrukcja switch ...........................................................................................................................67 3.4. Pętla while .........................................................................................................................................71 3.5. Pętla for .............................................................................................................................................76 3.6. Pętla for-in ........................................................................................................................................79 Ćwiczenia do rozdziału 3. .......................................................................................................................82 Podsumowanie .........................................................................................................................................83 Rozdział 4. Tablice i słowniki ................................................................................................. 85 4.1. Tworzenie i uaktualnianie tablic .....................................................................................................85 4.2. Funkcje array.count() i array.slice() ...............................................................................................89 4.3. Funkcje tablicy ..................................................................................................................................95 4.4. Utworzenie słownika ......................................................................................................................103 4.5. Funkcje słownika ............................................................................................................................106 Ćwiczenia do rozdziału 4. .....................................................................................................................112 Podsumowanie .......................................................................................................................................113 5 Poleć książkęKup książkę Podstawy języka Swift Rozdział 5. Funkcje ................................................................................................................115 5.1. Definicja i wywołanie funkcji ........................................................................................................115 5.2. Funkcje pobierające argumenty .....................................................................................................119 5.3. Funkcje zwracające wartość ...........................................................................................................124 5.4. Funkcje i zasięg zmiennej lub stałej ..............................................................................................129 5.5. Funkcje zagnieżdżone .....................................................................................................................133 Ćwiczenia do rozdziału 5. .....................................................................................................................136 Podsumowanie .......................................................................................................................................137 Rozdział 6. Klasy i protokoły .................................................................................................139 6.1. Typy wyliczeniowe ..........................................................................................................................139 6.2. Tworzenie klasy i jej egzemplarza .................................................................................................146 6.3. Podklasy i nadpisywanie metod .....................................................................................................154 6.4. Protokoły .........................................................................................................................................161 Ćwiczenia do rozdziału 6. .....................................................................................................................166 Podsumowanie .......................................................................................................................................167 Rozdział 7. Więcej konstrukcji języka Swift .........................................................................169 7.1. Rozszerzenia ....................................................................................................................................169 7.2. Przeciążanie operatora ...................................................................................................................173 7.3. Funkcje generyczne .........................................................................................................................176 7.4. Emotikony .......................................................................................................................................179 Ćwiczenia do rozdziału 7. .....................................................................................................................182 Podsumowanie .......................................................................................................................................183 Rozdział 8. Aplikacja iOS 8 w języku Swift ...........................................................................185 8.1. Utworzenie interfejsu użytkownika aplikacji ...............................................................................185 8.2. Utworzenie outletów i akcji ...........................................................................................................194 8.3. Uruchomienie i przetestowanie aplikacji ......................................................................................203 Ćwiczenia do rozdziału 8. .....................................................................................................................208 Podsumowanie .......................................................................................................................................212 Odpowiedzi ............................................................................................................................213 Dodatek ..................................................................................................................................225 Skorowidz ...............................................................................................................................229 6 Mark A. Lassoff Poleć książkęKup książkę ROZDZIA(cid:224) 7. WIĘCEJ KONSTRUKCJI JĘZYKA SWIFT W ROZDZIALE: (cid:120) Dowiesz się, jak używać rozszerzeń w celu zwiększenia użyteczności klas i typów danych. (cid:120) Poznasz mechanizm przeciążania operatorów i przekonasz się, że to narzędzie, które można wykorzystać do bardzo wielu celów. (cid:120) Nauczysz się wykorzystywać funkcje generyczne i zobaczysz, że ich stosowanie może ograniczyć konieczność powielania kodu i zapewnić mu większą czytelność. (cid:120) Dowiesz się, jak można używać emotikonów w języku Swift. 7.1. ROZSZERZENIA Jak dotąd używaliśmy elementów wbudowanych w języku Swift lub też tworzyliśmy własne konstrukcje. Na przykład za każdym razem, gdy korzystaliśmy ze zmiennej w postaci liczby rzeczywistej, stosowaliśmy wbudowany typ Int. W przypadku własnych konstrukcji, takich jak klasy, prototypy i typy wyliczeniowe, mieliśmy możliwość zdefiniowania wymaganej funkcjonalności. Jednak w trakcie programowania zdarzają się sytuacje, w których nie ma możliwości bezpośredniej modyfikacji pierwotnego kodu lub też wbudowane elementy mają zostać użyte do wykonania znacznie poważniejszych zadań niż te, do których zostały zaprojektowane. Podczas zwiększania użyteczności istniejącego fragmentu kodu mówimy o rozszerzeniu jego możliwości poza wbudowane. Dokładnie tym są rozszerzenia w języku Swift: to metody egzemplarza dodane do istniejących klas, struktur lub typów wyliczeniowych. Aby zademonstrować rozszerzenie, rozbudujemy jeden z podstawowych typów danych i tym samym zwiększymy jego funkcjonalność. W Xcode utwórz nowy plik typu playground, po czym umieść w nim następujący fragment kodu: extension Double { // Miejsce na kod rozszerzaj(cid:261)cy funkcjonalno(cid:286)(cid:252). } 169 Poleć książkęKup książkę Podstawy języka Swift W powyższym fragmencie kodu użyliśmy nowego słowa kluczowego extension do utworzenia metody egzemplarza, która będzie dodana do klasy Double. Nową metodę egzemplarza możemy wywołać, ponieważ istnieje jedynie w programie, w którym została zdefiniowana. W naszym rozszerzeniu zdefiniujemy kilka nowych właściwości typu Double za pomocą techniki, która nie została jeszcze omówiona. Do pobrania wartości wspomnianych właściwości wykorzystamy właściwości obliczane. Właściwości obliczane nie przechowują wartości, ale zwracają wynik obliczeń. Kod przeznaczony do ustawiania i pobierania wartości właściwości obliczanych nosi nazwę odpowiednio setter i getter. W omawianym przykładzie użyjemy właściwości obliczanej przeznaczonej jedynie do odczytu. Te właściwości mogą być tylko odczytywane, nie można przypisać im wartości i mają jedynie blok getter. Dokładne wyjaśnienie właściwości obliczanych wykracza poza zakres tematyczny tej książki, ale wyczerpującą dokumentację na ten temat znajdziesz w witrynie Apple Developer. W przygotowanym szkielecie rozszerzenia usuń komentarz, a następnie wprowadź przedstawiony poniżej fragment kodu (patrz rysunek 7.1): var toFahrenheit : Double { return self * 9/5 + 32 } var toCelsius : Double { return self – 32 * 5/9 } Rysunek 7.1. Rozszerzenie typu danych Double za pomocą właściwości obliczanych W powyższym kodzie znajduje się wiele znanych Ci już elementów, choć jednocześnie pojawiły się nowe idee. Zadeklarowane zostały właściwości, mają przypisane nazwy oraz jasno określone typy. Jednak każda właściwość zamiast wartości ma polecenie return wraz z blokiem kodu. To blok kodu typu getter odpowiedzialny za obliczenie wartości właściwości. 170 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift W omawianym fragmencie kodu właściwości toFahrenheit przypisywana jest wartość zwrócona przez wyrażenie znajdujące się w bloku kodu. Słowo kluczowe self odwołuje się do wartości Double wywołującej właściwość toFahrenheit i jest używane w wyrażeniu w celu obliczenia temperatury w skali Fahrenheita. Następnie tej samej składni używamy do obliczenia temperatury Fahrenheita w skali Celsjusza. Po zdefiniowaniu rozszerzeń warto uzyskać do nich dostęp, aby upewnić się, że działają prawidłowo. Rozpoczynamy od znanej wartości, czyli zera stopni w skali Celsjusza. Po kodzie rozszerzenia wprowadź następujący fragment kodu: let temp:double_t = 0 print( \(temp) stopni Celsjusza to \(temp.toFahrenheit) stopni Fahrenheita. ) Powyżej utworzyliśmy stałą typu Double. Następnie zastosowaliśmy ją w interpolacji ciągu tekstowego w celu wyświetlenia wartości tej stałej typu Double o właściwości obliczonej Double.toFahrenheit(), za pomocą której rozszerzyliśmy typ danych Double. Otrzymane dane wyjściowe pokazałem na rysunku 7.2. Rysunek 7.2. Przygotowana przez nas właściwość obliczona zwraca po wywołaniu odpowiedni wynik Zmień wartość temp na 30, a następnie spójrz na wygenerowane dane wyjściowe (patrz rysunek 7.3). Rysunek 7.3. Weryfikacja implementacji właściwości obliczanej 7.1. Rozszerzenia 171 Poleć książkęKup książkę Podstawy języka Swift Ponownie zmień wartość temp, tym razem na 212, i zmodyfikuj kod, aby wprowadzona wartość została przekonwertowana na temperaturę w skali Celsjusza. Powinieneś otrzymać wynik pokazany na rysunku 7.4. print( \(temp) stopni Fahrenheita to \(temp.toCelsius) stopni Celsjusza. ) Rysunek 7.4. Za pomocą rozszerzenia typu danych Double przeprowadzamy konwersję temperatury w skali Fahrenheita na temperaturę w skali Celsjusza Jak możesz zobaczyć w powyższych fragmentach kodu, rozszerzenia pozwalają na implementację pewnych nowych metod i właściwości w istniejących typach danych oraz klasach projektu. W następnym podrozdziale przeanalizujemy podobną technikę zwiększania funkcjonalności operatorów. PYTANIA KONTROLNE 1) Co to jest rozszerzenie? a) Konstrukcja pozwalająca na dodanie funkcjonalności do kodu istniejących elementów. b) Sposób na zwiększenie precyzji typów danych Float i Double. c) Sposób na zapewnienie funkcji dodatkowego czasu potrzebnego na zwrócenie wartości. d) Metoda modyfikacji istniejących klas. 2) Jak przedstawia się poprawna składnia rozszerzenia? a) func:extension Double. b) extension Double. c) extension T:Double. d) extension (Double). 3) Rozszerzenie spowoduje modyfikację pierwotnego kodu w rozszerzanym elemencie. a) Prawda. b) Fałsz. 172 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift 4) Na co pozwalają nam właściwości obliczane? a) Na użycie predefiniowanych wartości domyślnych. b) Na użycie przekazanej wartości. c) Na przypisanie wartości zgodnej z obliczanym blokiem kodu. d) Na żadne z powyższych. 7.2. PRZECIĄŻANIE OPERATORA W poprzednim podrozdziale dowiedziałeś się, jak używać rozszerzeń w celu dodania funkcjonalności do już istniejących klas lub typów danych. W tym podrozdziale zobaczysz, jak uzyskać podobny efekt, ale w przypadku operatorów. Wykorzystamy do tego tak zwane przeciążanie operatora. Jest to technika dodawania funkcjonalności do operatorów i zwiększania ich możliwości zwłaszcza podczas pracy z wygenerowanymi przez użytkownika typami wyliczeniowymi, klasami i strukturami. O strukturach pokrótce wspomniałem już we wcześniejszej części książki. Struktury w języku Swift są przeznaczone do hermetyzacji niewielkich zbiorów prostych wartości. Struktury można porównać do klas, ponieważ mogą zawierać właściwości i metody. W przedstawionym poniżej kodzie utworzymy strukturę przeznaczoną do przechowywania danych punktów niezbędnych do utworzenia trójwymiarowego wektora, następnie utworzymy dwa wektory i na koniec spróbujemy je dodać za pomocą standardowego operatora dodawania. Zdefiniowanie trójwymiarowego wektora wymaga trzech współrzędnych x, y i z, dodawanie dwóch wektorów odbywa się natomiast przez dodanie ich odpowiednich współrzędnych x, y i z. Utwórz nowy plik typu playground w Xcode, a następnie wprowadź w nim przedstawiony poniżej fragment kodu. struct Vector { var x = 0 var y = 0 var z = 0 } var v1 = Vector(x:5, y:8, z:5) var v2 = Vector(x:9, y:4, z:2) print(v1+v2) W powyższym kodzie za pomocą słowa kluczowego struct utworzyliśmy strukturę. Składnia w definicji struktury jest podobna do stosowanej w klasach. Deklaracje trzech właściwości definiujących wektor zostały przygotowane za pomocą słowa kluczowego var. Ponieważ wszystkie właściwości mają przypisane wartości początkowe, nie ma konieczności użycia metody inicjalizującej. 7.2. Przeciążanie operatora 173 Poleć książkęKup książkę Podstawy języka Swift Po definicji struktury utworzyliśmy dwie zmienne typu Vector, a następnie przypisaliśmy im zdefiniowane wcześniej właściwości. Kolejnym krokiem jest próba wyświetlenia wyniku operacji dodania obu wektorów. Wynik wykonania powyższego kodu pokazałem na rysunku 7.5. Rysunek 7.5. Standardowy operator dodawania nie jest w stanie dodać przygotowanych przez nas struktur Vector Wygenerowany przez powyższy fragment kodu komunikat błędu informuje, że Swift nie potrafi dodać dwóch struktur Vector. W celu zdefiniowania funkcjonalności pozwalającej na dodawanie struktur Vector konieczne jest przeciążenie operatora dodawania. W pliku typu playground po definicji struktury wprowadź poniższy fragment kodu: func + (augend: Vector, addend: Vector) - Vector { return Vector(x: augend.x + addend.x, y: augend.y + addend.y, z: augend.z + addend.z) } W powyższym kodzie użyliśmy słowa kluczowego func oraz operatora przeznaczonego do przeciążenia. Następnie zdefiniowaliśmy argumenty przekazywane do przeciążenia (dwie zdefiniowane wcześniej struktury Vector) i na końcu wskazaliśmy, że wartość zwrotna ma być typu Vector. Wewnątrz bloku kodu wskazujemy językowi Swift, jak przedstawia się wartość zwrotna typu Vector. W omawianym przykładzie zdefiniowaliśmy, że zwracane wartości x, y i z typu Vector mają być sumami wartości x, y i z przekazanych danych typu Vector. Kod powinien wyglądać tak, jak pokazałem na rysunku 7.6. Skoro wskazaliśmy operatorowi dodawania, jak obsługiwać struktury typu Vector, za pomocą poniższego fragmentu kodu możemy przetestować przeciążony operator: var v3 = v1 + v2 print( x:\(v3.x) y:\(v3.y) z:\(v3.z) ) Utworzonej zmiennej v3 przypisujemy sumę v1 i v2, a dodawanie jest przeprowadzane za pomocą zdefiniowanego przeciążonego operatora. Podczas wyświetlania poszczególnych właściwości v3 powinieneś zobaczyć, że zostały poprawne obliczone zgodnie z wyrażeniem dodawania Vector. Otrzymane dane wyjściowe porównaj z pokazanymi na rysunku 7.7. 174 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift Rysunek 7.6. Przeciążenie operatora pozwala na dodanie funkcjonalności do operatorów w języku Swift Rysunek 7.7. Po utworzeniu przeciążonego operatora dla struktury Vector język Swift zyskuje możliwość przeprowadzania operacji dodawania dwóch wektorów Przeciążanie operatorów pozwala na większą elastyczność podczas tworzenia aplikacji, ponieważ zyskujesz możliwość wykonania większej liczby zadań za pomocą standardowych operatorów. Tym samym struktury, klasy, typy wyliczeniowe oraz inne niestandardowe typy stają się jeszcze bardziej wszechstronne. 7.2. Przeciążanie operatora 175 Poleć książkęKup książkę Podstawy języka Swift PYTANIA KONTROLNE 1) Przeciążanie operatora pozwala na trwałe modyfikowanie operatorów w języku Swift. a) Prawda. b) Fałsz. 2) Jak przedstawia się poprawna składnia przeciążania operatora? a) func - (myVarA: Int, myVarB: Int) - Int. b) overload func - (myVarA: Int, myVarB: Int) - Int. c) func:overload - (myVarA: Int, myVarB: Int) - Int. d) func - (myVarA, myVarB) - Int. 3) Do czego przede wszystkim służą struktury? a) Do zdefiniowania abstrakcyjnych reprezentacji obiektów. b) Do przechowywania podobnych grup elementów w sposób zapewniający bezpieczeństwo typu. c) Do hermetyzacji małych zbiorów prostych wartości. d) Są alternatywą dla klas. 4) Struktury mogą zawierać właściwości i metody. a) Prawda. b) Fałsz. 7.3. FUNKCJE GENERYCZNE Podczas tworzenia funkcji i metod wyraźnie deklarujemy typy przekazywanych im argumentów. Jednym z celów efektywnego programowania jest uniknięcie powielania tego samego kodu. Jednak czasami w trakcie pracy z różnymi typami danych powielenie kodu wydaje się nieuniknione. Kiedy potrzebujesz funkcji przeprowadzającej te same obliczenia na różnych typach danych, wówczas tworzysz wiele funkcji różniących się zaledwie nazwą i składnią definicji. Problem związany z powtarzaniem tego samego kodu można rozwiązać za pomocą funkcji generycznych. Funkcje generyczne w języku Swift to funkcje, które mogą działać ze wszystkimi zgodnymi z nimi typami danych. W ten sposób pozwalają na uniknięcie powielania kodu i jednocześnie zwiększają jego czytelność. Rozważ sytuację, gdy potrzebna jest funkcja sprawdzająca równość dwóch argumentów i zwracająca wartość typu boolowskiego. Kod funkcji będzie dokładnie taki sam, niezależnie od sprawdzanego typu danych. Jedyna różnica będzie występowała w deklaracji funkcji. W nowym pliku typu playground wprowadź przedstawiony poniżej fragment kodu: 176 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift func isEqualInt(a:Int, b:Int) - Bool { return a == b } print(isEqualInt(3, b: 3)) print(isEqualInt(3.4, b: 3.8)) W powyższym fragmencie kodu sprawdzamy, czy dwie wartości typu Int są takie same. Dwa wywołania print() pokazują wyniki użycia funkcji isEqualInt() najpierw na wartościach typu Int, a później Double. Wynik wykonania tego fragmentu kodu pokazałem na rysunku 7.8. Rysunek 7.8. Przygotowana funkcja isEqualInt() działa jedynie z wartościami typu Int i generuje błąd w przypadku otrzymania wartości typu Double. Dla obu wymienionych typów danych kod funkcji będzie dokładnie taki sam Funkcja zwraca poprawny wynik dla wartości typu Int, a dla wartości typu Double, jak pokazałem na rysunku 7.8, generuje komunikat błędu. Aby uzyskać tę samą funkcjonalność dla typu Double, konieczne jest dodanie kolejnej funkcji: func isEqualDouble(a:Double, b:Double) - Bool { return a == b } print(isEqualInt(3, b: 3)) print(isEqualDouble(3.5, b: 3.8)) Po wprowadzeniu kodu drugiej funkcji otrzymasz wynik pokazany na rysunku 7.9. Jak możesz zobaczyć, otrzymaliśmy poprawny wynik dla wartości typu Double. Niestety odbyło się to kosztem utworzenia zupełnie nowej funkcji w większości składającej się z tego samego kodu, który znajduje się w pierwszej funkcji. Aby rozwiązać problem związany z powielaniem kodu, możemy użyć funkcji generycznej pobierającej argument dowolnego typu danych. Utwórz funkcję generyczną o następującym kodzie: 7.3. Funkcje generyczne 177 Poleć książkęKup książkę Podstawy języka Swift Rysunek 7.9. Utworzenie nowej funkcji dla typu danych Double pozwala na zwrócenie poprawnej wartości, choć jednocześnie oznacza konieczność wprowadzenia dwukrotnie większej ilości kodu func isEqual T: Equatable (a:T, b:T) - Bool { return a == b } print(isEqual(3, b: 3)) print(isEqual(3.3, b: 3.5)) print(isEqual( 3.3 , b: 3.3 )) print(isEqual(true, b: false)) W powyższym fragmencie kodu po nazwie funkcji zdefiniowaliśmy, że typ argumentów funkcji to T, o ile są równe (Equatable). Słowo kluczowe Equatable oznacza, że wszystkie argumenty są tego samego typu. Następnie w definicji argumentów zadeklarowaliśmy T jako typ wszystkich argumentów. Pozostała część funkcji jest dokładnie taka sama jak w przedstawionych wcześniej przykładach. Oczekiwane wyniki działania nowej wersji funkcji isEqual() pokazałem na rysunku 7.10. W wywołaniach print() przetestowaliśmy funkcję wraz z wartościami typów Int, Double, String i Boolean. We wszystkich przypadkach funkcja zwraca prawidłowy wynik, co eliminuje konieczność czterokrotnego tworzenia tego samego kodu. W ostatnim podrozdziale zajmiemy się jednym z zabawniejszych aspektów języka Swift, czyli użyciem emotikonów w kodzie. 178 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift Rysunek 7.10. Funkcje generyczne pozwalają na wyeliminowanie znacznej ilości powielanego kodu PYTANIA KONTROLNE 1) Funkcje generyczne pozwalają na uniknięcie powielania kodu. a) Prawda. b) Fałsz. 2) Jak przedstawia się prawidłowa składnia funkcji generycznej? a) func myFunc (myVarA: T, myVarB: T). b) func myFunc: T (myVarA: T, myVarB: T). c) func myFunc T: Equatable (myVarA: T, myVarB: T). d) generic myFunc (myVarA, myVarB). 3) Funkcje generyczne to dobry wybór, gdy trzeba znać dokładny typ argumentów w funkcji. a) Prawda. b) Fałsz. 4) Które z poniższych zdań NIE przedstawia zalety funkcji generycznych? a) Mniejsza ilość powielonego kodu. b) Większa czytelność kodu. c) Łatwiejszy proces usuwania błędów. d) Dodanie funkcjonalności do istniejących klas. 7.4. EMOTIKONY Emotikony (ang. emoji) to małe obrazy przeznaczone do przedstawiania idei lub koncepcji. Pierwotnie były stosowane w japońskich komunikatach tekstowych. Nazwa pochodzi od japońskiego e oznaczającego obraz i moji oznaczającego znak. Ostatnio w standardzie Unicode 7.4. Emotikony 179 Poleć książkęKup książkę Podstawy języka Swift wprowadzono setki emotikonów, co pozwala na ich zastosowanie w wielu różnych miejscach. W języku Swift emotikonów można używać dla nazw zmiennych, klas, typów wyliczeniowych, struktur oraz innych konstrukcji. W Xcode utwórz nowy plik typu playground, a następnie zadeklaruj w nim stałą przeznaczoną do przechowywania imienia i nazwiska. Zamiast nazwy tekstowej dla stałej użyj emotikona. Aby uzyskać dostęp do menu emotikonów w języku Swift, naciśnij kombinację klawiszy Spacja+Ctrl+Command. Na ekranie zostanie wyświetlone menu (patrz rysunek 7.11), w którym możesz wybrać emotikon do użycia. Rysunek 7.11. Menu emotikonów w języku Swift Po wyborze emotikona język Swift uznaje go za całkowicie poprawną nazwę zmiennej. W omawianym przykładzie zdecydowałem się na uśmiechniętą buźkę jako nazwę stałej. Następnie za pomocą wywołania print() wyświetliliśmy wartość tej stałej (patrz rysunek 7.12). Istnieje również możliwość użycia wielu emotikonów do przedstawienia elementu. Na rysunku 7.13 możesz zobaczyć, jak wykorzystałem trzy emotikony do przedstawienia ciągu tekstowego Ja śpię!. 180 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift Rysunek 7.12. Swift współpracuje z emotikonami tak jak z innymi nazwami elementów Rysunek 7.13. Użycie wielu emotikonów do przedstawienia zmiennej Emotikony to niewielki, uprzyjemniający pracę dodatek do języka programowania Swift, ale nie stanowią one najbardziej efektywnych nazw dla elementów. Mimo wszystko mogą dostarczyć nieco radości podczas tworzenia oprogramowania w języku Swift. PYTANIA KONTROLNE 1) Nazwa emotikony (emoji) pochodzi z języka japońskiego, w którym e oznacza obraz, a moji oznacza znak. a) Prawda. b) Fałsz. 2) W nazwach których elementów można używać emotikonów? Wybierz wszystkie poprawne odpowiedzi. 7.4. Emotikony 181 Poleć książkęKup książkę Podstawy języka Swift a) W nazwach zmiennych. b) W nazwach stałych. c) W nazwach klas. d) W nazwach struktur. 3) Intensywne użycie emotikonów prowadzi do uzyskania czytelnego, łatwego w konserwacji kodu. a) Prawda. b) Fałsz. 4) Za pomocą jakiej kombinacji klawiszy można uzyskać dostęp do menu emotikonów? a) Ctrl+Alt+Delete. b) Ctrl+Command+Enter. c) Ctrl+Command+Space. d) Ctrl+Command+Alt. ĆWICZENIA DO ROZDZIAŁU 7. 1) Utwórz nowy plik typu playground o nazwie SLA_Lab7. W edytorze tekstów usuń cały niepotrzebny kod i pozostaw jedynie niezbędne polecenie import. 2) Utwórz wielowierszowy komentarz z Twoim imieniem, bieżącą datą oraz nazwą ćwiczenia (SLA_Lab7). 3) W pliku typu playground wprowadź następujący fragment kodu: import UIKit func feetToInchesInt(feet:Int) - Double { return Double(feet*12) } func feetToInchesDouble(feet:Double) - Double { return feet*12 } func feetToInchesFloat(feet:Float) - Float { return feet*12 } func InchesToFeetInt(inches:Int) - Double { return Double(inches/12) } func InchestToFeetDouble(inches:Double) - Double { 182 Mark A. Lassoff Poleć książkęKup książkę Rozdział 7. Więcej konstrukcji języka Swift return inches/12 } func InchestToFeetFloat(inches:Double) - Double { return inches/12 } print(feetToInchesInt(177)) print(feetToInchesFloat(164.55)) print(InchesToFeetInt(1000)) 1) Wykorzystując zdobytą w rozdziale wiedzę o funkcjach generycznych, funkcjonalność wszystkich przedstawionych powyżej metod hermetyzuj w dwóch metodach generycznych. Zmień wywołania funkcji na końcu kodu w taki sposób, aby były używane opracowane przez Ciebie metody generyczne. PODSUMOWANIE W tym rozdziale poznałeś kolejne użyteczne funkcje języka programowania Swift. Dowiedziałeś się, jak rozszerzenia pozwalają na zwiększenie użyteczności wbudowanych elementów i klas. Przeanalizowaliśmy temat przeciążania operatorów, aby stały się jeszcze bardziej użyteczne i lepiej dopasowane do budowanych programów. Wykorzystaliśmy funkcje generyczne do utworzenia funkcji, które mogą obsługiwać dowolne typy danych, co umożliwia wyeliminowanie powielania kodu oraz pozwala na tworzenie jeszcze bardziej czytelnego kodu źródłowego. Na końcu rozdziału spojrzeliśmy na emotikony, które dodają nieco uśmiechu do tworzonych aplikacji. W kolejnym i zarazem ostatnim rozdziale książki zdobytą dotąd wiedzę wykorzystasz do utworzenia aplikacji. Podsumowanie 183 Poleć książkęKup książkę Podstawy języka Swift 184 Mark A. Lassoff Poleć książkęKup książkę SKOROWIDZ A abstrakcja, 153 akcja, 194, 196 aplikacja, 185 delegat, 21 działanie w tle, 21 interfejs użytkownika, 193, 194 nazwa, 17, 187 testowanie, 203, 204 App Store, 187 Apple Developer, 10 biblioteka, 117, 189 blok case, 68, 143 default, 68 błąd komunikat, 32 precyzji, 36 ciąg tekstowy, 37 interpolacja, 46 konkatenacja, 47 pusty, 126 B C D emotikon, 180, 181 etykieta, 22, 189 atrybut, 191, 193 właściwości, 24 F funkcja, 14, 31, 115, Patrz też: polecenie addNumbers, 15 argument, Patrz: funkcja parametr array.append, 97, 100 array.count, 89, 90, 93 array.insert, 99, 100 array.isEmpty, 95 array.removeAll, 100 array.removeAtIndex, 101, 102 array.removeLast, 100 array.slice, 89, 91, 93 deklaracja, 116, 176 dictionary.removeValueForKey, 110, 111 dictionary.updateValue, 108, 109 generyczna, 99, 176, 177 nadrzędna, 133, 134 nazwa, 116, 117 parametr, 15, 119, 120, 121 potomna, 133 print, 14, 16, 125 wartość zwrotna, 122, 124 wywołanie, 115 zagnieżdżona, 133 zasięg, Patrz: zasięg drzewo katalogów i plików, 19 E gutter, 15 edytor pomocniczy, 15, 195 tekstów, 11 G H hermetyzacja, 133, 135, 144, 162, 173 229 Poleć książkęKup książkę Podstawy języka Swift I M IDE, 9 Integrated Development Environment, Patrz: IDE Interface Builder, 197 interfejs użytkownika aplikacji, 193, 194 iteracja, 77, 79, 105 metoda, 150, 157 didReceiveMemoryWarning, 195 inicjalizacyjna, 149 nadpisująca, 158, 159 viewDidLoad, 195 J K język kompilowany, 9 skryptowy, 9 Swift, Patrz: Swift karta Build Phases, 19 Build Rules, 19 Build Settings, 19 Capabilities, 19 General, 19 Info, 19 klasa, 146, 173, 175 egzemplarz, 148, 149 Patrz też: obiekt hierarchia, 154, 160 nadrzędna, 154 nazwa, 30, 180 potomna, 154 UIView, 187 ViewController, 195, 196, 197 właściwość, Patrz: właściwość komentarz, 21 konstrukcja warunkowa, Patrz: polecenie if, polecenie if-else skomplikowana, 63 złożona, 59, 62 kontrola działania programu, 53 kontroler widoku, 21 konwencja camel case, 29, 30, 116 L liczba zmiennoprzecinkowa, 44 licznik, 72, 79 230 Mark A. Lassoff O obiekt, 154 object-oriented programming, Patrz: programowanie zorientowane obiektowo obszar gutter, Patrz: gutter OOP, Patrz: programowanie zorientowane obiektowo operator arytmetyczny, 14, 39 modulo, 40 dekrementacji, 42 inkrementacji, 42, 43 porównania, 55 postfiks, 43 prefiks, 43 przeciążanie, 173, 174, 175 przypisania, 13, 30, 108 zakresu, 80 outlet, 194, 196 P panel, 22 para klucz-wartość, 103 modyfikacja, 108 pętla, 71 for, 76, 77, 78, 87 for-in, 79, 87, 89, 105 while, 71, 72, 75, 78 platforma OS, 17 plik Main.storyboard, 22 nazwa, 29 typu playground, 11, 29 storyboard, 22 ViewController.swift, 22 Poleć książkęKup książkę podklasa, 154 UIViewController, 195 polecenie, Patrz też: funkcja break, 68 if, 53, 59, 61 if-else, 53, 55, 56, 59 if-else-if, 64, 67 let, 31 pętli, Patrz: pętla return, 170 switch, 67, 68, 143, 144 var, 30 polecenieif-else, 60 programowanie zorientowane obiektowo, 153, 154, 160 protokół, 161, 162 R relacja jeden do jednego, 106 rozszerzenie, 169, 172 S słownik, 103 słowo kluczowe @IBOutlet, 197 atIndex, 99 class, 147 Equatable, 178 extension, 170 for, 76 forKey, 109 func, 116, 174 init, 149 let, 31, 32, 87 nil, 110 override, 21 protocol, 162 return, 124 struct, 173 var, 13, 30, 86, 87, 140 stała, 29, 31, 32, 87 zasięg, Patrz: zasięg struktura, 173 Swift, 9 symulator, 26, 204 Skorowidz Ś środowisko programistyczne zintegrowane, Patrz: IDE T tablica, 73, 79, 85, 126 deklarowanie, 86 element, 73, 85, 87 dodawanie, 97 liczba, 90 typ, 85 usuwanie, 100, 101 zakres, 91 indeks, 73, 87 konkatenacja, 98 modyfikowalna, 87 niemodyfikowalna, 87 pusta, 95, 96, 101 typu NSArray, 96 typ, 35 bezpieczeństwo, 139, 140, 146 Boolean, 13, 37 Character, 13 Double, 13, 36, 44 Float, 13, 33, 36, 38 błąd precyzji, 36 Int, 13, 33, 35, 44 Int16, 35 Int32, 35 Int64, 35 Int8, 35 kolekcji, 85 niejawnie określony, 33 rzutowanie, 44, 45 String, 13, 33 UITextField, 197, 201 wyliczeniowy, 139, 140, 146, 173, 175 nazwa, 180 wyraźnie określony, 33, 36, 86 U Unicode, 179 Skorowidz 231 Poleć książkęKup książkę Podstawy języka Swift W wektor trójwymiarowy, 173 widok, 21, 187 właściwość, 148, 151 obliczana, 170 przechowywana, 148 X Xcode, 9, 10, 17 biblioteka obiektów, 188, 189 karta, Patrz: karta obszar, 188 panel, Patrz: panel szablon, 185 Z zasięg, 129 globalny, 130 lokalny, 130 zmienna, 12, 29, 31, 87 deklaracja, 31, 33 nazwa, 30, 180 typ, Patrz: typ zasięg, Patrz: zasięg znak , 40 , 60 ||, 60 ++, 42 cudzysłów, 37 cytowania, 37 nawias kwadratowy, 86 potokowania, Patrz: znak || 232 Mark A. Lassoff Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Podstawy języka Swift. Programowanie aplikacji dla platformy iOS
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ą: