Tetapkan nilai parameter default untuk fungsi JavaScript

Saya ingin fungsi JavaScript memiliki argumen opsional yang saya atur defaultnya, yang digunakan jika nilainya tidak didefinisikan (dan diabaikan jika nilainya diteruskan). Di Ruby Anda bisa melakukannya seperti ini:

def read_file(file, delete_after = false)
  # code
end

Apakah ini berfungsi dalam JavaScript?

function read_file(file, delete_after = false) {
  // Code
}

Dari ES6 / ES2015 , parameter default ada dalam spesifikasi bahasa.

function read_file(file, delete_after = false) {
  // Code
}

hanya bekerja.

Referensi: Parameter Default - MDN

Parameter fungsi default memungkinkan parameter formal diinisialisasi dengan nilai default jika tidak ada nilai atau tidak terdefinisi .

Anda juga dapat mensimulasikan parameter bernama default melalui penghancuran :

// the `= {}` below lets you call the function without any parameters
function myFor({ start = 5, end = 1, step = -1 } = {}) { // (A)
    // Use the variables `start`, `end` and `step` here
    ···
}

Sebelum ES2015 ,

Ada banyak cara, tetapi ini adalah metode yang saya sukai - ini memungkinkan Anda memasukkan apa pun yang Anda inginkan, termasuk false atau null. ( typeof null == "object")

function foo(a, b) {
  a = typeof a !== 'undefined' ? a : 42;
  b = typeof b !== 'undefined' ? b : 'default_b';
  ...
}

function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

Ini memberikan delete_afternilai delete_afterjika bukan nilai falsey jika tidak maka akan memberikan string "my default here". Untuk lebih detail, lihat survei bahasa Doug Crockford dan periksa bagian tentang Operator .

Pendekatan ini tidak bekerja jika Anda ingin lulus dalam falsey nilai yaitu false, null, undefined, 0atau "". Jika Anda memerlukan nilai falsey untuk diteruskan, Anda harus menggunakan metode dalam jawaban Tom Ritter .

Ketika berhadapan dengan sejumlah parameter ke suatu fungsi, sering kali berguna untuk memungkinkan konsumen untuk melewatkan argumen parameter dalam suatu objek dan kemudian menggabungkan nilai-nilai ini dengan objek yang berisi nilai default untuk fungsi tersebut.

function read_file(values) {
    values = merge({ 
        delete_after : "my default here"
    }, values || {});

    // rest of code
}

// simple implementation based on $.extend() from jQuery
function merge() {
    var obj, name, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    for (; i < length; i++) {
        if ((obj = arguments[i]) != null) {
            for (name in obj) {
                copy = obj[name];

                if (target === copy) {
                    continue;
                }
                else if (copy !== undefined) {
                    target[name] = copy;
                }
            }
        }
    }

    return target;
};

menggunakan

// will use the default delete_after value
read_file({ file: "my file" }); 

// will override default delete_after value
read_file({ file: "my file", delete_after: "my value" }); 

Saya menemukan sesuatu yang sederhana seperti ini menjadi jauh lebih ringkas dan dapat dibaca secara pribadi.

