Version en ligne

Tutoriel : Créez des applications pour iPhone, iPad et iPod Touch

Table des matières

Créez des applications pour iPhone, iPad et iPod Touch
L’équipement du codeur
De quel ordinateur s'équiper ?
Une brève histoire d'Apple
Et la programmation dans tout ça ?
Les logiciels nécessaires
Un premier développement
Création de l'application
Ajout des contrôles sur l’interface
Liaison des contrôles au code
Ecriture du code
Construction et exécution
Le simulateur iOS
Les bases
Simuler les gestuelles et les actions de l'utilisateur
Quelques pratiques à connaître
Les bases de l'Objective-C
Mise en pratique de ce chapitre
Instructions
Variables, constantes et opérateurs
Commentaires
Types de données
Les pointeurs
Conditions, boucles et fonctions
Conditions
Boucles
Fonctions
La programmation orientée objet
Qu'est-ce que la programmation Orientée Objet ?
Définir une classe
Définir des méthodes
Appeler des méthodes
Les principaux objets utilisés en Objective-C
Chaînes de caractères
Nombres
Dates et heures
Tableaux
Dictionnaires
Ensembles
TP – Un jeu de Mastermind
Instructions pour réaliser le TP
Correction
Fenêtres, vues et contrôles
Création d'une application multivues
Insérer un contrôle dans une application
Positionner, aligner et redimensionner un contrôle à vue
Un aperçu des contrôles disponibles
Les volets Attributs et Taille
Les contrôles qui affichent des données (1/2)
Afficher du texte non modifiable
Saisir du texte sur une ligne
Saisir du texte sur plusieurs lignes
Afficher une image
Les contrôles qui affichent des données (2/2)
Afficher du contenu Web
Afficher une carte
Quand le contenu dépasse la taille du contrôle, de la vue ou de la fenêtre
Demander son avis à l'utilisateur
Les informations tabulaires
Listes d'informations sur une colonne
Listes d'informations sur une ou plusieurs colonnes
Sélection d'une date dans un contrôle spécialisé
Les contrôles d'action
Boutons
Segmented Control
Zones de texte
Curseurs
Interrupteurs
Contrôles de page
Barres et tabulations
Applications multivues
Barre d'outils
Barre de recherche
Gestion simultanée de deux vues sur un iPad
Insertion de contrôles avec le code
Le code complet
Affichage d'un label
Affichage d'un Round Rect Button
Affichage d'un Text Field
Affichage d'un rectangle de couleur rouge
Affichage d'une image
TP – Un navigateur Web très ciblé
Principe du TP
Correction
Géolocalisation
Longitude et latitude
Vitesse
Géolocalisation inversée
Multimédia : le son
Jouer des éléments audio
Enregistrement audio
Multimédia : l'image
Jouer des éléments vidéo
Prendre des photos
Accéléromètre
Mise en place de l'application
Écriture du code
Un jeu de casse briques
Définition de l'interface
Immersion dans le code
Le code de l'application
TP - Capturez les vers
Principe du TP
Solution
Gestion des matériels et des identités numériques
Déboguer une application
Souscrire au programme de développement iOS
Certificats et profils d'approvisionnement
Travailler sur un device
Proposer une application sur l'App Store
Préparation préliminaire
Configuration de iTunes Connect
Validation et soumission d'une application
Gagner de l'argent avec une application

Créez des applications pour iPhone, iPad et iPod Touch

Créer ses propres applications pour iPhone, iPad ou iPod Touch : un rêve pour beaucoup d'entre nous ! Certains disent que l'univers Apple est fermé, d'autres que les langages de programmation pour Apple sont difficiles à apprendre. Mais qu'en est-il vraiment ?

En ce qui me concerne, je pense que si vous avez un peu de volonté, de temps et des idées plein la tête, vous pouvez faire des merveilles sur les périphériques portables Apple. Avec ce tutoriel, je vais vous faire découvrir l'univers merveilleux de la programmation iOS, c'est-à-dire de la programmation d'applications pour iPhone / iPod Touch / iPad, toutes versions confondues.

Peu importe que vous soyez de parfaits débutants en programmation ; si tel est le cas, il vous faudra juste un peu plus de temps pour assimiler et mettre en pratique tout ce qui sera dit dans ce tutoriel. Bien vite, vous progresserez à pas de géant et vous serez capables de réaliser des applications qui viendront enrichir l'App Store, la plateforme d'applications dédiée à l'univers Apple, et plus particulièrement aux iPhone, iPod Touch et iPad.

Pour cela, vous allez devoir apprendre à utiliser :

  1. Xcode, l'environnement de développement dédié d'Apple ;

  2. Objective-C, le langage (principalement) dédié à la programmation des périphériques portables d'Apple.

Votre apprentissage se fera de façon très progressive et je suis sûr que vous passerez toutes les étapes du parfait programmeur avec succès.
Pour vous mettre l'eau à la bouche, voici en images quelques exemples des applications qui seront développées dans ce tutoriel :

Image utilisateurImage utilisateurImage utilisateurImage utilisateurImage utilisateur

Si vous êtes prêts à me rejoindre dans cette aventure, j'en serais ravi. Mais assez parlé, il est temps de faire connaissance avec l'univers Apple.

Image utilisateurCe cours vous plaît ?

Si vous avez aimé ce cours, vous pouvez retrouver le livre "Créez des applications pour iPhone, iPad et iPod Touch" du même auteur en vente sur le Site du Zéro, en librairie et dans les boutiques en ligne. Vous y trouverez ce cours adapté au format papier.

Vous pouvez également obtenir cet ouvrage au format eBook sur Amazon ou sur iTunes.

Plus d'informations

L’équipement du codeur

De quel ordinateur s'équiper ?

Ça y est, vous êtes prêts à franchir le pas et à développer des applications pour les périphériques mobiles Apple ? Vous devez certainement vous demander si cela est possible et si vous y arriverez.

Rien n'est impossible ! Surtout que je vais vous accompagner tout au long de votre apprentissage. Peu importe si vous n'avez jamais utilisé de Mac ou si vous n'avez aucune expérience en programmation. Avec de la volonté et armés de ce livre, vous vous en sortirez haut la main.

Si vous êtes prêts à tenter l'aventure, voyons de quel matériel vous aurez besoin.

De quel ordinateur s'équiper ?

L’équipement du codeur Une brève histoire d'Apple

Comment ça, de quel ordinateur s'équiper ? J'ai déjà un PC et j'en suis satisfait ! Pourquoi est-ce que je devrais investir dans un nouveau matériel ?

Eh bien, je suis désolé de vous l'apprendre, mais les développements pour iPhone, iPad et iPod Touch se font presque exclusivement sur Mac. Et ce n'est pas tout ! Le Mac doit :

  1. être équipé d'un processeur Intel ;

  2. posséder au moins 1 gigaoctet (1 Go) de mémoire vive ;

  3. utiliser le système d'exploitation Mac OS X Lion, Snow Leopard ou Leopard ;

  4. disposer d'un port USB libre et/ou d'une connexion wifi afin de connecter votre iPhone/iPod Touch/iPad à l'ordinateur et de tester vos applications.

Presque exclusivement sur un Mac ? Des précisions s'il vous plaît ?

Il est également possible de développer des applications pour les produits Apple en utilisant un ordinateur fonctionnant sous Windows ou Linux, mais ce n'est (vraiment) pas la voie la plus simple, ni bien évidemment celle recommandée par Apple.
Ce livre s'intéressera uniquement à la méthode de développement traditionnelle : sur un Mac, via l'application Xcode.

Si vous possédez déjà un Mac, je vais vous montrer comment savoir s'il est équipé en conséquence : cliquez sur la pomme dans le Finder et sélectionnez À propos de ce Mac dans le menu. À la figure suivante par exemple, le Mac est équipé d'un processeur Intel Core 2 Duo et utilise le système OS X 10.6.7, donc Snow Leopard.

Quelques informations à propos du Mac

Si vous devez vous équiper, allez faire un tour sur l'Apple Store. Tous les Mac vendus dans le Store peuvent être utilisés. Selon votre budget, vous choisirez un Mac Mini, un MacBook, un MacBook Air, un MacBook Pro ou un iMac.

Si votre budget est limité, rabattez-vous sur une machine reconditionnée. Vous y trouverez des Mac testés et agréés par Apple. Sous garantie pendant un an, les machines proposées sont à un prix sensiblement inférieur à celui du neuf et (sauf exception) dans un excellent état !

Dans la mesure du possible, investissez dans un écran large de 22 ou 24 pouces. Comme vous le verrez dans ce livre, l'environnement de développement est à l'aise sur un grand écran, et un 22 pouces n'est vraiment pas un luxe !
Si vous êtes déjà équipés d'un écran pour PC, vous pourrez le connecter sur votre Mac, à condition que sa connexion soit de type DVI (figure suivante).

Une prise DVI

J'entends déjà bon nombre d'entre vous se plaindre : « mon écran n'a qu'un connecteur VGA ! Est-ce que je dois acheter un nouvel écran ? »
Non, rassurez-vous, il vous suffit d'acheter un adaptateur VGA/DVI (figure suivante). Pour quelques euros, vous pourrez connecter votre Mac sur votre écran VGA.

Un adaptateur VGA/DVI

Pour les plus ambitieux d'entre vous, sachez qu'il est possible de connecter deux écrans sur tous les Mac récents. À vous de trouver les adaptateurs qui conviennent, comme par exemple un Mini DisplayPort/VGA (figure suivante).

À gauche un Mini DisplayPort/VGA et à droite un Mini DisplayPort/DVI

Un autre matériel est-il nécessaire ?

Je vais encore jouer les rabat-joie : il ne suffit pas d'être équipé d'un Mac pour écrire des applications destinées aux appareils mobiles Apple. Vous devez également posséder un iPhone, un iPod Touch et/ou un iPad. Ou encore mieux, les trois !

En effet, si l'environnement de développement est en mesure de simuler le fonctionnement de ces trois appareils, le comportement des applications est cependant biaisé car elles ne disposent pas des mêmes ressources (mémoire et processeur) si elles sont exécutées sur un Mac ou sur un device (entendez par là un iPhone, un iPad ou un iPod Touch).

Une bonne nouvelle : les iPod Touch et les iPad sont également disponibles en version reconditionnée ! Vous pourrez faire de substantielles économies en vous rendant sur ces pages. Par cet intermédiaire, je me suis équipé d'un iPad et d'un iPod Touch reconditionnés, et je dois dire que je m'en félicite tous les jours. :-)

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

L’équipement du codeur Une brève histoire d'Apple

Une brève histoire d'Apple

De quel ordinateur s'équiper ? Et la programmation dans tout ça ?

À l'origine d'Apple, deux amis : Steve Wozniak et Steve Jobs. Le premier est un électronicien et un programmeur de génie. Le deuxième est un visionnaire qui saura imposer la marque à la pomme en lui conférant une simplicité d'utilisation et une ligne uniques. Steve Jobs est l'instigateur de cinq évolutions majeures dans le monde de l'informatique personnelle :

C'est courant 1975 que naît l'Apple I dans le garage de Steve Jobs. Rencontrant un succès mitigé mais suffisant, il apporte suffisamment de capitaux pour que Steve Wozniak se consacre à temps plein à son digne successeur, l'Apple II. Cette machine révolutionnaire conquiert un large public grâce à ses innovations majeures, notamment un affichage texte et graphique, un interpréteur BASIC, le tableur VisiCalc et un lecteur de disquettes !

Début 1984, le grand public découvre le premier modèle de Macintosh. C'est encore à Steve Jobs que l'on doit ce beau succès commercial. Son design innovant, sa compacité, son écran graphique de grande qualité, sa simplicité d'utilisation et… sa souris révolutionnent l'utilisation de l'ordinateur. Le succès est immédiat et perdure depuis lors.

Mais l'aventure ne s'arrête pas là : en 2001 naît l'iPod, en 2007 l'iPhone et en 2010 l'iPad. Bien sûr, l'iPod n'est pas le premier baladeur MP3, l'iPhone n'est pas le premier téléphone cellulaire et l'iPad n'est pas la première tablette tactile. Par contre, ces trois périphériques sont vraiment simples à utiliser, et c'est ce qui fera leur succès. Une fois encore, Steve Jobs a su flairer le marché et adapter ce qui a fait le succès d'Apple : la simplicité d'utilisation et la ligne esthétique.

Aujourd'hui, Steve Jobs n'est plus avec nous, mais son empreinte demeure indélébile dans la galaxie Apple !

Les iPhone, iPod Touch et iPad

L'iPhone

Les iPhone (figure suivante) sont en tout point comparables aux iPod Touch, si ce n'est qu'ils permettent de téléphoner. Vous pouvez donc les utiliser pour :

L'iPhone

iPod Touch

Les iPod Touch (figure suivante) sont équipés d'un écran tactile de 3,5 pouces de diagonale. Ils peuvent être utilisés pour :

L'iPod Touch

iPad

Les iPad (figure suivante) sont en gros des iPod Touch un peu plus grands. Ils peuvent donc être utilisés pour :

L'iPad

La grande taille de l'affichage les rend également plus agréables que les iPod Touch ou les iPhone pour surfer sur le Web et lire des e-books et autres fichiers PDF.

Vous avez maintenant une idée des possibilités offertes par les appareils mobiles Apple. Une question cruelle va se poser à vous : de quel(s) appareil(s) devez-vous vous équiper ?

Le mieux serait d'avoir un iPhone, un iPod Touch et un iPad. Vous pourriez ainsi développer pour ces trois périphériques et toucher un vaste public. Notez cependant que les différences entre l'iPod Touch et l'iPhone sont très réduites : grossièrement, le premier est équivalent au second, excepté qu'il ne peut pas être utilisé pour téléphoner.

Un bon choix consiste donc à acheter :

Limitations des appareils mobiles Apple

Les appareils mobiles Apple sont limités par :

La taille de l'affichage est un facteur déterminant. Elle conditionnera la mise en page de vos applications et devra s'adapter aux tailles caractéristiques des différents appareils mobiles.
La quantité de mémoire vive est assez limitée. C'est pour cela qu'il est absolument nécessaire de tester une application sur un périphérique physique avant de la rendre disponible sur l'Apple Store.

Le type et la vitesse du processeur n'influent qu'assez peu sur la vitesse d'exécution des applications. Ils ne seront pris en compte que dans le cas de jeux manipulant un grand nombre d'éléments graphiques.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

De quel ordinateur s'équiper ? Et la programmation dans tout ça ?

Et la programmation dans tout ça ?

Une brève histoire d'Apple Les logiciels nécessaires

Qu'est-ce qu'un programme ?

Les ordinateurs, les téléphones, les tablettes graphiques et, d'une certaine manière, tous les appareils numériques, utilisent des programmes (appelés aussi applications) pour accomplir des tâches bien précises. Ainsi par exemple, lorsque vous démarrez votre traitement de texte, votre navigateur Web ou votre messagerie, vous utilisez un programme. Autour de ces programmes, un « super programme », appelé système d'exploitation, joue le rôle de chef d'orchestre et permet aux applications d'accéder au matériel sur lequel elles s'exécutent. On dit qu'il sert d'interface entre le matériel et les programmes. À titre d'exemple, Microsoft Windows et Mac OS X sont des systèmes d'exploitation.

Selon le matériel et le système d'exploitation utilisés, les applications sont écrites en utilisant un ou plusieurs langages de programmation. Les iPhone, iPod Touch et iPad sont orchestrés par un système d'exploitation identique. Pour écrire des applications destinées à ce système, un seul langage de programmation peut être utilisé : Objective-C.

Connaissances préalables nécessaires pour programmer

Vous êtes en train de lire un Livre du Zéro, et à ce titre, et pour ne pas déroger à la règle, aucune connaissance préalable n'est nécessaire ! Ceci étant dit, si vous avez déjà une première expérience de la programmation orientée objet ou du langage Objective-C, ce sera un vrai plus : vous comprendrez très rapidement bon nombre de notions qui seront évoquées ici et vous serez très vite capables de passer à la pratique. Si vous n'avez jamais programmé, ne vous en faites surtout pas ! Je serai votre guide tout au long de votre apprentissage. Pour peu que vous ayez un peu de temps, d'intérêt, de passion et de persévérance, vous progresserez très vite.

Langages, API et système

Tout au long de ce tutoriel, nous allons souvent parler d'Objective-C, de Cocoa Touch et d'iOS. Il est temps pour moi de vous présenter ces termes.

Vous trouverez à la figure suivante un schéma pour vous aider à visualiser tout ce petit monde.

Nous aurons besoin du langage Objective-C et de Cocoa Touch pour développer nos applications iOS
Nous aurons besoin du langage Objective-C et de Cocoa Touch pour développer nos applications iOS

Combien de temps me faudra-t-il pour écrire ma première application ?

Les réponses à cette question sont multiples.
Si tous les logiciels nécessaires sont installés et si vous voulez juste créer votre première application sans vraiment comprendre ce que vous faites, dix minutes sont suffisantes !

