JavaScript işlevi için varsayılan bir parametre değeri ayarlama

Ben bir JavaScript işlevi değeri tanımlanmadıysa (ve değer geçirilirse yoksayılır) kullanılan varsayılan olarak ayarladığım isteğe bağlı bağımsız değişkenlere sahip olmak istiyorum. Ruby'de bunu şöyle yapabilirsiniz:

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

Bu JavaScript'te çalışıyor mu?

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

Gönderen ES6 / ES2015 , varsayılan parametreleri dil şartnamede bulunmaktadır.

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

sadece çalışır.

Referans: Varsayılan Parametreler - MDN

Varsayılan fonksiyon parametreleri, herhangi bir değer veya tanımlanmamışsa resmi parametrelerin varsayılan değerlerle başlatılmasına izin verir .

Ayrıca , yıkım yoluyla varsayılan adlandırılmış parametreleri simüle edebilirsiniz :

// 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
    ···
}

ES2015 öncesi ,

Birçok yol var, ama bu benim tercih ettiğim yöntem - yanlış veya null dahil olmak üzere istediğiniz her şeyi iletmenizi sağlar. ( 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
}

Bu, delete_after değeri delete_aftero değilse Falsey değeri aksi takdirde dize atar "my default here". Daha fazla ayrıntı için Doug Crockford'un dil araştırmasına ve Operatörler bölümüne göz atın. .

Bir falsey değerini geçmek istiyorsanız bu yaklaşım işe yaramaz false, yani ,null , undefined, 0veya "". Eğer falsey değerlerinin geçilmesini istiyorsanız Tom Ritter'ın cevabındaki yöntemi kullanmanız gerekir. .

Bir işleve birkaç parametre ile uğraşırken, tüketicinin parametre bağımsız değişkenlerini bir nesneye geçirmesine ve ardından bu değerleri işlevin varsayılan değerlerini içeren bir nesneyle birleştirmesine izin vermek genellikle yararlıdır

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

kullanmak

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

Kişisel olarak çok daha özlü ve okunabilir bir şey buldum.

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

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

ECMAScript 6'da tam olarak sahip olduklarınızı tam olarak yazabilirsiniz:

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

Bu ayarlar delete_afteriçin falsedeğil mevcut veya buysa undefined. Bunun gibi ES6 özelliklerini bugün Babel gibi transpillerle kullanabilirsiniz .

Daha fazla bilgi için MDN makalesine bakın .

Varsayılan Parametre Değerleri

ES6 ile, JavaScriptbir fonksiyon parametresi için varsayılan bir değer ayarlamakla ilgili olarak belki de en yaygın deyimlerden birini yapabilirsiniz . Bunu yıllardır yapma şeklimiz oldukça tanıdık gelmelidir:

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

Bu model en çok kullanılır, ancak aşağıdaki gibi değerler geçirdiğimizde tehlikelidir

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

Neden? Çünkü 0 is falsy, ve x || 11 results in 11doğrudan doğruya 0'dan geçmedi.

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

artık ES6varsayılan değerlerin eksik argümanlara atanmasını kolaylaştırmak için eklenmiş hoş bir sözdizimini inceleyebiliriz :

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 = 11bir işlev bildiriminde x !== undefined ? x : 11çok daha yaygın bir deyimden daha çokx || 11

Varsayılan Değer İfadeleri

Functionvarsayılan değerler 31 gibi basit değerlerden daha fazlası olabilir; geçerli bir ifade olabilir, hatta 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

Gördüğünüz gibi, varsayılan değer ifadeleri tembel olarak değerlendirilir, yani yalnızca gerektiğinde ve gerektiğinde, yani bir parametrenin argümanı atlandığında veya tanımsız olduğunda çalıştırılır.

Varsayılan değer ifadesi, genellikle Hemen Çağırılan İşlev İfadesi olarak adlandırılan bir satır içi işlev ifadesi çağrısı bile olabilir (IIFE):

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

Bu çözüm js benim için iş:

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

Undefined ile açık bir karşılaştırma kullanın.

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

