Transcription
1. Bienvenue: Bienvenue dans ce cours,
javascript, les fondamentaux. Javascript est l'un des
langages de programmation les plus demandés aujourd'hui, et c'est un excellent langage pour commencer votre parcours
de programmation. L'une des difficultés rencontrées
lors de l'apprentissage code est de trouver les meilleures
ressources pour les débutants. Ce cours
vous présentera tous les sujets clés tels que les types de données primitifs,
puis les objets et tableaux. Ce
cours court et concis vous donnera une base solide de
toutes les bases et vous
fournira suffisamment d'
informations à travers exemples pour que vous
puissiez vous entraîner seul. Je suis Emma et je travaille comme programmeur depuis sept ans. La plupart du temps,
j'ai utilisé JavaScript et j'ai
adoré la langue. J'ai également aidé
suffisamment de personnes en cours de route à savoir quels sujets
les débutants devraient connaître. J'espère que vous avez appris à aimer
JavaScript autant que moi et que vous
apprécierez le cours.
2. Présentation des types primitifs: La première chose que
nous allons examiner ce sont les types primitifs. Si vous y réfléchissez, données se présentent sous toutes sortes
de formes et de tailles. Lorsque nous parlons d'un type de données, nous faisons référence au
type d'une valeur spécifique. Dans notre langue quotidienne,
nous utilisons des mots et des chiffres
à des fins différentes. Par exemple, lorsque vous publiez la lettre est probablement
sur l'enveloppe, vous écrivez une adresse. la plupart des cas, cette adresse serait constituée de mots. Par contre, lorsque
vous passez un appel téléphonique il est plus probable que vous
composez un ensemble de numéros. En programmation,
ce n'est pas différent. C'est juste qu'il existe
quelques autres catégories lesquelles les types de données
sont divisés. Mais essentiellement, un type de données définit comment nous allons utiliser
les données de notre code. Ils constituent également les principales options
essentielles pour représenter les données. Certaines langues
vous obligent à spécifier à
l'avance le type de données
lorsque vous les utilisez. Mais JavaScript est
ce qu'on appelle un langage lâchement typé et
dynamique, ce qui signifie que vous
n'avez pas à le faire, car JavaScript,
nous le comprendrons lui-même lorsqu'il sera exécuté. En JavaScript, nous appelons
ces types de données les plus basiques
comme des types primitifs. Et il y en a sept. Fastly number, c'est ainsi que nous représentons les valeurs numériques. Booléen, vrai ou faux. Chaîne, jeu de caractères. Null, non défini. Enfin, le symbole et les
grands, simples
et grands, ne sont pas
aussi communs et un sujet
légèrement plus avancé, mais il vaut toujours la peine de
savoir qu'ils existent. Le premier des types
primitifs que nous
allons examiner est
le type de nombre. Le type de numéro est la
façon dont JavaScript nous
permet de représenter des valeurs
numériques. En JavaScript, il
n'y a qu'un seul type de nombre, mais la valeur peut être l'une
des suivantes. Positif ou négatif. C'est comme un ou
moins un tout, également connu sous le nom d'entiers. Il s'agit de valeurs
comme 50 ou huit. Il y a ensuite des décimales, parfois appelées valeurs à
virgule flottante. Il s'agit de valeurs
telles que 10,1 ou 22,8. Il est bon d'être conscient
du fait que JavaScript comporte certaines restrictions de
mémoire. Si vous travaillez avec des nombres
très longs, lorsque vous utilisez un nombre de
plus de 15 chiffres, il sera arrondi vers le
haut ou le bas sauf si vous utilisez le type de données
Big int. Dans la vidéo suivante, nous examinerons quelques
exemples de ces valeurs. Pour ce faire, nous pouvons
utiliser la console. La console est une interface de ligne de
commande dans votre navigateur Internet. Et à l'intérieur, vous pouvez
exécuter des morceaux de code. Vous pouvez taper des nombres
indirectement et effectuer des calculs comme
lorsque vous utilisez une calculatrice. Vous pouvez suivre les
instructions incluses pour le charger, mais il vous
suffit d'ouvrir Chrome. À partir de là, vous pouvez sélectionner View Developer,
JavaScript Console. Si vous voulez un Mac, vous pouvez
également utiliser les touches de raccourci, option de
commande et j. Ou si vous êtes sur une machine
Windows, Shift Control et J. Comme je l'ai mentionné dans
la dernière vidéo, nous pouvons utiliser le console pour
expérimenter avec des nombres. Si vous n'avez pas déjà ouvert
la console, c'est très bien. Il vous suffit de lancer Chrome. Vous pouvez voir que je l'ai
déjà ouvert ici. Accédez ensuite à la console
JavaScript View Developer. Commençons par
examiner les chiffres positifs. Nous pouvons simplement en taper
un dans la console, ce qui
serait positif. Si je fais cela ici,
j'appuie sur un, puis j'appuie sur Entrée. Vous pouvez voir que nous avons
le numéro un. Il est donc important de noter ici que rien ne se passe réellement. Rien n'est
stocké ou enregistré. La console reconnaît simplement que nous avons saisi une valeur dans. C'est un peu comme lorsque
vous tapez un nombre dans une calculatrice et que vous pouvez
voir qu'il est tapé. Nous pouvons le refaire
avec un nombre négatif. Si nous prenons la valeur moins
200, nous pouvons le saisir. Ensuite, nous appuyons sur Entrée. Nous pouvons faire de même
avec une décimale. Si nous prenons la valeur
5.1, appuyez sur Entrée. Enfin, j'ai également mentionné restrictions de
mémoire avec des nombres
très longs. Si je tape évalué avec
plus de 15 chiffres, si je fais cela, j'appuie sur Entrée. Vous pouvez voir les
valeurs arrondies. Si je refais la même chose, mais je fais
moins de 15 chiffres. J'appuie ensuite sur Entrée. Vous pouvez voir que nous obtenons
la valeur précise. Et c'est parce que JavaScript ne
peut pas stocker un nombre
infini. Une dernière chose à noter
ici est que sur la console vous souhaitez revenir à la dernière commande que vous avez saisie. Il vous suffit d'utiliser la flèche vers le
haut de votre clavier. Et il vous sera
donné. Là.
3. Booleans: Le prochain
type primitif, nous allons
regarder un Booléen. Boolean est l'une des deux
valeurs, true ou false. C'est un peu comme dire
oui ou non, allumé ou désactivé. Vous n'utilisez pas de guillemets
lorsque vous utilisez un booléen, c'est simplement
vrai ou faux. Plus tard dans le cours, nous
parlerons des conditions et de la logique. Et l'utilisation des booléens sera montrée plus en profondeur dans. Mais pour l'instant, n'oubliez pas qu'
un booléen est vrai ou faux. Dans la console, nous pouvons voir à
quoi ressemble un booléen. Si je voulais utiliser un booléen
avec la valeur true, je peux simplement taper
true et appuyer sur Entrée. Si je voulais utiliser un booléen
avec la valeur false, je vais simplement taper
false et appuyer sur Entrée. En guise de note, si vous souhaitez effacer
le contenu de la console, vous pouvez appeler
la méthode clear, qui est une méthode
de la console. Nous l'appelons simplement comme alors nous avons
parlé de la console point clair. Ensuite, parce que c'est une
méthode, nous devons utiliser parenthèses, puis
appuyer sur Entrée. Comme vous pouvez le constater, la console
est maintenant en cours de désactivation pour nous.
4. Nulle et non défini: À côté des types primitifs, nous allons
discuter d'une valeur nulle et indéfinie.
Commençons par null. Null ne représente rien.
Pour le dire autrement, pas comme une simple non-valeur. Imaginez-vous, je suis dans
votre frigo pour
chercher du lait, puis il
n'y avait pas de lait là-dedans. On pourrait dire que ce n'
est pas JavaScript. Nous définissons généralement la valeur nulle
intentionnellement. Vous pouvez donc créer une
variable pour stocker la valeur. Dans ce cas, on pourrait
appeler ça frigo a du lait, et vous attribueriez la
valeur nulle à cette variable. Non défini, par contre, ne représente pas non
plus de valeur, mais il est moins courant
d'attribuer à une variable la
valeur non définie. Au lieu de cela, non défini, car le plus souvent
nous revenait sous la forme d' une époque où nous sommes retournés vers
nous si nous déclarons une variable. Mais nous ne l'initialisons pas en attribuant une valeur
à la variable. De retour dans la console, nous pouvons regarder quelques exemples
de valeurs nulles et non définies. Commençons par indéfini. Une fois que vous verrez peut-être non défini c'est si vous travaillez
avec une chaîne et que vous
recherchez un élément qui n'
existe pas réellement dans la chaîne. Si nous prenons l'exemple de la
glace à cordes, vous pouvez voir qu'
elle ne contient que trois lettres. Et je peux le prouver en utilisant
la propriété length. Maintenant, si nous allons de l'avant et que nous
recherchons la quatrième lettre
dans la chaîne, utiliserons la notation entre crochets. Vous pouvez voir que cela
n'
existe pas réellement , nous sommes indéfinis. Si je le refais et que je
finis pour la première lettre de la chaîne qui existe. Vous pouvez voir que nous obtenons
le prochain exemple de cas où vous pouvez voir non défini lorsque nous créons une variable, mais nous n'initialisons pas
la variable avec une valeur. Je vais donc créer une variable appelée boisson froide. Vous pouvez voir que nous ne sommes pas définis. Si nous savions à l'
avance que nous voulions initialiser la
variable des boissons froides sans valeur. Ce serait vraiment le moment
approprié pour utiliser null. Si je l'attribue maintenant à
la variable boisson froide. Vous pouvez voir que nous avons non. Je viens d'essayer
d'utiliser la variable juste pour vous montrer qu'
elle est toujours là. C'est ce que nous avons maintenant.
5. Ssarith: Lorsque nous travaillons
avec des nombres, nous voudrions probablement effectuer certaines opérations
ou certains calculs. Nous avons un ensemble d'
opérateurs arithmétiques que nous pouvons utiliser. Il s'agit de l'addition, de la soustraction, la multiplication, de
la division et du modulo. Maintenant, l'opérateur ici, qui
est peut-être le moins familier ,
est probablement l'opérateur
modulo , parfois appelé
opérateur restant. Cet opérateur divise la valeur à droite
par la valeur à gauche ,
puis renvoie le
reste qui reste après
avoir
effectué la division. Par exemple, si je
faisais 100 modules à, la valeur renvoyée serait 0. Ou si au lieu de cela j'ai
fait 75 modulo 60, la valeur de retour serait 15. Il est intéressant de savoir que si la valeur de
gauche est positive
, la valeur renvoyée
sera toujours positive. Et si la valeur de gauche est négative
, la valeur renvoyée
sera toujours négative. Une autre chose qui
mérite d'être mentionnée ici est la priorité des opérateurs. Vous connaissez peut-être maintenant le rôle
de l'ordre des opérations et
l'acronyme PEMDAS. Pemdas est synonyme
de parenthèses, d'exposants, multiplication, de division, d'
addition et de soustraction. En JavaScript, l'ordre de priorité
fonctionne essentiellement de la même manière. Par conséquent, tout élément entre
parenthèses sera
évalué en premier. La multiplication
et la division ont alors une priorité supérieure à celle de l'
addition et de la soustraction. Examinons donc quelques exemples d'utilisation d'opérateurs arithmétiques. Une fois de plus, nous utiliserons
la console JavaScript. Si nous commençons par
l'opérateur d'ajout, nous voulions effectuer
le calcul. Deux plus deux saisiront
l'opérateur d'ajout, suivis de deux et appuyez sur Entrée. Comme vous pouvez le constater, il est renvoyé dans le calcul
a été fait pour nous. Nous pouvons
refaire la même chose, mais avec soustraction. Si je voulais
soustraire deux de dix, je vais taper dix. L'opérateur de soustraction,
suivi de 28, est renvoyé. Ensuite, essayons
une certaine multiplication et multiplions six par deux. Je peux taper six. L'
opérateur de multiplication est
suivi de deux et appuyez sur Entrée. Comme vous pouvez le constater, 12 sont retournés. Nous pouvons faire la même
chose pour la division. Si je voulais diviser,
disons quatre par deux, alors je taperai
l'opérateur
de division et j'appuierai sur Entrée. Ensuite, nous sommes
retournés à nous. Enfin, examinons
l'opérateur modulo. Si je voulais voir
ce qui restait, si je divisais 100 par
100, nous obtenons cela il y a, tuyauterie 100 modulo 1000 nous
est retournée, et c'est parce que 100
correspond exactement à 100. n'y a pas de valeur restante. Mais si je refais ça,
mais j'ai essayé avec 98, je tape 100 modulo 98, puis je reviendrai. Et c'est parce que 98 correspond
exactement à 100 une fois, mais reste la valeur
restante.
6. Commentaires: Dans cette section, nous allons
parler de commentaires. Lorsque vous avez effectué une révision
pour les examens par le passé, vous connaissez peut-être le concept de laisser des notes dans le manuel pour
vous rappeler si les choses à
retenir plus tard, comme quand c'est arrivé
jusqu'à l'heure de révision. Les commentaires en JavaScript
fonctionnent de la même manière. Lorsque vous écrivez du code, il peut être facile d'
oublier que nous ou quelqu'un d'autre aurions
besoin de clarté ultérieurement. Nous voudrions peut-être simplement laisser un rappel pour revoir un
code ultérieurement, peut-être pour le ranger. Javascript comporte deux
types de commentaires, sur
une seule ligne et les commentaires
multilignes. Si le commentaire ne comporte que quelques
mots et s'inscrit sur une seule ligne, nous pouvons utiliser le commentaire sur
une seule ligne. S'il est plus long que plusieurs lignes, les commentaires
seront plus appropriés. Nous sommes ici dans l'
éditeur de texte et je
vais juste donner quelques
exemples de commentaires. Je vais juste
faire de la place ici. Ensuite, je vais
commencer par faire un commentaire sur une seule ligne. Nous faisons un commentaire sur une seule ligne
avec deux barres obliques. Et je vais juste
ajouter un coup de texte. Comme vous pouvez le constater,
tout ce qui se
trouve sur cette ligne après les barres obliques est ignoré. Je vais donc passer à
la diapositive suivante et je vais créer une variable. Comme vous pouvez le constater, cela ne fait
plus partie du commentaire. Maintenant, si nous créons
un peu plus d'espace, je vais créer un commentaire
multiligne. Pour ce faire, j'utilise une
barre oblique et un astérisque. Ensuite, nous allons
ajouter du texte. Vous pouvez voir que jusqu'à ce que
je ferme ce commentaire, tout ce qui se trouve sur les
lignes suivantes est ignoré. Maintenant, si je vais me diriger
et que je ferme le commentaire et que j'utilise un astérisque
et une barre oblique. Et je vais passer à la ligne suivante et créer une autre variable. Vous pouvez voir que cela ne fait
plus partie du commentaire.
7. Introduction des variables: La prochaine chose que nous allons
examiner, c'est les variables. Les variables nous permettent
de stocker des valeurs. C'est vraiment
important pour
que notre code dispose de
certaines fonctionnalités. Au lieu de simplement
utiliser la console. Les variables nous permettent d'étiqueter
et de stocker nos données, puis d'accéder aux données et de les utiliser ou de les mettre
à jour ultérieurement. Une bonne façon de penser à une
variable est comme un conteneur. Imaginez que vous ayez un
pot de beurre de cacahuète. Si vous l'avez acheté
à la boutique, y
aura probablement une étiquette sur
ce pot. Vous savez donc ce qu'il y a
à l'intérieur du pot. Dans le code, vous pouvez
créer une variable appelée pot, puis attribuer la
valeur beurre d'arachide. En JavaScript, nous avons trois façons de
créer une variable, la plus rapide à utiliser les
mots-clés gauche ou const. Let et const ont été
introduits dans ES 2015, parfois
appelé ES6. Il s'agit d'une version de
JavaScript publiée en 2015. Avant cela, la
seule façon de créer une variable était d'utiliser
la barre de mots clés. Vous pouvez toujours voir du code qui
utilise cela et c'est correct. Mais à l'avenir, il est préférable
de s'en tenir à gauche ou à const. La principale différence
entre l'utilisation de left ou const est que
les variables créées avec le mot-clé const ne peuvent pas être modifiées une fois
qu'elles ont été créées. Donc, avant de nous
plonger dans un code, il existe certaines
conventions de dénomination qu'il est important de savoir quand il s'agit
de nommer des variables. Tout d'abord, le nom de la variable commençant par une lettre
ou un trait de soulignement, ou un signe de dollar. Habituellement, il est
préférable de commencer la variable par une lettre et d'utiliser une convention
appelée camel casing. casse chameau est
l'endroit où le premier mot est en
minuscules et que tous les autres mots majuscule la première lettre, mais le reste de ce
mot est en minuscules. Vous ne pouvez pas utiliser d'espaces
dans un nom de variable, c'est une autre raison pour laquelle boîtier de
chameau est une
bonne convention. Les variables sont également sensibles à la casse. La majuscule d'une variable
, puis la nommer à nouveau en minuscules créerait
deux variables distinctes. Enfin, vous ne pouvez utiliser aucun des mots
de réserve JavaScript
pour nommer votre variable. Les mots réservés se
trouvent sur le site MDM ici. Cependant, un conseil est également bon d'utiliser un nom
qui signifie quelque chose. Lorsque quelqu'un d'autre
lit votre code, le nom
de la variable est logique. Dans la console. Essayons de créer
l' exemple dont nous avons parlé
précédemment. Et nous allons créer une variable
à l'aide de let appelé jar. Et nous allons attribuer la
valeur du beurre de cacahuète. Maintenant, chaque fois que nous voulons
utiliser la variable jar, suffit de saisir le nom de
la variable, rappeler et d'appuyer sur Entrée. Ensuite, nous obtiendrons la valeur stockée dans la variable. Vous pouvez également
effectuer des opérations à l'aide de plusieurs variables. Si je voulais ajouter
deux valeurs ensemble, je peux créer une variable, appelons-la première valeur. Je vais initialiser
cela avec la valeur cinq. Créons maintenant une
deuxième variable, que nous
appellerons la deuxième valeur. Nous allons initialiser cela
avec la valeur dix. Essayons maintenant d'ajouter
les deux ensemble. Je dis première valeur, deuxième valeur. Nous y obtenons le nouveau total, 15.
8. Utiliser le const: Nous allons maintenant jeter un coup d'œil à la
création de variables avec const. Nous allons donc créer
une variable à l'aide de const. Nous appellerons ça, je suis Const. Nous allons initialiser cela
avec la valeur booléenne true et appuyez sur Entrée. Essayons maintenant de
rappeler la variable. Et ensuite, on devient vrai.
Comme je l'ai mentionné précédemment, une
fois qu'une variable a été
créée avec const, la valeur de cette variable, comptez-la être modifiée. Mais essayons ça quand même. Nous allons essayer de modifier la valeur
de la variable sur false. Comme vous pouvez le constater, nous obtenons
maintenant une erreur.
9. SsupdatingVariables les variables: Lorsque nous travaillons
avec des variables, nous pouvons initialiser la
variable avec une valeur, mais ensuite être liée à la modification de cette valeur. Pour ce faire, nous mettons
à jour la variable. Commençons par une variable. Nous appellerons ça de la couleur.
Nous allons initialiser cela avec la valeur rouge. Rappelez-vous cette variable. Comme vous pouvez le constater, il a été
initialisé correctement. Maintenant, si nous voulons mettre
à jour la variable, peut-être que nous changeons d'avis et que
nous voulons changer
la couleur en bleu. Nous devons utiliser l'opérateur
d'affectation, qui est le signe égal.
Essayons ça. Nous disons que la couleur est égale au bleu. Rappelons maintenant
la variable à nouveau. Et comme vous pouvez le constater, il a
été mis à jour en bleu. Si vous travaillez avec une
variable qui stocke un nombre, mais que vous souhaitez
mettre à jour cette variable. Encore une fois, vous devez utiliser l'opérateur
d'affectation. Créons une
variable appelée count. L'initialisera
avec une valeur de trois. Maintenant, si nous voulons augmenter
cette variable d'un, on dirait que le nombre est égal
au nombre pour obtenir la
valeur initiale de count plus un et appuyer sur Entrée. Puis déplacez Rico, comptez. Comme vous pouvez le constater, il a
été mis à jour à quatre. Vous ne pouvez pas simplement faire c'est
compter plus un parce que vous n'
attribueriez aucune valeur. Nous allons essayer ça. Nous dirons compter plus un. Et puis rappelez-vous le compte. Comme vous pouvez le constater,
rien n'a été mis à jour. Pour résumer ici, chaque fois que vous souhaitez
mettre à jour une variable, vous devez utiliser l'
opérateur d'affectation pour le faire.
10. Introduction des opérateurs de comparaison: Bienvenue de retour. Nous passons maintenant aux
opérateurs de comparaison. Plus tôt dans le cours, nous avons couvert les opérateurs arithmétiques, ce qui nous a aidés à
effectuer des calculs. Javascript
nous fournit également un ensemble d'
opérateurs appelés opérateurs de comparaison. Les opérateurs de comparaison
nous permettent de comparer les valeurs et
renverront un booléen vrai ou
faux pour que nous puissions travailler. Le premier ensemble de
ces opérateurs, nous examinerons un plus grand que, qui vérifie si une
valeur est
supérieure à quelque chose, inférieure à. Ce qui vérifie si une valeur
est inférieure à quelque chose, alors nous avons l'opérateur
supérieur ou égal, qui vérifiera si
une valeur est
supérieure ou égale
à quelque chose. Enfin, nous avons l'opérateur
inférieur ou égal, qui vérifie si une valeur est
inférieure ou égale
à quelque chose. Si nous étions en train de créer un programme basé sur les stocks de supermarchés, nous pourrions rencontrer une situation dans laquelle nous voulons seulement que l'utilisateur
puisse passer une commande. Si nous avions, disons, des
bananes en stock. Pour ce faire, nous
voudrions vérifier que le nombre de bananes
disponibles est supérieur à 0. Ce serait un exemple d'
utilisation de l'opérateur supérieur à. Plus tard, nous pourrions alors limiter la quantité de bananes
qu'un client peut commander en une, passer à cinq, afin de nous assurer que
le système de commande est équitable. Dans ce cas, nous
voudrions vérifier que la commande compte bananes avec
moins de cinq. Et ici, nous utiliserions l'opérateur
inférieur ou égal. Commençons par un
exemple simple de
plus grand que va vérifier si
un est inférieur à deux. Nous en disons donc un, moins de deux, et nous devenons réalité. Essayons maintenant si
un est supérieur à deux. Nous dirons donc un
plus grand que deux, et nous deviendrons faux. Essayons maintenant avec un opérateur
inférieur ou égal à l'opérateur. Nous dirons donc qu'il est cinq, moins ou égal à cinq ? Et nous deviendrons vrais. Si nous essayons, cinq
sont supérieurs ou
égaux à dix deviendront faux.
11. Plus d'opérateurs de comparaison: L'ensemble suivant des opérateurs de
comparaison, vérifions si une
valeur est égale à une valeur et renvoie une valeur booléenne
selon que c'est le cas ou non. Nous avons l'opérateur d'égalité, parfois appelé opérateur
de qualité plus lâche. L'opérateur d'inégalité, parfois appelé opérateur d'inégalité
lâche. Nous avons également une
égalité stricte et des inégalités strictes. En JavaScript, nous avons
ce qu'on appelle une
qualité plus lâche et aussi une égalité
stricte. Lorsque nous utilisons l'opérateur d'
égalité lâche, JavaScript effectue ce qu'on
appelle la coercition de type. coercition de type est la conversion
automatique d'un type de données en
un autre type de données. Si nous voulions
comparer l'entier 0 à une chaîne contenant 0, la comparaison utilisant l'
égalité lâche renverrait vrai. Cela est dû
au fait que la chaîne 0
sera contrainte au type entier. Ensuite, la comparaison
effectuée serait le nombre 0 par rapport
au nombre 0. D'autre part, si nous effectuons la même comparaison à l'aide de l'opérateur d'égalité
stricte, la valeur de retour
serait fausse car l'
opérateur d'égalité stricte
n' effectue aucune coercition de type. Commençons donc par
essayer l'opérateur d'égalité. Voyons ce qui se passe
si on essayait comparer le bord de
cinq avec un phi à cordes ? On dira que cinq W
équivaut à la chaîne cinq. Comme vous pouvez le constater, nous devenons réalité. Et cela est dû au fait que la
chaîne cinq est contrainte dans le type de données entier avant que
la comparaison ne soit effectuée. Essayons à nouveau, mais nous allons comparer l'entier
cinq à la chaîne six. Nous disons donc que cinq W
équivaut à la chaîne six. Ils ne sont pas égaux
, donc nous sommes faux. Cependant, si nous l'avons
refait et que nous utilisons l'opérateur d'
inégalité, nous disons que cinq ne sont pas égaux à
la chaîne six. Nous sommes vrais parce que les
valeurs ne sont pas égales. Passons maintenant à l'opérateur
strict de l'égalité. Comparons l'entier
dix au tour de l'intrus. Nous disons donc que dix triples équivaut à dix. Ces valeurs sont toutes les deux les
mêmes, donc nous devenons vrais. Essayons de changer
cela un peu et nous allons comparer l'entier
dix à la chaîne dix. Nous disons donc que dix triples
équivaut à la chaîne dix. Maintenant, nous sommes faux. C'est parce que nous utilisons
l' opérateur d'égalité stricte, et donc cette fois-ci, la
chaîne ne sera pas forcée. Cependant, si nous vérifions que
ces valeurs ne sont pas égales à l'aide de l'opérateur d'
inégalité stricte, nous disons dix, pas w
est égal à la chaîne dix. Vous pouvez voir que nous devions réalité.
12. Introduction des conditions: Dans cette section, nous allons
examiner les conditions conditionnelles. Lorsque nous écrivons du code, nous
arriverons à un point où nous aurons besoin que le
code soit plus dynamique et qu'il agisse en fonction de
certaines décisions. Lorsque vous jouez à un jeu de société. Tout au long du jeu,
vous feriez probablement certains mouvements ou choix, en fonction de certains résultats. À un moment donné, le
jeu commencerait ou se
terminerait selon que
quelque chose a été réalisé. Une autre façon d'y
penser est la façon dont nous faisons certains choix
tout au long de la journée en fonction de la météo. S'il fait vraiment froid, nous ne
choisirions généralement pas de porter une paire de tongs, par
exemple. Ou s'il fait vraiment chaud, les restants ne
veulent pas porter de pull. Lorsque nous écrivons du code, nous avons souvent besoin du code
pour fonctionner de cette façon. Nous aurons besoin de certaines
fonctionnalités pour être
exécutées ou non selon que certaines conditions
sont vraies ou fausses. En JavaScript, nous appelons cette logique sous le nom de logique conditionnelle. Nous allons commencer par
examiner les opérateurs de comparaison. Nous sommes maintenant prêts à passer
aux déclarations conditionnelles. Une instruction conditionnelle nous
permet d'exécuter code selon qu'une
condition était vraie ou fausse. Tous les opérateurs
logiques et comparatifs peuvent être affichés dans une instruction
conditionnelle. Lorsque nous utilisons
des instructions conditionnelles, nous pouvons utiliser if, else et else-if. Bienvenue de retour. Encore une fois pour commencer par
regarder les déclarations si. Si les instructions nous permettent d'
exécuter ou d'exécuter un morceau de code selon qu'une
condition est vraie ou fausse. Pour écrire une instruction if, vous avez arrêté d'utiliser
le mot-clé. Si. Le mot-clé if est ensuite
suivi d'un ensemble de parenthèses
, suivi d'un ensemble d'accolades. A l'intérieur des parenthèses,
a remplacé la condition. À l'intérieur des bretelles bouclées. Nous plaçons le code que
nous voulons exécuter. Si la condition
est vraie. Si la condition n'est
pas évaluée à true
, le code à l'intérieur des
accolades ne sera pas exécuté dans l'éditeur de texte. Jetons maintenant un coup d'œil
à l'utilisation des instructions if. Nous allons commencer par une
simple instruction if qui imprime quelque chose
sur la console. Si un est inférieur à deux. Nous commençons par le mot clé def. Nous avions un ensemble de parenthèses suivies d'un ensemble d'
accolades bouclées. À l'intérieur des parenthèses, nous
avons l'état que
nous voulons vérifier. Dans ce cas, nous
voulons vérifier si un est inférieur à deux. À l'intérieur des accolades, nous ajoutons le code que
nous voulons exécuter. Si la condition est vraie, nous allons simplement
imprimer un
message simple sur la console. Nous allons dire console.log. Un, c'est moins de deux. Nous allons sauver ça. Nous reviendrons au navigateur. Maintenant, je vais simplement
utiliser la
commande de touches R pour rafraîchir mon écran, mais vous pouvez utiliser le
bouton d'actualisation de votre navigateur. Là, nous recevons le message
parce que la condition était vraie. Faisons un autre exemple. Supprimons cela. Et nous allons créer une variable. Appelons-le si nous allons initialiser cela avec la chaîne Sunny va créer
une autre instruction if. Nous utilisons donc le mot-clé def, les parenthèses, les
accolades d'ouverture et de fermeture. Cette fois,
nous allons vérifier si le temps est ensoleillé. Nous dirons donc que le temps
est ensoleillé. Et nous ajouterons à nouveau un message
à la console. Nous allons donc dire console.log. Le temps est ensoleillé. Revenons dans le navigateur. Je suis impressionné. Rafraîchir Là, nous recevons le message à nouveau parce que
le temps est ensoleillé. Mais revenons à l'
éditeur de code et nous allons
changer la valeur en pluvieux. Nous ne changerons rien
dans l'énoncé if, mais nous
sauvegarderons cela et nous allons y aller. Je retourne sur la console
et j'appuie sur Actualiser cette fois-ci parce que
la condition était fausse, le code ne s'exécute jamais et je ne reçois pas de message
dans mon navigateur.
13. Ssif: Bienvenue de retour. Encore une fois pour commencer par
regarder les déclarations si. Si les instructions nous permettent d'
exécuter ou d'exécuter un morceau de code selon qu'une
condition est vraie ou fausse. Pour écrire une instruction if, vous commencez par utiliser le mot-clé. Si. Le mot-clé if est ensuite suivi d'un
ensemble de parenthèses, qui sont ensuite
suivies d'un ensemble d'accolades. À l'intérieur des
parenthèses, nous avons placé la condition à
l'intérieur des accolades bouclées. Nous avons placé le code que
nous voulons exécuter. Si la condition
est vraie. Si la condition n'est
pas évaluée à true
, le code à l'intérieur des
accolades ne sera pas exécuté dans l'éditeur de texte. Jetons maintenant un coup d'œil
à l'utilisation des instructions if. Nous allons commencer par une
simple instruction if qui imprime quelque chose
sur la console. Si un est inférieur à deux. Nous commençons par le mot clé def. Nous avions un ensemble de parenthèses suivies d'un ensemble d'
accolades bouclées. À l'intérieur des parenthèses, nous
avons l'état que
nous voulons vérifier. Dans ce cas, nous
voulons vérifier si un est inférieur à deux. À l'intérieur des accolades, nous ajoutons le code que
nous voulons exécuter. Si la condition est vraie, nous allons simplement
imprimer un
message simple sur la console. Nous allons dire console.log. Un, c'est moins de deux. Nous allons sauver ça. Retournez dans le navigateur. Maintenant, je vais simplement
utiliser la commande de touches R pour rafraîchir mon écran, mais vous pouvez utiliser le
bouton d'actualisation de votre navigateur. Là, nous recevons le message
parce que la condition était vraie. Faisons un autre exemple. Supprimons cela. Et nous allons créer une variable. Appelons-le si on va initialiser ça avec
la corde ensoleillée. Et nous allons créer
une autre déclaration si. Nous utilisons donc le mot-clé def, les parenthèses et les accolades d'ouverture et de
fermeture. Cette fois,
nous allons vérifier si le temps est ensoleillé. Nous dirons donc que le temps
est ensoleillé. J'ajouterai à nouveau un message
à la console. Nous allons donc dire console.log. Le temps est ensoleillé. Revenons dans le navigateur. Rafraîchir Et là, nous recevons le message à nouveau parce que
le temps est ensoleillé. Mais revenons à l'
éditeur de code et nous allons
changer la valeur en pluvieux. Nous ne changerons rien
dans l'énoncé if, mais nous
sauvegarderons cela et nous allons y aller. Je retourne à la
console et je suis frais, rafraîchissant et cette fois parce que la
condition était fausse, le code ne s'exécute jamais et je ne reçois pas de message
dans mon navigateur.
14. Sselse: utilisant l'instruction else, nous pouvons également
exécuter du code lorsque l'instruction if est
évaluée à false. L'instruction else doit être utilisée en combinaison
avec l'instruction if. Une façon de se rappeler si d'autres déclarations consiste à les considérer comme
des questions oui
ou non. Par exemple, s'il pleut
aujourd'hui, faites quelque chose. S'il ne pleut pas aujourd'hui, faites autre chose. Jetons un coup d'œil à l'utilisation de la souris utilisera à nouveau un
exemple météo. Mais cette fois, je vais y ajouter
une autre déclaration. Nous allons donc créer une
variable qui ferait le temps. Et nous allons initialiser
cela avec de la neige, créera l'instruction if. Nous utilisons donc le mot-clé entre parenthèses
et accolades. Pour la déclaration if vérifiera si le temps est ensoleillé. Et nous ajouterons un journal de console
indiquant s'il s'agit de quelqu'un. Nous pouvons maintenant ajouter la déclaration
else. Nous utilisons donc le mot-clé autre et un autre ensemble
d'accolades. Cette fois, nous
ajouterons un message
indiquant que le temps n'est pas ensoleillé. Gardons ça et
on va y aller. Comme vous pouvez le voir, parce que le
temps n'est pas soudainement, nous obtenons le journal de la console indiquant
s'il n'est pas ensoleillé.
15. Autre: Lorsque nous avons plusieurs conditions avec lesquelles
nous voulons travailler, nous pouvons utiliser else-if pour enchaîner
les instructions ensemble. Par exemple, s'il pleut, nous voudrions peut-être rester à l'intérieur. S'il neige, nous ne voudrons
pas allumer le chauffage. Mais pour toutes les autres conditions
météorologiques, nous voudrions peut-être aller à l'extérieur. Les instructions ELSE-if sont
faites à partir de
la combinaison des mots réservés autres et if, qui sont séparés par un espace. La déclaration else-if vient
toujours après la première déclaration if et avant
la dernière déclaration else. Revenons maintenant à
notre exemple météorologique. Cette fois, j'ajouterai une déclaration autre que lorsque le temps est venteux créera
la variable météorologique. Je vais initialiser
ça avec la corde venteuse. Permet de créer l'énoncé if pour vérifier si
le temps est ensoleillé. Maintenant, nous pouvons ajouter notre déclaration
d'autre part. Nous disons donc autre chose. Ensuite, nous ajoutons un
ensemble de parenthèses et un ensemble d'accolades bouclées. Tout comme lorsque vous
utilisez une déclaration if à l'intérieur des parenthèses, nous mettons la condition que nous voulons vérifier cette fois que vous vouliez dire si le vent est égal. Et s'il y a du vent, j'imprimerai un message
indiquant s'il y a du vent. Enfin, nous ajouterons
une instruction else, dira simplement console.log. Le temps n'est ni venteux ni ensoleillé. Gardons ça
et on va y aller. Comme vous pouvez le constater, étant donné que la
variable météo était réglée sur venteuse, nous recevons le message
s'il y a du vent. Si nous revenons à l'éditeur de
texte et que nous
changerons la météo pour devenir neige. Allons y aller. Nous recevons maintenant le message s'
il n'y a ni vent ni ensoleillé.
16. Opérateurs logiques: Nous sommes maintenant prêts à passer
aux opérateurs logiques. Il existe trois
opérateurs logiques en JavaScript. L'opérateur AND,
l'opérateur OR et l'opérateur NOT. Les opérateurs logiques nous
permettent de rendre la logique de notre code
un peu plus complexe. Si nous revenons à l'arrêt en prenant l'exemple lorsque nous introduisons des opérateurs de
comparaison, nous avons discuté de deux scénarios
que nous
voudrions peut-être vérifier avant qu'un client
puisse passer sa commande. Il s'agissait du nombre de bananes en stock ou de plus de 0. Et plus tard, nous avons discuté de
vérifier si l'utilisateur ne
commandait pas
plus de cinq bananes. Lorsque nous les avons examinés, nous avons examiné ces deux
scénarios de manière indépendante. Toutefois, si nous avions utilisé des opérateurs
logiques, nous pourrons
vérifier
ces deux scénarios en même temps. Commençons par
regarder l'opérateur AND. L'opérateur se compose de deux symboles esperluette et
vérifie si deux
conditions sont vraies. Pour être clair, lorsque
nous disons une condition, il se peut que deux
soient plus grands qu'une. Pour revenir à l'exemple du stock, bananes en stock sont
supérieures à 0 est une condition, et le client
commande moins
de cinq bananes
serait une autre condition. Lorsque nous utilisons l'opérateur AND. Si les deux conditions sont
évaluées à vrai
, la
valeur renvoyée sera vraie. Si aucune des conditions n'est
évaluée à true
, la
valeur renvoyée sera fausse. Mais si une seule
condition est fausse
, l'ensemble
du groupe de conditions sera toujours fausse. Jetons un coup d'œil à
l'utilisation de l'opérateur AND. Commencera par deux expressions, toutes deux étant
les valeurs booléennes vraies. Nous dirons vrai. Vrai. Maintenant, comme ces deux
expressions sont déjà
égales à vrai, l'expression entière est vraie. Essayons encore une fois. Mais cette fois, nous allons définir
la première expression sur true et la deuxième
expression sur false. Nous dirons donc vrai et faux. Cette fois, nous nous trompons parce que toute
l'expression
n'est pas évaluée. Si nous faisons un autre exemple, mais cette fois, nous définissons
les deux expressions sur false, false, false. Cette fois, nous sommes également faux parce que l'
expression entière est fausse. Essayons à nouveau
avec un autre type de données. Disons qu'un a moins de
22 ans, c'est moins de trois. Je tape un, moins de deux et moins de trois. Comme vous pouvez le constater, nous
devenons vrais parce que les deux
conditions sont vraies.
17. Ssor: Nous allons maintenant passer
à l'opérateur OR. L'opérateur est composé
de deux caractères de tuyau. À l'aide de l'opérateur OR, nous pouvons vérifier si l'
une des conditions est vraie. Si l'une des
conditions est vraie
, la condition suivante ne
sera même pas vérifiée car l'opérateur OR ne vérifie les conditions
restantes si l'une des
conditions antérieures est fausse. Dans ce cas, la
valeur renvoyée est vraie. Si aucune des
conditions n'est vraie
, la
valeur renvoyée sera fausse. Jetons maintenant un coup d'œil
à quelques exemples avec tous. Premièrement, nous dirons qu'
il y a dix de plus de neuf ou 11 de plus que dix. Nous disons donc dix de plus que neuf. Est 11 ans de plus que dix. Ces deux
expressions sont vraies, donc comme on s'y attendait, nous devenons vrais. Essayons encore une fois. Mais cette fois, nous dirons qu'
il y a dix ans de plus que neuf ? Neuf est-il supérieur à dix ? Nous disons dix de plus de neuf, ou neuf de plus de dix. Comme la première expression
ici est vraie
, la seconde expression
n'a même pas besoin d'être vérifiée et l'ensemble
sera évalué à vrai. Essayons un autre exemple
qui retournerait faux. Nous dirons donc qu'il y a cinq ans de
plus que six, 11, plus de 12. Et comme on s'y attendait, nous sommes faux.
18. Ssnot: Enfin, nous avons
l'opérateur NOT. L'opérateur NOT inverse sur une démarche la
valeur d'un booléen. L'opérateur NOT
renvoie false si la valeur est vraie et true si
la valeur est fausse, la valeur renvoyée de l'opérateur not sera
toujours brillante. L'opérateur NOT peut être utilisé
avec des types de données non booléens, mais ces valeurs seront
converties en booléens selon que la valeur
est vraie ou fausse. Avant d'être annulé,
vous trouverez ici
une liste des 40 valeurs
sur le site MPN. Commençons par
un exemple simple. Si l'opérateur
NOT dit non vrai, nous obtenons des forces
sur la valeur de retour parce que nous négligeons vrai. Essayons un autre exemple. Si nous disons qu'il y a 20 ans
de moins de 30 ans, nous deviendrons réalité. Mais maintenant, si vous utilisez
l'opérateur NOT, nous disons
donc pas 20, moins de 30. Cette fois-ci, nous devenons faux
parce que c'est désormais faux. J'ai parlé plus tôt des valeurs
fausses en JavaScript. L'une d'elles est une chaîne vide. Donc maintenant, si nous utilisons
suffisamment d'opérateur sur une chaîne vide, nous devions vrai. Si nous le faisons avec
une valeur non défectueuse, c'est
ce que nous
appelons une valeur véridique. Comme dans une chaîne, les
caractères écoutés ne diront pas. Bonjour. Vous pouvez voir que nous devions faux.
19. Introduction de boucles: Nous sommes maintenant prêts à commencer à
parler de boucles. En boucle, répétons encore
et encore du code jusqu'à ce qu'une
condition soit remplie. Nous utilisons une boucle lorsque nous
avons une logique que nous
devons répéter. Si vous sortez faire une
promenade et que vous voulez
atteindre 10 000
pas à plusieurs reprises, vous faites des pas jusqu'à ce que vous en atteigniez 10 000,
puis vous arrêtez. Ce serait un exemple
de répéter une séquence encore et encore jusqu'à ce que
vous atteigniez une condition. Vous avez peut-être rencontré
le terme pour
parcourir quelque chose comme un tableau. C'est la même chose
que l'utilisation d'une boucle. Les trois types
de boucles les plus courants en JavaScript, ou la boucle for, while loop
et la boucle do-while. Une boucle for-loop est utile
pour exécuter du code lorsque nous savons combien de fois
nous voulons que la boucle s'exécute. Par exemple, il se peut que nous
souhaitions exécuter du code plusieurs fois jusqu'à ce que nous atteignions
une valeur spécifique. Si nous n'utilisions pas la boucle, nous devrions écrire
à
plusieurs reprises le code que nous voulons exécuter, ce qui enfreignerait un
principe clé du codage du code. Ne vous répétez pas,
parfois raccourci pour sécher. En revenant aux boucles for-loop, il y a trois
parties dans la boucle. L'initialisation,
la condition et l'
expression finale ou le programme de mise à jour. Pour initialiser la boucle, nous
créons une variable appelée I, ce qui est pratique courante. Nous utiliserons la variable
est le compteur. Nous allons initialiser cette
variable avec une valeur de 0. Ensuite, nous créons la
condition qui est le point d'arrêt
du moment où la variable doit
cesser de compter. Donc, si nous voulons compter jusqu'
à dix, mais sans inclure dix, nous dirions que j'ai moins de dix ans. Enfin, pour le programme de mise à jour, nous indiquerons comment
le compteur doit changer chaque fois que la boucle s'exécute. Donc, si nous voulions
compter jusqu'à dix, nous pouvons utiliser l'opérateur d'
incrément. L'
opérateur d'incrément se compose de deux symboles d'ajout et nous allons incrémenter
la valeur d'un. Jetons un coup d'œil aux boucles. Commençons par créer
la chaudière. Pour le for-loop. Nous avons parlé de l'
ensemble de parenthèses de mots clés for et
d'un ensemble d'accolades bouclées. Avec cette boucle,
supposons que nous voulions imprimer les chiffres
de un à cinq. Entre parenthèses. Nous commençons par créer
une variable appelée i. Nous disons œil gauche. Ensuite, nous l'
initialisons avec la valeur 0. Aide à la fin de
l'initialisation. Nous ajoutons un point-virgule. Nous passons maintenant à la condition. Nous voulons en compter jusqu'à cinq. Nous dirons donc que si j'ai
moins ou égal à cinq, cela signifie que
la boucle s'arrêtera une fois que j'aurai plus de cinq ans, nous ajoutons un autre point-virgule parce que nous sommes à la
fin de la condition. Maintenant, chaque fois que la boucle s'exécute, nous voulons l'incrémenter d'un. Nous dirons donc que je suis avec
l'opérateur d'incrément. À l'intérieur des accolades, nous voulons ajouter le
code que nous voulons exécuter chaque fois que la boucle s'exécute. Nous allons donc faire un console.log. Nous allons imprimer la valeur de I. Je vais l'enregistrer et
nous allons y aller. Comme vous pouvez le constater
, toutes les valeurs jusqu'à cinq sont
imprimées sur la console. Prenons un autre
exemple en utilisant des tableaux. Nous avons un tableau
avec quelques valeurs ,
puis nous
devons parcourir ce tableau afin de pouvoir imprimer la valeur de chaque élément
du tableau. C'est à ce moment-là que nous procédons comme suit. Créons un tableau. Nous appellerons ça des lettres. J'ajouterai quelques lettres. Maintenant, nous pouvons fabriquer la
chaudière pour notre boucle for. On en dira quatre avec les
parenthèses et les accolades bouclées. Ensuite, nous allons créer
la variable pour I. Nous voulons initialiser
cette variable avec la valeur 0. Et c'est parce que nous
voulons commencer à compter à
partir du premier
élément du tableau, qui est à l'indice 0. Maintenant, pour la condition, nous voulons continuer
cette boucle jusqu'à ce que tous les éléments du tableau
soient imprimés. Nous pouvons utiliser la longueur
du tableau dira moi moins que les lettres longueur de point. Et puis chaque fois que la boucle
s'exécute, on veut incrémenter i. l'intérieur des accolades bouclées. Nous avons mis le code
que nous voulions
exécuter chaque fois que la boucle s'exécute. Nous allons donc juste déconnecter l'élément de la
console. Nous disons des lettres, puis nous
transmettons moi pour obtenir l'index. Allons y aller. Vous pouvez maintenant voir que chaque
fois que la boucle s'exécute, nous obtenons chaque élément
du tableau.
20. Les boucles: Une boucle While s'exécute
plus rapidement est vraie et s'arrête quand
elle n'est plus vraie. Bien que les boucles soient utiles
lorsque nous ne savons pas combien de fois nous
voulons que le code s'exécute. La boucle While consiste en une
condition et une instruction. La condition sera
une expression booléenne, quelque chose dont la
valeur est vraie ou fausse. Et l'état
sera vérifié à chaque fois que la boucle s'exécute. L'instruction est le code qui s'exécute chaque fois que
la condition est vraie. convient également de mentionner ici qu'il y a un danger lorsque vous travaillez avec des boucles de la
boucle qui s'exécutent indéfiniment. Si une condition pour mettre fin à
la boucle n'est jamais remplie. C'est ce qu'
on appelle une
boucle infinie et cela provoquera un crash. Il vaut donc la peine de s'assurer que vous configurez correctement vos
conditions. Passons maintenant à la
création d'une boucle While. Lorsque nous avons cherché des boucles, nous avons créé une boucle for-loop pour compter
jusqu'à cinq. Essayons d'y parvenir à nouveau, mais cette fois, nous
utiliserons la boucle while. La syntaxe est très
similaire à une boucle for-loop,
sauf que cette fois, vous
utilisez le mot-clé pendant que vous utilisez le mot-clé. Nous disons, alors que nous avions un ensemble de parenthèses et un
ensemble d'accolades bouclées. Nous allons commencer par initialiser une variable pour agir
comme compteur. Pour la boucle While. Nous le faisons en dehors de la boucle. Variable créative, que
nous appellerons numéro. Et nous allons initialiser
cela avec la valeur 0. Pour la condition
à l'intérieur des parenthèses, on dira un nombre
inférieur ou égal à cinq. Maintenant, dans les accolades, nous allons consoler déconnecter
la valeur du nombre. Si nous essayons de l'exécuter maintenant, ce serait un exemple de
création d'une boucle infinie. Nous ne faisons
rien pour augmenter la valeur du nombre chaque
fois
que la boucle s'exécute. Le nombre sera donc toujours 0, alors la condition ne
sera jamais remplie. Évitons cela et nous dirons numéro avec l'opérateur
d'incrément. Enregistrera cela et retourne à la console et appuyez sur Actualiser. Comme vous pouvez le constater, nous obtenons le même comportement
qu'avec une boucle for-loop et le nombre est incrémenté chaque
fois que la boucle s'exécute.
21. Faire des boucles: La dernière boucle dont nous allons
parler s'appelle une
boucle do while est très similaire
à une boucle while, sauf que les
instructions à l'intérieur la boucle seront toujours
exécutées sur celles-ci. Si la condition est fausse, la boucle sera toujours exécutée
une fois avant sa fin. La configuration de la
boucle do-while est légèrement différente car le code
et les accolades bouclées viennent avant la condition. Et c'est ce qui
permet à la boucle de
s'exécuter une fois avant que les
conditions ne soient remplies. Passons maintenant à la
création d'une boucle « do-while ». Nous commençons par
le mot-clé Duke. Nous avions un ensemble de catégories. Après cela, nous ajoutons
le mot-clé while et un ensemble de parenthèses. Déclarera également une variable
que nous
appellerons I. Nous allons initialiser
cela avec la valeur 0. Pour la condition. Disons que je suis
inférieur ou égal à cinq. Maintenant, dans les accolades, va
imprimer la valeur de I, va également incrémenter i. Sauvegardons cela
et donnons un coup de main. Revenez à la console
et appuyez sur Actualiser. Maintenant, comme vous pouvez le voir quand il s'exécute, on m'imprime jusqu'
à la valeur de cinq. Essayons encore une fois. Mais cette fois, nous commencerons par être initialisé
à la valeur six. Cela signifie que la condition ne
sera jamais remplie. Mais essayons encore une fois. Je vais donc revenir à
la console et appuyer sur Actualiser, comme vous pouvez le voir, car nous utilisons
la boucle do-while et donc le code
s'exécute au moins une fois. Nous obtenons toujours la valeur de moi
imprimée, mais seulement une seule fois. Et puis la boucle se termine.