Si rien n'est encore installé (je suppose quand même que vous avez un Mac sous la main), comptez trois à quatre heures pour installer le logiciel et mettre au point une application qui affiche un texte sur votre device.

Je vous conseille cependant de ne pas compter le temps passé : vous vous lancez dans une grande aventure. Il vous faudra du temps (beaucoup de temps même) pour comprendre les mécanismes de la programmation Objective-C, mais cela en vaut la peine ! Une fois les mécanismes de base assimilés, vous pourrez réaliser tout ce qui vous vient en tête…

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Une brève histoire d'Apple Les logiciels nécessaires

Les logiciels nécessaires

Et la programmation dans tout ça ? Un premier développement

Xcode sur votre Mac

Xcode est le programme que vous utiliserez pour développer vos applications. La version utilisée dans ce tutoriel est la 4.2 (sous OS X Lion 10.7.2). Si vous utilisez une autre version, quelques détails différeront, mais la plupart de ce qui sera dit restera valable. Par défaut, Xcode est normalement déjà installé sur votre Mac. Pour vous en assurer, cliquez sur l'icône du Finder, à l'extrême gauche du dock. Cette action ouvre une fenêtre dans laquelle sont affichés vos principaux dossiers, comme le montre la figure suivante.

Affichage des principaux dossiers du Mac

Dans le volet de gauche, sous APPAREILS, cliquez sur Macintosh HD. Dans le volet de droite, double-cliquez sur Developper, sur Applications, puis sur Xcode. Une boîte de dialogue est alors affichée, comme à la figure suivante.

Une boîte de dialogue Xcode s'affiche

La version du logiciel est affichée juste en dessous du titre « Welcome to Xcode ». Ici, il s'agit de la version 3.2.6. Si votre version de Xcode n'est pas au moins égale à la 4.2, je vous conseille vivement de télécharger puis d'installer la toute dernière version disponible. Pour cela, vous devez rejoindre la communauté des développeurs Apple. Rassurez-vous, cette opération est entièrement gratuite. Connectez-vous sur la page d'enregistrement d'Apple, cliquez sur Get Started et suivez la procédure indiquée pour rejoindre la communauté des développeurs.

Une fois enregistrés, connectez-vous sur la page de téléchargement de Xcode, cliquez sur Log in et connectez-vous en utilisant votre identifiant Apple ID.

Et surtout, armez-vous de patience : le fichier à télécharger pèse quelque 4 Go !

Installation de Xcode

Une fois Xcode téléchargé, une icône d'installation est affichée dans le dock, comme à la figure suivante.

L'icône d'installation de Xcode apparaît dans le dock

Cliquez sur l'icône Install Xcode. Cette action ouvre la fenêtre Install Xcode. Cliquez sur Install, sur Agree, entrez votre nom et votre mot de passe puis patientez jusqu'à la complète installation du programme. Une fois l'installation terminée, l'icône Install Xcode du dock se transforme en Xcode. Il suffit de cliquer dessus pour accéder à Xcode.

En résumé

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Et la programmation dans tout ça ? Un premier développement

Un premier développement

Les logiciels nécessaires Création de l'application

Le but de ce premier développement est de vous faire prendre contact avec Xcode et le langage Objective-C. N'essayez pas de comprendre tout ce qui va être dit ici : cela deviendra de plus en plus clair au fur et à mesure de votre apprentissage.

Vous verrez, cette première application sera vraiment très basique. Un clic sur l'écran remplacera un texte par un autre. Ça n'a l'air de rien dit comme ça, mais ce n'est déjà pas si mal.

Création de l'application

Un premier développement Ajout des contrôles sur l’interface

Avant toute chose, il nous faut lancer Xcode, en cliquant par exemple sur l'icône présente dans le dock (figure suivante).

L'icône de Xcode dans le dock

La fenêtre Welcome to Xcode s'affiche alors, comme à la figure suivante.

Fenêtre de lancement de Xcode

Nous allons ensuite créer un nouveau projet. Pour cela, rien de plus simple, il vous suffit de cliquer sur Create a new Xcode project. Une nouvelle boîte de dialogue s'affiche (figure suivante). Dans le volet de gauche, sous iOS, choisissez Application. Dans la partie centrale de la boîte de dialogue, choisissez Single View Application.

Création d'un nouveau projet dans Xcode

Cliquez sur Next, donnez le nom « premier » au projet, tapez « test » dans la zone de texte Company Identifier, sélectionnez iPhone dans la liste Device Family, et cochez la case Include Unit Tests, comme indiqué à la figure suivante.

Les options du nouveau projet

Cliquez sur Next et choisissez le dossier dans lequel le projet sera créé (figure suivante), au besoin en cliquant sur New Folder pour créer un nouveau dossier.

Il faut choisir l'emplacement du projet

Cliquez sur Create. Le projet est alors créé et ouvert dans Xcode, comme à la figure suivante.

Le projet est créé et ouvert

Cette fenêtre va vous permettre de définir l'allure de l'application, de saisir du code Objective-C et de tester l'application. Pour l'instant, nous n'allons pas entrer dans les détails de la fenêtre de Xcode, cela ne ferait que vous embrouiller.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Un premier développement Ajout des contrôles sur l’interface

Ajout des contrôles sur l’interface

Création de l'application Liaison des contrôles au code

La première étape va consister à dessiner ce que l'on souhaite voir s'afficher sur l'écran du device (Je vous rappelle que device désigne le périphérique sur lequel s'exécutera l'application ; il peut tout aussi bien s'agir d'un iPhone, d'un iPod Touch ou d'un iPad. Ici, la cible de l'application étant un iPhone ou iPod Touch, device désigne ces deux périphériques).
L'interface de Xcode est composée de plusieurs modules (éditeur de code, zone de débogage, utilitaires, éditeur d'interface, etc.). Chacun d'entre eux utilise un ou plusieurs volets, accessibles à partir de la zone de navigation ou de la barre d'outils. Dans cette première étape, vous allez utiliser Interface Builder pour construire la partie visuelle de l'application. Pour ce faire, procédez selon les trois étapes suivantes en vous aidant au besoin de la figure suivante.

  1. Dans la zone de navigation, cliquez sur MainStoryboard.storyboard (1) pour accéder à Interface Builder.

  2. Dans la barre d'outils, cliquez sur l'icône Hide or Show the utilites (2), au-dessus du libellé View, pour révéler le volet des utilitaires.

  3. Dans la partie inférieure du volet des utilitaires, cliquez sur l'icône Show the Object library (3) pour afficher la bibliothèque d'objets. Cliquez si nécessaire sur l'icône Icon View (4) pour afficher plus de contrôles dans la bibliothèque d'objets.

Affichage de la bibliothèque d'objets

Glissez-déposez un contrôle Label de la bibliothèque d'objets dans la zone d'édition. Si vous n'êtes pas (encore) familiers avec cette opération, sachez qu'elle consiste à cliquer sur le contrôle Label dans la bibliothèque d'objets, à maintenir le bouton gauche de la souris enfoncé, à déplacer l'élément ainsi sélectionné au-dessus de la zone d'édition puis à relâcher le bouton de la souris, comme le montre la figure suivante.

Glisser-déposer un contrôle Label

Glissez-déposez ensuite un contrôle Round Rect Button (un bouton) de la bibliothèque d'objets dans la zone d'édition, comme indiqué à la figure suivante.

Le contrôle Round Rect Button

Vous allez maintenant modifier le texte affiché par défaut dans le Label. Double-cliquez sur celui-ci dans la zone d'édition, écrivez « Cliquez sur le bouton » puis appuyez sur la touche Entrée de votre clavier.
Faites de même pour afficher un texte sur le bouton : double-cliquez sur le bouton, écrivez « Cliquez ici » et appuyez sur la touche Entrée.
La zone d'édition doit maintenant ressembler à la figure suivante.

La zone d'édition que vous devriez avoir
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Création de l'application Liaison des contrôles au code

Liaison des contrôles au code

Ajout des contrôles sur l’interface Ecriture du code

Cette application doit afficher un texte dans le Label lorsque l'utilisateur clique sur le bouton. Pour que le code Objective-C puisse agir sur les contrôles définis dans l'étape précédente, il faut relier les contrôles au code.

Cliquez sur l'icône Show the Assistant editor, au-dessus du libellé Editor, dans la partie droite de la barre d'outils (figure suivante). Cette action affiche le code du fichier ViewController.h dans un volet vertical.

L'icône Show the Assistant editor

Si votre écran n'est pas assez large pour visualiser la zone d'édition et le code, désactivez la zone d'utilitaires en cliquant sur l'icône Hide or Show the Utilities, dans la partie droite de la barre d'outils, au-dessus du libellé View (figure suivante).

L'icône Hide or Show the Utilities

Le fichier ViewController.h contient les déclarations relatives aux objets manipulés.

Déclarations, objets ? Je n'y comprends rien !

Les applications développées avec Xcode sont composées de nombreux fichiers. Certains ont un nom qui se termine par .h, comme par exemple ViewController.h dans le cas qui nous intéresse. Ces fichiers sont dits fichiers d'en-têtes.
Ils contiennent des instructions Objective-C qui permettent d'identifier les objets (c'est-à-dire les contrôles déposés sur la zone d'édition depuis Interface Builder) utilisés dans l'application. Ces instructions sont appelées déclarations.

Pour ajouter les déclarations nécessaires pour le Label, contrôle-glissez-déposez le contrôle Label du volet d'édition dans le volet de code, juste au-dessus de la dernière ligne (figure suivante). Cette technique deviendra vite habituelle. Elle consiste à :

  1. placer le pointeur de la souris sur le contrôle Label dans le volet d'édition ;

  2. maintenir la touche Ctrl de votre clavier enfoncée ;

  3. maintenir le bouton gauche de la souris enfoncé et déplacer le contrôle Label du volet d'édition dans le volet de code, juste au-dessus de la ligne où apparaît l'instruction @end ;

  4. relâcher le bouton gauche de la souris ainsi que la touche Ctrl.

Un simple contrôle-glisser-déposer permet d'ajouter des déclarations dans le volet d'édition

Au relâchement du bouton gauche de la souris, une boîte de dialogue est affichée. Tapez « message » dans la zone de texte Name, comme à la figure suivante.

Une boîte de dialogue s'affiche au relâchement du bouton de la souris

Cliquez sur Connect. Le code du fichier ViewController.h devrait maintenant ressembler à ceci :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *message;

@end

Passons quelques minutes sur ce code si vous le voulez bien.

La première ligne, sur laquelle figure le mot import, fait référence à tout ce dont vous aurez besoin pour développer une interface utilisateur pour périphérique iOS. En ajoutant cette simple ligne au début de l'application, le code pourra afficher sur l'écran du device et répondre aux gestuelles (appui, déplacement, rotation, etc.) des utilisateurs.

La ligne 3, sur laquelle figure le mot interface, indique que l'application ViewController est de type UIViewController :

@interface ViewController : UIViewController

La ligne 5, qui contient le mot property, indique le comportement de l'objet :

@property (weak, nonatomic) IBOutlet UILabel *message;

Enfin, la ligne 7 matérialise la fin du fichier ViewController.h :

@end

Contrôle-glissez-déposez le bouton de la zone d'édition dans le volet de code, juste au-dessus de la dernière ligne, comme à la figure suivante

Un contrôle-glisser-déposer au-dessus de la dernière ligne de code

Au relâchement du bouton de la souris, une boîte de dialogue est affichée. Ici, nous voulons associer une action au bouton, afin qu'un message soit affiché dans le Label lorsque l'utilisateur appuie sur le bouton. Choisissez Action dans la liste déroulante Connection et tapez « reagir » dans la zone de texte Name. La boîte de dialogue devrait maintenant ressembler à la figure suivante.

La boîte de dialogue permet d'associer une action au bouton

Comme vous pouvez le voir sur cette image, l'action reagir (paramètre Name), exécutée lorsque l'utilisateur appuie sur le bouton (Touch Up Inside, soit « au relâchement du bouton de la souris » dans le paramètre Event), est sur le point d'être définie.

Cliquez sur Connect. Le code est complété avec une nouvelle instruction :

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController

@property (weak, nonatomic) IBOutlet UILabel *message;

- (IBAction)reagir:(id)sender;

@end

Comme vous pouvez le voir, une ligne a été ajoutée dans le code pour déclarer l'action reagir dans le code (ligne 7).

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Ajout des contrôles sur l’interface Ecriture du code

Ecriture du code

Liaison des contrôles au code Construction et exécution

Cliquez sur l'entrée ViewController.m dans le volet de navigation. Un code assez imposant apparaît dans la partie centrale de la fenêtre. Il a (gentiment) été généré par Xcode.

//
//  ViewController.m
//  premier
//
//  Created by Michel Martin on 24/10/11.
//  Copyright (c) 2011 __MyCompanyName__. All rights reserved.
//

#import "ViewController.h"

@implementation ViewController
@synthesize message;

- (void)didReceiveMemoryWarning
{
  [super didReceiveMemoryWarning];
  // Release any cached data, images, etc that aren't in use.
}

#pragma mark - View lifecycle

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

- (void)viewDidUnload
{
  [self setMessage:nil];
  [super viewDidUnload];
  // Release any retained subviews of the main view.
  // e.g. self.myOutlet = nil;
}

- (void)viewWillAppear:(BOOL)animated
{
  [super viewWillAppear:animated];
}

- (void)viewDidAppear:(BOOL)animated
{
  [super viewDidAppear:animated];
}

- (void)viewWillDisappear:(BOOL)animated
{
  [super viewWillDisappear:animated];
}

- (void)viewDidDisappear:(BOOL)animated
{
  [super viewDidDisappear:animated];
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
  // Return YES for supported orientations
  return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
}

- (IBAction)reagir:(id)sender {
}
@end

Jetez un œil aux dernières lignes du code. Est-ce que cela ne vous rappelle rien ?
La ligne 62 est la copie conforme de la déclaration qui a été générée lorsque vous avez contrôle-glissé-déposé le bouton de la zone d'édition dans le fichier ViewController.h. Avez-vous remarqué les accolades, juste après le mot sender ? C'est à cet endroit que vous allez écrire le code qui permettra d'afficher un message dans le Label lorsque l'utilisateur clique sur le bouton. Complétez cette déclaration comme suit :

- (IBAction)reagir:(id)sender {
  NSString *lemessage = [[NSString alloc] initWithFormat:@"Bravo !"];
  message.text = lemessage;
}

Mais qu'est-ce que tout ce charabia ? C'est comme ça que parle mon iPhone ?

Ce n'est pas comme ça que parle votre iPhone, mais plutôt comme ça qu'Objective-C se fait comprendre de votre device. Je sais que la syntaxe de ces instructions a de quoi surprendre. Ne vous en faites pas, et surtout, n'essayez pas de tout comprendre tout de suite. Pour l'instant, contentez-vous de voir le mot « Bravo » sur la deuxième ligne. C'est ce mot qui sera affiché sur l'iPhone lorsque vous cliquerez sur le bouton.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Liaison des contrôles au code Construction et exécution

Construction et exécution

Ecriture du code Le simulateur iOS

Dans la barre d'outils, cliquez sur l'icône Run (figure suivante).

L'icône Run de la barre d'outils

Au bout de quelques instants, une fenêtre complémentaire nommée Simulateur iOS est affichée, et l'application apparaît dans son état initial. Cliquez sur le bouton. Le texte « Bravo ! » remplace le texte « Cliquez sur le bouton », comme à la figure suivante. Je vous félicite ! Vous venez de réaliser votre première application sur iPhone !

Votre première application iPhone !

En résumé

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Ecriture du code Le simulateur iOS

Le simulateur iOS

Construction et exécution Les bases

Le simulateur iOS fait partie intégrante de Xcode. Cette application permet de simuler le fonctionnement d'un iPhone, d'un iPod Touch et d'un iPad. Que vous ayez rejoint la communauté des développeurs Apple ou non, vous utiliserez fréquemment le simulateur pour tester rapidement vos applications. Il est donc important de savoir l'utiliser.

Dans le chapitre précédent, vous avez eu un premier contact avec le simulateur iOS. Dans ce chapitre, vous allez faire plus ample connaissance avec lui. Vous apprendrez entre autres à simuler les gestuelles de l'utilisateur, à installer et désinstaller une application et bien d'autres choses encore.

Les bases

Le simulateur iOS Simuler les gestuelles et les actions de l'utilisateur

Lorsque vous définissez un nouveau projet Xcode, vous devez choisir un type de device : iPhone/iPod Touch ou iPad (figure suivante).

Xcode vous demande de choisir un type de device

Si vous voulez utiliser le simulateur iOS, vous pouvez à tout moment changer de device en utilisant la liste déroulante Scheme, dans la partie supérieure gauche de la fenêtre de Xcode (figure suivante).

Vous pouvez à tout moment changer le device du simulateur à partir de Xcode

