Bir Javascript işlevinde bir parametre geçirmezsem ne olur?

Javascript dünyasında yeniyim ve çok temel fonksiyonları yazmakla uğraşıyorum ve aşağıdaki örneğe tesadüfen rastladım ve fonksiyon gerektirdiğinde bir parametreyi geçmediğimde neden çalıştığından emin değilim.

Örnek işlev

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

Şimdi işlevi myfunction();ararsam uyarı ile karşılaşıyorum. Neden bir parametreyi geçmediğim halde fonksiyonu herhangi bir hata veya uyarı olmadan çağırabiliyorum?

DÜZENLE

Bu kadar çok harika cevap beklemiyordum ve hiçbir şekilde hangi cevabın en iyi olduğunu söyleyebilecek durumda değilim, bu yüzden insanlardan en iyi cevabı önermelerini isteyebilir miyim ve o kişiye kabulü ödüllendireceğim.

Hiçbir şey olmayacak - yani parametreleri javascript'te geçirmek isteğe bağlı olduğundan bir hata veya uyarı almayacaksınız.
"Sağlanmayan" tüm parametrelerin undefineddeğeri olacaktır .

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

foo(1);

fooŞimdi fonksiyonun içinde :

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

Daha fazla argüman bile iletebilirsiniz, örneğin:

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

arguments.lengthİşlevin içinden sağlanan parametre miktarlarını öğrenebilirsiniz .

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

Herhangi bir miktarda parametreyi işleyen kullanışlı işlev örneği:

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

JavaScript işlevlerindeki tüm bağımsız değişkenler isteğe bağlıdır ("gevşek yazılan" ifadesini okuyun).

JavaScript işlevleri, işlev tanımında belirtilen bağımsız değişkenlerin sayısına bakılmaksızın herhangi bir sayıda bağımsız değişkenle çağrılabilir. Bir işlev gevşek bir şekilde yazıldığından, beklediği bağımsız değişken türünü bildirmesinin bir yolu yoktur ve herhangi bir türdeki değeri herhangi bir işleve geçirmek yasaldır. Bir işlev bildirilenden daha az bağımsız değişkenle çağrıldığında, ek bağımsız değişkenler tanımsız değere sahiptir.

Adlandırılmış bağımsız değişkenleri veya arguments nesnesini kullanarak, işlev içindeki bir işlevin bağımsız değişkenlerine başvurabilirsiniz. Bu nesne, işleve iletilen her bağımsız değişken için bir girdi içerir, ilk girdinin dizini 0'dan başlar. Örneğin, bir işleve üç bağımsız değişken iletilirse, bağımsız değişkene aşağıdaki şekilde başvurabilirsiniz:

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

• JavaScript - Kesin Kılavuz, 5. Baskı

İşte JavaScript böyle çalışır. Parametreler isteğe bağlıdır ve bir işlev çağrısında eksiklerse işlevde gerçekten bir değer olmayan "tanımsız" değerine sahip olacaktır.

"İsteğe bağlı" derken şunu kastediyorum: herhangi bir işlevi çağırmak , rastgele uzun bir parametre listesi içerir. Bir işleve aktarılan parametrelerin sayısı ile bildirilen sayı arasında bir ilişki olması gerekmez . Bu beyanı düşünmenin en iyi yolu, o zaman:

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

bir işlevi bildirip "a" adını birinci parametreye, "b" ikinci parametreye ve "c" adını üçüncü parametreye bağlamanızdır. Ancak, daha sonra işlevin herhangi bir çağrılmasında bunlardan herhangi birinin gerçekten bir değere bağlanacağı garanti edilemez .

Aynı şekilde, herhangi bir parametre olmadan bir işlevi tanımlayabilir ve ardından bunları argumentsnesne aracılığıyla "bulabilirsiniz" :

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

Yani bu ilk işlevle tamamen aynı değil , ancak pratikte önemli olan çoğu yönden yakındır.

JavaScript'teki "tanımsız" değer bir değerdir, ancak anlambilimi diller ilerledikçe biraz sıra dışıdır. Özellikle nulldeğer ile tam olarak aynı değil . Ayrıca, "tanımsız" ın kendisi bir anahtar kelime değildir; bu sadece yarı özel bir değişken adı!

JavaScript, diğer dillerde olduğu gibi işlev parametreleri için varsayılan değerlere sahip değildir. Böylece, istediğiniz kadar çok veya az argüman iletebilirsiniz.

Bir değer iletmezseniz, parametre olur undefined.

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

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

İmzada bulunandan daha fazla parametre geçirirseniz, kullanabilirsiniz arguments.

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

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

İşlevde belirtilenden daha fazla argüman da sağlayabilirsiniz.

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

argumentsSağlanan bağımsız değişkenleri görüntülemek için bir dizi olan özelliği kullanabilirsiniz .

Çünkü işlev, geçirmeniz gereken parametre ile çalışmayı beklemeden hata olmaz.

Örneğin:

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

Bir hata atar; muhtemelen sadece a NaN(bu durumda) veya a variable is undefined.

Eğer argümanı atlarsanız, değeri olacaktır undefined. Bu, isteğe bağlı parametreleri oldukça kolay bir şekilde oluşturmanıza olanak sağlar.

Diğer bir özellik, parametresiz bir işlevi tanımlama ve argumentsnesneyi kullanarak onu başarılı bir şekilde argümanlarla çağırma yeteneğidir . Bu, değişken uzunluklu bağımsız değişken dizilerini kolayca oluşturmanıza olanak sağlar.

Bir işlevin içindeki javascript console.log, geçilmemiş parametreler için çıktı olarak tanımsız verir, ancak işlevin dışında, tarayıcılar değişkeni açıkça bildirdiği için işlevin dışında tanımlı hata verir. Örneğin

console.log(x) 

VM1533 verir: 1 Yakalanmamış ReferenceError: x tanımlı değilken

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

tanımsız verir. Bunun nedeni, test () işlevinin tarayıcı tarafından şu şekilde yeniden yazılmasıdır:

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

Başka bir örnek : -

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

işlev haline geldikçe hala tanımsız

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

Aşağıdaki örnekteki uyarı, tanımsız değerini verecektir: -

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

test(); 

Yukarıdaki işlev şu hale gelecektir: -

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

Bir işlevin içindeki javascript değişkeninin kapsamı, işlev düzeyi kapsamıdır ve blok düzeyi değildir. Örneğin

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

şu şekilde çıktı verecektir:

j is 5 
i is 10

Yine işlev şu hale geldi: -

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