Cara terbaik untuk menentukan apakah argumen tidak dikirim ke fungsi JavaScript

Saya sekarang telah melihat 2 metode untuk menentukan apakah suatu argumen telah diteruskan ke fungsi JavaScript. Saya bertanya-tanya apakah satu metode lebih baik dari yang lain atau apakah satu hanya buruk untuk digunakan?

 function Test(argument1, argument2) {
      if (Test.arguments.length == 1) argument2 = 'blah';

      alert(argument2);
 }

 Test('test');

Atau

 function Test(argument1, argument2) {
      argument2 = argument2 || 'blah';

      alert(argument2);
 }

 Test('test');

Sejauh yang saya tahu, keduanya menghasilkan hal yang sama, tetapi saya hanya menggunakan yang pertama sebelum produksi.

Opsi lain seperti yang disebutkan oleh Tom :

function Test(argument1, argument2) {
    if(argument2 === null) {
        argument2 = 'blah';
    }

    alert(argument2);
}

Sesuai komentar Juan, akan lebih baik untuk mengubah saran Tom menjadi:

function Test(argument1, argument2) {
    if(argument2 === undefined) {
        argument2 = 'blah';
    }

    alert(argument2);
}

Ada beberapa cara berbeda untuk memeriksa apakah argumen dilewatkan ke suatu fungsi. Selain dua yang Anda sebutkan dalam pertanyaan (asli) Anda - memeriksa arguments.lengthatau menggunakan ||operator untuk memberikan nilai default - satu juga dapat secara eksplisit memeriksa argumen untuk undefinedmelalui argument2 === undefinedatau typeof argument2 === 'undefined'jika ada yang paranoid (lihat komentar).

Menggunakan ||Operator telah menjadi praktek standar - semua anak keren melakukannya - tapi hati-hati: Nilai default akan dipicu jika mengevaluasi argumen untuk false, yang berarti sebenarnya mungkin undefined, null, false, 0, ''(atau apa pun yang Boolean(...)kembali false).

Jadi pertanyaannya adalah kapan harus menggunakan cek mana, karena semuanya menghasilkan hasil yang sedikit berbeda.

Memeriksa arguments.lengthmenunjukkan perilaku 'paling benar', tetapi mungkin tidak layak jika ada lebih dari satu argumen opsional.

Tes untuk undefined'terbaik' berikutnya - itu hanya 'gagal' jika fungsi secara eksplisit disebut dengan undefinednilai, yang dalam semua kemungkinan harus diperlakukan dengan cara yang sama seperti menghilangkan argumen.

Penggunaan ||operator dapat memicu penggunaan nilai default bahkan jika argumen yang valid diberikan. Di sisi lain, perilakunya sebenarnya mungkin diinginkan.

Untuk meringkas: Hanya gunakan jika Anda tahu apa yang Anda lakukan!

Menurut pendapat saya, menggunakan ||juga merupakan cara untuk pergi jika ada lebih dari satu argumen opsional dan seseorang tidak ingin meneruskan objek literal sebagai solusi untuk parameter bernama.

Cara lain yang bagus untuk memberikan nilai-nilai default menggunakan arguments.lengthdimungkinkan dengan masuk ke label pernyataan switch:

function test(requiredArg, optionalArg1, optionalArg2, optionalArg3) {
    switch(arguments.length) {
        case 1: optionalArg1 = 'default1';
        case 2: optionalArg2 = 'default2';
        case 3: optionalArg3 = 'default3';
        case 4: break;
        default: throw new Error('illegal argument count')
    }
    // do stuff
}

Ini memiliki kelemahan bahwa niat programmer tidak (secara visual) jelas dan menggunakan 'angka ajaib'; karena itu kemungkinan rawan kesalahan.

Jika Anda menggunakan jQuery, satu opsi yang bagus (terutama untuk situasi yang rumit) adalah menggunakan metode extended jQuery .

function foo(options) {

    default_options = {
        timeout : 1000,
        callback : function(){},
        some_number : 50,
        some_text : "hello world"
    };

    options = $.extend({}, default_options, options);
}

Jika Anda memanggil fungsi maka seperti ini:

foo({timeout : 500});

Variabel opsi akan menjadi:

{
    timeout : 500,
    callback : function(){},
    some_number : 50,
    some_text : "hello world"
};

Ini adalah salah satu dari sedikit kasus di mana saya menemukan tes:

if(! argument2) {  

}

bekerja dengan sangat baik dan membawa implikasi yang benar secara sintaksis.

(Dengan pembatasan simultan bahwa saya tidak akan mengizinkan nilai nol yang sah argument2yang memiliki arti lain; tapi itu akan sangat membingungkan.)

EDIT:

Ini adalah contoh yang sangat bagus dari perbedaan gaya antara bahasa yang diketik longgar dan diketik kuat; dan opsi gaya yang diberikan javascript dalam sekop.

Preferensi pribadi saya (tanpa kritik dimaksudkan untuk preferensi lain) adalah minimalis. Semakin sedikit kode yang harus dikatakan, selama saya konsisten dan ringkas, semakin sedikit orang lain yang harus memahami untuk menyimpulkan dengan benar makna saya.

Salah satu implikasi dari preferensi itu adalah bahwa saya tidak ingin - tidak merasa berguna untuk - menumpuk banyak tes tipe-dependensi. Sebagai gantinya, saya mencoba untuk membuat kode itu seperti apa artinya; dan hanya menguji untuk apa saya benar-benar perlu menguji.

