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 +++++++++++++++++++++++++++++++++++++ 1 file changed, 510 insertions(+) create mode 100644 fr-fr/objective-c-fr.html.markdown (limited to 'fr-fr/objective-c-fr.html.markdown') 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 -- 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/objective-c-fr.html.markdown') 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/objective-c-fr.html.markdown') 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/objective-c-fr.html.markdown') 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 From 5ab214be7270c9b0d0b7d394ebf05f8b75457a76 Mon Sep 17 00:00:00 2001 From: Adam Date: Wed, 29 Jan 2014 22:01:30 -0800 Subject: Added lang to objc fr --- fr-fr/objective-c-fr.html.markdown | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'fr-fr/objective-c-fr.html.markdown') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index b14b3a52..0aeb5082 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -8,6 +8,7 @@ contributors: translators: - ["Yannick Loriot", "https://github.com/YannickL"] filename: LearnObjectiveC.m +lang: fr-fr --- @@ -524,4 +525,4 @@ __unsafe_unretained NSArray *unsafeArray; // Comme __weak, mais la variable n'es [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 +[Programming with Objective-C. Apple PDF book](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf) -- cgit v1.2.3 From 4a9b80d5f5a0b2618bf7b7f5b4a6b603f6f7d7f0 Mon Sep 17 00:00:00 2001 From: Adam Date: Wed, 29 Jan 2014 22:05:08 -0800 Subject: No objc highlighting, use cpp to fix errors --- fr-fr/objective-c-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr/objective-c-fr.html.markdown') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index 0aeb5082..d48bcc5e 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -14,7 +14,7 @@ lang: fr-fr 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 +```cpp // Les commentaires sur une seule ligne commencent par // /* -- cgit v1.2.3 From 0b2a283db4bc622aaca3c23daa3c39dfd9297db1 Mon Sep 17 00:00:00 2001 From: Adam Date: Wed, 29 Jan 2014 23:30:28 -0800 Subject: Updated a lot of filenames --- fr-fr/objective-c-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr/objective-c-fr.html.markdown') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index d48bcc5e..b98d161e 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -7,7 +7,7 @@ contributors: - ["Levi Bostian", "https://github.com/levibostian"] translators: - ["Yannick Loriot", "https://github.com/YannickL"] -filename: LearnObjectiveC.m +filename: LearnObjectiveC-fr.m lang: fr-fr --- -- cgit v1.2.3 From eab554a7a7f2869ff7dac9f54acce9a7ed55cfa4 Mon Sep 17 00:00:00 2001 From: Adam Date: Mon, 8 Sep 2014 13:08:28 +0200 Subject: Review docs for added rouge lexers and update those with new highlighters --- fr-fr/objective-c-fr.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'fr-fr/objective-c-fr.html.markdown') diff --git a/fr-fr/objective-c-fr.html.markdown b/fr-fr/objective-c-fr.html.markdown index b98d161e..69f4d8f9 100644 --- a/fr-fr/objective-c-fr.html.markdown +++ b/fr-fr/objective-c-fr.html.markdown @@ -14,7 +14,7 @@ lang: fr-fr 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. -```cpp +```objective_c // Les commentaires sur une seule ligne commencent par // /* -- cgit v1.2.3