Journée de plongée approfondie dans les types de données JavaScript, le mode strict et les opérations de base

Bienvenue dans notre série de didacticiels JavaScript ! Dans l'article d'aujourd'hui, nous explorerons quelques concepts fondamentaux de JavaScript : les types de données, le mode strict et les opérations de base. Ce sont les éléments constitutifs de tout programme JavaScript, donc bien les comprendre vous préparera au succès à mesure que vous approfondirez le codage.

Comprendre les types de données en JavaScript

JavaScript est un langage typé dynamiquement, ce qui signifie que vous n'avez pas besoin de spécifier le type de données contenues dans une variable. Le type est déterminé automatiquement en fonction de la valeur attribuée. Examinons de plus près certains des types de données clés en JavaScript.

type d'opérateur

L'opérateur typeof est utilisé pour déterminer le type d'une variable. Voici un exemple rapide :

console.log(typeof undefined); // Outputs: "undefined"
console.log(typeof null);      // Outputs: "object"

• non défini : Lorsqu'une variable est déclarée mais qu'aucune valeur ne lui est attribuée, son type est indéfini.
• null : représente l'absence intentionnelle de toute valeur d'objet. Fait intéressant, typeof null renvoie un objet. Il s’agit d’une bizarrerie connue de JavaScript, et même si cela peut sembler déroutant, c’est une chose à laquelle vous vous habituerez.

Types de données clés

1. Nombre : représente à la fois des nombres entiers et des nombres à virgule flottante.

   • Exemple : soit num = 42 ;
   • JavaScript peut gérer des nombres jusqu'à 2 ^ 53, au-delà desquels vous utiliserez un BigInt.

2. BigInt : utilisé pour les grands entiers qui se situent au-delà de la plage d'entiers sûrs pour Number.

   • Exemple : laissez bigNum = 9007199254740991n ;

3. Chaîne : Une séquence de caractères, utilisée pour le texte.

   • Exemple : let Greeting = "Bonjour tout le monde !";

4. Booléen : Représente des valeurs logiques : vraie ou fausse.

   • Exemple : let isJavaScriptFun = true;

5. Null : Un mot-clé spécial désignant une valeur nulle, c'est-à-dire aucune valeur du tout.

   • Exemple : let emptyValue = null ;

6. Non défini : Indique qu'une variable a été déclarée mais qu'aucune valeur n'a été affectée.

   • Exemple : laisser quelque chose ;

7. Symbole : Représente un identifiant unique. Les symboles sont souvent utilisés comme clés dans les objets pour éviter les collisions de noms.

   • Exemple : let uniqueId = Symbol("id");

Application du JavaScript moderne avec "use strict"

Pour garantir que votre code respecte les dernières normes JavaScript et éviter les pièges courants, vous pouvez utiliser « use strict » au début de vos scripts ou fonctions.

"use strict";
// All code below will be treated as newer version of JavaScript

Le mode strict permet de détecter les erreurs de codage courantes, telles que l'utilisation de variables non déclarées, et rend votre code plus sécurisé et optimisé.

Effectuer des opérations de base en JavaScript

JavaScript prend en charge un large éventail d'opérations, de l'arithmétique de base à la concaténation de chaînes. Regardons quelques exemples :

Opérations arithmétiques

let value = 3;
let negValue = -value;
console.log(negValue); // Outputs: -3

console.log(2 + 2); // Addition: 4
console.log(2 - 2); // Subtraction: 0
console.log(2 * 2); // Multiplication: 4
console.log(2 ** 3); // Exponentiation: 8
console.log(2 / 3); // Division: 0.666...
console.log(2 % 3); // Modulus: 2 (remainder)

Opérations sur les chaînes

let str1 = "hello";
let str2 = " hitesh";

let str3 = str1 + str2;
console.log(str3); // Outputs: "hello hitesh"

console.log("1" + 2); // Outputs: "12" (String concatenation)
console.log(1 + "2"); // Outputs: "12" (String concatenation)
console.log("1" + 2 + 2); // Outputs: "122"
console.log(1 + 2 + "2"); // Outputs: "32"

L’ordre des opérations compte ! Lorsque JavaScript rencontre une chaîne dans une opération arithmétique, il convertit les autres opérandes en chaînes et les concatène.

Opérations combinées

console.log((3 + 4) * 5 % 3); // Outputs: 2

Ici, les parenthèses dictent l'ordre des opérations, garantissant que l'addition se produit avant la multiplication et le module.

Opérateurs unaires

Les opérateurs unaires fonctionnent avec un seul opérande. Voici quelques exemples :

console.log(+true); // Outputs: 1 (Boolean `true` is converted to 1)
console.log(+""); // Outputs: 0 (An empty string is converted to 0)

Chaînage d’affectation de variables

Vous pouvez enchaîner les affectations en JavaScript :

let num1, num2, num3;
num1 = num2 = num3 = 2 + 2;
console.log(num1, num2, num3); // All will output: 4

Opérateurs d'incrémentation

JavaScript prend également en charge les opérateurs d'incrémentation (et de décrémentation) :

let gameCounter = 100;
++gameCounter;
console.log(gameCounter); // Outputs: 101

Incrément de préfixe et de postfixe

JavaScript fait la distinction entre les incréments de préfixe (++gameCounter) et de suffixe (gameCounter++) :

• Préfixe : Incrémente la valeur avant de l'utiliser.
• Postfix : utilise d'abord la valeur, puis l'incrémente.

Pour une lecture plus approfondie sur les conversions de types et les opérations, consultez la documentation ECMAScript.

Aujourd'hui, nous avons abordé quelques concepts JavaScript essentiels, de la compréhension des différents types de données et du mode strict à l'exécution d'opérations de base. Ce sont des concepts fondamentaux sur lesquels vous vous baserez au fur et à mesure de votre progression en JavaScript. Assurez-vous de mettre en pratique ces exemples et d'expérimenter différentes opérations pour mieux comprendre.

Restez à l'écoute pour plus de didacticiels dans cette série alors que nous continuons à explorer le monde fascinant de JavaScript !

-
Bon codage et à bientôt !!

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!