Swift 4.0 vs Swift 3.0 - Differenze e nuove funzionalità

Il giorno in cui Apple rilascia una nuova versione del noto linguaggio Swift ci ha finalmente colpito. Cosa dobbiamo aspettarci da esso? Pur tremando per l'attesa, abbiamo deciso di presentare una piccola panoramica dei nuovi aggiornamenti che saranno presenti nella versione Swift 4 .

3 capisaldi di Swift.

Come un fantastico linguaggio su cui scrivere codice, Swift ha i suoi vantaggi e si dice che "sopravviva" al linguaggio Objective-C.

Ti invitiamo a leggere le principali differenze tra Swift e Objective-C

Swift è veloce , indipendente dai tipi e molto espressivo . Potrebbe essere utilizzato per scrivere software su telefoni e tablet, desktop e server, a quanto pare, su tutto ciò che esegue il codice. Ti dà il benvenuto a giocare con esso: con l'app Swift Playgrounds per imparare a programmare di Apple o utilizzando Playgrounds in Xcode puoi vedere immediatamente i risultati del tuo lavoro, non c'è bisogno di mettere il naso nello sviluppo e nell'esecuzione di un'app su primo posto. Con ogni nuova versione additiva diventa migliore e più veloce, ed è il caso della versione Swift 4.
Pronti partenza?

Un'altra grande caratteristica che Xcode 9 possiede per Swift 4: non devi preoccuparti molto della migrazione imminente e scoprirai perché leggendo questo articolo.

A proposito, esploriamo brevemente quali bonbon e le nuove funzionalità di Swift 4 ci portano questo autunno.

Iniziare

Il linguaggio stesso non è molto utile senza un pratico IDE, che è Xcode nel mondo degli sviluppatori . Puoi scaricare l'ultima versione di Xcode 9 dal Mac App Store o dalla pagina Download del sito Apple Developer, ma assicurati innanzitutto di disporre di un account sviluppatore attivo. È abbastanza stabile, quindi puoi sostituire Xcode 8 con esso per le tue routine di programmazione quotidiane.

Puoi anche installare più versioni di Xcode usando xcversion

Se stai iniziando un nuovo progetto, sei a posto. Ma se hai già un progetto scritto in Swift 3.x, devi passare attraverso un processo di migrazione.

Ti consigliamo di provare prima su Playground - per abituarti alle nuove funzionalità.

Noterai collegamenti alle proposte Swift Evolution nel formato 'SE-____' mentre leggi questo articolo.

Migrazione a Swift 4

La migrazione da una versione principale di Swift a quella successiva è sempre stata piuttosto intensa, specialmente da Swift 2.x a 3.0. Di solito ci vogliono circa 1-2 giorni per progetto, ma la migrazione a Swift 4 è un po' più semplice e può essere passata molto più velocemente.

Preparazione pre-migrazione

Xcode 9 supporta non solo Swift 4, ma anche una versione di transizione 3.2, quindi il tuo progetto dovrebbe essere compilato senza dure difficoltà. Ciò è possibile perché il compilatore Swift 4 e lo strumento di migrazione supportano entrambe le versioni del linguaggio. Puoi specificare diverse versioni di Swift per target, questo è molto utile se alcune librerie di terze parti non si sono ancora aggiornate o se hai più target nel tuo progetto. Tuttavia, non solo la lingua, ma anche l'SDK ha subito alcune modifiche, quindi è molto probabile che alcuni aggiornamenti debbano essere applicati al tuo codice mentre Apple continua a migliorare le API dell'SDK...

Strumento di migrazione rapida

Come sempre, Apple fornisce lo strumento di migrazione Swift in bundle all'interno di Xcode che può aiutare a migrare dalla precedente versione di Swift. Puoi avviarlo in Xcode andando su Modifica -> Converti -> In sintassi Swift corrente... e selezionando i target che desideri convertire.

Ti verrà quindi chiesto quale preferenza di inferenza Objective-C desideri applicare:

Poiché le modifiche aggiuntive dominano in Swift 4, lo strumento di migrazione Swift gestirà la maggior parte delle modifiche per te.

baccelli di cacao