function pick(arg, def) {
   return (typeof arg == 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
} 

Dalam ECMAScript 6 Anda benar-benar dapat menulis apa yang Anda miliki:

function read_file(file, delete_after = false) {
  // Code
}

Ini akan diatur delete_afterke falsejika tidak ada atau undefined. Anda dapat menggunakan fitur ES6 seperti ini hari ini dengan transpiler seperti Babel .

Lihat artikel MDN untuk informasi lebih lanjut .

Nilai Parameter Default

Dengan ES6, Anda dapat melakukan salah satu idiom paling umum dalam JavaScriptkaitannya dengan pengaturan nilai default untuk parameter fungsi. Cara kami melakukan ini selama bertahun-tahun akan terlihat cukup akrab:

function foo(x,y) {
 x = x || 11;
 y = y || 31;
 console.log( x + y );
}
foo(); // 42
foo( 5, 6 ); // 11
foo( 5 ); // 36
foo( null, 6 ); // 17

Pola ini paling banyak digunakan, tetapi berbahaya ketika kita memberikan nilai seperti

foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42

Mengapa? Karena 0 is falsy, dan sebagainya x || 11 results in 11, bukan yang secara langsung disahkan dalam 0. Untuk memperbaiki gotcha ini, beberapa orang malah akan menulis cek dengan lebih jelas seperti ini:

function foo(x,y) {
 x = (x !== undefined) ? x : 11;
 y = (y !== undefined) ? y : 31;
 console.log( x + y );
}
foo( 0, 42 ); // 42
foo( undefined, 6 ); // 17

kita sekarang dapat memeriksa sintaks yang bagus dan membantu ES6untuk merampingkan penetapan nilai default ke argumen yang hilang:

function foo(x = 11, y = 31) {
 console.log( x + y );
}

foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42
foo( 5 ); // 36
foo( 5, undefined ); // 36 <-- `undefined` is missing
foo( 5, null ); // 5 <-- null coerces to `0`
foo( undefined, 6 ); // 17 <-- `undefined` is missing
foo( null, 6 ); // 6 <-- null coerces to `0`

x = 11dalam deklarasi fungsi lebih seperti x !== undefined ? x : 11daripada idiom yang jauh lebih umumx || 11

Ekspresi Nilai Default

Functionnilai default bisa lebih dari sekadar nilai sederhana seperti 31; mereka dapat berupa ekspresi yang valid, bahkan a function call:

function bar(val) {
 console.log( "bar called!" );
 return y + val;
}
function foo(x = y + 3, z = bar( x )) {
 console.log( x, z );
}
var y = 5;
foo(); // "bar called"
 // 8 13
foo( 10 ); // "bar called"
 // 10 15
y = 6;
foo( undefined, 10 ); // 9 10

Seperti yang Anda lihat, ekspresi nilai default dievaluasi dengan malas, artinya hanya berjalan jika dan ketika dibutuhkan - yaitu, ketika argumen parameter dihilangkan atau tidak ditentukan.

Ekspresi nilai default bahkan bisa menjadi panggilan ekspresi fungsi sebaris - umumnya disebut sebagai Ekspresi Fungsi yang Segera Diminta (IIFE):

function foo( x =
 (function(v){ return v + 11; })( 31 )
) {
 console.log( x );
}
foo(); // 42

solusi itu bekerja untuk saya di js:

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}

Cukup gunakan perbandingan eksplisit dengan undefined.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

Saya akan sangat menyarankan hati-hati ketika menggunakan nilai parameter default di javascript. Ini sering menimbulkan bug ketika digunakan bersama dengan fungsi yang lebih tinggi seperti forEach, map, dan reduce. Sebagai contoh, pertimbangkan baris kode ini:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt memiliki parameter kedua function parseInt(s, [radix opsional =10])tetapi memetakan panggilan parseIntdengan tiga argumen: ( elemen , indeks , dan array ).

Saya sarankan Anda memisahkan parameter yang diperlukan dari argumen opsional / standar Anda. Jika fungsi Anda mengambil 1,2, atau 3 parameter yang diperlukan yang tidak ada nilai default yang masuk akal, menjadikannya parameter posisional untuk fungsi tersebut, setiap parameter opsional harus mengikuti atribut yang dinamai objek tunggal. Jika fungsi Anda membutuhkan 4 atau lebih, mungkin lebih masuk akal untuk memasok semua argumen melalui atribut parameter objek tunggal.

Dalam kasus Anda, saya akan menyarankan Anda menulis fungsi DeleteFile seperti ini: ( diedit per instead 's komentar ) ...

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

Menjalankan cuplikan di atas menggambarkan bahaya yang bersembunyi di balik nilai argumen default untuk parameter yang tidak digunakan.

Sebagai pembaruan ... dengan ECMAScript 6 Anda AKHIRNYA dapat menetapkan nilai default dalam deklarasi parameter fungsi seperti:

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

Seperti yang dirujuk oleh - http://es6-features.org/#DefaultParameterValues

menjadi pengembang C ++ yang lama (Rookie to web development :)), ketika saya pertama kali menemukan situasi ini, saya melakukan penugasan parameter dalam definisi fungsi, seperti yang disebutkan dalam pertanyaan, sebagai berikut.

function myfunc(a,b=10)

Tetapi berhati-hatilah karena itu tidak bekerja secara konsisten di seluruh browser. Bagi saya itu berfungsi di chrome di desktop saya, tetapi tidak bekerja di chrome di android. Opsi yang lebih aman, karena banyak yang telah disebutkan di atas adalah -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

Niat untuk jawaban ini bukan untuk mengulangi solusi yang sama, apa yang telah disebutkan orang lain, tetapi untuk menginformasikan bahwa penetapan parameter dalam definisi fungsi dapat berfungsi pada beberapa browser, tetapi jangan bergantung padanya.

