Quelle est la fonction fonction de js ? Comment utiliser la fonction en js

Le contenu de cet article porte sur quelle est la fonction de js ? L'utilisation de la fonction dans js a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère que cela vous sera utile.

Fonction et fonction

Function est un type de référence fourni par JavaScript. Les objets Function sont créés via le type Function.
En JavaScript, les fonctions existent également sous forme d'objets, et chaque fonction est un objet Function.

//字面量方式创建函数
var fun =function () {
    console.log(100)
};
//函数声明方式创建函数
function fn () {
    console.log(200)
};
/*     创建Funtion类型的对象
*       var 函数名 = new Function('参数',''函数体)*/
var f = new Function('a','console.log(a)');
f(2);//以函数方式调用

Type de fonction

Méthode apply() de la fonction

La méthode apply() de la fonction est utilisée pour appeler A fonction qui accepte la valeur this spécifiée et un tableau comme paramètres.

//定义函数
function fun(value) {
    console.log(value)
}
/*
函数的apply()方法——>用于调用一个函数
     函数名.apply(thisArg,[argsArray])
       thisArg——>可选项，函数运行时使用的this值
       argsArray——>可选项，一个数组或者类数组对象,其中的元素作为单独的参数传给Function函数。*/
fun.apply(null,['100']);

Méthode call() de la fonction

La méthode call() de la fonction est utilisée pour appeler une fonction et accepte la liste de valeurs et de paramètres spécifiée.

var fun  = function (value,a,b,) {
    console.log(value,a,b,)
}
/*
*   call()方法调用函数
*   函数名.call(thisArg,arg1,arg2,…)
*
*   和apply()的区别在于提供参数的方式不同
*/
fun.call(null,2,3,4);//2 3 4

Méthode de liaison de la fonction

La fonction est utilisée pour créer une nouvelle fonction, appelée fonction de liaison, et accepte la valeur spécifiée comme paramètre, et le paramètre list

var fun = function (a,b,c) {
    console.log( a,b,c)
}
/*  bind方法->相当于复制一份当前函数
*   函数名.bind(thisArg，arg1，arg2，...)
*     thisArg->当绑定函数被调用时，该属性作为原函数运行时的this指向
*     arg->参数。当绑定函数被调用时，这些参数将在实参之前传递给被绑定的方法
*     */

var v =fun.bind(null,2,3,4);
v();//2 3 4

Pas de surcharge

Dans d'autres langages de développement, les fonctions ont une fonctionnalité appelée surcharge. Il s'agit de définir plusieurs fonctions portant le même nom, mais chaque fonction reçoit un nombre différent de paramètres. Le programme déterminera quelle fonction est appelée en fonction du nombre de paramètres réels transmis lors de l'appel.
Il n'y a pas de chevauchement de fonctions dans un seul JavaScript. Si plusieurs fonctions portant le même nom sont définies, seule la dernière fonction définie est valide.

objet arguments

Bien qu'il n'y ait pas de surcharge, JavaScript fournit un objet arguments pour simuler le phénomène de surcharge de fonctions.

/*
*    argumengs对象
*    *该对象存储当前函数中所有的参数（实参）->类数组对象
*    *该对象一般用于函数中
*    *作用-用于获取当前函数的所有参数
*    *arguments.length->函数所有参数（实参）的个数*/
function fun() {
    var num = arguments.length;
    switch (num){
        case 2://参数个数
            return arguments[0]+arguments[1];
        break;
        case 3:
            return arguments[0]+arguments[1]+arguments[2];
        break;
    }
}
console.log(fun(4,5));//9
console.log(fun(4,5,6));//15

Récursive

Une fonction qui s'appelle elle-même au sein d'un corps de fonction est appelée fonction récursive. Dans un sens, la récursivité est similaire à une boucle. Les deux exécutent le même code à plusieurs reprises et nécessitent tous deux une condition de terminaison pour éviter les boucles infinies et la récursivité infinie.
Dans un corps de fonction, si vous souhaitez appeler sa propre fonction, il y a deux manières :

