Types de données Day, variables, opérateurs, instructions conditionnelles, boucle en Javascript

Type de données JavaScript :

En JavaScript, les types de données définissent les types de valeurs qu'une variable peut contenir. Le type détermine quelles opérations peuvent être effectuées sur la valeur. JavaScript possède à la fois des types de données primitifs (valeurs simples) et des types de données de référence (objets complexes).

1. Type de données d'origine :

Ce sont les types de données les plus basiques en JavaScript, ils contiennent une valeur unique. Ils sont immuables, ce qui signifie qu’une fois leurs valeurs définies, elles ne peuvent plus être modifiées.

a) Numéro :

représente des nombres entiers et des nombres à virgule flottante.

let x = 42;

b) Chaîne :

représente une série de caractères.

let name = "Alice";

c) Booléen :

signifie vrai ou faux.

let isActive = true;

d) Nulle :

signifie ne pas avoir intentionnellement de valeur d'objet.

let person = null;

e) Non défini :

Indique une variable qui a été déclarée mais à laquelle aucune valeur n'a été attribuée.

let value;

f) Symbole :

Un identifiant unique.

const uniqueID = Symbol();

g) BigInt :

est utilisé pour représenter de grands entiers.

let bigNum = 123n;

2. Type de données de référence :

Ces types de données sont plus complexes, stockant des collections de valeurs ou des données plus structurées. Ils sont mutables, ce qui signifie que leur contenu peut changer même si la référence reste la même.

a) Objet :

Une collection de paires clé-valeur.

let person = {name: "John"};

b) Tableau :

Une collection triée de valeurs.

let arr = [1, 2, 3];

c) Fonction :

Bloc de code qui effectue des tâches.

function greet() {}

Variables JavaScript :

En JavaScript, les variables sont nommées conteneurs pour stocker des données qui peuvent être référencées et manipulées dans tout votre code.

Les variables vous permettent de stocker des valeurs telles que des nombres, des chaînes, des objets et des fonctions.

1. Déclarez les variables :

En JavaScript, les variables sont déclarées à l'aide de l'un des trois mots-clés suivants :

var (ancienne méthode, moins utilisée maintenant) let (portée du bloc, introduite dans ES6) const (portée du bloc, pour les constantes, également introduite dans ES6)

a) var (ancienne méthode) :

Le mot-clé var est traditionnellement utilisé pour déclarer des variables en JavaScript.

var name = "Alice"; var age = 25;

b) laisser (méthode moderne) :

La portée du bloc signifie qu'une variable n'est accessible que dans le bloc dans lequel elle est définie (par exemple, dans une instruction if ou une boucle).

let name = "Bob"; let age = 30;

c) const (variable constante) :

Le mot-clé const est utilisé pour déclarer les variables qui ne doivent pas être réaffectées après l'affectation initiale.

const country = "USA";

Redéclarer les variables :

Utilisez var : Vous pouvez redéclarer des variables dans la même portée et JavaScript ne générera pas d'erreur.

<code class="language-javascript">var name = "Alice";
var name = "Bob";  // 没有错误
console.log(name);  // 输出：Bob</code>

Utilisez let et const : Vous ne pouvez pas redéclarer une variable dans la même portée. Cela provoquerait une SyntaxError.

<code class="language-javascript">let name = "Alice";
let name = "Bob";  // SyntaxError: Identifier 'name' has already been declared</code>

<code class="language-javascript">const country = "USA";
const country = "Canada";  // SyntaxError: Identifier 'country' has already been declared</code>

Opérateurs JavaScript :

En JavaScript, les opérateurs sont des symboles ou des mots-clés qui effectuent des opérations sur les opérandes.

1. Opérateurs arithmétiques :

Ces opérateurs sont utilisés pour effectuer des opérations mathématiques sur des valeurs numériques.

<code>+               加法                        5 + 3 → 8
-               减法                        5 - 3 → 2
*               乘法                        5 * 3 → 15
/               除法                        5 / 3 → 1.6667
%               取模（除法的余数）        5 % 3 → 2
**              幂运算（乘方）              2 ** 3 → 8
++              递增（加 1）                let x = 5; x++ → 6
--              递减（减 1）                let x = 5; x-- → 4</code>

