1. Conversion de types
1.Convertir en chaîne
La chose intéressante à propos des valeurs booléennes, des nombres et des primitives de chaîne d'ECMAScript est qu'ils sont des pseudo-objets, ce qui signifie qu'ils ont en réalité des propriétés et des méthodes.
comme:
Copiez le code comme suit :
var sColor = "bleu";
alert(sColor.length);//sortie "4"
En résumé, les trois principales valeurs primitives, les valeurs booléennes, les nombres et les chaînes, ont toutes des méthodes toString(). Tous les objets définis par ECMAScript ont une méthode toString(), qu'il s'agisse d'un pseudo-objet ou d'un objet réel.
La méthode booléenne toString() renvoie simplement "true" ou "false", et le résultat est déterminé par la valeur de la variable :
Copiez le code comme suit :
var bFound = faux;
alert(bFound.toString());//sortie "false"
La méthode toString() de type Number est spéciale. Elle a deux modes, à savoir le mode par défaut et le mode de base. En utilisant le mode par défaut, la méthode toString() utilise uniquement la chaîne correspondante pour afficher la valeur numérique (qu'elle soit ou non). un nombre entier, un nombre à virgule flottante ou une méthode de notation scientifique).
Copiez le code comme suit :
var iNum1 = 10 ;
var fNum2 = 10,0 ;
alert(iNum1.toString()); //sortie "10"
alert(fNum2.toString()); //sort "10"
En utilisant le mode base de la méthode toString() du type Number, les nombres peuvent être générés dans différentes bases (bases).
Copiez le code comme suit :
var iNum = 10 ;
alert(iNum.toString(2)); //sortie "1010"
alert(iNum.toString(8)); //sortie "12"
alert(iNum.toString(16)); //sortie "A"
2. Convertir en nombres
ECMAScript fournit deux méthodes pour convertir des valeurs primitives non numériques en nombres, à savoir parseInt() et parseFloat().
Remarque : Ce n'est que lorsque ces méthodes sont appelées sur le type String (sauf Number) qu'elles s'exécuteront correctement. Tous les autres types renverront NaN.
Par exemple:
Copiez le code comme suit :
var iNum1 = parseInt("1234blue");//renvoie 1234
var iNum2 = parseInt("oxA"); //renvoie 10
var iNum3 = parseInt("22.5"); //renvoie 22
var iNum4 = parseInt("bleu"); //renvoie NaN
La méthode parseInt() possède également un mode de base, qui peut convertir une chaîne binaire, octale, hexadécimale ou toute autre chaîne de base en un entier décimal. Le deuxième paramètre spécifie la base à analyser.
Copiez le code comme suit :
var iNum1 = parseInt("AF",16);// renvoie 175
var iNum2 = parseInt("10",2); // renvoie 2
var iNum3 = parseInt("10",8); //renvoie 8
var iNum4 = parseInt("10",10); //renvoie 10
Remarque : Si le nombre décimal contient des 0 en tête, il est préférable d'utiliser la base 10, sinon vous obtiendrez une valeur octale.
Copiez le code comme suit :
var iNum1 = parseInt("010"); // renvoie 8
var iNum2 = parseInt("010",8); //renvoie 8
var iNum3 = parseInt("010",10);//renvoie 10
La méthode parseFloat() est similaire à la méthode parseInt(). Elle examine chaque caractère à partir de la position 0 jusqu'à ce que le premier caractère non valide soit trouvé, puis convertit la chaîne précédant le caractère en nombre. Pour cette méthode, la première virgule décimale est un caractère valide. Si deux points décimaux sont utilisés, le deuxième point décimal sera considéré comme invalide. Une autre différence dans l'utilisation de cette méthode est que la chaîne doit représenter un nombre à virgule flottante sous forme décimale.
Copiez le code comme suit :
var fNum1 = parseFloat("1234blue"); //renvoie 1234.0
var fNum2 = parseFloat("0xA"); //renvoie NaN
var fNum3 = parseFloat("22.5"); //renvoie 22.5
var fNum4 = parseFloat("22.34.5");//renvoie 22,34
var fNum5 = parseFloat("0908");//renvoie NaN
var fNum6 = parseFloat("blue");//renvoie NaN
3. Conversion de type forcée
Les 3 types de conversions disponibles dans ECMAScript sont les suivants :
(1).Booléen(valeur)
Convertissez la valeur donnée en type booléen.
La fonction Boolean() renvoie true lorsque la valeur à convertir est une chaîne, un nombre différent de zéro ou un objet comportant au moins un caractère. Si la valeur est une chaîne vide, le nombre 0, non défini ou nul, elle renverra faux.
comme:
Copiez le code comme suit :
var b1 = Booléen(""); // faux;
var b2 = Boolean("salut");//true
var b3 = Booléen(100);//true
var b4 = Booléen(null);//false
var b5 = Booléen(0);//faux
var b6 = Boolean(new Object());//true
(2).Nombre (valeur)
Convertit la valeur donnée en nombre (peut être un nombre entier ou un nombre à virgule flottante).
N'oubliez pas non plus que les méthodes parseInt() et parseFloat() ne convertissent que la chaîne avant le premier caractère invalide, donc "4.5.6" sera converti en "4.5". La conversion avec Number() de "4.5.6" renverra NaN car la valeur entière de la chaîne ne peut pas être convertie en nombre. Si la chaîne peut être complètement convertie, Number() déterminera s'il faut appeler la méthode parseInt() ou la méthode parseFloat().
comme:
Copiez le code comme suit :
Nombre(faux);//0
Nombre(vrai);//1
Nombre (non défini);//NaN
Nombre (nul);//0
Nombre("5,5");//5,5
Numéro("56");//56
Nombre("5.6.7");//NaN
Nombre(nouvel objet());//NaN
Nombre(100);//100
(3).String(valeur)
Convertissez la valeur donnée en chaîne.
La seule différence avec l'appel de la méthode toString() est que la conversion d'une valeur nulle ou non définie produit une chaîne sans générer d'erreur :
Copiez le code comme suit :
var s1 = Chaîne (null);//"null"
var oNull = nul ;
var s2 = oNull.toString();//provoque une erreur
2. Type de référence
Les types référence sont généralement appelés classes, ce qui signifie que lorsqu'une valeur de référence est rencontrée, l'objet est traité. ECMAScript définit des « définitions d'objets » qui sont logiquement équivalentes aux classes d'autres langages de programmation.
1.Classe d'objet
Toutes les classes d'ECMAScript sont héritées de cette classe, et toutes les propriétés et méthodes de la classe Object apparaîtront dans d'autres classes (remplacées).
Propriétés de la classe Objet :
(1).Constructeur ---- Référence (pointeur) à la fonction qui crée l'objet. Pour la classe Object, ce pointeur pointe vers la fonction object() d'origine.
(2).Prototype----Une référence au prototype de l'objet. Pour toutes les classes, il renvoie une instance de l'objet Object par défaut.
Méthodes de la classe Object :
(1).HasOwnProperty(property)----Déterminez si l'objet a un attribut spécifique. La propriété doit être spécifiée sous forme de chaîne (par exemple : o.hasOwnProperty("name")).
(2).IsPrototypeOf(object)----Déterminez si l'objet est le prototype d'un autre objet.
(3).PropertyIsEnumerable(property)----Déterminez si la propriété donnée peut être énumérée à l'aide de l'instruction for..in.
(4).ToString()----Renvoie la représentation sous forme de chaîne d'origine de l'objet. Différentes implémentations ECMAScript ont des valeurs différentes.
(5).ValueOf()----Renvoie la valeur d'origine qui convient le mieux à l'objet. Pour de nombreuses classes, la valeur renvoyée par cette méthode est la même que la valeur de retour de toString().
2.Classe booléenne
Les objets booléens sont rarement utilisés dans ECMAScript, et même s'ils le sont, ils ne sont pas faciles à comprendre.
Par exemple:
Copiez le code comme suit :
var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true;//sortie true;
Raison : Dans les expressions booléennes, tous les objets sont automatiquement convertis en vrai.
3.Classe numérique
Les valeurs spéciales telles que Number.MAX_VALUE sont des propriétés statiques de la classe Number. Pour obtenir la valeur originale du Number d'un objet numérique, utilisez simplement la méthode valueOf() :
var iNumber = oNumberObject.valueOf();
En plus des méthodes standard héritées de la classe Object, la classe Number dispose de plusieurs méthodes spécialisées pour gérer les valeurs numériques.
Méthode toFixed() :
Renvoie une représentation sous forme de chaîne d'un nombre avec le nombre spécifié de décimales. La méthode peut représenter des nombres comportant de 0 à 20 décimales. Les valeurs en dehors de cette plage provoqueront une erreur.
comme:
Copiez le code comme suit :
var oNumberObject = nouveau Nombre (99);
aler(oNumberObject.toFixed(2));//sorties "99.00"
Méthode toExponential() :
Renvoie la représentation sous forme de chaîne du nombre en notation scientifique. Cette méthode prend également un paramètre qui spécifie le nombre de décimales à afficher. Par exemple:
Copiez le code comme suit :
var oNumberObj = nouveau Nombre (99);
alert(oNumberObj.toExponential(1));//sorties "9.9e+1"
Méthode toPrecision() :
Renvoie une forme prédéterminée ou exponentielle d'un nombre, selon la forme la plus logique. Il a un argument, qui est le nombre total de chiffres utilisés pour représenter le nombre (à l'exclusion de l'exposant).
Copiez le code comme suit :
var oNumberObj = nouveau Nombre (99);
alert(oNumberObj.toPrecision(1));//sorties "1e+2" ==100
Comme on peut le voir, la méthode toPrecision() arrondit le nombre pour obtenir un nombre aussi proche que possible de la vraie valeur.
comme:
Copiez le code comme suit :
var oNumberObj = nouveau Nombre (99);
alert(oNumberObj.toPrecision(2));// affiche "99"
alert(oNumberObj.toPrecision(3));// affiche "99.0"
Les méthodes toFixed(), toExponential() et toPrecision() effectuent toutes des opérations d'arrondi pour représenter correctement un nombre avec le nombre correct de décimales.
Méthode toLocaleString() :
Il peut être affiché au format sur la page, par exemple, 5210,50 est affiché sous la forme 5 210,50, mais si sa valeur est utilisée, elle doit être remplacée sous la forme parseFloat($("N_YJJE").value.replace(// ,/g, "")); Supprimez la virgule et obtenez sa valeur.
Remarque : Semblables aux objets booléens, les objets Number sont également importants, mais ils doivent être utilisés avec parcimonie pour éviter des problèmes potentiels. Dans la mesure du possible, utilisez la représentation brute des nombres.
4.Classe de chaînes
Les méthodes valueOf() et toString() de l'objet String renvoient toutes deux la valeur originale du type String :
Copiez le code comme suit :
alert(oStringObj.valueOf() == oStringObj.toString());//sortie "true"
La classe String a l'attribut length, qui correspond au nombre de caractères dans la chaîne :
Copiez le code comme suit :
var oStringObj = new String("bonjour tout le monde");
alert(oStringObj.length);sortie "11"
Remarque : Même si la chaîne contient des caractères codés sur deux octets, chaque caractère compte pour un seul caractère.
Méthode charAt() :
Renvoie une chaîne contenant le caractère à la position spécifiée :
Copiez le code comme suit :
var oStringObj = new String("bonjour tout le monde");
alert(oStringObj.charAt(1));sortie "e"
Méthode charCodeAt() :
Renvoie une chaîne contenant le code du caractère à la position spécifiée :
Copiez le code comme suit :
var oStringObj = new String("bonjour tout le monde");
alert(oStringObj.charCodeAt(1));sortie "101"
Méthode concat() :
Utilisé pour concaténer une ou plusieurs chaînes à la valeur d'origine d'un objet String. L'objet String d'origine reste inchangé.
Copiez le code comme suit :
var oStringObj = new String("bonjour ");
var sResult = oStringObj.concat("world");//oStringObj+"world" plus courant;
alert(sResult); // affiche "hello world"
alert(oStringObj); // affiche "bonjour"
Les méthodes indexOf() et lastIndexOf() renvoient la position de la sous-chaîne spécifiée dans une autre chaîne (ou -1, si la sous-chaîne n'est pas trouvée). La différence entre ces deux méthodes est que indexOf() commence à rechercher la sous-chaîne à partir du début de la chaîne (position 0), tandis que lastIndexOf() commence à rechercher la sous-chaîne à partir de la fin de la chaîne.
localeCompare(), compare les chaînes (comparez par ordre alphabétique, les dernières sont plus grandes). Cette méthode a un paramètre : la chaîne à comparer, et renvoie l'une des trois valeurs suivantes :
1. Si l'objet String est classé par ordre alphabétique avant la chaîne dans le paramètre, un nombre négatif est renvoyé (le plus courant est -1, mais le retour réel est déterminé par l'implémentation).
2. Si l'objet String est égal à la chaîne dans le paramètre, 0 est renvoyé.
3. Si l'objet String est classé par ordre alphabétique après la chaîne dans le paramètre, renvoie un nombre positif (le plus courant est 1, mais le retour réel est déterminé par l'implémentation)
Méthodes slice() et substring() :
Les deux méthodes renvoient des sous-chaînes de la chaîne à traiter et acceptent toutes deux un ou deux paramètres. Le premier paramètre est la position de début de la sous-chaîne à obtenir, et le deuxième paramètre est la position avant la fin de la sous-chaîne à obtenir (les caractères à la position terminale ne sont pas inclus dans la valeur renvoyée). Si le deuxième argument est omis, le bit de terminaison prend par défaut la longueur de la chaîne. Aucune de ces méthodes ne modifie la valeur de l'objet String lui-même.
Copiez le code comme suit :
var oStringObj = new String("bonjour tout le monde");
alert(oStringObj.slice(3));//sorties "lo world"
alert(oStringObj.slice(3,7));//sorties "faibles"
Remarque : Pour les paramètres négatifs, la méthode slice() ajoutera la longueur de la chaîne au paramètre et la méthode substring() la traitera comme 0 (c'est-à-dire qu'elle sera ignorée).
Copiez le code comme suit :
var oStringObj = new String("bonjour tout le monde");
alert(oStringObj.slice(-3));//outputs "rld" équivaut à une récupération inversée
alert(oStringObj.substring(-3));//sortie "hello world"
alert(oStringObj.slice(3,-4));//sorties "faible"
alert(oStringObj.substring(3,-4));//outputs "hel" substring() utilise toujours le plus petit nombre comme bit de début et le plus grand nombre comme bit de fin.
toLowerCase(), toLocalLowerCase(), toUpperCase() et toLocaleUpperCase() :
Les deux premières méthodes convertissent la chaîne en minuscules, et les deux dernières méthodes sont utilisées pour convertir la chaîne en majuscules. Les méthodes toLocalLowerCase() et toLocaleUpperCase() sont implémentées en fonction de régions spécifiques.
N'oubliez pas : toutes les propriétés et méthodes de la classe String peuvent être appliquées aux valeurs primitives String car ce sont des pseudo-objets.
5.instance d'opérateur
Il y a un problème lors de l'utilisation du type référence pour stocker des valeurs lors de l'utilisation de l'opérateur typeof. Quel que soit le type d'objet référencé, il renvoie "objet". La méthode instanceof nécessite que les développeurs confirment explicitement que l'objet est d'un type spécifique. comme:
Copiez le code comme suit :
var oStrObj = new String("bonjour tout le monde");
alert (oStrObj instanceof String); // affiche "true"