Catégorie : Programmation

La programmation est au cœur de toute solution numérique performante. Dans cette section, je partage des articles techniques autour du développement web, du code et des bonnes pratiques de programmation. Qu’il s’agisse de PHP, de JavaScript ou encore de frameworks comme CodeIgniter, chaque article vise à éclairer des problématiques concrètes et à proposer des solutions efficaces. Ces contenus s’adressent aussi bien aux développeurs curieux qu’aux professionnels cherchant à optimiser leurs projets applicatifs.

Normaliser l’affichage d’un nombre en PHP

Publié le par jmch

Vous vous demandez comment normaliser l’affichage d’un nombre long (par exemple: 3665321.725) sur vos pages web afin de le rendre plus lisible?

PHP propose parmi son arsenal conséquent de fonctions une solution simple et efficace qui s’adaptera à vos besoins et vous comblera de bonheur.

number_format

La fonction PHP number_format s’utilise comme suit:

<?php
echo "Le montant total du financement réalisé par la région est de ".<a href="http://www.php.net/number_format">number_format</a>(3665321.725, 2, ',', ' ')." euros";

 

L’exemple ci-dessus affichera le résultat suivant:

Le montant total du financement réalisé par la région est de 3 665 321,73 euros

La fonction permet de spécifier le nombre de décimales auquel vous souhaitez arrondir, le symbole utilisé comme séparateur décimal et enfin le symbole utilisé comme séparateur de milliers.

Liens et références

Je vous laisse avec le lien officiel vers la documentation en ligne de PHP consacrée à cette fonction

La propriété CSS « filter »

Publié le par jmch

CSS3 nous propose quantité de possibilités pour agrémenter nos sites web. Parmi elles aujourd’hui, je tiens particulièrement à vous présenter la propriété filter. Celle ci propose de réaliser des effets d’image en temps réel et normalement obtenu à travers des logiciels de retouche photo.

Le support n’étant pas encore totalement accepté en CSS3 il sera nécessaire de préciser (même sur un navigateur moderne début 2015) une entrée spécifique pour les navigateurs à base de webkit (comme Google Chrome).

filter: blur(3px);
-webkit-filter: blur(3px);

Voici la liste (non exhaustive) des effets supportés

  • Flou = blur()
  • Luminosité = brightness()
  • Constraste = contrast()
  • Noir et blanc (désaturation) = grayscale()
  • Rotation de la roue chromatique = hue-rotate()
  • Inversion (négatif) = invert()
  • Opacité (transparence) = opacity()
  • Sepia (effet vieille photo) = sepia()

Je vous propose de retrouver ci-dessous une petite application qui vous montrera en temps réel le résultat des effets et valeurs choisies sur une image.

Amusez vous

CSS généré

filter: blur(15px);
-webkit-filter: blur(15px);

Mode radin – Utiliser les caractères spéciaux HTML5 / UTF8

Publié le par jmch

Pourquoi rechercher et acheter des icônes alors qu’on peut trouver aujourd’hui des quantités astronomiques de symboles dans le domaine public? Les standards UTF-8 et HTML5 nous permettent d’utiliser un certain nombre de ces symboles sans avoir à reverser de droits à qui que ce soit.

De plus, cela vous fera économiser des octets car il ne s’agit pas d’images à proprement parler, mais bien de caractères qui seront interprétés directement par le navigateur de l’internaute. Au final, ça nous fait gagner de la place sur nos disques, mais également de la bande passante sur nos hébergements. Bref, c’est que du bonheur et ça ne coûte pas cher!

Voici pour vous une petite sélection parmi les nombreux symboles utilisables sur les navigateurs modernes. Je précise que certains de ces symboles ont été agrémentés avec un peu de CSS pour leur donner de la couleur, un effet d’ombrage. Ce ne sont là que des suggestions d’utilisation.

Attention! : Si vous voyez un carré à la place d’un caractère, c’est qu’il n’est pas interprété (reconnu) par votre navigateur.

Pour QCM ou listes à cocher

Vrai : ☑ ✓ ✔

Faux : ☒ ✗ ✘

Cases à cocher : ❍ ❏ ❐ ❑ ❒

Informations commerce et marques

Trade Mark : ™ Copyright : © Reserved : ®

Symboles d’environnement dangereux

Toxicité : ☠ Radioactivité : ☢ Risques biologiques : ☣

On a jamais trop de flèches

Les chevrons < > ˄ ˅

Flèches fines ← ↑ → ↓ ↔ ↕

Flèches blanches ⇐ ⇑ ⇒ ⇓ ⇔ ⇕

Flèches blanches 2 ⇦ ⇧ ⇨ ⇩

Flèches pointillées ⇠ ⇡ ⇢ ⇣

Flèches noires pleines ⬅ ⬆ ⬇ ⬈ ⬉ ⬊ ⬋ ⬌ ⬍

Spéciales archers ➳ ➴ ➵ ➶ ➷ ➸ ➹

Mains ☚ ☛ ☜ ☝ ☞ ☟

Pour les joueurs de cartes

Pique : ♠ Trèfle : ♣ Cœur : ♥ Carreau : ♦

Communication générale

On ne le dit jamais trop : ❤

Fractions : ‰ ‱ ¼ ½ ¾

Rédaction de texte : ¶ ⌫ ⏎

Téléphone : ☎ ☏

Communication écrite : ✍ ✎ ✏ ✐ ✑ ✒

Courrier : ✉

Etoiles : ✩ ✪ ✫ ✬ ✭ ✮ ✯ ✰ ✱ ✲ ✳ ✴ ✵ ✶ ✷ ✸ ✹ ✺

Fleurs : ✻ ✼ ✽ ✾ ✿ ❀ ❁ ❂ ❃ ❄ ❅ ❆ ❇ ❈ ❉ ❊ ❋

Zones à découper : ✁ ✂ ✃ ✄

Pour les joueurs d’échec

Joueur blanc Reine : ♔ Roi : ♕ Tour : ♖ Fou : ♗ Cavalier : ♘ Pion : ♙

Joueur noir Reine : ♚ Roi : ♛ Tour : ♜ Fou : ♝ Cavalier : ♞ Pion : ♟

Quelques symboles astronomique

Système solaire

☉ Soleil

☿ Mercure

♀ Venus

⊕ Terre

☽ Lune

♂ Mars

♃ Jupiter

♄ Saturne

♅ Uranus

♆ Neptune

♇ Pluton

☄ Comète

Signes astrologiques

♈Bélier
21 Mars – 20 Avril

♉Taureau
21 Avril – 21 Mai

♊Gémeaux
22 Mai – 21 Juin

♋Cancer
22 Juin – 22 Juillet

♌Lion
23 Juillet – 22 Août

♍Vierge
23 Août – 22 Septembre

♎Balance
23 Septembre – 22 Octobre

♏Scorpion
23 Octobre – 22 Novembre

♐Sagittaire
23 Novembre – 21 Décembre

♑Capricorne
22 Décembre – 21 Janvier

♒Verseau
22 Janvier – 19 Février

♓Poisson
20 Février – 20 Mars

Indications climatiques ou de conservation

Nuage : ☁

 Pluie : ☂

 Soleil : ☼

 Givre, glace : ❄ ❅

Quelques courants de pensée

Paix : ☮ Equilibre : ☯

Pour les musiciens

Notes

Noire : ♩ Simple croche : ♪ Simples croches ramées : ♫ Double croche : 𝅘𝅥𝅯 Triple croche : 𝅘𝅥𝅰 Quadruple croche : 𝅘𝅥𝅯 Doubles croches ramées : ♬

Indications

Bémol : ♭ Bécarre : ♮ Dièse : ♯

Et bien d’autres encore, cette liste est loin d’être exhaustive. Il y a encore de nombreux domaines susceptibles d’utiliser certains symboles. (math, chimie, géométrie…)

Liens et références

Les structures de contrôle – partie 3

