Was passiert, wenn ich in einer Javascript-Funktion keinen Parameter übergebe?

Ich bin neu in der Welt von Javascript und bastele am Schreiben sehr grundlegender Funktionen. Ich bin versehentlich auf das folgende Beispiel gestoßen und bin mir nicht sicher, warum es funktioniert, wenn ich keinen Parameter übergebe, wenn die Funktion dies erfordert.

Beispielfunktion

function myfunction(x) {
    alert("This is a sample alert");
}

Wenn ich jetzt die Funktion myfunction();aufrufe, wird mir die Warnung angezeigt. Warum kann ich die Funktion ohne Fehler oder Warnungen aufrufen, wenn ich keinen Parameter übergeben habe?

BEARBEITEN

Ich habe nicht so viele großartige Antworten erwartet und bin noch keineswegs in der Lage zu sagen, welche Antwort die beste ist. Daher kann ich die Leute bitten, die beste Antwort vorzuschlagen, und ich werde dieser Person die Akzeptanz verleihen.

Es wird nichts passieren - das heißt, Sie erhalten keinen Fehler oder eine Warnung, da die Übergabe der Parameter in Javascript optional ist.
Alle Parameter, die nicht "angegeben" wurden, haben den undefinedWert .

function foo(x, y, z){
    //...
}

foo(1);

Innerhalb der fooFunktion jetzt:

function foo(x, y, z){
    x === 1
    y === undefined
    z === undefined
}

Sie können sogar weitere Argumente übergeben, z.

foo(1,2,3,4,5,7); // Valid!

Sie können die Anzahl der arguments.lengthvon der Funktion gelieferten Parameter innerhalb der Funktion ermitteln.

function foo(x, y, z) {
    console.log('x value: ' + x);
    console.log('y value: ' + y);
    console.log('z value: ' + z);
    console.log('Arguments length: ' + arguments.length);
}
console.log('Zero parameters');
foo();
console.log('Four parameters');
foo(1, 2, 3, 4);

Beispiel für eine nützliche Funktion, die eine beliebige Anzahl von Parametern verarbeitet:

function max() {
    var maxValue = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
        if (maxValue < arguments[i]) {
            maxValue = arguments[i];
        }
    }
    return maxValue;
}

alert(max(1, 5, 7, 2, 88, 32, 44));

Alle Argumente in JavaScript-Funktionen sind optional (lesen Sie "lose eingegeben").

JavaScript-Funktionen können mit einer beliebigen Anzahl von Argumenten aufgerufen werden, unabhängig von der Anzahl der in der Funktionsdefinition genannten Argumente. Da eine Funktion lose typisiert ist, kann sie den erwarteten Argumenttyp nicht deklarieren, und es ist zulässig, Werte eines beliebigen Typs an eine Funktion zu übergeben. Wenn eine Funktion mit weniger Argumenten als deklariert aufgerufen wird, haben die zusätzlichen Argumente den undefinierten Wert.

Sie können auf die Argumente einer Funktion innerhalb der Funktion verweisen, indem Sie die benannten Argumentvariablen oder das Argumentobjekt verwenden. Dieses Objekt enthält einen Eintrag für jedes an die Funktion übergebene Argument. Der Index des ersten Eintrags beginnt bei 0. Wenn einer Funktion beispielsweise drei Argumente übergeben werden, können Sie auf das Argument wie folgt verweisen:

arguments[0]
arguments[1]
arguments[2]

• JavaScript - The Definitive Guide, 5. Ausgabe

So funktioniert JavaScript. Parameter sind optional und haben den nicht wirklich wertvollen Wert "undefined" in der Funktion, wenn sie in einem Funktionsaufruf fehlen.

Mit "optional" meine ich genau das: Das Aufrufen einer Funktion beinhaltet eine beliebig lange Liste von Parametern. Es braucht keine Beziehung zwischen der Anzahl von Parametern zu sein geben zu einer Funktion und die Zahl erklärt . Der beste Weg, um an diese Erklärung zu denken, dann:

function x(a, b, c) {
  // ...
}

ist, dass Sie eine Funktion deklarieren und den Namen "a" an den ersten Parameter, "b" an den zweiten und "c" an den dritten Parameter binden. Es ist jedoch keineswegs garantiert, dass dies tatsächlich der Fall ist einer dieser Werte bei einem späteren Aufruf der Funktion an einen Wert gebunden wird.

