Déclaration Js des variables. Variables, portées et levage de variables en JavaScript

Les variables sont un composant fondamental de nombreux langages de programmation ; ils constituent l'un des concepts les plus importants pour les nouveaux programmeurs. Il existe de nombreuses propriétés différentes des variables en JavaScript, ainsi que plusieurs règles à suivre pour les nommer. JavaScript dispose de trois mots-clés utilisés pour déclarer une variable : var, let et const, et chacun d'eux affecte la façon dont la variable sera interprétée dans le code.

Ce manuel vous présentera les variables, vous apprendra comment les déclarer et les nommer, et expliquera également la différence entre var, let et const. De plus, vous apprendrez ce qu'est le levage de variable et comment la portée affecte le comportement d'une variable.

Une variable est un élément de mémoire nommé utilisé pour stocker différentes valeurs. Une information qui peut être référencée plusieurs fois peut être stockée dans une variable pour une utilisation ou une modification ultérieure. En JavaScript, la valeur contenue dans une variable peut être n'importe quel type de données, notamment un nombre, une chaîne ou un objet.

Avant la spécification du langage ECMAScript 2015 (ES6), sur laquelle est basé JavaScript à l'heure actuelle, il n'y avait qu'une seule façon de déclarer une variable : en utilisant le mot-clé var. C'est pourquoi la plupart des anciens codes et manuels utilisent uniquement var pour déclarer les variables. Regardons les différences entre var, let et const.

Le mot-clé var vous permet de démontrer le concept de la variable elle-même. Dans l'exemple ci-dessous, nous déclarons une variable et lui attribuons une valeur.

// Attribue la valeur de chaîne 8host à l'identifiant du nom d'utilisateur
var nom d'utilisateur = "8host_blog" ;

Cette expression se compose de plusieurs parties :

• Déclaration d'une variable à l'aide du mot-clé var ;
• Nom de la variable (ou identifiant), nom d'utilisateur ;
• L'opérateur d'affectation représenté par la syntaxe =;
• La valeur attribuée est "8host_blog".

Vous pouvez maintenant utiliser la variable username dans votre code. JavaScript se souviendra que le nom d'utilisateur représente la valeur 8host_blog.

// Vérifiez si la variable est égale à la valeur
if (nom d'utilisateur === "8host_blog") (
console.log(true);
}
vrai

Comme mentionné précédemment, les variables peuvent être exprimées par n'importe quel type de données JavaScript. Dans cet exemple, les variables sont exprimées sous forme de chaîne, nombre, objet, booléen et null.

// Affectation de diverses variables
var nom = "Morty" ;
var spartiates = 300 ;
var kingdoms = [ "mammifères", "oiseaux", "poissons" ];
var poème = (roses : "rouges", violettes : "bleues" );
var succès = vrai ;
var rien = nul ;

En utilisant console.log, vous pouvez afficher la valeur de n'importe quelle variable :

// Envoie la variable Spartans à la console
console.log(spartiates);
300

Les variables stockent des données en mémoire qui peuvent ensuite être utilisées ou modifiées. Les variables peuvent également être réaffectées et recevoir une nouvelle valeur. L'exemple simple ci-dessous montre comment un mot de passe peut être stocké puis mis à jour dans une variable.

// Attribuer une valeur à la variable de mot de passe
var mot de passe = "chasseur2" ;
// Réaffecter la valeur de la variable avec une nouvelle valeur
mot de passe = "chasseur3" ;
console.log(mot de passe);
"chasseur3"

DANS vrai programme Le mot de passe sera très probablement stocké en toute sécurité dans une base de données. Cependant, cet exemple simple illustre une situation dans laquelle vous souhaiterez peut-être mettre à jour la valeur d'une variable. La valeur de la variable de mot de passe était hunter2, mais elle a reçu une nouvelle valeur, hunter3, et JavaScript utilisera désormais la nouvelle valeur.