Bagi siapa pun yang tertarik memiliki kode yang berfungsi di Microsoft Edge, jangan gunakan standar dalam parameter fungsi.

function read_file(file, delete_after = false) {
    #code
}

Dalam contoh itu, Edge akan menampilkan kesalahan "Mengharapkan ')'"

Untuk menyiasati penggunaan ini

function read_file(file, delete_after) {
  if(delete_after == undefined)
  {
    delete_after = false;
  }
  #code
}

Sampai 08 Agustus 2016 ini masih menjadi masalah

Sesuai sintaks

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

Anda dapat menentukan nilai default dari parameter formal. dan juga memeriksa nilai yang tidak ditentukan dengan menggunakan fungsi typeof .

function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!

Gunakan ini jika Anda ingin menggunakan ECMA6sintaks terbaru :

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Ini disebut default function parameters. Ini memungkinkan parameter formal diinisialisasi dengan nilai default jika tidak ada nilai atau tidak terdefinisi. CATATAN : Ini tidak akan berfungsi dengan Internet Explorer atau browser yang lebih lama.

Untuk kompatibilitas maksimum yang mungkin, gunakan ini:

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

Kedua fungsi memiliki perilaku yang sama persis karena masing-masing contoh ini bergantung pada fakta bahwa variabel parameter akan menjadi undefinedjika tidak ada nilai parameter yang dilewati ketika memanggil fungsi itu.

ES6: Seperti yang sudah disebutkan di sebagian besar jawaban, di ES6, Anda cukup menginisialisasi parameter bersama dengan nilai.

ES5: Sebagian besar jawaban yang diberikan tidak cukup baik bagi saya karena ada beberapa kesempatan di mana saya mungkin harus memberikan nilai falsey seperti 0, nulldan undefinedke suatu fungsi. Untuk menentukan apakah suatu parameter tidak terdefinisi karena itulah nilai yang saya berikan alih-alih tidak terdefinisi karena tidak didefinisikan sama sekali, saya melakukan ini:

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}

function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}

Here foo () adalah fungsi yang memiliki parameter bernama argValue. Jika kita tidak melewatkan apa pun dalam pemanggilan fungsi di sini, maka fungsi throwIfNoValue () akan dipanggil dan hasil yang dikembalikan akan ditugaskan ke argumen hanya ArgValue. Ini adalah bagaimana panggilan fungsi dapat digunakan sebagai parameter default. Yang membuat kode lebih disederhanakan dan dibaca.

Contoh ini diambil dari sini

Jika Anda menggunakan, ES6+Anda dapat mengatur parameter default dengan cara berikut:

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Jika Anda membutuhkan ES5sintaks, Anda dapat melakukannya dengan cara berikut:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

Dalam sintaks di atas ORoperator digunakan. The OROperator selalu mengembalikan nilai pertama jika ini dapat dikonversi ke truejika tidak mengembalikan nilai righthandside. Ketika fungsi dipanggil tanpa argumen yang sesuai, variabel parameter ( bardalam contoh kami) diatur undefinedoleh mesin JS. undefinedKemudian dikonversi ke false dan dengan demikian ORoperator mengembalikan nilai 0.

Ya, menggunakan parameter default didukung sepenuhnya di ES6 :

function read_file(file, delete_after = false) {
  // Code
}

atau

const read_file = (file, delete_after = false) => {
    // Code
}

tetapi sebelumnya di ES5 Anda dapat dengan mudah melakukan ini:

function read_file(file, delete_after) {
  var df = delete_after || false;
  // Code
}

Yang berarti jika nilainya ada di sana, gunakan nilainya, jika tidak, gunakan nilai kedua setelah ||operasi yang melakukan hal yang sama ...

Catatan: juga ada perbedaan besar di antara mereka jika Anda memberikan nilai ke ES6 satu bahkan nilainya falsy, yang akan diganti dengan nilai baru, sesuatu seperti nullatau ""... tetapi ES5 satu hanya akan diganti jika hanya nilai yang diteruskan benar, itu karena cara ||kerjanya ...

Jika karena alasan tertentu Anda tidak di ES6 dan yang menggunakan lodashdi sini adalah cara ringkas untuk default parameter fungsi melalui _.defaultTometode:

var fn = function(a, b) {
  a = _.defaultTo(a, 'Hi')
  b = _.defaultTo(b, 'Mom!')

  console.log(a, b)
}