Aus dem gleichen Grund können Sie eine Funktion ohne Parameter definieren und diese dann über das argumentsObjekt "finden" :

function noArgs() {
  var a = arguments[0], b = arguments[1], c = arguments[2];
  // ...
}

Das ist also nicht ganz das Gleiche wie die erste Funktion, aber es ist in den meisten Punkten nah, die praktisch zählen.

Der "undefinierte" Wert in JavaScript ist ein Wert, aber seine Semantik ist in Bezug auf Sprachen ungewöhnlich. Insbesondere ist es nicht genau das gleiche wie der nullWert. Außerdem ist "undefiniert" selbst kein Schlüsselwort. Es ist nur ein semi-spezieller Variablenname!

JavaScript hat keine Standardwerte für Funktionsparameter wie andere Sprachen. Sie können also so viele oder so wenig Argumente übergeben, wie Sie möchten.

Wenn Sie keinen Wert übergeben, lautet der Parameter undefined.

function myfunction(x) {
    alert(x);
}

myfunction(); // alerts undefined
myfunction(1); // alerts 1
myfunction(1,2,3); // alerts 1

Wenn Sie mehr Parameter als in der Signatur übergeben, können Sie verwenden arguments.

function myfunction(x) {
    alert(x);
    console.log(arguments);
}

myfunction(1,2,3); // alerts 1, logs [1,2,3]

Sie können auch mehr Argumente als nur das in der Funktion erwähnte angeben

myFunction(1,2,3,4,5,6,7,'etc');

Sie können die argumentsEigenschaft eines Arrays verwenden, um die angegebenen Argumente anzuzeigen.

Weil es keinen Fehler gibt, bis die Funktion erwartet, mit dem Parameter arbeiten zu können, den Sie übergeben sollen.

Beispielsweise:

function myfunction(x) {
    return x*2;
}

Würde einen Fehler werfen; wenn auch wahrscheinlich nur ein NaN(in diesem Fall) oder ein variable is undefined.

Wenn Sie das Argument weglassen, ist sein Wert undefined. Auf diese Weise können Sie ganz einfach optionale Parameter erstellen.

Ein weiteres Merkmal ist die Möglichkeit, eine Funktion ohne Parameter zu definieren und sie mit Argumenten erfolgreich aufzurufen, wobei das argumentsObjekt verwendet wird. Auf diese Weise können Sie auf einfache Weise Argumentarrays mit variabler Länge erstellen.

In javascript console.log gibt innerhalb einer Funktion undefined als Ausgabe für nicht übergebene Parameter aus, aber außerhalb der Funktion gibt es keinen definierten Fehler, da innerhalb einer Funktion Browser die Variable explizit deklarieren. Zum Beispiel

console.log(x) 

gibt VM1533: 1 Ungefangener Referenzfehler: x ist nicht definiert, wohingegen

function test(x) {
console.log(x)
}
test(); 

gibt undefiniert. Dies liegt daran, dass der Funktionstest () vom Browser wie folgt umgeschrieben wird:

function test(x) {
    var x;
    console.log(x)
    }

Ein anderes Beispiel : -

var x =5 ;
function test(x) {
console.log(x)
}
test(); 

ist immer noch undefiniert, wenn die Funktion wird

function test(x) {
    var x;
    console.log(x)
    }

Die Warnung im folgenden Beispiel gibt undefiniert: -

    var x =5;
    function test() {
    alert(x);
    var x =10;
    }

test(); 

Die obige Funktion wird: -

 function test() {
    var x;
    alert(x);
    x =10;
    }

Der Bereich der Javascript-Variablen innerhalb einer Funktion ist der Bereich der Funktionsebene und nicht die Blockebene. Zum Beispiel

function varScope() {

for(var i = 0; i < 10; i++){
    for(var j = 0; j < 5; j++){}
        console.log("j is "+j)
    }
    console.log("i is "+i);


}
varScope();

gibt die Ausgabe aus als:

j is 5 
i is 10

Wieder ist die Funktion wie folgt geworden:

  function varScope() {
    var i;
    var j;
    for(i = 0; i < 10; i++){
        for(j = 0; j < 5; j++){}
            console.log("j is "+j)
        }
        console.log("i is "+i);
    }