En JavaScript, les noms de variables sont appelés identifiants. Plusieurs règles de dénomination des identifiants peuvent être trouvées dans le manuel. Les voici en bref :

• Les noms de variables ne peuvent contenir que des lettres, des chiffres (0 à 9), un signe dollar ($) et un trait de soulignement (_).
• Les noms de variables ne peuvent pas contenir de caractères d'espacement.
• Le nom de la variable ne doit pas commencer par un chiffre.
• Il existe plusieurs mots-clés réservés qui ne peuvent pas être utilisés comme noms de variables.
• Les noms de variables sont sensibles à la casse.

JavaScript a également une convention pour utiliser la casse camel dans les noms des fonctions et des variables déclarées avec var ou let. Dans ce cas, le premier mot est écrit en minuscule, et chaque mot suivant commence par une lettre majuscule (les mots sont écrits sans espaces entre eux). La plupart des variables qui ne sont pas constantes suivront cette convention, à quelques exceptions près. Les noms de variables qui sont des constantes (déclarées avec le mot-clé const) sont généralement écrits en majuscule.

Il semble qu'il existe de nombreuses règles, mais cela ne semble le cas qu'à première vue. En travaillant souvent avec JavaScript, vous vous en souviendrez rapidement.

JavaScript utilise trois mots-clés différents pour déclarer les variables, ce qui ajoute une couche supplémentaire de complexité. Ces mots-clés diffèrent par la portée variable, le levage et la réaffectation.

Vous vous demandez peut-être lequel des trois mots-clés vous devriez utiliser dans vos programmes. Il est courant d'utiliser const aussi souvent que possible, et de laisser entrer des boucles et des réaffectations. Généralement, var est utilisé dans le code existant.

La portée en JavaScript fait référence au contexte de code actuel, qui détermine si les variables sont accessibles. La zone peut être locale ou globale :

• Les variables globales sont celles qui sont déclarées en dehors du bloc.
• Les variables locales sont celles qui sont déclarées à l'intérieur d'un bloc.

Dans l'exemple ci-dessous, nous allons créer une variable globale.

var créature = "loup";

Vous savez que les variables peuvent être réaffectées. Dans la portée locale, vous pouvez créer de nouvelles variables portant le même nom que les variables de la portée externe sans modifier ni remplacer la valeur d'origine.

L'exemple ci-dessous crée une espèce variable globale. À l’intérieur de la fonction se trouve une variable locale du même nom. Lorsque vous les envoyez à la console, vous verrez que la valeur de la variable diffère selon la portée, mais la valeur d'origine ne change pas.

// Initialise une variable globale
var espèce = "humain";
fonction transformer() (
// Initialise une variable locale de portée fonction
var espèce = "loup-garou";
console.log(espèce);
}
// Enregistre les variables globales et locales
console.log(espèce);
transformer();
console.log(espèce);
humain
loup-garou
humain

Dans cet exemple, la variable locale a une portée au niveau de la fonction. Les variables déclarées avec le mot-clé var sont toujours dans cette portée (c'est-à-dire qu'elles reconnaissent les fonctions comme ayant une portée distincte). Une variable locale n'est donc pas accessible dans la portée globale.

Cependant, les mots-clés new let et const ont une portée au niveau du bloc. Cela signifie qu'une nouvelle zone locale est créée à partir de n'importe quel bloc, y compris les blocs fonctionnels, les instructions if et pour les boucles et pendant.

Pour illustrer la différence entre les variables au niveau de la fonction et au niveau du bloc, créez une nouvelle variable dans un bloc if à l'aide de let.

var fullMoon = vrai;
// Initialise une variable globale
soit espèce = « humain » ;
si (pleine Lune) (
// Initialise une variable de portée bloc
soit espèce = "loup-garou" ;

}


Ce n'est pas une pleine lune. Lupin est actuellement un humain.

