Desde ES6 / ES2015, los parámetros predeterminados están en la especificación del idioma.

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

simplemente funciona.

Referencia: Parámetros predeterminados: MDN

Los parámetros de función predeterminados permiten inicializar parámetros formales con valores predeterminados si ningún valor or indefinido esta pasado.

También puede simular por defecto llamado parámetros mediante desestructuración:

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

Antes de ES2015,

Hay muchas formas, pero este es mi método preferido: te permite pasar lo que quieras, incluso falso o nulo. (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
}

Esto asigna a delete_after el valor de delete_after si no es un Falsey valor de lo contrario asigna la cadena "my default here". Para obtener más detalles, consulte Estudio del idioma de Doug Crockford y consulte la sección sobre operadores..

Este enfoque no funciona si desea pasar un Falsey valor es decir false, null, undefined, 0 or "". Si usted requiere Falsey valores que se pasarán, necesitará usar el método en La respuesta de Tom Ritter.

Cuando se trata de una serie de parámetros para una función, a menudo es útil permitir que el consumidor pase los argumentos de los parámetros en un objeto y luego unir estos valores con un objeto que contiene los valores predeterminados para la función

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

que se utilizará

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

Me parece que algo tan simple como esto es mucho más conciso y legible personalmente.

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

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

En ECMAScript 6, podrá escribir exactamente lo que tiene:

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

Esto establecerá delete_after a false si no está presente o undefined. Puede utilizar funciones de ES6 como esta hoy con transpiladores como Babel.

Consulte el artículo de MDN para obtener más información..

Valores de parámetros predeterminados

Con ES6, puede hacer quizás uno de los modismos más comunes en JavaScript se relaciona con el establecimiento de un valor predeterminado para un parámetro de función. La forma en que lo hemos hecho durante años debería parecer bastante familiar:

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

Este patrón es el más utilizado, pero es peligroso cuando pasamos valores como

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

¿Por qué? Porque el 0 is falsy, y entonces el x || 11 results in 11, no el pasado directamente en 0. Para solucionar este problema, algunas personas escribirán el cheque de manera más detallada de esta manera:

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

ahora podemos examinar una sintaxis útil agradable agregada a partir de ES6 para simplificar la asignación de valores predeterminados a los argumentos faltantes:

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 en una declaración de función es más como x !== undefined ? x : 11 que el modismo mucho más común x || 11

Expresiones de valor predeterminado

Function los valores predeterminados pueden ser más que simples valores como 31; pueden ser cualquier expresión válida, incluso una 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

Como puede ver, las expresiones de valor predeterminado se evalúan de manera perezosa, lo que significa que solo se ejecutan cuando son necesarias, es decir, cuando el argumento de un parámetro se omite o no está definido.

Una expresión de valor predeterminado puede ser incluso una llamada de expresión de función en línea, comúnmente conocida como expresión de función invocada inmediatamente (IIFE):

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

esa solución funciona para mí en js:

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

Simplemente use una comparación explícita con undefined.

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

Recomiendo encarecidamente tener extrema precaución al usar valores de parámetros predeterminados en javascript. A menudo crea errores cuando se usa junto con funciones de orden superior como forEach, map y reduce. Por ejemplo, considere esta línea de código:

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

parseInt tiene un segundo parámetro opcional function parseInt(s, [base=10]) pero el mapa llama parseInt con tres argumentos: (elementos, índice y matriz).

Le sugiero que separe sus parámetros requeridos de sus argumentos opcionales / valorados por defecto. Si su función toma 1,2, 3 o 4 parámetros requeridos para los cuales no tiene sentido ningún valor predeterminado, conviértalos en parámetros posicionales para la función, cualquier parámetro opcional debe seguir como atributos con nombre de un solo objeto. Si su función toma XNUMX o más, quizás tenga más sentido proporcionar todos los argumentos a través de los atributos de un único parámetro de objeto.

En su caso, le sugiero que escriba su función deleteFile así: (editado por instead's comentarios) ...

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

La ejecución del fragmento anterior ilustra los peligros que se esconden detrás de los valores de argumento predeterminados para los parámetros no utilizados.

Como actualización ... con ECMAScript 6 puede FINALMENTE establecer valores predeterminados en declaraciones de parámetros de función de la siguiente manera:

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

f(1) === 50

Como referenciado por - http://es6-features.org/#DefaultParameterValues

Siendo un desarrollador de C ++ desde hace mucho tiempo (novato en el desarrollo web :)), cuando me encontré por primera vez con esta situación, hice la asignación de parámetros en la definición de la función, como se menciona en la pregunta, de la siguiente manera.

function myfunc(a,b=10)

