Lisez cet article sur JS quand vous avez le temps

Les fonctions sont la base de la programmation modulaire. Pour écrire des applications Ajax complexes, vous devez avoir une compréhension plus approfondie des fonctions.

Les fonctions en JavaScript sont différentes des autres langages. Chaque fonction est maintenue et exécutée en tant qu'objet. Grâce aux propriétés des objets fonction, vous pouvez facilement attribuer une fonction à une variable ou transmettre la fonction en paramètre. Avant de continuer, examinons la syntaxe d'utilisation des fonctions :

Ce qui suit est un fragment de citation :

function func1(…){…}
var func2=function(…){…};
var func3=function func4(…){…};
var func5=new Function();

Voici la syntaxe correcte pour déclarer des fonctions. Elles sont très différentes des fonctions courantes dans d'autres langages ou des méthodes de définition de fonctions introduites précédemment. Alors pourquoi peut-il être écrit ainsi en JavaScript ? Quelle est la syntaxe qu’il suit ? Ceux-ci sont décrits ci-dessous.

　Comprendre l'objet fonction

Vous pouvez utiliser le mot-clé function pour définir une fonction, spécifier un nom de fonction pour chaque fonction et l'appeler via le nom de la fonction . Lorsque JavaScript est interprété et exécuté, les fonctions sont conservées en tant qu'objet, qui est l'objet fonction à introduire.

Les objets fonction sont essentiellement différents des autres objets définis par l'utilisateur. Ce type d'objet est appelé objet interne, tel qu'un objet date (Date), un objet tableau (Array) et un objet chaîne (String All). sont des objets internes. Les constructeurs de ces objets intégrés sont définis par JavaScript lui-même : en exécutant une instruction telle que new Array() pour renvoyer un objet, JavaScript dispose d'un mécanisme interne pour initialiser l'objet renvoyé, au lieu que l'utilisateur spécifie comment l'objet est construit. .

En JavaScript, le type d'objet fonction correspondant est Function, tout comme le type d'objet tableau correspondant est Array et le type d'objet date correspondant est Date. Vous pouvez créer un objet fonction via new Function(), ou vous pouvez créer un objet via le mot-clé function. Pour faciliter la compréhension, nous comparons la création d’objets fonction avec la création d’objets tableau. Regardons d'abord l'objet tableau : Les deux lignes de code suivantes créent toutes deux un objet tableau myArray :

Ce qui suit est un fragment de référence :

var myArray=[];
//等价于
var myArray=new Array();

De même, les deux lignes suivantes de Le code crée également une fonction. myFunction :

function myFunction(a,b){
return a+b;
}
//等价于
var myFunction=new Function("a","b","return a+b");

En la comparant avec l'instruction pour construire un objet tableau, vous pouvez clairement voir la nature de l'objet fonction. La déclaration de fonction introduite précédemment est la première façon de le faire. le code ci-dessus et à l'intérieur de l'interpréteur, lorsque vous rencontrez cette syntaxe, un objet Function sera automatiquement construit pour stocker et exécuter la fonction en tant qu'objet interne. On peut également voir ici qu'un nom d'objet fonction (variable de fonction) et un nom de variable ordinaire ont les mêmes spécifications. Les deux peuvent faire référence à la variable via le nom de la variable, mais le nom de la variable fonction peut être suivi de parenthèses et d'un paramètre. list pour effectuer l’appel de fonction.

Il n'est pas courant de créer une fonction sous la forme de new Function(), car le corps d'une fonction comporte généralement plusieurs instructions. Si elles sont passées en paramètres sous la forme d'une chaîne, la lisibilité du code est compromise. sera pauvre. Ce qui suit est une introduction à sa syntaxe d'utilisation :

Ce qui suit est un fragment de citation :

var funcName=new Function(p1,p2,...,pn,body);

Les types de paramètres sont tous des chaînes, p1 à pn représentent la liste de noms de paramètres du fonction créée, et body représente tout L'instruction du corps de fonction de la fonction créée, funcName est le nom de la fonction créée. Vous pouvez créer une fonction vide sans spécifier de paramètre et créer une fonction sans nom sans spécifier funcName. Bien entendu, une telle fonction n'a aucune signification.

Il convient de noter que p1 à pn sont des listes de noms de paramètres, c'est-à-dire que p1 peut non seulement représenter un paramètre, il peut également s'agir d'une liste de paramètres séparés par des virgules. Par exemple, les définitions suivantes sont équivalentes. :

Ce qui suit est un fragment de référence :

new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")