Dans cet exemple, la variable espèce a une valeur globale (humain) et une valeur locale (loup-garou). Cependant, si vous utilisez var, le résultat sera différent.

// Utiliser var pour initialiser une variable
var espèce = "humain";
si (pleine Lune) (
// Tentative de création d'une nouvelle variable dans un bloc
var espèce = "loup-garou";
console.log(`C'est la pleine lune. Lupin est actuellement une $(espèce).`);
}
console.log(`Ce n'est pas la pleine lune. Lupin est actuellement une $(espèce).`);
C'est la pleine lune. Lupin est actuellement un loup-garou.
Ce n'est pas une pleine lune. Lupin est actuellement un loup-garou.

En conséquence, la variable globale et la variable au niveau du bloc produisent la même valeur, loup-garou. En effet, au lieu de créer une nouvelle variable locale, var réaffecte la même variable dans la même portée. var ne comprend pas que if devrait faire partie d'une nouvelle portée différente. Il est généralement recommandé de déclarer les variables au niveau du bloc, car cela réduit le risque de remplacement involontaire des valeurs des variables.

Jusqu'à présent, la plupart des exemples ont utilisé le mot-clé var pour déclarer une variable et initialiser la variable avec une valeur. Une fois déclarée et initialisée, la valeur est accessible ou réaffectée.

Si vous essayez d'utiliser une variable avant qu'elle n'ait été déclarée et initialisée, le résultat ne sera pas défini.

console.log(x);
// Affectation de variables
variable x = 100 ;
indéfini

Cependant, si vous omettez le mot clé var, la variable ne sera pas déclarée, mais seulement initialisée. Cela renverra une ReferenceError et arrêtera l’exécution du script.

// Tentative d'utiliser une variable avant de la déclarer
console.log(x);
// Affectation de variable sans var
x = 100 ;
ReferenceError : x n'est pas défini

Cela est dû au levage, un comportement JavaScript dans lequel les déclarations de variables et de fonctions sont déplacées vers partie supérieure leurs domaines. Puisque seule la déclaration réelle est levée et non l'initialisation, le premier exemple renvoie undefined.

Pour mieux démontrer ce concept, nous avons écrit le code suivant et expliqué comment JavaScript le lit :

// Le code que nous avons écrit
console.log(x);
variable x = 100 ;
// Comment JavaScript l'a interprété
variable x ;
console.log(x);
x = 100 ;

Avant d'exécuter le script, JavaScript stocke x en mémoire en tant que variable. Étant donné que la variable a été appelée avant d'être définie, le résultat est renvoyé non défini plutôt que 100. Cependant, cela ne génère pas de ReferenceError ni n'arrête le script. Bien que le mot-clé var n'ait pas réellement modifié l'emplacement du var, il montre comment fonctionne le levage. Ce comportement peut poser des problèmes car le programmeur qui a écrit ce code s'attend très probablement à ce que la sortie de x soit vraie plutôt qu'indéfinie.

Une augmentation peut également conduire à des résultats imprévisibles, comme dans l'exemple suivant :

variable x = 100 ;
fonction palan() (
// Une condition qui ne devrait pas affecter le résultat du code
si (faux) (
variable x = 200 ;
}
console.log(x);
}
hisser();
indéfini

Dans cet exemple, la variable globale x est 100. Selon l'instruction if, x peut passer à 200, mais comme la condition était fausse, cela ne devrait pas affecter la valeur de x. Au lieu de cela, x a été levé avant le début de hoist() et la valeur est devenue indéfinie.

Ce comportement imprévisible peut provoquer des erreurs dans le programme. Puisque let et const sont définis au niveau du bloc, ils ne seront pas hissés de la même manière que dans l'exemple ci-dessous.

// Initialise x dans la portée globale
soit x = vrai ;
fonction palan() (
// Initialise x dans la portée de la fonction
si (3 === 4) (
soit x = faux ;
}
console.log(x);
}
hisser();
vrai

