Share
In deze zelfstudie leert u hoe u efficiënter kunt programmeren met objectliteralen!
Tijdens het programmeren, a letterlijk is gewoon een vaste waarde die een programmeur invoert in een broncodebestand. Een paar voorbeelden van C zijn onder meer:
int jaar = 2012; char initial = 'M';
In het bovenstaande is '2012' een int Letterlijk en 'M' is a verkolen letterlijk.
Computerwetenschappers noemen dit soms ook letterlijke uitdrukkingen. Een uitdrukking is gewoon een groep waarden en operatoren die een nieuwe waarde retourneren, zoals "2 * pi * r". Een letterlijke uitdrukking is een uitdrukking die alleen letterlijke waarden bevat, zoals "2 * 3.14 * 10".
Het volgende codefragment laat zien hoe variabelen kunnen worden gemaakt en toegewezen letterlijke uitdrukkingen in C:
int resultaat = 15/5; // De letterlijke uitdrukking "15/5" levert 3 dubbel op = 5/2; // De letterlijke uitdrukking "5/2" levert 2,5 op
Omdat Objective-C een superset van C is, zijn alle coderegels die tot nu toe in C zijn gedemonstreerd, ook de geldige Objective-C-syntaxis. Alle getoonde literalen zijn echter ook voor primitieve gegevenstypen. Een interessanter gebruik van letterlijke woorden is om ze op objecten toe te passen.
Het volgende is een voorbeeld van een object letterlijk:
NSString * siteTitle = @ "Mobiletuts +";
In de bovenstaande coderegel, @ "Mobiletuts +" is een letterlijk object dat wordt gebruikt om een stringobject voor te stellen. Zonder het gebruik van een letterlijk object zou de bovenstaande coderegel heel anders geschreven moeten zijn, misschien als volgt:
NSString * siteTitle = [NSString stringWithUTF8String: "Mobiletuts"];
Zoals u kunt zien, is de letterlijke syntaxis van het object veel beknopter en leesbaarder.
Met de release van de Apple LLVM Compiler 4.0 is extra letterlijk letterlijke ondersteuning toegevoegd voor NSNumber objecten, matrixobjecten en woordenboekobjecten.
NSNumber objecten kunnen nu worden weergegeven met object-letterwoorden.
Het volgende codefragment illustreert de traditionele stijl:
NSNumber * boolYES = [NSNumber numberWithBool: YES]; NSNumber * boolNO = [NSNumber numberWithBool: NO]; NSNumber * charX = [NSNumber numberWithChar: '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];
Met behulp van objectliteralen kan het bovenstaande als eenvoudig worden herschreven:
NSNumber * boolYES = @YES; NSNummer * boolNO = @NO; NSNumber * charX = @ 'X'; NSNumber * fortySevenInt = @ 47; NSNumber * fortySevenUnsigned = @ 47U; NSNumber * fortySevenLong = @ 47L; NSNumber * goldenRatioFloat = @ 1.61803F; NSNummer * goldenRatioDouble = @ 1.61803;
Letterlijke verzamelingen zijn een ongelooflijk nuttige aanvulling op Objective-C. De nieuwe LLVM-compiler biedt de mogelijkheid om verzamel-literalen te maken voor zowel arrays en woordenboeken, maar niet voor sets.
De oude syntaxis voor het maken van een NSArray:
NSArray * -instrumenten = [NSArray-arrayWithObjects: @ "Ocarina", @ "Flute", @ "Harp", niets];
De nieuwe, object-letterlijke syntaxis voor het maken van een NSArray:
NSArray * -instrumenten = @ [@ "Ocarina", @ "Flute", @ "Harp"];
Helaas werkt de bovenstaande syntaxis niet voor het declareren van een NSMutableArray, maar er is een gemakkelijk werk rond. Ga gewoon voorbij mutableCopy bericht naar het nieuw gevormde object:
NSMutableArray * instrumentsMutable = [@ [@ "Ocarina", @ "Flute", @ "Harp"] mutableCopy];
De traditionele methode voor het maken van een woordenboek met Objective-C ziet er ongeveer zo uit:
NSArray * keys = [NSArray arrayWithObjects: @ "Character", @ "Weapon", @ "Hitpoints", nihil]; NSArray * objects = [NSArray arrayWithObjects: @ "Zelda", @ "Sword", [NSNumber numberWithInt: 50], nihil]; NSDictionary * stats = [NSDictionary woordenboekWithObjects: objects forKeys: keys];
Of, een iets minder uitgebreid alternatief:
NSDictionary * stats = [NSDictionary woordenboekWithObjectsAndKeys: @ "Zelda", @ "Character", @ "Sword", @ "Weapon", [NSNumber numberWithInt: 50], @ "Hitpoints", nihil];
Beide voorbeelden zijn een goed voorbeeld van waarom Objective-C een slechte reputatie heeft opgebouwd door overdreven breedsprakig te zijn. Niet meer! Met object-letterwoorden kan de bovenstaande code eenvoudig worden herschreven:
NSDictionary * stats = @ @ "Character": @ "Zelda", @ "Weapon": @ "Sword", @ "Hitpoints": @ 50;
Dit is veel gemakkelijker om te begrijpen en te schrijven.
Naast het kunnen maken van collecties met objectliteralen, heeft de nieuwste LLVM-compiler ook ondersteuning geïntroduceerd voor toegang tot matrix- of woordenboekwaarden met subscripts.
Dit is bijvoorbeeld de traditionele vorm die wordt gebruikt voor toegang tot een object uit een matrix of woordenboek:
NSString * instrument = [instruments objectAtIndex: 0]; // Retourneert 'Ocarina' NSString * name = [stats objectForKey: @ "Character"]; // Retourneert 'Zelda'
Met de nieuwe, subscripting-mogelijkheid kunt u dit gewoon doen:
NSString * instrument = instrumenten [0]; // Retourneert 'Ocarina' NSString * name = stats [@ "Character"]; // Retourneert 'Zelda'
Beter nog, verzameling subscripts zijn niet alleen beperkt tot het selecteren van objecten. Als de verzameling muteerbaar is, kunt u ook waarden opnieuw toewijzen:
instrumentsMutable [0] = @ "Ocarina of Time"; statsMutable [@ "Weapon"] = @ "Hammer";
Dit is een enorme stap voorwaarts voor Objective-C-programmeurs en ik denk dat het de taal toegankelijker zal maken voor mensen die overstappen van andere talen zoals Java of C ++.
Het laatste onderwerp dat het vermelden waard is in deze tutorial is het concept van "Boxed Expressions". In wezen ondersteunt Objective-C nu het converteren van het resultaat van een expressie in C-stijl naar een Objective-C-object. De basissyntaxis hiervoor is als volgt:
@ (2 * pi * r)
Het resultaat van het bovenstaande zou een zijn NSNumber object dat het product bevatte van 2 keer de waarde van pi maal de waarde van r. We zouden dit product natuurlijk onmiddellijk kunnen toewijzen aan een NSNumber-variabele:
NSNummer * diameter = @ (2 * pi * r);
Deze techniek zal ook werken met enums en strings:
// Boxed Expressions with Enums typedef enum Sword, Hammer, Shield, Arrow Weapons; NSNumber * currentWeapon = @ (Sword); // Retourneert 0 // Boxed Expressions with char * NSString * login = @ (getlogin ()); // Retourneert inlognaam // Resultaten NSLog (@ "Weapon:% @ \ nLogin:% @", currentWeapon, login);
Deze zelfstudie biedt u een snel overzicht van objectliteralen, een nieuwe techniek die is geïntroduceerd met de Apple LLVM Compiler 4.0. Raadpleeg de officiële LLVM-documentatie voor meer informatie over dit onderwerp.
Ik hoop dat je deze tutorial met plezier hebt gelezen. Voel je vrij om feedback te geven die je hebt in de comments hieronder. U kunt ook contact met mij opnemen via Twitter of Google Plus. Proost!
Accentsconagua