Exemples de contextes où on trouve des suites d'instructions?
Un algorithme est une suite finie et non ambiguë d’opérations ou d'instructions permettant de résoudre un problème ou d'obtenir un résultat.
var compteur;
varpour déclarer une variable
;(optionnel) pour terminer une instruction
// type Number
var compteur = 10;
// type String
var libelle = 'Nombre de slides restantes';
// absence de valeur
var YaRienIci = null;
=pour valoriser ou affecter une variable
10un nombre seul vaut sa valeur.
'texte'les "single quotes" ouvrent et ferment une chaîne de caractère.
var x = 9;
var y = 2;
var somme = x + y;
var debutQuestion = 'Quelle est la valeur de ';
var variable = 'somme';
var pointDInterrogation = ' ?';
var question = debutQuestion + variable + pointDInterrogation;
var a = '32';
var b = '10';
var c = a + b;
var a = 32;
var b = '10';
var c = a + b;
Algorithmiquement c'est une erreur d'écriture.
En JavaScript la valeur sera '3210'.
=> Conversion automatique du String en Number.
var a = 32;
var b = 10;
var c = a * b;
var a = 32;
var b = '10';
var c = a * b;
Algorithmiquement c'est une erreur d'écriture.
En JavaScript la valeur sera 320.
=> Conversion automatique du Number en String.
Une fonction est une suite finie et non ambiguë d’opérations ou d'instructions permettant de résoudre un problème ou d'obtenir un résultat.
// cet algorithme met un nombre au carré, puis ajoute 3 au total.
var unNombre = 2;
unNombre = auCarre(unNombre);
var resultat = additionne(unNombre, 3);
nomDeLaFonction()pour appeler une fonction
nomDeLaFonction(variable1, variable2)pour donner une ou des valeurs en entrée à la fonction
function neRienFaire() {
// instructions ici, mais là il n'y en a pas :'(
}
functionpour déclarer une function
()pour déclarer les paramètres
{}
pour déclarer les instructions (Corps de la fonction)
function retourne42(){
return 42;
}
function auCarre(unNombre){
return unNombre * unNombre;
}
function additionne(a, b){
return a + b;
}
,pour séparer les paramètres d'entrées
returnpour renvoyer le résultat de la fonction
function auCarre(unNombre){
return unNombre * unNombre;
}
function additionne(a, b){
return a + b;
}
var unNombre = 2;
unNombre = auCarre(unNombre);
var resultat = additionne(unNombre, 3);
var resultat = aireDuCercle(12);
var corpsDeLaQuestion = "la capitale de la France";
var resultat = interroger(corpsDeLaQuestion);
"Quelle est [corps de la question] ?".
// En reprenant les fonctions des exercices 1 et 2
var resultat = interroger("l'aire d'un cercle de rayon 1") + aireDuCercle(1);
function auCarre(unNombre){
return unNombre * unNombre;
}
var resultat = auCarre(auCarre(2));
function auCarre(unNombre){
return unNombre * unNombre;
}
var resultat = auCarre(auCarre(2));
La condition permet d'exécuter ou non une partie du traitement en fonction d'une comparaison logique.
var unNombre = 40;
var resultat = 'Je compare un nombre à 42';
if (unNombre < 42) {
resultat = 'Le nombre est plus petit que 42';
}
if"Si" pour déclarer un traitement conditionnel (la condition est respecté)
{}
pour déclarer la liste d'instructions conditionnées
var unNombre = 40;
var resultat;
if (unNombre < 42) {
resultat = 'Le nombre est plus petit que 42';
} else {
resultat = 'Le nombre est plus grand ou égale à 42';
}
else"Sinon" pour déclarer un traitement conditionnel inverse (la condition n'est pas respecté)
var unNombre = 40;
var resultat;
if (unNombre < 42) {
resultat = 'Le nombre est plus petit que 42';
} else if (unNombre > 42) {
resultat = 'Le nombre est plus grand à 42';
} else {
resultat = 'Le nombre est égal à 42';
}
else if"Sinonsi" pour déclarer un traitement conditionnel
var a = 1;
var b = 2;
if (a < b) { /* si a est plus petit que b */ }
if (a > b) { /* si a est plus grand que b */ }
if (a <= b) { /* si a est plus petit ou égal à b */ }
if (a >= b) { /* si a est plus grand ou égal à b */ }
if (a == b) { /* si a est égal à b */ }
if (a === b) { /* si a est strictement égal à b */ }
if (a != b) { /* si a est différent de b */ }
if (a !== b) { /* si a est strictement différent de b */ }
if (1 == '1' ) { /* vrai */ }
if (1 === '1') { /* FAUX */ }
if (1 === 1 ) { /* vrai */ }
if ('1' === '1') { /* vrai */ }
if (1 != '1' ) { /* faux */ }
if (1 !== '1') { /* vrai */ }
if (1 !== 1 ) { /* faux */ }
if ('1' !== '1') { /* faux */ }
function nameMe(nombre1, nombre2) {
if (nombre1 < nombre2) {
return nombre1;
} else {
return nombre2;
}
}
function plusGrand(nombre1, nombre2) {
if (nombre1 ??? nombre2) {
return nombre1;
}
return nombre2;
}
Quels sont les 2 opérateurs possible pour remplacer "???" de telle sorte que "plusGrand" retourne le plus grand des 2 nombres ?
Astuce : une fonction est immédiatement interrompue lorsqu'une instruction "return" est atteinte.
function estPositif(unNombre) {
// ?
}
Ecrire la fonction "estPositif" tel que la fonction retourne 'vrai', 'faux' ou 'zéro' selon que unNombre soit positif, négatif ou 0.
Un programme informatique peut recevoir une ou plusieurs entrées, et produire une ou plusieurs sorties.
Il peut y avoir des entrées initiales : les paramètres du programme.
Il peut y avoir plusieurs entrées en cours d'exécutions (ex: saisie d'une valeur au clavier, clic souris).
// demande à l'utilisateur de saisir une valeur
var nom = prompt("Quel est votre nom ?");
Il peut y avoir une sortie finale.
Il peut y avoir plusieurs sorties en cours d'exécutions (ex: affichage à l'écran d'une valeur).
// affiche une valeur dans la console.
console.log(nom);
La console est un outils d'interaction, très utilisé pendant les phases de programmation.
.a une signification qu'on verra ultérieurement, considérer l'ensemble comme une fonction nommée
console.log.
Une fonction est un sous programme qui se comporte de la même façon qu'une programme.
// entrée initiale : le titre
function lireEtAfficherUnNom(titre) {
var nom = prompt("Quel est votre nom ?"); // entrée en cours d'exécution
var resultat = titre + ' ' + nom;
console.log(resultat); // sortie en cours d'exécution
console.log('Et voilà une autre sortie !'); // 2eme sortie en cours d'exécution
return resultat; // sortie finale
}
Une boucle est une structure algorithmique qui permet d'exécuter de manière répétée une même suite d'instructions.
var compteur = 0;
var somme = 0;
while (compteur < 5) {
compteur = compteur + 1;
somme = somme + compteur;
}
while"Tant que" pour déclarer un traitement qui doit s'exécuter en boucle, tant que la condition n'est pas rencontrée.
{}
Déclare la liste d'instruction à exécuter en boucle
var somme = 0;
for (var compteur = 0; compteur < 5; compteur++) {
somme = somme + compteur;
}
forLa boucle "for" permet d'exécuter un nombre déterminé d'itérations.
var compteur = 0; compteur < 5; compteur++Initialise une variable, spécifie une condition de fin, specifie une instruction de suite.
{}
Déclare la liste d'instruction à exécuter en boucle
for (var compteur = 8; compteur >= 2; compteur--) {
console.log(compteur);
}
var vrai = true;
var faux = false;
var vraiETvrai = vrai && vrai; // true
var vraiETfaux = vrai && faux; // false
var fauxETvrai = faux && vrai; // false
var fauxETfaux = faux && faux; // false
var vraiOUvrai = vrai || vrai; // true
var vraiOUfaux = vrai || faux; // true
var fauxOUvrai = faux || vrai; // true
var fauxOUfaux = faux || faux; // false
var reponse = 42;
var test1 = reponse > 0;
var test2 = reponse < 10;
var test1et2 = test1 && test2; // opérateur ET logique
var cestPasFaux = !false; // true
var cestPasVrai = !true; // false
var tableauDeChaines = ['l', 'm', 'n', 'o', 'p']; // déclare un tableau
console.log(tableauDeChaines[0]);
var tableauDEntiers = [0, 1, 2, 3];
console.log(tableauDEntiers[0]);
var tableauMixte = [2, 'b', tableauDeChaines];
console.log(tableauMixte[2][0]);
var tableauDeCaracteres = 'Et oui une chaine de caractère se comporte parfois comme un tableau !';
console.log(tableauDeCaracteres[tableauDeCaracteres.length - 1]);
// ça veut dire que var ['l', 'm', 'n', 'o', 'p'] === 'lmnop' ? Presque…
// création
var tab = [];
// ajouter un élément
tab.push('un élément');
tab.push('un autre élément', 'et encore un autre');
// lire un élément par son indice
console.log(tab[1]); // affiche le 2eme élément du tableau
// modifier un élément du tableau
tab[1] = 'nouvelle valeur';
// connaitre la longueur
console.log('Ce tableaux contient ' + tab.length + ' éléments.');
// supprimer un élément
tab.splice(0, 1); // supprime 1 élément à partir de l'indice 0
console.log(tab[1]); // le 2eme élément du tableau n'est plus le même
console.log(tab); // affiche le tableau en entier
var tab = [1, 2, 3, 4, 5];
for (var indice = 0; indice < tab.length; indice++) {
console.log(tab[indice]);
}
var tab1 = [1, 2, 3];
var tab2 = ['a', 'b', 'c'];
var resultat = [];
for (var iTab1 = 0; iTab1 < tab.length; iTab1++) {
for (var iTab2 = 0; iTab2 < tab2.length; iTab2++) {
resultat.push(tab2[iTab2] + String(tab[iTab1]))
}
}
function plusQue7(tab) {
var indice = 0;
while(tab[indice] <= 7 && indice < tab.length)
indice++;
}
if (indice >= tab.length) {
return -1;
}
// else {
return indice;
// }
}
var resultat = plusQue7([1, 5, 12, 6, 7]);
var chaine = "1-2-3-4-56";
var tab = chaine.split('-'); // [1, 2, 3, 4, 56]
var presentation = 'Je suis ';
// objet anonyme, on le créée en ouvrant un accolade à l'emplacement d'une valeur
// (ex: ici à droite d'une affectation).
var unProfesseur = {
// propriété "nom"
nom: 'Samuel Bouchet',
// méthode "seNommer"
seNommer: function() {
// "presentation" ne fait pas partie de l'objet mais est visible dans le contexte
// "nom" fait partie de l'objet, on y accède avec le mot clé "this"
return presentation + this.nom
}
};
console.log(unProfesseur.seNommer());
// objet qui regroupe une chaîne de caractère, un nombre, un tableau, des méthodes.
var unProfesseur = {
nom: 'Samuel Bouchet',
age: 30,
matieres: ['Algorithmique', 'Jeu Vidéo'],
passerUneAnnee: function() {
this.age ++;;
},
construireDescription: function() {
return this.nom + ' a ' + this.age + ' ans' +
' et enseigne : ' + this.matieres.join(', ');
}
};
console.log(unProfesseur.construireDescription());
unProfesseur.passerUneAnnee();
console.log(unProfesseur.construireDescription());
var magicien = {
mana: 10,
lancerUnSort(coutDuSort) {
this.mana = this.mana - coutDuSort;
}
}
magicien.lancerUnSort(4);
console.log(magicien.mana);
magicien.lancerUnSort(8);
console.log(magicien.mana);
var magicien = {
mana: 10,
// retourne vrai si le sort a été lancé, sinon false
lancerUnSort(coutDuSort) {
this.mana = this.mana - coutDuSort;
return true;
}
}
var sortOk = magicien.lancerUnSort(4);
console.log(sortOk); // doit être "true"
console.log(magicien.mana); // doit valoir 6
sortOk = magicien.lancerUnSort(8);
console.log(sortOk); // doit être "false"
console.log(magicien.mana); // doit valoir 6
var magicien = {
mana: 10,
lancerUnSort(sort) {
this.mana = this.mana - sort.coutEnMana;
}
}
var teleportation = {} // compléter à l'intérieur des {}
var soin = {} // compléter à l'intérieur des {}
magicien.lancerUnSort(teleportation);
magicien.lancerUnSort(soin);
console.log(magicien.mana);
class LanceurDeSort {
constructor(manaInitial) {
this.mana = manaInitial;
}
lancerUnSort(coutEnMana) {
this.mana = this.mana - coutEnMana;
}
}
var magicien = new LanceurDeSort(8); // nouvelle instance de la classe
magicien.lancerUnSort(1);
class LanceurDeSort {
constructor(manaInitial) {
this.mana = manaInitial;
}
lancerUnSort(coutEnMana) {
this.mana = this.mana - coutEnMana;
}
}
var magicien = new LanceurDeSort(8); // new NomDeLaClass(param1, params2)
console.log(typeof(magicien)); // object
console.log(magicien instanceof LanceurDeSort); // vrai
console.log(magicien instanceof String); // faux
class LanceurDeSort {
constructor(manaInitial) {
this.mana = manaInitial;
}
lancerUnSort(sort) {
sort.lancer();
this.mana = this.mana - sort.coutEnMana;
}
}
var teleportation = new Sortilege(3);
var soin = new Sortilege(2);
var magicien = new LanceurDeSort(10);
magicien.lancerUnSort(teleportation);
magicien.lancerUnSort(soin);