La maggior parte degli sviluppatori  utilizza il gestore delle dipendenze CocoaPods per i propri progetti poiché Swift Package Manager non è maturo come potrebbe essere, sebbene stia migliorando molto rapidamente. Come accennato in precedenza, non tutte le librerie di terze parti sono state ancora aggiornate a Swift 4, quindi potresti vedere errori durante la compilazione di alcune di esse. Una possibile soluzione per risolvere questo problema è specificare la versione 3.2 Swift per quei pod che non sono stati ancora aggiornati aggiungendo uno script post_install al tuo Podfile :

 old_swift_3_pods = [ 'PodName1', 'PodName2', ] post_install do |installer| installer.pods_project.targets.each do |target| if old_swift_3_pods.include? target.name target.build_configurations.each do |config| config.build_settings['SWIFT_VERSION'] = '3.2' end end end end

Allora corri

 pod install

Ora puoi compilare i pod senza errori.

Esaminiamo le modifiche e le aggiunte all'API Swift 4.

Modifiche e aggiunte API

stringhe

String ora è conforme al protocollo Collection grazie alla proposta SE-0163. Ricordi Swift 1.x?

Non è necessario nella proprietà array di characters ora in quanto è possibile eseguire l'iterazione direttamente su String :

 let string = "Hello, Mind Studios!" for character in string { print(character) }

Ciò significa anche che puoi utilizzare qualsiasi metodo e proprietà Collection su String , come count , isEmpty , map() , filter() , index(of:) e molti altri:

 string.count // No more `string.characters.count` string.isEmpty // false let index = string.index(of: " ") // 6 let reversedCollection = "abc".reversed() let reversedString = String(reversedCollection) // "cba" // String filtering let string = "ni123n456iniASijasod! 78a9-kasd aosd0" let numbersString = string.filter { Int(String($0)) != nil } // "1234567890"

Nuovo tipo di Substring

Swift 4 porta un nuovo tipo Substring che rappresenta una sottosequenza di String (come descritto in SE-0163 menzionato sopra).

 // Split string into substrings let string = "Hello, Mind Studios!" let parts = string.split(separator: " ") // ["Hello,", "Mind", "Studios!"] type(of: parts.first!) // Substring.Type

Sia String che Substring ora supportano il nuovo StringProtocol che li rende quasi identici e interoperabili:

 var hello = parts.first! // Concatenate a String onto a Substring hello += " !" // "Hello, !" // Create a String from a Substring let helloDog = String(hello) // "Hello, !"

Nota importante

SE-0163 ha una nota molto importante:

 Long-term storage of `Substring` instances is discouraged. A substring holds a reference to the entire storage of a larger string, not just to the portion it presents, even after the original string's lifetime ends. Long-term storage of a substring may therefore prolong the lifetime of elements that are no longer otherwise accessible, which can appear to be memory leakage.

Ciò significa che la Substring deve essere utilizzata come memoria temporanea per la String di String . Se vuoi passarlo ad alcuni metodi o ad altre classi, convertilo prima in String :

 let substring: Substring = ... // Substring let string = String(substring) // String someMethod(string)

Ad ogni modo, il sistema di tipi di Swift ti aiuterà a non passare Substring da qualche parte dove è previsto String (supponendo che tu non stia usando il nuovo StringProtocol come tipo di parametro).

Letterali stringa multilinea