JavaScript introduit le type Function et fournit une syntaxe telle que new Function() car les objets fonction doivent utiliser le type Function pour ajouter des propriétés et des méthodes. .

L'essence d'une fonction est un objet interne, et l'interpréteur JavaScript détermine son fonctionnement. La fonction créée par le code ci-dessus peut être appelée en utilisant le nom de la fonction dans le programme. Les problèmes de définition de fonction répertoriés au début de cette section sont également expliqués. Notez que vous pouvez ajouter des parenthèses directement après la déclaration de la fonction pour indiquer que la fonction est appelée immédiatement après sa création, par exemple :

Ce qui suit est un fragment de référence :

var i=function (a,b){
return a+b;
}(1,2);
alert(i);

Ce code sera afficher la variable i La valeur est égale à 3. i représente la valeur renvoyée, pas la fonction créée, car les crochets "(" ont une priorité plus élevée que le signe égal "=". Un tel code n'est peut-être pas couramment utilisé, mais lorsque l'utilisateur le souhaite, c'est une bonne solution pour les applications modulaires. conception ou pour éviter les conflits de noms

Il convient de noter que bien que les deux méthodes suivantes de création de fonctions soient équivalentes :

Les fragments de citation suivants :

function funcName(){
//函数体
}
//等价于
var funcName=function(){
//函数体
}

Mais la première méthode crée une fonction nommée, tandis que la seconde méthode crée une fonction sans nom et fait simplement pointer une variable vers la fonction sans nom. Il n'y a qu'une seule différence d'utilisation : pour une fonction nommée, elle peut être définie après. elle est appelée ; pour une fonction sans nom, elle doit être définie avant d'être appelée :

Ce qui suit est un fragment de référence :

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
var func=function(){
alert(1)
}
//--＞
＜/script＞

Cette instruction générera un indéfini. erreur pour func, et :

Ce qui suit est un fragment de citation :

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
function func(){
alert(1)
}
//--＞
＜/script＞

　　则能够正确执行，下面的语句也能正确执行：

以下是引用片段：

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
var someFunc=function func(){
alert(1)
}
//--＞
＜/script＞

　　由此可见，尽管JavaScript是一门解释型的语言，但它会在函数调用时，检查整个代码中是否存在相应的函数定义，这个函数名只有是通过function funcName()形式定义的才会有效，而不能是匿名函数。

　　函数对象和其他内部对象的关系

　　除了函数对象，还有很多内部对象，比如：Object、Array、Date、RegExp、Math、Error。这些名称实际上表示一个类型，可以通过new操作符返回一个对象。然而函数对象和其他对象不同，当用typeof得到一个函数对象的类型时，它仍然会返回字符串“function”，而typeof一个数组对象或其他的对象时，它会返回字符串“object”。下面的代码示例了typeof不同类型的情况：

以下是引用片段：

alert(typeof(Function)));
alert(typeof(new Function()));
alert(typeof(Array));
alert(typeof(Object));
alert(typeof(new Array()));
alert(typeof(new Date()));
alert(typeof(new Object()));

　　运行这段代码可以发现：前面4条语句都会显示“function”，而后面3条语句则显示“object”，可见new一个function实际上是返回一个函数。这与其他的对象有很大的不同。其他的类型Array、Object等都会通过new操作符返回一个普通对象。尽管函数本身也是一个对象，但它与普通的对象还是有区别的，因为它同时也是对象构造器，也就是说，可以new一个函数来返回一个对象，这在前面已经介绍。所有typeof返回“function”的对象都是函数对象。也称这样的对象为构造器（constructor），因而，所有的构造器都是对象，但不是所有的对象都是构造器。

　　既然函数本身也是一个对象，它们的类型是function，联想到C++、Java等面向对象语言的类定义，可以猜测到Function类型的作用所在，那就是可以给函数对象本身定义一些方法和属性，借助于函数的prototype对象，可以很方便地修改和扩充Function类型的定义，例如下面扩展了函数类型Function，为其增加了method1方法，作用是弹出对话框显示"function"：

以下是引用片段：

Functiothod1=function(){
alert("function");
}
function func1(a,b,c){
return a+b+c;
}
func1.method1();
functhod1();

　　注意最后一个语句：funchotd1()，它调用了method1这个函数对象的method1方法。虽然看上去有点容易混淆，但仔细观察一下语法还是很明确的：这是一个递归的定义。因为method1本身也是一个函数，所以它同样具有函数对象的属性和方法，所有对Function类型的方法扩充都具有这样的递归性质。