Publié le par jmch

Dans cette troisième partie consacrée aux structures de contrôle nous allons étudier certains types de boucles particulièrement adaptées aux tableaux (for, foreach), la structure de contrôle switch qui permet d’écrire des ensembles de conditions plus simplement qu’avec la structure if.

Les boucles for

La boucle for permet de faire plusieurs choses. Premièrement, elle permet d’attribuer une valeur de départ à une variable. Ensuite elle applique une condition, par exemple tant que la variable initialisée est inférieur à une valeur maximale fixée. Et enfin elle permet de réaliser une action, par exemple l’incrémentation (valeur+1) ou la décrémentation (valeur-1) de la variable.

Voici à quoi cela ressemble d’un point de vue logique

POUR (POSITION=VALEUR ; TANT QUE POSITION INFÉRIEUR A VALEUR MAX ; ACTION SUR POSITION) {
	// Instructions à exécuter
	// A chaque passage dans la boucle, POSITION aura une valeur différente selon que l'on choisisse
	// de l'incrémenter ou décrémenter
	// Pour sortir prématurément d'une boucle
	break ;
}

Dans nos exemples ci-dessous, nous utiliserons la variable position que nous allons initialiser à 0 pour traiter les 8 valeurs contenues dans nos tableaux. Ainsi la valeur maximale de la variable position sera 7 (de 0 à 7, nous avons bien 8 valeurs).

Les tableaux de données utilisés seront les suivants :

0Marie
1Marc
2Antoine
3Jean
4Eric
5Simone
6Pierre
7Martine
0Lyon
1Grenoble
2Paris
3Beauvais
4Bordeaux
5Valence
6Nantes
7Auxerre

Création d’une boucle for en C

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
        /* Définition des variables */
        int position;
        int max=8;
        /* Définition du tableau personnes */
        char personnes[8][16]={
                "Marie", "Marc", "Antoine", "Jean", "Eric", "Simone",
                "Pierre", "Martine"
        };
        /* Définition du tableau villes */
        char villes[8][16]={
                "Lyon", "Grenoble", "Paris", "Beauvais", "Bordeaux",
                "Valence", "Nantes", "Auxerre"
        };
 
        /* Traitement des tableaux avec une boucle for */
        for (position=0; position < max; position++) {
                printf("%s travaille à %s\n", personnes[position], villes[position]);
        }
        return EXIT_SUCCESS;
}

Une fois compilé et exécuté, le code ci-dessus affichera ceci :Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

Nous constatons que à la valeur 0 du tableau personnes on trouve « Marie », dans le tableau villes à la même position nous trouvons « Lyon », le résultat avec position à 0 affiche donc « Marie travaille à Lyon ». Et on recommence ce même cycle jusqu’à 7 qui correspond à la dernière valeur des deux tableaux.

En Javascript à présent

var personnes=[ 'Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine' ] ;
var villes=[ 'Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre' ] ;
var pos ;
// Nombres d'éléments dans le tableau personnes
max=personnes.length ;
// Parcours du tableau avec la boucle for
for (pos=0 ; pos < max ; pos++) {
  console.log(personnes[pos] + ' travaille à ' + villes[pos]) ;
}

Le code ci-dessus affichera :Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

En PHP

<?php
$personnes=array('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine') ;
$villes=array('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre') ;
// Nombre d'éléments dans le tableau personnes
$max=count($personnes) ;
// Parcours du tableau avec la boucle for
for ($pos=0 ; $pos < $max ; $pos++) {
  echo $personnes[$pos]." travaille à ".$villes[$pos]."<br/>" ;
}
 
// Méthode alternative pour parcourir un tableau en PHP
$pos=0 ;
// A chaque passage, $prenom contiendra le nom de l'élément du tableau puis passera au suivant à la fin de la boucle
foreach ($personnes AS $prenom) {
  echo $prenom." travaille à ".$villes[$pos]
  $pos++ ;
}

De la même manière le code ci-dessus affichera :Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

En Perl

#!/usr/bin/perl
 
use strict;
 
# Définition des tableaux
my @personnes=('Marie', 'Marc', 'Antoine', 'Jean', 'Eric', 'Simone', 'Pierre', 'Martine');
my @villes=('Lyon', 'Grenoble', 'Paris', 'Beauvais', 'Bordeaux', 'Valence', 'Nantes', 'Auxerre');
 
my $pos;
 
# Parcours des tableaux
for ($pos=0; $pos < scalar(@personnes); $pos++) {
        print $personnes[$pos]." travaille à ".$villes[$pos]."\n";
}
 
# Méthode alternative pour un tableau en Perl
$pos=0;
foreach (@personnes) {
        print $_." travaille à ".$villes[$pos]."\n";
        $pos++;
}

Le code ci-dessus affichera :Marie travaille à Lyon
Marc travaille à Grenoble
Antoine travaille à Paris
Jean travaille à Beauvais
Eric travaille à Bordeaux
Simone travaille à Valence
Pierre travaille à Nantes
Martine travaille à Auxerre

En anglais, switch signifie commutateur et c’est exactement le rôle de cette structure de contrôle. Elle permet d’exécuter des instructions dans des cas bien spécifiques que ce soit pour un ou plusieurs cas de figures différents, mais elle offre également la possibilité de définir des instructions à exécuter pour tous les cas de figure non traités.

Voici la représentation logique de cette structure

SWITCH ($valeur) {
	CAS '1' :
		// Instructions à exécuter lorsque $valeur est égal à 1
		// Sortie de la structure
		BREAK
	CAS '2' :
	CAS '3' :
	CAS '5' :
		// Instructions à exécuter lorsque $valeur est égal à 2, 3 ou 5
		// Sortie de la structure
		BREAK
	CAS '6' :
		// Instructions à exécuter si $valeur est égal à 6
		// On ne sort pas de la structure, donc on traite aussi le cas de figure suivant
	CASE '9' :
		// Instructions à exécuter si $valeur est égal à 6 ou 9
		// Sortie de la structure
		BREAK
	DEFAULT :
		// Instructions à exécuter pour tous les cas de figure qui n'ont pas été traités précédemment
}

Ce type de structure complexe peut être réalisée entièrement avec des structures de contrôle if else if et else, mais elle sera alors moins évidente à écrire et à lire. La structure switch est une facilité visuelle pour les développeurs dans le sens où elle permet de traiter de multiples cas de figures dans une seule structure et de manière assez évidente.

Voici un exemple en C

#define <stdio.h>
#define <stdlib.h>
 
#define PERSIL 0 
#define SALADE 1
#define TOMATE 2
#define CAROTTE 3
#define POIVRON 4
 
/* Définition de la fonction de traitement */
void couleur(int legume) {
  switch (legume) {
      case PERSIL :
      case SALADE :
        printf("Couleur : verte\n") ;
        break ;
      case TOMATE :
      case POIVRON :
        printf("Couleur : rouge\n") ;
        break ;
      default :
        printf("Cas de figure non traité\n") ;
    }
  }
}
 
int main(void) {
  couleur(PERSIL) ; /* Affichera : Couleur : verte */
  couleur(POIVRON) ; /* Affichera : Couleur : rouge */
  couleur(CAROTTE) ; /* Affichera : Cas de figure non traité */
 
}

La même structure en Javascript

// Définition de la fonction
function couleur(legume) {
  var ret ;
 
  switch (legume) {
    case 'persil' :
    case 'salade' :
      ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      ret='rouge' ;
      break ;
    default :
      ret='Cas de figure non traité' ;
  }
  // Retourne le résultat à la fonction appelante
  return ret ;
}
 
// Utilisation de la fonction
console.log(couleur('persil')) ;  // Affichera : vert
console.log(couleur('poivron')) ;  // Affichera : rouge
console.log(couleur('banane')) ;  // Affichera : Cas de figure non traité

En PHP