Une autre possibilité consiste à utiliser le menu du simulateur. La fenêtre de ce dernier étant en avant-plan, déroulez le menu Matériel, pointez Appareil et choisissez un des devices proposés, comme à la figure suivante.

Le device peut également être choisi directement via le simulateur

Le menu Matériel offre des possibilités complémentaires, puisqu'il est possible de simuler la version du système iOS (on dit aussi firmware) utilisé. Déroulez le menu Matériel, pointez Version et choisissez la version d'iOS à utiliser, comme à la figure suivante.

Il est également possible de choisir la version d'iOS

Une fois le simulateur iOS choisi comme cible de l'application, cliquez sur le bouton Run pour lancer l'application dans le simulateur.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Le simulateur iOS Simuler les gestuelles et les actions de l'utilisateur

Simuler les gestuelles et les actions de l'utilisateur

Les bases Quelques pratiques à connaître

Le simulateur iOS est une application Mac. Il s'exécute dans une fenêtre affichée sur l'écran relié à votre ordinateur. Étant donné que cet écran est une simple dalle réservée à l'affichage, il n'est pas capable de réagir aux gestuelles ni aux actions effectuées sur un iPhone/iPod Touch/iPad. Toutefois les ingénieurs en charge du développement de cette application ont eu la bonne idée de lui associer des raccourcis clavier pour simuler les gestuelles et les actions des utilisateurs.

Simuler les gestuelles de l'utilisateur

Vous vous en doutez, il n'est pas possible de faire tourner votre écran d'ordinateur ou de le secouer pour simuler ces actions dans le simulateur iOS. Par contre, vous pouvez utiliser des commandes dans le menu Matériel du simulateur iOS, ou les raccourcis clavier équivalents.

Action

Commande dans le menu Matériel

Raccourci

Rotation d'un quart de tour à gauche

Rotation à gauche

Commande+Gauche

Rotation d'un quart de tour à droite

Rotation à droite

Commande+Droite

Verrouillage

Verrouiller

Commande+L

Secousse

Secousse

Ctrl+Commande+Z

Ecran d'accueil

Ecran d'accueil

Maj+Commande+H

Simuler les actions de l'utilisateur

Les actions liées au toucher (clic, double-clic, agrandir, etc.) peuvent également être simulées dans le simulateur iOS en utilisant la souris.

Action sur le device

Action dans le simulateur

Toucher

Cliquez

Toucher et maintenir

Maintenez le bouton gauche enfoncé

Feuilleter

Placez le pointeur sur l'objet à déplacer, maintenez le bouton gauche enfoncé, déplacez l'objet puis relâcher le bouton gauche

Glisser-déposer

Placez le pointeur sur l'objet à déplacer, maintenez le bouton gauche enfoncé, déplacez l'objet puis relâchez le bouton gauche

Zoom avant, zoom arrière

Maintenez la touche Option enfoncée. Deux ronds semi-opaques apparaissent sur l'écran. Maintenez le bouton gauche de la souris enfoncé et déplacez la souris dans la direction souhaitée pour obtenir le redimensionnement.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Les bases Quelques pratiques à connaître

Quelques pratiques à connaître

Simuler les gestuelles et les actions de l'utilisateur Les bases de l'Objective-C

Installer/désinstaller une application

Pour installer une application, il suffit de l'exécuter dans le simulateur en cliquant sur le bouton Run de Xcode. Elle est alors disponible sur l'écran des applications (figure suivante), et le restera jusqu'à ce que vous la désinstalliez.

Il est possible d'installer des applications dans le simulateur

Pour désinstaller une application, pointez son icône et maintenez le bouton gauche de la souris enfoncé jusqu'à ce que toutes les icônes se mettent à bouger. Cliquez alors sur la case de fermeture de l'application que vous voulez désinstaller (figure suivante).

La croix permet de désinstaller une application du simulateur

Retourner à la configuration d'usine

Une commande permet de réinitialiser le simulateur iOS pour lui redonner sa configuration d'usine, c'est-à-dire sa configuration juste après l'installation de Xcode. Toutes les applications installées, contenus et réglages sont supprimés et placés dans la corbeille du Mac.
Pour réinitialiser votre simulateur iOS, cliquez sur le menu Simulateur iOS et sélectionnez Réinitialiser le contenu et les réglages. Une boîte de dialogue de confirmation est affichée. Cliquez sur Réinitialiser pour confirmer votre choix.

Déboguer une application lors de son exécution sur le simulateur

L'application Xcode est dotée d'un volet de débogage, aussi appelé « console ». Ce volet permet d'afficher des informations textuelles pendant qu'une application s'exécute, et ce, quelle qu'en soit la cible : le simulateur iOS ou un device réel. Cette section est une première approche du débogage. N'ayant pas encore abordé l'exécution d'une application sur un device, vous allez apprendre à afficher des données dans la console pendant l'exécution sur le simulateur iOS.

Pour afficher le volet de débogage, il suffit de cliquer sur l'icône Hide or show the Debug area, dans la barre d'outils de Xcode (figure suivante).

Le bouton Hide or show the Debug area permet d'afficher le volet de débogage

Vous utiliserez une instruction, NSLog(), pour afficher des informations dans le volet de débogage :

NSLog(@"Le texte à afficher");

Comme vous pouvez le voir sur la figure précédente, l'instruction NSLog() affiche le texte « Bonjour » dans le volet de débogage (à la dernière ligne).

En résumé

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Simuler les gestuelles et les actions de l'utilisateur Les bases de l'Objective-C

Les bases de l'Objective-C

Quelques pratiques à connaître Mise en pratique de ce chapitre

Comme je vous le disais dans la première partie de ce livre, nous allons utiliser le langage Objective-C pour développer nos applications. Et pour bien comprendre comment fonctionne l'Objective-C, vous devez dans un premier temps en acquérir les bases. Tout ce qui sera dit ici vous sera profitable lorsque vous écrirez des applications en Objective-C.

Nous allons y aller en douceur et vous verrez que, progressivement, vous serez capables de réaliser de plus en plus de choses avec ce langage. Alors allons-y !

Mise en pratique de ce chapitre

Les bases de l'Objective-C Instructions

Avant tout chose, je vous rappelle que le langage Objective-C hérite du langage C, c'est-à-dire que leur syntaxe de base est relativement similaire. Si vous connaissez déjà le C, vous pouvez directement vous rendre au chapitre suivant. Si vous voulez en savoir plus sur le langage C, le Site du Zéro propose un tutoriel.

Tout ce qui va être dit dans ce chapitre est relativement théorique. Malheureusement, c'est un passage obligé pour apprendre le langage Objective-C. Cependant, rien ne vous empêche de tester ce que vous apprenez au fur et à mesure.

Pour commencer, définissez un nouveau projet appelé « test » basé sur le modèle Single View Application. Cliquez sur ViewController.m dans le volet de navigation (1) et entrez les instructions à tester dans la méthode viewDidLoad, juste après le message [super viewDidLoad]; (2), comme indiqué à la figure suivante.

Insérez une instruction dans votre code

Pour tester votre code, une des façons les plus simples consiste à afficher des éléments textuels dans le volet de débogage (aussi appelé « console ») avec la fonction NSLog(). À titre d'exemple, tapez cette ligne de code à la suite de [super viewDidLoad] :

NSLog(@"texte à afficher");

Cliquez sur l'icône Run (1) pour exécuter l'application et, si nécessaire, cliquez sur Hide or show the Debug area (2) pour afficher le volet de débogage. Comme vous pouvez le constater à la figure suivante, le texte passé à la fonction NSLog() est affiché dans le volet de débogage.

Le texte est bien affiché

Est-ce que NSLog() peut afficher autre chose que du texte ?

Oui, bien sûr. N'ayez crainte, vous découvrirez cela en temps utile. Passez vite à la suite pour faire connaissance avec vos premières instructions Objective-C.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Les bases de l'Objective-C Instructions

Instructions

Mise en pratique de ce chapitre Variables, constantes et opérateurs

Avant de pouvoir conduire une voiture, vous devez apprendre un certain nombre de règles. Pour cela, vous devez potasser le code de la route. Une fois cette première étape acquise, vous pouvez vous lancer dans la conduite. Là encore, vous devez apprendre plusieurs choses. Certaines ne sont pas essentielles. Par exemple, il n'est pas indispensable de savoir comment fonctionne le moteur de la voiture. D'autres sont par contre vitales : il est impensable de se mettre au volant d'une voiture si on ne sait pas mettre en route le moteur ou passer les vitesses !

Les choses sont assez similaires en programmation. Vous allez devoir apprendre des règles, acquérir des mécanismes et beaucoup pratiquer avant d'arriver à faire ce que vous voulez. Cela vous prendra du temps et de l'énergie, mais imaginez quelle joie vous éprouverez lorsqu'une de vos applications sera téléchargée, utilisée et appréciée par des milliers d'inconnus ! Pour l'instant, nous n'en sommes pas là. Commençons déjà par les bases de la programmation.

Tous les programmes sont constitués d'instructions. Une instruction demande à l'ordinateur d'effectuer quelque chose de précis. Généralement, on écrit une seule instruction par ligne.

Voici une instruction Objective-C plutôt simple :

int leNombreDix = 10;

Et voici une instruction Objective-C un peu plus compliquée :

NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

Je suis sûr que vous trouvez la première plus sympathique que la deuxième. Mais rassurez-vous, ces deux instructions sont très simples à comprendre du moment que l'on connaît le « code de la route » Objective-C.

Pour l'instant, contentez-vous de retenir qu'un programme est constitué d'un ensemble d'instructions. Au fil des chapitres, votre compréhension du langage Objective-C sera de plus en plus claire et vous pourrez commencer à concevoir vos propres applications.

Je vois que toutes les lignes se terminent par un « ; ». Est-ce que ce caractère est obligatoire ?

Eh bien oui, le « ; » est obligatoire. Il indique à l'ordinateur que l'instruction est terminée. Il faudra donc vous y faire : toutes les instructions se terminent par un « ; ».

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Mise en pratique de ce chapitre Variables, constantes et opérateurs

Variables, constantes et opérateurs

Instructions Commentaires

Les variables

Le langage Objective-C n'aurait aucun intérêt s'il n'était pas capable de manipuler des données. Ceci est possible grâce aux variables. En effet, ces dernières permettent de stocker temporairement des informations dans la mémoire de votre device et d'y accéder par la suite. Grâce à elles, vous allez pouvoir stocker l'âge ou la taille du visiteur, mais aussi effectuer des calculs et bien d'autres choses encore.

Pour définir une variable, vous utiliserez la syntaxe suivante :

type nomVariable;

Où :

Par exemple, pour définir une variable nommée « maVariable » dont le type est int, vous utiliserez l'instruction suivante :

int maVariable;

Pas si vite ! Qu'est-ce que veut dire int et pourquoi le deuxième mot est orthographié ainsi : maVariable et pas Ma variable ?

int vient du mot anglais integer (« entier » en français). Il faudra vous y faire : la plupart des langages de programmation sont en anglais. Pour ceux qui auraient des lacunes en maths, un entier est un nombre sans virgule, comme par exemple 12 ou 65241.

Quant à la syntaxe du deuxième mot, elle adopte la convention camelCase, qui consiste à utiliser une première lettre minuscule et une lettre majuscule pour chaque nouveau mot. Cette façon de faire n'est pas obligatoire, c'est juste une convention : vos programmes fonctionneront quand même si vous ne l'utilisez pas.

De plus, l'Objective-C interdit les espaces et les accents dans les noms de variables. Par exemple, maPremiereVariable respecte la convention camelCase et ne contient ni espace ni accent ; le nom est donc correct. A contrario, Ma première variable ne respecte pas la convention camelCase et contient des espaces et un accent ; le nom est donc incorrect.

Si vous le souhaitez, il est possible d'affecter une valeur à une variable pendant sa déclaration. Vous utiliserez alors la syntaxe suivante :

type nomVariable = valeur;

type est le type de la variable, nomVariable est son nom et valeur est la valeur que vous voulez lui affecter. Par exemple :

int maVariable = 10;

Ici, la valeur 10 est affectée à la variable maVariable de type int.

Vous pouvez manipuler ces variables comme bon vous semble. Par exemple :

int resultat, nombre1 = 10, nombre2 = 5;
resultat = nombre1 + nombre2;

Ici la variable resultat vaudra 15 : 10 + 5 = 15. Bon, je vous l'accorde, pour le moment ça ne nous sert pas à grand-chose. Mais croyez-moi, c'est primordial.

Que diriez-vous maintenant d'un peu de pratique ?
Ouvrez votre projet de test, celui défini quelques pages avant.

Comme vous le montre la figure suivante, cliquez sur ViewController.m (1) dans le volet de navigation, repérez la méthode viewDidLoad et ajoutez les deux lignes de code précédentes à la suite de [super viewDidLoad].

Ajoutez un NSLog pour afficher la valeur de la variable resultat dans le volet de débogage :

NSLog (@"Résultat vaut %d",resultat);

Cliquez sur Run (2) pour exécuter l'application. Si le volet de débogage n'est pas affiché, cliquez sur Hide or show the Debug area (3). Au bout de quelques instants, le volet de débogage affiche fièrement le résultat.

Le résultat est affiché dans le volet de débogage

Le langage Objective-C peut utiliser plusieurs autres types de variables. Les plus fréquents ont été rassemblés dans le tableau ci-dessous. Ne vous attardez pas trop sur ce tableau. Vous y reviendrez dans les sections suivantes, lorsque vous testerez des variables d'un de ces types.

Type

Signification

%@

Objet Cocoa. NSString par exemple

%d, %i

Entier signé (c'est-à-dire avec un signe "-" si nécessaire)

%f

Float ou Double

%c

Caractère

Les constantes

Les constantes sont comparables aux variables, à ceci près qu'une fois définies leur valeur ne peut pas changer. Voici la syntaxe à utiliser :

const type nomConstante = valeur;

La syntaxe est identique à celle des variables, à ceci près que l'on ajoute le mot-clé const au début de l'instruction.

Par exemple :

const float pi = 3.1415926536;

En résumé, vous utiliserez des variables pour mémoriser des valeurs qui peuvent changer dans le temps et des constantes pour stocker des valeurs fixes tout au long du programme (une TVA de 19,6 \% par exemple).

Les opérateurs

Comme leur nom le laisse supposer, les opérateurs permettent d'effectuer des opérations. Dans cette section, nous allons nous intéresser aux opérateurs d'affectation et aux opérateurs arithmétiques.

Opérateurs d'affectation

Les opérateurs utilisables en Objective-C sont regroupés dans le tableau qui suit.

Opérateur

Signification

Exemple

=

Affectation

int maVariable = 2;

+=

Ajout de la valeur spécifiée

maVariable += 5; // Ajoute 5 à maVariable

-=

Soustraction de la valeur spécifiée

maVariable -= 5; // Soustrait 5 à maVariable

/=

Divise par la valeur spécifiée

maVariable /= 5; // Divise par 5 maVariable

*=

Multiplie par la valeur spécifiée

maVariable *= 5; // Multiplie par 5 maVariable

%=

Donne le reste de la division entière dont le diviseur est spécifié

maVariable %= 5; // Stocke dans maVariable le reste de la division entière de maVariable par 5

Je ne comprends rien à ce tableau ! Quelques explications seraient les bienvenues.

L'instruction suivante (issue de la deuxième ligne du tableau) vous paraît certainement un peu farfelue, voire même totalement incompréhensible :

maVariable += 5;

Il s'agit d'une facilité, ou plutôt d'un raccourci d'écriture. Cette instruction est équivalente à :

maVariable = maVariable + 5;

Est-ce que c'est plus clair pour vous maintenant ? Ou avez-vous encore un peu de mal à comprendre comment on peut stocker dans maVariable la valeur maVariable + 5 ? Si vous accrochez là-dessus, sachez que le résultat de maVariable + 5 est calculé dans un premier temps, puis ensuite stocké dans maVariable.

Les autres opérateurs d'affectation fonctionnent de même. Ainsi par exemple :

maVariable %= 5;

Est équivalent à :

maVariable = maVariable % 5;

Après l'exécution de cette instruction, maVariable contient le reste de la division entière (%) de maVariable par 5 (maVariable % 5).

C'est quoi exactement ce % dont tu nous parles ?

C'est ce qu'on appelle un modulo. Il permet d'obtenir le reste d'une division. Par exemple, si je divise 5 par 2 ($5 / 2$), il reste 1. Ainsi, $5 % 2 = 1$

Opérateurs arithmétiques

Vous connaissez forcément les quatre opérateurs arithmétiques de base : plus, moins, divisé par et multiplié par. Vous aurez également à faire à quelques autres opérateurs, moins fréquents mais très utiles en programmation. Je les ai regroupés dans le tableau suivant.

Opérateur

Fonction

+

Addition

-

Soustraction ou inversion de signe

++

Ajout de 1

--

Soustraction de 1

*

Multiplication

/

Division

%

Modulo (reste de la division entière)

Ne soyez pas effrayés si c'est la première fois que vous rencontrez certains de ces opérateurs.

Et maintenant, voici quelques exemples d'utilisation :

int var1 = 10;
int var2 = 15;
int result;
result = var1 *  var2;
result++;
result = 15 % 10

Lorsque plusieurs opérateurs apparaissent dans une expression mathématique, il est nécessaire de savoir dans quel ordre ils sont utilisés. Pour les opérateurs +, -, * et /, les règles sont les mêmes que dans l'algèbre traditionnelle. À savoir que * et / sont prioritaires par rapport à + et -. En cas de priorités identiques, les calculs sont effectués de gauche à droite.

D'après vous, quelle est la valeur stockée dans la variable result ?

float result = 10 * 2 + 120 / 2;

Le résultat de cette opération est 80. L'évaluation se fait en calculant $10*2$ puis $120/2$. Ces deux valeurs sont ensuite ajoutées. Ainsi $20 + 60 = 80$.

Si nécessaire, vous pouvez utiliser un ou plusieurs jeux de parenthèses pour modifier l'ordre d'évaluation, et donc le résultat.
D'après vous, quelle est la valeur stockée dans la variable result ?

float result = 10 * (2 + 120) / 2;

Le résultat est 610. L'opération $2 + 120$ étant entourée de parenthèses, elle est prioritaire et donc calculée en premier. Les opérateurs * et / ayant le même niveau de priorité, l'expression est évaluée de la gauche vers la droite. Ainsi, result a pour valeur 10 multiplié par 122 puis divisé par 2, soit 610.

L'opérateur unaire - (en d'autres termes, le « - » qui inverse le signe d'un nombre ou d'une variable) est prioritaire. Il en va de même des opérateurs ++ et -- lorsqu'ils sont utilisés en préfixe (++variable et --variable). Ils sont donc exécutés en premier. Viennent ensuite au même niveau les opérateurs *, / et %, et enfin les opérateurs + et-.