• En utilisant son propre nom de fonction

• Réussi Utilisez l'attribut appelé de l'objet arguments pour implémenter

/*//无线递归
function fun() {
    console.log('23')
    fun()//调用自身函数，实现递归
}
fun()*/

function fn(v) {
    console.log(v);
    if (v>=5){
        return
    }
    /*fn(v+1)*///使用该方法终止递归当执行下列代码输出时，报错
    arguments.callee(v+1)
}
/*fn(0)*/
var f = fn;
fn=null;
f(0);

fonction spéciale

fonction anonyme

en JavaScript, lorsque vous utilisez une fonction comme données, vous n'avez pas besoin de définir un nom. Deux utilisations des fonctions anonymes

• Vous pouvez transmettre des fonctions anonymes en tant que paramètres à d'autres fonctions.

• Vous pouvez définir une fonction anonyme pour effectuer certaines tâches ponctuelles.

Fonction de rappel

Lorsqu'une fonction est utilisée comme paramètre d'une autre fonction, la fonction utilisée comme paramètre est appelée fonction de rappel.

//作为另一个函数参数的函数fun->回调函数
var fun = function () {
    return 2;
};

function fn(v) {
    return v();
}
/*
var result=fn(fun);//函数fun作为函数fn的实参
console.log(result);
*/

//以上代码等同于以下代码
//以下代码中作为参数的函数->匿名回调函数

var f = fn(function(){return 2;});
console.log(f);

Fonction d'auto-réglage

Une fonction d'auto-réglage est une fonction qui s'appelle après avoir défini une fonction

/*    自调函数->定义即调用的函数
*      相当于在匿名函数外加了小括号
*      第一对括号->定义函数
*      第二对括号->调用函数*/

(function () {
    console.log('23')
})()//23->后边的括号表示调用

en tant que fonction

une fonction comme Le résultat d'une autre fonction est renvoyé, et la fonction renvoyée comme résultat est appelée une fonction comme valeur

var one = function(){
    return 100;
}
// 作为值的函数 -> 内部函数的一种特殊用法
function fun(){
    var v = 100;
    // 内部函数
    return function(){
        return v;
    };
}

var result = fun();
// console.log(result);// one函数
// console.log(result());// 100

console.log(fun()());

Fermeture

chaîne de portée 🎜>

Chaîne de portée signifie que la portée locale peut accéder à la portée à laquelle son parent peut accéder

var a = 10;// 全局变量
function fun(){
    var b = 100;// fun函数作用域的局部变量
    // 内部函数
    function fn(){
        var c = 200;// fn函数作用域的局部变量
        // 内部函数
        function f(){
            var d = 300;// f函数作用域的布局变量
            // 调用变量
            console.log(a);// 10
            console.log(b);// 100
            console.log(c);// 200
            console.log(d);// 300
        }
        f();
        // 调用变量
        // console.log(a);// 10
        // console.log(b);// 100
        // console.log(c);// 200
        // console.log(d);// d is not defined
    }
    fn();
    // 调用变量
    // console.log(a);// 10
    // console.log(b);// 100
    // console.log(c);// c is not defined
    // console.log(d);// d is not defined
}
fun();

Fermeture

Lorsqu’une fonction interne est accédée par une portée externe d’une manière ou d’une autre, il s’agit d’une fermeture.

var n;// 定义变量，但不初始化值
function fun(){// 函数作用域
    var v = 100;
    // 进行初始化值 -> 一个函数
    n = function(){
        console.log(v);
    }
    // n();
}
fun();

n();// 100

Le rôle de la fermeture

• Fournir des variables locales partagées

• Protéger les variables locales partagées et fournir des fonctions dédiées à lecture et écriture de variables

• Éviter la pollution globale

Recommandations associées :

Introduction aux types de fonctions JavaScript

Une brève analyse de la compréhension de la fonction dans JS

Type de fonction dans les compétences ECMAScript_javascript

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!