<?php
// Définition de la fonction
function couleur($legume) {
  $ret='' ;
  switch ($legume) {
    case 'salade' :
    case 'persil' :
      $ret='vert' ;
      break ;
    case 'tomate' :
    case 'poivron' :
      $ret='rouge' ;
      break ;
    default :
      $ret='Cas de figure non traité' ;
  }
}
 
// Utilisation de la fonction
echo "Le persil c'est : ".couleur('persil') ;  // Affichera : Le persil c'est : vert
echo "La tomate c'est : ".couleur('tomate') ;  // Affichera : La tomate c'est : rouge
echo "La banane c'est : ".couleur('banane') ;  // Affichera : La banane c'est : Cas de figure non traité

En perl

En Perl les choses changent un peu. En effet, la structure de contrôle switch n’existe pas nativement en Perl et si on souhaite malgré tout pouvoir traiter des conditions de la même manière, il faut faire appel à un module spécifique qui devra être chargé au démarrage du script. Ce module se nomme ‘Switch.pm’.

#!/usr/bin/perl
 
use strict;
# Chargement du module Switch.pm
use Switch;
 
# Définition de la fonction
sub couleur {
        my ($legume)=@_;
        my $ret;
 
        # Utilisation de la structure émulée
        switch ($legume) {
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['salade', 'persil'] {
                        $ret='vert';
                }
                # Syntaxe pour exécuter les mêmes instructions
                # pour 2 cas de figures différents
                case ['tomate', 'poivron'] {
                        $ret='rouge';
                }
                # Équivalent du mot clé default pour traiter tous les cas de figure qui n'ont pas été 
                # traité par les instructions au dessus
                else {
                        $ret='Cas de figure non traité';
                }
        }
        return $ret;
}
 
print "Une salade c'est: ".couleur('salade')."\n";  # Affichera : Une salade c'est : vert
print "Un poivron c'est: ".couleur('poivron')."\n";  # Affichera : Un poivron c'est : rouge
print "Une banane c'est: ".couleur('banane')."\n";  # Affichera : Une banane c'est : Cas de figure non traité

Voilà, c’est la fin de cette série d’articles consacrés au bases de la programmation. Après avoir lu et appréhendé ces différents articles (qui je le répète ne sont pas exhaustifs), vous ne serez certainement pas des développeurs de pointe, mais vous aurez suffisamment d’éléments pour commencer à apprendre ou renoncer si cela ne vous parle pas du tout.

Si vous souhaitez des compléments d’informations ou voir un sujet particulier être traité à la suite de ces articles, vous pouvez en faire la demande par mail ou via les commentaires.

Les structures de contrôle – Opérateur conditionnel ternaire

Publié le par jmch

En complément des articles sur les bases de la programmation, voici une structure de contrôle particulière qui mérite qu’on s’y attarde et qui permet en quelque sorte d’attribuer un contenu conditionnel aux variable. Il s’agit de l’opérateur conditionnel ternaire. (Ternary operator in english)

Voici ce que cela donne d’un point de vue logique

ma_variable=(condition) ? Valeur si condition vrai:Valeur si condition fausse ;

Cela revient à écrire la structure suivante :
Si (condition est vrai) {
	ma_variable= valeur si condition vrai
}
Sinon {
	ma_variable= valeur si condition fausse
}
// La même en version courte
SI (condition) { ma_variable=valeur } SINON { ma_variable=valeur }

L’intérêt est double… Cela permet de gagner en lisibilité car le code de départ tient souvent en une seule ligne alors qu’une structure de contrôle if peut prendre souvent plus de place et demande de réécrire certaines portions de code plusieurs fois. Cela permet également de gagner quelques octets dans les scripts et programmes interprétés. Sur ces milliers de lignes et des millions de boucles, cela peut faire une différence conséquente.

Voici comment cet opérateur s’utilise en C

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=5 ;
  /* Si a est supérieur à 4, alors la valeur de b sera 6, sinon ce sera 2 */
  /* Dans le cas présent la valeur de b sera 6 */
  int b=(a > 4) ? 6:2 ;
}

En Javascript

var a=5 ;
var b=(a > 4) ? 'Attention !' :'Tout va bien' ;
console.log(b + ' Valeur = ' + a) ;  // Affichera : Attention ! Valeur = 5

En PHP

<?php
$a=4;
b=($a > 4) ? 'Alerte !' :'Ok';
 
echo "$b Valeur = $a";  // Affichera : Ok Valeur = 4

En Perl

#!/usr/bin/perl
 
use strict;
 
my $a=5;
my $b=($a > 4) ? 'Alerte!':'Ok';
 
print $b." Valeur: $a\n";  # Affichera : Alerte! Valeur: 5

Les structures de contrôle – partie 2

Publié le par jmch

Une fonction c’est quoi?

Les fonctions sont des conteneurs logique de code. Il s’agit d’une structure de contrôle dont vous pouvez définir le contenu et les conditions et qui peut retourner (en fonction du langage et de vos souhaits) une valeur, un tableau, des objets, un booléen ou seulement exécuter une action sans rien retourner.

Les fonctions sont faites pour ne pas avoir à réécrire les même portions de code pour traiter les 250 000 cas de figure de votre base client. Un ensemble d’instructions peut ainsi être écrit une seule fois et réutilisé des millions de fois pour traiter par exemple les données d’un tableau ce qui fait gagner un temps précieux pour le développeur et des milliers de ligne de code.

Les fonctions sont très simples à définir et à utiliser, voici un petit schéma logique

// Définition
FONCTION nom_fonction(paramètre_1, paramètre_2, paramètre_x) {
	// Instructions à exécuter et éventuellement valeur à retourner
}

// Utilisation
RESULTAT_1=nom_fonction(val1, val2, valx) ;
RESULTAT_2=nom_fonction(val12, val22, valx2) ;
RESULTAT_Y=nom_fonction(val1y, val2y, valxy) ;

Voici comment définir et utiliser une fonction en C

#define <stdio.h>
#define <stdlib.h>
 
/* En C les paramètres d'une fonction se définissent avec leur type comme les variables */
int voyelles(char *mot) {
  int res=0 ;
  int pos=0 ;
 
  /* Tant que la fin de la chaînes de caractères n'a pas été atteinte */
  while (mot[pos]!='\0') {
    // On parcoure chaque lettre du mot et à chaque voyelle on ajoute 1 à la valeur de res
    if (mot[pos]=='a' || mot[pos]=='e' || mot[pos]=='i' || mot[pos]=='o' || mot[pos]=='u' || mot[pos]=='y') {
      res++ ;
    }
    pos++;
  }
  // Retourne la valeur de res à la fonction appelante
  return res;
}
 
int main(void) {
  printf("azerty contient %d voyelle(s)\n", voyelles("azerty")) ;
   /* Affiche : azerty contient 3 voyelle(s) */
  printf("pierre contient%d voyelle(s)\n", voyelles("pierre")) ;
   /* Affiche : pierre contient 3 voyelle(s) */
  printf("toto contient%d voyelle(s)\n", voyelles("toto")) ;
   /* Affiche : toto contient 2 voyelle(s) */
 
  return EXIT_SUCCESS ;
}

en Javascript

// Définition de la fonction
// Retourne le chiffre entré en toutes lettres de 0 à 10 ;-)
function enToutesLettres(nombre) {
  // On teste la valeur du paramètre pour voir si il est dans la plage fixée
  if (nombre > 10 || nombre < 0) { return "Traite seulement les chiffres de 0 à 10 !" ; }
  if (nombre==0) { return "zéro" ; }
  if (nombre==1) { return "un" ; }
  if (nombre==2) { return "deux" ; }
  if (nombre==3) { return "trois" ; }
  if (nombre==4) { return "quatre" ; }
  if (nombre==5) { return "cinq" ; }
  if (nombre==6) { return "six" ; }
  if (nombre==7) { return "sept" ; }
  if (nombre==8) { return "huit" ; }
  if (nombre==9) { return "neuf" ; }
  if (nombre==10) { return "dix" ; }
  // On ne devrait jamais arriver ici
  return   "Il y a un problème !" ;
}
 