Salah satu kejengkelan yang saya temukan dalam kode orang lain adalah perlu mencari tahu apakah mereka berharap, dalam konteks yang lebih besar, untuk benar-benar mengalami kasus-kasus yang mereka uji. Atau jika mereka mencoba menguji segala kemungkinan, dengan harapan mereka tidak cukup mengantisipasi konteksnya. Yang berarti saya akhirnya perlu melacak mereka secara mendalam di kedua arah sebelum saya dapat dengan yakin menolak atau memodifikasi apa pun. Saya pikir ada kemungkinan mereka melakukan berbagai tes karena mereka meramalkan keadaan di mana mereka akan diperlukan (dan yang biasanya tidak jelas bagi saya).

(Saya menganggap itu adalah kelemahan serius dalam cara orang-orang ini menggunakan bahasa yang dinamis. Terlalu sering orang tidak mau menyerahkan semua tes statis, dan akhirnya berpura-pura.)

Saya telah melihat ini paling mencolok dalam membandingkan kode ActionScript 3 yang komprehensif dengan kode javascript yang elegan. AS3 dapat 3 atau 4 kali lebih besar dari js, dan keandalan yang saya curigai setidaknya tidak lebih baik, hanya karena jumlah (3-4X) keputusan pengkodean yang dibuat.

Seperti yang Anda katakan, Shog9, YMMV. : D

Ada perbedaan yang signifikan. Mari kita siapkan beberapa test case:

var unused; // value will be undefined
Test("test1", "some value");
Test("test2");
Test("test3", unused);
Test("test4", null);
Test("test5", 0);
Test("test6", "");

Dengan metode pertama yang Anda jelaskan, hanya tes kedua yang akan menggunakan nilai default. Metode kedua akan default semua kecuali yang pertama (seperti JS akan mengkonversi undefined, null, 0, dan ""ke boolean false. Dan jika Anda menggunakan metode Tom, hanya tes keempat akan menggunakan default!

Metode mana yang Anda pilih benar-benar tergantung pada perilaku yang Anda maksudkan. Jika nilai selain undefineddiizinkan argument2, maka Anda mungkin ingin beberapa variasi pada yang pertama; jika nilai yang bukan nol, tidak nol, tidak kosong diinginkan, maka metode kedua adalah ideal - bahkan, sering digunakan untuk dengan cepat menghilangkan berbagai nilai dari pertimbangan.

url = url === undefined ? location.href : url;

Dalam ES6 (ES2015) Anda dapat menggunakan parameter Default

function Test(arg1 = 'Hello', arg2 = 'World!'){
  alert(arg1 + ' ' +arg2);
}

Test('Hello', 'World!'); // Hello World!
Test('Hello'); // Hello World!
Test(); // Hello World!

Maaf, saya masih belum bisa berkomentar, jadi untuk menjawab jawaban Tom ... Dalam javascript (undefined! = Null) == false Pada kenyataannya fungsi itu tidak berfungsi dengan "null", Anda harus menggunakan "undefined"

Mengapa tidak menggunakan !!operator? Operator ini, ditempatkan sebelum variabel, mengubahnya menjadi boolean (jika saya mengerti dengan baik), jadi !!undefineddan !!null(dan bahkan !!NaN, yang bisa sangat menarik) akan kembali false.

Inilah contohnya:

function foo(bar){
    console.log(!!bar);
}

foo("hey") //=> will log true

foo() //=> will log false

Akan lebih mudah untuk mendekati deteksi argumen dengan membangkitkan fungsi Anda dengan Object of opsional properties:

function foo(options) {
    var config = { // defaults
        list: 'string value',
        of: [a, b, c],
        optional: {x: y},
        objects: function(param){
           // do stuff here
        }
    }; 
    if(options !== undefined){
        for (i in config) {
            if (config.hasOwnProperty(i)){
                if (options[i] !== undefined) { config[i] = options[i]; }
            }
        }
    }
}

Ada cara yang sulit juga untuk menemukan, apakah suatu parameter diteruskan ke suatu fungsi atau tidak . Lihat contoh di bawah ini:

this.setCurrent = function(value) {
  this.current = value || 0;
};

Ini perlu berarti bahwa jika nilai valuetidak ada / lulus - tetapkan ke 0.

Cukup keren ya!

Beberapa kali Anda mungkin juga ingin memeriksa jenis, khususnya jika Anda menggunakan fungsi sebagai pengambil dan penyetel. Kode berikut adalah ES6 (tidak akan berjalan di EcmaScript 5 atau lebih lama):

class PrivateTest {
    constructor(aNumber) {
        let _aNumber = aNumber;

        //Privileged setter/getter with access to private _number:
        this.aNumber = function(value) {
            if (value !== undefined && (typeof value === typeof _aNumber)) {
                _aNumber = value;
            }
            else {
                return _aNumber;
            }
        }
    }
}

function example(arg) {
  var argumentID = '0'; //1,2,3,4...whatever
  if (argumentID in arguments === false) {
    console.log(`the argument with id ${argumentID} was not passed to the function`);
  }
}

Karena array mewarisi dari Object.prototype. Pertimbangkan ⇑ untuk membuat dunia lebih baik.

fnCalledFunction (Param1, Param2, window.YourOptionalParameter)

Jika fungsi di atas dipanggil dari banyak tempat dan Anda yakin 2 parameter pertama dilewatkan dari setiap tempat tetapi tidak yakin tentang parameter 3 maka Anda dapat menggunakan jendela.

window.param3 akan menangani jika tidak ditentukan dari metode pemanggil.