Swift 4 – oficjalnie !

20 września 2017

Swift w wersji 4 został zaprezentowany po raz pierwszy podczas tegorocznego WWDC 2017. Za to wczoraj, tj. 19 września 2017 ujrzał światło
dzienne jako element nowej wersji produkcyjnej Xcode oraz oficjalnej premiery iOS 11. To dobra okazja, żeby jeszcze raz przejrzeć
nowości, jakie Swift 4 przynosi w stosunku do wersji 3. A trzeba przyznać, że zmieniło się sporo, na szczęście na lepsze.

W artykule streściłem tylko najwaniejsze, z mojego punktu widzenia, nowe elementy języka. Więcej informacji znajdziesz na głównej stronie projektu swift.org oraz na prelekcji z tegorocznego WWDC 2017. Zapraszam Cię do lektury!

String

W stosunku do poprzedniej wersji na szczególną uwagę zasługuje temat zmian w stringach (Zmiany zapisane w [SE-0163]).

String jako kolekcja

Przede wszystkim String wraca do struktury kolekcji zmiennych typu character znanej z wersji drugiej. Dzięki temu
znów możemy iterować po pojedynczych znakach w całym łańcuchu, zwracać długość stringa za pomocą metody count,
sprawdzić czy napis posiada jakieś znaki – isEmpty, czy wyrzucić dowolny element ze stringa:


var string = "Welcome to Swift 4, friend!"
for char in string
{
    print(char)
}
string.count // 27
string.isEmpty // false
string.dropLast(9) // "Welcome to Swift 4"

Nowy String pozwala również na filtrowanie (czyli zwracanie tablicy ze spełniającymi warunki elementami), możemy zatem wyciągnąć
z napisu konkretne znaki:


var string = "Welcome to Swift 4, friend"
let newString = string.filter { char in
    if (char != "e"){
        return true
    }
    return false
}
newString   // "Wlcom to Swift 4, frind"

Substring

Kolejną ważną zmianę w protokole String jest wprowadzenie typu Substring umożliwiającą dzielenie napisów:


let lastElementIndex = string.index(string.startIndex, offsetBy: 6)
var substring = string[string.startIndex...lastElementIndex] // "Welcome"
type(of: substring) // typ zmiennej: Substring

// konkatenacja
substring += "👋" // “Welcome👋”


// Create a String from a Substring
let helloString = String(substring) // “Welcome👋”
type(of: helloString) // typ zmiennej: String

Skoro jesteśmy już przy emoji – jedym z ulubionych tematów komunikacji według Apple – to należy wspomnieć o sposobie ich
interpretacji. W poprzedniej wersji języka często zdarzało się że jako znak emoji przyjmowało wartość większą
niż 1. Obecnie wraz z zaadaptowaniem standardu Unicode 9 każda emoji będzie interpetowana jako pojednynczy obiekt
typu character:


"👋".count // 1
"👋🏿".count // 1
"🐙".count // 1
"☠".count // 1

String o “””wielu liniach”””

