Swift Explicit vs. Inferred Typing: Performance

Question

Sto leggendo un tutorial su Swift (http://www.raywenderlich.com/74438/swift-tutorial-a-quick-start) e preconizzato per non impostare il tipo esplicitamente perché è più leggibile in questo modo.

Non sono d'accordo su questo punto, ma non è questa la domanda. La mia domanda è: è più efficiente, in termini di prestazioni (compilatore ...) impostare il tipo in modo esplicito?

Ad esempio, sarebbe questo: var hello: Int = 56 essere più efficiente di questo: var tutorialTeam = 56

Answer 1

Non c'è alcuna differenza di prestazioni tra codice che utilizza tipi espliciti e codice che utilizza l'inferenza dei tipi. L'output compilato è identico in ciascun caso.

Quando si omette il tipo, il compilatore lo sottrae semplicemente.

Le piccolissime differenze osservate nello accepted answer sono solo i tuoi soliti artefatti di benchmarking e non ci si può fidare!

Se includere o meno il tipo esplicito è una questione di gusti. In alcuni contesti potrebbe rendere il tuo codice più leggibile.

L'unica volta che fa la differenza per il codice è quando si desidera specificare un tipo diverso da quello che il compilatore dedurrebbe. Come esempio:

var num = 2 

Il codice sopra ne deduce che num è un Int, causa di una sua inizializzato con un numero intero letterale. Tuttavia si puo 'forza' di essere un Double come segue:

var num: Double = 2 

Answer 2

inferenza di tipo non influisce sulle prestazioni in data esempio. Tuttavia, ho trovato che essere specifico riguardo il Type nel tuo array Swift influisce significativamente sulle prestazioni.

Ad esempio, il metodo seguente mescola un array di tipo Any.

class func shuffleAny(inout array: [Any]) { 
    for (var i = 0; i < array.count; i++) { 
     let currentObject: Any = array[i] 
     let randomIndex = Int(arc4random()) % array.count 
     let randomObject: Any = array[randomIndex] 

     array[i] = randomObject; 
     array[randomIndex] = currentObject 
    } 
} 

La funzione di cui sopra è in realtà molto più lento rispetto se dovessi Tale funzione prende un array di Int invece simili

class func shuffleIntObjects(inout array: [Int]) { 
    for (var i = 0; i < array.count; i++) { 
     let currentObject: Int = array[i] 
     let randomIndex = Int(arc4random()) % array.count 
     let randomObject: Int = array[randomIndex] 

     array[i] = randomObject; 
     array[randomIndex] = currentObject 
    } 
} 

La funzione che utilizza [Any] clock in alle 0.537 secondi 3% DEV.ST. per 1 milione di oggetti Int. E la funzione che utilizza [Int] ha registrato un ritardo di 0,181 secondi 2% STDEV per 1 milione di oggetti Int.

È possibile controllare questo repo (https://github.com/vsco/swift-benchmarks) che fornisce dettagli molto più interessanti di benchmark in Swift. Uno dei miei preferiti è che i generici di Swift funzionano molto male con le condizioni di test menzionate sopra

Answer 3

Dalla mia esperienza, c'è stato un enorme impatto sulle prestazioni in termini di velocità di compilazione quando si utilizzano tipi espliciti o derivati. La maggior parte del mio lento codice di compilazione è stata risolta digitando esplicitamente le variabili.

Sembra che il compilatore Swift abbia ancora margini di miglioramento in quest'area. Prova a confrontare alcuni dei tuoi progetti e vedrai una grande differenza.

Ecco un articolo che ho scritto su how to speed up slow Swift compile times e come scoprire cosa lo sta causando.