Et maintenant, un peu de pratique !

Dans votre projet de test, cliquez sur ViewController.m dans le volet de navigation, repérez la méthode viewDidLoad et ajoutez les lignes de code précédentes à la suite de [super viewDidLoad]. Invoquez la fonction NSLog() chaque fois que vous voulez tester une variable. Voici à quoi pourrait ressembler la méthode viewDidLoad :

- (void)viewDidLoad
{
  [super viewDidLoad];
  int var1 = 10;
  int var2 = 15;
  int result;

  result = var1 *  var2;
  NSLog(@"var1 * var2 = %d",result);

  result++;
  NSLog(@"Après le ++, result vaut  %d",result);
        
  result = 15 % 10;
  NSLog(@"15 %% 10 vaut  %d",result);
            
  float result1 = 10 * 2 + 120 / 2;
  NSLog(@"10 * 2 + 120 / 2 vaut  %f",result1);
              
  float result2 = 10 * (2 + 120) / 2;
  NSLog(@"10 * (2 + 120) / 2 vaut %f",result2);
}

Cliquez sur Run pour exécuter l'application. Si le volet de débogage n'est pas affiché, cliquez sur Hide or show the Debug area. Au bout de quelques instants, le volet de débogage affiche les divers résultats. Comme vous pouvez le voir à la figure suivante, ils sont conformes aux attentes.

Les résultats sont bien affichés et sont corrects

Avant d'en terminer avec ceci, je voudrais faire une remarque sur une des fonctions NSLog() utilisées dans ce code.

Avez-vous remarqué un détail surprenant dans l'instruction suivante, vers le milieu de la méthode viewDidLoad ?

NSLog(@"15 %% 10 vaut  %d",result);

Le signe « % » a une signification particulière. En effet, associé à une lettre (%d ou %f par exemple), il précise le type d'une variable que l'on désire afficher. Dans cette instruction, on désire afficher le signe « % » dans le volet de débogage. C'est la raison pour laquelle il est doublé.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Instructions Commentaires

Commentaires

Variables, constantes et opérateurs Types de données

Un commentaire est un texte dans un programme, non pris en compte lors de l'exécution de ce dernier. Ils sont très utiles en programmation puisqu'ils vous permettent de vous y retrouver dans votre code. Imaginez que vous créiez une application et que, quelques mois ou même quelques années plus tard, vous décidiez de la mettre à jour. Même si vous êtes l'auteur du code, il vous sera difficile de tout comprendre au premier coup d'œil. C'est pourquoi il est fortement recommandé d'insérer des commentaires qui expliquent de manière claire ce que vous avez fait.

Pour insérer un commentaire qui tient sur une seule ligne, vous le ferez précéder d'un double slash :

int maVariable = 10; // maVariable vaut 10

Si le commentaire s'étale sur plusieurs lignes, vous utiliserez les caractères « /* » pour marquer le début et « */ » pour marquer la fin du commentaire :

/*
Ceci est un commentaire
sur
plusieurs lignes
*/
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Variables, constantes et opérateurs Types de données

Types de données

Commentaires Les pointeurs

Les variables utilisées jusqu'ici étaient de type entier (int) et à virgule (float). Ces deux types ne sont pas les seuls. Vous allez maintenant découvrir les différents types de base utilisables en Objective-C. Vous apprendrez également à effectuer des conversions entre ces différents types de données.

Booléens

Le type BOOL est utilisé lorsque vous devez manipuler des informations de type vrai/faux, oui/non ou 0/1. Ces informations sont dites « booléennes ».

Voici quelques exemples de déclaration :

BOOL booleen1 = 0;
BOOL booleen2 = NO;
BOOL booleen3 = 1;
BOOL booleen4 = YES;

Entiers

Il n'existe pas un mais plusieurs types de variables entières. Vous choisirez un type plutôt qu'un autre en fonction des valeurs maximales que peuvent prendre les variables ou constantes concernées.

Variable

Valeurs possibles

short int

-32768 à 32768

unsigned short int

0 à 65535

unsigned int et unsigned long int

0 à 4294967295

int et long int

-2147483647 à 2147483647

long long int

-9223372036854775807 à 9223372036854775808

unsigned long long int

0 à 18446744073709551615

Par exemple :

int variableEntiere = 123456;
short int entierCourt = -54;

Réels

Les réels, aussi appelés « nombres à virgule flottante », sont des nombres à virgule, comme par exemple 176.45 ou encore -0.561. Selon leur précision (c'est-à-dire selon le nombre de chiffres après la virgule), ils sont mémorisés dans des variables de type float ou double.

Les variables/constantes de type float peuvent être comprises entre $$3.4\times 10^{-38}$$ et $$3.4\times 10^{38}$$. Quant aux variables/constantes de type double, elles peuvent être comprises entre $$1.7\times 10^{-308}$$ et $$1.7\times 10^{308}$$.

Que signifie 3.4*10^-38 ?

Il s'agit d'une convention d'écriture dite « scientifique ». 10^-38 signifie 38 zéros avant la valeur numérique. Et 3.4* signifie que le nombre 3,4 est multiplié par le nombre 10^-38. Si vous avez du mal à visualiser tout ça, la figure suivante devrait vous aider.

$3.4\times 10^{-38}$ est en fait un nombre à virgule avec 38 zéros

Caractères

Le type char permet de manipuler des chaînes composées d'un et d'un seul caractère. Le caractère manipulé doit être délimité par des apostrophes :

char monCaractere = 'a';
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Commentaires Les pointeurs

Les pointeurs

Types de données Conditions, boucles et fonctions

Les pointeurs sont généralement redoutés comme la peste par les programmeurs débutants. Pourtant, ils rendent de grands services et vous devez absolument comprendre leur fonctionnement pour bien programmer en Objective-C. Pour l'instant, retenez leur principal intérêt : ils facilitent la manipulation des objets en Objective-C. Jusqu'ici, tout va bien. Nous allons donc aller un peu plus loin.

Sachez que les pointeurs ne sont pas un type de données. Il est donc impossible d'écrire quelque chose comme ceci :

pointer maVariable;

Contrairement aux types de données, les pointeurs ne sont pas utilisés pour stocker des données, mais des adresses. Par exemple, lorsque vous faites int monEntier = 10; , un espace en mémoire (dont la taille dépend du type de la variable) est réservé pour stocker la valeur 10. Cet espace se trouve à l'adresse &monEntier. Utilisons une instruction NSLog pour afficher la valeur et l'adresse de la variable monEntier :

NSLog(@"monEntier vaut %i et son adresse en mémoire est %p",monEntier, &monEntier);

Voici le résultat affiché dans la console :

2011-07-06 17:29:47.613 test[498:207] monEntier vaut 10 et son adresse en mémoire est 0xbfffd6f4

Ce qui vient d'être dit n'est peut-être pas très clair pour vous. Si tel est le cas, nous allons prendre quelques instants pour approfondir les choses. Sans vouloir jeter un froid, voici une définition sur laquelle vous devriez méditer : « un pointeur est une variable qui contient l'adresse d'une autre variable d'un type donné ».

Examinez la figure suivante.

L'emplacement d'adresse 17 contient un pointeur vers l'emplacement d'adresse 207

Le rectangle horizontal représente une partie de la mémoire de votre ordinateur. Chaque case correspond à un emplacement en mémoire. Pour repérer facilement les différents emplacements, on leur affecte un nombre appelé « adresse ». Dans cette figure, l'emplacement d'adresse 17 contient un pointeur vers l'emplacement d'adresse 207. En utilisant le « pointeur » d'adresse 17, on pourra donc accéder à la donnée stockée à l'adresse 207. En résumé :

Les deux derniers points représentent la différence essentielle entre les pointeurs et les variables. Si vous réfléchissez à cela, vous découvrirez un autre intérêt majeur des pointeurs : ils font référence à des données dont le contenu et la taille peuvent changer.

Voyons comment définir un pointeur en Objective-C :

int *pointeurSurMonEntier;

Supposons que pointeurSurMonEntier représente l'adresse de la variable monEntier. Afin de relier ces deux éléments, nous allons utiliser le signe & :

int monEntier = 10;
int *pointeurSurMonEntier = &monEntier;

Il est possible de modifier la valeur d'une variable en agissant sur son pointeur. Par exemple, pour affecter la valeur 25 à la variable monEntier, on peut utiliser indifféremment les deux instructions suivantes :

monEntier = 25;
*pointeursurMonEntier = 25;

Chaînes de caractères

Les chaînes de caractères sont composées de zéro, un ou plusieurs caractères. Comme il a été vu un peu plus tôt, les variables et constantes de type char ne peuvent mémoriser qu'un et un seul caractère. Pour mémoriser des chaînes, nous utiliserons des pointeurs de char.

Qu'est-ce encore que cela ?

Les pointeurs de char sont des zones mémoire qui mémorisent l'emplacement d'une suite de zéro, un ou plusieurs char. C'est précisément ce que sont les chaînes de caractères. Les pointeurs de char sont donc particulièrement bien adaptés à leur définition.

À titre d'exemple, l'instruction suivante définit la chaîne nom et l'initialise avec une chaîne de caractères :

char *nom = "Mon nom est Bond, James Bond";

Structures

Jusqu'ici, nous avons étudié des types de données « simples » : booléens, entiers, flottants, doubles, caractères et chaînes de caractères. Il est parfois nécessaire de regrouper plusieurs informations disparates dans une seule et même variable. Imaginez par exemple que vous désiriez mémoriser le prénom, le nom et l'âge de plusieurs personnes. Le plus simple consiste à regrouper ces informations dans une structure en utilisant l'instruction struct :

struct unePersonne
{
  char *prenom;
  char *nom;
  int age;
};

Une fois cette structure définie, on peut définir une variable de type unePersonne et accéder à ses différentes composantes en utilisant des instructions « à point ». Par exemple :

struct unePersonne schwarzi;
schwarzi.prenom = "Arnold";
schwarzi.nom = "Schwarzenegger";
schwarzi.age = 64;

Conversions de type

Dans votre vie de programmeur Objective-C, vous serez souvent amenés à convertir une variable d'un certain type en une variable d'un autre type. En effet, les types des variables manipulées doivent être exactement ceux attendus dans le langage, sans quoi une erreur se produira et il sera impossible d'exécuter le programme.

La conversion peut être « implicite » (c'est-à-dire sans nécessiter l'intervention du programmeur) ou « explicite » (c'est-à-dire en utilisant un opérateur de conversion).

Conversion implicite

Examinons les quelques lignes de code suivantes :

int a = 10;
float b = 13.562;
int c = a * b;
float d = a * b;

Le produit de a par b est égal à 135.62. Cette valeur est de type flottant puisqu'elle comporte des décimales.

Quelles valeurs auront les variables c et d selon vous ?

À la ligne 3, lorsque la valeur 135.62 est stockée dans la variable entière c, elle est « tronquée » (c'est-à-dire privée de ses décimales) à 135. L'instruction int c = a * b; a effectué une conversion implicite du type float vers le type int afin que le résultat puisse être mémorisé dans la variable entière c.

Par contre, dans la ligne 4, lorsque la valeur 135.62 est stockée dans la variable flottante d, elle est égale à 135.62.

Conversion explicite

Pour effectuer une conversion explicite (on dit aussi un casting), il suffit de préciser le type visé entre parenthèses avant la valeur à convertir.

int a = 10;
float b = 13.562;
float c = a * (long int)b;
NSLog(@"%f",c);

Est-il possible d'avoir quelques explications sur la ligne 3 ?

La variable b est de type float, puisqu'elle est déclarée comme telle à la ligne 2.
Le casting (long int)b convertit la valeur de la variable b en un long int. Cette valeur est ensuite multipliée par la valeur contenue dans la variable a, de type int. Le résultat est donc de type long int.
Enfin, ce résultat est stocké dans la variable c de type float (float c =). Il est donc converti dans le type float.

Quel résultat sera affiché par l'instruction NSLog selon vous ?
Le casting de b en un long int donne la valeur entière 13. Le résultat de la multiplication est donc 130. Mais étant donné que ce résultat est stocké dans une variable float, NSLog affichera 130.000000.

Pour aller un peu plus loin, nous allons nous intéresser à un autre exemple, basé sur l'utilisation d'un code ASCII.

Code ASCII ? Mais qu'est-ce donc que cela ?

ASCII est l'abréviation de American Standard Code for Information Interchange. Il s'agit d'une norme d'encodage des caractères alphanumériques de l'alphabet latin. Ainsi par exemple, le nombre 64 représente le caractère « @ », le nombre 65 représente le caractère « A », le nombre 66 représente le caractère « B », et ainsi de suite. Pour avoir de plus amples informations sur le codage ASCII, je vous suggère de vous reporter à cette table ASCII.

Voici notre exemple :

int i = 65;
char c = (char)i;
NSLog(@"%c", c);

En lui appliquant un casting de type (char), la variable char c est initialisée avec le caractère A. C'est donc ce qu'affiche l'instruction NSLog. L'entier 65 est donc équivalent au caractère A.

En résumé

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Types de données Conditions, boucles et fonctions

Conditions, boucles et fonctions

Les pointeurs Conditions

Dans ce chapitre, vous allez aller un peu plus loin dans la programmation Objective-C. Au fil des pages, vous apprendrez à :

Ça n'a l'air de rien comme ça, mais à la fin de ce chapitre vous serez capables de créer de petits programmes.

Conditions

Conditions, boucles et fonctions Boucles

En programmation, on utilise des conditions pour tester la valeur des variables. Selon le résultat obtenu, zéro, une ou plusieurs instructions peuvent alors être exécutées.
Avant de nous intéresser aux conditions, nous allons passer un peu de temps avec les opérateurs de comparaison. En effet, ces opérateurs sont très souvent utilisés dans des conditions. Par exemple pour savoir si une variable est supérieure à une autre, ou encore si une variable est égale à zéro.

Opérateurs de comparaison

Les opérateurs de comparaison (dits logiques) sont très importants. Ils permettent de comparer des valeurs entre elles. Par leur intermédiaire, vous pourrez savoir qui de Pierre ou de Jean est le plus grand, ou encore si les prunes sont plus chères au kilo que les bananes. J'ai regroupé tous les opérateurs logiques dans le tableau suivant.

Opérateur

Signification

!

Non

<

Inférieur à

>

Supérieur à

==

Egal à

<=

Inférieur ou égal à

>=

Supérieur ou égal à

!=

Différent de

&&

Et logique (vrai si les deux opérandes ont pour valeur true)

||

Ou logique (vrai si au moins un des deux opérandes a pour valeur true)

^

Ou exclusif (vrai si un seul des deux opérandes a pour valeur true)

Maintenant, nous allons mettre en pratique les opérateurs de comparaison en les utilisant dans des conditions.

if

Pour tester une condition, l'opérateur de base est le if ( « si » en français). Par exemple, imaginez que la variable pointure contienne une pointure de chaussures. Si la pointure est inférieure ou égale à 30, vous voulez afficher un message qui dit « Vous devez vous chausser au rayon enfants ». Vous écrirez quelque chose comme ceci :

if (pointure <= 30)
{
  NSLog(@"Vous devez vous chausser au rayon enfants");
}

Si la condition est vérifiée (si la variable pointure est inférieure ou égale à 30), alors ce qui se trouve entre les accolades sera exécuté. Les plus observateurs d'entre vous auront sans doute remarqué que la condition ainsi que les accolades la délimitant ne se terminent pas par un « ; ». C'est tout à fait normal, ce ne sont pas des instructions.

Bien entendu, il est possible d'exécuter plusieurs instructions :

if (pointure <= 30)
{
    NSLog(@"Vous avez de petits pieds");
    NSLog(@"Vous devez vous chausser au rayon enfants");
    // etc.
}
if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants"); // Ici les accolades sont facultatives

Que diriez-vous d'un peu de pratique ?
Ouvrez le projet de test créé au chapitre précédent. Si vous ne l'avez plus, pas de panique, vous pouvez en créer un nouveau, il fera aussi bien l'affaire.

Cliquez sur ViewController.m dans le volet de navigation et complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int pointure = 29;
    if (pointure <= 30)
    {
        NSLog(@"Vous avez de petits pieds");
        NSLog(@"Vous devez vous chausser au rayon enfants");
    }
}

À la ligne 4, la variable pointure est initialisée à 29. Mais rien ne vous empêche de choisir une autre valeur.

Exécutez l'application en cliquant sur Run. Si nécessaire, affichez le volet de déboguage en cliquant sur Hide or show the Debug area. Voici ce qui devrait s'afficher dans le volet de déboguage :

Attaching to process 877.
2011-11-18 11:35:20.428 test[877:f803] Vous avez de petits pieds
2011-11-18 11:35:20.430 test[877:f803] Vous devez vous chausser au rayon enfants

else

Il arrive parfois que l'on doive exécuter une instruction si une condition est remplie, et une autre instruction dans le cas contraire. Pour cela, on a recours au mot-clé else (c'est-à-dire « sinon » en français) :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else
  NSLog(@"Vous devez vous chausser au rayon adultes");

elseif

Imaginez maintenant que vous vouliez exécuter :

Pour cela, vous utiliserez les mots clés if (si), else if (sinon si) et else (sinon) :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure > 45)
  NSLog(@"Vous devez vous chausser sur mesure");