2. Opérateur d'affectation :

Ces opérateurs sont utilisés pour attribuer des valeurs aux variables.

<code>=               简单赋值                     let x = 10;
+=              加法赋值                     x += 5; → x = x + 5;
-=              减法赋值                     x -= 5; → x = x - 5;
*=              乘法赋值                     x *= 5; → x = x * 5;
/=              除法赋值                     x /= 5; → x = x / 5;
%=              取模赋值                     x %= 5; → x = x % 5;
**=             幂赋值                       x **= 2; → x = x ** 2;</code>

3. Opérateurs de comparaison :

Ces opérateurs comparent deux valeurs et renvoient une valeur booléenne (vrai ou faux).

<code>==              等于                          5 == "5" → true
===             全等                          5 === "5" → false
!=              不等于                        5 != "5" → false
!==             不全等                        5 !== "5" → true
>               大于                          5 > 3 → true
>=              大于等于                      5 >= 3 → true
<               小于                          5 < 3 → false
<=              小于等于                      5 <= 3 → false</code>

4. Opérateurs logiques :

Ces opérateurs sont utilisés pour effectuer des opérations logiques, généralement en utilisant des valeurs booléennes.

<code>&&              逻辑与                        true && false → false
||              逻辑或                        true || false → true
!               逻辑非                        !true → false</code>

Instruction conditionnelle JavaScript :

En JavaScript, les instructions conditionnelles sont utilisées pour effectuer différentes actions selon qu'une condition spécifique est vraie ou fausse.

1. si déclaration

L'instruction if est l'instruction conditionnelle la plus élémentaire. Si la condition spécifiée est vraie, le bloc de code est exécuté.

Grammaire :

<code class="language-javascript">if (condition) {
    // 如果条件为真，则执行的代码块
}</code>

2. autre déclaration

L'instruction

else suit l'instruction if et définit un bloc de code qui est exécuté si la condition de l'instruction if est fausse.

Grammaire :

<code class="language-javascript">if (condition) {
    // 如果条件为真，则执行的代码块
} else {
    // 如果条件为假，则执行的代码块
}</code>

3. sinon si déclaration

L'instruction else if vous permet de tester plusieurs conditions. Utilisez-le lorsque vous devez vérifier plusieurs conditions.

Grammaire :

<code class="language-javascript">if (condition1) {
    // 如果 condition1 为真，则执行的代码块
} else if (condition2) {
    // 如果 condition2 为真，则执行的代码块
} else {
    // 如果 condition1 和 condition2 都为假，则执行的代码块
}</code>

4. Déclarations if imbriquées

Vous pouvez imbriquer des instructions if dans d'autres instructions if pour créer des conditions plus complexes.

5. déclaration de changement

L'instruction switch est un moyen plus efficace de tester une valeur avec plusieurs conditions, en particulier lorsque vous avez de nombreux résultats possibles différents.

Grammaire :

<code class="language-javascript">switch (expression) {
    case value1:
        // 如果 expression === value1，则运行的代码
        break;
    case value2:
        // 如果 expression === value2，则运行的代码
        break;
    default:
        // 如果没有 case 匹配，则运行的代码
}</code>

Boucle JavaScript :

En JavaScript, une boucle est utilisée pour exécuter de manière répétée un bloc de code tant qu'une condition spécifique est remplie. Ceci est utile lorsque vous souhaitez effectuer des tâches répétitives, telles que parcourir un tableau ou exécuter plusieurs fois un bloc de code.

1. pour la boucle

La boucle for est la boucle la plus courante en JavaScript. Ceci est généralement utilisé lorsque vous savez combien de fois vous souhaitez parcourir un bloc de code.

Grammaire :

<code class="language-javascript">for (initialization; condition; increment/decrement) {
    // 每次迭代中要执行的代码
}</code>

2. boucle while

La boucle while exécute un bloc de code tant que la condition spécifiée est évaluée comme vraie. La condition est vérifiée avant chaque itération et la boucle s'arrête dès que la condition devient fausse.

Grammaire :

<code class="language-javascript">while (condition) {
    // 只要条件为真就执行的代码
}</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!