Saya ingin sebuah fungsi JavaScript untuk memiliki argumen optional yang saya set default, yang bisa digunakan jika nilai isn't didefinisikan (dan diabaikan jika nilai lulus). Di Ruby, anda dapat melakukannya seperti ini:
def read_file(file, delete_after = false)
# code
end
Apakah ini bekerja di JavaScript?
function read_file(file, delete_after = false) {
// Code
}
Dari ES6/ES2015, default parameter dalam spesifikasi bahasa.
function read_file(file, delete_after = false) {
// Code
}
hanya bekerja.
Referensi: Default Parameter - MDN
Default parameter fungsi memungkinkan parameter formal untuk dapat diinisialisasi dengan nilai-nilai default jika tidak ada nilai atau terdefinisi dilewatkan.
Anda juga dapat mensimulasikan default nama parameter melalui destructuring:
// 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
···
}
Pra ES2015,
Ada banyak cara, tapi ini adalah metode yang disukai saya — ini memungkinkan anda lulus dalam apa pun yang anda inginkan, termasuk false atau null. (typeof null == "objek"
)
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 menetapkan untuk delete_after
nilai delete_after
jika tidak falsey nilai jika tidak memberikan string "default saya di sini"
. Untuk lebih detail, lihat Doug Crockford's survei dari bahasa dan periksa bagian Operator.
Pendekatan ini tidak bekerja jika anda ingin lulus dalam falsey nilai yaitu false
, null
, undefined
, 0
atau ","
. Jika anda memerlukan falsey nilai-nilai yang harus dilalui dalam anda akan perlu untuk menggunakan metode dalam Tom Ritter's jawaban.
Ketika berhadapan dengan sejumlah parameter untuk fungsi, hal ini sering berguna untuk memungkinkan konsumen untuk melewati parameter argumen dalam suatu objek dan kemudian menggabungkan nilai-nilai ini dengan sebuah objek yang berisi nilai-nilai default untuk fungsi
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;
};
untuk 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" });
Dalam ECMAScript 6 anda akan benar-benar dapat menulis apa yang anda miliki:
function read_file(file, delete_after = false) {
// Code
}
Ini akan mengatur delete_after
untuk palsu
jika itu s tidak hadir atau undefined
. Anda dapat menggunakan fitur-fitur ES6 seperti ini hari ini dengan transpilers seperti Babel.
Default Nilai Parameter
Dengan ES6, yang dapat anda lakukan mungkin salah satu yang paling umum idiom dalam JavaScript
berkaitan dengan pengaturan nilai default untuk parameter fungsi. Cara kita melakukan ini selama bertahun-tahun harus 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 lebih berbahaya ketika kita lulus nilai-nilai seperti
foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42
Mengapa? Karena 0 falsy
, dan x || 11 hasil dalam 11
, tidak langsung disahkan pada 0. Untuk memperbaiki hal ini gotcha, beberapa orang malah akan menulis cek lebih verbosely 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
sekarang kita dapat memeriksa bagus dan membantu sintaks ditambahkan sebagai ES6
untuk merampingkan tugas dari nilai-nilai default untuk hilang argumen:
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 = 11
dalam deklarasi fungsi lebih seperti x !== undefined ? x : 11
dari jauh lebih umum idiom x || 11
Nilai Default Ekspresi
Fungsi
nilai default dapat menjadi lebih dari sekedar sederhana nilai-nilai seperti 31; mereka dapat setiap ekspresi valid, bahkan fungsi panggilan
:
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, nilai default ekspresi malas dievaluasi, yang berarti mereka hanya berjalan jika dan ketika mereka dibutuhkan — yang, ketika parameter argumen dihilangkan atau tidak terdefinisi.
Nilai default ekspresi bahkan dapat inline ekspresi fungsi panggilan — sering disebut sebagai Segera Dipanggil Fungsi Ekspresi (HIDUP)
:
function foo( x =
(function(v){ return v + 11; })( 31 )
) {
console.log( x );
}
foo(); // 42
Sebagai update...dengan ECMAScript 6 anda dapat AKHIRNYA set nilai default pada parameter fungsi deklarasi seperti:
function f (x, y = 7, z = 42) {
return x + y + z
}
f(1) === 50
Seperti yang dirujuk oleh - http://es6-features.org/#DefaultParameterValues
Saya akan sangat menyarankan hati-hati saat menggunakan parameter default nilai-nilai dalam javascript. Hal ini sering menimbulkan bug ketika digunakan dalam hubungannya dengan tatanan yang lebih tinggi fungsi seperti forEach
, peta
, dan mengurangi
. Sebagai contoh, perhatikan baris kode ini:
['1', '2', '3'].map(parseInt); // [1, NaN, NaN]
parseInt memiliki parameter opsional kedua fungsi parseInt(s, [
radix=10])
tapi peta panggilan parseInt
dengan tiga argumen: (element, index, dan array).
Saya sarankan anda memisahkan anda diperlukan parameter bentuk opsional anda/default dihargai argumen. Jika anda mengambil fungsi 1,2, atau 3 parameter yang diperlukan untuk yang tidak ada standar nilai masuk akal, membuat mereka positional parameter untuk fungsi, setiap parameter opsional harus mengikuti seperti yang disebutkan atribut-atribut dari suatu objek tunggal. Jika anda fungsi mengambil 4 atau lebih, mungkin lebih masuk akal untuk memasok semua argumen melalui atribut-atribut dari suatu objek tunggal parameter.
Dalam kasus anda, saya sarankan anda untuk menulis deleteFile fungsi seperti ini: (diedit per bukan
'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);
Berjalan di atas cuplikan yang menggambarkan bahaya mengintai di balik default argumen nilai-nilai untuk parameter yang tidak terpakai.
menjadi waktu yang lama C++ developer (Rookie untuk pengembangan web :)), ketika saya pertama kali datang di situasi ini, saya melakukan tugas parameter dalam definisi fungsi, seperti disebutkan dalam pertanyaan, yaitu sebagai berikut.
function myfunc(a,b=10)
Tapi hati-hati bahwa itu doesn't bekerja secara konsisten di seluruh browser. Bagi saya itu bekerja pada chrome di desktop saya, tapi tidak bekerja pada chrome di android. Pilihan yang lebih aman, seperti yang banyak disebutkan di atas adalah -
function myfunc(a,b)
{
if (typeof(b)==='undefined') b = 10;
......
}
Niat untuk jawaban ini adalah untuk tidak mengulangi hal yang sama solusi, apa yang orang lain telah disebutkan, tapi untuk menginformasikan bahwa tugas parameter dalam definisi fungsi dapat bekerja pada beberapa browser, tapi don't bergantung pada itu.
Untuk siapa saja yang tertarik dalam memiliki ada kode bekerja di Microsoft Edge, tidak menggunakan default pada parameter fungsi.
function read_file(file, delete_after = false) {
#code
}
Dalam contoh yang Edge akan melempar kesalahan "Mengharapkan ')'"
Untuk mendapatkan sekitar ini menggunakan
function read_file(file, delete_after) {
if(delete_after == undefined)
{
delete_after = false;
}
#code
}
Seperti dari Aug 08 2016 ini masih menjadi masalah
Sesuai dengan sintaks
function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
statements
}
anda dapat menentukan nilai default dari parameter formal. dan juga memeriksa nilai tak terdefinisi dengan menggunakan typeof fungsi.
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!!!
ES6: Seperti yang sudah disebutkan di sebagian besar jawaban, di ES6, anda hanya dapat menginisialisasi parameter seiring dengan nilai.
ES5: Sebagian besar jawaban yang diberikan aren't cukup baik bagi saya karena ada kesempatan di mana saya mungkin harus melewati falsey nilai-nilai seperti 0
, null
dan undefined
untuk sebuah fungsi. Untuk menentukan apakah suatu parameter yang tidak terdefinisi karena itu's nilai saya lulus bukan tidak terdefinisi karena tidak telah didefinisikan pada semua yang saya lakukan ini:
function foo (param1, param2) {
param1 = arguments.length >= 1 ? param1 : "default1";
param2 = arguments.length >= 2 ? param2 : "default2";
}
Gunakan ini jika anda ingin menggunakan terbaru ECMA6
sintaks:
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
Hal ini disebut default fungsi parameters
. Hal ini memungkinkan parameter formal untuk dapat diinisialisasi dengan nilai-nilai default jika tidak ada nilai atau tidak terdefinisi dilewatkan.
CATATAN: Ti wont bekerja dengan Internet Explorer atau browser yang lebih tua.
Untuk maksimum kompatibilitas **** 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
Keduanya memiliki fungsi yang sama persis perilaku karena masing-masing dari contoh-contoh ini bergantung pada kenyataan bahwa parameter variabel akan undefined
jika tidak ada nilai parameter yang dilewatkan saat pemanggilan fungsi.
Ya, dengan menggunakan parameter default adalah sepenuhnya didukung di ES6:
function read_file(file, delete_after = false) {
// Code
}
atau
const read_file = (file, delete_after = false) => {
// Code
}
tapi sebelum di ES5 anda bisa dengan mudah melakukan hal ini:
function read_file(file, delete_after) {
var df = delete_after || false;
// Code
}
Yang berarti jika nilai yang ada, gunakan nilai, jika tidak, gunakan nilai yang kedua setelah ||
operasi yang melakukan hal yang sama...
Catatan: juga ada perbedaan besar antara orang-orang jika anda melewatkan nilai ke ES6 satu bahkan nilai menjadi falsy, yang akan diganti dengan nilai baru, sesuatu seperti null
atau ","
... tapi ES5 satu-satunya akan diganti jika hanya melewati nilai truthy, yang's karena cara ||
bekerja...
Jika anda menggunakan ES6+
anda dapat mengatur parameter default dengan cara sebagai berikut:
function test (foo = 1, bar = 2) {
console.log(foo, bar);
}
test(5); // foo gets overwritten, bar remains default parameter
Jika anda membutuhkan ES5
sintaks anda dapat melakukannya dengan cara sebagai 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 yang ATAU
operator yang digunakan. The ATAU
operator selalu mengembalikan nilai pertama jika hal ini dapat dikonversi menjadi true
jika tidak kembali righthandside nilai. Ketika fungsi ini dipanggil dengan tidak sesuai argumen parameter variabel (bar
dalam contoh kita) diatur ke undefined
oleh JS engine. undefined
kemudian diubah menjadi false dan dengan demikian tidak ATAU
operator mengembalikan nilai 0.
function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}
Di sini foo() adalah fungsi yang memiliki parameter bernama argValue. Jika kita tidak lulus apa-apa dalam fungsi panggilan di sini, maka fungsi throwIfNoValue() akan dipanggil dan kembali hasilnya akan ditugaskan untuk satu-satunya argumen argValue. Ini adalah cara pemanggilan fungsi dapat digunakan sebagai parameter default. Yang membuat kode yang lebih sederhana dan mudah dibaca.
Jika untuk beberapa alasan anda tidak ** pada ES6 dan sedang** menggunakan lodash
berikut adalah cara ringkas untuk default parameter fungsi melalui _.standaruntuk
metode:
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 NaN, null, atau terdefinisi
Ya ini disebut sebagai parameter default
Default parameter fungsi memungkinkan parameter formal untuk dapat diinisialisasi dengan nilai-nilai default jika tidak ada nilai atau tidak terdefinisi dilewatkan.
Sintaks:
function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
statements
}
Keterangan:
Parameter dari fungsi default untuk undefined Namun, dalam situasi yang mungkin akan berguna untuk mengatur default yang berbeda nilai. Ini adalah di mana default parameter dapat membantu.
Di masa lalu, strategi umum untuk pengaturan default adalah untuk menguji nilai-nilai parameter dalam tubuh fungsi dan menetapkan nilai jika mereka tidak terdefinisi. Jika tidak ada nilai yang diberikan dalam panggilan ini, nilainya akan menjadi tidak terdefinisi. Anda akan memiliki untuk mengatur bersyarat periksa untuk memastikan parameter tidak terdefinisi
Dengan parameter default di ES2015, check-in fungsi tubuh tidak lagi diperlukan. Sekarang anda hanya dapat menempatkan nilai default fungsi kepala.
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
Sintaks Yang Berbeda Contoh:
Padding terdefinisi vs lainnya falsy nilai-nilai:
Bahkan jika nilai diatur secara eksplisit ketika menelepon, nilai num argumen 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:
Default argumen akan 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
Default parameter yang tersedia untuk kemudian default parameter:
Params sudah ditemui tersedia untuk kemudian parameter default
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 fungsi tubuh:
Diperkenalkan di Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Fungsi-fungsi yang dideklarasikan dalam fungsi tubuh tidak dapat disebut dalam parameter default dan membuang ReferenceError (saat ini TypeError di SpiderMonkey, melihat bug 1022967). Default parameter yang selalu dieksekusi pertama, deklarasi fungsi di dalam fungsi tubuh mengevaluasi sesudahnya.
// Doesn't work! Throws ReferenceError.
function f(a = go()) {
function go() { return ':P'; }
}
Parameter tanpa default setelah default parameter:
Sebelum Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), berikut kode mengakibatkan SyntaxError. Hal ini telah diperbaiki bug 777060 dan bekerja seperti yang diharapkan dalam versi kemudian. Parameter yang masih set kiri-ke-kanan, timpa default parameter bahkan jika ada kemudian tanpa parameter default.
function f(x = 1, y) {
return [x, y];
}
f(); // [1, undefined]
f(2); // [2, undefined]
Destructured parameter dengan nilai default tugas:
Anda dapat menggunakan default nilai tugas dengan destructuring tugas notasi
function f([x, y] = [1, 2], {z: z} = {z: 3}) {
return x + y + z;
}
f(); // 6