Les déclarations de variables en double, possibles avec var, provoqueront une erreur avec let et const.

// Tentative d'écraser une variable déclarée avec var
variable x = 1 ;
variable x = 2 ;
console.log(x);
2
// Tentative d'écraser une variable déclarée avec let
soit y = 1 ;
soit y = 2;
console.log(y);

Uncaught SyntaxError : l'identifiant « y » a déjà été déclaré
Ainsi, les variables déclarées avec var peuvent être affectées par le levage. Le levage est un mécanisme en JavaScript dans lequel les déclarations de variables sont stockées en mémoire. Cela peut entraîner des variables non définies dans le code. Les mots-clés let et const résolvent ce problème en provoquant une erreur si vous essayez d'utiliser une variable avant de la déclarer ou si vous déclarez une variable plusieurs fois.

De nombreux langages de programmation utilisent des constantes, qui sont des valeurs qui ne peuvent pas être modifiées. Autrement dit, les valeurs attribuées à une constante ne peuvent pas être réaffectées.

Par convention générale, les identifiants const sont écrits en majuscules. Cela les distingue des autres variables.

Dans l'exemple ci-dessous, la variable SPECIES est initialisée en tant que constante à l'aide du mot-clé const. Tenter de réaffecter une variable entraînera une erreur.

// Attribuer une valeur à const
const ESPÈCE = "humain";
// Tentative de réaffectation de valeur
ESPÈCE = "loup-garou" ;
console.log(ESPÈCE);
Uncaught TypeError : affectation à une variable constante.

Étant donné que les valeurs const ne peuvent pas être réaffectées, elles doivent être déclarées et initialisées en même temps, sinon une erreur se produira.

// Déclare mais n'initialise pas un const
const À FAIRE ;
console.log(TODO);
Uncaught SyntaxError : initialiseur manquant dans la déclaration const

Les valeurs qui ne peuvent pas être modifiées par programmation sont appelées immuables, et les valeurs qui peuvent être modifiées sont appelées mutables (évidemment). Les valeurs d'une constante ne peuvent pas être réaffectées, mais elles sont mutables car les propriétés des objets déclarées avec const peuvent être modifiées.

// Crée un objet CAR avec deux propriétés
const VOITURE = (
couleur : "bleu",
prix : 15000
}
// Modifier une propriété de CAR
CAR.prix = 20000 ;
console.log(CAR);
( couleur : " bleu ", prix : 20000 )

Les constantes vous permettent d'indiquer aux autres programmeurs travaillant sur le projet, ainsi qu'à vous-même, qu'une variable donnée ne doit pas être réaffectée. Pour déclarer une variable pouvant être réaffectée, vous devez utiliser let.

Dans ce manuel, vous avez appris ce qu'est une variable, vous êtes familiarisé avec les règles de dénomination des variables et vous avez appris à réaffecter leurs valeurs. Vous avez également découvert la portée et le levage des variables, les limites du mot-clé var et comment let et const éliminent ces problèmes.

L'instruction var déclare une variable, en l'initialisant éventuellement à une valeur.

La source de cet exemple interactif est stockée dans un référentiel GitHub. Si vous souhaitez contribuer au projet d'exemples interactifs, veuillez cloner https://github.com/mdn/interactive-examples et envoyez-nous une pull request.

indéfini

. Description Les déclarations var, où qu'elles se produisent, sont traitées avant l'exécution de tout code. C'est ce qu'on appelle le levage et est discuté plus en détail ci-dessous. La portée d'une variable déclarée avec var est sa valeur actuelle