Javascript varsayılan parametre değerleri kullanırken çok dikkatli tavsiye ediyoruz. Genellikle gibi yüksek mertebeden fonksiyonları ile birlikte kullanıldığında hataları oluşturur forEach, mapve reduce. Örneğin, şu kod satırını düşünün:

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

parseInt isteğe bağlı ikinci bir parametrenin function parseInt(s, [kök=10]) ancak harita çağrıları parseInt(üç bağımsız değişken ile eleman , göstergesi ve bir dizi ).

Gerekli parametreleri isteğe bağlı / varsayılan değerli argümanlarınızdan ayırmanızı öneririm. İşleviniz varsayılan değeri anlamlı olmayan 1,2 veya 3 gerekli parametre alıyorsa, bunları işleve konumsal parametreler yapın, isteğe bağlı tüm parametreler tek bir nesnenin adlandırılmış öznitelikleri olarak izlenmelidir. İşleviniz 4 veya daha fazla zaman alıyorsa, tüm bağımsız değişkenleri tek bir nesne parametresinin nitelikleri aracılığıyla sağlamak belki de daha mantıklıdır.

Senin durumunda ben böyle senin deleteFile işlevi yazmak öneririm: ( başına düzenlenmiş instead bireyin yorumlarla ) ...

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

Yukarıdaki snippet'in çalıştırılması, kullanılmayan parametreler için varsayılan bağımsız değişken değerlerinin ardında yatan tehlikeleri gösterir.

Bir güncelleme olarak ... ECMAScript 6 ile SON DAKİKA gibi işlev parametresi bildirimlerinde varsayılan değerleri ayarlayabilirsiniz:

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

f(1) === 50

Referans olarak - http://es6-features.org/#DefaultParameterValues

uzun zamandır C ++ geliştiricisi (Rookie to web development :)), bu duruma ilk rastladığımda, aşağıdaki gibi soruda belirtildiği gibi fonksiyon tanımında parametre ataması yaptım.

function myfunc(a,b=10)

Ancak tarayıcılarda tutarlı bir şekilde çalışmadığına dikkat edin. Benim için masaüstümde krom üzerinde çalıştı, ancak android üzerinde krom üzerinde çalışmadı. Yukarıda belirtildiği gibi daha güvenli bir seçenek -

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

Bu cevabın amacı, diğerlerinin daha önce bahsettikleri aynı çözümleri tekrarlamak değil, işlev tanımındaki parametre atamasının bazı tarayıcılarda işe yarayabileceğini, ancak buna güvenmediğini bildirmektir.

Kodun Microsoft Edge'de çalışmasını isteyen herkes için işlev parametrelerinde varsayılanları kullanmayın.

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

Bu örnekte Edge, "Bekliyor ')'" hatası veriyor

Bu kullanımdan kurtulmak için

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

08 Ağu 2016 itibarıyla bu hala bir sorun

Sözdizimine göre

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

biçimsel parametrelerin varsayılan değerini tanımlayabilirsiniz. ve typeof fonksiyonunu kullanarak tanımlanmamış değeri kontrol edin .

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!!!

En son ECMA6sözdizimini kullanmak istiyorsanız bunu kullanın :

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

Buna denir default function parameters. Herhangi bir değer veya tanımlanmamışsa, resmi parametrelerin varsayılan değerlerle başlatılmasına izin verir. NOT : Internet Explorer veya daha eski tarayıcılarla çalışmaz.

Mümkün olan maksimum uyumluluk için bunu kullanın:

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

Her iki işlev de bu örneğin her biriyle aynı davranışa sahiptir, undefinedbu işlev çağrılırken parametre değerinin geçilmemesi durumunda parametre değişkeninin olacağına güvenir .

ES6: Çoğu cevapta daha önce de belirtildiği gibi, ES6'da, bir değerle birlikte bir parametreyi başlatabilirsiniz.

ES5: Verilen cevapların çoğu ben gibi Falsey değerler geçirmek gerekebilir durumlar vardır çünkü benim için iyi değil yeterli 0, nullve undefinedbir işleve. Bir parametrenin tanımlanıp tanımlanmadığını belirlemek için tanımlandığım için tanımsız yerine geçirdiğim değer budur, bunu yaptım:

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

