Points de connaissances moins populaires sur JavaScript

Fonctions natives

Fonctions natives couramment utilisées

String()

Number()

Boolean()

Array()

Object()

Function()

RegExp()

Date()

　 Erreur()

　Symbol()

　 Propriétés internes [Classe]

　 Toustype de Les objets avec une valeur de retour de objet contiennent un attribut interne [Classe], Cet attribut ne peut pas être directement Accès, généralement via Object.prototype.toString(..) .

Par exemple :

Object.prototype.toString.call([1,2,3]);

// " [ object Array]"

Valeur de type de base

　Object.prototype.toString.call(null);

// "[object Null] "

　　Wrapper d'objet d'emballage

　　　　Puisque la valeur de type de base n'a pas .length et .toString () Ces propriétés et méthodes.

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　var a = "abc";

var b = new String (a);

　var c = Object(a); Il n'est généralement pas recommandé de utilisez directement la fonction encapsulée Déballage

Pour encapsuler les valeurs de type de base dans des objets, vous pouvez utiliser la

valueOf()

fonction.

var a = new String("abc");

var b = new Number(42);

var c = new Boolean(true);

a.valueOf(); // "abc"

b.valueOf(); // 42 c.valueOf(); // true

　 Fonction native en tant que constructeur

　　Array(..)

　　var a = new Array(1,2,3); 🎜>

a; // [1,2,3]

var b = [1,2,3]

b; 🎜>

Constructeur

Array(..),

n'est pas obligé d'avoir le mot-clé new, il sera automatiquement ajouté si

ne l'est pas inclus Lorsque le constructeur

Array

ne prend qu'un seul paramètre, le paramètre sera la longueur prédéfinie du tableau

au lieu d'un élément du tableau.

var a = new Array(3);

a.length; // 3

a; Ne pas créer et utiliser des tableaux de cellules vides 　 Object(..) , Function(..) , et RegExp(..)

Sauf nécessité absolue, n'utilisez pas

Object(..) / Function(..)/ RegExp(..)

Date(..)

et Erreur(..)

　 L'heure de création doit utiliser new Date(), est principalement utilisée pour obtenir l'horodatage Unix actuel Date .new() puis récupérez-le via getTime() dans l'objet date.

　 Créer un objet d'erreur (error objec) Principalement pour obtenir le contexte d'exécution actuel.

　Symbole(..)

　 Type de données de base —— symbole. Les symboles ont des valeurs spéciales uniques. Les utiliser pour nommer des attributs n'entraînera pas facilement des noms en double.

Forme d'attribut statique de Symbol , Symbol.create, Symbol.iterator

obj[Sybol.iterator] = function() {/*..*/}

Utilisez le constructeur natif Symbol(..) pour personnaliser les symboles. Vous ne pouvez pas apporter de nouveau <.>Mot clé, sinon une erreur sera signalée.

var mysym = Symbol("mon propre symbole");

mysym; // Symbol(mon propre symbole)

mysym.toString( /); / "Symbole (mon propre symbole)"

typeof mysym; // "symbole"

var a = { };

a[mysym ] = "foobar";

Object.getOwnPropertySymbols(a);

// [Symbole (mon propre symbole)]

Type de prototype

Le constructeur natif a son propre objet .prototype tel que : Array.prototype,

String.prototype.

>

　　　　String#indexOf(..)

　　　　 Recherchez la position de la chaîne spécifiée dans la chaîne.

String#charAt(..)

Récupère le caractère à la position spécifiée dans la chaîne

String#substr(.. ),String #substring(..)

et String# slice(..)

Obtenez la partie spécifiée de la chaîne

String#toUpperCase()

et String#toLowerCase()

Convertir la chaîne en majuscules et minuscules

String #trim()

　　　　　　　　　　　　　　　　　　　　　　　　 sera renvoyé sous forme de nouvelle chaîne 　　

　　　　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　到　　　　　　〉

🎜> Conversion de types de valeurs

Conversion d'une valeur à partir d'une tapez vers un autre, c'est le cas affiché,

Les cas implicites sont généralement des transtypages.

La conversion de type en JavaScript

renvoie toujours un type de base scalaire.

Opération de valeur abstraite ToString Opération abstraite ToString , qui est responsable de la gestion des non -strings Conversion en chaîne

La méthode par défaut

toString()

du tableau a été redéfinie pour stringifier toutes les unités

avant de les concaténer ensemble.

var a = [1,2,3];

a.toString(); // "1,2,3" JSONRemplacement de chaîne,

　　　　 JSON.stringify(..) se produira automatiquement lors de la rencontre de non défini, fonction et symbole dans l'objet est ignoré et null est renvoyé dans le tableau.

Par exemple :

JSON.stringify(undéfini); // undéfini

JSON.stringify(function(){}) ; // undefined

　　　　　　JSON.stringify(

　　　　[1,undefined,function(){},4]

　　); , 4]"

　　　　　JSON.stringify(

　　　{a:2,b:function(){}}

　　); // "{"a":2 } "