else
  NSLog(@"Vous devez vous chausser au rayon adultes");

Il est bien évidemment possible d'utiliser plusieurs else if. Vous pourriez très bien écrire quelque chose comme ceci, même si l'intérêt de ce code est limité :

if (pointure <= 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure == 36)
  NSLog(@"Vous chaussez du trente six");
else if (pointure == 37)
  NSLog(@"Vous chaussez du trente sept");
else if (pointure == 38)
  NSLog(@"Vous chaussez du trente huit");

N'hésitez pas à tester ce code (n'oubliez pas de déclarer votre variable pointure) en changeant ses valeurs. C'est comme ça qu'on apprend !

Plusieurs conditions dans un test

Les opérateurs logiques && (et), || (ou) et ! (non) peuvent être utilisés dans une condition. Par exemple, pour tester si la pointure est supérieure à 35 et inférieure à 42, vous écrirez ceci :

if (pointure >35 && pointure <42)

D'après-vous, que devriez-vous écrire pour tester si la pointure est comprise entre 35 et 42, mais différente de 40. Je vous laisse quelques instants…

Voilà la solution :

if (pointure >35 && pointure <42 && pointure != 40)

Facile, non ?

Il est parfois nécessaire d'utiliser des parenthèses dans un test complexe pour modifier l'ordre d'exécution des éléments qui composent le test. Par exemple, les deux tests suivants ne sont pas équivalents :

if ((a+3)/4 < 10)
if (a+3/4 < 10)

Le premier test ajoute 3 à la variable a, divise cette somme par 4 et compare le résultat obtenu à 10. Le deuxième test ajoute 3/4 à la variable a et compare le résultat obtenu à 10.

À titre d'information, voici l'ordre d'exécution des principaux opérateurs, du plus prioritaire vers le moins prioritaire :

Nom

Opérateur

Parenthèses

()

Opérateur de changement de signe

-

Opérateurs ++ et -- utilisés en préfixe

++ et --

Négation

!

Multiplication, division et modulo

*, / et %

Addition et soustraction

+ et -

Inférieur, inférieur ou égal, supérieur, supérieur ou égal

<, <=, >, >=

Egal, différent de

== et !=

Et logique

&&

Ou logique

||

Affectation

=

L'instruction switch

Il existe une variante de l'instruction if… elseif… else… : l'instruction switch. Voici sa syntaxe :

switch (variable)
{
  case valeur1:
    une ou plusieurs instructions;
    break;
  case valeur2:
    une ou plusieurs instructions;
    break;
  case valeur3:
    une ou plusieurs instructions;
    break;
  ...
  default:
    une ou plusieurs instructions;
    break;
}

Où :

L'instruction switch est un peu plus complexe que celles que nous avons vu jusqu'ici. Un exemple va vous aider à en comprendre le fonctionnement.

Considérez le test suivant :

if (pointure == 30)
  NSLog(@"Vous devez vous chausser au rayon enfants");
else if (pointure ==36)
  NSLog(@"Vous chaussez du trente six");
else if (pointure ==37)
  NSLog(@"Vous chaussez du trente sept");
else if (pointure ==38)
  NSLog(@"Vous chaussez du trente huit");
else
  NSLog(@"Vous ne chaussez pas du 30, 36, 37 ou 38");

Vous pourriez tout aussi bien écrire :

switch (pointure)
{
  case 30:
    NSLog(@"Vous devez vous chausser au rayon enfants");
    break;
  case 36:
    NSLog(@"Vous chaussez du trente six");
    break;
  case 37:
    NSLog(@"Vous chaussez du trente sept");
    break;
  case 38:
    NSLog(@"Vous chaussez du trente huit");
    break;
  default:
    NSLog(@"Vous ne chaussez pas du 35, 36, 37 ou 38");
    break;
}

Encore une fois, n'hésitez pas à tester ce code en modifiant ses valeurs.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Conditions, boucles et fonctions Boucles

Boucles

Conditions Fonctions

En programmation, il est souvent nécessaire d'exécuter à plusieurs reprises une instruction ou un groupe d'instructions, par exemple tant qu'une condition n'est pas vérifiée.

Supposons que vous vouliez afficher à dix reprises le mot « Bonjour ». Comment vous y prendriez-vous ? La première idée qui vient à l'esprit consiste à répéter dix fois l'instruction d'affichage NSLog :

NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");
NSLog(@"Bonjour");

Imaginez maintenant que vous vouliez répéter 100 fois l'affichage du mot « Bonjour ». Allez-vous écrire cent fois la même instruction ? Heureusement non ! Il existe plusieurs solutions bien plus élégantes : vous utiliserez pour cela une boucle for, while ou do&nbsp;while.

Dans tous les cas, la procédure est la même. Regardez la figure suivante, elle représente le fonctionnement d'une boucle.

Image utilisateur

Voici ce qui se passe:

Malheureusement il y a un problème : la boucle est infinie! Si on ne l'arrête pas, l'ordinateur va lire les instructions ad vitam æternam. Heureusement, les conditions vont nous aider. Lorsqu'on crée une boucle, on indique une condition pour sortir de la boucle.

La boucle for

La boucle for est là pour vous éviter une luxation du poignet. Voici sa syntaxe :

for (début; fin; incrément)
{
  //Une ou plusieurs instructions
}

Trois paramètres sont passés à l'instruction for :

Tout ceci vous semble peut-être obscur. Rassurez-vous, un petit exemple va vite clarifier les choses. Considérez le code suivant :

int compteur;
for (compteur = 0; compteur < 100; compteur++)
{
  NSLog(@"Bonjour");
}

Lors de la première exécution de la boucle, la variable entière compteur est initialisée à 0. La condition compteur < 100 est alors vérifiée, puisque 0 < 100. L'instruction NSLog est exécutée, l'ordinateur repart au début de la boucle.

Lors de la deuxième exécution de la boucle, le compteur est incrémenté de 1 (compteur++). Il a donc pour valeur 1. La condition étant vérifiée (1 < 100), l'instruction NSLog est de nouveau exécutée.

Ainsi de suite jusqu'à ce que compteur soit égal à 100. Dans ce cas, la boucle for prend fin et le programme continue de s'exécuter. Si vous faites le compte, l'instruction NSLog aura été exécutée … 100 fois, ce qui est exactement l'effet recherché.

Etant donné qu'une seule instruction est exécutée dans la boucle for, les accolades ne sont pas obligatoires. Dans notre exemple, vous auriez donc tout aussi bien pu écrire :

for (compteur = 0; compteur < 100; compteur++)
  NSLog(@"Bonjour");

Que diriez-vous d'un peu de pratique?

Toujours dans votre projet test, cliquez sur ViewController.m dans le volet de navigation. Repérez la méthode viewDidLoad et complétez-la comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int compteur;
    for (compteur = 0; compteur < 100; compteur++)
        NSLog(@"Bonjour");
}

Exécutez l'application en cliquant sur Run. Très rapidement, cent lignes contenant le mot "Bonjour" sont affichées dans le volet de déboguage :

Attaching&nbsp;to&nbsp;process&nbsp;2440.
2011-11-18&nbsp;15:22:32.967&nbsp;test[2440:f803]&nbsp;Bonjour
...
2011-11-18&nbsp;15:22:33.048&nbsp;test[2440:f803]&nbsp;Bonjour

La boucle while

La boucle while est une variante de l'instruction for. Elle exécute une ou plusieurs instructions tant qu'une condition est vérifiée. Voici sa syntaxe :

while(condition)
{
  //Une ou plusieurs instructions
}

Voyons comment résoudre notre problème précédent avec une boucle while.

int compteur = 0;
while (compteur < 100)
{
  NSLog(@"Bonjour");
  compteur++;
}

La première instruction initialise à 0 la variable compteur.

La boucle while se poursuit jusqu'à ce que la variable compteur soit supérieure ou égale à 100 (while (compteur < 100)). Lors de l'entrée dans la boucle, compteur vaut 0.

Les instructions entre les accolades sont donc exécutées: la première affiche le texte « Bonjour », la deuxième incrémente d'un la variable compteur, qui vaut alors 1.

Après l'incrémentation, la condition compteur < 100 est toujours vérifiée, puisque compteur vaut 1. Les instructions à l'intérieur des accolades sont donc exécutées une nouvelle fois.

Ainsi de suite jusqu'à ce que compteur soit égal à 100.

N'hésitez pas à tester le fonctionnement de la boucle while. Dans votre projet test, repérez la méthode viewDidLoad et complétez-la comme suit :

- (void)viewDidLoad
{
    [super viewDidLoad];
    int compteur = 0;
    while (compteur < 100)
    {
        NSLog(@"Bonjour");
        compteur++;
    }
}

Exécutez l'application en cliquant sur Run pour constater que cent lignes contenant le mot "Bonjour" sont affichées dans le volet de débogage.

Vous pouvez vous amuser à modifier la condition initiale du compteur (ligne 4) et la limite supérieure du compteur (ligne 5). Relancez l'application pour voir l'effet résultant.

La boucle do while

L'instruction do while est une variante de l'instruction while. Mais ici, la condition est testée après l'exécution des instructions entre accolades. Dans tous les cas, les instructions entre les accolades seront donc exécutées au moins une fois. Voici la syntaxe de cette instruction :

do
{
  //Une ou plusieurs instructions
} while (condition);

Si on voulait adapter notre exemple précédent, voici comment il faudrait faire avec une boucle do while :

int compteur = 0;
do
{
  NSLog(@"Bonjour");
  compteur++;
} while (compteur < 100);

La première instruction initialise la variable compteur à 0. Les instructions entre les accolades sont alors exécutées une première fois : le mot « Bonjour » est affiché avec la fonction NSLog() et la variable compteur est incrémentée de 1.

La condition à la suite du while est alors examinée. Après la première exécution des instructions entre les accolades, compteur vaut 1. Il est donc bien inférieur à 100 et la boucle se poursuit. Ainsi de suite jusqu'à ce que compteur devienne égal à 100.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Conditions Fonctions

Fonctions

Boucles La programmation orientée objet

Une fonction peut être comparée à une boîte dont l'intérieur ne peut être vu. On lui fournit (éventuellement) une ou plusieurs données, elle effectue un traitement et retourne (éventuellement) une ou plusieurs autres données (figure suivante).

Image utilisateur

Une fonction consiste donc en un ensemble d'instructions qui effectuent un traitement et transforment les données qui lui sont fournies en d'autres données.

Découper le code d'une application en plusieurs fonctions présente plusieurs avantages : chaque fonction étant indépendante du reste du code, il est facile de la tester et de la faire évoluer au grès des différentes versions de l'application.

Pour déclarer une fonction, vous utiliserez la syntaxe suivante :

type nom(paramètres)
{
  //Une ou plusieurs instructions
  return retour;
}

Où :

La fonction nom utilise le ou les paramètres qui lui sont fournis pour effectuer un traitement et retourner la donnée retour.

L'appel d'une fonction n'a rien de bien compliqué : il suffit d'indiquer son nom, éventuellement suivi des paramètres qui doivent lui être passés. Si la fonction renvoie une valeur, vous l'affecterez à une variable du même type que la valeur renvoyée.

À titre d'exemple, la fonction ttc ci-après renvoie le prix TTC correspondant au prix HT qui lui est passé. Le prix HT et le prix TTC sont de type float.

float ttc(float ht)
{
  return ht * 1.196;
}

Ici un paramètre de type float doit être fourni à la fonction (le prix HT) qui renvoie une valeur de type float. L'instruction utilisée sera donc du type suivant (ici, nous calculons la valeur TTC correspondant à un prix HT de 100) :

float lePrixTTC = ttc(100);

Il est possible d'aller plus loin! Supposons que la fonction TTC doive calculer deux types de prix TTC : un avec une TVA de 5,5%, un autre avec une TVA de 19.6%. Comment devriez-vous compléter la fonction ttc précédente ? Je vous laisse réfléchir.

...

Si c'est vraiment trop difficile pour vous, je vais vous mettre sur la voie :

Cette fois-ci, je vous laisse vraiment réfléchir. Vous avez tous les éléments pour écrire cette fonction.

Voici le code que je vous propose :

float ttc(float ht, int tva)
{
  if (tva==1)
    return ht * 1.055;
  else
    return ht * 1.196;
}

La fonction ttc a maintenant deux paramètres : le prix HT et la TVA. Le deuxième paramètre est de type int. S'il est égal à 1, la fonction ttc renverra un prix TTC calculé avec une TVA de 5.5%. Dans tous les autres cas, la fonction ttc renverra un prix TTC calculé avec une TVA de 19.6%.

Et pour appeler la fonction:

float prix1 = ttc (100, 1); // Prix HT de 100 et TVA à 5,5%
float prix2 = ttc (100, 2); // Prix HT de 100 et TVA à 19,6%

Par exemple, une fonction qui affiche le mot « Bonjour » dans le volet de débogage ne demande aucun paramètre et ne retourne aucune valeur. Elle pourrait avoir l'allure suivante :

void bonjour(void)
{
  NSLog(@"Bonjour\n");
}

En résumé

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Boucles La programmation orientée objet

La programmation orientée objet

Fonctions Qu'est-ce que la programmation Orientée Objet ?

Dans ce chapitre, vous allez dans un premier temps découvrir ce qui se cache derrière la programmation orientée objet (POO). Vous verrez ensuite comment mettre en œuvre ce type de programmation en utilisant le langage Objective-C.

La programmation orientée objet est une notion difficile à comprendre, aussi n'hésitez pas à lire ce chapitre plusieurs fois, à tête reposée. Vous verrez, cela devrait finir par rentrer !

Qu'est-ce que la programmation Orientée Objet ?

La programmation orientée objet Définir une classe

Dans la programmation « traditionnelle », les programmes sont constitués d'un ensemble d'instructions qui s'exécutent les unes à la suite des autres (voir figure suivante).

Les instructions s'exécutent les unes à la suite des autres

Dans la plupart des programmes, on définit une boucle qui ne fait rien d'autre qu'attendre l'arrivée d'un événement. Par exemple, la fin d'un calcul, un changement d'heure, un clic souris ou un autre type d'événement quelconque. Si aucun événement ne se produit, la boucle se contente d'attendre, encore et encore. C'est pourquoi on l'appelle souvent « boucle d'attente ». Si un événement survient, il est identifié et traité en conséquence. La figure suivante illustre mes propos.

Dans la plupart des programmes, on attend un événement

Dans la programmation orientée objet, les programmes sont constitués d'un ensemble de blocs de code indépendants appelés objets. Chaque objet contient sa propre boucle d'attente. Lorsqu'un événement concernant un objet particulier survient, c'est à cet objet de traiter l'événement, comme le montre la figure suivante.

Avec la POO, ce sont les objets qui traitent les événements