Burada foo (), argValue adlı bir parametreye sahip bir işlevdir. Burada işlev çağrısında bir şey iletmezsek, throwIfNoValue () işlevi çağrılır ve döndürülen sonuç yalnızca argValue bağımsız değişkenine atanır. Bir işlev çağrısı varsayılan parametre olarak bu şekilde kullanılabilir. Bu da kodu daha basit ve okunabilir hale getirir.

Bu örnek buradan alınmıştır

Kullanıyorsanız, ES6+varsayılan parametreleri aşağıdaki şekilde ayarlayabilirsiniz:

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

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

ES5Sözdizimine ihtiyacınız varsa, bunu aşağıdaki şekilde yapabilirsiniz:

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

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

Yukarıdaki sözdiziminde ORoperatör kullanılır. ORBu dönüştürülebilir eğer operatör her zaman ilk değerini verir trueo rightHandSide değerini döndürür değilse. İşlev karşılık gelen bir argüman olmadan çağrıldığında, parametre değişkeni ( barörneğimizde) undefinedJS motoru tarafından ayarlanır . undefinedDaha sonra false ORdeğerine dönüştürülür ve böylece operatör 0 değerini döndürür.

Evet, varsayılan parametreleri kullanmak ES6'da tam olarak desteklenir :

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

veya

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

ancak ES5'ten önce bunu kolayca yapabilirsiniz:

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

Bu, değer varsa, değeri kullanın, aksi takdirde, ikinci değeri || aynı şeyi işlemden ...

Not: Eğer bir değer geçirmesi durumunda da bu arasında büyük bir fark vardır ES6 gibi yeni değer, bir şey ile değiştirilir olacağını, hatta değer falsy olmak bir nullya ""... ama ES5 sadece iletilen değerin eğer biri sadece değiştirilecektir doğrudur, çünkü ||çalışma şekli ...

Herhangi bir nedenle varsa değil ES6 ve edilir kullanarak lodashburada aracılığıyla işlev parametreleri varsayılan özlü bir yoldur _.defaultToyöntemle:

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>

Geçerli değer NaN , null veya undefined ise varsayılanı ayarlar

Geleceğin Sesleri

Gelecekte, bir nesneyi diğerine "yayabileceksiniz" (şu anda 2019'dan itibaren Edge tarafından desteklenmiyor !)

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

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

... bu arada Edge'in desteklediği şey Object.assign () (IE değil, ama IE'yi geride bırakabileceğimizi umuyoruz :))

Benzer şekilde yapabilirsin

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

DÜZENLEME: nedeniyle ilgili yorumlarına constseçenekleri - İşlevin geri kalanında sabit seçenekleri kullanarak sorunu aslında değil bunu yapamam, sen kendi bildiriminde sabit değişkeni kullanamazsınız sadece - Eğer olurdu giriş adlandırma gibi bir şeye ayarlamak için

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
}

Sadece becerilerimi de sergilemek (lol), yukarıdaki fonksiyon aşağıdaki gibi argümanlar adlandırılmadan bile yazılabilir:

ES5 ve üstü

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

ES6 ve üstü

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

ECMAScript 6 (ES6) ve önceki sürümler dahil olmak üzere bu durumda aşağıdaki kodlar işe yarayabilir.

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

dilde varsayılan değer olarak çağrıldığında işlevin parametre değeri atlandığında çalışır, JavaScript'te tanımsız olarak atanır . Bu yaklaşım programlı olarak çekici görünmüyor, ancak geriye dönük uyumluluğa sahip .

Evet, bu varsayılan parametre olarak adlandırılır

Varsayılan fonksiyon parametreleri, herhangi bir değer veya tanımlanmamışsa resmi parametrelerin varsayılan değerlerle başlatılmasına izin verir.

Sözdizimi:

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

Açıklama:

Varsayılan olarak tanımlanmamış işlevlerin parametreleri Ancak, farklı bir varsayılan değer ayarlamak yararlı olabilir. Bu, varsayılan parametrelerin yardımcı olabileceği yerdir.

