Une explication des types de référence JavaScript

Type d'objet

 1 //创建方式一 2 var person = new Object(); 3 person.name = "jack"; 4 person.age = 12; 5  6 //创建方式二 7 var person = { 8       name:"jack", 9       age:1210 }11 //创建空对象12 var person = {};//与new Object()相同13 14 //访问方式15 person["name"];  jack16 person.name;  jack17 //以上两种方式区别在于使用中括号方式可以通过变量访问18 var propertyName="name";19 person[propertyName];  jack20 person["first name"] = "jack";//如果属性名有空格

Type de tableau　

//定义var array = new Array();var array2 = new Array("a","b","c");var array3 = ["a","b","c"];//修改array3[2] = "d";//array3:a,b,d//新增array3[3] = "d";//array3:a,b,c,darray3[length] = "d";//array3:a,b,c,d第二种新增方式//末尾删除元素//数组的length属性不是只读的，所以通过改变length可以从数组末尾移除array3.length=3;//array3:a,b,c

Détecter un tableau :

Déterminer le type de base d'une valeur (Indéfini, Null, Booléen, Nombre, Chaîne) Utiliser l'opérateur typeof pour déterminer le type d'une valeur. Référence les types utilisent l’opérateur instanceof.

La raison pour laquelle la méthode Array.isArray() est ajoutée à Array est que l'opérateur instanceof est utilisé lorsqu'il n'y a qu'un seul environnement d'exécution global s'il contient plusieurs frameworks, il y aura plus de deux In différents ; Dans l'environnement global, il existe plus de deux versions différentes du constructeur Array. Méthode Stack (LIFO)  : Le tableau passe le push (reçoit un nombre quelconque de paramètres et les ajoute un par un à la fin du tableau) et pop (supprime le dernier élément de la fin du tableau et réduit la valeur de longueur, renvoie l'élément supprimé) Deux méthodes peuvent obtenir un comportement de type pile.

Méthode de file d'attente (FIFO)  : Le tableau passe le décalage (récupère les éléments de l'avant du tableau) et le push ou unshift (ajoute un nombre quelconque d'éléments à l'avant du tableau et renvoie un nouveau tableau. La longueur) et le pop peuvent réaliser la forme d'une file d'attente simulée.

Méthode de réorganisation  : inverser (inverser l'ordre des éléments du tableau (implémenter le tri, recevoir une fonction personnalisée, transmettre des nombres négatifs, 0, des nombres positifs) ;

Méthode de fonctionnement : concat (ajouter au tableau de copie en fonction des paramètres reçus et renvoyer une copie du tableau (renvoyer les positions de début et de fin) ; ) éléments entre, mais en excluant les éléments à la position finale);

méthode splice() : vous pouvez supprimer n'importe quel nombre d'éléments. splice(0,2) supprimera les deux premiers éléments (la position et la somme des éléments). premier élément à supprimer Le nombre d'éléments à supprimer) ; plusieurs éléments peuvent être insérés à la position spécifiée ; n'importe quel nombre d'éléments peut être inséré dans la position spécifiée et n'importe quel nombre d'éléments peut être supprimé en même temps.

Méthodes de position : ECMAScript 5 ajoute deux méthodes de position pour les instances de tableau : indexOf() et lastIndexOf()

Méthode d'itération  :

1. every() : Reçoit une fonction, si true est renvoyé pour chaque élément du tableau, le résultat renvoie true.

2. some() : Reçoit une fonction S'il y a un élément dans le tableau qui renvoie vrai, le résultat sera vrai.

3. filter() : reçoit une fonction et renvoie les éléments qui satisfont à la condition, ce qui est vrai.

4. forEach() : exécute la fonction donnée sur chaque élément du tableau.

5. map() : exécute la fonction donnée et renvoie un tableau composé des résultats de chaque appel de fonction.

Méthode de fusion  : réduire (à partir du premier élément du tableau) et réduireRight (à partir du dernier élément du tableau) .

Type de fonction

Les fonctions sont en fait des objets. Chaque fonction est une instance du type Function et possède les mêmes propriétés et méthodes que les autres types de référence. Le nom de la fonction est donc en fait un pointeur vers l’objet fonction.

 1 //使用函数声明语法定义 2 function sum(num1,num2) 3 { 4      return num1+num2;          
 5 } 6 //使用函数表达式定义，注意结尾要加分号 7 var sum = function(num1,num2) 8 { 9     return num1+num2;10 };

Il existe une différence entre la déclaration de fonction et l'expression de fonction. Lorsque l'analyseur charge des données dans l'environnement d'exécution, il lira d'abord la déclaration de fonction et la laissera exécuter n'importe quel code. Elle est accessible avant ; tandis que l'expression de fonction doit attendre que l'analyseur s'exécute sur la ligne de code où elle se trouve avant d'être réellement interprétée et exécutée. C'est-à-dire que l'expression de fonction doit être écrite devant le code. qui appelle la fonction.

