From 84b7e2ccd6ac9f9641edeb30f2c0ed22e18b0666 Mon Sep 17 00:00:00 2001 From: Yannick Date: Sat, 11 Jan 2014 22:31:22 +0100 Subject: [ADD] Translation in french of the first part --- fr-fr/objective-c.html.markdown | 509 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 509 insertions(+) create mode 100644 fr-fr/objective-c.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown new file mode 100644 index 00000000..b6567382 --- /dev/null +++ b/fr-fr/objective-c.html.markdown @@ -0,0 +1,509 @@ +--- + +language: Objective-C +contributors: + - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] + - ["Yannick Loriot", "https://github.com/YannickL"] + - ["Levi Bostian", "https://github.com/levibostian"] +translators: + - ["Yannick Loriot", "https://github.com/YannickL"] +filename: LearnObjectiveC.m + +--- + +L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs framworks respectifs, Cocoa et Cocoa Touch. + +```objective-c +// Les commentaires unilignes commencent par // + +/* +Les commentaires multilignes ressemblent à ça +*/ + +// Importe les en-têtes en utilisant #import +// Utilisez <> pour importer des fichiers globaux (en général des frameworks) +// Utilisez "" pour importer des fichiers locaux (du projet) +#import +#import "MaClasse.h" + +// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9 +// dans Xcode 5 vous pouvez importer les frameworks comme cela : +@import Foundation; + +// Le point d'entrée de votre programme est une fonction qui s'appelle main +// et qui return un entier comme type +int main (int argc, const char * argv[]) +{ + // Créer un groupe de libération automatique de la mémoire pour l'ensemble + // du programme + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + // Si vous utilisez le comptage de référence automatique (ARC), utilisez + // @autoreleasepool à la place : + @autoreleasepool { + + // Utilisez NSLog pour afficher les lignes sur la console + // Affiche la chaine de caractères "Bonjour Tous Le Monde !" + NSLog(@"Bonjour tous le Monde !"); + + /////////////////////////////////////// + // Les Types & Les Variables + /////////////////////////////////////// + + // Déclarations de primitive + int maPrimitive1 = 1; + long maPrimitive2 = 234554664565; + + // Declarations d'objets + // Il faut mettre l'* devant la déclaration d'objets fortement typés + MaClasse *monObject1 = nil; // Typage fort + id monObject2 = nil; // Typage faible + // %@ est un objet + // 'description' est une convention pour afficher la valeur des objets + NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" + + // Chaines de caractères + NSString *chaineMonde = @"Monde"; + NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" + // NSMutableString est une chaine mutable + NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"]; + [chaineMutable appendString:@" Monde !"]; + NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !" + + // Les littéraux pour les caratères + NSNumber *laLettreZSousFormeDeNombre = @'Z'; + char laLettreZ = [laLettreZSousFormeDeNombre charValue]; // ou 'Z' + NSLog(@"%c", laLettreZ); + + // Les littéraux pour les nombres + NSNumber *nombreQuaranteDeux = @42; + int quaranteDeux = [nombreQuaranteDeux intValue]; // ou 42 + NSLog(@"%i", quaranteDeux); + + NSNumber *nombreQuaranteDeuxnonSigne = @42U; + unsigned int quaranteDeuxnonSigne = [nombreQuaranteDeuxnonSigne unsignedIntValue]; + NSLog(@"%u", fortyTwoUnsigned); + + NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42]; + short quaranteDeuxCourt = [nombreQuaranteDeuxCourt shortValue]; // ou 42 + NSLog(@"%hi", fortyTwoShort); + + NSNumber *nombreQuaranteDeuxLong = @42L; + long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 + NSLog(@"%li", fortyTwoLong); + + // Les littéraux pour les flottans + NSNumber *nombrePiFlottan = @3.141592654F; + float piFlottan = [nombrePiFlottan floatValue]; // ou 3.141592654f + NSLog(@"%f", piFlottan); // affiche => 3.141592654 + NSLog(@"%5.2f", piFlottan); // affiche => " 3.14" + + NSNumber *nombrePiDouble = @3.1415926535; + double piDouble = [nombrePiDouble doubleValue]; // ou 3.1415926535 + NSLog(@"%f", piDouble); + NSLog(@"%4.2f", piDouble); // affiche => "3.14" + + // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans + // et les doubles + NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; + NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; + // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : + // +, -, *, /, il utilise donc ses propres fonctions : + [decNumUn decimalNumberByAdding:decNumDeux]; + [decNumUn decimalNumberBySubtracting:decNumDeux]; + [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; + [decNumUn decimalNumberByDividingBy:decNumDeux]; + NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable + + // Les littéraux pour les booléens + NSNumber *ouiNumber = @YES; + NSNumber *nonNumber = @NO; + // ou + BOOL ouiBool = YES; + BOOL nonBool = NO; + NSLog(@"%i", ouiBool); // affiche => 1 + + // Les listes + // Ils peuvent contenir différents types de données, mais ils doivent absolument + // être des objets + NSArray *uneListe = @[@1, @2, @3, @4]; + NSNumber *troisiemeNombre = uneListe[2]; + NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" + // NSMutableArray est une version mutable de NSArray qui permet de changer les + // objets dans la liste et l'étendre ou la réduire + // C'est très pratique, mais pas aussi performant que l'utilsation de la classe + // NSArray + NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; + [listeMutable addObject:@"Bonjour tous le"]; + [listeMutable addObject:@"Monde"]; + [listeMutable removeObjectAtIndex:0]; + NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" + + // Les dictionnaires + NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; + NSObject *valeur = unDictionnaire[@"Une clé"]; + NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" + // NSMutableDictionary est un dictionnaire mutable + NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2]; + [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"]; + [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"]; + [dictionnaireMutable removeObjectForKey:@"cle1"]; + + // Les ensembles + NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; + NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente) + // NSMutableSet est un ensemble mutable + NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2]; + [ensembleMutable addObject:@"Salut"]; + [ensembleMutable addObject:@"Salut"]; + NSLog(@"%@", ensembleMutable); // affiche => {(Salut)} + + /////////////////////////////////////// + // Operateurs + /////////////////////////////////////// + + // Les opérateurs sont les mêmes que ceux du langage C + // Par exemple : + 2 + 5; // => 7 + 4.2f + 5.1f; // => 9.3f + 3 == 2; // => 0 (NO) + 3 != 2; // => 1 (YES) + 1 && 1; // => 1 (et logique) + 0 || 1; // => 1 (ou logique) + ~0x0F; // => 0xF0 (négation bit à bit) + 0x0F & 0xF0; // => 0x00 (et bit à bit) + 0x01 << 1; // => 0x02 (décale à gauche (par 1)) + + /////////////////////////////////////// + // Structures de controle + /////////////////////////////////////// + + // Expression If-Else + if (NO) + { + NSLog(@"Je ne suis jamais affiché"); + } else if (0) + { + NSLog(@"Je ne suis jamais affiché aussi"); + } else + { + NSLog(@"Je suis affiché"); + } + + // Expression Switch + switch (2) + { + case 0: + { + NSLog(@"Je ne suis jamais affiché"); + } break; + case 1: + { + NSLog(@"Je ne suis jamais affiché aussi"); + } break; + default: + { + NSLog(@"Je suis affiché"); + } break; + } + + // Expression de boucle While + int ii = 0; + while (ii < 4) + { + NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure + } // => affiche "0," + // "1," + // "2," + // "3," + + // Expression de boucle For loops + int jj; + for (jj=0; jj < 4; jj++) + { + NSLog(@"%d,", jj); + } // => affiche "0," + // "1," + // "2," + // "3," + + // Expression de boucle Foreach + NSArray *valeurs = @[@0, @1, @2, @3]; + for (NSNumber *valeur in valeurs) + { + NSLog(@"%@,", valeur); + } // => affiche "0," + // "1," + // "2," + // "3," + + // Expressions Try-Catch-Finally + @try + { + @throw [NSException exceptionWithName:@"FileNotFoundException" + reason:@"Fichier non trouvé" userInfo:nil]; + } @catch (NSException * e) + { + NSLog(@"Exception : %@", e); + } @finally + { + NSLog(@"Finalement"); + } // => affiche "Exceptio : Fichier non trouvé" + // "Finalement" + + /////////////////////////////////////// + // Objets + /////////////////////////////////////// + + // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant + // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente + // ne sont pas fini + MaClass *monObjet = [[MaClass alloc] init]; + + // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de + // méthodes comme la plupart des autres langage de programmation + [myObject instanceMethodWithParameter:@"Steve Jobs"]; + + // Nettoie la mémoire que vous avez utilisé dans votre programme + [pool drain]; + + // Fin the l'@autoreleasepool + } + + // Fin du programme + return 0; +} + +/////////////////////////////////////// +// Classes et Fonctions +/////////////////////////////////////// + +// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) : +// La syntaxe de déclaration : +// @interface NomDeLaClasse : NomDeLaClasseParent +// { +// type nom; <= declarations de variable; +// } +// @property type nom; <= declarations de propriété. +// -/+ (type) Methode declarations; <= Declarations de methodes. +// @end +// NSObject est la classe de base de l'Objective-C +@interface MaClasse : NSObject +{ + // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans + // l'implémentation) + int nombre; // Accès protégé par défaut + @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) + NSString *nom; +} +// Notation pratique pour l'accès aux variable public et pour générrer les +// accésseurs/affecteurs +// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property +@property int propInt; // Nom du setter = 'setPropInt' +@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation +// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface +// Utilisez @synthesize dans l'@implementation pour créer l'accésseur +@property (readonly) NSString *roString; +// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les +// noms par défauts +@property (getter=longeurGet, setter=longeurSet:) int longeur; + +// Methodes ++/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre; + +// + pour les méthodes de classe : ++ (NSString *)methodeDeClasse; ++ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut; + +// - pour les méthodes d'instances : +- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string; +- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number; + +// Contructeur avec des arguments : +- (id)initAvecDistance:(int)distanceParDefault; +// Les méthodes en Objective-C sont très descriptive + +@end // Définit la fin de l'interface + + +// Exemple d'utilisation de MaClasse +MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse +[maClasse setNombre:10]; +NSLog(@"%d", [maClasse nombre]); // affiche => 10 +[myClass longeurSet:32]; +NSLog(@"%i", [maClasse longeurGet]); // affiche => 32 +// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux +// variables d'instances : +maClasse.nombre = 45; +NSLog(@"%i", maClasse.nombre); // maClasse => 45 + +// Appeler un méthode de classe : +NSString *s1 = [MaClasse methodeDeClasse]; +MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; + +// Appeler un méthode d'instance : +MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse +NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; + +// Sélecteurs sont un moyen de représenté les méthodes dynamiquement +// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions +// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en +// tant que variables +// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode +SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); +if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode + // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction + // performSelector:withObject: + NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; + [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode +} else { + // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur + NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur)); +} + +// Implement la méthode dans le fichier d'impémentation (MaClasse.m) +@implementation MaClasse { + long distance; // Variable d'instance privé + NSNumber hauteur; +} + +// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom +// de la variable : +_nombre = 5; +// Accès d'une variable définit dans le fichier d'implémentation : +distance = 18; +// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les +// accésseurs : +@synthesize roString = _roString; // _roString est disponible dans l'@implementation + +// Première méthode appelé ++ (void)initialize +{ + if (self == [MaClasse class]) { + distance = 0; + } +} + +// Counterpart to initialize method. Called when an object's reference count is zero. +- (void)dealloc +{ + [height release]; // If not using ARC, make sure to release class variable objects + [super dealloc]; // and call parent class dealloc. +} + +// Constructors are a way of creating instances of a class. +// This is a default constructor which is called when the object is initialized. +- (id)init +{ + if ((self = [super init])) // 'super' used to access methods from parent class. + { + self.count = 1; // 'self' used for object to call itself. + } + return self; +} +// Can create constructors that contain arguments: +- (id)initWithDistance:(int)defaultDistance +{ + distance = defaultDistance; + return self; +} + ++ (NSString *)classMethod +{ + return [[self alloc] init]; +} + ++ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight +{ + height = defaultHeight; + return [[self alloc] init]; +} + +- (NSString *)instanceMethodWithParameter:(NSString *)string +{ + return @"New string"; +} + +- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number +{ + return @42; +} + +// To create a private method, create the method in the @implementation but not in the @interface. +- (NSNumber *)secretPrivateMethod { + return @72; +} +[self secretPrivateMethod]; // Calls private method. + +// Methods declared into MyProtocol +- (void)myProtocolMethod +{ + // statements +} + +@end // States the end of the implementation. + +/* + * A protocol declares methods that can be implemented by any class. + * Protocols are not classes themselves. They simply define an interface + * that other objects are responsible for implementing. + */ +@protocol MyProtocol + - (void)myProtocolMethod; +@end + + +/////////////////////////////////////// +// Memory Management +/////////////////////////////////////// +/* +For each object used in an application, memory must be allocated for that object. When the application +is done using that object, memory must be deallocated to ensure application efficiency. +Objective-C does not use garbage collection and instead uses reference counting. As long as +there is at least one reference to an object (also called "owning" an object), then the object +will be available to use (known as "ownership"). + +When an instance owns an object, its reference counter is increments by one. When the +object is released, the reference counter decrements by one. When reference count is zero, +the object is removed from memory. + +With all object interactions, follow the pattern of: +(1) create the object, (2) use the object, (3) then free the object from memory. +*/ + +MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object. +[classVar release]; // Decrements classVar's reference count. +// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object. +MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner. +[classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object. + +// @property can use 'retain' and 'assign' as well for small convenient definitions. +@property (retain) MyClass *instance; // Release old value and retain a new one (strong reference). +@property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference). + +// Automatic Reference Counting (ARC) +// Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC). +// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, +// you must not use retain, relase, or autorelease. +MyClass *arcMyClass = [[MyClass alloc] init]; +// ... code using arcMyClass +// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, +// there is no need. It will insert this release statement for you. + +// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'. +@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count +// is set to zero, weakVar will automatically receive value of nil to avoid application crashing. +@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use. + +// For regular variables (not @property declared variables), use the following: +__strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope. +__weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil. +__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released. + +``` +## Further Reading + +[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) + +[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) + +[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started) -- cgit v1.2.3 From 42a5b7d305610a98d57c7ad9d576b22f33aeff75 Mon Sep 17 00:00:00 2001 From: Yannick Date: Sun, 12 Jan 2014 22:43:53 +0100 Subject: [NEW] french translation --- fr-fr/objective-c.html.markdown | 73 ++++++++++++++++++++--------------------- 1 file changed, 36 insertions(+), 37 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown index b6567382..730687db 100644 --- a/fr-fr/objective-c.html.markdown +++ b/fr-fr/objective-c.html.markdown @@ -375,80 +375,79 @@ distance = 18; // accésseurs : @synthesize roString = _roString; // _roString est disponible dans l'@implementation -// Première méthode appelé -+ (void)initialize -{ - if (self == [MaClasse class]) { - distance = 0; - } -} - -// Counterpart to initialize method. Called when an object's reference count is zero. +// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus +// utilisé - (void)dealloc { - [height release]; // If not using ARC, make sure to release class variable objects - [super dealloc]; // and call parent class dealloc. + [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet + [super dealloc]; // et à appeler la méthode de la classe parent } -// Constructors are a way of creating instances of a class. -// This is a default constructor which is called when the object is initialized. +// Les constructeurs sont une manière de créer des instances de classes +// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé - (id)init { - if ((self = [super init])) // 'super' used to access methods from parent class. + if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent { - self.count = 1; // 'self' used for object to call itself. + self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant } return self; } -// Can create constructors that contain arguments: -- (id)initWithDistance:(int)defaultDistance + +// Vous pouvez créer des constructeurs qui possèdent des arguments : +- (id)initAvecUneDistance:(int)distanceParDefault { - distance = defaultDistance; - return self; + if ((self = [super init])) + { + distance = distanceParDefault; + return self; + } } -+ (NSString *)classMethod ++ (NSString *)methodDeClasse { return [[self alloc] init]; } -+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight ++ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut { - height = defaultHeight; + hauteur = hauteurParDefaut; return [[self alloc] init]; } -- (NSString *)instanceMethodWithParameter:(NSString *)string +- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string { - return @"New string"; + return @"Ma chaine de charactère"; } -- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number +- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number { return @42; } -// To create a private method, create the method in the @implementation but not in the @interface. -- (NSNumber *)secretPrivateMethod { +// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans +// l'@interface +- (NSNumber *)methodePrivee +{ return @72; } -[self secretPrivateMethod]; // Calls private method. -// Methods declared into MyProtocol -- (void)myProtocolMethod +[self methodePrivee]; // Appel de la méthode privée + +// Méthode déclarée dans MonProtocole +- (void)methodeDuProtocole { - // statements + // expressions } -@end // States the end of the implementation. +@end // Fin de l'implémentation /* - * A protocol declares methods that can be implemented by any class. - * Protocols are not classes themselves. They simply define an interface - * that other objects are responsible for implementing. + * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci + * Un protocole n'est pas une classe, c'est juste une interface */ -@protocol MyProtocol - - (void)myProtocolMethod; +@protocol MonProtocole + - (void)methodeDuProtocole; @end -- cgit v1.2.3 From a35126f22e481fa154c6cc7252bf4d91dced2607 Mon Sep 17 00:00:00 2001 From: Yannick Date: Mon, 20 Jan 2014 22:42:23 +0100 Subject: [UPDATE] MRC section --- fr-fr/objective-c.html.markdown | 44 ++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 22 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown index 730687db..610283aa 100644 --- a/fr-fr/objective-c.html.markdown +++ b/fr-fr/objective-c.html.markdown @@ -452,32 +452,32 @@ distance = 18; /////////////////////////////////////// -// Memory Management +// Gestion de la mémoire /////////////////////////////////////// /* -For each object used in an application, memory must be allocated for that object. When the application -is done using that object, memory must be deallocated to ensure application efficiency. -Objective-C does not use garbage collection and instead uses reference counting. As long as -there is at least one reference to an object (also called "owning" an object), then the object -will be available to use (known as "ownership"). - -When an instance owns an object, its reference counter is increments by one. When the -object is released, the reference counter decrements by one. When reference count is zero, -the object is removed from memory. - -With all object interactions, follow the pattern of: -(1) create the object, (2) use the object, (3) then free the object from memory. +Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux. +Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane. +Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la +place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé. + +Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est +libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de +la mémoire. + +Une bonne pratique à suivre quand on travaille avec des objets est la suivante : +(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire. */ -MyClass *classVar = [MyClass alloc]; // 'alloc' sets classVar's reference count to one. Returns pointer to object. -[classVar release]; // Decrements classVar's reference count. -// 'retain' claims ownership of existing object instance and increments reference count. Returns pointer to object. -MyClass *newVar = [classVar retain]; // If classVar is released, object is still in memory because newVar is owner. -[classVar autorelease]; // Removes ownership of object at end of @autoreleasepool block. Returns pointer to object. +MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence +[classeVar release]; // Décrémente le compteur de rérence +// 'retain' incrémente le compteur de référence +// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle +MaClasse *nouvelleVar = [classVar retain]; +[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block -// @property can use 'retain' and 'assign' as well for small convenient definitions. -@property (retain) MyClass *instance; // Release old value and retain a new one (strong reference). -@property (assign) NSSet *set; // Pointer to new value without retaining/releasing old (weak reference). +// @property peuvent utiliser 'retain' et 'assign' +@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle +@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur // Automatic Reference Counting (ARC) // Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC). @@ -499,7 +499,7 @@ __weak NSSet *weakSet; // Weak reference to existing object. When existing objec __unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released. ``` -## Further Reading +## Lectures Complémentaires [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) -- cgit v1.2.3 From 15dcc4a6ce1d7df54292925f4d0af4a8af87eea8 Mon Sep 17 00:00:00 2001 From: Yannick Date: Fri, 24 Jan 2014 18:36:30 +0100 Subject: [UPDATE] French Translation --- fr-fr/objective-c.html.markdown | 46 +++++++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 22 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown index 610283aa..e6a8abfb 100644 --- a/fr-fr/objective-c.html.markdown +++ b/fr-fr/objective-c.html.markdown @@ -458,14 +458,14 @@ distance = 18; Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux. Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane. Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la -place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé. +place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de -la mémoire. +la mémoire Une bonne pratique à suivre quand on travaille avec des objets est la suivante : -(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire. +(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire */ MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence @@ -480,29 +480,31 @@ MaClasse *nouvelleVar = [classVar retain]; @property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur // Automatic Reference Counting (ARC) -// Because memory management can be a pain, Xcode 4.2 and iOS 4 introduced Automatic Reference Counting (ARC). -// ARC is a compiler feature that inserts retain, release, and autorelease automatically for you, so when using ARC, -// you must not use retain, relase, or autorelease. -MyClass *arcMyClass = [[MyClass alloc] init]; -// ... code using arcMyClass -// Without ARC, you will need to call: [arcMyClass release] after you're done using arcMyClass. But with ARC, -// there is no need. It will insert this release statement for you. - -// As for the 'assign' and 'retain' @property attributes, with ARC you use 'weak' and 'strong'. -@property (weak) MyClass *weakVar; // 'weak' does not take ownership of object. If original instance's reference count -// is set to zero, weakVar will automatically receive value of nil to avoid application crashing. -@property (strong) MyClass *strongVar; // 'strong' takes ownership of object. Ensures object will stay in memory to use. - -// For regular variables (not @property declared variables), use the following: -__strong NSString *strongString; // Default. Variable is retained in memory until it leaves it's scope. -__weak NSSet *weakSet; // Weak reference to existing object. When existing object is released, weakSet is set to nil. -__unsafe_unretained NSArray *unsafeArray; // Like __weak, but unsafeArray not set to nil when existing object is released. +// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence +// automatique (Automatic Reference Counting en anglais). +// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease' +// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés +MaClasse *arcMaClasse = [[MaClasse alloc] init]; +// ... code utilisant arcMaClasse +// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus +// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous + +// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong' +@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar +// sera automatiquement mis à nil +@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain' + +// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes : +__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée +__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak' +__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet +// est supprimé ailleurs ``` ## Lectures Complémentaires [La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) -[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) +[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12) -[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started) +[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) \ No newline at end of file -- cgit v1.2.3 From 3dae1ab745c2f3e5eae0a9d47c0b848f3ed44730 Mon Sep 17 00:00:00 2001 From: Yannick Date: Fri, 24 Jan 2014 18:43:22 +0100 Subject: [FIX] Objective-C French Translation Filename --- fr-fr/objective-c-fr.html.markdown | 510 +++++++++++++++++++++++++++++++++++++ fr-fr/objective-c.html.markdown | 510 ------------------------------------- 2 files changed, 510 insertions(+), 510 deletions(-) create mode 100644 fr-fr/objective-c-fr.html.markdown delete mode 100644 fr-fr/objective-c.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown new file mode 100644 index 00000000..e6a8abfb --- /dev/null +++ b/fr-fr/objective-c-fr.html.markdown @@ -0,0 +1,510 @@ +--- + +language: Objective-C +contributors: + - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] + - ["Yannick Loriot", "https://github.com/YannickL"] + - ["Levi Bostian", "https://github.com/levibostian"] +translators: + - ["Yannick Loriot", "https://github.com/YannickL"] +filename: LearnObjectiveC.m + +--- + +L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs framworks respectifs, Cocoa et Cocoa Touch. + +```objective-c +// Les commentaires unilignes commencent par // + +/* +Les commentaires multilignes ressemblent à ça +*/ + +// Importe les en-têtes en utilisant #import +// Utilisez <> pour importer des fichiers globaux (en général des frameworks) +// Utilisez "" pour importer des fichiers locaux (du projet) +#import +#import "MaClasse.h" + +// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9 +// dans Xcode 5 vous pouvez importer les frameworks comme cela : +@import Foundation; + +// Le point d'entrée de votre programme est une fonction qui s'appelle main +// et qui return un entier comme type +int main (int argc, const char * argv[]) +{ + // Créer un groupe de libération automatique de la mémoire pour l'ensemble + // du programme + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + // Si vous utilisez le comptage de référence automatique (ARC), utilisez + // @autoreleasepool à la place : + @autoreleasepool { + + // Utilisez NSLog pour afficher les lignes sur la console + // Affiche la chaine de caractères "Bonjour Tous Le Monde !" + NSLog(@"Bonjour tous le Monde !"); + + /////////////////////////////////////// + // Les Types & Les Variables + /////////////////////////////////////// + + // Déclarations de primitive + int maPrimitive1 = 1; + long maPrimitive2 = 234554664565; + + // Declarations d'objets + // Il faut mettre l'* devant la déclaration d'objets fortement typés + MaClasse *monObject1 = nil; // Typage fort + id monObject2 = nil; // Typage faible + // %@ est un objet + // 'description' est une convention pour afficher la valeur des objets + NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" + + // Chaines de caractères + NSString *chaineMonde = @"Monde"; + NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" + // NSMutableString est une chaine mutable + NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"]; + [chaineMutable appendString:@" Monde !"]; + NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !" + + // Les littéraux pour les caratères + NSNumber *laLettreZSousFormeDeNombre = @'Z'; + char laLettreZ = [laLettreZSousFormeDeNombre charValue]; // ou 'Z' + NSLog(@"%c", laLettreZ); + + // Les littéraux pour les nombres + NSNumber *nombreQuaranteDeux = @42; + int quaranteDeux = [nombreQuaranteDeux intValue]; // ou 42 + NSLog(@"%i", quaranteDeux); + + NSNumber *nombreQuaranteDeuxnonSigne = @42U; + unsigned int quaranteDeuxnonSigne = [nombreQuaranteDeuxnonSigne unsignedIntValue]; + NSLog(@"%u", fortyTwoUnsigned); + + NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42]; + short quaranteDeuxCourt = [nombreQuaranteDeuxCourt shortValue]; // ou 42 + NSLog(@"%hi", fortyTwoShort); + + NSNumber *nombreQuaranteDeuxLong = @42L; + long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 + NSLog(@"%li", fortyTwoLong); + + // Les littéraux pour les flottans + NSNumber *nombrePiFlottan = @3.141592654F; + float piFlottan = [nombrePiFlottan floatValue]; // ou 3.141592654f + NSLog(@"%f", piFlottan); // affiche => 3.141592654 + NSLog(@"%5.2f", piFlottan); // affiche => " 3.14" + + NSNumber *nombrePiDouble = @3.1415926535; + double piDouble = [nombrePiDouble doubleValue]; // ou 3.1415926535 + NSLog(@"%f", piDouble); + NSLog(@"%4.2f", piDouble); // affiche => "3.14" + + // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans + // et les doubles + NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; + NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; + // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : + // +, -, *, /, il utilise donc ses propres fonctions : + [decNumUn decimalNumberByAdding:decNumDeux]; + [decNumUn decimalNumberBySubtracting:decNumDeux]; + [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; + [decNumUn decimalNumberByDividingBy:decNumDeux]; + NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable + + // Les littéraux pour les booléens + NSNumber *ouiNumber = @YES; + NSNumber *nonNumber = @NO; + // ou + BOOL ouiBool = YES; + BOOL nonBool = NO; + NSLog(@"%i", ouiBool); // affiche => 1 + + // Les listes + // Ils peuvent contenir différents types de données, mais ils doivent absolument + // être des objets + NSArray *uneListe = @[@1, @2, @3, @4]; + NSNumber *troisiemeNombre = uneListe[2]; + NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" + // NSMutableArray est une version mutable de NSArray qui permet de changer les + // objets dans la liste et l'étendre ou la réduire + // C'est très pratique, mais pas aussi performant que l'utilsation de la classe + // NSArray + NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; + [listeMutable addObject:@"Bonjour tous le"]; + [listeMutable addObject:@"Monde"]; + [listeMutable removeObjectAtIndex:0]; + NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" + + // Les dictionnaires + NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; + NSObject *valeur = unDictionnaire[@"Une clé"]; + NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" + // NSMutableDictionary est un dictionnaire mutable + NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2]; + [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"]; + [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"]; + [dictionnaireMutable removeObjectForKey:@"cle1"]; + + // Les ensembles + NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; + NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente) + // NSMutableSet est un ensemble mutable + NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2]; + [ensembleMutable addObject:@"Salut"]; + [ensembleMutable addObject:@"Salut"]; + NSLog(@"%@", ensembleMutable); // affiche => {(Salut)} + + /////////////////////////////////////// + // Operateurs + /////////////////////////////////////// + + // Les opérateurs sont les mêmes que ceux du langage C + // Par exemple : + 2 + 5; // => 7 + 4.2f + 5.1f; // => 9.3f + 3 == 2; // => 0 (NO) + 3 != 2; // => 1 (YES) + 1 && 1; // => 1 (et logique) + 0 || 1; // => 1 (ou logique) + ~0x0F; // => 0xF0 (négation bit à bit) + 0x0F & 0xF0; // => 0x00 (et bit à bit) + 0x01 << 1; // => 0x02 (décale à gauche (par 1)) + + /////////////////////////////////////// + // Structures de controle + /////////////////////////////////////// + + // Expression If-Else + if (NO) + { + NSLog(@"Je ne suis jamais affiché"); + } else if (0) + { + NSLog(@"Je ne suis jamais affiché aussi"); + } else + { + NSLog(@"Je suis affiché"); + } + + // Expression Switch + switch (2) + { + case 0: + { + NSLog(@"Je ne suis jamais affiché"); + } break; + case 1: + { + NSLog(@"Je ne suis jamais affiché aussi"); + } break; + default: + { + NSLog(@"Je suis affiché"); + } break; + } + + // Expression de boucle While + int ii = 0; + while (ii < 4) + { + NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure + } // => affiche "0," + // "1," + // "2," + // "3," + + // Expression de boucle For loops + int jj; + for (jj=0; jj < 4; jj++) + { + NSLog(@"%d,", jj); + } // => affiche "0," + // "1," + // "2," + // "3," + + // Expression de boucle Foreach + NSArray *valeurs = @[@0, @1, @2, @3]; + for (NSNumber *valeur in valeurs) + { + NSLog(@"%@,", valeur); + } // => affiche "0," + // "1," + // "2," + // "3," + + // Expressions Try-Catch-Finally + @try + { + @throw [NSException exceptionWithName:@"FileNotFoundException" + reason:@"Fichier non trouvé" userInfo:nil]; + } @catch (NSException * e) + { + NSLog(@"Exception : %@", e); + } @finally + { + NSLog(@"Finalement"); + } // => affiche "Exceptio : Fichier non trouvé" + // "Finalement" + + /////////////////////////////////////// + // Objets + /////////////////////////////////////// + + // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant + // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente + // ne sont pas fini + MaClass *monObjet = [[MaClass alloc] init]; + + // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de + // méthodes comme la plupart des autres langage de programmation + [myObject instanceMethodWithParameter:@"Steve Jobs"]; + + // Nettoie la mémoire que vous avez utilisé dans votre programme + [pool drain]; + + // Fin the l'@autoreleasepool + } + + // Fin du programme + return 0; +} + +/////////////////////////////////////// +// Classes et Fonctions +/////////////////////////////////////// + +// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) : +// La syntaxe de déclaration : +// @interface NomDeLaClasse : NomDeLaClasseParent +// { +// type nom; <= declarations de variable; +// } +// @property type nom; <= declarations de propriété. +// -/+ (type) Methode declarations; <= Declarations de methodes. +// @end +// NSObject est la classe de base de l'Objective-C +@interface MaClasse : NSObject +{ + // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans + // l'implémentation) + int nombre; // Accès protégé par défaut + @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) + NSString *nom; +} +// Notation pratique pour l'accès aux variable public et pour générrer les +// accésseurs/affecteurs +// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property +@property int propInt; // Nom du setter = 'setPropInt' +@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation +// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface +// Utilisez @synthesize dans l'@implementation pour créer l'accésseur +@property (readonly) NSString *roString; +// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les +// noms par défauts +@property (getter=longeurGet, setter=longeurSet:) int longeur; + +// Methodes ++/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre; + +// + pour les méthodes de classe : ++ (NSString *)methodeDeClasse; ++ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut; + +// - pour les méthodes d'instances : +- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string; +- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number; + +// Contructeur avec des arguments : +- (id)initAvecDistance:(int)distanceParDefault; +// Les méthodes en Objective-C sont très descriptive + +@end // Définit la fin de l'interface + + +// Exemple d'utilisation de MaClasse +MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse +[maClasse setNombre:10]; +NSLog(@"%d", [maClasse nombre]); // affiche => 10 +[myClass longeurSet:32]; +NSLog(@"%i", [maClasse longeurGet]); // affiche => 32 +// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux +// variables d'instances : +maClasse.nombre = 45; +NSLog(@"%i", maClasse.nombre); // maClasse => 45 + +// Appeler un méthode de classe : +NSString *s1 = [MaClasse methodeDeClasse]; +MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; + +// Appeler un méthode d'instance : +MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse +NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; + +// Sélecteurs sont un moyen de représenté les méthodes dynamiquement +// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions +// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en +// tant que variables +// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode +SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); +if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode + // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction + // performSelector:withObject: + NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; + [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode +} else { + // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur + NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur)); +} + +// Implement la méthode dans le fichier d'impémentation (MaClasse.m) +@implementation MaClasse { + long distance; // Variable d'instance privé + NSNumber hauteur; +} + +// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom +// de la variable : +_nombre = 5; +// Accès d'une variable définit dans le fichier d'implémentation : +distance = 18; +// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les +// accésseurs : +@synthesize roString = _roString; // _roString est disponible dans l'@implementation + +// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus +// utilisé +- (void)dealloc +{ + [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet + [super dealloc]; // et à appeler la méthode de la classe parent +} + +// Les constructeurs sont une manière de créer des instances de classes +// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé +- (id)init +{ + if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent + { + self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant + } + return self; +} + +// Vous pouvez créer des constructeurs qui possèdent des arguments : +- (id)initAvecUneDistance:(int)distanceParDefault +{ + if ((self = [super init])) + { + distance = distanceParDefault; + return self; + } +} + ++ (NSString *)methodDeClasse +{ + return [[self alloc] init]; +} + ++ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut +{ + hauteur = hauteurParDefaut; + return [[self alloc] init]; +} + +- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string +{ + return @"Ma chaine de charactère"; +} + +- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number +{ + return @42; +} + +// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans +// l'@interface +- (NSNumber *)methodePrivee +{ + return @72; +} + +[self methodePrivee]; // Appel de la méthode privée + +// Méthode déclarée dans MonProtocole +- (void)methodeDuProtocole +{ + // expressions +} + +@end // Fin de l'implémentation + +/* + * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci + * Un protocole n'est pas une classe, c'est juste une interface + */ +@protocol MonProtocole + - (void)methodeDuProtocole; +@end + + +/////////////////////////////////////// +// Gestion de la mémoire +/////////////////////////////////////// +/* +Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux. +Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane. +Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la +place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé + +Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est +libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de +la mémoire + +Une bonne pratique à suivre quand on travaille avec des objets est la suivante : +(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire +*/ + +MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence +[classeVar release]; // Décrémente le compteur de rérence +// 'retain' incrémente le compteur de référence +// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle +MaClasse *nouvelleVar = [classVar retain]; +[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block + +// @property peuvent utiliser 'retain' et 'assign' +@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle +@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur + +// Automatic Reference Counting (ARC) +// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence +// automatique (Automatic Reference Counting en anglais). +// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease' +// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés +MaClasse *arcMaClasse = [[MaClasse alloc] init]; +// ... code utilisant arcMaClasse +// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus +// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous + +// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong' +@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar +// sera automatiquement mis à nil +@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain' + +// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes : +__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée +__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak' +__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet +// est supprimé ailleurs + +``` +## Lectures Complémentaires + +[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) + +[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12) + +[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) \ No newline at end of file diff --git a/fr-fr/objective-c.html.markdown b/fr-fr/objective-c.html.markdown deleted file mode 100644 index e6a8abfb..00000000 --- a/fr-fr/objective-c.html.markdown +++ /dev/null @@ -1,510 +0,0 @@ ---- - -language: Objective-C -contributors: - - ["Eugene Yagrushkin", "www.about.me/yagrushkin"] - - ["Yannick Loriot", "https://github.com/YannickL"] - - ["Levi Bostian", "https://github.com/levibostian"] -translators: - - ["Yannick Loriot", "https://github.com/YannickL"] -filename: LearnObjectiveC.m - ---- - -L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs framworks respectifs, Cocoa et Cocoa Touch. - -```objective-c -// Les commentaires unilignes commencent par // - -/* -Les commentaires multilignes ressemblent à ça -*/ - -// Importe les en-têtes en utilisant #import -// Utilisez <> pour importer des fichiers globaux (en général des frameworks) -// Utilisez "" pour importer des fichiers locaux (du projet) -#import -#import "MaClasse.h" - -// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9 -// dans Xcode 5 vous pouvez importer les frameworks comme cela : -@import Foundation; - -// Le point d'entrée de votre programme est une fonction qui s'appelle main -// et qui return un entier comme type -int main (int argc, const char * argv[]) -{ - // Créer un groupe de libération automatique de la mémoire pour l'ensemble - // du programme - NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; - // Si vous utilisez le comptage de référence automatique (ARC), utilisez - // @autoreleasepool à la place : - @autoreleasepool { - - // Utilisez NSLog pour afficher les lignes sur la console - // Affiche la chaine de caractères "Bonjour Tous Le Monde !" - NSLog(@"Bonjour tous le Monde !"); - - /////////////////////////////////////// - // Les Types & Les Variables - /////////////////////////////////////// - - // Déclarations de primitive - int maPrimitive1 = 1; - long maPrimitive2 = 234554664565; - - // Declarations d'objets - // Il faut mettre l'* devant la déclaration d'objets fortement typés - MaClasse *monObject1 = nil; // Typage fort - id monObject2 = nil; // Typage faible - // %@ est un objet - // 'description' est une convention pour afficher la valeur des objets - NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" - - // Chaines de caractères - NSString *chaineMonde = @"Monde"; - NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" - // NSMutableString est une chaine mutable - NSMutableString *chaineMutable = [NSMutableString stringWithString:@"Bonjour tous le"]; - [chaineMutable appendString:@" Monde !"]; - NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !" - - // Les littéraux pour les caratères - NSNumber *laLettreZSousFormeDeNombre = @'Z'; - char laLettreZ = [laLettreZSousFormeDeNombre charValue]; // ou 'Z' - NSLog(@"%c", laLettreZ); - - // Les littéraux pour les nombres - NSNumber *nombreQuaranteDeux = @42; - int quaranteDeux = [nombreQuaranteDeux intValue]; // ou 42 - NSLog(@"%i", quaranteDeux); - - NSNumber *nombreQuaranteDeuxnonSigne = @42U; - unsigned int quaranteDeuxnonSigne = [nombreQuaranteDeuxnonSigne unsignedIntValue]; - NSLog(@"%u", fortyTwoUnsigned); - - NSNumber *nombreQuaranteDeuxCourt = [NSNumber numberWithShort:42]; - short quaranteDeuxCourt = [nombreQuaranteDeuxCourt shortValue]; // ou 42 - NSLog(@"%hi", fortyTwoShort); - - NSNumber *nombreQuaranteDeuxLong = @42L; - long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 - NSLog(@"%li", fortyTwoLong); - - // Les littéraux pour les flottans - NSNumber *nombrePiFlottan = @3.141592654F; - float piFlottan = [nombrePiFlottan floatValue]; // ou 3.141592654f - NSLog(@"%f", piFlottan); // affiche => 3.141592654 - NSLog(@"%5.2f", piFlottan); // affiche => " 3.14" - - NSNumber *nombrePiDouble = @3.1415926535; - double piDouble = [nombrePiDouble doubleValue]; // ou 3.1415926535 - NSLog(@"%f", piDouble); - NSLog(@"%4.2f", piDouble); // affiche => "3.14" - - // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans - // et les doubles - NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; - NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; - // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : - // +, -, *, /, il utilise donc ses propres fonctions : - [decNumUn decimalNumberByAdding:decNumDeux]; - [decNumUn decimalNumberBySubtracting:decNumDeux]; - [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; - [decNumUn decimalNumberByDividingBy:decNumDeux]; - NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable - - // Les littéraux pour les booléens - NSNumber *ouiNumber = @YES; - NSNumber *nonNumber = @NO; - // ou - BOOL ouiBool = YES; - BOOL nonBool = NO; - NSLog(@"%i", ouiBool); // affiche => 1 - - // Les listes - // Ils peuvent contenir différents types de données, mais ils doivent absolument - // être des objets - NSArray *uneListe = @[@1, @2, @3, @4]; - NSNumber *troisiemeNombre = uneListe[2]; - NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" - // NSMutableArray est une version mutable de NSArray qui permet de changer les - // objets dans la liste et l'étendre ou la réduire - // C'est très pratique, mais pas aussi performant que l'utilsation de la classe - // NSArray - NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; - [listeMutable addObject:@"Bonjour tous le"]; - [listeMutable addObject:@"Monde"]; - [listeMutable removeObjectAtIndex:0]; - NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" - - // Les dictionnaires - NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; - NSObject *valeur = unDictionnaire[@"Une clé"]; - NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" - // NSMutableDictionary est un dictionnaire mutable - NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2]; - [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"]; - [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"]; - [dictionnaireMutable removeObjectForKey:@"cle1"]; - - // Les ensembles - NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; - NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente) - // NSMutableSet est un ensemble mutable - NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2]; - [ensembleMutable addObject:@"Salut"]; - [ensembleMutable addObject:@"Salut"]; - NSLog(@"%@", ensembleMutable); // affiche => {(Salut)} - - /////////////////////////////////////// - // Operateurs - /////////////////////////////////////// - - // Les opérateurs sont les mêmes que ceux du langage C - // Par exemple : - 2 + 5; // => 7 - 4.2f + 5.1f; // => 9.3f - 3 == 2; // => 0 (NO) - 3 != 2; // => 1 (YES) - 1 && 1; // => 1 (et logique) - 0 || 1; // => 1 (ou logique) - ~0x0F; // => 0xF0 (négation bit à bit) - 0x0F & 0xF0; // => 0x00 (et bit à bit) - 0x01 << 1; // => 0x02 (décale à gauche (par 1)) - - /////////////////////////////////////// - // Structures de controle - /////////////////////////////////////// - - // Expression If-Else - if (NO) - { - NSLog(@"Je ne suis jamais affiché"); - } else if (0) - { - NSLog(@"Je ne suis jamais affiché aussi"); - } else - { - NSLog(@"Je suis affiché"); - } - - // Expression Switch - switch (2) - { - case 0: - { - NSLog(@"Je ne suis jamais affiché"); - } break; - case 1: - { - NSLog(@"Je ne suis jamais affiché aussi"); - } break; - default: - { - NSLog(@"Je suis affiché"); - } break; - } - - // Expression de boucle While - int ii = 0; - while (ii < 4) - { - NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure - } // => affiche "0," - // "1," - // "2," - // "3," - - // Expression de boucle For loops - int jj; - for (jj=0; jj < 4; jj++) - { - NSLog(@"%d,", jj); - } // => affiche "0," - // "1," - // "2," - // "3," - - // Expression de boucle Foreach - NSArray *valeurs = @[@0, @1, @2, @3]; - for (NSNumber *valeur in valeurs) - { - NSLog(@"%@,", valeur); - } // => affiche "0," - // "1," - // "2," - // "3," - - // Expressions Try-Catch-Finally - @try - { - @throw [NSException exceptionWithName:@"FileNotFoundException" - reason:@"Fichier non trouvé" userInfo:nil]; - } @catch (NSException * e) - { - NSLog(@"Exception : %@", e); - } @finally - { - NSLog(@"Finalement"); - } // => affiche "Exceptio : Fichier non trouvé" - // "Finalement" - - /////////////////////////////////////// - // Objets - /////////////////////////////////////// - - // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant - // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente - // ne sont pas fini - MaClass *monObjet = [[MaClass alloc] init]; - - // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de - // méthodes comme la plupart des autres langage de programmation - [myObject instanceMethodWithParameter:@"Steve Jobs"]; - - // Nettoie la mémoire que vous avez utilisé dans votre programme - [pool drain]; - - // Fin the l'@autoreleasepool - } - - // Fin du programme - return 0; -} - -/////////////////////////////////////// -// Classes et Fonctions -/////////////////////////////////////// - -// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) : -// La syntaxe de déclaration : -// @interface NomDeLaClasse : NomDeLaClasseParent -// { -// type nom; <= declarations de variable; -// } -// @property type nom; <= declarations de propriété. -// -/+ (type) Methode declarations; <= Declarations de methodes. -// @end -// NSObject est la classe de base de l'Objective-C -@interface MaClasse : NSObject -{ - // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans - // l'implémentation) - int nombre; // Accès protégé par défaut - @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) - NSString *nom; -} -// Notation pratique pour l'accès aux variable public et pour générrer les -// accésseurs/affecteurs -// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property -@property int propInt; // Nom du setter = 'setPropInt' -@property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation -// (readonly) => Ne peut pas affecté la variable en dehors de l'@interface -// Utilisez @synthesize dans l'@implementation pour créer l'accésseur -@property (readonly) NSString *roString; -// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les -// noms par défauts -@property (getter=longeurGet, setter=longeurSet:) int longeur; - -// Methodes -+/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre; - -// + pour les méthodes de classe : -+ (NSString *)methodeDeClasse; -+ (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut; - -// - pour les méthodes d'instances : -- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string; -- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number; - -// Contructeur avec des arguments : -- (id)initAvecDistance:(int)distanceParDefault; -// Les méthodes en Objective-C sont très descriptive - -@end // Définit la fin de l'interface - - -// Exemple d'utilisation de MaClasse -MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse -[maClasse setNombre:10]; -NSLog(@"%d", [maClasse nombre]); // affiche => 10 -[myClass longeurSet:32]; -NSLog(@"%i", [maClasse longeurGet]); // affiche => 32 -// Pour des raisons pratiques vous pouvez aussi utiliser la notation en point pour accéder aux -// variables d'instances : -maClasse.nombre = 45; -NSLog(@"%i", maClasse.nombre); // maClasse => 45 - -// Appeler un méthode de classe : -NSString *s1 = [MaClasse methodeDeClasse]; -MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; - -// Appeler un méthode d'instance : -MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse -NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; - -// Sélecteurs sont un moyen de représenté les méthodes dynamiquement -// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions -// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en -// tant que variables -// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode -SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); -if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode - // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction - // performSelector:withObject: - NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; - [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode -} else { - // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur - NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur)); -} - -// Implement la méthode dans le fichier d'impémentation (MaClasse.m) -@implementation MaClasse { - long distance; // Variable d'instance privé - NSNumber hauteur; -} - -// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom -// de la variable : -_nombre = 5; -// Accès d'une variable définit dans le fichier d'implémentation : -distance = 18; -// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les -// accésseurs : -@synthesize roString = _roString; // _roString est disponible dans l'@implementation - -// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus -// utilisé -- (void)dealloc -{ - [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet - [super dealloc]; // et à appeler la méthode de la classe parent -} - -// Les constructeurs sont une manière de créer des instances de classes -// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé -- (id)init -{ - if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent - { - self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant - } - return self; -} - -// Vous pouvez créer des constructeurs qui possèdent des arguments : -- (id)initAvecUneDistance:(int)distanceParDefault -{ - if ((self = [super init])) - { - distance = distanceParDefault; - return self; - } -} - -+ (NSString *)methodDeClasse -{ - return [[self alloc] init]; -} - -+ (MaClasse *)maClasseDepuisUneHauteur:(NSNumber *)hauteurParDefaut -{ - hauteur = hauteurParDefaut; - return [[self alloc] init]; -} - -- (NSString *)methodeInstanceAvecUnParametre:(NSString *)string -{ - return @"Ma chaine de charactère"; -} - -- (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number -{ - return @42; -} - -// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans -// l'@interface -- (NSNumber *)methodePrivee -{ - return @72; -} - -[self methodePrivee]; // Appel de la méthode privée - -// Méthode déclarée dans MonProtocole -- (void)methodeDuProtocole -{ - // expressions -} - -@end // Fin de l'implémentation - -/* - * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci - * Un protocole n'est pas une classe, c'est juste une interface - */ -@protocol MonProtocole - - (void)methodeDuProtocole; -@end - - -/////////////////////////////////////// -// Gestion de la mémoire -/////////////////////////////////////// -/* -Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux. -Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane. -Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la -place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé - -Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est -libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de -la mémoire - -Une bonne pratique à suivre quand on travaille avec des objets est la suivante : -(1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire -*/ - -MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence -[classeVar release]; // Décrémente le compteur de rérence -// 'retain' incrémente le compteur de référence -// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle -MaClasse *nouvelleVar = [classVar retain]; -[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block - -// @property peuvent utiliser 'retain' et 'assign' -@property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle -@property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur - -// Automatic Reference Counting (ARC) -// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence -// automatique (Automatic Reference Counting en anglais). -// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease' -// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés -MaClasse *arcMaClasse = [[MaClasse alloc] init]; -// ... code utilisant arcMaClasse -// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus -// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous - -// Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong' -@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar -// sera automatiquement mis à nil -@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain' - -// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes : -__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée -__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak' -__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet -// est supprimé ailleurs - -``` -## Lectures Complémentaires - -[La Page Wikipedia de l'Objective-C](http://fr.wikipedia.org/wiki/Objective-C) - -[iOS pour les écoliers : Votre première app iOS](http://www.raywenderlich.com/fr/39272/ios-pour-les-ecoliers-votre-premiere-app-ios-partie-12) - -[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) \ No newline at end of file -- cgit v1.2.3 From a759407f0b0da9784cf6c0f3865452d546c03da7 Mon Sep 17 00:00:00 2001 From: Yannick Date: Fri, 24 Jan 2014 20:00:45 +0100 Subject: [FIX] Typing Errors In The First Part --- fr-fr/objective-c-fr.html.markdown | 174 ++++++++++++++++++------------------- 1 file changed, 87 insertions(+), 87 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index e6a8abfb..ca0b2391 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -11,27 +11,32 @@ filename: LearnObjectiveC.m --- -L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs framworks respectifs, Cocoa et Cocoa Touch. +L'Objective-C est un langage de programmation orienté objet réflexif principalement utilisé par Apple pour les systèmes d'exploitations Mac OS X et iOS et leurs frameworks respectifs, Cocoa et Cocoa Touch. ```objective-c -// Les commentaires unilignes commencent par // +// Les commentaires sur une seule ligne commencent par // /* -Les commentaires multilignes ressemblent à ça +Les +commentaires +multi-lignes +ressemblent +à +ceci */ -// Importe les en-têtes en utilisant #import +// #import permet d'importer les en-têtes d'autres fichiers // Utilisez <> pour importer des fichiers globaux (en général des frameworks) // Utilisez "" pour importer des fichiers locaux (du projet) #import #import "MaClasse.h" -// Si vous activez les modules pour les projects iOS >= 7 ou Mac OS X >= 10.9 -// dans Xcode 5 vous pouvez importer les frameworks comme cela : +// Si vous activez les modules dans les projets iOS >= 7 ou Mac OS X >= 10.9 +// dans Xcode 5, vous pouvez importer les frameworks comme cela : @import Foundation; // Le point d'entrée de votre programme est une fonction qui s'appelle main -// et qui return un entier comme type +// et qui retourne un entier comme type int main (int argc, const char * argv[]) { // Créer un groupe de libération automatique de la mémoire pour l'ensemble @@ -41,7 +46,7 @@ int main (int argc, const char * argv[]) // @autoreleasepool à la place : @autoreleasepool { - // Utilisez NSLog pour afficher les lignes sur la console + // NSLog() permet d'afficher une chaine de caractères dans la console // Affiche la chaine de caractères "Bonjour Tous Le Monde !" NSLog(@"Bonjour tous le Monde !"); @@ -49,19 +54,19 @@ int main (int argc, const char * argv[]) // Les Types & Les Variables /////////////////////////////////////// - // Déclarations de primitive + // La déclaration de primitive int maPrimitive1 = 1; long maPrimitive2 = 234554664565; - // Declarations d'objets - // Il faut mettre l'* devant la déclaration d'objets fortement typés + // La déclaration d'objet + // Il faut mettre un astérisque devant la déclaration d'objet fortement typé MaClasse *monObject1 = nil; // Typage fort id monObject2 = nil; // Typage faible - // %@ est un objet - // 'description' est une convention pour afficher la valeur des objets + // 'description' est une méthode qui permet d'afficher un aperçut de l'objet + // La méthode 'description' est appelée par défaut quand on utilise le paramètre '%@' NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" - // Chaines de caractères + // Les chaines de caractères NSString *chaineMonde = @"Monde"; NSLog(@"Bonjour tous le %@ !", chaineMonde); // affiche => "Bonjour Tous Le Monde !" // NSMutableString est une chaine mutable @@ -69,12 +74,12 @@ int main (int argc, const char * argv[]) [chaineMutable appendString:@" Monde !"]; NSLog(@"%@", chaineMutable); // affiche => "Bonjour Tous Le Monde !" - // Les littéraux pour les caratères + // Les caractères NSNumber *laLettreZSousFormeDeNombre = @'Z'; char laLettreZ = [laLettreZSousFormeDeNombre charValue]; // ou 'Z' NSLog(@"%c", laLettreZ); - // Les littéraux pour les nombres + // Les nombres NSNumber *nombreQuaranteDeux = @42; int quaranteDeux = [nombreQuaranteDeux intValue]; // ou 42 NSLog(@"%i", quaranteDeux); @@ -91,7 +96,7 @@ int main (int argc, const char * argv[]) long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 NSLog(@"%li", fortyTwoLong); - // Les littéraux pour les flottans + // Les nombres flottans NSNumber *nombrePiFlottan = @3.141592654F; float piFlottan = [nombrePiFlottan floatValue]; // ou 3.141592654f NSLog(@"%f", piFlottan); // affiche => 3.141592654 @@ -102,19 +107,19 @@ int main (int argc, const char * argv[]) NSLog(@"%f", piDouble); NSLog(@"%4.2f", piDouble); // affiche => "3.14" - // NSDecimalNumber est une classe pour avoir plus de précision sur les flottans - // et les doubles + // NSDecimalNumber est une classe pour avoir plus de précision sur les nombres + // flottans et les doubles NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; - // NSDecimalNumber n'est pas capable d'utiliser les opérations standards : - // +, -, *, /, il utilise donc ses propres fonctions : + // NSDecimalNumber n'est pas capable d'utiliser les opérations standards (+, -, *, /) + // Il faut utiliser les méthodes suivantes : [decNumUn decimalNumberByAdding:decNumDeux]; [decNumUn decimalNumberBySubtracting:decNumDeux]; [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; [decNumUn decimalNumberByDividingBy:decNumDeux]; - NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber is immuable + NSLog(@"%@", decNumUn); // affiche => 10.99 comme NSDecimalNumber est immuable - // Les littéraux pour les booléens + // Les booléens NSNumber *ouiNumber = @YES; NSNumber *nonNumber = @NO; // ou @@ -123,15 +128,13 @@ int main (int argc, const char * argv[]) NSLog(@"%i", ouiBool); // affiche => 1 // Les listes - // Ils peuvent contenir différents types de données, mais ils doivent absolument - // être des objets + // Une liste peut contenir uniquement des objets NSArray *uneListe = @[@1, @2, @3, @4]; NSNumber *troisiemeNombre = uneListe[2]; NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" - // NSMutableArray est une version mutable de NSArray qui permet de changer les - // objets dans la liste et l'étendre ou la réduire - // C'est très pratique, mais pas aussi performant que l'utilsation de la classe - // NSArray + // NSMutableArray est une version mutable de NSArray + // Cela permet de modifier la liste en ajoutant/supprimant/modifiant des objets + // C'est très pratique, mais pas aussi performant que l'utilisation de la classe NSArray NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; [listeMutable addObject:@"Bonjour tous le"]; [listeMutable addObject:@"Monde"]; @@ -139,18 +142,20 @@ int main (int argc, const char * argv[]) NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" // Les dictionnaires + // Un dictionnaire est un ensemble de { clé: valeur } NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; NSObject *valeur = unDictionnaire[@"Une clé"]; NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" - // NSMutableDictionary est un dictionnaire mutable + // NSMutableDictionary est un dictionnaire mutable, c-à-d que l'on peut modifier NSMutableDictionary *dictionnaireMutable = [NSMutableDictionary dictionaryWithCapacity:2]; [dictionnaireMutable setObject:@"valeur1" forKey:@"cle1"]; [dictionnaireMutable setObject:@"valeur2" forKey:@"cle2"]; [dictionnaireMutable removeObjectForKey:@"cle1"]; // Les ensembles + // Un ensemble peut ne peut contenir que des objets uniques contrairement aux NSArray NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; - NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (peut être dans un ordre différente) + NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (Pas forcément dans le même ordre) // NSMutableSet est un ensemble mutable NSMutableSet *ensembleMutable = [NSMutableSet setWithCapacity:2]; [ensembleMutable addObject:@"Salut"]; @@ -158,7 +163,7 @@ int main (int argc, const char * argv[]) NSLog(@"%@", ensembleMutable); // affiche => {(Salut)} /////////////////////////////////////// - // Operateurs + // Les Operateurs /////////////////////////////////////// // Les opérateurs sont les mêmes que ceux du langage C @@ -174,10 +179,10 @@ int main (int argc, const char * argv[]) 0x01 << 1; // => 0x02 (décale à gauche (par 1)) /////////////////////////////////////// - // Structures de controle + // Les Structures de Controle /////////////////////////////////////// - // Expression If-Else + // Expression "Si-Sinon" (If-Else) if (NO) { NSLog(@"Je ne suis jamais affiché"); @@ -189,7 +194,7 @@ int main (int argc, const char * argv[]) NSLog(@"Je suis affiché"); } - // Expression Switch + // Expression "Selon" (Switch) switch (2) { case 0: @@ -206,17 +211,17 @@ int main (int argc, const char * argv[]) } break; } - // Expression de boucle While + // Expression de boucle "Tant Que" (While) int ii = 0; while (ii < 4) { - NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeure + NSLog(@"%d,", ii++); // ii++ incrémente ii après avoir utilisé sa valeur } // => affiche "0," // "1," // "2," // "3," - // Expression de boucle For loops + // Expression de boucle "Pour" (For) int jj; for (jj=0; jj < 4; jj++) { @@ -226,7 +231,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression de boucle Foreach + // Expression de boucle "Pour Chaque" (Foreach) NSArray *valeurs = @[@0, @1, @2, @3]; for (NSNumber *valeur in valeurs) { @@ -236,37 +241,37 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expressions Try-Catch-Finally + // Expression "Essayer-Attraper-Finalement" (Try-Catch-Finally) @try { @throw [NSException exceptionWithName:@"FileNotFoundException" reason:@"Fichier non trouvé" userInfo:nil]; } @catch (NSException * e) { - NSLog(@"Exception : %@", e); + NSLog(@"Une exception est survenue : %@", e); } @finally { NSLog(@"Finalement"); - } // => affiche "Exceptio : Fichier non trouvé" + } // => affiche "Une exception est survenue : Fichier non trouvé" // "Finalement" /////////////////////////////////////// - // Objets + // Les Objets /////////////////////////////////////// - // Créez une instance d'objet en allouant un espace mémoire puis en l'initialisant - // Un objet n'est pas complétement fonctionnel jusqu'à ce que les deux étapes précédente - // ne sont pas fini + // Définis et créé une instance d'objet en allouant un espace mémoire puis en + // l'initialisant. Un objet n'est pas complétement fonctionnel tant que les deux + // étapes précédentes ne sont pas terminées MaClass *monObjet = [[MaClass alloc] init]; - // Le modèle Objective-C est basé sur l'envoie de message et non sur les appels de - // méthodes comme la plupart des autres langage de programmation + // L'Objective-C est basé sur le principe d'envoie de message et non sur celui + // d'appel de méthode comme la plupart des autres langages de programmation [myObject instanceMethodWithParameter:@"Steve Jobs"]; - // Nettoie la mémoire que vous avez utilisé dans votre programme + // Nettoie la mémoire qui a été utilisée dans le programme [pool drain]; - // Fin the l'@autoreleasepool + // Fin de l'@autoreleasepool } // Fin du programme @@ -274,58 +279,54 @@ int main (int argc, const char * argv[]) } /////////////////////////////////////// -// Classes et Fonctions +// Les Classes et Les Fonctions /////////////////////////////////////// -// Déclarez votre classe dans une en-tête de fichier (MaClasse.h) : -// La syntaxe de déclaration : -// @interface NomDeLaClasse : NomDeLaClasseParent +// Déclaration d'une classe dans un en-tête de fichier (MaClasse.h) : +// La déclaration d'une classe en Objective-C commence par la déclaration de son interface : +// @interface NomDeLaClasse : NomDeLaClasseParent // { -// type nom; <= declarations de variable; +// type nom; // declaration d'une variable; // } -// @property type nom; <= declarations de propriété. -// -/+ (type) Methode declarations; <= Declarations de methodes. -// @end -// NSObject est la classe de base de l'Objective-C +// @property type nom; // declaration d'une propriété +// -/+ (type)nomDeLaMethode; // Declaration d'une methode +// @end // Termine la déclaration +// NSObject est la classe de base (super classe) en Objective-C @interface MaClasse : NSObject { - // Déclaration des variables d'instances (peut existé soit dans l'interface soir dans - // l'implémentation) - int nombre; // Accès protégé par défaut + int nombre; // Accès protégé par défaut (équivalent à '@protected int nombre;') @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) NSString *nom; } -// Notation pratique pour l'accès aux variable public et pour générrer les -// accésseurs/affecteurs -// Par défaut, le nom de l'affecteur vaut 'set' suivi par le nom de la @property -@property int propInt; // Nom du setter = 'setPropInt' +// Les propriétés permettent de générrer les accésseurs/affecteurs publiques à la compilation +// Par défaut, le nom de l'affecteur est la chaine 'set' suivi par le nom de la @property +@property int propInt; // Nom de l'affecteur = 'setPropInt' @property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation // (readonly) => Ne peut pas affecté la variable en dehors de l'@interface -// Utilisez @synthesize dans l'@implementation pour créer l'accésseur +// Il faut utiliser le mot clé '@synthesize' dans l'@implementation pour créer l'accésseur @property (readonly) NSString *roString; -// Vous pouvez personnaliser les noms des accésseurs et des affecteurs au lieu d'utiliser les -// noms par défauts +// Vous pouvez aussi personnaliser les noms des accésseurs ou des affecteurs @property (getter=longeurGet, setter=longeurSet:) int longeur; // Methodes -+/- (type de retour)signatureDeLaMethode:(Type Du Parametre *)nomDuParametre; ++/- (TypeDeRetour)signatureDeLaMethode:(TypeDuParametre *)nomDuParametre; -// + pour les méthodes de classe : +// '+' signifie que c'est une méthode de classe (statique) : + (NSString *)methodeDeClasse; + (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut; -// - pour les méthodes d'instances : +// '-' pour les méthodes d'instances (classe) : - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string; - (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number; // Contructeur avec des arguments : - (id)initAvecDistance:(int)distanceParDefault; -// Les méthodes en Objective-C sont très descriptive +// Les méthodes en Objective-C sont très descriptives -@end // Définit la fin de l'interface +@end // Fin de l'interface -// Exemple d'utilisation de MaClasse +// Voici un exemple d'utilisation de MaClasse MaClasse *maClasse = [[MaClasse alloc] init]; // créer une instance de MaClasse [maClasse setNombre:10]; NSLog(@"%d", [maClasse nombre]); // affiche => 10 @@ -336,27 +337,26 @@ NSLog(@"%i", [maClasse longeurGet]); // affiche => 32 maClasse.nombre = 45; NSLog(@"%i", maClasse.nombre); // maClasse => 45 -// Appeler un méthode de classe : +// Pour appeler une méthode de classe : NSString *s1 = [MaClasse methodeDeClasse]; MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; -// Appeler un méthode d'instance : +// Pour appeler une méthode d'instance : MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; -// Sélecteurs sont un moyen de représenté les méthodes dynamiquement -// Ils sont utilisé pour appeller des méthodes de classe, passer des methodes au travers de fonctions -// pour notifier les autres classes qu'elle peuvent les appellé, et pour sauvegarder les méthodes en -// tant que variables -// SEL est un type de donnée. @selected retourne un selecteur à partir d'un nom de methode +// les sélecteurs sont un moyen de décrire les méthodes dynamiquement +// Ils sont utilisés pour appeler des méthodes de classe et avoir des pointeurs de fonctions +// facilement manipulable +// SEL est un type de donnée et @selector retourne un selecteur à partir d'un nom de methode SEL selecteur = @selector(methodeInstanceAvecUnParametre:puisUnDeuxieme:); -if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe contient la méthode - // Doit mettre tous les arguments de la méthode dans un seul objet pour l'envoyer via la fonction +if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe possède la méthode + // Met les arguments de la méthode dans un seul objet pour l'envoyer via la fonction // performSelector:withObject: NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; - [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode + [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode via le sélecteur } else { - // NSStringFromSelector() retourne une chaine de charactères à partir d'un sélecteur + // NSStringFromSelector() retourne une chaine de caractères à partir d'un sélecteur NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur)); } @@ -417,7 +417,7 @@ distance = 18; - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string { - return @"Ma chaine de charactère"; + return @"Ma chaine de caractère"; } - (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number -- cgit v1.2.3 From 409317cf25c28dc9a034e0b23b7e284d73dd97e6 Mon Sep 17 00:00:00 2001 From: Yannick Date: Fri, 24 Jan 2014 20:19:22 +0100 Subject: [FIX] Typing Errors In The Second Part --- fr-fr/objective-c-fr.html.markdown | 63 +++++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 28 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index ca0b2391..d0e6f3eb 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -315,7 +315,7 @@ int main (int argc, const char * argv[]) + (NSString *)methodeDeClasse; + (MaClasse *)maClasseDepuisLaHauteur:(NSNumber *)hauteurParDefaut; -// '-' pour les méthodes d'instances (classe) : +// '-' pour les méthodes d'instances : - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string; - (NSNumber *)methodeInstanceAvecUnParametre:(NSString*)string puisUnDeuxieme:(NSNumber *)number; @@ -355,46 +355,48 @@ if ([maClasse respondsToSelector:selecteur]) { // Vérifie si la classe possède // performSelector:withObject: NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil]; [myClass performSelector:selectorVar withObject:arguments]; // Appele la méthode via le sélecteur -} else { +} +else { // NSStringFromSelector() retourne une chaine de caractères à partir d'un sélecteur NSLog(@"MaClasse ne possède pas de méthode : %@", NSStringFromSelector(selecteur)); } -// Implement la méthode dans le fichier d'impémentation (MaClasse.m) +// Le fichier d'implémentation de la classe MaClasse (MaClasse.m) doit commencer comme ceci : @implementation MaClasse { - long distance; // Variable d'instance privé + long distance; // Variable d'instance privé (équivalent à @private dans l'interface) NSNumber hauteur; } -// Pour accéder à une variable depuis le fichier d'implémentation on peut utiliser le _ devant le nom +// Pour accéder à une variable depuis l'implémentation on peut utiliser le _ (tiret bas) devant le nom // de la variable : _nombre = 5; -// Accès d'une variable définit dans le fichier d'implémentation : +// Accès d'une variable défini dans le fichier d'implémentation : distance = 18; -// Pour utiliser la varible @property dans l'implémentation, utiliser @synthesize qui créer les -// accésseurs : -@synthesize roString = _roString; // _roString est disponible dans l'@implementation +// Pour utiliser la variable défini par l'intermédiaire de @property, il faut utiliser @synthesize +// qui permet de créer les affecteurs et les accésseurs : +@synthesize roString = _roString; // _roString est maintenant disponible dans l'implementation -// En contre-partie de l'initialisation, la fonction dealloc est appelé quand l'objet est n'est plus -// utilisé +// En contre-partie de l'appel de la fonction 'init' lors de la création d'un objet, la fonction +// 'dealloc' est appelée quand l'objet est supprimé - (void)dealloc { - [hauteur release]; // Si vous n'utilisez par l'ARC, pensez bien à supprimer l'objet - [super dealloc]; // et à appeler la méthode de la classe parent + [hauteur release]; // Si vous n'utilisez pas ARC, pensez bien à supprimer l'objet + [super dealloc]; // et à appeler la méthode 'dealloc' de la classe parent } // Les constructeurs sont une manière de créer des instances de classes -// Ceci est le constructeur par défaut; il est appelé quand l'objet est créé +// 'init' est le constructeur par défaut; il est appelé quand l'objet est créé - (id)init { if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent { - self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'objet courrant + self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'instance courante } return self; } -// Vous pouvez créer des constructeurs qui possèdent des arguments : +// Vous pouvez aussi créer des constructeurs qui possèdent des arguments +// Attention : chaque nom de constructeur doit absolument commencer par 'init' - (id)initAvecUneDistance:(int)distanceParDefault { if ((self = [super init])) @@ -404,6 +406,7 @@ distance = 18; } } +// Implémentation d'une méthode de classe + (NSString *)methodDeClasse { return [[self alloc] init]; @@ -415,6 +418,7 @@ distance = 18; return [[self alloc] init]; } +// Implémentation d'une méthode d'instance - (NSString *)methodeInstanceAvecUnParametre:(NSString *)string { return @"Ma chaine de caractère"; @@ -425,8 +429,8 @@ distance = 18; return @42; } -// Pour créer une méthode privée, il faut la définir dans l'@implementation et non pas dans -// l'@interface +// Pour créer une méthode privée, il faut la définir dans l'implementation et non pas dans +// l'interface - (NSNumber *)methodePrivee { return @72; @@ -434,7 +438,7 @@ distance = 18; [self methodePrivee]; // Appel de la méthode privée -// Méthode déclarée dans MonProtocole +// Implémentation d'une méthode qui est déclarée dans - (void)methodeDuProtocole { // expressions @@ -443,7 +447,8 @@ distance = 18; @end // Fin de l'implémentation /* - * Un protocole déclare les méthodes qu'ils doivent implémenter afin de se conformer celui-ci + * Un protocole déclare des méthodes que chaque objet respectant celui-ci doit implémenter + * afin de se conformer celui-ci * Un protocole n'est pas une classe, c'est juste une interface */ @protocol MonProtocole @@ -455,14 +460,16 @@ distance = 18; // Gestion de la mémoire /////////////////////////////////////// /* -Pour chaque objet utilisé dans une application, la mémoire doit être alloué pour chacun d'entre eux. -Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la performane. -Il n'y a pas de ramasse-miettes en Objective-C, il utilise à la place le comptage de référence à la -place. Tant que le compteur de référence est supérieur à 1 sur un objet, l'objet ne sera pas supprimé - -Quand une instance détient un objet, le compteur de référence est incrémenté de un. Quand l'objet est -libéré, le compteur est décrémenté de un. Quand le compteur est égale à zéro, l'objet est supprimé de -la mémoire +A chaque fois qu'un objet est créé dans l'application, un bloque mémoire doit être alloué. +Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la bonne +réactivité du programme (éviter les fuites mémoires) +Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par example. L'Objective-C repose +sur le comptage de référence. A chaque objet est assigné un compteur qui permet de connaitre son état. + +Le principe est le suivant : +Lorsque l'objet est créé, le compteur est initialisé à 1. Quand une instance détient un objet, le +compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Enfin +quand le compteur arrive à zéro, l'objet est supprimé de la mémoire Une bonne pratique à suivre quand on travaille avec des objets est la suivante : (1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire -- cgit v1.2.3 From dc8f3cbe30a8271f4be809ce17d68d146ee53f88 Mon Sep 17 00:00:00 2001 From: Yannick Date: Fri, 24 Jan 2014 22:07:09 +0100 Subject: [FIX] typo with the help of @Nami-Doc --- fr-fr/objective-c-fr.html.markdown | 138 ++++++++++++++++++++----------------- 1 file changed, 74 insertions(+), 64 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index d0e6f3eb..b14b3a52 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -62,7 +62,7 @@ int main (int argc, const char * argv[]) // Il faut mettre un astérisque devant la déclaration d'objet fortement typé MaClasse *monObject1 = nil; // Typage fort id monObject2 = nil; // Typage faible - // 'description' est une méthode qui permet d'afficher un aperçut de l'objet + // 'description' est une méthode qui permet de retourner un aperçut de l'objet sous forme textuelle // La méthode 'description' est appelée par défaut quand on utilise le paramètre '%@' NSLog(@"%@ and %@", monObject1, [monObject2 description]); // Affiche "(null) et (null)" @@ -96,11 +96,11 @@ int main (int argc, const char * argv[]) long quaranteDeuxLong = [nombreQuaranteDeuxLong longValue]; // ou 42 NSLog(@"%li", fortyTwoLong); - // Les nombres flottans - NSNumber *nombrePiFlottan = @3.141592654F; - float piFlottan = [nombrePiFlottan floatValue]; // ou 3.141592654f - NSLog(@"%f", piFlottan); // affiche => 3.141592654 - NSLog(@"%5.2f", piFlottan); // affiche => " 3.14" + // Les nombres flottants + NSNumber *nombrePiFlottant = @3.141592654F; + float piFlottant = [nombrePiFlottant floatValue]; // ou 3.141592654f + NSLog(@"%f", piFlottant); // affiche => 3.141592654 + NSLog(@"%5.2f", piFlottant); // affiche => " 3.14" NSNumber *nombrePiDouble = @3.1415926535; double piDouble = [nombrePiDouble doubleValue]; // ou 3.1415926535 @@ -108,11 +108,11 @@ int main (int argc, const char * argv[]) NSLog(@"%4.2f", piDouble); // affiche => "3.14" // NSDecimalNumber est une classe pour avoir plus de précision sur les nombres - // flottans et les doubles + // flottants et les doubles NSDecimalNumber *decNumUn = [NSDecimalNumber decimalNumberWithString:@"10.99"]; NSDecimalNumber *decNumDeux = [NSDecimalNumber decimalNumberWithString:@"5.002"]; - // NSDecimalNumber n'est pas capable d'utiliser les opérations standards (+, -, *, /) - // Il faut utiliser les méthodes suivantes : + // NSDecimalNumber ne permet pas d'utiliser les opérations standards (+, -, *, /) + // Il faut utiliser les méthodes suivantes à la place : [decNumUn decimalNumberByAdding:decNumDeux]; [decNumUn decimalNumberBySubtracting:decNumDeux]; [decNumUn decimalNumberByMultiplyingBy:decNumDeux]; @@ -133,7 +133,8 @@ int main (int argc, const char * argv[]) NSNumber *troisiemeNombre = uneListe[2]; NSLog(@"Troisième nombre = %@", troisiemeNombre); // affiche "Troisième nombre = 3" // NSMutableArray est une version mutable de NSArray - // Cela permet de modifier la liste en ajoutant/supprimant/modifiant des objets + // Cela permet de modifier la liste en ajoutant de nouveaux éléments et en supprimant ou + // changeant de place des objets déjà présent // C'est très pratique, mais pas aussi performant que l'utilisation de la classe NSArray NSMutableArray *listeMutable = [NSMutableArray arrayWithCapacity:2]; [listeMutable addObject:@"Bonjour tous le"]; @@ -142,7 +143,7 @@ int main (int argc, const char * argv[]) NSLog(@"%@", [listeMutable objectAtIndex:0]); // affiche => "Monde" // Les dictionnaires - // Un dictionnaire est un ensemble de { clé: valeur } + // Un dictionnaire est un ensemble de clés : valeurs NSDictionary *unDictionnaire = @{ @"cle1" : @"valeur1", @"cle2" : @"valeur2" }; NSObject *valeur = unDictionnaire[@"Une clé"]; NSLog(@"Objet = %@", valeur); // affiche "Objet = (null)" @@ -153,7 +154,7 @@ int main (int argc, const char * argv[]) [dictionnaireMutable removeObjectForKey:@"cle1"]; // Les ensembles - // Un ensemble peut ne peut contenir que des objets uniques contrairement aux NSArray + // Un ensemble ne peut contenir de duplicatas contrairement aux NSArray NSSet *ensemble = [NSSet setWithObjects:@"Salut", @"Salut", @"Monde", nil]; NSLog(@"%@", ensemble); // affiche => {(Salut, Monde)} (Pas forcément dans le même ordre) // NSMutableSet est un ensemble mutable @@ -166,7 +167,7 @@ int main (int argc, const char * argv[]) // Les Operateurs /////////////////////////////////////// - // Les opérateurs sont les mêmes que ceux du langage C + // Les opérateurs sont pareil qu'en C // Par exemple : 2 + 5; // => 7 4.2f + 5.1f; // => 9.3f @@ -176,13 +177,13 @@ int main (int argc, const char * argv[]) 0 || 1; // => 1 (ou logique) ~0x0F; // => 0xF0 (négation bit à bit) 0x0F & 0xF0; // => 0x00 (et bit à bit) - 0x01 << 1; // => 0x02 (décale à gauche (par 1)) + 0x01 << 1; // => 0x02 (décalage à gauche (par 1)) /////////////////////////////////////// - // Les Structures de Controle + // Les Structures de Contrôle /////////////////////////////////////// - // Expression "Si-Sinon" (If-Else) + // Structure "Si-Sinon" (If-Else) if (NO) { NSLog(@"Je ne suis jamais affiché"); @@ -194,7 +195,7 @@ int main (int argc, const char * argv[]) NSLog(@"Je suis affiché"); } - // Expression "Selon" (Switch) + // Structure "Selon" (Switch) switch (2) { case 0: @@ -211,7 +212,7 @@ int main (int argc, const char * argv[]) } break; } - // Expression de boucle "Tant Que" (While) + // Structure de boucle "Tant Que" (While) int ii = 0; while (ii < 4) { @@ -221,7 +222,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression de boucle "Pour" (For) + // Structure de boucle "Pour" (For) int jj; for (jj=0; jj < 4; jj++) { @@ -231,7 +232,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression de boucle "Pour Chaque" (Foreach) + // Structure de boucle "Pour Chaque" (Foreach) NSArray *valeurs = @[@0, @1, @2, @3]; for (NSNumber *valeur in valeurs) { @@ -241,7 +242,7 @@ int main (int argc, const char * argv[]) // "2," // "3," - // Expression "Essayer-Attraper-Finalement" (Try-Catch-Finally) + // Structure "Essayer-Attraper-Finalement" (Try-Catch-Finally) @try { @throw [NSException exceptionWithName:@"FileNotFoundException" @@ -264,8 +265,11 @@ int main (int argc, const char * argv[]) // étapes précédentes ne sont pas terminées MaClass *monObjet = [[MaClass alloc] init]; - // L'Objective-C est basé sur le principe d'envoie de message et non sur celui - // d'appel de méthode comme la plupart des autres langages de programmation + // L'Objet en Objective-C est basé sur le principe d'envoie de message et non sur + // celui d'appel de méthode comme la plupart des autres langages + // C'est un détail important car cela veut dire que l'on peut envoyer un message + // à un objet qui ne possède pas la méthode demandée sans aucune incidence sur le + // fonctionnement du programme (aucune exception ne sera levée) [myObject instanceMethodWithParameter:@"Steve Jobs"]; // Nettoie la mémoire qui a été utilisée dans le programme @@ -286,10 +290,10 @@ int main (int argc, const char * argv[]) // La déclaration d'une classe en Objective-C commence par la déclaration de son interface : // @interface NomDeLaClasse : NomDeLaClasseParent // { -// type nom; // declaration d'une variable; +// type nom; // Déclaration d'une variable; // } -// @property type nom; // declaration d'une propriété -// -/+ (type)nomDeLaMethode; // Declaration d'une methode +// @property type nom; // Déclaration d'une propriété +// -/+ (type)nomDeLaMethode; // Déclaration d'une methode // @end // Termine la déclaration // NSObject est la classe de base (super classe) en Objective-C @interface MaClasse : NSObject @@ -298,7 +302,7 @@ int main (int argc, const char * argv[]) @private id donnee; // Accès privé (il est plus pratique de le faire dans l'implémentation) NSString *nom; } -// Les propriétés permettent de générrer les accésseurs/affecteurs publiques à la compilation +// Les propriétés permettent de générer les accésseurs/affecteurs publiques à la compilation // Par défaut, le nom de l'affecteur est la chaine 'set' suivi par le nom de la @property @property int propInt; // Nom de l'affecteur = 'setPropInt' @property (copy) id copyId; // (copy) => Copie l'objet pendant l'affectation @@ -345,7 +349,7 @@ MaClasse *m2 = [MaClasse maClasseDepuisLaHauteur:38]; MaClasse *maClasse = [[MaClasse alloc] init]; // Créer une instance de MaClasse NSString *stringDepuisUneInstanceDeMethode = [maClasse methodeInstanceAvecUnParametre:@"Salut"]; -// les sélecteurs sont un moyen de décrire les méthodes dynamiquement +// Les sélecteurs sont un moyen de décrire les méthodes dynamiquement // Ils sont utilisés pour appeler des méthodes de classe et avoir des pointeurs de fonctions // facilement manipulable // SEL est un type de donnée et @selector retourne un selecteur à partir d'un nom de methode @@ -363,20 +367,20 @@ else { // Le fichier d'implémentation de la classe MaClasse (MaClasse.m) doit commencer comme ceci : @implementation MaClasse { - long distance; // Variable d'instance privé (équivalent à @private dans l'interface) + long distance; // Variable d'instance privée (équivalent à @private dans l'interface) NSNumber hauteur; } // Pour accéder à une variable depuis l'implémentation on peut utiliser le _ (tiret bas) devant le nom // de la variable : _nombre = 5; -// Accès d'une variable défini dans le fichier d'implémentation : +// Accès d'une variable définie dans le fichier d'implémentation : distance = 18; -// Pour utiliser la variable défini par l'intermédiaire de @property, il faut utiliser @synthesize -// qui permet de créer les affecteurs et les accésseurs : +// Pour utiliser la variable définie par l'intermédiaire de @property, il faut utiliser @synthesize +// qui permet de créer les affecteurs et les accésseurs correspondants : @synthesize roString = _roString; // _roString est maintenant disponible dans l'implementation -// En contre-partie de l'appel de la fonction 'init' lors de la création d'un objet, la fonction +// A l'inverse dela méthode 'init' qui est appelée lors de la création d'un objet, la fonction // 'dealloc' est appelée quand l'objet est supprimé - (void)dealloc { @@ -384,18 +388,18 @@ distance = 18; [super dealloc]; // et à appeler la méthode 'dealloc' de la classe parent } -// Les constructeurs sont une manière de créer des instances de classes -// 'init' est le constructeur par défaut; il est appelé quand l'objet est créé +// Les constructeurs sont des fonctions qui permettent d'instancier un objet +// 'init' est le constructeur par défaut en Objective-C - (id)init { if ((self = [super init])) // 'super' est utilisé pour appeler la méthode de la classe parent { - self.count = 1; // 'self' est utilisé pour appeler la méthodes de l'instance courante + self.count = 1; // 'self' permet d'appeler la méthode de l'instance courante } return self; } -// Vous pouvez aussi créer des constructeurs qui possèdent des arguments +// Vous pouvez aussi créer des constructeurs avec des arguments // Attention : chaque nom de constructeur doit absolument commencer par 'init' - (id)initAvecUneDistance:(int)distanceParDefault { @@ -447,8 +451,8 @@ distance = 18; @end // Fin de l'implémentation /* - * Un protocole déclare des méthodes que chaque objet respectant celui-ci doit implémenter - * afin de se conformer celui-ci + * Un protocole déclare des méthodes et propriétés que chaque implémentation doit avoir afin de se + * conformer à celui-ci * Un protocole n'est pas une classe, c'est juste une interface */ @protocol MonProtocole @@ -460,16 +464,17 @@ distance = 18; // Gestion de la mémoire /////////////////////////////////////// /* -A chaque fois qu'un objet est créé dans l'application, un bloque mémoire doit être alloué. -Quand l'application en a fini avec cet objet, la mémoire doit être libéré pour assurer la bonne -réactivité du programme (éviter les fuites mémoires) -Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par example. L'Objective-C repose -sur le comptage de référence. A chaque objet est assigné un compteur qui permet de connaitre son état. +À chaque fois qu'un objet est créé dans l'application, un bloc mémoire doit être alloué. +Quand l'application en a fini avec cet objet, la mémoire doit être libérée afin d'éviter les fuites +mémoires +Il n'y a pas de ramasse-miettes en Objective-C contrairement à Java par exemple. La gestion de la +mémoire repose sur le comptage de référence qui, pour chaque objet, assigne un compteur qui permet +de connaitre le nombre de référence qui l'utilise. Le principe est le suivant : Lorsque l'objet est créé, le compteur est initialisé à 1. Quand une instance détient un objet, le -compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Enfin -quand le compteur arrive à zéro, l'objet est supprimé de la mémoire +compteur est incrémenté de un. Quand l'objet est libéré, le compteur est décrémenté de un. Au moment +où le compteur arrive à zéro, l'objet est supprimé de la mémoire Une bonne pratique à suivre quand on travaille avec des objets est la suivante : (1) créer un objet, (2) utiliser l'objet, (3) supprimer l'objet de la mémoire @@ -478,34 +483,39 @@ Une bonne pratique à suivre quand on travaille avec des objets est la suivante MaClasse *classeVar = [MyClass alloc]; // 'alloc' incrémente le compteur de référence [classeVar release]; // Décrémente le compteur de rérence // 'retain' incrémente le compteur de référence -// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nulle +// Si 'classeVar' est libéré, l'objet reste en mémoire car le compteur de référence est non nul MaClasse *nouvelleVar = [classVar retain]; -[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du block +[classeVar autorelease]; // Supprime l'appartenance de l'objet à la fin du bloc -// @property peuvent utiliser 'retain' et 'assign' +// Les @property peuvent utiliser 'retain' et 'assign' @property (retain) MaClasse *instance; // Libère l'ancienne valeur et retient la nouvelle @property (assign) NSSet *set; // Pointeur vers la valeur sans retenir/libérer l'ancienne valeur // Automatic Reference Counting (ARC) -// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de référence -// automatique (Automatic Reference Counting en anglais). -// ARC est une fonctionnalité du compilateur qui lui permet d'ajouter les 'retain', 'release' et 'autorelease' -// automatiquement. Donc quand utilisez ARC vous de devez plus utiliser ces mots clés +// La gestion de la mémoire étant pénible, depuis iOS 4 et Xcode 4.2, Apple a introduit le comptage de +// référence automatique (Automatic Reference Counting en anglais) +// ARC est une fonctionnalité du compilateur qui permet d'ajouter les 'retain', 'release' et 'autorelease' +// automatiquement. Cela veut dire que lorsque vous utilisez ARC vous ne devez plus utiliser ces mot-clés MaClasse *arcMaClasse = [[MaClasse alloc] init]; // ... code utilisant arcMaClasse -// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC il n'y a plus -// besoin car le compilateur ajoutera l'expréssion automatiquement pour vous +// Sans ARC, vous auriez dû appeler [arcMaClasse release] après avoir utilisé l'objet. Mais avec ARC +// activé il n'est plus nécessaire de le faire car le compilateur ajoutera l'expréssion automatiquement +// pour vous // Les mots clés 'assign' et 'retain', avec ARC sont respectivement remplacé par 'weak' et 'strong' -@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si l'instance original descend à zero, weakVar -// sera automatiquement mis à nil -@property (strong) MaClasse *strongVar; // 'strong' prend posséssion de l'objet comme le ferai le mot clé 'retain' - -// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions suivantes : -__strong NSString *strongString; // Par defaut. La variable est retenu en mémoire jusqu'à la fin de sa portée -__weak NSSet *weakSet; // Réfère la variable en utilisant le mot clé '__weak' -__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais quand la variable n'est pas mis à nil quand l'objet -// est supprimé ailleurs +@property (weak) MaClasse *weakVar; // 'weak' ne retient pas l'objet. Si le compteur de référence +// descend à zero, weakVar sera automatiquement mis à nil +@property (strong) MaClasse *strongVar; // 'strong' prend possession de l'objet comme le ferait avec +// le mot-clé 'retain' + +// Pour l'instanciation des variables (en dehors de @property), vous pouvez utiliser les instructions +// suivantes : +__strong NSString *strongString; // Par défaut. La variable est retenue en mémoire jusqu'à la fin +// de sa portée +__weak NSSet *weakSet; // Maintient une référence vers l'objet sans incrémenter son compteur de référence : +// Lorsque l'objet sera supprimé, weakSet sera mis à nil automatiquement +__unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'est pas mis à nil quand +// l'objet est supprimé ``` ## Lectures Complémentaires -- cgit v1.2.3