Geçmişte, varsayılanları ayarlamak için genel strateji, işlevin gövdesinde parametre değerlerini sınamak ve tanımlanmamışlarsa bir değer atamaktı. Çağrıda hiçbir değer sağlanmazsa, değeri tanımsız olur. Parametrenin tanımsız olmadığından emin olmak için bir koşullu denetim ayarlamanız gerekir

ES2015'teki varsayılan parametrelerle, işlev gövdesindeki kontrol artık gerekli değildir. Artık işlev kafasına varsayılan bir değer koyabilirsiniz.

Farklılıklara örnek:

// 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

Farklı Sözdizimi Örnekleri:

Dolgu tanımsız ve diğer yanlış değerler:

Arama sırasında değer açıkça ayarlanmış olsa bile, num bağımsız değişkeninin değeri varsayılan değerdir.

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)

Çağrı zamanında değerlendirme:

Varsayılan argüman çağrı zamanında değerlendirilir, bu nedenle diğer bazı dillerden farklı olarak, işlev her çağrıldığında yeni bir nesne oluşturulur.

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

Varsayılan parametreler daha sonraki varsayılan parametreler için kullanılabilir:

Karşılaşılan parametreler daha sonraki varsayılan parametreler için kullanılabilir

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.')

İşlev gövdesi içinde tanımlanan işlevler:

Gecko 33'te (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30) tanıtıldı. İşlev gövdesinde bildirilen işlevler varsayılan parametreler içinde gönderilemez ve ReferenceError atar (şu anda SpiderMonkey'de bir TypeError, bkz. Hata 1022967). Varsayılan parametreler her zaman önce yürütülür, işlev gövdesi içindeki işlev bildirimleri daha sonra değerlendirilir.

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

Varsayılan parametrelerden sonra varsayılanları olmayan parametreler:

Gecko 26'dan (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) önce, aşağıdaki kod bir SyntaxError ile sonuçlandı. Bu hata 777060 ile giderilmiştir ve sonraki sürümlerde beklendiği gibi çalışır. Parametreler yine de soldan sağa ayarlanmıştır, varsayılan olmayan daha sonraki parametreler olsa bile varsayılan parametrelerin üzerine yazılır.

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

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

Varsayılan değer ataması ile tahrip edilen paramet:

Varsayılan değer atamasını, yıkıcı atama gösterimi ile kullanabilirsiniz

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

f(); // 6

Varsayılan parametreleri ayarlamak için sadece farklı bir yaklaşım, argümanların doğrudan nesne yerine argümanların nesne haritasını kullanmaktır. Örneğin,

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

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

Bu şekilde, argümanları genişletmek ve argüman uzunluğu uyuşmazlığı konusunda endişelenmemek kolaydır.

Cevap Evet. Aslında, varsayılan parametreleri destekleyen birçok dil vardır. Python bunlardan biri:

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

Bu parantez nedeniyle Python 3 kodu olsa da, işlevlerdeki varsayılan parametreler JS'de de çalışır.

Örneğin ve sizin durumunuzda:

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

read_file("test.txt");

Ancak bazen gerçekten varsayılan parametrelere ihtiyacınız yoktur.

Değişkeni, işlevin başlamasından hemen sonra şu şekilde tanımlayabilirsiniz:

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

read_file("test.txt");

Her iki örneğimde de aynı şeyi döndürüyor. Ancak bazen çok gelişmiş projelerde olduğu gibi faydalı olabilirler.

Sonuç olarak, JS'de varsayılan parametre değerleri kullanılabilir. Fakat neredeyse fonksiyonun başlamasından hemen sonra bir değişken tanımlamakla aynı şeydir. Bununla birlikte, bazen hala çok faydalıdırlar. Fark edebileceğiniz gibi, varsayılan parametre değerleri, fonksiyonun başlamasından hemen sonra parametreyi tanımlayan standart yoldan 1 daha az kod satırı alır.

EDIT: Ve bu çok önemli! Bu olacak değil IE'de çalışır. Belgelere bakın. Yani IE ile "fonksiyonun üstündeki değişken tanımla" yöntemini kullanmalısınız. Varsayılan parametreler IE'de çalışmaz.

Evet, Javascript ile çalışacaktır. Ayrıca şunları da yapabilirsiniz:

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