Les langages orientés objet utilisent plusieurs termes techniques bien particuliers. Pour vous aider à les appréhender, je vais utiliser une analogie en me basant sur des objets courants de la vie de tous les jours : des voitures.

Une voiture est définie par un ensemble de caractéristiques : modèle et couleur entre autres. Elle est fabriquée dans une usine. Lors de la fabrication, une ou plusieurs options sont ajoutées au modèle de base.

Dans un langage orienté objet :

Je vous ai fait un schéma en figure suivante pour vous aider à mieux visualiser tout ça.

Une voiture est un objet

Maintenant que vous avez le vocabulaire nécessaire, nous allons rentrer dans le vif du sujet.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

La programmation orientée objet Définir une classe

Définir une classe

Qu'est-ce que la programmation Orientée Objet ? Définir des méthodes

Revenons au petit monde des devices Apple. Une application iOS est bâtie autour d'une classe qui contient un ensemble d'objets, de propriétés (qui représentent l'état des objets) et de méthodes (qui régissent le fonctionnement des objets) (voir figure suivante) .

Une application iOS est bâtie autour d'une classe qui contient un ensemble d'objets, de propriétés et de méthodes

Supposons que vous vouliez définir la classe maClasse (oui, je sais, c'est très original !).
Vous devrez agir dans deux fichiers distincts : maClasse.h et maClasse.m.

Le fichier .h

Pour interagir avec ses utilisateurs, une application utilise une interface. Dans une application iOS, cette interface peut contenir du texte, des images, des vidéos, des boutons et bien d'autres choses encore. En tant que programmeur, vous devrez utiliser des classes pour définir ces différents éléments. Bien qu'il soit possible de définir à partir de zéro tous ces éléments (forme, ombrage, couleur, comportement sur l'écran etc.), vous préférerez sans aucun doute utiliser des classes toutes faites. Pour faciliter la vie des développeurs, Apple a eu la bonne idée de regrouper ces classes dans une sorte de boîte à outils (on dit aussi framework) appelée UIKit. C'est par son intermédiaire que vous pourrez ajouter du texte, des images, des boutons, des vidéos, etc. à vos applications.

Pour établir le lien entre l'application en cours de développement et le framework UIKit, la première instruction d'un fichier .h doit toujours être la suivante :

#import <UIKit/UIKit.h>

Cette simple instruction donne accès à toutes les classes du framework UIKit.

Les lignes qui suivent l'instruction #import définissent le nom et le type de l'application, ainsi que les variables utilisées dans l'application :

@interface nom : type 
{
  Une ou plusieurs variables
}

nom est le nom de l'application et type définit son type.

Supposons donc que vous définissiez l'application test de type UIViewController. L'instruction @interface aura l'allure suivante :

@interface testViewController : UIViewController
{
  //Une ou plusieurs variables
}

Les variables définies entre les accolades sont appelées variables d'instance.

Qu'est-ce encore que cela ?

Quand vous développez une application iOS, vous définissez une nouvelle classe. Lorsque l'application est lancée, on dit qu'une « instance de la classe » est créée. Cela signifie qu'un objet de cette classe est créé. Les variables d'instance sont propres à cette instance : si vous lancez deux fois l'application, les variables utilisées dans la première instance ne seront pas liées à la seconde, et inversement. Si vous avez du mal à comprendre, la figure suivante devrait vous éclairer.

Chaque instance de classe  a des variables qui lui sont propres

Voici un exemple de fichier d'en-têtes .h :

#import <UIKit/UIKit.h>

@interface Voiture : NSObject {
  NSString* modele;
  NSString* couleur;
}
@end

La classe a pour nom Voiture. Le fichier qui définit l'interface a donc pour nom Voiture.h.

La classe Voiture possède deux variables d'instance NSString : modele et couleur.

Pas si vite ! Qu'est-ce que signifie NSString et pourquoi y a-t-il un astérisque après ce mot ?

NSString représente le type des variables modele et couleur. Il s'agit d'un type permettant de manipuler des chaînes de caractères.
L'astérisque indique que les variables modele et couleur sont des pointeurs de NSString. Elles contiendront donc l'adresse des chaînes et non les chaînes elles-mêmes. Comme vous le verrez tout au long de ce livre, l'utilisation de pointeurs dans Objective-C est monnaie courante.

Définir des variables d'instance, c'est bien, mais pouvoir y accéder, c'est mieux ! En effet, les variables d'instance sont là pour mémoriser des données, et ces données doivent pouvoir être écrites dans les variables d'instance et lues depuis les variables d'instance.

Pour accéder aux variables d'instance, nous allons ajouter des getters (pour connaître la valeur stockée dans les variables) et des setters (pour stocker des valeurs dans les variables et y accéder) :

- (NSString*) modele;
- (NSString*) couleur;
- (void) setModele: (NSString*)input;
- (void) setCouleur: (NSString*)input;

Les deux premières instructions sont des getters. Elles permettent de lire les valeurs stockées dans les variables d'instance modele et couleur ; en d'autres termes, de connaître le modèle et la couleur de la voiture. La valeur renvoyée est de type NSString. Au début de ces deux lignes, le signe - indique qu'il s'agit de méthodes d'instance.

Les deux dernières lignes sont des setters. Elles permettent de stocker des valeurs dans les variables d'instance modele et couleur, c'est-à-dire définir le modèle et la couleur de la voiture. Ici aussi, il s'agit de méthodes d'instance, d'où le signe - au début des instructions. Ces méthodes ne renvoient aucune valeur, ce qui explique le (void) au début des instructions.

Le fichier d'en-têtes est maintenant complet. Voici les instructions qui le composent :

#import <UIKit/UIKit.h>

@interface Voiture : NSObject {
  NSString* modele;
  NSString* couleur;
}
- (NSString*) modele;
- (NSString*) couleur;
- (void) setModele: (NSString*)input;
- (void) setCouleur: (NSString*)input;
@end

Le fichier .m

Nous allons maintenant implémenter (c'est-à-dire écrire le code de) la classe Voiture en définissant ses getters et ses setters dans le fichier Voiture.m. Je vous rappelle que les getters vont permettre de lire le contenu des variables d'instance et que les setters vont permettre de les modifier.

Commençons par les getters. Le but du jeu est d'obtenir la valeur stockée dans les variables d'instance modele et couleur. Une simple instruction return fera donc l'affaire :

#import "Voiture.h"
@implementation Voiture
- (NSString*) modele {
  return modele;
}
- (NSString*) couleur {
  return couleur;
}
@end

Passons maintenant aux setters. Leur but est de modifier les valeurs contenues dans les variables d'instance modele et couleur. Que pensez-vous du code suivant ?

- (void) setModele: (NSString*)nouvModele {
  modele = nouvModele;
}
- (void) setCouleur: (NSString*)nouvCouleur {
  couleur = nouvCouleur;
}

Vous devez encore écrire une méthode pour définir et initialiser les variables d'instance. Cette méthode est le constructeur de la classe. Elle pourrait contenir quelque chose comme ceci :

- (id) init
{
  if ( self = [super init] )
  {
    [self setModele:@"Maserati Spyder"];
    [self setCouleur:@"Rouge"];
  }
    return self;
}

La première ligne identifie le constructeur. Ne cherchez pas à comprendre le pourquoi du comment : c'est la syntaxe à utiliser !

En observant les lignes 5 et 6, vous pouvez déduire que ces deux instructions affectent la valeur « Maserati Spyder » à la variable d'instance modele en utilisant le setter setModele et la valeur « Rouge » à la variable d'instance couleur en utilisant le setter setCouleur. Rien ne vous empêche de choisir d'autres valeurs par défaut, mais j'ai pensé que ce choix n'était pas dépourvu d'intérêt.

La troisième ligne affecte le résultat de [super init] à self.

Mais qu'est-ce que c'est que tout ce charabia ? Des explications s'il vous plaît !

Le mot self identifie l'objet courant. Dans notre cas, une instance de la classe Voiture. Quant au mot super, il identifie la classe « parente », c'est-à-dire la classe à partir de laquelle la classe Voiture a été créée. Un simple coup d'œil au fichier Voiture.h nous montre que la classe parente de Voiture est NSObject :

@interface Voiture : NSObject {
  ...
}

[super init] exécute donc la méthode init de la classe parente. Ici, NSObject. Cette méthode initialise la classe Voiture. La valeur renvoyée est nil si un problème s'est produit pendant l'initialisation. Dans le cas contraire, l'adresse de l'objet Voiture est renvoyée.

L'instruction if teste la valeur stockée dans self, c'est-à-dire la valeur retournée par [self init]. Si la valeur renvoyée est différente de nil, les variables d'instance peuvent être initialisées. Dans le cas contraire, il est inutile de poursuivre l'exécution puisque l'initialisation de la classe a échoué.

J'espère que l'initialisation de la classe n'a maintenant plus aucun secret pour vous. N'hésitez pas à relire plusieurs fois les lignes qui précèdent jusqu'à ce que vous ayez bien compris. Ne vous en faites toutefois pas si vous ne comprenez pas encore parfaitement cette section. Cela viendra avec la pratique et vous n'en êtes encore qu'à vos premiers pas en programmation Objective-C. Et croyez-moi, c'est assurément la partie la plus difficile de votre apprentissage !

Allez, pour vous encourager, voici le code complet du fichier Voiture.m :

#import "Voiture.h"
@implementation Voiture
- (NSString*) modele {
  return modele;
}
- (NSString*) couleur {
  return couleur;
}
- (void) setModele: (NSString*)nouvModele
{
  modele = nouvModele;
}
- (void) setCouleur: (NSString*)nouvCouleur
{
  couleur = nouvCouleur;
}
- (id) init
{
  if ( self = [super init] )
  {
    [self setModele:@"Ferrari 360"];
    [self setCouleur:@"Rouge"];
  }
  return self;
}

@end
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Qu'est-ce que la programmation Orientée Objet ? Définir des méthodes

Définir des méthodes

Définir une classe Appeler des méthodes

Les méthodes Objective-C peuvent être attachées à une classe (méthode de classe) ou à une instance (méthode d'instance). Par exemple, stringWithFormat est une méthode de classe, rattachée à la classe NSString ; ou encore arrayWithArray est une méthode de classe, rattachée à la classe NSArray.

Dans une de vos applications, vous pourriez être amenés à définir une méthode d'instance nombreElementsTableau qui renverrait le nombre d'éléments du tableau qui lui est communiqué en paramètre.
Voici la syntaxe générale permettant de déclarer une méthode :

typeMethode (typeRetour) nomMethode : paramètres
{
  //Une ou plusieurs instructions
};

Où :

Quelques exemples vont vous aider à y voir plus clair.
L'instruction suivante déclare la méthode d'instance premierJour, qui renvoie le nom du premier jour de la semaine lorsqu'on lui transmet une année (an) et un numéro de semaine (numSem) :

- (NSString *) premierJour : (int) an: (int) numSem;

Cette autre instruction déclare la méthode de classe maMethode, qui ne renvoie rien (void) et qui ne demande aucun paramètre :

+ (void) maMethode ;

Enfin, cette dernière instruction déclare la méthode d'instance changePropriete, qui renvoie un booléen et qui admet deux paramètres : le nom de la propriété à modifier (prop) et la valeur à lui affecter (valeur) :

- (BOOL) changePropriete: (NSString *)prop: (NSString *)valeur;
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Définir une classe Appeler des méthodes

Appeler des méthodes

Définir des méthodes Les principaux objets utilisés en Objective-C

Avant la pratique, un peu de théorie

En Objective-C, appeler une méthode de classe revient à envoyer un message. Pour cela, on utilise une syntaxe un peu particulière : le nom de l'objet est placé entre crochets et on le fait suivre du nom de la méthode :

[objet methode];

Si la méthode demande une valeur en entrée, faites suivre le nom de la méthode par le caractère « : » et entrez la valeur après ce caractère :

[objet methode:entree];

Si une méthode demande plusieurs paramètres, séparez-les par un espace et indiquez la valeur de ces paramètres après le caractère « : ». Ici par exemple, trois paramètres sont transmis à la méthode. Le premier suit le nom de la méthode (methode:valeur1) et les deux autres sont précédés du nom du paramètre correspondant (param2:valeur2 et param3:valeur3) :

[objet methode:valeur1 param2:valeur2 param3:valeur3];

Une méthode peut retourner un objet. Dans ce cas, vous pouvez le stocker dans une variable :

variable = [objet methode];

Ou encore :

variable = [objet methode:entree];

Si la méthode retourne un objet, vous pouvez enchaîner plusieurs appels de méthodes (c'est d'ailleurs ce qu'on appelle un chaînage). Dans l'exemple suivant, le paramètre param1 est envoyé à la méthode methode1, et cette dernière est appliquée à l'objet objet1. Le résultat de la méthode est un objet auquel on applique la méthode methode2 avec le paramètre param2 :

[[objet1 methode1:param1] methode2:param2];

Si les choses ne sont pas très claires, examinez la figure suivante.

Le paramètre param1 est envoyé à la méthode methode1, et cette dernière est appliquée à l'objet objet1

Je ne comprends rien à ce schéma ! Pourrais-je avoir quelques explications ?

Pour comprendre ce schéma, il suffit de suivre les flèches, de la gauche vers la droite.

parametre 1 est passé à la methode 1 de l'objet 1. Cette méthode fait un traitement et retourne un résultat sous la forme d'un objet (la deuxième flèche rouge). La methode 2 de cet objet est exécutée, en lui passant le parametre 2 en entrée (la troisième flèche rouge). Le résultat final est représenté par la quatrième flèche rouge.
J'espère que c'est plus clair cette fois-ci. Dans le cas contraire, relisez ce qui vient d'être dit. Il n'y a rien de vraiment sorcier là-dedans… ;-)

Les méthodes ne sont pas l'apanage des objets : elles peuvent également être appliquées à des classes. Par exemple, pour créer une variable de type NSString, vous appliquerez la méthode string de la classe NSString :

NSString* uneChaine [NSString string];

Cette instruction peut être simplifiée comme suit :

NSString* uneChaine;

Je suis sûr que vous préférez la deuxième syntaxe à la première. Je dois bien avouer que moi aussi !

Appel d'une méthode existante

Et maintenant, un peu de pratique. Vous allez utiliser un peu de code Objective-C pour concaténer (coller si vous préférez) deux chaînes NSString et afficher le résultat dans la console du Simulateur iOS.

Définissez un nouveau projet basé sur le modèle Single View Application et donnez-lui le nom « test ».
Cliquez sur ViewController.m dans le volet de navigation et repérez la méthode viewDidLoad. Cette méthode est exécutée dès le démarrage de l'application. Vous allez y ajouter quelques instructions pour tester l'exécution de méthodes.
La méthode viewDidLoad (ainsi que de nombreuses autres méthodes) a été générée par Xcode. Voici à quoi elle doit ressembler :

- (void)viewDidLoad
{
  [super viewDidLoad];
  // Do any additional setup after loading the view, typically from a nib.
}

Le message [super viewDidLoad] exécute la méthode viewDidLoad de la classe parente (super) de la classe en cours d'exécution. Étant donné que notre classe test hérite de la classe UIView, cette instruction va exécuter la méthode viewDidLoad de la classe UIView.

La ligne de commentaire n'a aucune utilité. Vous pouvez la supprimer.
Pour concaténer deux chaînes, vous utiliserez la méthode stringByAppendingString en envoyant un message du type suivant :
[chaine1 stringByAppendingString: chaine2];
chaine1 et chaine2 sont les deux chaînes à concaténer.

Complétez la méthode viewDidLoad comme suit :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSString* chaine = @"un ";
  chaine = [chaine stringByAppendingString:@"texte"];
  NSLog(@"%@",chaine);
}

Exécutez l'application en cliquant sur l'icône Run. La figure suivante représente ce que vous devriez obtenir dans la console.

Nos deux chaînes ont bien été concaténées

Examinons les instructions utilisées dans la méthode viewDidLoad.

La ligne 4 définit l'objet NSStringchaine et lui affecte la valeur « un » :

NSString* chaine = @"un ";

La ligne 5 applique la méthode stringByAppendingString à l'objet NSStringchaine en lui passant le paramètre « texte ». Le résultat est stocké dans l'objet chaine (chaine =) :

chaine = [chaine stringByAppendingString:@"texte"];

Enfin, la ligne 6 affiche le contenu de l'objet chaine (c'est-à-dire « un texte ») :

NSLog(@"%@",chaine);

Création et appel d'une méthode

Vous venez d'apprendre à appeler la méthode stringByAppendingString. Cette méthode fait partie des méthodes standards de la classe NSString.
Vous allez maintenant aller un peu plus loin en créant une méthode et en l'appelant. Cette méthode :

  1. aura pour nom « concat » ;

  2. recevra deux paramètres NSString ;

  3. renverra leur concaténation dans un objet NSString.

Munis de toutes ces informations, vous devriez pouvoir définir le gabarit (c'est-à-dire l'allure) de la méthode :

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2;

Cliquez sur ViewController.h dans le volet de navigation et ajoutez ce gabarit dans le fichier d'en-têtes, après l'instruction @interface.

Il n'y a rien de bien compliqué dans ce gabarit. Si vous ne comprenez pas comment il est construit, relisez la section « Définir des méthodes ».
Le fichier d'en-têtes doit maintenant ressembler à ceci :

#import <UIKit/UIKit.h>
@interface ViewController : UIViewController

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2;

@end

Maintenant, vous allez écrire quelques lignes de code dans le fichier ViewController.m. Cliquez sur ce fichier dans le volet de navigation et définissez la méthode concat, juste au-dessous de l'instruction @implementation :

-(NSString*) concat:(NSString*)ch1: (NSString*)ch2
{
  return [ch1 stringByAppendingString:ch2];
}

La première ligne reprend le gabarit de la fonction.

La troisième ligne définit l'objet retourné par la méthode (viareturn). Cet objet est le résultat de la concaténation de ch1 et ch2, passés en arguments.

Et maintenant, modifiez la méthode viewDidLoad comme suit pour appeler la méthode concat et afficher le résultat retourné dans la console :

- (void)viewDidLoad
{
  [super viewDidLoad];
  NSString* chaine = [self concat: @"premier ":@"deuxième"];
  NSLog(@"%@",chaine);
}

La ligne 4 définit le NSString chaine (NSString* chaine) et lui affecte la valeur retournée par la méthode concat, en lui passant les NSString « premier » et « deuxième ».

Que signifie le mot self dans ce code ?

Il signifie que la méthode concat a été définie dans la classe courante, tout simplement.

Enfin, la ligne 5 affiche le résultat retourné par concat dans la console. Exécutez l'application. La figure suivante représente ce que vous devriez obtenir dans la console.

Les deux chaînes ont bien été concaténées

Crochet ou point ?

Deux styles d'écriture peuvent être utilisés pour appeler une méthode : les crochets ou les points. À titre d'exemple, les deux instructions suivantes sont équivalentes :

[voiture setCouleur:@"rouge"];
voiture.couleur = @"rouge";

Ces deux écritures font une seule et même action : elles appliquent la méthode couleur à l'objet voiture en lui passant l'entrée rouge.

Les deux lignes suivantes sont elles aussi équivalentes :

laCouleur = [voiture couleur];
laCouleur = voiture.couleur;

Vous l'aurez compris, elles lisent la couleur de l'objet voiture et la stockent dans la variable laCouleur.

Créer un objet

La gestion mémoire d'un objet peut être automatique ou manuelle. Dans le premier cas, lorsque l'objet n'est plus utilisé, il est automatiquement retiré de la mémoire. Dans le deuxième cas, c'est à vous de le retirer de la mémoire pour éviter qu'elle ne se sature.
À titre d'exemple, pour créer l'objet NSString maChaine avec une gestion automatique de la mémoire, vous utiliserez l'instruction suivante :

NSString* maChaine = [NSString string];

Ou plus simplement :

NSString* maChaine;

Si vous préférez gérer manuellement l'objet NSString maChaine en mémoire, vous utiliserez l'instruction suivante :

NSString* maChaine = [[NSString alloc] init];

Examinons cette deuxième écriture. Dans un premier temps, la méthode alloc est appliquée à la classe NSString. Cette opération réserve un espace mémoire et instancie un objet NSString. Dans un deuxième temps, la méthode init est appliquée à cet objet pour l'initialiser et le rendre utilisable (ce n'est qu'après l'initialisation de l'objet que l'on peut lui appliquer des méthodes).

Si nécessaire, il est possible d'affecter une valeur à un objet NSString.

Voici l'instruction à utiliser si vous optez pour une gestion automatique de la mémoire :

NSString* maChaine = [NSString stringWithString:@"Une chaîne quelconque"];

Ou plus simplement :

NSString* maChaine = @"Une chaîne quelconque";

Et voici les instructions à utiliser si vous optez pour une gestion manuelle de la mémoire :

NSString* maChaine2 = [[NSString alloc] init];
maChaine2 = @"Une chaîne quelconque";

Cycle de vie des objets

Tout comme les êtres vivants, les objets utilisés dans une application iOS ont un cycle de vie.

  1. Création.

  2. Utilisation.

  3. Destruction.

Une très bonne nouvelle : iOS 5 introduit un système nommé ARC (Automatic Reference Counting) qui automatise le cycle de vie des objets. Désormais, c'est le compilateur qui se charge de cette tâche ingrate qui consiste à détruire les objets une fois qu'ils ne sont plus utilisés.

Je ne m'étendrai pas plus sur le sujet, mais sachez que vous échappez à des complications aussi inutiles que dangereuses.

En résumé

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Définir des méthodes Les principaux objets utilisés en Objective-C

Les principaux objets utilisés en Objective-C

Appeler des méthodes Chaînes de caractères

En tant que programmeurs Objective-C, vous allez être amenés à dialoguer avec des méthodes de classes en leur envoyant des messages. Ce chapitre s'intéresse aux classes incontournables et aux méthodes qui vous seront les plus utiles.

Chaînes de caractères

Les principaux objets utilisés en Objective-C Nombres

Une chaîne de caractères est une suite de zéro, un ou plusieurs caractères. Voici quelques exemples de chaînes de caractères :

Ceci est une chaîne de caractères
123 est plus petit que 456
@ç/w&!

Dans une application destinée aux iPhone, iPod Touch ou iPad, les chaînes de caractères sont manipulées à travers la classe Cocoa Touch NSString :

NSString *maChaine;

Il se peut qu'un jour vous tombiez sur une variante de cette déclaration :

NSString * maChaine; 
(NSString*) maChaine; 
NSString* maChaine;

Ces trois déclarations sont strictement équivalentes à celle que je viens de vous présenter.

Si nécessaire, il est possible d'affecter une valeur à une chaîne lors de sa définition :

NSString *maChaine = @"Ceci est une chaîne de caractères";

Avez-vous remarqué le signe @ avant le début de la chaîne ? Il est là pour indiquer à Xcode que les caractères suivants sont une chaîne de caractères.

Et maintenant, nous allons voir comment manipuler les chaînes de caractères en étudiant quelques méthodes de la classe NSString.

Tester l'égalité de deux NSString

Il est souvent utile de comparer deux chaînes entre elles. Vous pensez peut-être qu'il suffit d'utiliser une instruction du type suivant :

if (chaine1 == chaine2)
{
  // Traitement
}

Eh bien, ce serait trop simple ! En fait, cette instruction compare non pas le contenu mais l'adresse des deux chaînes. Rappelez-vous, lorsque vous définissez une nouvelle chaîne, vous le faites en créant un pointeur :

NSString *chaine1;

Heureusement, il existe une solution pour comparer simplement deux chaînes. Vous utiliserez pour cela la méthode isEqualToString de la classe NSString :

if ([chaine1 isEqualToString:chaine2])
{
  // Traitement
}

Si cette syntaxe vous laisse perplexes, jetez un œil à la section « Appeler des méthodes » du chapitre précédent et tout deviendra plus clair. Pour ceux qui auraient la mémoire courte, les méthodes de classe sont appelées en utilisant la syntaxe suivante :

[objet methode:entrée];

Dans le cas qui nous occupe, la méthode isEqualToString est appliquée à l'objet chaine1 en lui transmettant l'objet chaine2 en entrée. Cette méthode retourne la valeur TRUE si les deux chaînes sont égales, FALSE dans le cas contraire.

Longueur d'un NSString

La longueur d'une chaîne est obtenue avec la méthode length de la classe NSString. Voici un exemple d'utilisation de cette méthode :

NSString *a = @"ceci est une chaîne";
NSLog(@"Longueur de la chaine : %i", [a length]);

L'instruction NSLog affiche le texte suivant dans le volet de débogage :

Longueur de la chaîne : 19

Concaténer deux NSString

Pour concaténer deux chaînes, c'est-à-dire pour les mettre bout à bout, vous utiliserez la méthode stringWithFormat :

NSString *chaine1=@"première partie";
NSString *chaine2= @" deuxième partie";
NSString *chaine3;
chaine3 = [NSString stringWithFormat:@"%@%@",chaine1,chaine2];
NSLog(@"%@",chaine3);

Les trois premières instructions ne devraient pas vous poser de problème. Pour tous ceux qui pensent que la quatrième ligne est incompréhensible, faisons quelques étapes intermédiaires.
L'objet NSString chaine3 a été défini à la ligne précédente. Pour lui affecter une valeur, il suffit de faire suivre son nom du signe = et de la valeur souhaitée : chaine3 = valeur;.

La valeur est obtenue en utilisant la méthode stringWithFormat de la classe NSString. Le début de l'expression est donc tout à fait clair : [NSString stringWithFormat ...].

La méthode stringWithFormat admet un paramètre de type NSString. Dans cet exemple, ce paramètre a pour valeur @"%@%@",chaine1,chaine2. Le signe @ devant le premier guillemet indique que la suite est une chaîne de caractères. Quant aux %@, ils se réfèrent aux éléments spécifiés juste après le deuxième guillemet. Ainsi, le premier %@ est remplacé par chaine1 et le deuxième par chaine2. Le résultat renvoyé est la concaténation des deux chaînes. L'instruction NSLog affiche donc le texte suivant dans le volet de débogage :

première partie deuxième partie

Définir une chaîne pendant l'exécution d'une l'application

Supposons que l'objet NSString maChaine soit défini et initialisé avec l'instruction suivante :

NSString *maChaine = @"Bonjour";

Pour initialiser un objet NSString à partir d'une chaîne de type char, vous utiliserez les instructions suivantes :

char *chaineC;
NSString *chaineObjC;
...
// Instructions qui initialisent la variable char chaineC
...
chaineObjC = [NSString stringWithString: chaineC];

Inversement, pour initialiser une chaîne de type char à partir d'un objet NSString, vous utiliserez les instructions suivantes :

const char *chaineC;
NSString *chaineObjC = @"Bonjour";
chaineC = [chaineObjC String];

Parcourir un NSString, caractère par caractère

Un jour ou l'autre, vous serez certainement confrontés à ce problème : comment isoler chacun des caractères contenus dans un objet NSString afin d'effectuer des comparaisons ou de leur appliquer un traitement individuel ?
La solution est des plus simples : il suffit d'appliquer de manière répétitive la méthode characterAtIndex à la chaîne.

NSString *chaine;
chaine = @"helloworld";
int i = chaine.length; // La variable i contient le nombre de caractères de la chaîne
int j;
char uneLettre;
for(j=0; j<i; j++)  // Boucle de 0 à i en incrémentant j
{
  uneLettre = [chaine characterAtIndex:j];  // Extraction d'un caractère de la chaîne
  NSLog(@"La lettre en position %i est %c ", j, uneLettre);
}

La figure suivante représente le résultat dans la fenêter de débogage.

Le résultat s'affiche dans la fenêtre de débogage
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Les principaux objets utilisés en Objective-C Nombres

Nombres

Chaînes de caractères Dates et heures

Nous allons ici parler des objets de classe NSNumber, qui peuvent laisser perplexe. En effet, pourquoi utiliser une classe dédiée à la manipulation des nombres alors que les types int, float, double, etc. sont déjà disponibles ?

Et pourtant, vous aurez besoin de la classe NSNumber dans plusieurs cas bien précis. Par exemple, pour convertir des types de données. Le type d'un objet NSNumber peut être facilement modifié en utilisant les méthodes floatValue, doubleValue, intValue, longValue, etc. Ici par exemple, un nombre entier est converti en un nombre double avec la méthode doubleValue :

NSNumber *unEntier = [NSNumber numberWithInteger:23];
float unDouble = [unEntier doubleValue];

La première instruction définit l'objet unEntier de type NSNumber et l'initialise avec la valeur entière 23. La deuxième instruction définit la variable unDouble de type float et lui affecte la conversion en un double de l'objet unEntier.

À la vue de ce code, vous vous sentez certainement désorientés. Ne vous en faites pas, tout deviendra plus clair au fur et à mesure de votre apprentissage. Pour l'instant, il vous suffit de savoir que les types numériques cohabitent avec la classe NSNumber, et que cette dernière est utile dans certains cas bien précis.

Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Chaînes de caractères Dates et heures

Dates et heures

Nombres Tableaux

Plusieurs classes sont associées à la manipulation des objets date et heure dans Objective-C : NSDate, NSCalendar, NSTimeZone, NSDateComponents, NSDateFormatter. Pour mieux appréhender ces différentes classes, rien de tel qu'un peu de code.

Affichage de la date courante

Ces quelques lignes de code affichent la date courante au format américain (en_US) et français (fr_FR) :

/* ---Définition de l'objet date et de sa mise en forme--- */

// Aujourd'hui
NSDate *date = [NSDate date];
NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

// Aucun affichage de l'heure
[miseEnForme setTimeStyle:NSDateFormatterNoStyle];

// Affichage de la date au format semi-abrégé
[miseEnForme setDateStyle:NSDateFormatterMediumStyle]; 

/* ---Affichage de la date au format US--- */
NSLocale *usLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];
[miseEnForme setLocale:usLocale];
NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

/* ---Affichage de la date au format FR--- */
NSLocale *frLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"fr_FR"];
[miseEnForme setLocale:frLocale];
NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

