JavaScript-Variablen und Datentypen: Speichern und Bearbeiten von Daten in JavaScript.

JavaScript est un langage de programmation polyvalent qui alimente le Web, permettant aux développeurs de créer des sites Web interactifs et dynamiques. L'un des concepts fondamentaux de JavaScript, et de tout langage de programmation, est la manière dont les données sont stockées et manipulées. Pour créer efficacement des applications Web, il est essentiel de comprendre les variables et les types de données en JavaScript.

Dans cet article, nous expliquerons ce que sont les variables, comment les déclarer et les différents types de données pris en charge par JavaScript pour stocker et manipuler les données.

Variables en JavaScript

Qu'est-ce qu'une variable ?

Une variable en JavaScript est comme un conteneur qui contient des données. Il vous permet de stocker et de récupérer des valeurs que vous pouvez utiliser tout au long de votre programme. Considérez les variables comme des étiquettes attachées à des valeurs. Une fois que vous attribuez une valeur à une variable, vous pouvez y faire référence par son nom, plutôt que d'utiliser la valeur directement à chaque fois.

Par exemple, au lieu d'écrire « John » plusieurs fois, vous pouvez l'attribuer à une variable comme celle-ci :

let name = "John";
console.log(name);  // Outputs: John

Déclaration de variables

En JavaScript, les variables peuvent être déclarées à l'aide des mots-clés var, let ou const.

1. var

var est la manière la plus ancienne de déclarer des variables en JavaScript. Cependant, il présente quelques problèmes de portée, c'est pourquoi les développeurs JavaScript modernes préfèrent utiliser let et const.

var age = 30;
console.log(age);  // Outputs: 30

2. laisser

let a une portée de bloc, ce qui signifie que la variable n'existe que dans le bloc dans lequel elle est définie (par exemple, à l'intérieur d'une fonction ou d'une boucle). C'est le moyen le plus couramment utilisé pour déclarer des variables en JavaScript moderne.

let city = "New York";
console.log(city);  // Outputs: New York

3. const

const est similaire à let, mais il est utilisé pour déclarer des variables dont les valeurs ne changeront pas. Une fois qu'une valeur est attribuée à une variable déclarée avec const, elle ne peut pas être réaffectée.

const country = "USA";
console.log(country);  // Outputs: USA

// This will throw an error
// country = "Canada";  

Nommer les variables

Lorsque vous nommez des variables, gardez les règles suivantes à l'esprit :

• Les noms de variables peuvent contenir des lettres, des chiffres, des traits de soulignement (_) et des signes dollar ($).
• Ils doivent commencer par une lettre, un trait de soulignement ou un signe dollar.
• Les noms de variables sont sensibles à la casse (par exemple, myVar et myvar sont des variables différentes).
• Les mots-clés JavaScript (par exemple, var, let, if, function) ne peuvent pas être utilisés comme noms de variables.

Une convention courante consiste à utiliser camelCase pour les noms de variables, comme myVariableName.

Types de données en JavaScript

JavaScript prend en charge divers types de données qui spécifient le type de valeur qu'une variable peut contenir. Les types de données sont divisés en deux catégories :

• Types de données primitifs
• Types de données non primitifs (de référence)

Types de données primitifs

Les types de données primitifs sont les types de données les plus élémentaires en JavaScript. Ils comprennent :

1. Chaîne

Les chaînes sont utilisées pour représenter des données textuelles. Ils sont entourés de guillemets : simples ('), doubles (") ou guillemets (`).

let greeting = "Hello, World!";
let anotherGreeting = 'Hi there!';
console.log(greeting);  // Outputs: Hello, World!

2. Numéro

Le type de données numérique représente à la fois des nombres entiers et des nombres à virgule flottante (c'est-à-dire des décimales).

let age = 25;       // Integer
let price = 99.99;  // Floating-point number

3. Booléen

Les booléens représentent des valeurs logiques : vraies ou fausses. Ils sont souvent utilisés dans les instructions conditionnelles et les comparaisons.

let isLoggedIn = true;
let hasAccess = false;

4. Non défini

Lorsqu'une variable est déclarée mais qu'aucune valeur ne lui est attribuée, elle est automatiquement initialisée avec la valeur non définie.

let myVar;
console.log(myVar);  // Outputs: undefined

5. Nul

null représente une valeur explicitement vide ou inexistante. Il est utilisé lorsque l'on souhaite indiquer qu'une variable ne doit avoir aucune valeur.

let emptyValue = null;

6. Symbole

Les symboles sont des valeurs uniques et immuables, généralement utilisées pour créer des clés de propriété uniques pour les objets. Bien qu'ils ne soient pas couramment utilisés par les débutants, ils sont utiles dans les applications avancées.

let symbol1 = Symbol("description");

7. BigInt

Le type BigInt permet la représentation de nombres entiers plus grands que la plage du type Number. C’est particulièrement utile lorsque vous travaillez avec de très grands entiers.

let bigNumber = BigInt(123456789012345678901234567890);

Types de données non primitifs (référence)

Les types de données non primitifs stockent des structures de données et des objets plus complexes. Ils sont appelés types de référence car les variables stockent des références aux données réelles.

1. Objet

Les objets sont des collections de paires clé-valeur. Ils vous permettent de stocker plusieurs valeurs associées en tant que propriétés.

let person = {
  name: "John",
  age: 30,
  isStudent: false
};
console.log(person.name);  // Outputs: John

2. Array

Arrays are ordered collections of values (elements). Arrays can store multiple values in a single variable, and the values can be of any data type.

let fruits = ["Apple", "Banana", "Cherry"];
console.log(fruits[1]);  // Outputs: Banana

3. Function

Functions are blocks of code designed to perform a particular task. In JavaScript, functions themselves are treated as objects, allowing them to be passed as arguments or stored in variables.

function greet() {
  console.log("Hello!");
}
greet();  // Outputs: Hello!

Type Coercion and Dynamic Typing

JavaScript is dynamically typed, which means you don’t need to explicitly declare the type of a variable. JavaScript will automatically infer the type based on the value assigned. For example:

let variable = "Hello";  // variable is of type string
variable = 42;           // variable is now of type number

In addition, JavaScript performs type coercion, which means it will automatically convert values from one type to another when necessary.

console.log("5" + 10);  // Outputs: "510" (String concatenation)
console.log("5" - 1);   // Outputs: 4 (Number subtraction)

In the first example, JavaScript coerces 10 to a string and concatenates it with "5". In the second example, "5" is coerced into a number for subtraction.

Conclusion

Understanding variables and data types is a fundamental step in learning JavaScript. Variables allow you to store and manage data in your programs, while data types define the kind of data you’re working with, from strings to numbers, booleans, and beyond.

As you continue learning JavaScript, you'll frequently use variables and work with various data types to build interactive and dynamic web applications. By mastering how to manipulate these data types, you’ll be able to write more efficient and effective code.

Das obige ist der detaillierte Inhalt vonJavaScript-Variablen und Datentypen: Speichern und Bearbeiten von Daten in JavaScript.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!