Dopo aver lavorato a lungo su un'app per iPhone, mi sono reso conto che il mio codice è piuttosto sporco, contenente diversi #import e metodi che non vengono chiamati o non sono affatto utili.
Vorrei sapere se esiste una direttiva del compilatore o un modo per rilevare quelle righe di codice inutili. Xcode ha uno strumento per rilevarlo?
Risposte:
Xcode ti consente di (des) controllare le impostazioni per avvisi specifici del compilatore che possono avvisarti di alcuni tipi di codice inutilizzato. (Seleziona il progetto nell'elenco sorgente e File> Ottieni informazioni, quindi seleziona la scheda Crea.) Eccone alcuni (che per me vengono visualizzati per Clang e GCC 4.2) che potrebbero interessarti:
Non vedo alcuna opzione per rilevare le importazioni inutilizzate, ma è un po 'più semplice: l'approccio a bassa tecnologia consiste semplicemente nel commentare le istruzioni di importazione fino a quando non si ottiene un errore / avviso di compilazione.
I metodi Objective-C inutilizzati sono molto più difficili da rilevare rispetto alle funzioni C inutilizzate perché i messaggi vengono inviati dinamicamente. Un avviso o un errore può dirti che hai un potenziale problema, ma la mancanza di uno non garantisce che non avrai errori di runtime.
Modifica: un altro buon modo per rilevare metodi (potenzialmente) inutilizzati è esaminare la copertura del codice dalle esecuzioni effettive. Questo di solito viene fatto in tandem con i test automatici delle unità, ma non è necessario.
Questo post del blog è un'introduzione decente al test di unità e alla copertura del codice utilizzando Xcode. La sezione su gcov(che funziona solo con il codice generato da GCC, tra l'altro) spiega come ottenere Xcode per creare codice strumentato in grado di registrare la frequenza con cui è stato eseguito. Se prendi una build strumentata della tua app per un giro nel simulatore, quindi esegui gcov su di essa, puoi vedere quale codice è stato eseguito utilizzando uno strumento come CoverStory (una GUI abbastanza semplicistica) o lcov(script Perl per creare report HTML) .
Uso gcove lcovper CHDataStructures.framework e genera automaticamente rapporti di copertura dopo ogni commit SVN. Ancora una volta, ricorda che non è saggio trattare la copertura eseguita come una misura definitiva di ciò che il codice è "morto", ma può certamente aiutare a identificare i metodi che puoi investigare ulteriormente.
Infine, dal momento che stai cercando di rimuovere il codice morto, penso che troverai interessante anche questa domanda SO:
Abbiamo utilizzato un codice Ruby creato in casa, ora estratto in una gemma chiamata fui: https://github.com/dblock/fui
Recentemente ho scritto uno script per trovare #importdichiarazioni inutilizzate (o duplicate) : https://gist.github.com/Orangenhain/7691314
Lo script prende un file ObjC .m e inizia a commentare ogni #importriga a turno e vedere se il progetto viene ancora compilato. Dovrai modificare BUILD_DIR e BUILD_CMD.
Se stai utilizzando un findcomando per consentire l'esecuzione dello script su più file, assicurati di utilizzare BUILD_CMD che utilizzi effettivamente tutti quei file (o vedrai un file con molte istruzioni di importazione inutilizzate).
L'ho scritto senza sapere che AppCode ha una caratteristica simile, tuttavia quando ho testato AppCode non era così completo come questo script (ma molto più veloce [per un intero progetto]).
Come ha detto paddydub , AppCode lo fa molto bene. Ho provato e mi ci sono voluti solo 10 minuti:
Vai a Code > Optimize Imports..., o^ + ⌥ + O
Ecco un video che descrive come eseguire questa operazione: Rilevamento dell'importazione e dei metodi inutilizzati in AppCode
Puoi utilizzare Xcode Analyzer per trovare questo e altri problemi.
http://help.apple.com/xcode/mac/8.0/#/devb7babe820
Inoltre è possibile accedere al progetto e alla build di destinazione e aggiungere le preferenze degli avvisi di modifica nelle impostazioni di build. Vedi questa guida:
http://oleb.net/blog/2013/04/compiler-warnings-for-objective-c-developers/
Recentemente, ho cambiato un grande progetto da Carbon a Cocoa. Alla fine di questo, c'erano parecchi file orfani che non erano più utilizzati. Ho scritto uno script per trovarli che essenzialmente facevano questo:
Assicurati che il sorgente sia tutto archiviato in subversion (cioè pulito) Assicurati che attualmente compili senza errori (cioè, xcodebuild restituisce lo stato 0) Quindi, per ogni file sorgente nella directory, vuoto (cioè rimuovi il contenuto, tronca la lunghezza) il source e il file di intestazione, prova una build, se fallisce, ripristina i file, altrimenti lasciali vuoti.
Dopo aver eseguito questo, ripristinare e quindi eliminare tutti i file svuotati, compilare e quindi rimuovere tutti gli errori #imports.
Dovrei anche aggiungere che è necessario evitare file a cui si fa riferimento da file .xib o .sdef e potrebbero esserci altri casi di collegamento dinamico, ma può comunque darti un buon vantaggio su ciò che può essere eliminato.
La stessa tecnica può essere utilizzata per vedere quali #import possono essere rimosse: invece di troncare il file, rimuovere a turno ogni #import nel file e vedere se la compilazione fallisce.
id, o crei un selettore da chiamare in fase di esecuzione, l'analizzatore statico non può garantire che il codice è veramente inutilizzato. Se il codice ancora necessario viene rimosso, è lì che si ottengono errori di runtime. Mi sto perdendo qualcosa?