// Utilisation de la fonction
console.log(enToutesLettres(3)) ; // Affichera trois
console.log(enToutesLettres(6)) ; // Affichera six
console.log(enToutesLettres(9)) ; // Affichera neuf

En PHP

<?php
// Définition de la fonction
// Crée retourne une histoire avec les noms passés en paramètres
function histoire($nomPrince, $superPouvoir, $nomPrincesse, $nomSorciere) {
  $prepa='Il était une fois il y a bien longtemps, une princesse nommée '.$nomPrincesse.' fut enlevée par '.
  'la sorcière '.$nomSociere.'. Mais heureusement, arriva le prince '.$nomPrince.' qui grâce à '.
  'son super pouvoir, '.$superPouvoir.', terrassa la princesse '.$nomPrincesse.' et épousa la sorcière '.
  $nomSorciere.'. Oups !!!' ;
 
  return $prepa ;
}
 
echo "Voici ce qui arrive quand on veut aller trop vite et qu'on ne fait pas attention:<br/>".
histoire('Kevin', 'la sieste', 'Cent-Vingt Drillons', 'Bien-Aimée')."<br/>";

Le code ci-dessus affichera (et l’histoire changera à chaque fois qu’un paramètre sera modifié) :

Voici ce qui arrive quand on veut aller trop vite et qu’on ne fait pas attention:
Il était une fois il y a bien longtemps, une princesse nommée Cent-Vingt Drillons fut enlevée par la sorcière Bien-Aimée. Mais heureusement arriva le prince Kevin qui grâce à son super pouvoir, la sieste, terrassa la princesse Cent-Vingt Drillons, et épousa la sorcière Bien-Aimée. Oups !!!

Ca n’a aucun sens bien entendu, c’était seulement pour l’exemple…

Et enfin en Perl

#!/usr/bin/perl
 
use strict;
 
sub concatenation {
        my ($motA, $motB, $lien)=@_;
        my $resu;
 
        $resu = $motA.$lien.$motB;
 
        return $resu;
}
# Appel de la fonction
print "Résultat: ".concatenation("Jean", "Pierre", "-")."\n";

Le code ci-dessus affichera :

Résultat: Jean-Pierre

Les structures de contrôle – partie 1

Publié le par jmch

Introduction

Les structures de contrôle permettent comme leur nom l’indique de contrôler des conditions durant l’exécution de votre code. Cela peut varier de la valeur d’une variable en passant par le retour d’une fonction. Les structures de contrôle permettent également de traiter les éléments d’un tableau ou des listes de valeurs déterminées (par exemple : de 0 à 31).

Sans ces structures logiques, la programmation serait un véritable enfer où le choix des portion de code à exécuter reviendrai à la décision d’un humain et où il faudrait réécrire x fois la même portion de code pour traiter les x valeurs d’un tableau.

Dans les structures de contrôle et pour les langages que nous allons étudier, la condition à tester est un booléen, soit une valeur comprise entre 0 (FAUX) et 1 (VRAI). Une condition sera toujours déclenchée par un état VRAI. Si on souhaite faire le contraire, c’est à dire déclencher lorsque la vérification est fausse, il faut faire précéder son expression par un point d’exclamation !. Enfin, les conditions doivent être entourées par des parenthèses.

Les opérateurs de contrôle

Voici une liste non exhaustive des principaux symboles utilisés pour tester des conditions.

OpérateurSignification
==égal
!=différent
>strictement supérieur
<strictement inférieur
>=supérieur ou égal
<=inférieur ou égal

Voici quelques exemples de conditions et leur retour booléen:

  • (12==13) FAUX
  • (13==13) VRAI
  • (12==(12+1)) FAUX
  • (12==(13-1)) VRAI
  • (13 > 12) VRAI
  • (12 < 13) VRAI
  • (12 > 13) FAUX
  • (13 >= 13) VRAI
  • (12!=13) VRAI

SI ou SINON et SINON-SI

La première structure de contrôle et aussi la plus simple consiste à vérifier une condition et à exécuter des instructions en fonction qu’elle soit vrai ou fausse. Il est également possible de tester plusieurs conditions dans une structure SI avec SINON-SI.

Voici comment se présente cette structure

SI (CONDITION VRAI)
	ALORS
	// Instructions à exécuter si la condition est vrai
SINON
	// Instructions à exécuter si la condition est fausse

Simple n’est-ce pas? Si la condition est vrai, on exécute les instructions définies en haut, sinon les autres. On peut même ne pas spécifier d’instruction pour SINON si ce n’est pas utile.

Pour illustrer l’exemple ci-dessous avec une valeur

SI (12 < 13)
	ALORS
	AFFICHER '12 est inférieur à 13'

Ici pas de sinon, 12 sera toujours inférieur à 13 et ce n’est pas la crise ni les attaques terroristes qui pourront y changer quelque chose…

Voici comment s’utilise cette structure en C

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int a=13;
  int b=12;
 
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est supérieure à la valeur de b */
 
  a=12 ; b=13 :
  /* SI */
  if (a > b) {
    printf("La valeur de a est supérieure à la valeur de b\n") ;
  }
  /* SINON */
  else {
    printf("La valeur de a est inférieure à la valeur de b\n") ;
  }
  /* Affichera :  La valeur de a est inférieure à la valeur de b */
}

en Perl à présent

# !/usr/bin/perl
 
use strict ;
 
my $a=13 ;
my $b=12 ;
 
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
# SI
if ($a > $b) {
  # Instructions
  print "La valeur de a est supérieure à la valeur de b\n" ;
}
# SINON
else {
  # Instructions
  print "La valeur de a est inférieure à la valeur de b\n" ;
}
# Affichera :  La valeur de a est inférieure à la valeur de b

Au tour de PHP

<?php
 