L'attribution d'une valeur à une variable non déclarée la crée implicitement en tant que variable globale (elle devient une propriété de l'objet global) lorsque l'affectation est exécutée. Les différences entre les variables déclarées et non déclarées sont :

1. Les variables déclarées sont contraintes dans le contexte d'exécution dans lequel elles sont déclarées. Les variables non déclarées sont toujours globales.

Fonction x() ( y = 1; // Lève une ReferenceError en mode strict. var z = 2; ) x(); console.log(y); // 1 console.log(z); // Lève une ReferenceError : z n'est pas défini en dehors de x.

2. Les variables déclarées sont créées avant l'exécution de tout code. Les variables non déclarées n'existent pas tant que le code qui leur est attribué est exécuté.

Console.log(a); // "non défini" ou "" selon le navigateur console.log("toujours..."); // ça continue... var a = 1; console.log(a); // 1 console.log("toujours..."); // ça continue...

3. Les variables déclarées sont une propriété non configurable de leur contexte d'exécution (fonction ou global). Les variables non déclarées sont configurables (par exemple peuvent être supprimées).

Var a = 1 ; b = 2 ; supprimez ceci.a; // Lève une TypeError en mode strict. Sinon, il échoue silencieusement. supprimez ceci.b; console.log(a, b); // Lève une ReferenceError. // La propriété "b" a été supprimée et n'existe plus.

En raison de ces trois différences, le fait de ne pas déclarer les variables entraînera très probablement des résultats inattendus. Il est donc recommandé de toujours déclarer les variables, qu'elles soient dans une fonction ou dans une portée globale.

var levage

Étant donné que les déclarations de variables (et les déclarations en général) sont traitées avant l'exécution de tout code, déclarer une variable n'importe où dans le code équivaut à la déclarer en haut. Cela signifie également qu'une variable peut sembler être utilisée avant d'être déclarée. Ce comportement est appelé « levage », car il semble que la déclaration de variable soit déplacée vers le haut de la fonction ou du code global.

Bla = 2 ; var bla; // ...est implicitement compris comme : var bla; bla = 2 ;

Pour cette raison, il est recommandé de toujours déclarer les variables en haut de leur portée (en haut du code global et en haut du code de fonction) afin de savoir clairement quelles variables sont de portée fonction (locale) et lesquelles sont résolues sur la portée. chaîne.

La fonction do_something() ( console.log(bar); // undefined var bar = 111; console.log(bar); // 111 ) // ...est implicitement comprise comme : function do_something() ( var bar; console .log(bar); // barre non définie = 111; console.log(bar);

Attention à l'ordre :

Var x = y, y = "A" ; console.log(x + y); //non définiA

Ici, x et y sont déclarés avant l'exécution de tout code, mais les affectations ont lieu plus tard. Au moment où " x = y " est évalué, y existe donc aucune ReferenceError n'est levée et sa valeur est undefined . Ainsi, x se voit attribuer la valeur indéfinie. Ensuite, y reçoit la valeur "A" . Consequently, after the first line, x === undefined && y === "A" , hence the result.!}

Le même exemple que ci-dessus mais avec un mode strict :

« utiliser strict » ; variable x = 0 ; function f() ( var x = y = 1; // Lève une ReferenceError en mode strict. ) f(); console.log(x, y);

Les variables qui semblent être des globales implicites peuvent être des références à des variables dans une portée de fonction externe :

Var x = 0 ; // Déclare x dans la portée du fichier, puis lui attribue la valeur 0. console.log(typeof z); // "indéfini", puisque z n'existe pas encore fonction a() ( var y = 2; // Déclare y dans le cadre de la fonction a, puis lui attribue la valeur 2. console.log(x, y); // 0 2 function b() ( x = 3; // Attribue 3 au fichier existant de portée x. y = 4; // Attribue 4 au y externe existant. z = 5; // Crée une nouvelle variable globale z, et lui attribue une valeur de 5. // (Lance une ReferenceError en mode strict.) b(); // Crée z en tant que variable globale. console.log(x, y, z); . console.log(x, z); // 3 5 console.log(typede y);

Le tableau de compatibilité sur cette page est généré à partir de données structurées. Si vous souhaitez contribuer aux données, veuillez consulter https://github.com/mdn/browser-compat-data et envoyez-nous une pull request.

Mettre à jour les données de compatibilité sur GitHub

En travaillant en Javascript, nous pouvons saisir des chiffres, des chaînes et valeurs booléennes, cependant, ils fonctionnent si le programme contient les informations nécessaires. À cette fin, des variables ont été créées qui nous permettent de stocker différents types d'informations et de les représenter comme une sorte de conteneur auquel nous pouvons accéder à tout moment et obtenir les informations qui s'y trouvent.

Une variable est créée en deux étapes : déclarer la variable et lui attribuer un nom.

Tout d'abord, nous devons déclarer la variable, c'est-à-dire la déclarer, cela se fait à l'aide du mot-clé var. Ensuite nous écrivons une instruction, c'est le nom de la variable, son nom est la façon dont nous y accéderons, par exemple j'écrirai dwstv.

Le nom que vous donnez aux variables dépend bien sûr de vous, mais il y a quelques règles qui doivent être suivies pour que javascript fonctionne :

• première règle, évitez d'utiliser des mots réservés. Certains mots du langage JavaScript sont utilisés dans le système lui-même, comme le mot var avec lequel on déclare une variable. De plus, certains mots, tels que alert , document , window , sont considérés comme des propriétés spéciales d'une page Web. Si vous essayez de les utiliser comme variables, vous recevrez un message d'erreur. Ici vous pouvez voir une liste de mots réservés.
• deuxième règle, le nom de la variable doit commencer par une lettre, un symbole $ ou _. Autrement dit, la variable ne peut pas commencer par un chiffre ou un signe de ponctuation : les noms 1dwstv et &dwstv ne fonctionneront pas, mais les noms $dwstv et _dwstv le feront.
• troisième règle, le nom de la variable peut contenir des lettres, des chiffres, des symboles $ et _, et ne peut pas utiliser d'espaces ou d'autres caractères dans le nom signes spéciaux: dws&tv et dws tv sont des noms invalides, mais ce format est possible, dws_tv et dwstv1 ou dws_tv_1.
• quatrième règle, les noms de variables sont sensibles à la casse. L'interpréteur JavaScript traite les lettres minuscules et majuscules différemment, ce qui signifie que la variable DWSTV est différente de la variable dwstv, ainsi que des variables DwStv et Dwstv.
• cinquième règle, il n'est pas recommandé d'utiliser des caractères autres que latins ; les variables écrites en cyrillique, même si elles fonctionneront, ne sont pas garanties et ne seront pas comprises par les collègues d'autres pays.

Ce sont les cinq règles de base que je recommande de suivre, en plus d'elles, je voudrais également dire, attribuez des noms clairs et expressifs à vos variables. Nommez les variables en fonction du type de données qui y sont stockées, cela vous aidera à mieux comprendre ce qui est écrit et, en regardant ces variables, vous comprendrez clairement de quoi nous parlons.

Lorsque vous nommez des variables, essayez de les rendre faciles à lire. Lorsque vous utilisez plusieurs mots, ajoutez un trait de soulignement entre eux ou commencez chaque mot après le premier par une lettre majuscule. Par exemple, dwsTv ou dws_tv.

Au début de la leçon, nous avons vu en quoi consiste une variable, maintenant que nous savons comment la créer, nous pouvons y stocker n'importe quel type de données à notre discrétion.

Pour mettre des données dans une variable, utilisez caractère spécial, le signe égal (=) est appelé opérateur d'affectation car il est utilisé pour attribuer une valeur à une variable.

Par exemple, mettons une valeur numérique dans la variable dwstv, le nombre d'abonnés est de 8500, déclarons la variable var dwstv ;

et dans la deuxième ligne on y met la valeur dwstv = 8500 ;

Var dwstv; dwstv = 7 200 ;

Et ainsi, avec la première ligne, nous avons créé une variable et avec la seconde, nous y avons enregistré la valeur. Nous pouvons également créer une variable et y stocker des valeurs à l'aide d'une seule instruction, par exemple :

Var dwstv = 7200 ;

Dans une variable, nous pouvons stocker tous les types de données que nous avons abordés dans les leçons précédentes, il peut s'agir de valeurs numériques, de chaînes et logiques :

Var dwstv = 7200 ;var leçons = 'JavaScript' ; varyoutubeKanal = 'DwsTV'; var abonnés = '7700'; var contenu = vrai ;

Var leçons = 'JavaScript', youtubeKanal = 'DwsTV', abonnés = '7700', contenu = true ;

Après avoir stocké les valeurs dans des variables, nous pouvons accéder à ces données. Pour ce faire, utilisez simplement le nom de la variable elle-même.

Par exemple, si nous voulons ouvrir une boîte de dialogue d'alerte et afficher la valeur stockée dans la variable kanal, nous pouvons simplement écrire le nom de la variable dans la fonction d'alerte.

Alerte (canal) ;

Notez que nous ne mettons pas de guillemets autour des variables - ils sont uniquement destinés aux chaînes, donc nous n'écrivons pas alert('kanal') car cela nous donnerait les mots kanal plutôt que la valeur stockée dans la variable.

Maintenant, je pense que vous comprenez pourquoi les chaînes doivent être placées entre guillemets : l'interpréteur JavaScript traite les mots sans guillemets soit comme des objets spéciaux (par exemple, la commande alert()) soit comme des noms de variables.

Et il y a aussi un moment où on a déclaré une variable avec le mot clé var et on veut la changer dans valeur variable, il n'est pas nécessaire de la déclarer à nouveau en écrivant le mot var , il suffit d'appeler le nom de la variable et de lui attribuer une nouvelle valeur.

Abonnés = « 10 000 » ;

À la fin de cette leçon, je tiens à dire qu'en apprenant n'importe quel langage, vous n'apprendrez pas à programmer. Sans aucun doute, vous apprendrez quelque chose de nouveau, mais très probablement votre cerveau ne se souviendra pas de cette information, puisque vous ne travaillez pas avec elle. Il est impossible d'apprendre une langue sans pratiquer, c'est pourquoi à partir de cette leçon, vous recevrez une petite tâche afin que les informations fournies s'intègrent dans votre esprit et que vous puissiez travailler avec elles.

Tâche pratique :

Créez trois variables, attribuez à la première une valeur numérique, à la seconde une valeur de chaîne et à la troisième une valeur logique. Déclarez toutes les variables avec un mot-clé var et affichez-les sur la page. Redéfinissez ensuite la variable avec valeur numérique, et affichez le résultat résultant à l'aide de la fonction alert().

Au début de la prochaine vidéo, nous examinerons cette tâche, partagez vos résultats dans les commentaires, écrivez si quelqu'un a des questions. Si vous avez aimé la leçon et souhaitez soutenir le projet, partagez-la simplement sur les réseaux sociaux.

Dans la leçon suivante, nous examinerons en détail comment travailler avec des types de données et des variables, nous familiariserons avec les opérations mathématiques et l'ordre de leur exécution, et analyserons également les méthodes de combinaison de valeurs de chaîne et de valeurs numériques.

La leçon a été préparée par Denis Gorelov.

Le programmeur souhaite créer une variable globale film et une autre variable portant le même nom mais n'agissant que dans la fonction showBadFilm(). Quel message l'alerte sera-t-elle émise par la fonction showGoodFilm() ? Quel message s'affichera si cette fonction est à nouveau appelée, mais après avoir appelé la fonction showBadFilm() ?

Bon ou mauvais film ?

var film = "Viorne rouge";

function showGoodFilm() ( alert(film + " - bon film !"); ) function showBadFilm() ( film = "11 septembre"; alert(film + " - mauvais film !"); ) showGoodFilm(); // que va afficher l'alerte ?

• showBadFilm(); // que va afficher l'alerte ?

  showBonFilm(); // que va afficher l'alerte ?

  Solution:

  var film = "Viorne rouge";

  Notez que la fonction showBadFilm() n'a pas le mot-clé var avant la variable film. Par conséquent, JavaScript suppose que vous souhaitez remplacer la valeur d'une variable globale plutôt que de créer une variable locale du même nom. Par conséquent, appeler à nouveau la fonction showGoodFilm() affichera : "Le 11 septembre est un bon film !"

Vérification du type de données

De quel type de données primitif sont les variables suivantes ? Essayez de répondre sans exécuter le script.

• Vérification du type de données var film = "Red Viburnum" ;
• var 07_agent = "Agent" ;
• var num = 10 ;

var u = vrai ;

variable x ;

alerte (type de film); //???

alerte (type de 07_agent); //???

alert(type de numéro); //???

alert(type de vous); //???

alerte (type de x); //???

Les identifiants peuvent être des noms courts (tels que x et y) ou des noms plus descriptifs (âge, somme, volume total).

Règles générales Les noms de construction pour les variables (identifiants uniques) sont :

• Les noms peuvent contenir des lettres, des chiffres, des traits de soulignement et des signes dollar.
• Les noms doivent commencer par une lettre
• Les noms peuvent aussi commencer par $ et _ (mais nous ne l'utiliserons pas dans ce tutoriel)
• Les noms sont sensibles à la casse (y et y sont des variables différentes)
• Les mots réservés (tels que les mots-clés JavaScript) ne peuvent pas être utilisés comme noms

Les identifiants JavaScript sont sensibles à la casse.

En JavaScript, le signe égal (=) est un opérateur « d'affectation », et non un opérateur « égal ».

C’est différent de l’algèbre. Ce qui suit n’a aucun sens en algèbre :

En JavaScript, cependant, cela a du sens : il attribue la valeur x + 5 à x.

(Il calcule la valeur de x + 5 et met le résultat dans x. La valeur de x est augmentée de 5)

L'opérateur "égal à" s'écrit == en JavaScript.

Les variables JavaScript peuvent contenir des nombres comme 100 et valeurs de texte comme "John Doe".

En programmation, les valeurs de texte sont appelées chaînes de texte.

JavaScript peut fonctionner avec différents types données, mais pour l'instant, je pense juste aux chiffres et aux chaînes.

Les lignes sont écrites en double ou guillemets simples. Les nombres sont écrits sans guillemets.

Si vous mettez des guillemets autour d’un nombre, celui-ci sera traité comme une chaîne de texte.

Créer une variable en JavaScript s'appelle « déclarer » une variable.

Vous annoncez Variable JavaScript avec le mot-clé var :

Une fois déclarée, la variable n'a plus de valeur. (Techniquement, le sens n'est pas défini)

Pour attribuer une valeur à une variable, utilisez le signe égal :

Nom de la voiture = "Volvo" ;

Vous pouvez également attribuer une valeur à une variable lors de sa déclaration :

var carName = "Volvo";

Dans l'exemple ci-dessous, nous créons une variable appelée carName et lui attribuons la valeur « Volvo ».

Ensuite, nous "affichons" la valeur à l'intérieur de l'élément HTML avec id="demo" :

var carName = "Volvo";
document.getElementById("demo").innerHTML = carName;

Vous pouvez déclarer plusieurs variables dans une seule instruction.

Commencez l'instruction par var et séparez les variables par des virgules :

La déclaration peut s'étendre sur plusieurs lignes :

DANS programmes informatiques, les variables sont souvent déclarées sans valeur. La valeur peut être quelque chose qui doit être calculé ou quelque chose qui sera fourni ultérieurement en tant que saisie utilisateur.

Une variable déclarée sans valeur aura une valeur indéfinie.

La variable carName aura la valeur non définie après l'exécution de cette instruction.