Il existe six types de données courants dans js : le type String, le type Null, le type Number, le type Boolean et le type Object.
1. Notes sur le type de
Lorsqu'il s'agit de types de données, il est inévitable de mentionner le type d'opérateur. A noter :
1. typeof est un opérateur, pas une méthode. Bien que nous utilisions souvent typeof() pour obtenir le type de données d'un objet.
2. Typeof pour null est un objet (c'est parce que null est une référence d'objet vide) et typeof pour fonction est une fonction.
Copiez le code comme suit :
alert(typeof null); //retourne l'objet
fonction démo(){
alert('démo');
}
alert (type de démo); // fonction de retour
2. Définissez les valeurs initiales pour les variables d'objet de différents types de données
Notez que si la variable objet de type Object ne sait pas quoi attribuer au début, n'utilisez pas var demo={}, il est préférable de la définir sur null ;
Copiez le code comme suit :
var d2 = nul ;
d2={'key':"merde"};
var d3='';//Chaîne par défaut
var d4=0; //La valeur initiale du type numérique est définie sur 0
var d5=null; //Définir la valeur par défaut initiale pour le type d'objet
3. La différence et les points à noter entre undefined et null
1. Si vous utilisez "==" pour comparer, ils sont égaux car ils comparent les valeurs.
2. Il existe deux manières de les distinguer (leur principale est de comparer leurs types de données)
1) Utilisez typeof pour les distinguer
2) Utilisez "===" congruent : la comparaison s'effectue entre la valeur et le type de données, et true ne sera renvoyé que s'ils sont tous identiques.
Copiez le code comme suit :
alerte (non défini == null); // vrai
alert(typeof non défini == typeof null); //false
alerte (non défini === null); //true
4. Notes sur le booléen
1. La comparaison entre vrai et 1 est la même, et la comparaison entre faux et 0 est la même (c'est une comparaison "=="), car la conversion du type de données est implémentée en interne, convertissant vrai en 1 et convertissant faux en 0. Il y a beaucoup de données à l'intérieur de js. La conversion automatique des types est une chose à laquelle tout le monde doit prêter attention. Beaucoup d’autres seront mentionnés plus tard. Mais utiliser "===" n'est pas égal, car leurs types de données ne sont pas égaux.
2. Affichez la conversion en booléen. Utilisez la méthode Boolean() pour afficher la conversion. Ce à quoi vous devez faire attention, ce sont les différents types de données, quand convertir en vrai et quand convertir en faux.
1) Type de chaîne, tant qu'il ne s'agit pas d'une chaîne vide, elle sera convertie en vrai
2) Type de nombre, tant qu'il n'est pas 0, même un nombre négatif sera converti en vrai
3) Le type d'objet, tant qu'il n'est pas de type nul, sera converti en vrai
4) Le type non défini sera converti en faux
Je ne ferai pas de démonstration, vous pouvez l'essayer vous-même.
3. (***) La fonction booléenne est appelée à l'intérieur () de l'instruction if().
5. Points à noter sur le type de numéro
1. Le type flottant ne peut pas effectuer d'opérations précises.
Copiez le code comme suit :
alerte (0,1 + 0,2); // Retour 0,3000000000000000004
2. Soutenir les opérations de notation scientifique
3. NaN (pas un nombre)
1) var d=0/0 ; Remarque : aucune erreur ne sera signalée dans js, mais NaN sera renvoyé.
2) Peut être obtenu via Number.NaN
3) Toute opération entre NaN et n’importe quel objet renverra NaN.
4) isNaN() détermine s'il s'agit de NaN
Copiez le code comme suit :
alert(isNaN(NaN));//true
alert(isNaN(12));//false
alert(isNaN('123'));//false : car les nombres de type chaîne peuvent être automatiquement convertis en nombres
alert(isNaN('lew'));//true
alert(isNaN(false));//(*)false : étant donné que la valeur booléenne peut être convertie en nombre, true devient 1, false devient 0
5) Principe d'exécution interne de isNaN() : Il en va de même pour les objets. Principe de mise en œuvre : Le Premier ministre appelle la méthode valueOf() de l'objet, s'il peut être converti en nombre, il sera jugé directement s'il ne peut pas être converti en nombre, il appellera à nouveau la méthode toString(), puis testez la valeur de retour.
valueOf() appelle en interne la méthode toObject(). Le principe d'exécution interne des deux méthodes est le suivant :
Copiez le code comme suit :
var boîte={
//Remplace la méthode toString() de l'objet box
toString:fonction(){
renvoie '123';
}
} ;
alert(isNaN(box));//false
alert(box);//123 En interne, alert() appelle également d'abord la valeur valueOf() de l'objet, puis appelle la méthode toString().
6) Convertir d'autres types de données en type Nombre
Contient trois fonctions : Number() : peut convertir tous les types de données ; parseInt() et parseFloat() ne convertissent que les chaînes.
Copiez le code comme suit :
alerte(Numéro('123'));//123
alerte(Numéro('0234'));//234
alerte(Nombre(vrai));//1
alerte(Numéro(null));//(**)0
//À l'exception de ce qui précède, tout le reste renvoie NaN.
alerte (Numéro (non défini))//NaN
Le principe d'implémentation interne de Number() : identique à isNaN(), valueOf() est appelé en premier, puis toString() est appelé. . On peut donc imaginer que les performances soient relativement médiocres. . Donc, tant que l'objet à transformer est une chaîne, appelez parseInt() ou parseFloat() car ils n'ont pas besoin de juger le type en interne.
Remarque lors de l'appel de parseInt() et parseFloat() : la partie de la chaîne commençant par le premier caractère numérique jusqu'au nombre avant le premier caractère numérique est convertie en nombre.
Copiez le code comme suit :
alerte(parseInt('123leb'));//123
alerte(parseInt('123leb345'));//123
alert(parseInt('len234'));//NaN
Lorsque le paramètre dans parseInt() est de type float, seule la partie entière du nombre est obtenue.
Copiez le code comme suit :
alerte(parseInt(56.12));//56
6. Type de chaîne
1) (*Important*) Les chaînes sont immuables dans ECMAScript : les chaînes ne changeront pas après leur création.
Pour modifier une variable chaîne à laquelle une valeur a été affectée, détruisez d'abord la chaîne dans la variable, puis remplissez la variable avec une chaîne contenant la nouvelle valeur.
Copiez le code comme suit :
var d='bonjour';
d=d+'shit';//Processus d'exécution : attribuez d'abord une valeur à 'hello', puis effacez la chaîne dans d, concaténez les chaînes 'hello' et 'shit', puis attribuez une valeur à la variable d. (Donc la valeur de la chaîne ne changera pas une fois créée)
2) La méthode toString() convertit les autres types de données en type String. Mais si vous opérez sur null ou undefined, une erreur sera signalée.
3) Cependant, la méthode String() peut également obtenir l'effet de toString(), mais peut opérer sur null et non défini.
Principe interne : appelez d'abord toString(), et s'il peut être converti en chaîne, le résultat sera renvoyé directement. Non, jugez ensuite s'il est nul ou indéfini, puis renvoyez « null » ou « non défini »
Résumé : Si vous savez que la variable ne peut pas être nulle ou indéfinie, utilisez toString(), qui est plus performant que String(). Étant donné que String() doit faire des jugements internes, cela nuira aux performances.