$a=13 ; $b=12 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
$a=12 ; $b=13 ;
// SI
if ($a > $b) {
  // Instructions
  echo "La valeur de a est supérieure à la valeur de b<br/>" ;
}
// SINON
else {
  // Instructions
  echo "La valeur de a est inférieure à la valeur de b<br/>" ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b
?>

Et finalement en Javascript

var a=13 ;
var b=12 ;
 
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est supérieure à la valeur de b
 
a=12 ; b=13 ;
// SI
if (a > b) {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// SINON
else {
  // Instructions
  console.log('La valeur de a est supérieure à la valeur de b') ;
}
// Affichera :  La valeur de a est inférieure à la valeur de b

La structure de contrôle SI-SINON existe dans la majorité des langages de programmation et est indispensable pour prendre des décisions dans un programme. On ne peut s’en passer et vous verrez par la suite que ceraines structures de contrôles plus complexes reposent sur celle-ci.

TANT QUE

Cette structure de contrôle fait partie des boucles. Parce que, tant que la condition est vrai, nous allons exécuter les mêmes instructions. Attention toutefois à réaliser les bons contrôles pour sortir de la boucle sans quoi votre programme peut boucler à l’infini (jusqu’à interruption manuelle).

Elle se présente comme suit

TANT-QUE (CONDITION VRAI) {
	// Instructions à exécuter à chaque passage dans la boucle
}

Voici ce que ça donne en C

#define <stdio.h>
#define <stdlib.h>
 
int main(void) {
  int position=12 ;
  int max=24 ;
 
  /* Tant que position est inférieur à max */
  while (position < max) {
    /* Instructions à exécuter tant que position est inférieur à max */
    printf("Valeur de position : %d\n", position) ; /* Affiche la valeur de position */
    position++ /* On augmente position de 1 à chaque passage */
  }
  /* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
}

En perl

# !/usr/bin/perl
 
use strict ;
 
my $pos=12 ;
my $max=24 ;
 
# Tant que pos est inférieur à max
while ($pos <= $max) {
  # Affiche la valeur de pos à chaque passage
  print "Valeur de pos : $pos\n" ;
  # Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
# La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal)

En PHP

<?php
$pos=12 ; $max=24 ;
// Tant que pos est inférieur à max
while ($pos < $max) {
  // Affiche la valeur de pos à chaque passage
  echo "Valeur de pos : $pos<br/>" ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 23 puisque 24 étant == à max on sort de la boucle avant de l'afficher */
?>

En Javascript

var pos=12 ;
var max=24 ;
 
while (pos <= max) {
  // Affiche la valeur de pos à chaque passage (dans la console)
  console.log('Valeur de pos : ' + pos) ;
  // Incrémente la valeur de pos à chaque passage (ajoute 1)
  $pos++ ;
}
/* La boucle affichera les valeurs de 12 à 24 puisque nous avons utilisé l'opérateur <= (inférieur ou égal) */

Dans les articles à venir nous allons étudier d’autres structures de contrôle plus complexes ou plus spécifiques à certains langages. Ces structures sont là pour faciliter le travail du développeur, aider à prendre des décision dans un programme mais aussi à parcourir des tableaux de donnée ou encore à traiter des ensembles de cas de figures spécifiques.

Les variables tableau

Publié le par jmch

Cet article, sera le dernier de la série sur les variables traitera d’un type de variable très utile que sont les variables tableaux ou array en anglais.

Voici comment une variable tableau pourraît être représentée:

Numéro ou IndexValeur
0Albert
1André
2Bertrand
3Corinne
4Félicie
x…

Une variable tableau est une liste de données rangées sous la forme d’un tableau indicé. Par exemple l’indice 0 contient Albert, l’indice 3 contient Corinne.

Voici la définition d’un tableau destiné à contenir 5 entiers en C:

// Définition de 5 emplacements pour entiers
int monTableau[5];
 
// Initialisation des emplacements (== indices)
// Premier emplacement
monTableau[0]=101;
// Second emplacement
monTableau[1]=102;
// Troisième emplacement
monTableau[2]=103;
// nième emplacement
monTableau[n-1]=nnn;

Si l’indice x de la variable monTableau est modifié à x + 1, alors le curseur en mémoire avancera de la taille d’un int. A l’inverse, si l’indice est modifié à x – 3, alors le curseur reculera de 3 fois la taille d’un int. Survolez les int présents dans le tableau ci-dessous.

Position en mémoire012345678910111213141516171819
Taille d’un élémentint 1int 2int 3int 4int 5

Chaque int pesant (hypothèse sur un système 32 bits) 4 octets, lorsqu’on avance d’un int, on déplace le curseur de 4 octets en mémoire.

En C le type chaîne de caractères n’existe pas comme on peut le trouver dans les autres langages. Il s’agit en fait d’un tableau de caractères qui peut se définir comme suit:

// On réserve 20 caractères
char maChaine[20];
 
// On réserve 11 caractères et on initialise le contenu de la variable
// Oui 11 et pas 10 car en C une chaîne doit se terminer par le caractère \0
// Il faut donc toujours prévoir un caractère de plus par rapport à la taille de la chaîne à contenir
char maChaine[]="Bonjour!!!";
// Equivalent de:
char maChaine[32];
maChaine[0]='B';
maChaine[1]='o';
maChaine[2]='n';
maChaine[3]='j';
maChaine[4]='o';
maChaine[5]='u';
maChaine[6]='r';
maChaine[7]='!';
maChaine[8]='!';
maChaine[9]='!';
maChaine[10]='\0';
/* ... etc ... */
// Equivalent de:
char maChaine[]={ 'B', 'o', 'n', 'j', 'o', 'u', 'r', '!', '!', '!', '\0' };
 
printf("%c - %c - %c", maChaine[0], maChaine[1], maChaine[2]); // Affichera B - o - n

Tous les types de variables peuvent être ordonnés en tableau. On retrouve les tableaux dans la majorité des langages de programmation modernes. Il est possible également de créer des tableaux contenant des tableaux. Attention toutefois à ne pas sombrer dans la complexité et ne perdez jamais de vue que tout cela a un coût en mémoire.

Définition de deux tableaux en PHP:

<?php
// Tableau indicé
$epices=array('poivre', 'cumin', 'piment', 'coriandre', 'curry');
// Equivalent de
$epices=array();
$epices[0]='poivre';
$epices[1]='cumin';
$epices[2]='piment';
$epices[3]='coriandre';
$epices[4]='curry';
 
echo "Un peu de ".$epices[2]."?"; // Affichera: Un peu de piment?
 
// Tableau associatif
// On remplace l'index numérique par une chaîne de caractères appelée clé
// Ainsi le tableau associatif, comme son nom l'indique devient un tableau d'associations de clé=>valeur
$fiche=array('nom' => 'Dupont', 'prenom' => 'Henry', 'email' => 'hdupont@exemple.org');
// Pour accéder à l'adresse email de monsieur dupont, il suffit d'appeler la variable ainsi
echo $fiche['email'];  // Affichera: hdupont@exemple.org

Définition de deux tableaux en Javascript:

// Tableau indicé
epices=['poivre', 'cumin', 'piment', 'coriandre', 'curry'];
// Equivalent de:
epices=[];
epices[0]='poivre';
epices[1]='cumin';
epices[2]='piment';
epices[3]='coriandre';
epices[4]='curry';
 
console.log('Aimez-vous le ' + epices[1] +'?'); // Affichera dans la console Javascript: Aimez-vous le cumin?
 
// Tableau associatif
// Même fonctionnement qu'en PHP, seule la syntaxe change
fiche={'nom': 'Dupont', 'prenom': 'Henry', 'email': 'hdupont@exemple.org'};
// Deux méthodes permettent d'accéder à l'adresse email de monsieur dupont
console.log(fiche['email']);  // Affiche hdupont@exemple.org dans la console javascript
// Ou
console.log(fiche.email);  // Affiche hdupont@exemple.org dans la console javascript

Définition de deux tableaux en Perl:

# Déclaration d'une variable tableau (indicé)
my @epices;
# Initialisation du contenu du tableau
@epices=('poivre', 'cumin', 'piment', 'coriandre', 'curry');
print "Encore un peu de ".$epice[0]."?"; # Affichera: Encore un peu de poivre?
# Equivalent de:
@epices=();
$epices[0]='poivre';
$epices[1]='cumin';
$epices[2]='piment';
$epices[3]='coriandre';
$epices[4]='curry';
print "Encore un peu de ".$epice[0]."?"; # Affichera: Encore un peu de poivre?
 
# En perl, on définit une variable tableau en faisant précéder son nom d'un @
# Mais pour accéder à ses valeurs, on utilise le symbole $ comme une variable classique
 
# Tableau associatif (aussi appelé table de hachage)
my %fiche=('nom' => 'Dupont', 'prenom' => 'Henry', 'email' => 'hdupont@exemple.org');
print $assoc{'email'}."\n"; # Affichera: hdupont@exemple.org

L’utilité de ce type de variable c’est de pouvoir traiter un grand volume de données avec un seul algorithme.

Par exemple, prenons l’algorithme suivant (en PHP):

<?php
// Liste d'abonnés
$liste=array(
  'jacques'  => 'jacques@truc.info',
  'Henry'    => 'henry@machin.fr',
  'Mike'    => 'mike@chose.com',
  'Pierre'  => 'pierre@bidule.net'
);
 
// On envoie le même mail à tous les abonnés
// A chaque passage dans cette boucle $clé contient le nom de l'abonné et $valeur l'adresse email de l'abonné
// Initialisation du sujet du mail
$sujet='Joyeuses fêtes';
foreach ($liste AS $cle=>$valeur) {
  // Initialisation du contenu du mail
  $message="Bonjour ".$cle."!".PHP_EOL.PHP_EOL.
    "Le blog ANDEE vous souhaite de joyeuses fêtes de fin d'année!".PHP_EOL;
  // Cette fonction n'existe pas, c'est une hypothèse pour l'exemple
  envoyerUnMail($sujet, $message, $valeur);
}

Dans l’exemple ci-dessous, nous avons envoyé un mail personnalisé à tous les abonnés avec un seul code. Grâce à l’utilisation d’un tableau associatif nous avons réussi à écrire un code simple qui traite une liste d’abonnés et envoie un mail à chacun d’eux.

Les tableaux sont la solution pour traiter des informations en masse avec un code simple et réexploitable.

Maintenant que nous avons parcouru la plupart des types de variables, nous pourrons étudier à partir du prochain article les structures de contrôle et commencer à faire des choses concrètes.

Pointeurs et références

Publié le par jmch

Dans l’article précédent, nous avons défini ce qu’était une variable, une constante. Nous avons également introduit la notion de typage même présenté différents types de variables. Toutefois il existe encore d’autres types très importants en programmation et nous allons tâcher de les présenter dans cet article. Rappel sur les variables

Une variable c’est quoi?

Nous avons vu plus tôt qu’une variable représentait l’association entre un mot et une valeur. Nous avons vu également qu’une variable était définie par son type, qui va déterminer sa taille en octets et la manière de stocker et traiter les données contenues afin d’en interprêter la valeur.

Pour faire plus simple, une variable c’est donc un espace mémoire dédié au stockage d’une valeur auquel on associe un mot (ex: maVariable).

En C une variable se défini ainsi

/* On défini une variable nommée maVariable et on l'initialise avec la valeur 5 */
int maVariable=5;

En PHP une variable se défini ainsi

<?php
/* On défini une variable nommée $maVariable et on l'initialise avec la valeur 5 */
$maVariable=5;

En Javascript une variable se défini ainsi

/* On défini une variable nommée maVar et on l'initialise avec la valeur 5 */
var maVariable=5;

En Perl une variable se défini ainsi

# On définit une variable nommée maVariable et on l'initialise avec la valeur 5
my $maVariable=5;

Notez qu’il est important de toujours initialiser (attribuer une valeur) ses variables. Si vous ne le faîtes pas, vous pouvez vous retrouver avec des variables contenant des valeurs inconnues et non maîtrisées qui peuvent planter votre programme.

Un pointeur c’est quoi?

Un pointeur, c’est une variable qui va contenir en guise de valeur, l’adresse d’une autre variable. Par exemple:

En C un pointeur se défini comme suit:
/* On défini un pointeur nommé monPointeur et on le fait pointer vers l'adresse (adresse mémoire) d'une variable. */
int *monPointeur=&maVariable;

Le symbole & indique au compileur que nous ne voulons pas la valeur de la variable (soit 5) mais l’adresse mémoire à laquelle il a rangé cette valeur. Ainsi l’affichage de &maVariable pourrait donner 0x12aec345. (Correspond à une adresse mémoire en 32 bits)

Le symbole * précise que nous ne demandons pas la création d’une variable de type int, mais bien d’un pointeur dont l’adresse de destination va contenir une valeur de type int.

Quel est l’intérêt des pointeurs?

En C les pointeurs sont très utilisés pour donner aux fonctions (que nous étudierons plus tard) l’accès à de grosses quantités de données rapidement. il faut savoir que lorsqu’on appelle une fonction avec en paramètres des variables, nous ne donnons qu’une copie des valeurs contenues dans ces variables à la fonction. Elle ne peut que les utiliser pour faire des calculs ou d’autres copies, mais en aucun cas les modifier. C’est là qu’interviennent les pointeurs.

/* Illustration en C */
/* Dans ma variable Big, je stocke 1Go de données dans un type imaginaire */
monGrosType Big="1 Go de données";
 
/* Si je dois la donner en paramètre d'une fonction */
maFonction(Big);
 
/* le système va d'abord réaliser une copie locale de Big et donc consommer 1Go de mémoire en plus alors que ce n'est pas utile et en prime, il va consommer du temps processeur le temps de copier les 1Go de données. */

En résumé, nous perdons beaucoup de temps et beaucoup de mémoire pour une opération aussi anodine que l’exécution d’une fonction. Soit quelque chose qui ne devrait pas prendre plus de quelques millisecondes sur un système moderne. Imaginez un peu sur les jeux vidéos moderne la perte de temps que cela représenterai si le système copiait 1Go de donnée à chaque fois qu’un objet se déplace à l’écran en perdant plusieurs secondes. On serait loin des performances connues aujourd’hui.

/* Le même exemple avec un pointeur */
/* P_Big contient la position en mémoire du contenu de la variable Big */
monGrosType *P_Big=&Big;
 
/* Ici ma fonction est prévue pour travailller avec un pointeur */
maFonction(P_Big);
 
/* Elle récupère donc l'adresse contenu dans P_Big soit 4 octets en 32 bits et 8 octets en 64 bits. */

Vous admettrez qu’entre 8 octets max et 1Go la différence est toute faîte. Nous gagnons ici un temps processeur précieux et une quantité de mémoire non négligeable.

Les pointeurs sont spécifiques aux langages C et C++. Dans d’autres langages, on parle de référence, mais attention! Même si on retrouve quelques similarité, il ne s’agit pas de la même chose. Bien d’autres usages spécifiques sont réservés aux pointeurs, nous n’avons vu ici que la base.

Une référence c’est quoi?

Une référence est un type de variable qui partage quelques similarités avec les pointeurs, mais qui ne sont pas des pointeurs.

En PHP

<?php
/* Initialise le contenu de $maVariable avec "Beaucoup de blabla" */
$maVariable = "Beaucoup de blabla";
echo $maVariable; // Affichera: Beaucoup de blabla
 
/* Initialise le contenu de $bobVariable avec une copie du contenu de $maVariable */
$bobVariable = $maVariable;
 
echo $bobVariable; // Affichera: Beaucoup de blabla
 
/* Modifie le contenu de $bobVariable */
$bobVariable = "Coucou c'est Bob!";
 
echo $bobVariable; // Affichera: Coucou c'est Bob!
echo $maVariable; // Affichera encore: Beaucoup de blabla
 
/* Initialise le contenu de $totoVariable avec une référence vers $maVariable */
$totoVariable = &$maVariable;
 
echo $totoVariable; // Affichera: Beaucoup de blabla
 
/* Modifie le contenu référencé par $totoVariable */
$totoVariable = "Coucou c'est Toto!";
 
echo $totoVariable; // Affichera: Coucou c'est Toto!
echo $maVariable; // Affichera cette fois: Coucou c'est Toto!
?>

Nous constatons

  • Que lorsqu’on modifie le contenu copié depuis une autre variable, cela n’affecte que le contenu de la copie, l’original reste intact.
  • Que lorsqu’on modifie le contenu référencé depuis autre variable, cela affecte le contenu de l’original car il n’y a pas création d’une copie. La zone mémoire pointée par $totoVariable est donc la même que $maVariable.
  • Qu’en PHP une référence vers une variable se fait en faisant précéder la variable d’un et commercial ‘&’

En Javascript

// Initialise le contenu de maVar avec Beaucoup de blabla
var maVar = 'Beaucoup de blabla';
 
console.log(maVar); // Affiche: Beaucoup de blabla
 
// Initialise le contenu de $bobVar avec une copie de la valeur de maVar
var bobVar = maVar;
 
console.log(bobVar); // Affiche: Beaucoup de blabla
 
// Modifie le contenu de la variable bobVar avec Salut c'est Bob
bobVar = 'Salut, c\'est Bob!';
 
console.log(bobVar); // Affiche: Salut, c'est bob!
console.log(maVar); // Affiche: Beaucoup de blabla
 
/* Sur un objet à présent les choses diffèrent */
// Initialisation d'un objet vide
var monObj={};
// Initialisation de la propriété contenu avec Beaucoup de blabla
monObj.contenu = 'Beaucoup de blabla';
 
console.log(monObj.contenu); // Affiche: Beaucoup de blabla
 
// Initialisation de l'objet bobObj avec une copie de monObj
var bobObj = monObj;
 
console.log(bobObj.contenu); // Affiche: Beaucoup de blabla
 
// Modification du contenu référencé dans la copie de l'objet
bobObj.contenu = 'Salut c\'est bob!';
 
console.log(bobObj.contenu); // Affiche: Salut, c'est bob!
 
console.log(monObj.contenu); // Affiche: Salut, c'est bob!

Nous constatons

  • Que le contenu d’une variable simple est copié mais que les éléments contenus dans les objets sont des références. La zone mémoire pointée par monObj.contenu et bobObj.contenu est donc la même.

En Perl

# Initialise le contenu de $maVar avec Beaucoup de blabla
my $maVar = 'Beaucoup de blabla';
 
# Initialise le contenu de la variable $bobVar avec le contenu de la variable $maVar
my $bobVar = $maVar;
 
print $bobVar."\n"; # Affiche: Beaucoup de blabla
 
# Modification du contenu de la variable $bobVar
$bobVar = "Salut c'est Bob!";
 
print $bobVar."\n"; # Affiche: Salut c'est Bob
 
print $maVar."\n"; # Affiche: Beaucoup de blabla
 
# Initialise le contenu de la variable $totoVar avec une référence vers le contenu de $maVar
my $totoVar = \$maVar;
 
print $$totoVar."\n"; # Affiche: Beaucoup de blabla
 
# Modifie le contenu référencé par $totoVar
$$totoVar = "Salut c'est Toto!";
 
print $$totoVar."\n"; #Affiche: Salut c'est Toto!
 
print $maVar."\n"; #Affiche: Salut c'est Toto!

Nous constatons

  • Que lorsqu’on modifie le contenu copié depuis une autre variable, cela n’affect que le contenu de la copie, l’original reste intact.
  • Que lorsqu’on modifie le contenu référencé depuis une autre variable, cela affecte le contenu de l’original car il n’y a pas création d’une copie.
  • La zone mémoire piontée par $totoVar est donc la même que $maVar.
  • Qu’en Perl les références sont appelée en faisant précéder le nom de la variable par un antislash ‘\’
  • Qu’en Perl le contenu pointé par une référence s’appelle en faisant précéder le nom de la variable contenant une copie de la référence par un dollar ‘$’

En conclusion de cet article, nous avons étudié les pointeurs qui sont propres en C et les références que vous pouvez retrouver dans de nombreux langages. Les références sont très utilisées dans le monde de la programmation car elles permettent de travailler sur des quantités de données très grandes sans avoir à copier systématiquement des contenus économisant ainsi du temps processeur et de la mémoire. Leur utilisation va bien au delà de ce qui est décrit dans cet article bien entendu, mais il s’agit ici de bases de programmation.

Dans le prochain article nous allons parler des énumérations et des variables tableaux qui sont très utiles en programmation. En attendant, je vous laisse avec un peu de lecture.

Liens et références

Les variables

Publié le par jmch

Introduction et commentaires

Dans cette série d’articles nous allons voir des bases de programmation. Il est recommandé d’avoir consulté au préalable l’article traitant des données numériques. Les sujets traités seront les variables (types, constantes, tableaux, les pointeurs ou références), les structures de contrôle (boucle, switch, conditions) et les fonctions (déclaration, utilisation). Au delà, les détails propres à chaque langages seront traités dans des articles dédiés à chacun d’entre eux.

Les différents langages traités ici, ne pas du même niveau. En effet, le langage C est un langage bas niveau qui doit être compilé (comprendre transformé) en instruction machine lui donnant ainsi une rapidité d’exécution sans pareil. Les autres langages (Perl, PHP et Javascript) sont pour leur part des langages dits de haut niveau. Chacune de leur instruction est interprété par un programme appelé interpréteur qui peut être au choix, votre navigateur web pour javascript, ou un programme spécifique au langage dans les cas du Perl et de PHP.

Pour information dans les parties code définies comme ci-dessous, vous trouverez des commentaires aidant à la bonne compréhension des codes. Il seront représentés comme suit:

// Ceci est un commentaire (Javascript, PHP, C)
 
/* Il s'agit également d'un commentaire
* Pouvant être rédigé
* Sur plusieurs lignes (Javascript, PHP, C) */
 
# C'est un commentaire aussi (Perl, Shell)

Les commentaires sont des chaînes de caractères (mots, phrases) insérés dans du code de manière à ne pas être interprété. Ils n’ont de valeur que pour les programmeurs, lecteurs du code. Un commentaire n’influencera pas le déroulement d’un programme. Il pourra par contre aider un programmeur reprenant le code d’un autre.

Présentation des variables

En programmation, on appelle variable l’association entre un mot clé (nom de variable) et une (ou plusieurs) valeur pouvant être modifiée au fur et à mesure du déroulement du programme.

Pour ceux qui se sentent déjà perdus, voici un exemple simple en PHP.

<?php
// En PHP les noms variables doivent être précédés du symbole $
// Je renseigne ici ma variable $nomprenom avec un nouveau contenu
$nomprenom='Henry Dupont';
 
// J'utilise ici le contenu de cette variable
// La fonction echo permet d'afficher du texte et le contenu (ASCII, affichable) de certaines variables simples
echo "Salutations $nomprenom";
?>

Le code ci-dessus affichera: Salutations Henry Dupont

Si la valeur de la variable $nomprenom venait à être modifié, le même morceau de code affichera le nouveau contenu de $nomprenom.

Cela pourrait permettre par exemple de créer des salutations pour une liste de prénom-nom sans avoir à réécrire le code pour chaque cas de figure.

Une variable peut avoir un contenu bien plus complexe qu’un simple texte et c’est ce que nous allons voir ci-dessous.

Les constantes

En opposition avec les variables, on trouve les constantes qui, comme leur nom l’indique ont un contenu qui ne change pas.

Par exemple, PI est une constante, sa valeur ne changera pas au cours de l’exécution d’un programme. (en tout cas pas sans remettre en cause un certain nombre de choses)

Exemple en Javascript

// Définition de la constante PI
const PI=3.14159265359;
 
// Définition de la variable r (pour rayon)
r=12;
 
// Utilisation de la constante PI avec la variable r
console.log('Circonférence d’un cercle de rayon r: ' + r + '=' + (2*PI*r);

L’exemple ci-dessus affichera: Circonférence d’un cercle de rayon r: 12 = 75.39822368616001

Exemple en PHP

<?php
// Définition de la constante PI
define("PI", 3.14159265359);
 
// Définition de la variable r (pour rayon)
$r=12;
 
// Utilisation de la constante PI avec la variable r
echo "Circonférence d’un cercle de rayon r: $r = ".(2*PI*$r);
?>

L’exemple ci-dessus affichera: Circonférence d’un cercle de rayon r: 12 = 75,39822368616

Exemple en C

#include <stdio.h>
#include <stdlib.h>
 
/* Pour compiler ce code source:
*       gcc constante.c -o constante.exe
* Pour éxécuter ce programme une fois compilé ./constante.exe (sous UNIX/Linux) ou constante.exe (sous Windows)
*/
 
/* Définition de la constante PI */
#define PI 3.14159265359
 
int main(void) {
        /* Définition de la variable r (pour rayon)
        short int r=12;
        /* Utilisation de la constante PI */
        printf("Circonférence d’un cercle de rayon r: %d = %f\n", r, (float) (2*PI*r));
 
        return EXIT_SUCCESS;
}

L’exemple ci-dessus affichera une fois compilé et éxécuté: Circonférence d’un cercle de rayon r: 12 = 75.398224

Exemple en Perl

#!/usr/bin/perl
 
use strict;
use warnings;
# Définition de la constante PI
use constant PI => 3.14159265359;
 
# En Perl, comme en PHP les noms de variable doivent être précédés du symbole $
# Définition de la variable r (pour rayon)
my $r=12;
 
# Utilisation de la constante PI avec la variable r
print "Circonférence d'un cercle de rayon r: $r = ".(2*PI*$r)."\n";

L’exemple ci-dessus affichera une fois exécuté: Circonférence d’un cercle de rayon r: 12 = 75.39822368616

Pour une constante il est important que quelqu’un ne puisse pas faire quelque chose comme ça: PI=8.53!!! C’est pour cela que les constantes sont en général définies d’une manière différente des variables.

Typage

Le typage correspond à la définition du type des données à stocker. Il existe différents niveaux de typage dépendants du langage utilisé.

Par exemple on parlera de typage statique un langage bas niveau comme C où le programmeur doit définir à l’avance (début de fonction ou de programme) le type de données qui sera stocké dans la variable (char, int, cf: Article sur les données numériques). Au contraire on parlera plutôt de typage dynamique pour des langages de plus haut niveau (PHP par exemple) qui ne demanderont pas au programmeur de définir à l’avance ses variables ni de spécifier le type des données qui seront stockées.

3 est un nombre. Nombre est un type.

3.1415 est un nombre à virgule. Nombre à virgule est un type.

C est une lettre. Lettre est également un type.

Bonjour est un mot. Mot est aussi un type (en fonction des langages).

-8 est un nombre négatif. Nombre négatif a lui aussi un type pour le représenter.

Déclarez vos variables

Dans l’oeuvre de Douglas Adams Le guide du voyageur intergalactique il est dit que la réponse à la Grande Question sur la Vie, l’Univers et le Reste est 42. Essayons de rentrer le nombre 42 dans une variable et ceci dans différents langages.

En C (typage statique)

 
/* On précise un type numérique adapté */
short int reponse=42;
/* On pourrait également utiliser un type plus large */
int reponse=42;
/* Ou encore plus petit car le nombre est inférieur à 127 */
/* Attention! Dans ce cas de figure le nombre n'est pas stocké sous forme de caractère mais bien sous sa forme numérique */
/* Ce qui donne en hexadécimal: 2A */
/* Le caractère ASCII associé à 2A est * ce qui vous vous en doutez n'a rien à voir avec le contenu que nous venons d'entrer dans cette variable */
char reponse=42;
/* Ici il sera stocké sous forme d'une chaîne de caractère ASCII soit 2 caractères de 8 bits chacun */
/* Soit en hexadécimal:  34 32 */
/* N'étant pas de type numérique, il sera alors impossible de l'utiliser dans des calculs en l'état. */
char reponse[]="42";
/* B est un caractère donc de type char et sera stocké avec son code ASCII : 42 */
char lettre='B';
/* Bonjour est un mot, en C un mot est un tableau de caractères (appelé aussi string)
* Ce tableau (que nous verrons plus en détails dans un autre article) contiendra respectivement les codes ASCII des lettres
* B o n j o u r soit 42 6F 6E 6A  6F 75 72 */
char mot[]="Bonjour";

Le langage C est très précis et propose de nombreux types de données pour définir les variables.

En PHP (typage dynamique)

<?php
/* PHP déterminera qu'il s'agit d'un numérique et adaptera le type de la variable en conséquence */
$reponse=42;
 
// Affiche integer ce qui correspond à un entier
echo gettype($reponse)
 
/* Si 42 est entouré de double quotes, PHP l’interprétera alors comme une chaîne de caractères, c'est une forme de typage en PHP */
$reponse="42";
// Affiche string ce qui correspond à une chaîne de caractères
echo gettype($reponse)
 
// Toutefois, si on utilise $reponse défini avec les doubles quotes dans un calcul, celui-ci sera alors interprété comme un nombre */
echo ($reponse + $reponse);    // Affichera 84
?>

En Perl (typage dynamique)

/* Perl détermine qu'il s'agit d'une valeur numérique */
my $reponse=42;
 
/* Perl détermine qu'il s'agit d'une chaîne de caractères */
my $reponse="42";
 
// Comme en PHP, utiliser $reponse défini comme une chaîne de caractère dans un calcul interprétera ce dernier comme un nombre.
print ($reponse + $reponse);    # Affichera 84

Enfin le cas particulier du Javascript

/* Javascript détermine qu'il s'agit d'une valeur numérique */
var reponse=42;
console.log(typeof(reponse));    // Affichera number
 
/* Javascript détermine qu'il s'agit d'une chaîne de caractères */
my $reponse="42";
console.log(typeof(reponse));    // Affichera string
 
// A la différence de Perl de PHP, Javascript traitera un string en tant que tel, même dans un calcul
console.log((reponse + reponse));    // Affichera 4242, on parle alors de concaténation (à suivre dans un autre article)

Les signes

Le mot clé unsigned permet de préciser que le type n’est pas signé et ne pourra contenir par conséquent que des valeurs positives allant de 0 à 2x (où x vaut le nombre de bits du type). Un type signé permet lui de contenir des valeurs négatives comme positives allant de -2(x-1) à 2(x-1)-1. Pourquoi la valeur positive est diminuée de 1? C’est simple, la valeur 0 est une valeur qu’il faut prendre en compte dans nos calculs car elle existe bien.

Par exemple, un type unsigned char permet de coder des valeurs allant de 0 à 255 soit 256 valeurs. Dans le cas d’un char signé, on ne peut coder que de 256 valeurs également allant de -128 à 127 ce qui nous fait bien 256 valeurs en comptabilisant le 0. Le signe du nombre contenu utilise 1 bit dont la valeur est soit à 0 indiquant que le nombre est positif, soit à 1 indiquant que le nombre est négatif. Pour mieux comprendre, voici un petit exemple utilisant deux signed char de même valeur avec avec un signe différent. Attention! Cet exemple ne tient pas compte de l’architecture endianness un PC ne codera pas la valeur comme dans l’exemple ci-dessous, mais plutôt 111010012 soit e916 (l’ordre des bits est inversé).

Positions des bitsSIGNE0123456
Valeur binaire de 2300010111
Valeur hexa de 2317
Positions des bitsSIGNE0123456
Valeur binaire de -2310010111
Valeur hexa de -2397

Les flottants

Voici un type dédié au stockage des nombre décimaux.

En C il existe plusieurs types de flottant

/* Le flottant à précision simple */
float valeur=12.75;
/* Le flottant à précision double */
double valeur=3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;

Voici comment les données sont rangées en fonction du type. Une fois encore, ce schéma ne tient pas compte de l’architecture. Garder une lecture de gauche à droite permet de simplifier la présentation de ces types plus complexes..

Le type float

Positions des bits012345678910111213141516171819202122232425262728293031
Répartition des valeursSigne
+ ou –		Exposant
×10puissance y		Fraction
314159265358979323846264338327950288419716939937510582097494459230781640628620899

Le type double

Positions des bits0123456789101112131415…60616263
Répartition des valeursSigne
+ ou –		Exposant
×10puissance y		Fraction
314159265358979323846264338327950288419716939937510582097494459230781640628620899

Les autres langages traités ici (Perl, Javascript et PHP) ne feront pas de différence. Javascript nous répondra number quoi qu’il arrive, PHP stockera décrétera qu’il s’agit d’un double que nous souhaitions stocker 2.75 ou un nombre avec 50 décimales.

Nous venons de balayer dans cet article les variables simples avec la plupart des types de base utilisés en programmation. Il en existe d’autres plus complexes et plus spécifique dont nous étudierons (pour certain) les détails dans d’autres articles à venir.

Liens et références

En attendant le prochain article, si vous souhaitez vous documenter un peu sur le sujet, voici quelques liens intéressants:

Ma documentation préférée reste celle du PHP que je trouve particulièrement bien présentée et facile à comprendre. Pour le reste, je vous souhaite une bonne lecture.