fn()                 // Hi Mom!
fn(undefined, null)  // Hi Mom!
fn(NaN, NaN)         // Hi Mom!
fn(1)                // 1 "Mom!"
fn(null, 2)          // Hi 2
fn(false, false)     // false false
fn(0, 2)             // 0 2

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Yang akan mengatur default jika nilai saat ini adalah NaN , null , atau tidak terdefinisi

Sounds of Future

Di masa depan, Anda akan dapat "menyebar" satu objek ke objek lain (saat ini pada 2019 TIDAK didukung oleh Edge !) - menunjukkan cara menggunakannya untuk opsi default yang bagus terlepas dari urutan:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

Referensi MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

... sementara itu yang didukung Edge DOES adalah Object.assign () (IE tidak, tapi saya sangat berharap kita dapat meninggalkan IE di belakang :))

Demikian pula yang bisa Anda lakukan

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input options
        
        var body = document.getElementsByTagName('body')[0];
        body.innerHTML += '<br>' + options.url + ' : ' + options.some;
    }
    test();
    test({});
    test({url:'myURL'});
    test({some:'somethingOfMine'});
    test({url:'overrideURL', some:'andSomething'});
    test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

EDIT: Karena komentar tentang constopsi - masalah dengan menggunakan opsi konstan di sisa fungsi sebenarnya bukan karena Anda tidak bisa melakukan itu, hanya saja Anda tidak dapat menggunakan variabel konstan dalam deklarasi sendiri - Anda akan memiliki untuk menyesuaikan penamaan input ke sesuatu seperti

function test(input_options){
   const options = {
     // defaults
     someKey:    'someDefaultValue',
     anotherKey: 'anotherDefaultValue',

     // merge-in input options
     ...input_options
   };

   // from now on use options with no problem
}

Sekadar memamerkan keahlian saya juga (lol), fungsi di atas dapat ditulis bahkan tanpa menyebutkan argumen seperti di bawah:

ES5 dan di atasnya

function foo() {
    a = typeof arguments[0] !== 'undefined' ? a : 42;
    b = typeof arguments[1] !== 'undefined' ? b : 'default_b';
    ...
}

ES6 ke atas

function foo(...rest) {
    a = typeof rest[0] !== 'undefined' ? a : 42;
    b = typeof rest[1] !== 'undefined' ? b : 'default_b';
    ...
}

def read_file(file, delete_after = false)
  # code
end

Kode berikut dapat berfungsi dalam situasi ini termasuk ECMAScript 6 (ES6) serta versi sebelumnya.

function read_file(file, delete_after) {
    if(delete_after == undefined)
        delete_after = false;//default value

    console.log('delete_after =',delete_after);
}
read_file('text1.txt',true);
read_file('text2.txt');

karena nilai default dalam bahasa berfungsi saat nilai parameter fungsi dilewati saat memanggil, dalam JavaScript fungsi tersebut ditetapkan untuk tidak terdefinisi . Pendekatan ini tidak terlihat menarik secara pemrograman tetapi memiliki kompatibilitas ke belakang .

Ya ini disebut sebagai parameter default

Parameter fungsi default memungkinkan parameter formal diinisialisasi dengan nilai default jika tidak ada nilai atau tidak terdefinisi.

Sintaksis:

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

Deskripsi:

Parameter fungsi default ke undefined Namun, dalam situasi mungkin berguna untuk menetapkan nilai default yang berbeda. Di sinilah parameter default dapat membantu.

Di masa lalu, strategi umum untuk menetapkan standar adalah dengan menguji nilai parameter di badan fungsi dan menetapkan nilai jika tidak ditentukan. Jika tidak ada nilai yang diberikan dalam panggilan, nilainya akan tidak ditentukan. Anda harus menetapkan pemeriksaan bersyarat untuk memastikan parameter tidak terdefinisi

Dengan parameter default di ES2015, pemeriksaan di badan fungsi tidak lagi diperlukan. Sekarang Anda cukup meletakkan nilai default di kepala fungsi.

Contoh perbedaan:

// OLD METHOD
function multiply(a, b) {
  b = (typeof b !== 'undefined') ?  b : 1;
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5


// NEW METHOD
function multiply(a, b = 1) {
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5

Contoh Sintaks yang berbeda:

Padding tidak terdefinisi vs nilai-nilai palsu lainnya:

Bahkan jika nilainya diatur secara eksplisit saat memanggil, nilai argumen num adalah yang default.

function test(num = 1) {
  console.log(typeof num);
}

test();          // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)

// test with other falsy values:
test('');        // 'string' (num is set to '')
test(null);      // 'object' (num is set to null)

Dievaluasi pada waktu panggilan:

Argumen default dievaluasi pada waktu panggilan, jadi tidak seperti beberapa bahasa lain, objek baru dibuat setiap kali fungsi dipanggil.

function append(value, array = []) {
  array.push(value);
  return array;
}

append(1); //[1]
append(2); //[2], not [1, 2]


// This even applies to functions and variables
function callSomething(thing = something()) {
 return thing;
}

function something() {
  return 'sth';
}

callSomething();  //sth

Parameter default tersedia untuk parameter default nanti:

Params sudah ditemui tersedia untuk parameter default nanti

function singularAutoPlural(singular, plural = singular + 's',
                        rallyingCry = plural + ' ATTACK!!!') {
  return [singular, plural, rallyingCry];
}

//["Gecko","Geckos", "Geckos ATTACK!!!"]
singularAutoPlural('Gecko');

//["Fox","Foxes", "Foxes ATTACK!!!"]
singularAutoPlural('Fox', 'Foxes');

//["Deer", "Deer", "Deer ... change."]
singularAutoPlural('Deer', 'Deer', 'Deer peaceably and respectfully \ petition the government for positive change.')

Fungsi yang didefinisikan di dalam tubuh fungsi:

Diperkenalkan di Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Fungsi yang dideklarasikan di badan fungsi tidak dapat dirujuk di dalam parameter default dan melempar ReferenceError (saat ini TypeError di SpiderMonkey, lihat bug 1022967). Parameter default selalu dijalankan terlebih dahulu, deklarasi fungsi di dalam tubuh fungsi mengevaluasi sesudahnya.

// Doesn't work! Throws ReferenceError.
function f(a = go()) {
  function go() { return ':P'; }
}

Parameter tanpa default setelah parameter default:

Sebelum Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), kode berikut menghasilkan SyntaxError. Ini telah diperbaiki di bug 777060 dan berfungsi seperti yang diharapkan di versi yang lebih baru. Parameter masih diatur kiri-ke-kanan, menimpa parameter default bahkan jika ada parameter selanjutnya tanpa default.

function f(x = 1, y) {
  return [x, y];
}

f(); // [1, undefined]
f(2); // [2, undefined]

Parameter yang dirusak dengan penetapan nilai default:

Anda dapat menggunakan penetapan nilai default dengan notasi penetapan merusak

function f([x, y] = [1, 2], {z: z} = {z: 3}) {
  return x + y + z;
}

f(); // 6

Hanya pendekatan yang berbeda untuk mengatur params default adalah dengan menggunakan objek peta argumen, bukan argumen secara langsung. Sebagai contoh,

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

Dengan cara ini, mudah untuk memperluas argumen dan tidak khawatir tentang panjang ketidakcocokan argumen.

Jawabannya iya. Bahkan, ada banyak bahasa yang mendukung parameter default. Python adalah salah satunya:

def(a, enter="Hello"):
   print(a+enter)

Meskipun ini adalah kode Python 3 karena tanda kurung, parameter default dalam fungsi juga berfungsi di JS.

Misalnya, dan dalam kasus Anda:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

Tetapi terkadang Anda tidak benar-benar membutuhkan parameter default.

Anda bisa mendefinisikan variabel tepat setelah dimulainya fungsi, seperti ini:

function read_file(file){
  var deleteAfter = false;
  console.log(deleteAfter);
}

read_file("test.txt");

Dalam kedua contoh saya, ini mengembalikan hal yang sama. Tetapi kadang-kadang mereka sebenarnya bisa bermanfaat, seperti dalam proyek yang sangat maju

Jadi, sebagai kesimpulan, nilai parameter default dapat digunakan di JS. Tapi itu hampir sama dengan mendefinisikan variabel tepat setelah dimulainya fungsi. Namun, terkadang mereka masih sangat bermanfaat. Seperti yang Anda perhatikan, nilai parameter default mengambil 1 baris kode lebih sedikit daripada cara standar yang mendefinisikan parameter tepat setelah dimulainya fungsi.

EDIT: Dan ini sangat penting! Ini tidak akanberfungsi di IE. Lihat dokumentasi . Jadi dengan IE Anda harus menggunakan metode "define variable at top of function". Parameter default tidak akan berfungsi di IE.

Ya, ini akan berfungsi dalam Javascript. Anda juga dapat melakukannya:

function func(a=10,b=20)
{
    alert (a+' and '+b);
}

func(); // Result: 10 and 20

func(12); // Result: 12 and 20

func(22,25); // Result: 22 and 25