summaryrefslogtreecommitdiffhomepage
path: root/fr-fr
diff options
context:
space:
mode:
authorYannick <yannick.loriot@gmail.com>2014-01-24 22:07:09 +0100
committerYannick <yannick.loriot@gmail.com>2014-01-24 22:07:09 +0100
commitdc8f3cbe30a8271f4be809ce17d68d146ee53f88 (patch)
tree7ceaec3e8ff4ba79f6b4d366019b34c3760ea4be /fr-fr
parent409317cf25c28dc9a034e0b23b7e284d73dd97e6 (diff)
[FIX] typo with the help of @Nami-Doc
Diffstat (limited to 'fr-fr')
-rw-r--r--fr-fr/objective-c-fr.html.markdown138
1 files changed, 74 insertions, 64 deletions
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 <ListeDesProtocoles>
// {
-// 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 <MonProtocole>
@@ -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