Et voici ce que ça donne dans la console :

[...] test[1527:207] Date au format en_US: Jun 7, 2011
[...] test[1527:207] Date for locale fr_FR: 7 juin 2011

Cette syntaxe est vraiment incroyable et j'ai peur d'être dépassé ! Est-ce que j'aurais raté un chapitre ?

Examinons le premier bloc d'instructions. La ligne 4 définit l'objet NSDate date (NSDate *date) et lui affecte la date courante ([NSDate date]).

NSDate *date = [NSDate date];

La ligne 5 définit l'objet miseEnForme de type NSDateFormatter. C'est par l'intermédiaire de cet objet que l'on définira un format d'affichage pour la date.

NSDateFormatter *miseEnForme = [[NSDateFormatter alloc] init];

La ligne 8 indique que l'heure ne doit pas être affichée. La méthode setTimeStyle est donc appliquée à l'objet miseEnForme en lui transmettant un paramètre :

[miseEnForme setTimeStyle:NSDateFormatterNoStyle];

Enfin, la quatrième instruction donne le format d'affichage de la date. Les messages autorisés pour la méthode setDateStyle sont :

Je vous invite à modifier l'instruction en question afin d'observer les différents comportements de ces méthodes.

[miseEnForme setDateStyle:NSDateFormatterMediumStyle];

Examinons maintenant le deuxième bloc d'instructions.
La ligne 14 définit l'objet NSLocale usLocale et l'initialise au format en_US, c'est-à-dire anglais américain :

NSLocale *usLocale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US"];

La ligne suivante utilise la classe setLocale pour indiquer à l'objet NSDateFormatter miseEnForme que l'affichage devra se faire au format anglais américain :

[miseEnForme setLocale:usLocale];

Enfin, la ligne 16 affiche la date courante dans ce format. Le premier message entre crochets récupère l'identificateur de langue (en_US) et le deuxième la date au format miseEnForme :

NSLog(@"Date au format %@: %@", [[miseEnForme locale] localeIdentifier], [miseEnForme stringFromDate:date]);

Le troisième bloc d'instructions est très proche du deuxième, à ceci près qu'il demande l'affichage de la date au format français.

Création d'une date relative à la date système

La méthode initWithTimeIntervalSinceNow permet de créer un objet NSDate en lui appliquant un décalage par rapport à la date système. Le décalage peut être positif (pour définir une date postérieure à la date système) ou négatif (pour définir une date antérieure à la date système).
Examinez le code suivant :

NSDate *dateCourante = [NSDate date]; //Aujourd'hui
NSTimeInterval secondesParJour = 24 * 60 * 60;
NSDate *demain = [[NSDate alloc] initWithTimeIntervalSinceNow:secondesParJour];
NSDate *hier = [[NSDate alloc] initWithTimeIntervalSinceNow:-secondesParJour];

La première ligne définit l'objet NSDate dateCourante et y mémorise la date système.
La deuxième ligne définit l'objet NSTimeInterval secondesParJour et y mémorise le nombre de secondes contenues dans une journée.
La troisième ligne définit l'objet NSDate demain et y stocke la date système plus un jour. Pour cela, la méthode initWithTimeIntervalSinceNow lui est appliquée en lui transmettant la valeur secondesParJour. L'objet demain est donc initialisé avec la date qui suit le jour courant.
La quatrième ligne est très proche de la troisième, mais ici, le paramètre passé à la méthode initWithTimeIntervalSinceNow est égal à -secondesParJour. L'objet hier est donc initialisé avec la date qui précède le jour courant.

Définition d'une date autre que la date système

Pour définir une date différente de la date système, vous devez :

  1. définir et initialiser un objet NSDateComponents ;

  2. l'affecter à un objet NSDatevia un objet NSCalendar.

Tout ceci a l'air bien compliqué, mais vous allez voir qu'il n'en est rien en examinant le code suivant :