La fonction peut être utilisée comme valeur, soit comme paramètre, soit comme valeur de retour, comme le montre l'exemple suivant :

//根据属性名来创建一个比较函数，来指明按照哪个属性来排序function createComparisonFunction(propertyName)
{return function(object1,object2)
     {         var value1 = object1[propertyName];         var value2 = object2[propertyName];         
         if(value1<value2){             return -1;
         }else if(value1<value2){             return 1;
         }else{ 
             return 0;
         }
     }
}    
//利用数组data调用sort()方法data.sort(createComparisonFunction("name"));

Attributs internes de la fonction :

A l'intérieur d'une fonction, il y a deux objets spéciaux : les arguments et ceci. L'objectif principal des arguments est de sauvegarder les paramètres de la fonction, parmi lesquels il existe un attribut appelé, qui est un pointeur vers la fonction propriétaire de l'objet arguments.

//简单的递归算法，但是函数内部的执行和函数名factorial耦合在一起function factorial(num)
{if(num<=1)
    {return 1;
    }else{return num*factorial(num-1);
    }
}//利用arguments.callee解决function factorial(num)
{if(num<-1){return 1;
    }else{return num*arguments.callee(num-1);
    }
}

Un autre attribut de l'objet fonction est : l'appelant. Il contient une référence à la fonction qui a appelé la fonction actuelle. Autrement dit, celui qui appelle la fonction enregistre sa référence.

function outer()
{
   inner();
}function inner()
{
   alert(inner.caller);//弹出outer()函数的源代码
   alert(arguments.callee.caller);//和上一句一样}

函数属性和方法：

每个函数都包含两个属性：length（函数接收的命名参数的个数）和prototype。

每个函数都包含两个非继承而来的方法：apply()和call()，在特定的作用域中调用函数，实际上等于设置函数体内this对象的值。apply()接收两个参数，一个在其中运行函数的作用域，拎一个是参数数组（可以是array或arguments对象）。call()第一个参数和apply一样，后面必须明确传入每个参数。除了用法不同其他的没什么不同。另外他们真正强大的地方是能够扩充函数赖以运行的作用域。

function sum(num1,num2)
{     return num1+num2;  
}
sum.apply(this, [num1,num2] );
sum.call(this,num1, num2);//扩充函数作用域window.color = "red";var o = {color:"blue"};function showColor(){
    alert(this.color);
}

showColor();//redshowColor.call(this);//redshowColor.call(window);//redshowColor.call(o);//blue

也可以使用bind()方法。

基本包装类型

为了便于操作基本类型值，ECMAScript引入3个特殊的引用类型：Boolean,Number,String。所谓包装类型，就是将基本类型包装起来，放一些操作方法和属性等。

每当读取一个基本类型值的时候，后台就会创建与一个对应的基本包装类型的对象，从而能让我们可以调用某些方法操作这些数据。

var s1 = "some text";var s2 = s1.substring(2);//后台内部相当于如下代码var s1 = new String("some text");var s2 = s1.substring(2);
s1 = null;

当第二行代码访问s1时，访问过程处于一种读取模式，也就是要从内存中读取这个字符串的值，读取模式访问字符串时，后台都会自动完成下列处理：

1. 创建String类型的一个实例。

2. 在实例上调用指定的方法。

3. 销毁这个实例。

引用类型与基本包装类型的主要区别就是对象的生存期。使用new 操作符在执行流离开当前作用域之前一直保存在内存中。而自动创建的基本包装类型的对象，则只存在一行代码的执行瞬间，然后立即销毁。

单体内置对象

内置对象：

由ECMAScript实现提供的，不依赖于宿主环境的对象，程序执行之前就已经存在，比如：Object,Array和String。另外还有Global和Math。

Global对象：

• URI编码方法：通过encodeURI()和encodeURICOMponent()方法对URI进行编码，以便发送给浏览器。区别在于第一个不会对本身属于URI的特殊字符进行编码，例如冒号，正斜杠，问号和井号。而另一个则会对它发现的任何非标准字符进行编码。与这两个方法对应的是：decodeURI(只能对使用encodeURI()替换的字符进行解码)和decodeURIComponent(针对encodeURIComponent()编码的字符)。

• eval()方法像是一个解析器。比如eval("function say(){  alert(' Hi '); }");但是创建的任何变量或者函数都不会被提升，只有在eval执行时候才创建。

• window对象，全局作用域中声明的所有变量和函数，都成为了window对象的属性。

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!