Was ist die Funktionsfunktion von js? So verwenden Sie eine Funktion in js

Der Inhalt dieses Artikels befasst sich mit der Funktion von js. Die Verwendung der Funktion in js hat einen gewissen Referenzwert. Freunde in Not können darauf verweisen.

Funktion und Funktion

Funktion ist ein von JavaScript bereitgestellter Referenztyp. Funktionsobjekte werden über den Funktionstyp erstellt.
In JavaScript existieren Funktionen auch in Form von Objekten, und jede Funktion ist ein Funktionsobjekt.

//字面量方式创建函数
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);//以函数方式调用

Funktionstyp

Apply()-Methode der Funktion

Die apply()-Methode der Funktion wird zum Aufrufen einer Funktion verwendet. und akzeptiert den angegebenen this-Wert und ein Array als Parameter.

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

call()-Methode der Funktion

Die call()-Methode der Funktion wird zum Aufrufen einer Funktion verwendet und akzeptiert die angegebene Werte- und Parameterliste.

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

Bind-Methode der Funktion

Funktion wird zum Erstellen einer neuen Funktion verwendet, die als Bindungsfunktion bezeichnet wird, und akzeptiert den angegebenen Wert als Parameter sowie den Parameterliste

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

Keine Überladung

In anderen Entwicklungssprachen verfügen Funktionen über eine Funktion namens Überladung. Das heißt, mehrere Funktionen mit demselben Namen zu definieren, aber jede Funktion erhält eine unterschiedliche Anzahl von Parametern. Das Programm bestimmt anhand der Anzahl der tatsächlichen Parameter, die während des Aufrufs übergeben werden.
Es gibt keine Überschneidung von Funktionen in einem einzelnen JavaScript. Wenn mehrere Funktionen mit demselben Namen definiert sind, ist nur die zuletzt definierte Funktion gültig.

Argumente-Objekt

Obwohl es keine Überladung gibt, stellt JavaScript Argumente-Objekte bereit, um das Phänomen der Funktionsüberladung zu simulieren.

/*
*    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

Rekursion

Eine Funktion, die sich selbst innerhalb eines Funktionskörpers aufruft, wird als rekursive Funktion bezeichnet. In gewissem Sinne ähnelt die Rekursion einer Schleife. Beide führen denselben Code wiederholt aus und beide erfordern eine Beendigungsbedingung, um Endlosschleifen und Endlosrekursionen zu vermeiden.
Wenn Sie in einem Funktionskörper eine eigene Funktion aufrufen möchten, gibt es zwei Möglichkeiten:

• Durch die Verwendung eines eigenen Funktionsnamens

• Bestanden Verwenden Sie das callee-Attribut des arguments-Objekts, um

/*//无线递归
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);

Sonderfunktion

Anonyme Funktion

in JavaScript zu implementieren , wenn die Funktion als Daten verwendet wird, muss der Name nicht festgelegt werden. Zwei Verwendungsmöglichkeiten anonymer Funktionen

• Sie können anonyme Funktionen als Parameter an andere Funktionen übergeben.

• Sie können eine anonyme Funktion definieren, um bestimmte einmalige Aufgaben auszuführen.

Callback-Funktion

Wenn eine Funktion als Parameter einer anderen Funktion verwendet wird, wird die als Parameter verwendete Funktion als Callback-Funktion bezeichnet.

//作为另一个函数参数的函数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);

Selbsteinstellende Funktion

Eine selbstanpassende Funktion ist eine Funktion, die

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

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

als eigenen Wert aufruft, nachdem die Funktion

A definiert wurde Funktion fungiert als eine andere Funktion. Das Ergebnis wird zurückgegeben, und die als Ergebnis zurückgegebene Funktion wird als Funktion als Wert bezeichnet

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()());

Abschluss

Bereichskette

Bereichskette bedeutet, dass der lokale Bereich auf den Bereich zugreifen kann, auf den sein übergeordneter Bereich zugreifen kann

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();

Abschluss

Wenn eine interne Funktion übergeben wird Wenn von einem beliebigen äußeren Bereich aus auf eine Methode zugegriffen wird, handelt es sich um einen Abschluss.

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

n();// 100

Die Rolle des Abschlusses

• Stellen Sie gemeinsam nutzbare lokale Variablen bereit

• Schützen Sie gemeinsam genutzte lokale Variablen und stellen Sie spezielle Lesefunktionen zum Schreiben bereit Variablen

• Globale Umweltverschmutzung vermeiden

Verwandte Empfehlungen:

Einführung in JavaScript-Funktionsfunktionstypen

Eine kurze Analyse des Funktionsverständnisses in JS

Funktionstyp in ECMAScript_Javascript-Fähigkeiten

Das obige ist der detaillierte Inhalt vonWas ist die Funktionsfunktion von js? So verwenden Sie eine Funktion in js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!