En JS (ce qui se vérifie dans la plupart des langages de programmation), pour nommer les variables on utilise:
/*Déclaration des variables
---------------------------------*/
var valeur; //déclaration simple
var 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; //la valeur systè
/*Déclaration
----------------*/
var valeur;
/*Affectation externe de la variable valeur
------------------------------------------*/
valeur=window.prompt("Entrer une valeur","--ici---");
Démo
console.log(nomUtil);
var 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
var 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
var t1;
console.log(t1);
console.log(t2);
Nous utiliserons la méthode write() de l'objet document.
On utilise les guillemets, les quotes ou l'accent grave pour délimiter une chaîne de caractères.
Pour cette méthode la virgule sépare les paramètres, l'opérateur "+" concatène et le caractère "\" permet d'échapper un caractère.
Un caractère d'échappement permet d'empêcher qu'un caractère réservé du langage soit interprété.
On peut y intégrer des balises html et du code css.
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
var 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
var 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}.
L'accent grave permet aussi d'écrire un document.write sur plusieurs lignes!
Démo
/*Déclaration
---------------*/
var 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
--------------*/
var 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
var 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
var carac,valascii;
carac="b";
valascii=carac.charCodeAt();
document.write("Equivalent ASCII de "+carac+" = "+valascii);
Démo
var valascii,carac;
valascii=98;
carac=String.fromCharCode(valascii);
document.write("Equivalent alphanumérique de "+valascii+" = "+carac);