// Définition d'un objet NSDateComponents
NSDateComponents *nsDatePerso = [[NSDateComponents alloc] init];
[nsDatePerso setYear:2065];
[nsDatePerso setMonth:8];
[nsDatePerso setDay:12];

// Création d'un objet NSDate et affectation de l'objet nsDatePerso défini précédemment
NSDate *datePerso = [[NSCalendar currentCalendar] dateFromComponents:nsDatePerso];
NSLog(@"Date utilisateur : %@", datePerso);

Voici le résultat affiché dans la console :

[...] test[1680:207] Date utilisateur : 2065-08-11 22:00:00 +0000

Comme vous le voyez, aucune mise en forme NSFormatter n'a été appliquée à l'objet datePerso.

Examinons les instructions qui composent ce code.
La première instruction définit l'objet NSDateComponents nsDatePerso et réserve son emplacement en mémoire :

NSDateComponents *nsDatePerso = [[NSDateComponents alloc] init];

Les trois instructions suivantes initialisent les composants année, mois et jour de cet objet.

[nsDatePerso setYear:2065];
[nsDatePerso setMonth:8];
[nsDatePerso setDay:12];

Le deuxième bloc d'instructions définit un objet NSDate de nom datePerso (NSDate *datePerso). Cet objet est initialisé avec la date définie dans l'objet nsDatePerso (dateFromComponents:nsDatePerso) en passant par un objet NSCalendar ([NSCalendar currentCalendar]) :

NSDate *datePerso = [[NSCalendar currentCalendar] dateFromComponents:nsDatePerso];

Une variante pour définir une date autre que la date système

Pour définir et initialiser un objet NSDate avec une date différente de la date système, il est également possible d'utiliser une chaîne de caractères. Cette technique est plus simple que la précédente. Elle consiste à passer en paramètre la chaîne qui contient la date à la méthode dateFromString, qui elle-même est appliquée à un objet NSDateFormatter :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"dd-MM-yyyy"];
NSDate *uneDate = [df dateFromString:@"12-08-2011"];

La première instruction définit l'objet NSDateFormatter df et lui réserve un emplacement en mémoire :

NSDateFormatter* df = [[NSDateFormatter alloc]init];

La deuxième instruction définit le format utilisé dans l'objet NSDateFormatter :

[df setDateFormat:@"dd-MM-yyyy"];

Enfin, la troisième instruction affecte une date à l'objet NSDate uneDate en transmettant une chaîne à la méthode dateFromString de l'objet NSDateFormlatter df :

NSDate *uneDate = [df dateFromString:@"12-08-2011"];

Extraction des composants d'un objet NSDate

Pour accéder aux composants (jour, mois, année, heure, minute et seconde) d'une date au format NSDate, vous devez utiliser la méthode components: fromDate: d'un objet NSCalendar dans lequel vous aurez stocké la date.

À titre d'exemple, le code ci-dessous extrait le jour, le mois, l'année, l'heure, les minutes et les secondes de la date système et les affiche dans la console :

NSDate *date = [NSDate date]; //Aujourd'hui
NSCalendar *calendrier = [NSCalendar currentCalendar];
NSDateComponents *composants = [calendrier components:(NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSHourCalendarUnit | NSMinuteCalendarUnit | NSSecondCalendarUnit) fromDate:date];
NSLog(@"Nous sommes le %i / %i / %i", [composants day], [composants month], [composants year]);
NSLog(@"Il est  %i : %i : %i", [composants hour], [composants minute], [composants second]);

La première instruction crée l'objet NSDate date et y stocke la date système :

NSDate *date = [NSDate date]; //Aujourd'hui

La deuxième instruction crée l'objet NSCalendar calendrier :

NSCalendar *calendrier = [NSCalendar currentCalendar];

La troisième instruction crée l'objet NSDateComponents composants et lui affecte les composants suivants de l'objet NSDate date :

Les deux dernières instructions affichent les composants de la date système dans la console, ce qui donne le résultat suivant :

[...] test[1897:207] Nous sommes le 7 / 6 / 2011
[...] test[1897:207] Il est  16 : 39 : 6

Ajouter ou soustraire des dates

Pour ajouter ou soustraire un certain nombre d'années, de mois et de jours à une date, vous devez créer un objet dateComponents, y stocker la valeur à ajouter ou soustraire et ensuite utiliser la méthode dateByAddingComponents:toDate pour ajuster la date d'origine.
À titre d'exemple, nous allons ajouter 1 an, 3 mois et 10 jours à la date système et afficher le résultat dans la console. Voici le code utilisé :

NSDate *date = [NSDate date]; //Aujourd'hui
NSDateComponents *leGap = [[NSDateComponents alloc] init];
[leGap setYear:1];
[leGap setMonth:3];
[leGap setDay:10];

NSDate *nouvelleDate = [[NSCalendar currentCalendar] dateByAddingComponents:leGap toDate:date options:0];

NSLog(@"Date système : %@", date);
NSLog(@"Nouvelle date : %@", nouvelleDate);

La date système puis la nouvelle date sont affichées dans la console :

[...] test[1995:207] Date système : 2011-06-07 14:59:53 +0000
[...] test[1995:207] Nouvelle date : 2012-09-17 14:59:53 +0000

Examinons les instructions utilisées.
La première ligne définit l'objet NSDate date et y stocke la date système :

NSDate *date = [NSDate date];

La deuxième ligne définit l'objet NSDateComponents leGap et réserve son emplacement en mémoire :

NSDateComponents *leGap = [[NSDateComponents alloc] init];

Les trois lignes suivantes initialisent le décalage souhaité dans l'objet leGap :

[leGap setYear:1];
[leGap setMonth:3];
[leGap setDay:10];

La nouvelle date est calculée dans l'objet NSDate nouvelleDate. Les composants définis dans l'objet leGap sont ajoutés (dateByAddingComponents:leGap) à l'objet NSDate date (toDate: date) :

NSDate *nouvelleDate = [[NSCalendar currentCalendar] dateByAddingComponents:leGap toDate:date options:0];

Calculer la différence entre deux dates

Il est parfois nécessaire de calculer la différence entre deux dates. En Objective-C, cela se fait en appliquant les méthodes fromDate et toDate à un objet NSCalendar. Voici le code :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"yyyy-MM-dd"];
NSDate *dateA = [NSDate date]; //Aujourd'hui
NSDate* dateB = [df dateFromString:@"2011-01-01"];
NSCalendarUnit calendrier = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit;
NSDateComponents *difference = [[NSCalendar currentCalendar] components:calendrier fromDate:dateA toDate:dateB options:0];
NSInteger mois = [difference month];
NSInteger jours = [difference day];
NSLog(@"Différence entre les deux dates : %i mois et %i jours.", mois,jours);

Examinons ce code.
Les deux premières instructions définissent et initialisent l'objet NSDateFormatter df :

NSDateFormatter* df = [[NSDateFormatter alloc]init];
[df setDateFormat:@"yyyy-MM-dd"];

Les deux instructions suivantes stockent la date courante ainsi qu'une autre date (celle du 01/01/2011) dans les objets NSDate dateA et dateB :

NSDate *dateA = [NSDate date]; //Aujourd'hui
NSDate* dateB = [df dateFromString:@"2011-01-01"];

L'instruction suivante définit les composants qui seront utilisés pour calculer la différence entre les deux dates (ici les années, les mois et les jours) :

NSCalendarUnit calendrier = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit;

L'instruction suivante calcule la différence entre les deux dates. L'instruction est assez conséquente, alors prenez le temps de bien la comprendre. Dans la section « Extraction des composants d'un objet NSDate », vous avez appris à utiliser la méthode components: fromDate pour extraire les composants (année, mois, jour, heures, minutes, …) d'une date. Ici, nous allons utiliser la méthode components: fromDate: toDate: pour effectuer une soustraction entre deux dates et en extraire les composants.

Dans un premier temps, un objet NSCalendar est obtenu avec le message [NSCalendar currentCalendar].

La méthode components: fromDate: toDate: est alors exécutée. La différence entre les dates dateA et dateB est calculée (fromDate:dateA toDate:dateB), et seuls les composants définis dans l'objet NSCalendatUnit calendrier sont retournés. Le résultat est stocké dans l'objet NSDateComponents difference :

NSDateComponents *difference = [[NSCalendar currentCalendar] components:calendrier fromDate:dateA toDate:dateB options:0];

Il ne reste plus qu'à extraire les composants ans, mois et jour du résultat et à les stocker dans des objets NSInteger :

NSInteger ans = [difference year];
NSInteger mois = [difference month];
NSInteger jours = [difference day];

Il ne reste plus qu'à les afficher dans la console :

NSLog(@"Différence entre les deux dates : % ans %i mois et %i jours.", ans,mois,jours);

Temps nécessaire pour exécuter un bloc d'instructions

Pendant la mise au point d'une application, il peut être utile de calculer le temps nécessaire à l'exécution d'un bloc de code. Voici comment procéder :

  1. définissez un objet NSDate et initialisez-le avec la date courante juste avant le bloc de code dont vous voulez tester le temps d'exécution ;

  2. exécutez le bloc de code ;

  3. appliquez la méthode timeIntervalSinceNow à l'objet NSDate initialisé à l'étape 1 et mémorisez le résultat dans un objet NSTimeInterval.

Voici un exemple de code qui teste le temps nécessaire à l'affichage de 100 lignes dans la console :

NSDate *debut = [NSDate date]; //Date courante

//On affiche 100 lignes dans la console grâce à une boucle
int compteur;
for (compteur=1; compteur<100; compteur++)
{
  NSLog(@"abc");
}

NSTimeInterval intervalle = [debut timeIntervalSinceNow]; //On calcule le temps d'exécution...
NSLog(@"Temps écoulé : %f", intervalle); //Et on l'affiche

La figure suivante représente les dernières informations affichées dans la console.

On calcul le temps que prennent 100 lignes à s'afficher dans la console
Fatigué(e) de lire sur un écran ? Découvrez ce cours en livre.

Nombres Tableaux

Tableaux

Dates et heures Dictionnaires

La classe NSArray est dédiée à la manipulation de tableaux (un tableau est un assemblage d'objets quelconques : c'est une façon de les ranger, comme dans une armoire). En programmation, on parle aussi d'array (d'où le nom de la classe NSArray).

Définir et initialiser un tableau

Pour créer un tableau contenant une chaîne de caractères, vous utiliserez l'instruction suivante :

NSArray *monTableau = [NSArray arrayWithObject :@"premier"];

Pour créer un tableau contenant un entier, vous utiliserez l'instruction suivante :

NSArray *monTableau = [NSArray arrayWithObject :[NSNumber numberWithInt: 10]];

Pour créer un tableau contenant plusieurs chaînes de caractères, vous utiliserez l'instruction suivante :

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];

Enfin, pour créer un tableau à partir d'un autre tableau, vous utiliserez l'instruction suivante :

NSArray *monTableau2 = [NSArray arrayWithArray :monTableau1];

Accéder aux objets contenus dans un tableau

Plusieurs méthodes très pratiques permettent d'accéder aux informations contenues dans un objet NSArray.

Pour clarifier ces méthodes, rien de tel que quelques exemples :

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];
NSLog(@"%@",monTableau);
NSLog(@"Objet qui se trouve à l'index 1 : %@", [monTableau objectAtIndex:1]);

if ([monTableau containsObject:@"premier"]) 
  NSLog(@"L'objet premier a été trouvé dans le tableau");
else 
  NSLog(@"L'objet premier n'a pas été trouvé dans le tableau");

if ([monTableau containsObject:@"dixième"]) 
  NSLog(@"L'objet dixième a été trouvé dans le tableau");
else 
  NSLog(@"L'objet dixième n'a pas été trouvé dans le tableau");

NSLog(@"Dernier objet du tableau : %@", [monTableau lastObject]);

Examinons ces instructions.
La première ligne définit l'objet NSArray monTableau et l'initialise avec quatre chaînes de caractères : premier, deuxième, troisième et quatrième :

NSArray *monTableau = [NSArray arrayWithObjects : @"premier",@"deuxième",@"troisième",@"quatrième", nil];

La deuxième instruction (NSLog(@"%@",monTableau);) affiche le contenu du tableau dans la console.

La troisième instruction affiche l'objet qui se trouve en position 1 (le deuxième donc, puisque l'index commence à 0) :

NSLog(@"Objet qui se trouve à l'index 1 : %@", [monTableau objectAtIndex:1]);

Et voici les informations retournées dans la console :

[...] test[1095:207] Objet qui se trouve à l'index 1 : deuxième

Le premier bloc if else utilise la méthode containsObject pour tester la présence de l'objet premier dans le tableau et affiche un message en conséquence :

if ([monTableau containsObject:@"premier"]) 
  NSLog(@"L'objet premier a été trouvé dans le tableau");
else 
  NSLog(@"L'objet premier n'a pas été trouvé dans le tableau");

Ici, l'objet premier faisant partie du tableau, voici ce qu'affiche la console :

[...] test[1095:207] L'objet premier a été trouvé dans le tableau

Le bloc if else suivant utilise la méthode containsObject pour tester la présence de l'objet dixième dans le tableau et afficher un message en conséquence :

if ([monTableau containsObject:@"dixième"]) 
  NSLog(@"L'objet dixième a été trouvé dans le tableau");
else 
  NSLog(@"L'objet dixième n'a pas été trouvé dans le tableau");

L'objet dixième ne faisant pas partie du tableau, voici ce qu'affiche la console :

[...] test[1095:207] L'objet dixième n'a pas été trouvé dans le tableau

Enfin, la dernière instruction affiche le dernier objet du tableau :

NSLog(@"Dernier objet du tableau : %@", [monTableau lastObject]);

Comme prévu, le dernier objet est la chaîne quatrième :

[...] test[1095:207] Dernier objet du tableau : quatrième

Passer en revue les objets contenus dans un tableau

Vous vous en doutez certainement, la lecture successive des différents objets contenus dans un tableau se fera dans une boucle. Les objets peuvent être retrouvés avec la méthode objectAtIndex ou avec la méthode objectEnumerator. Nous allons examiner tour à tour ces deux possibilités.

Avec la méthode objectAtIndex

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];
int nombreElements = [monTableau count];
for (int i = 0; i < nombreElements; i++)
{
  NSLog(@"Objet de rang %i : %@", i, [monTableau objectAtIndex: i]);
}

La première instruction définit l'objet NSArray monTableau et y stocke quatre chaînes de caractères. Je ne vous remets pas le code, à ce stade vous devriez avoir compris.

La deuxième instruction définit l'entier nombreElements et y stocke le nombre d'éléments du tableau :

int nombreElements = [monTableau count];

La boucle for exécute l'instruction NSLog() autant de fois que le tableau contient d'objets :

for (int i = 0; i < nombreElements; i++)

L'instruction NSLog de la ligne 5 accède aux éléments du tableau en passant l'index de la boucle à la méthode objectAtIndex et en l'appliquant à l'objet monTableau :

NSLog(@"Objet de rang %i : %@", i, [monTableau objectAtIndex: i]);

Le résultat affiché dans la console est bien celui qu'on attendait :

[...] test2[1417:207] Objet de rang 0 : premier
[...] test2[1417:207] Objet de rang 1 : deuxième
[...] test2[1417:207] Objet de rang 2 : troisième
[...] test2[1417:207] Objet de rang 3 : quatrième

Avec la méthode objectEnumerator

NSArray *monTableau = [NSArray arrayWithObjects :@"premier",@"deuxième",@"troisième",@"quatrième", nil];
NSEnumerator *enumer = [monTableau objectEnumerator];
NSObject *obj;
while ((obj = [enumer nextObject]) != nil)
{
  NSLog(@"Objet : %@", obj);
}

La première instruction définit l'objet NSArray monTableau et y stocke quatre chaînes de caractères.

La deuxième instruction crée l'objet enumer de type NSEnumerator et l'initialise avec un énumérateur basé sur l'objet monTableau :

NSEnumerator *enumer = [monTableau objectEnumerator];

Ce type d'objet permet de décrire très facilement des tableaux. Pour en savoir plus sur ce sujet, consultez l'aide en cliquant sur les mots NSEnumerator (1) et objectEnumerator (2), et si nécessaire en activant les icônes Hide or show the Utilities (3) et Show Quick Help (4), comme indiqué à la figure suivante.

Consultez l'aide

L'instruction suivante définit l'objet obj de type NSObject :

NSObject *obj;

En appliquant la méthode nextObject à l'objet NSEnumerator enumer, on obtient tour à tour tous les objets stockés dans le tableau monTableau. Lorsque tout le tableau a été parcouru, la méthode nextObject renvoie la valeur nil. La façon la plus simple de passer en revue tout le contenu du tableau consiste à utiliser une boucle while :

while ((obj = [enumer nextObject]) != nil)

Si l'objet renvoyé par la méthode nextObject est différent de nil, il est affiché dans la console :

NSLog(@"Objet : %@", obj);

Dans le cas contraire, la boucle while prend fin.
Voici le résultat affiché dans la