En JS (ce qui se vérifie dans la plupart des langages de programmation), pour nommer les variables on utilisera ma méthode camelCase.
/*Déclaration des variables
---------------------------------*/
let valeur; //déclaration simple
let val1,val2,val3,val4; //déclaration multiple
/*Affectation des variables
--------------------------*/
val1=5; //un entier en B10
val1=5.4e-6; //un entier en B10 exprimé en exposant
val1=0x5A; //un entier en B16
val1=0b1101; //un entier en B2
val2=65.298; //un réel (virgule flottante)
val3="Agent D, le professeur Doofenshmirtz..."; //une chaîne
val4=true; //un booléen
valeur=null; //signifie une absence de valeur
/*Déclaration
----------------*/
let valeur;
/*Affectation externe de la variable valeur
------------------------------------------*/
valeur=window.prompt("Entrer une valeur","--ici---");
Démo
console.log(nomUtil);
let nomUtil; //Déclaration de nomUtil;
On constate qu'on a accès à la variable nomUtil avant sa déclaration!
Ceci démontre que, discrètement, l'interpréteur remonte la déclaration avent l'exécution du code.
Javascript est un langage faiblement typé.
Ce qui fait le type d'une variable est son contenu, une variable ne reçoit pas de type au moment de sa déclaration, celle-ci obtient son type de la valeur qui lui est affectée!
Une variable peut donc changer de type, il suffit pour cela de l'affecter avec une valeur du type désiré.
Une variable n'est pas typée lors de sa déclaration, elle reçoit le type de la valeur qui lui est affectée.
Démo
let t1,t2,t3,t4,t5,t6,t7,t8,t9;
t1=5;
t2="Super!";
t3=true;
t4=null;
//On affecte pas t5
t6=new Array();
t7=new Date();
t8=Symbol();
t9=function(){};
document.write(typeof t1+"<br>"+ typeof t2 +"<br>"+ typeof t3 +"<br>"+ typeof t4
+"<br>"+ typeof t5 +"<br>"+ typeof t6 +"<br>"+ typeof t7 +"<br>"+ typeof t8
+"<br>"+ typeoft9);
Il ne faut pas confondre une variable déclarée qui n'a pas encore été affectée et une variable non déclarée.
Lorsqu'une variable a été déclarée elle est accessible (selon sa portée!) en lecture ou écriture, elle a une référence (son dresse mémoire) même si elle n'a pas encore été affectée.
Par contre, une variable non déclarée n'existe tout simplement pas, sa référence n'existe pas, il n'existe aucune adresse correspondant à son nom mnémonique.
Démo
let t1;
console.log(t1);
console.log(t2);
Nous utiliserons la méthode write() de l'objet document.
Attention à l'aspect "bloquant" lors du chargement de la page!
En programmation web on préférera element.innerHTML=...;
Tout doit se trouver sur la même ligne, sans quoi la console renvoie une erreur!
Les guillemets permettent d'afficher des chaînes de caractères à l'écran.
Démo
document.write("Le prix s'oublie, la qualité reste!");
Les quotes permettent d'afficher des chaînes de caractères à l'écran.
Démo
document.write('Toujours balayer devant sa porte avant de balayer devant la porte des autres!');
Le caractère d'échappement \ pour empêcher l'interprétation d'un caractère réservé.
Démo
document.write("Avec son pseudo \"Super brol\" il en impose");
document.write("<br>");
document.write('Avec son pseudo "Super brol" il en impose');
document.write("<br>");
document.write("Avec son pseudo 'Super brol' il en impose");
document.write("<br>");
document.write("Avec son pseudo \\Super brol\\ il en impose");
La variable ne peut pas être prise entre les guillemets ou les quoutes.
Démo
let nomUtil = "Jean-François";
document.write("Bonjour ",nomUtil,"."); //Avec le séparateur de paramètres
document.write("<br>");
document.write("Bonjour "+nomUtil+"."); //Avec l'opérateur de concaténation
L'accent grave fonctionne exactement comme les guillemets et les quotes, à part...
Démo
let nomUtil = "Jean-François";
document.write(`Bonjour `,nomUtil,`.`);
document.write(`<br>`);
document.write(`Bonjour ${nomUtil}.`);
document.write(`<br>`);
document.write(`Bonjour
${nomUtil}.`); //... sur plusieurs lignes!
L'accent grave permet de déréférencer une variable au sein de la chaîne de caractères pour peu qu'on utilise la syntaxe ${nom_variable}, très pratique pour éviter les concaténations.
L'accent grave permet aussi d'écrire un document.write sur plusieurs lignes!
Démo
/*Déclaration
---------------*/
let valeur;
/*Affectation externe de la variable valeur
-------------------------------------------*/
valeur=window.prompt("Entrer une valeur","--ici---");
/*Affichage du contenu de la variable valeur
-------------------------------------------*/
document.write("Votre valeur:",valeur,".","<br>")
/*Avec l'échappement
-------------------------*/
document.write("Votre valeur \"personnelle\":",valeur,".","<br>");
/*Avec la concaténation
----------------------------*/
document.write("Votre valeur \"personnelle\":"+valeur+"."+"<br>");
/*Avec l'accent grave
----------------------------*/
document.write(`Votre valeur
"personnelle": ${valeur}.
<br>`);
Démo
/*Déclaration
--------------*/
let valeur;
/*Affectation externe de la variable valeur
------------------------------------------*/
valeur=window.prompt("Entrer une valeur","--ici---");
/*Affichage du type de la variable valeur
-----------------------------------------*/
document.write("Type de votre variable: ",typeof valeur);
Un accumulateur (ou décumulateur) est une variable permettant d'accumuler des valeurs.
Pour ce faire, et parce que l'affectation écrase le contenu d'une variable, la variable où l'on veut accumuler des valeurs doit être présente des 2 côtés du signe d'affectation
Démo
let res=0;
for(let i=1;i < 11; i++) {
res = res + i;
document.write("Contenu au tour "+i+": "+res+"<br>");
}
document.write("<br>Contenu final de res:",res,"<br>");
Démo
let carac,valascii;
carac="b";
valascii=carac.charCodeAt();
document.write("Equivalent ASCII de "+carac+" = "+valascii);
Démo
let valascii,carac;
valascii=98;
carac=String.fromCharCode(valascii);
document.write("Equivalent alphanumérique de "+valascii+" = "+carac);