L'apprentissage d'un langage de programmation n'a que deux aspects: l'un est la syntaxe et l'autre est le type de données. La syntaxe des langues de type C n'est rien de plus que si, pendant que, pour, les fonctions, les opérations arithmétiques, etc., et les langues orientées objet sont ajoutées à l'objet.
La syntaxe n'est qu'un ensemble de règles que les concepteurs de langues ont établi à l'avance. La grammaire de différentes langues est différente, mais elles ont toutes des points communs. Pour ceux qui connaissent un ou deux langages de programmation, la grammaire n'est souvent pas un problème lors de l'apprentissage d'autres langages de programmation (bien sûr, si vous avez appris les langages de type C, il faudra certainement un certain temps pour vous impliquer dans Lisp pour la première fois). L'apprentissage se concentre souvent sur les types de données et les opérations connexes, et il n'y a pas d'ancien dicton: "Structure de données + algorithme = programme"! Deuxièmement, la syntaxe de certaines langues elle-même a des problèmes de conception (JavaScript l'est encore plus), donc nous n'avons pas besoin de creuser dans ces points. Bien sûr, si vous prétendez être du geek, vous pouvez jouer avec.
Cet article donnera une introduction détaillée aux types de données en JavaScript.
Type faible vs type fort
Compte tenu de la philosophie de conception de JavaScript, JavaScript est conçu comme une langue faible.
En parlant de cela, il est inévitable de parler de la différence entre les types faibles et les types forts.
Certaines personnes pensent à tort que la différence entre les deux est que "un langage fortement dactylographié doit indiquer son type lors de la déclaration d'une variable, tandis qu'une faible dactylographie ne l'utilise pas." En fait, ce point de vue est faux. Par exemple, l'extrait de code Java suivant:
La copie de code est la suivante:
String S = "Hello";
int l = s.getBytes (). longueur;
Comment le compilateur sait-il que .Length est une expression légale? En effet, le compilateur sait que le type de données de S est une chaîne. Lorsque la méthode Getbytes de la chaîne est appelée, le type de données de la valeur de retour est byte [], donc .length est une expression légale.
La vraie différence entre les deux est:
Dans les langages fortement typés, le type de chaque expression peut être déterminé au temps de compilation et seules les opérations qui s'appliquent à ce type sont autorisées;
Les langages de type faible permettent à toute opération d'être imposée à tout type, mais cette opération peut signaler une erreur au moment de l'exécution.
Type de données
Selon la spécification de ECMAScript 5.1, il existe six types de données dans JavaScript, à savoir: Undefined, Null, Boolean, Number, String et Object. Les cinq premiers appartiennent au type de base, et le dernier appartient au type d'objet.
Types de données de base
Le type non défini n'a qu'une seule valeur, qui n'est pas définie, ce qui signifie "valeur nulle", qui s'applique à tous les types de données.
Le type nul n'a qu'une seule valeur, qui est nul, ce qui signifie "pas d'objet" et ne s'applique qu'aux types d'objets.
Le type booléen a deux valeurs, vraies et fausses
Les valeurs du numéro de type sont des ensembles de nombres à virgule flottante 64 bits qui suivent la norme IEEE 754, similaire au double de Java. Il n'y a pas de structure de données entière. De plus, il y a trois valeurs spéciales: nan, infinité, -infinity
Une valeur de la chaîne de type est une collection de caractères Unicode finis. Doit être enfermé avec «ou».
nul et indéfini
Null et indéfinis représentent le concept de «non-valeur», s'il est strictement distingué:
- Null signifie vide
- Undefined signifie qu'il n'existe pas. Cette valeur est toutes les variables sans initialisation, paramètres manquants dans la fonction et aucune valeur de retour explicite.
Dans d'autres langues, un seul null est utilisé pour représenter les valeurs nulles. Pourquoi y a-t-il un indéfini en JavaScript? Cela est causé par des raisons historiques:
JavaScript adopte la syntaxe Java, divise les types en types de base et types d'objets. En Java, Null est utilisé pour représenter des objets vides, et JavaScript les hérite pour acquis; Dans le langage C, Null est 0 lorsqu'il est converti en nombre, et JavaScript adopte également la même méthode:
La copie de code est la suivante:
> Numéro (null)
0
> 5 + null
5
Dans JavaScript 1.0, il n'y a pas encore de gestion d'exception. Pour certaines exceptions (pas de variables initialisées, des paramètres manquants lors des fonctions d'appel, etc.), ils doivent être marqués comme une valeur spéciale. Null est un bon choix, mais Brendan Eich veut éviter les deux choses suivantes:
- Cette valeur spéciale ne doit pas avoir d'attribut de référence, car elle est spécifique à l'objet
- Cette valeur particulière ne doit pas être convertie en 0, car il n'est pas facile de détecter les erreurs dans le programme
Pour ces deux raisons, Brendan Eich a choisi non défini, qui peut être forcé à Nan.
La copie de code est la suivante:
> Numéro (non défini)
Nan
> 5 + indéfini
Nan
Les résultats sont très différents lorsqu'ils traitent avec des objets JSON:
La copie de code est la suivante:
> Json.parse (null)
nul
> JSON.Parse (Undefined)
// Syntaxerror de Firfox: JSON.Parse: caractère inattendu à la ligne 1 colonne 1 des données JSON
// Syntaxerror chromé: jeton inattendu u
> Json.stringify (null)
"nul"
> Json.stringify (non défini)
indéfini
Type d'objet
En tant que langage de script, JavaScript lui-même a des fonctions très rationalisées et de nombreuses fonctions (lecture et écriture de fichiers, réseautage, etc.) sont fournis par l'environnement hôte. Le pont entre l'environnement hôte et la langue JavaScript est des objets. L'environnement hôte offre une variété de fonctions en fournissant une série d'objets conformes à la syntaxe JavaScript.
Dans cet article dans la programmation orientée objet JavaScript (si vous ne savez pas ce qu'est un prototype, je recommande fortement de lire cet article), j'ai souligné à plusieurs reprises que les objets sont une série de paires de valeurs clés en JavaScript, tout comme Hashmap en Java. Cependant, les propriétés des objets dans JavaScript peuvent avoir certains descripteurs (descripteurs de propriétés), qui n'est pas disponible dans HashMap.
Descripteur d'attribut
Les descripteurs d'attribut sont divisés en deux catégories:
Descripteur de données (Descripteur de données), contient une série de valeurs booléennes, pour indiquer si l'attribut permet la modification et la suppression.
Descripteur d'accessoires, y compris les fonctions GET et SET.
Les deux descripteurs sont des objets, et ils ont tous les deux les deux propriétés booléennes suivantes:
Configurable est utilisé pour spécifier si le descripteur permet la modification et la suppression. La valeur par défaut est fausse.
L'énumérable est utilisé pour spécifier s'il faut accéder à la propriété lorsqu'elle traverse un objet (en utilisant la méthode FOR ... en boucle ou la méthode Object.Keys). La valeur par défaut est fausse.
En plus des deux attributs communs ci-dessus, le descripteur de données a les deux attributs suivants:
- La valeur est utilisée pour spécifier la valeur de cette propriété, la valeur par défaut n'est pas définie
- Le scénario est utilisé pour spécifier si la valeur de la propriété permet la modification de la valeur de la propriété. La valeur par défaut est fausse
Il existe deux propriétés pour les descripteurs d'accès:
- GET est utilisé pour spécifier l'accessoire (Getter, essentiellement une fonction) lors de l'accès à la propriété, et la valeur de retour de l'accessoire est la valeur de la propriété. La valeur par défaut n'est pas définie
- SET est utilisé pour spécifier l'évaluateur (Setter, essentiellement une fonction) lors de l'accès à cette propriété. L'évaluateur accepte un paramètre. La valeur par défaut n'est pas définie
Nous pouvons utiliser Object.DefineProperty pour définir le descripteur de propriété de l'objet. Par exemple:
La copie de code est la suivante:
// en utilisant __proto__
Object.defineproperty (obj, 'key', {
__proto__: null, // pas de propriétés héritées
Valeur: «statique» // pas énumérable
// non configurable
// non écrit
// en défaut
});
D'après l'exemple ci-dessus, nous pouvons voir que les descripteurs ont les caractéristiques de l'héritage. Nous définissons explicitement le __proto__ de l'objet descripteur sur NULL, ce qui évite l'héritage des attributs correspondants de object.prototype. Bien sûr, nous pouvons également définir explicitement toutes les propriétés du descripteur:
La copie de code est la suivante:
// étant explicite
Object.defineproperty (obj, 'key', {
Énumérable: faux,
configurable: faux,
Écrivable: faux,
Valeur: «statique»
});
Cet effet est le même que le premier morceau de code.
Voici un autre exemple de descripteur d'accès:
La copie de code est la suivante:
// Exemple d'une propriété d'objet ajouté avec DefineProperty avec un descripteur de propriété accessoire
var bValue = 38;
Object.defineproperty (obj, 'key', {
get: function () {return bValue; },
set: function (newValue) {bValue = newValue; },
Énumérable: vrai,
configurable: vrai
});
Il convient de noter que les descripteurs d'accès et les descripteurs de données ne peuvent pas être confus. Il est faux d'écrire ce qui suit:
La copie de code est la suivante:
// Vous ne pouvez pas essayer de mélanger les deux:
Object.defineproperty (obj, 'conflit', {
Valeur: 0x9f91102,
get: function () {return 0xDeadBeef; }
});
// lève une tactéror: les descripteurs de propriété ne doivent pas spécifier de valeur
// ou être écrit lorsqu'un getteur ou un secteur a été spécifié
typeof
Si vous souhaitez connaître le type de variable au moment de l'exécution, vous pouvez utiliser le type d'opérateur. La valeur de retour du typeof est la suivante:
Une chose qui doit être notée est le type de null == "objet". Selon la norme ECMAScript 5.1, le type nul doit être un type de base. Pourquoi l'objet est-il renvoyé ici? La raison en est la suivante:
Dans JavaScript 1.0, la valeur en JavaScript est représentée par une structure telle qu'une balise de type et une valeur réelle. L'indicateur de type de l'objet est 0, et NULL représente un pointeur nul (0x00) dans le langage C, donc le drapeau de type de NULL est 0.
Ce qui précède est l'intégralité du contenu de cet article. Veuillez y consulter si vous en avez besoin.