Pero tenga en cuenta que no funciona de manera uniforme en todos los navegadores. Para mí, funcionó en Chrome en mi escritorio, pero no funcionó en Chrome en Android. La opción más segura, como muchos han mencionado anteriormente es:

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

La intención de esta respuesta no es repetir las mismas soluciones, lo que otros ya han mencionado, sino informar que la asignación de parámetros en la definición de función puede funcionar en algunos navegadores, pero no confíe en ella.

Para cualquier persona interesada en que el código funcione en Microsoft Edge, no use valores predeterminados en los parámetros de función.

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

En ese ejemplo, Edge arrojará un error "Esperando ')'"

Para evitar este uso

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

A partir del 08 de agosto de 2016, esto sigue siendo un problema.

Según la sintaxis

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

puede definir el valor predeterminado de los parámetros formales. y también verifique el valor indefinido usando tipo de función.

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

Utilice esto si desea utilizar la última ECMA6 sintaxis:

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

Se llama default function parameters. Permite que los parámetros formales se inicialicen con valores predeterminados si no se pasa ningún valor o indefinido. NOTA: No funcionará con Internet Explorer o navegadores más antiguos.

Para el máximo posible compatibilidad utilizar esto:

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

Ambas funciones tienen exactamente el mismo comportamiento ya que cada uno de estos ejemplos se basa en el hecho de que la variable de parámetro será undefined si no se pasó ningún valor de parámetro al llamar a esa función.

Si está utilizando ES6+ puede configurar los parámetros predeterminados de la siguiente manera:

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

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

Si usted necesita ES5 sintaxis, puede hacerlo de la siguiente manera:

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

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

En la sintaxis anterior, el OR se utiliza el operador. La OR El operador siempre devuelve el primer valor si se puede convertir a true si no, devuelve el valor del lado derecho. Cuando se llama a la función sin un argumento correspondiente, la variable de parámetro (bar en nuestro ejemplo) se establece en undefined por el motor JS. undefined Luego se convierte en falso y, por lo tanto, el OR operador devuelve el valor 0.

ES6: Como ya se mencionó en la mayoría de las respuestas, en ES6, simplemente puede inicializar un parámetro junto con un valor.

ES5: La mayoría de las respuestas dadas no son lo suficientemente buenas para mí porque hay ocasiones en las que tengo que pasar valores falsos como 0, null y undefined a una función. Para determinar si un parámetro no está definido porque ese es el valor que pasé en lugar de indefinido debido a que no se ha definido en absoluto, hago esto:

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

Aquí foo () es una función que tiene un parámetro llamado argValue. Si no pasamos nada en la llamada a la función aquí, entonces se llamará a la función throwIfNoValue () y el resultado devuelto se asignará al único argumento argValue. Así es como se puede utilizar una llamada a función como parámetro predeterminado. Lo que hace que el código sea más simplificado y legible.

Este ejemplo ha sido tomado de aquí.

Sí, el uso de parámetros predeterminados es totalmente compatible ES6:

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

or

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

pero antes en ES5 fácilmente podría hacer esto:

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

Lo que significa que si el valor está allí, use el valor; de lo contrario, use el segundo valor después || operación que hace lo mismo ...

Nota: también hay una gran diferencia entre ellos si pasa un valor a ES6 uno incluso el valor sea falso, que será reemplazado por un nuevo valor, algo así como null or ""... pero ES5 uno solo será reemplazado si solo el valor pasado es verdadero, eso es porque la forma || trabajando...

Si por alguna razón eres no en ES6 y están usar lodash aquí hay una forma concisa de los parámetros de función predeterminados a través de _.defaultTo método:

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>

Que establecerá el valor predeterminado si el valor actual es Yaya, nuloo indefinido

Sonidos del futuro

En el futuro, podrá "difundir" un objeto a otro (actualmente a partir de 2019 NO es compatible con Edge!) - demostración de cómo usar eso para obtener buenas opciones predeterminadas independientemente del orden:

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

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

... mientras tanto que El soporte de Edge SÍ es Object.assign () (IE no, pero realmente espero que podamos dejar IE atrás :))

Del mismo modo, podrías hacer

    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: Debido a los comentarios sobre const opciones: el problema con el uso de opciones constantes en el resto de la función es en realidad no que no puede hacer eso, es solo que no puede usar la variable constante en su propia declaración; tendría que ajustar el nombre de entrada a algo como

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
}

Solo para mostrar mis habilidades también (risas), la función anterior se puede escribir incluso sin tener los argumentos nombrados como se muestra a continuación:

ES5 y superior

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

ES6 y superior

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