SE-0168 introduce una semplice sintassi per stringhe letterali multilinea utilizzando tre virgolette """ che significa che la maggior parte dei formati di testo (come JSON o HTML) o un testo lungo può essere incollato senza alcuna fuga:

 let multilineString = """ Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam mattis lorem et leo laoreet fermentum. Mauris pretium enim ac mi tempor viverra et fermentum nisl. Sed diam nibh, posuere non lectus at, ornare bibendum erat. Fusce mattis sem ac feugiat vulputate. Morbi at nunc maximus, vestibulum orci et, dictum neque. Vestibulum vulputate augue ac libero vulputate vestibulum. Nullam blandit et sapien non fermentum. Proin mollis nisl at vulputate euismod. """

Escape delle nuove righe nei letterali stringa

SE-0182 aggiunge la possibilità di sfuggire alle nuove righe nelle stringhe letterali multilinea con una barra rovesciata alla fine della riga.

 let escapedNewline = """ Line 1, Line 2 \ next part of line 2, Line 3 """ print(escapedNewline)

 Line 1, Line 2 next part of line 2, Line 3

Supporto Unicode migliorato

Swift 4 offre supporto per Unicode 9, il che significa che i problemi con il conteggio dei caratteri Unicode sono ora scomparsi:

 "".count // 1, in Swift 3: 2 "".count // 1, in Swift 3: 2 "".count // 1, in Swift 3: 2 - person + skin tone "".count // 1, in Swift 3: 4 "".count // 3, in Swift 3: 1

Tutti i cambiamenti e le proposte implementate evidenziate sopra (come molti altri) stanno prendendo le loro radici da un insieme di funzionalità ampiamente descritto chiamato String Manifesto.

Controllo di accesso

Swift 3 ha apportato un elemento molto contraddittorio al controllo fileprivate accessi: il modificatore di accesso fileprivate che può essere davvero confuso.
In precedenza, il modificatore del livello di accesso private veniva utilizzato per nascondere i membri del tipo da altri tipi e ai membri privati ​​era possibile accedere solo dai metodi e dalle proprietà definiti nella definizione del tipo, lasciando da parte le stesse estensioni di tipo poiché non potevano accedere a tali membri.
fileprivate potrebbe essere utilizzato per condividere l'accesso per i membri del tipo, ad esempio proprietà e metodi, all'interno dello stesso file.
In effetti l'uso di private portato a un problema quando le estensioni su un tipo non avevano accesso ai membri di quel tipo, quindi l'uso di fileprivate in tali circostanze era una soluzione molto comune, che ha portato a un altro problema: altri tipi nel lo stesso file potrebbe accedere anche a quei membri.

Swift 4 mette le cose in ordine consentendo alle estensioni del tipo di accedere private membri private di quel tipo nello stesso file come descritto in SE-0169:

 struct User { private let firstName: String private let lastName: String } extension User: CustomStringConvertible { var description: String { return "User: \(firstName) \(lastName)" } }

Dizionario e set

Inizializzazione del Dictionary con la Sequence

Dictionary può essere inizializzato con Sequence ora, ma non tutte le sequenze possono essere passate in questo inizializzatore, solo quelle contenenti tuple (Key, Value) , dove Key è il tipo di chiave del Dictionary e Value rappresenta il tipo di valore Dictionary:

 let stocksIdentifiers = ["AAPL", "GOOGL", "NKE"] let stocksValues = [158.28, 940.13, 53.73] let pairs = zip(stocksIdentifiers, stocksValues) let stocksValuesDict = Dictionary(uniqueKeysWithValues: pairs) // ["GOOGL": 940.13, "NKE": 53.73, "AAPL": 158.28]

Qui la funzione zip crea una coppia ( Tuple ) da 2 sequenze, puoi leggere di più su questa funzione nella documentazione della libreria standard Swift.

Unione di dizionari

È possibile specificare come devono essere gestite le chiavi duplicate durante la creazione di un dizionario da una sequenza di Tuple passando una chiusura al parametro uniquingKeysWith , che viene utilizzato per combinare i valori di 2 chiavi identiche.

Esempio 1:

 let duplicates = [("a", 1), ("b", 5), ("a", 3), ("b", 3)] let dictionary = Dictionary(duplicates, uniquingKeysWith: { (first, _) in return first }) // ["b": 5, "a": 1]

Qui lasciamo il primo valore ignorando tutti i valori successivi con la stessa chiave.

Esempio 2:

Contare quante volte ogni carattere appare nella stringa.

 let string = "Hello!" let pairs = Array(zip(string, repeatElement(1, count: string.count))) let counts = Dictionary(pairs, uniquingKeysWith: +) // ["H": 1, "e": 1, "o": 1, "l": 2, "!": 1]

Esempio 3:

Utilizzando il metodo di merge :

 let values = ["a": 1, "b": 5] var additionalValues = ["b": 3, "c": 2, "a": 3] additionalValues.merge(values, uniquingKeysWith: +) // ["b": 8, "c": 2, "a": 4]

Pedice con valore predefinito

In precedenza, una pratica comune consisteva nell'utilizzare l'operatore di coalescenza nil per fornire un valore predefinito nel caso in cui il valore fosse zero.

Veloce 3:

 let dict = ["a": 1, "b": 5] dict["c"] ?? 0 // 0

Swift 4 introduce un nuovo valore default sui pedici (parte di SE-0165):

 let dict = ["a": 1, "b": 5] dict["c", default: 0] // 0, equals to `dict["c"] ?? 0` in Swift 3

Puoi anche mutare un dizionario mentre lo sottoscrivi con il valore predefinito:

 let string = """ Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam mattis lorem et leo laoreet fermentum. Mauris pretium enim ac mi tempor viverra et fermentum nisl. Sed diam nibh, posuere non lectus at, ornare bibendum erat. Fusce mattis sem ac feugiat vulputate. Morbi at nunc maximus, vestibulum orci et, dictum neque. Vestibulum vulputate augue ac libero vulputate vestibulum. Nullam blandit et sapien non fermentum. Proin mollis nisl at vulputate euismod. """ var wordsCountByLine = [Int: Int]() let lines = string.split(separator: "\n") for (index, line) in lines.enumerated() { let lineWordsCount = line.split(separator: " ").count wordsCountByLine[index, default: 0] += lineWordsCount } print(wordsCountByLine) // [2: 10, 4: 15, 5: 7, 6: 6, 7: 6, 0: 8, 1: 7, 3: 10]

Mappa e filtro specifici del dizionario

Raggruppamento di elementi di sequenza

Tipi associati vincolati nei protocolli

La proposta SE-0142 introduce l'aggiunta di clausole condizionali alle dichiarazioni di tipo associate.

 extension Sequence where Element: Numeric { var sum: Element { var result: Element = 0 for element in self { result += element } return result } } [1,2,3,4].sum

Archiviazione e serializzazione (codifica/decodifica)

In precedenza, per serializzare un tipo personalizzato avresti dovuto utilizzare il vecchio e ben noto protocollo NSCoding . Il problema è che i tipi non di classe come struct ed enum non possono conformarsi a questo protocollo, quindi gli sviluppatori non hanno avuto altro da fare che utilizzare hack come fornire un ulteriore livello di compatibilità creando una classe annidata che potesse conformarsi a NSCoding .

Swift 4 ha una soluzione molto conveniente a questo problema grazie a SE-0166 - un'introduzione del protocollo Codable :

 struct Employee: Codable { let name: String let age: Int let role: Role enum Role: String, Codable { case manager case developer case admin } } struct Company { let name: String let officeLocation: Location? let employees: [Employee] } struct Location : Codable { let latitude: Double let longitude: Double }

In un caso semplice come questo, tutto ciò di cui hai bisogno è aggiungere la Codable protocollo Codable a tutti i tuoi tipi personalizzati, il compilatore farà tutta la magia per te. Questo è tutto!

Codable è un typealias per una composizione di protocolli Decodable & Encodable , quindi puoi dichiarare, ad esempio, solo la Decodable protocollo Decodable se vuoi decodificare l'istanza del tuo tipo dai dati JSON.

Codifica

Se si desidera serializzare o deserializzare un valore Codable , è necessario utilizzare un oggetto codificatore o decodificatore. Swift 4 viene già fornito con un set di codificatori/decodificatori per JSON e elenchi di proprietà, nonché nuovi CocoaError per diversi tipi di errori che potrebbero essere CocoaError durante la codifica/decodifica. NSKeyedArchiver e NSKeyedUnarchiver supportano anche i tipi Codable .

 let employee = Employee(name: "Peter", age: 27, role: .manager) let company = Company(name: "Awesome Company", officeLocation: nil, employees: [employee]) let encoder = JSONEncoder() let companyData = try encoder.encode(company) let string = String(data: companyData, encoding: .utf8)! print(string) >>> { "name" : "Awesome Company", "employees" : [ { "name" : "Peter", "age" : 27, "role" : "manager" } ] }

Un pezzo di torta, no?

decodifica

Decoder viene utilizzato per deserializzare il tipo Codable personalizzato da Data . Non sa quale tipo decodificare dai dati stessi, quindi dovresti specificare quale tipo decodificare, ad esempio Employee o [Employee] :

 let decoder = JSONDecoder() let jsonData = """ [ { "name" : "Peter", "age" : 27, "role" : "manager" }, { "name" : "Alex", "age" : 26, "role" : "developer" }, { "name" : "Eugene", "age" : 30, "role" : "admin" } ] """.data(using: .utf8)! let employees = try decoder.decode([Employee].self, from: jsonData)

 If one of `Codable` type instances fails to decode, then whole collection will fail to decode.

Nomi chiave personalizzati

Nella maggior parte dei casi i nomi che utilizziamo nei tipi Swift personalizzati non corrispondono alle chiavi nei dati JSON che rappresentano questo tipo. Per creare una mappatura tra i nomi delle proprietà di tipo personalizzato e le chiavi JSON, puoi creare CodingKeys nidificata denominata CodingKeys che dovrebbe essere conforme al protocollo CodingKey :

 struct Country: Decodable { let id: String let name: String let phoneCode: String private enum CodingKeys: String, CodingKey { case id = "alpha3" case name case phoneCode = "phone_code" } }

Decodifica personalizzata

Se hai un caso complesso puoi implementare il tuo inizializzatore personalizzato da un protocollo Decodable :

 struct Transaction { let id: Int let action: String let source: String let amount: Int let state: TransactionState let createdAt: Date let authorName: String enum TransactionState: String, Decodable { case done case canceled case processed } } extension Transaction: Decodable { private enum CodingKeys: String, CodingKey { case id case action = "action_name" case source = "source_name" case amount case state case createdAt = "created_at" case author } private enum AuthorKeys: String, CodingKey { case fullName = "full_name" } init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: CodingKeys.self) id = try container.decode(Int.self, forKey: .id) actionName = try container.decode(String.self, forKey: .action) sourceName = try container.decode(String.self, forKey: .source) let createdAtValue = try container.decode(Double.self, forKey: .createdAt) createdAt = Date(timeIntervalSince1970: createdAtValue) state = try container.decode(TransactionState.self, forKey: .state) amount = try container.decodeIfPresent(Int.self, forKey: .amount) ?? 0 do { let authorContainer = try container.nestedContainer(keyedBy: AuthorKeys.self, forKey: .author) authorName = try authorContainer.decode(String.self, forKey: .fullName) } catch { authorName = "" } } }

Codifica valore chiave

Una delle utili funzionalità offerte da Swift 4 è Smart KeyPaths descritta in SE-0161. A differenza di Swift 3 #keyPath() , che non è fortemente tipizzato e funziona solo per i membri Objective-C, Swift 4 KeyPath è una classe generica, il che significa che i percorsi chiave sono ora fortemente tipizzati. Entriamo in alcuni esempi:

 struct User { var username: String }

La forma generale del percorso chiave \<Type>.<path> , dove <Type> è un nome di tipo e <path> è una catena di una o più proprietà, ad esempio \User.username :

 let user = User(username: "max") let username = user[keyPath: \User.username] // "max"

Puoi anche scrivere un nuovo valore con questo percorso chiave se è modificabile:

 var user = User(username: "max") user[keyPath: \User.username] = "alex" // "alex"

I percorsi chiave non sono limitati a un livello di gerarchia:

 struct Comment { let content: String var author: User } let max = User(username: "max") let comment = Comment(content: "Nice post!", author: max) let authorUsername = comment[keyPath: \Comment.author.username] // "max"

I percorsi chiave possono essere memorizzati in una variabile:

 let authorKeyPath = \Comment.author let usernameKeyPath = authorKeyPath.appending(path: \.username) let authorUsername = comment[keyPath: usernameKeyPath] // "max"

Puoi anche utilizzare i percorsi chiave per le proprietà facoltative e calcolate:

 struct Post { let title: String var comments: [Comment] var topComment: Comment? { return comments.first } } let max = User(username: "max") let alex = User(username: "alex") var post = Post(title: "What's new in Swift 4", comments: []) let topCommentAuthorUsernameKeyPath = \Post.topComment?.author.username post[keyPath: topCommentAuthorUsernameKeyPath] // nil let comment = Comment(content: "", author: alex) let anotherComment = Comment(content: "Nice post!", author: max) post.comments = [comment, anotherComment] post[keyPath: topCommentAuthorUsernameKeyPath] // "alex"

Nonostante le evidenziazioni SE-0161 supportino i pedici nei percorsi chiave, non sono ancora stati implementati:

 post.comments[keyPath: \.[0].content] // error: key path support for subscript components is not implemented let firstCommentAuthorKeyPath = \Post.comments[0].author // error: key path support for subscript components is not implemented

KVO

Oltre ai nuovi percorsi chiave, anche l'API di osservazione dei valori-chiave è stata aggiornata in Swift 4.

 New KVO APIs depend on Objective-C runtime and works for `NSObject` subclasses only, so it can't be used for Swift structs and classes which don't inherit `NSObject`. In order to observe property it should be marked as `@objc dynamic var`.

 class User: NSObject { @objc dynamic var name: String var username: String init(name: String, username: String) { self.name = name self.userName = userName super.init() } } let user = User(name: "Max", username: "max") let nameObservation = user.observe(\.name, options: [.new, .old]) { user, change in // NSKeyValueObservation if let oldValue = change.oldValue, let newValue = change.newValue { print("fullName has changed from \(oldValue) to \(newValue)") } else { print("fullName is now \(user.name)") } } user.name = "Alex" // name has changed from Max to Alex

Chiama il metodo invalidate() se vuoi interrompere l'osservazione

 nameObservation.invalidate() user.name = "Elina" // observer isn't get called

Viene anche interrotto quando viene deinito, quindi assicurati di conservarlo in una proprietà o da qualche altra parte se vuoi preservarlo.

Intervalli unilaterali

SE-0172 introduce intervalli "unilaterali", creati tramite versioni prefisso/postfisso degli operatori di intervallo esistenti e un nuovo protocollo RangeExpression per semplificare la creazione di metodi che accettano diversi tipi di intervalli.

Sequenze Infinite

Puoi usare un intervallo unilaterale per costruire una sequenza infinita:

 let letters = ["a", "b", "c", "d"] let numberedLetters = Array(zip(1..., letters)) // [(1, "a"), (2, "b"), (3, "c"), (4, "d")]

 let string = "Hello, Mind Studios!" let index = string.index(of: ",")! string[..<index] // "Hello" string[...index] // "Hello,"

Utilizzo di intervalli unilaterali in Pattern Matching

 let value = 5 switch value { case 1...: print("greater than zero") case 0: print("zero") case ..<0: print("less than zero") default: break }

Pedici generici

SE-0148 I pedici ora possono avere argomenti generici e tipi di ritorno

 struct JSON { let data: [String: Any] subscript<T>(key: String) -> T? { return data[key] as? T } } let jsonDictionary: [String: Any] = [ "name": "Ukraine", "flag": "", "population": 42_500_000 ] let json = JSON(data: jsonDictionary) let population: Int? = json["population"] // 42500600

 extension Dictionary where Value == String { subscript<T: RawRepresentable>(key: Key) -> T? where T.RawValue == Value { guard let string = self[key] else { return nil } return T(rawValue: string) } } enum Color: String { case red case green case blue } let dictionary = [1: "red"] let color: Color? = dictionary[1] // red

Limitare l'inferenza Objective-C

Swift 4 minimizza l'inferenza @objc limitandola solo ai casi in cui la dichiarazione deve essere disponibile per Objective-C (SE-0160).
Ciò riduce la dimensione binaria della tua app non compilando il codice Objective-C ridondante se non lo usi e offre un maggiore controllo su quando verrà dedotto @objc. Le classi derivate da NSObject non deducono più @objc.

Ma ci sono alcune situazioni in cui il codice Swift continuerà ad avere un'inferenza implicita:

• Dichiarazioni che hanno un attributo @objc

• Dichiarazioni che soddisfano un requisito di un protocollo @objc

• Dichiarazioni con attributi @IBAction, @IBInspectable, @IBOutlet, @NSManaged, @GKInspectable

Per abilitare l'inferenza @objc per un'intera classe puoi utilizzare il nuovo attributo @objcmembers.
Per disabilitare l'inferenza @objc per un'estensione o una funzione specifica, aggiungi il nuovo attributo @nonobjc.

Comporre classi e protocolli

In Swift 4 ora possiamo comporre protocolli insieme ad altri tipi di Swift:

 User & Codable & CustomStringConvertible typealias MyType = User & Codable & CustomStringConvertible

Vantaggi di Swift 4.

I vantaggi di Swift 4 sono davvero enormi, come spesso accade quando Apple rilascia una nuova versione linguistica. Oltre al miglioramento delle prestazioni linguistiche, ha anche stabilizzato notevolmente il processo di migrazione. Riportando le nostre menti al processo di migrazione da Swift 2.2 a 3.0, ricordiamo il perplesso processo di trasferimento di tutte le dipendenze. Le modifiche a Swift 4.0 ci consentono di lasciare le librerie di terze parti senza "riposizionarle" in realtà: devi solo aggiornare Swift stesso.

Anche per quanto riguarda i miglioramenti di Swift 4.0 vs 3.0, la dimensione dei file binari compilati è stata modificata, il che ha comportato una diminuzione delle dimensioni dell'app; ad esempio, l'applicazione mobile pesava 20 MB, e nella versione Swift più recente ci vorranno circa 17 MB. E c'è una differenza fondamentale tra Swift 4 e Swift 3: la correzione dei bug è avvenuta e il linguaggio è diventato un po' più rapido.

Sono passati anni da quando Swift è stato utilizzato e continua a evolversi con ogni aggiornamento in arrivo. Con ogni nuovo linguaggio si rinnovano nuove prospettive di sviluppo, prima sconosciute, sorgono e non vediamo l'ora di esplorare nuovi orizzonti iOS.

Non perdere il nostro articolo su MVP vs MVC vs MVVM vs VIPER per lo sviluppo iOS.

Scritto da Max Mashkov ed Elina Bessarabova .