　toJSON() devrait renvoyer une valeur appropriée, qui peut être de n'importe quel type, puis JSON.stringify(. . ) Alignement pour stringification.

　ToNumber

Parfois, vous devez utiliser des valeurs non numériques comme nombres, comme des opérations mathématiques.

vrai est converti en 1, faux est converti en 0, non défini est converti en NaN

　 null est converti en 0

　　　　Afin de convertir la valeur en type de base correspondant, l'opération abstraite ToPrimitive, vérifie d'abord si la valeur a un valueOf() méthode, et si c'est le cas, utilisez-la. La valeur est convertie. Sinon, utilisez la valeur de retour de toString()

pour effectuer une conversion de type forcée. Si ni valueOf() ni toString() ne renvoient la valeur , une erreur TypeError se produira.

ToBoolean

Fausse valeur :

Les valeurs peuvent être divisées dans les deux catégories suivantes.

1. peut être converti à la valeur de faux

2.Autres ( est un type léger converti en la valeur de true)

　　　　 Les valeurs suivantes sont fausses

undefined

null

false

+0,-0 et NaN

""

　　　 Objet à fausse valeur : Dans certains cas spécifiques, le navigateur, basé sur la syntaxe JavaScript régulière crée des valeurs étrangères, ce sont les "False Value Object"

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　logous

　 Une vraie valeur See More est une valeur en dehors de la liste des fausses valeurs

Castation explicite

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ccoleg dans une chaîne et un nombre

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 la main de la banque� 　　 La conversion d'affichage entre la chaîne et le nombre se fait via String(..) et Nombre(..).

　 Casting explicite entre les deux

var a = 🎜>

var b = String(a);

var c = "3.14";

var d = Number(c);

b; >d: // 3.14

　　

Il existe d'autres moyens d'obtenir une conversion d'affichage entre les chaînes et les nombres

var a = 42 ;

var b = a.toString();

var c = "3.14";

var d = +c;

b; d: // 3.14

　 Convertir l'affichage de la date en nombre

Opérateur unaire+ est de convertir un objet date

(Date)

s'opposer à un numéro . var timestamp = +new Date(); Analyser explicitement la chaîne numérique

Analyser la chaîne numérique Nombres et le résultat de retour de la conversion d'une chaîne en un nombre sont les deux nombres.

Par exemple :

var a = "42";

var b = "42px"; Nombre (a); // 42

parseInt(a); // 42

Nombre(b); // NaN

parseInt(b);

L'analyse permet à la chaîne de contenir des caractères non numériques. L'analyse s'effectue de gauche à droite. Si

rencontre un caractère non numérique, elle s'arrêtera.

　　　　 parseInt(..) est pour les chaînes, comme parseInt(..)

Il n'y a aucun moyen de transmettre des nombres et d'autres types de paramètres Utilisez

pour afficher la conversion en valeur booléenne ToBoolean

est explicite

ToBoolean

obligatoire Conversion de type :

var a = "0";var b = [];var c = {};

var d = "";

var e = 0;

var f = null;

var g;

Booléen(a); // vrai

Booléen(b); // vrai

Booléen(c); // vrai

Boolea(d); // faux

Boolea(e); // faux

Boolea(f); // faux

Boolea(g); /false

　　Opérateur unaire ! Convertit explicitement une valeur en valeur booléenne.

var a = "0";

var b = [];var c = {};

var d = "";

var e = 0;

var f = null;

var g;

!!a; // vrai

!!b; // vrai

!!c; // vrai

!!d; // faux

!!e; // faux

!!f; // faux

!!g; >

Casting implicite

Implicitement simplifié

Conversion de conversion implicite entre les chaînes et les nombres

L'opérateur + peut être utilisé à la fois pour l'addition de nombres et la concaténation de chaînes.

var a = "42";

var b = "0";

var c= 42;

var d = 0 ;

a + b; // "42"

c + d; // 42

Objet - L'opération est similaire à +

var a = [3];

var b = [1];

a - b ; // 2

Conversion implicite du booléen en nombre

Conversion implicite en valeur booléenne

Les situations suivantes entraîneront une conversion de conversion implicite

1 expression conditionnelle dans l'instruction if(..) .

2.pour(..;...;..)Expression du jugement conditionnel dans la déclaration(La seconde )

3.while(..) et do..while(..) Conditions dans la boucle Expression de jugement .

4. ? : Expression conditionnelle en

5.Opérateur logique|| (OU logique) et ( ET logique ) L'opérande à gauche de (comme expression conditionnelle)

　　 || et &&

|| Il doit être de type booléen, mais la valeur d'un des deux opérandes var a = 42;var b = "abc";

var c = null;

a || b; // 42

a && b; // "abc"

c || b; // "abc"

c&& b; >

if pour

||

Si le résultat du jugement conditionnel est

vrai

, la valeur du premier nombre sera être renvoyé. Si est faux , le deuxième opérande sera renvoyé. && est le contraire.