Coś, czego brakowało bardzo w strukturze języka to tzw. Multiliniowe stringi (Multilines string). W Swift 4 pojawia się opcja
zapisywania wielolinijkowych napisów za pomocą symbolu """ jak to ma miejsce w wielu innych znanych językach programowania:


let multiline = """
Welcome
In Swift 4
!!!
"""

print(multiline)   // Welcome\nIn Swift 4\n!!!

To tyle w kwestii Stringów. Myślę że zmiany jakie zostały wprowadzone w dużym stopniu ułatwią wykonywanie operacji na napisach, co z pozoru wydaje się dość trywialne, jednak w poprzedniej wersji potrafiło przysporzyć wielu problemów.

Set oraz Dictionary

Jak każdy iOS deweloper dobrze wie, kolekcje to nie był zbyt intuicyjny fragment programowania w Swift 3, szczególnie dla nowych programistów. I specjalnie użyłem
tutaj formy przeszłej, bo Swift 4 wprowadza kilka usprawnień, na które wszyscy czekaliśmy. Dokładna specyfikacja
tutaj: [SE-0165] Po pierwsze Swift 4 daje możliwość łączenia w słowniki (Dictionaries) pary zmiennych
(klucz-wartość) za pomocą metody zip:


let words = ["jeden", "dwa", "trzy", "cztery"]
let numbers = 1...4

var dict = Dictionary❬String, Any❬()
for (word, number) in zip(words, numbers) {
    dict.updateValue(number, forKey: word)
}

Podobnie jak w innych typach zmiennych, jak np. Tablice możemy wybrać elementy spełniające konkretne warunki. Myślę że dwa
powyższe usprawnienia protokołu Dictioraries zwiąkszą ich użyteczność.

Na koniec chcę wspomnieć o jeszcze jednym nowym elemencie – mianowicie o grupowaniu słowników. Załóżmy, że chcemy uszeregować
elementy po pierwszej literze klucza. Zatem:

let starsByFirstLetter = Dictionary(grouping: dict.keys, by: { $0.first! }) // ["j": ["jeden"], "d": ["dwa"], "t": ["trzy"], "c": ["cztery", "czternaście"]]

Modyfikator private

W trakcie pisania Extensions w Swift 3 pojawiał się problem z wykorzystaniem zmiennych znajdujących się wewnątrz rozszerzanej
klasy, które zadeklarowane zostały jako prywatne private. To przecież niezbyt zroworozsądkowe, bo skoro dopisuję rozszerzenie
dla klasy, to raczej chcę mieć możliwość używania tych zmiennych. Z pomocą przyszli deweloperzy Swift 4, który wprowadzają
taką możliwość [SE-0169]. Zatem spójrzmy na przykład:


struct Person{
    private let name: String
    init(name: String) {
        self.name = name
    }
}
extension Person{
    func isThisMyName(name: String) -closedTag Bool{
    if name == self.name{  // Patrze... i nie widzę błędu!!
    return true
    }
    return false
    }
}
let kuba = Person(name: "Kuba")
kuba.isThisMyName(name: "Kuba")  // true
kuba.isThisMyName(name: "Jakub") // false

Działa!! Mam dostęp do prywatnej zmiennej klasy, którą rozszerzam, wreszcie… GOOD!

Kodowanie i Serializacja

Do tej pory kodowanie struktur takich jak np. JSON było umiarkowanie przyjemne. Przykładowo Objective-C wymagał wykorzystania protokołu
NSCoding oraz dopisania sporej ilości kodu. Od teraz – koniec. Swift w wersji 4 wprowadza zupełnie nowy protokół Codable,
który umożliwia serializację raz deserializację. Co więcej, nie tracimy przy tym typów serializowanych
danych, a nawet możemy wybrać dokładnie sposób tej serializacji. I jeszcze raz – Tak, mówimy o Swifcie 🤗 .


struct Vehicle: Codable{
    var name: String
    var wheels: Int
}
let bike = Vehicle(name: "bike", wheels: 2)
let car = Vehicle(name: "car", wheels: 4)

let encoder = JSONEncoder()


if let encode = try? encoder.encode(bike){
    if let json = String(data: encode, encoding: .utf8) {
        print(json)
    }
    
    
    let decoder = JSONDecoder()
    if let decoded = try? decoder.decode(Vehicle.self, from: encode) {
        print(decoded.name)
    }
}

Zwróć uwagę – decoder nie potrzebuje rzutowania na konkretny typ! To naprawdę duża zmiana w stosunku do poprzedniej wersji.

Key Paths

Key Paths to znany dla deweloperów Objective-C mechanizm do dynamicznego wskazywania referencji. W dużym uproszczeniu polega
na wskazywaniu referencji zmiennej danego obiektu bez potrzeby bezpośredniego odczytywania jej, czyli do odczytywania
parametrów w sposób dynamiczny. Jeśli nie jest to jasne dla Ciebie, spokojnie, poświęce temu osobny artykuł. Ważne jest,
że key paths wraz z wersją 4 stały się dostępne dla deweloperów piszących w Swift. Jak to wygląda? 💻 :


let bike = Vehicle(name: "bike", wheels: 2)
let nameKeyPath = Vehicle.name
let wheelsKeyPath = Vehicle.wheels

let vehicleName = bike[keyPath: nameKeyPath]
let vehicleWheels = bike[keyPath: wheelsKeyPath]

Zostajemy przy pojazdach. Tworzymy obiekt bike, a następnie chcemy dostać się do jego wartości – nazwy oraz ilości kół. Nie
chcemy jednak operować na tych wartościach, a jedynie je wskazać. Key paths uzyskujemy w Swift za pomocą symbolu / jak w naszym przykładnie z rowerem.

Migracja języka

Na koniec coś, od czego w sumie powinienem zacząć, czyli migracja istniejącego projektu do kolejnej wersji języka. Jak pamiętamy,
przejście z wersji 2 do 3 było prawdziwym koszmarem. Było to związane w dużej mierze z dość dużymi zmianami w samej składni.
W wersji 3 zostało uproszczone nazewnictwo klas i metod, co w paru przypadkach powodowało konflikty. Tym razem jest o
niebo lepiej! Zmiany są wewnątrz struktury języka, zaś w samej składni nie zmieniło się aż tak dużo. Dzięki czemu migracja
jest w zasadzie automatyczna. Aby zmigrować projekt do Swift 4 należy przejść do Edit/Convert/To Current Swift Syntax…
w Xcode.

Ciągły rozwój

Swift w końcu doczekał się wersji, którą można w pewnym stopniu uznać za dojrzałą – jak na język programowania przystało.
Mam wrażenie że powoli sprząta siębałagan, którym rządziła się architektura tego języka. Wszystkie zmiany wprowadzone w tej
wersji powodują, że Swift staje się coraz bardziej samodzielny i traktowany poważnie przez doświadczonych deweloperów
tworzących na wszelakie applowskie platformy od lat. Wszelkie zmiany i nowowści, o jakich tutaj nie napisałem są dostępne
na oficjalnej stronie projektu Swift. Jeszcze raz polecam wrócić wspomnieniami do tegorocznego WWDC 2017, na którym
nowa wersja wraz ze wszystkimi nowościami ujrzała światło dzienne. Jeśli zaś jesteś ciekawy, jakie konkretne zmiany następują,
będą następowały lub nastąpiły, polecam stronę gdzie opisane są dalsze propozycję
usprawnień języka. Jeśli dotarłeś aż tutaj, to jest mi niezmiernie miło, tym bardziej że to moje pierwsze kroki w, narazie
;), małym świecie blogów technicznych. Miłego kodowania, i happy #iOS11 day!

Co nowego w Swift 4 – raz jeszcze

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *