Indice Swift XCode Congelamento o Lento

Forse sono solo io che sto vivendo una “caratteristica” così fastidiosa:

Dopo l’aggiornamento da Xcode 6.0.1 a Xcode 6.1, le cose sono cambiate. Xcode 6.1 sta indicizzando per sempre il progetto o compilando i file sorgente. Il progetto non è enorme. Contiene solo una serie di file Swift e Cocoapods AWS SDK 2.0 nell’area di lavoro. Non penso che dovrebbe impedire al tutto di indicizzare e compilare senza intoppi. Ho provato con alcuni aws-sdk-ios-samples, solo per vedere come Xcode 6.1 funziona su di loro, e finì nello stesso modo in attesa.

Quali soluzioni ho provato finora:

  1. Eliminazione di “Dati derivati” nella Libreria e riapertura e spazio di lavoro. (non riescono a risolvere)
  2. “Mostra contenuto pacchetto” nel file .xcodeproj ed eliminazione .xcworkspace come in ( Xcode 4 – prestazioni lente )

Nessuno di loro ha funzionato, sfortunatamente.

Qualche idea? O qualche esperienza simile?

    PS forse dovrei provare a ricreare il progetto? Impostazioni del mio computer: MacBook Pro (Retina, 13 pollici, metà 2014), memoria 8 GB 1600 MHz DDR3, con Yosemite. (Penso che questo sia sufficiente per gestire questo piccolo progetto.)

    Ho provato molti dei suggerimenti sopra citati, inclusi la divisione dei file, l’installazione di Xcode 6.2 beta e l’interruzione delle istruzioni di concatenazione delle stringhe. Ciò che alla fine ha fatto per me è stata la divisione di una serie di dichiarazioni letterali dei dizionari che stavo usando per i dati di test in più istruzioni .append .

     // This causes indexing/building to hang... var test = [ [ "a": false, "b": "c" ], [ "a": false, "b": "c" ], [ "a": false, "b": "c" ], [ "a": false, "b": "c" ], [ "a": false, "b": "c" ], [ "a": false, "b": "c" ] ] // This works fine. var test = [ [ "a": false, "b": "c" ] ] test.append([ "a": false, "b": "c" ]) test.append([ "a": false, "b": "c" ]) test.append([ "a": false, "b": "c" ]) test.append([ "a": false, "b": "c" ]) test.append([ "a": false, "b": "c" ]) 

    Inoltre, per quello che vale, la sesta voce in questo array è ciò che causa il problema per me; cinque funziona bene.

    L’unica soluzione funzionante per me è quella di eliminare tutti i dati derivati ​​(non solo per il progetto corrente, basta ripulire l’intera cartella) e quindi riavviare Xcode.

    1. Apri File / Preferenze in Xcode

    2. Fare clic su Posizioni all’estrema destra della finestra a comparsa

    3. Fai clic sulla piccola icona a forma di freccia accanto a “/Users/Mac/Library/Developer/Xcode/DerivedData”….it ti porta in una cartella Xcode che contiene una cartella DerivedData (che contiene tutti i dati derivati ​​dai tuoi progetti precedenti .)

    4. CANCELLARE la cartella DerivedData

    Stai usando CocoaPods? Ho incontrato lo stesso problema all’inizio di oggi. (Uso di xCode 6.1.1)

    Per risolvere il problema, ho eliminato tutto in ~/Library/Developer/Xcode/DerivedData , nella cartella Pods nella directory del progetto e .xcworkspace .

    Ho quindi aperto il terminale, ho navigato nella directory del mio progetto e ho eseguito nuovamente l’ pod install .

    Ho avuto lo stesso problema oggi. Xcode 6.3.2, progetto Swift di medie dimensioni. A un certo punto ha iniziato l’indicizzazione e non avrebbe mai finito di indicizzare. Il codice che causava questo era un dizionario di tipo [String: [String]], quindi un dettt a chiave di stringa con array di stringhe come valori. Avevo due di questi con le chiavi dalla A alla Z e ognuna di queste 26 voci contiene un array di stringhe da 5 a 10 stringhe.

    Cancellare i dati derivati ​​non ha aiutato. Solo commentando quei dicts è andata di nuovo.

    Onestamente, questo è ridicolo! Apple ha bisogno di riparare Xcode! È già orrendamente lento quando si compilano i progetti Swift, ma i bug di questo tipo sono un problema. Non posso fare il mio lavoro correttamente con questo!

    Per coloro che hanno ancora questo problema, questo è un trucco che ho imparato a divertirti e che ti impedisce di dover inserire gli oggetti uno per uno:

     // instead of this, which freezes indexing let keys = [keyQ, keyW, keyE, keyR, keyT, keyY, ... keyM] // and instead of this, which is ugly & lengthy var keys = [KeyboardKey]() keys.append(keyQ) keys.append(keyW) ... keys.append(keyM) // use this: var keys = [KeyboardKey]() keys.appendContentsOf([keyQ, keyW, keyE, keyR, keyT, keyY, ... keyM]) 

    Per quanto mi riguarda, ho provato tutto quanto sopra senza successo; ma tutto quello che dovevo fare era eliminare la cartella dei dati derivati, quindi aprire un altro progetto casuale, attendere che indicasse e ora il mio progetto originale (malfunzionante) funziona!

    Fai del mondo dello sviluppo un favore per la mela e rendi i tuoi veloci compilatori open source – quindi non siamo tutti frustrati dalla tua incompetenza.

    Sto usando Xcode versione 7.3 (7D175)

    Penso che avrei potuto capire un problema di fondo. Lì dove due istanze in cui mi sono bloccato nella fase di indicizzazione:

    • Ho creato una chiusura che ho assegnato a una variabile e ho omesso la firma del tipo. Penso che xcode abbia avuto problemi con quel passo di inferenza di tipo. Se ricordo correttamente uno degli argomenti era un CGPoint, che ha un costruttore sovraccarico. La mia ipotesi è che là dove troppe possibilità di ciò che la mia chiusura potrebbe accettare come argomenti.

    • Ho rifattorizzato un metodo factory in modo che invece di restituire istanze di un tipo, potesse restituire istanze di molti tipi con una class base comune. Sembra che ovunque io abbia usato il metodo factory, ho dovuto lanciare l’object risultante ad un tipo specifico (con as? O assegnandolo ad una variabile che accetta un tipo specifico). Di nuovo il passaggio di inferenza del tipo sembra essere rotto.

    Sembra che la stessa cosa stia succedendo con le dichiarazioni del dizionario menzionate da individui precedenti. Ho presentato una segnalazione di bug con Apple.

    Ho riscontrato questo stesso problema dopo l’aggiornamento a 6.1. Xcode si bloccherebbe la compilazione o l’indicizzazione senza generare un messaggio di errore specifico.

    Il problema è stato infine risolto rompendo alcune delle espressioni più lunghe nei file rapidi verso il basso in più espressioni più brevi. Parte del mio programma combina molte variabili stringa diverse per formare una stringa più lunga. I tentativi di combinarli in una singola espressione e l’utilizzo dell’operatore di assegnazione delle aggiunte sono entrambi falliti. Sono stato in grado di farlo funzionare facendo qualcosa di simile al seguente (semplificato):

     var a = "Hello" var b = " " var c = "World" var d = "!" var partA = a + b var partB = c + d var result = partA + partB 

    Ho avuto questa idea di ricevere il seguente errore molte volte nella versione precedente di Xcode “L’espressione era troppo complessa per essere risolta in tempi ragionevoli, prendere in considerazione la possibilità di scomporre l’espressione in sub-espressioni distinte.”

    Spero che questo ti aiuti

    Ho faticato con lo stesso problema. Ho provato le due soluzioni citate (eliminazione dei dati derivati ​​ed eliminazione di .xcworkspace) senza successo. Ho anche provato a commentare lentamente la maggior parte del codice bit per bit e rimuovere i file fino a quando non rimaneva quasi nulla e l’indicizzazione era ancora bloccata.

    Ho trovato una soluzione che ha funzionato per me, ho aperto il progetto con un Xcode versione 6.1 (6A1030) precedente che non ha avuto problemi di indicizzazione, quindi sono tornato all’ultima versione di Xcode 6.1 (6A1052d) che stavo usando prima e l’indicizzazione era risolto e ha continuato a funzionare bene.

    La mia conclusione è che si tratta di un bug con Xcode versione 6.1 (6A1052d) che spero possa migliorare con le versioni future.

    Il problema si ripresenta una volta ogni tanto, la stessa soluzione funziona ogni volta. Suppongo che un’altra soluzione sarebbe quella di limitarsi a utilizzare Xcode versione 6.1 (6A1030) precedente ma non funzionerà con i dispositivi con iOS 8.1 e non avrà le ultime correzioni di bug.

    Infine, ho “risolto” il problema, anche se è solo una soluzione.

    Ho creato un altro progetto e aggiunto file uno alla volta. Poi ho individuato un file “molto lungo” viewcontroller.swift. Poi ho rotto i suoi codici in moduli e ho trasformato quei codici usati più volte in funzioni in un altro file rapido. E inoltre, ho suggerito in linea che la lunga espressione dovrebbe essere spezzata in quelle più brevi. Quindi, l’indicizzazione funziona e la compilazione funziona.

    Quindi per ora, l’ho “risolto”.

    MA, non penso che sia giusto. Xcode IDE dovrebbe essere più che in grado di gestire il mio file “molto lungo”, solo 1500 righe. Credo che questo sia sicuramente un bug (esistente per molto tempo), sebbene Xcode 6.1 sia già un aggiornamento da Xcode 6.0.1.

    Per me, ho cancellato l’app Xcode e l’ho scaricato di nuovo e installato. Questo ha risolto il problema, almeno ora.

    Sul mio Xcode la soluzione era chiudere tutte le windows ridondanti. Per qualche motivo molte windows aperte rendono XCode molto lento.

    L’indicizzazione Xcode di solito per il tuo codice per suggerimenti e completamento automatico tra le altre cose, come l’assistenza in story board e viceversa. Ma per rendere più veloce il tuo progetto xcode puoi spegnerlo / accenderlo tramite terminale

    Distriggers l’indicizzazione
    valori predefiniti write com.apple.dt.XCode IDEIndexDisable 1 Attiva i valori di indicizzazione write com.apple.dt.XCode IDEIndexDisable 0

    Ma un approccio migliore per usare un veloce mac con una buona RAM.

    Ho provato questo con Xcode 8.3.3. Ecco i miei risultati:

    È ansible scrivere codice Swift perfettamente fine che causerà l’interruzione dell’indicizzazione.

    Una volta che l’indicizzazione si blocca, si blocca. La modifica del codice Swift su qualcosa che non causerebbe il blocco dell’indicizzazione non aiuta, si blocca ancora.

    Chiudere il progetto e riaprire non aiuta in quella situazione.

    Chiudere Xcode e riavviarlo aiuta. L’indicizzazione non si bloccherà più (vale a dire se hai cambiato il codice in qualcosa che non lo rende appeso).

    Anche il riavvio del tuo Mac ti aiuta, anche se non è necessario.

    L’impiccagione è causata dal perfetto codice Swift. Un esempio che mi era sembrato

     if let date = function1() ?? function2() ?? function3() ?? function4() ?? function5() ?? function6() ?? function7() ?? function8() ?? function9() ?? function10() { return date } 

    L’indicizzazione si bloccherebbe. Ho commentato la maggior parte del “??” linee e andava bene (dopo aver smesso e riavviato Xcode). Incomparabile una riga dopo l’altra. Con un certo numero di linee andava bene, quindi decommentare la riga successiva lo avrebbe bloccato.

    L’unica cosa che aiuta a quanto pare è cambiare il tuo codice.

    Ho avuto anche questo problema e ho risolto rimuovendo / cambiando espressioni con l’operatore “+”.

    Giuro cambiando questo:

     var mainArray = arrayOne + arrayTwo + arrayThree + arrayFour + arrayFive 

    A questa:

     var mainArray = arrayOne mainArray += arrayTwo mainArray += arrayThree mainArray += arrayFour mainArray += arrayFive 

    problema risolto. Mi rendo conto che sembra pazzesco ma era vero per me.

    La mia macchina è un MBP al massimo della fine del 2013

    La beta Xcode 6.2 ha risolto il problema per me. Non è un fulmine veloce, ma almeno non sta indicizzando per sempre. La beta non si installa nella parte superiore della normale installazione di Xcode, quindi se non ti piace la versione beta, puoi semplicemente eliminarla.

    Vari download di Xcode, inclusa la versione beta>

    Potresti voler aggiornare a Xcode 6.1.1

    È stato ufficialmente rilasciato e risolto per noi il problema dell’indicizzazione. Nella descrizione dell’aggiornamento si dice che hanno applicato le correzioni di stabilità, quindi è molto probabile che si comporti in modo più stabile.

    Ti auguro buona fortuna con questa saga!

    Se non ti dispiace tornare alla 6.0.1 finché non lo scoprono, è quello che ha funzionato per me. Stavo avendo lo stesso problema sia con 6.1 e 6.1.1. Ora sto bene. Proverò il 6.2 quando uscirà.

    Puoi trovare versioni precedenti del software Apple sul loro sito ufficiale di sviluppo, qui: https://developer.apple.com/downloads/index.action

    Se lo fai, assicurati di cancellare prima la tua copia attuale di Xcode.

    Sto usando Xcode 6.1.1 con file rapidi sullo stesso MacBook Pro esatto.

    Come ho continuato ad aggiungere righe in un array di stringhe 3D, Xcode è diventato improvvisamente inutilizzabile e ora non posso fare nulla.

    Proverò a tornare alla versione 6.1 e spero che il problema vada via.

    Sto vedendo questo in Xcode 6.3.2. Avevo davvero sperato che un anno dopo la pubblicazione, avrebbero fatto funzionare il compilatore, ma purtroppo.

    Se nessuna delle soluzioni di cui sopra funziona, prova a verificare il codice per gli errori sintattici. Nel processo di refactoring, ho estratto una chiusura ma ho dimenticato di qualificare i parametri:

      let hangsInsteadOfError = { l, r in return l.nameFirst < r.nameFirst || l.nameFirst == r.nameFirst && l.nameLast < r.nameLast } let fixingErrorAvoidsHang = { (l:User, r:User) -> Bool in return l.nameFirst < r.nameFirst || l.nameFirst == r.nameFirst && l.nameLast < r.nameLast } 

    Se ho imparato qualcosa dal lavorare in Swift, è di lavorare in modo incrementale, per evitare di dover tornare indietro troppo per trovare il codice offendente.

    1. Il tuo stato di indicizzazione è un “cerchio indicatore” o “barra di avanzamento”?
    2. Se è un “cerchio indicatore”, significa che è già bloccato all’inizio.
    3. Apri e controlla gli altri tuoi progetti, se sono tutti uguali, significa che si tratta di un problema di sistema.
    4. Riavvia il tuo computer e tutto andrà bene.

    Io uso Xcode 8.2 e ho finito anche con questo problema. È iniziato dopo che ho definito una variabile tupla complessa: una serie di tuple con sottoarray di tuple. Le cose diventano molto lente quando il sottoarray della tupla ha una proprietà calcasting a livello di programmazione.

    Come hanno notato altre risposte, l’indicizzazione richiede sempre e credo che stia tentando di inferire i tipi della variabile.

    Ho risolto il problema innanzitutto definendo chiaramente la variabile con i tipi inclusi. Quando si aggiorna la proprietà, la calcolo prima di assegnarla alla tupla, invece di calcolare nel definire la variabile.

    Ecco un codice di esempio.

     var sectionTuples: [(section: String, rows: [(name: String, subtitle: String)])] = [] let subtitle1: String = "" // something calculated dynamically let subtitle2: String = "" // something calculated dynamically sectionTuples = [( section: "Section 1", rows: [ (name: "name1", subtitle: subtitle1), (name: "name2", subtitle: subtitle2) ])] 

    La linea di fondo è non lasciare che Xcode deduca strutture complesse.

    Stavo avendo lo stesso problema. Il mio xCode è 8.2.1. Ma nel mio caso volevo creare un array di dizionario con 33 coppie chiave-valore. Stavo facendo in questo modo che era bloccato nell’indicizzazione:

      var parameter = [String : AnyObject]() var finalArray = [parameter] for item in listArray { parameter = ["A": item.a as AnyObject, "B": item.b as AnyObject, "C": item.c as AnyObject, ... , "Z": item.z as AnyObject] finalArray.append(parameter) } 

    In seguito ha funzionato per me:

     var parameter = [String : AnyObject]() var finalArray = [parameter] for item in listArray { parameter["A"] = listArray.a as AnyObject parameter["B"] = listArray.b as AnyObject parameter["C"] = listArray.c as AnyObject parameter["D"] = listArray.d as AnyObject . . . parameter["Z"] = listArray.z as AnyObject finalArray.append(parameter) }