Ce qui suit est une utilisation

||

très courante.

fonction foo(a,b){a = a || "bonjour";b = b || console.log(a + " " + b );

}

foo(); // "bonjour tout le monde"

foo("ouais", "ouais"); // "ouais ouais"

Casting de symboles

Égalité détendue et égalité stricte

　　　　 "== autorise les conversions dans les comparaisons d'égalité, tandis que === n'autorise pas "

　Égalité abstraite

Il y en a quelques non conventionnelles à noter

NaN n'est pas égal à NaN

+0 Égal à-0

Inégalité relâchée != est Le contraire de == est le même que !==

Caractères Comparaison d'égalité entre les chaînes et les nombres

1.Si Type(x) est un nombre, Type( y ) est une chaîne, alors le résultat de x== ToNumber(y)

est renvoyé.

2.Si Type(x) est une chaîne, Type(y) est un nombre, alors le résultat de ToNumber(x)== y est renvoyé.

Comparaison d'égalité entre les autres types et les types booléens

== == L'endroit le plus sujet aux erreurs est vrai et faux et autres types

var a = "42";

var b = true;

a == b; // false

1.

Si Type(x) est un type booléen, Renvoyez ensuite le résultat de ToNumber(x) == y

2.

IfType(y) est un type booléen, puis renvoie le résultat de x == ToNumber(y)

Premièrement :

var x = true;

var y = "42";

x == y; // false

Inversement

var x = "42";

var y = false;

x == y;

　　　　 null

et indéfini

==

implique également des moulages d'ermites. 1.Si x est

nul, y

est indéfini , alors le résultat est vrai

2.Si x est indéfini, y est null, Le résultat estvrai

var a == null;

var b;

a == b; vrai

a == null; // vrai

b == null; // vrai

a == faux

b == faux; // faux

a == "" ; // faux

b == ""; // faux

a == 0; false

b == 0; // false

　　Comparaison d'égalité entre objets et non-objets

À propos des objets et (Objet/Fonction/ Array) et primitives scalaires (String/Number/Boolean Comparaison entre les valeurs ​​).

1.Si Type(x) est une chaîne ou un nombre, type(y) est un objet, renvoie le résultat de x == ToPrimitive(y)

2.If Type(x) est un objet, Type(y) est une chaîne ou un nombre, puis retourne

　　ToPromitive( x) Le résultat de == y .

var a = 42;

var b = [42];

a == b; // vrai

var a = "abc";

var b = Object(a); // new String(a) Idem

a === b; // faux

a == b; // vrai

a == b Le résultat est vrai, devrait être b lance via ToPromitive , et renvoie la valeur de type de base "abc" , égal à a .

Comparaison de valeurs faussement égales

Ce qui suit sont des comparaisons régulières et non conventionnelles

"0" = = null; // false

"0" == non défini; // false

"0" == false -- Halo !

"0" == NaN; // faux

"0" == 0; // vrai

"0" == "" / / false

false == null; // false

false == non défini; // false

false == NaN;

false == 0; // vrai -- Halo !

false == "" // vrai -- Halo !

false == [] // vrai -- Halo !

false == {} // faux

"" == null; // faux

"" == non défini; // faux

"" == NaN; // faux

"" == 0; // vrai -- Halo !

"" == []; // vrai -- Halo !

"" == {}; // faux

0 == null; // faux

0 == non défini; // faux

0 == NaN; // faux

0 == [];

0 == {}; false

Parce que ce sont des faux positifs.

　　　

Cas extrêmes

　　　　[] == ![] // true

 　　

Conversion de type forcée des valeurs booléennes [] == ![] devient [] == false,

　　　　 2 == [2]

　　　 = = [null] ; //vrai

42 == "43" // faux

"foo" == 42; = '"" // faux

42 == "42" // vrai

"foo" == ["foo"] // vrai

Utilisez en toute sécurité la conversion implicite

1.Si les valeurs des deux côtés ont

vrai Ou faux, Ne jamais utiliser ==.2.S'il y a

[] ,""

ou 0 , essayez de ne pas utiliser ==. À ce stade, il est préférable de utilisez === pour éviter la conversion de type forcée.

Comparaison de relations abstraites

Les deux côtés sont des comparaisons de chaînes

var a = ["42"];var b = ["043"];

a < > et

b

ne sont pas convertis en nombres car

ToPrimitive renvoie une chaîne, et compare les deux chaînes "42" et "043"

, car "0" est alphabétiquement plus petit que "4", donc le résultat final est faux.

De mêmevar a = [4,2];

var b = [0,4,3];

a <

a est converti en "4,2", b est converti en " 0,4,3” Le même style est comparé par ordre alphabétique.

var a = {b: 42};

var b = {b:43};

a <

a

est [objet Objet], b est aussi [objet Objet] donc par ordre alphabétique

a < b

n'est pas vrai.

L'exemple suivant

var a = {b: 42};

var b = {b:43};

a < // faux

a == b; // faux

a > b; // vrai

a >= b;

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!