Share
Questo tutorial ti insegnerà come programmare in modo più efficiente usando gli oggetti letterali!
Nella programmazione, a letterale è semplicemente un valore fisso che un programmatore immette in un file di codice sorgente. Alcuni esempi di C includono:
int anno = 2012; char initial = 'M';
Nel precedente, '2012' è un int letterale e 'M' è un carbonizzare letterale.
Anche a Computer Scientist ci si riferisce a volte espressioni letterali. Un espressione è semplicemente un gruppo di valori e operatori che restituiscono un nuovo valore, ad esempio "2 * pi * r". Un'espressione letterale è un'espressione che contiene solo valori letterali, ad esempio "2 * 3.14 * 10".
Il seguente frammento di codice dimostra come è possibile creare e assegnare le variabili espressioni letterali in C:
int risultato = 15/5; // L'espressione letterale "15/5" restituisce 3 double = 5/2; // L'espressione letterale "5/2" restituisce 2.5
Poiché Objective-C è un superset di C, tutte le linee di codice dimostrate in C finora sono anche valide sintassi Objective-C. Tuttavia, tutti i letterali dimostrati sono stati anche per tipi di dati primitivi. Un uso più interessante dei letterali è di applicarli agli oggetti.
Il seguente è un esempio di un oggetto letterale:
NSString * siteTitle = @ "Mobiletuts +";
Nella riga di codice sopra, @ "Mobiletuts +" è un oggetto letterale che viene utilizzato per rappresentare un oggetto stringa. Senza l'uso di un oggetto letterale, la riga di codice sopra dovrebbe essere scritta in modo molto diverso, forse in questo modo:
NSString * siteTitle = [NSString stringWithUTF8String: "Mobiletuts"];
Come puoi vedere, la sintassi letterale dell'oggetto è molto più concisa e leggibile.
Con il rilascio di Apple LLVM Compiler 4.0, è stato aggiunto un supporto letterale agli oggetti aggiuntivo NSNumber oggetti, oggetti matrice e oggetti dizionario.
NSNumber gli oggetti possono ora essere rappresentati con oggetti letterali.
Il seguente frammento di codice illustra lo stile tradizionale:
NSNumber * boolYES = [NSNumero numericoWithBool: YES]; NSNumber * boolNO = [NSNumero numericoWithBool: NO]; NSNumber * charX = [NSNumero numericoWithChar: 'X']; NSNumber * fortySevenInt = [NSNumber numberWithInt: 47]; NSNumber * fortySevenUnsigned = [NSNumber numberWithUnsignedInt: 47U]; NSNumber * fortySevenLong = [NSNumber numberWithLong: 47L]; NSNumber * goldenRatioFloat = [NSNumber numberWithFloat: 1.61803F]; NSNumber * goldenRatioDouble = [NSNumber numberWithDouble: 1.61803];
Usando gli oggetti letterali, quanto sopra può essere riscritto come semplicemente:
NSNumber * boolYES = @YES; NSNumber * boolNO = @NO; NSNumber * charX = @ 'X'; NSNumber * fortySevenInt = @ 47; NSNumber * fortySevenUnsigned = @ 47U; NSNumber * fortySevenLong = @ 47L; NSNumber * goldenRatioFloat = @ 1.61803F; NSNumber * goldenRatioDouble = @ 1.61803;
I letterali di raccolta sono un'aggiunta incredibilmente utile a Objective-C. Il nuovo compilatore LLVM offre la possibilità di creare letterali di raccolta per array e dizionari, ma non per set.
La vecchia sintassi per la creazione di un NSArray:
NSArray * instruments = [NSArray arrayWithObjects: @ "Ocarina", @ "Flute", @ "Arpa", nil];
La nuova sintassi letterale dell'oggetto per la creazione di un NSArray:
NSArray * instruments = @ [@ "Ocarina", @ "Flute", @ "Arpa"];
Sfortunatamente, la sintassi precedente non funzionerà per la dichiarazione di un NSMutableArray, ma c'è un lavoro facile in giro. Basta passare il mutableCopy messaggio all'oggetto appena formato:
NSMutableArray * instrumentsMutable = [@ [@ "Ocarina", @ "Flute", @ "Arpa"] mutableCopy];
Il metodo tradizionale per creare un dizionario con Objective-C assomiglia a questo:
NSArray * keys = [NSArray arrayWithObjects: @ "Character", @ "Weapon", @ "Hitpoints", nil]; NSArray * objects = [NSArray arrayWithObjects: @ "Zelda", @ "Sword", [NSNumber numberWithInt: 50], nil]; NSDictionary * stats = [Dizionario NSDictionaryWithObjects: oggetti forKeys: keys];
O, un'alternativa un po 'meno prolissa:
NSDictionary * stats = [dizionario NSDictionaryWithObjectsAndKeys: @ "Zelda", @ "Character", @ "Sword", @ "Weapon", [NSNumber numberWithInt: 50], @ "Hitpoints", nil];
Entrambi i precedenti sono esempi fondamentali del perché Objective-C ha sviluppato una cattiva reputazione per essere eccessivamente prolisso. Non piu! Con gli oggetti letterali, il codice sopra può essere riscritto come semplicemente:
NSDictionary * stats = @ @ "Character": @ "Zelda", @ "Weapon": @ "Sword", @ "Hitpoints": @ 50;
Questo è molto più facile da capire e scrivere.
Oltre a essere in grado di creare raccolte con oggetti letterali, l'ultimo compilatore LLVM ha anche introdotto il supporto per l'accesso ai valori dell'array o del dizionario con gli indici.
Ad esempio, questo è il modulo tradizionale utilizzato per accedere a un oggetto da un array o da un dizionario:
NSString * instrument = [instruments objectAtIndex: 0]; // Restituisce 'Ocarina' NSString * name = [stats objectForKey: @ "Character"]; // restituisce 'Zelda'
Con la nuova funzionalità di sottoscrizione puoi fare questo:
NSString * instrument = instruments [0]; // Restituisce 'Ocarina' NSString * name = stats [@ "Character"]; // restituisce 'Zelda'
Ancora meglio, gli abbonati alla raccolta non si limitano solo alla selezione degli oggetti. Se la raccolta è modificabile, puoi anche riassegnare i valori:
instrumentsMutable [0] = @ "Ocarina of Time"; statsMutable [@ "Weapon"] = @ "Hammer";
Questo è un enorme passo in avanti per i programmatori Objective-C, e penso che renderà il linguaggio più accessibile a coloro che passano da altri linguaggi come Java o C ++.
L'argomento finale che vale la pena menzionare in questo tutorial è il concetto di "Boxed Expressions". Essenzialmente, Objective-C ora supporta la conversione del risultato di un'espressione in stile C in un oggetto Objective-C. La sintassi di base per questo è così:
@ (2 * pi * r)
Il risultato di quanto sopra sarebbe un NSNumber oggetto che conteneva il prodotto di 2 volte il valore di pi volte il valore di r. Potremmo, ovviamente, assegnare immediatamente quel prodotto a una variabile NSNumber:
NSNumber * diameter = @ (2 * pi * r);
Questa tecnica funzionerà anche con enumerazioni e stringhe:
// Espressioni in scatola con Enums typedef enum Spada, Martello, Scudo, Freccia Armi; NSNumber * currentWeapon = @ (Sword); // Restituisce 0 // Espressioni in box con char * NSString * login = @ (getlogin ()); // Restituisce il nome di login // Results NSLog (@ "Weapon:% @ \ nLogin:% @", currentWeapon, login);
Questo tutorial ti ha fornito una rapida panoramica dei letterali degli oggetti, una nuova tecnica introdotta con Apple LLVM Compiler 4.0. Per una trattazione più approfondita di questo argomento, fare riferimento alla documentazione ufficiale di LLVM.
Spero ti sia piaciuto leggere questo tutorial. Sentiti libero di lasciare qualsiasi commento nella sezione commenti qui sotto. Puoi anche connetterti con me su Twitter o Google Plus. Saluti!
Accentsconagua