El siguiente código puede funcionar en esta situación, incluido ECMAScript 6 (ES6), así como versiones anteriores.

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

como valor predeterminado en los idiomas funciona cuando el valor del parámetro de la función se omite al llamar, en JavaScript se asigna a indefinido. Este enfoque no parece atractivo desde el punto de vista programático, pero tiene compatibilidad con versiones anteriores.

Sí, esto se conoce como parámetro predeterminado

Los parámetros de función predeterminados permiten que los parámetros formales se inicialicen con valores predeterminados si no se pasa ningún valor o si se pasa indefinido.

Sintaxis:

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

Descripción

Los parámetros de las funciones están predeterminados como indefinidos. Sin embargo, en situaciones puede ser útil establecer un valor predeterminado diferente. Aquí es donde los parámetros predeterminados pueden ayudar.

En el pasado, la estrategia general para establecer valores predeterminados era probar los valores de los parámetros en el cuerpo de la función y asignar un valor si no estaban definidos. Si no se proporciona ningún valor en la llamada, su valor sería indefinido. Debería establecer una verificación condicional para asegurarse de que el parámetro no esté indefinido

Con los parámetros predeterminados en ES2015, la verificación en el cuerpo de la función ya no es necesaria. Ahora puede simplemente poner un valor predeterminado en el encabezado de la función.

Ejemplo de las diferencias:

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

Diferentes ejemplos de sintaxis:

Relleno indefinido frente a otros valores falsos:

Incluso si el valor se establece explícitamente al llamar, el valor del argumento num es el predeterminado.

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)

Evaluado al momento de la llamada:

El argumento predeterminado se evalúa en el momento de la llamada, por lo que, a diferencia de otros lenguajes, se crea un nuevo objeto cada vez que se llama a la función.

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

Los parámetros predeterminados están disponibles para los parámetros predeterminados posteriores:

Los parámetros ya encontrados están disponibles para los parámetros predeterminados posteriores

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

Funciones definidas dentro del cuerpo de la función:

Introducido en Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Las funciones declaradas en el cuerpo de la función no se pueden hacer referencia dentro de los parámetros predeterminados y arrojan un ReferenceError (actualmente un TypeError en SpiderMonkey, consulte el error 1022967). Los parámetros predeterminados siempre se ejecutan primero, las declaraciones de función dentro del cuerpo de la función se evalúan después.

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

Parámetros sin valores predeterminados después de los parámetros predeterminados:

Antes de Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), el siguiente código generaba un SyntaxError. Esto se ha corregido en el error 777060 y funciona como se esperaba en versiones posteriores. Los parámetros aún se establecen de izquierda a derecha, sobrescribiendo los parámetros predeterminados incluso si hay parámetros posteriores sin valores predeterminados.

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

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

Parámetro desestructurado con asignación de valor por defecto:

Puede utilizar la asignación de valor predeterminada con la notación de asignación de desestructuración

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

f(); // 6

Solo un enfoque diferente para establecer parámetros predeterminados es usar un mapa de objetos de argumentos, en lugar de argumentos directamente. Por ejemplo,

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

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

De esta manera, es fácil extender los argumentos y no preocuparse por la falta de coincidencia de la longitud de los argumentos.

La respuesta es sí. De hecho, hay muchos idiomas que admiten parámetros predeterminados. Python es uno de ellos:

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

Aunque este es el código de Python 3 debido a los paréntesis, los parámetros predeterminados en las funciones también funcionan en JS.

Por ejemplo, y en tu caso:

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

read_file("test.txt");

Pero a veces realmente no necesitas los parámetros predeterminados.

Puede definir la variable justo después del inicio de la función, así:

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

read_file("test.txt");

En mis dos ejemplos, devuelve lo mismo. Pero a veces pueden resultar útiles, como en proyectos muy avanzados.

Entonces, en conclusión, los valores de parámetros predeterminados se pueden usar en JS. Pero es casi lo mismo que definir una variable justo después del inicio de la función. Sin embargo, a veces siguen siendo muy útiles. Como habrá notado, los valores de los parámetros predeterminados toman 1 línea menos de código que la forma estándar que define el parámetro justo después del inicio de la función.

EDIT: ¡Y esto es super importante! Esta voluntad no trabajar en IE. Ver documentación. Entonces, con IE tienes que usar el método "definir variable en la parte superior de la función". Los parámetros predeterminados no funcionarán en IE.

Sí - prueba:

function read_file(file, delete_after = false) {
  // Code
  console.log({file,delete_after});
}



// TEST
read_file("A");
read_file("B",true);
read_file("C",false);

Sí, esto funcionará en Javascript. También puedes hacer eso:

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