Types de données primitifs et non primitifs en JavaScript

Les types de données sont généralement connus comme l'un des éléments constitutifs de tout langage de programmation. C'est pourquoi connaître les types de données dans un langage de programmation est essentiel et crucial pour devenir programmeur professionnel. Les types de données en JavaScript ont été classés en deux catégories différentes. Cet article affichera la différence entre ces deux catégories différentes à l'aide d'exemples.

Note supplémentaire: Tout dans JavaScript est connu pour être un objet, chaque type de données peut être primitif ou non primitif, c'est un objet de javascript.

Types de données primitives en javascript

Par définition, les types de données primitifs sont les types de données qui ont été mis en JavaScript par les développeurs de JavaScript. Ou, en mots beaucoup plus simples, ces types de données ont été prédéfinis en JavaScript. La liste des types de données primitives de JavaScript comprend les éléments suivants:

• chaîne
• nombre
• grand
• booléen
• indéfini
• symbole
• nul

Tous les types de données mentionnés dans la liste ci-dessus ont des contraintes spécifiques. Ces contraintes incluent le type de valeur qu'ils peuvent stocker à l'intérieur de leur variable, la limite maximale de cette valeur et la taille maximale de la mémoire qu'ils peuvent consommer. Pour démontrer le fonctionnement de certains des types suivants, regardez les exemples suivants ci-dessous:

1: cordes

Pour créer une chaîne, créez simple une variable et définissez-la égale à une chaîne enfermée à l'intérieur des doubles guillemets comme:

StringVar = "Bienvenue sur LinuxHint";

Affichez-le sur le terminal à l'aide de la fonction de journal de la console:

console.log (StringVar);

Et le terminal montrera ce qui suit:

La chaîne a été imprimée sur le terminal, la contrainte de définition d'une chaîne peut être l'encapsulation avec un double devis.

2: Nombres

Pour créer une variable du type de données des nombres, définissez simplement sa valeur égale à un entier ou à un point flottant comme:

num1 = 50;
num2 = 20.33;
console.log (num1);
console.log (num2);

L'exécution de ce qui suit donne la sortie suivante sur le terminal:

La contrainte pour créer un nombre est qu'elle ne peut contenir aucune autre valeur que les caractères numériques et un point décimal.

3: indéfini

Undefined est un type de données non trouvé dans de nombreux langages de programmation. Ce type de données définit simplement la mémoire de la variable comme attribué, Mais aucune valeur n'est placée à l'intérieur de ce souvenir. Pour démontrer cela, utilisez:

var x = non défini;
varier;
console.log (x);
console.journal (y

Une variable est définie sur le mot-clé indéfini, et l'autre est simplement créé et ne donne aucune valeur. Lors de l'exécution du code, le terminal montre:

Les deux variables sont retournées indéfinies sur le terminal.

4: Booléens et null

Les booléens peuvent être définis en créant une variable et en les définissant égaux au mot clé vrai ou FAUX, et les variables nulles peuvent être définies en définissant la valeur égale à la clé nul. Utilisez les lignes suivantes pour démontrer ces deux types de données:

var x = true;
var y = null;
console.log (x);
console.journal (y);

Lors de l'exécution des lignes de code ci-dessus, le terminal s'affiche:

Types de données non primitives en javascript

Ce sont les types de données que le programmeur définit sous un nom particulier lors de l'écriture d'un programme JavaScript. Le point clé de ces types de données est que leur taille n'est pas définie, et ils peuvent stocker les valeurs de presque tous les types de données primitives. Les types de données non primitifs en JavaScript sont les suivants:

• Objets (utilisateur - défini)
• Tableaux

Passons en revue le fonctionnement des types de données non primitives un par un

1: objets

Pour créer un objet, il existe deux façons différentes, on comprend l'utilisation du "Nouveau objet ()" constructeur et l'autre est connu comme la notation littérale. Pour le constructeur de nouveaux objets (), prenez les lignes suivantes:

var obj1 = nouveau objet ();
obj1.stringval = "String à l'intérieur de l'objet";
obj1.intVal = 14;
console.log (obj1);

Dans les lignes ci-dessus:

• La variable obj1 a été créé en utilisant le Nouveau objet () constructeur
• Obj1 a reçu 2 valeurs stringval et intval, stringval est une valeur de type de données de chaîne tandis que le intval est une valeur de type de données numérique.
• La fonction de journal de la console est utilisée pour afficher la sortie sur le terminal

L'exécution du code ci-dessus fournit le résultat suivant sur le terminal:

La variable obj a été affiché sur le terminal dans la notation de l'objet. L'autre façon de créer une variable d'objet est d'utiliser une notation littérale. Pour le démontrer, utilisez les lignes suivantes:

var obj1 =
StringVal: "String à l'intérieur de l'objet",
Intval: 14,
;
console.log (obj1);

Comme il est clair à partir de l'extrait de code ci-dessus, pour utiliser la notation littérale pour la définition d'objet, utilisez simplement le accolades Comme la valeur de la variable et à l'intérieur des supports bouclés, passez les paires de valeurs clés. L'exécution des lignes de code ci-dessus fournit la sortie suivante:

La sortie est les paires de valeurs clés de l'objet en notation littérale

2: tableaux

Les tableaux sont également considérés comme un type de données primitif dans le langage JavaScript. Et la raison en est le fait que la taille des tableaux n'est pas définie, plus elles peuvent stocker les valeurs à partir de types de données primitifs. Utilisez les lignes suivantes comme exemple de définition du tableau:

var array1 = [1, 2, true, "google", undefined, null];

Après cela, passez cette variable de tableau "Array1" à la fonction de journal de la console comme:

console.log (array1);

Et le résultat sur le terminal sera:

Le Array1 une variable avec presque tous les types de données primitives a été imprimée sur le terminal

Conclure

Les types de données primitifs sont les types de données prédéfinis en JavaScript, ont une contrainte sur la façon de les définir et les valeurs qu'ils peuvent stocker, et enfin, ils ont une taille limitée. Alors que les types de données non primitives en JavaScript incluent l'objet et le tableau. Les types de données non primitifs n'ont pas de contrainte sur le type de valeur qu'ils peuvent stocker. De même, ils n'ont pas de limite de taille maximale sur eux.