Defina um valor de parâmetro padrão para uma função JavaScript

Question

Gostaria uma função JavaScript para ter argumentos opcionais que eu definir um padrão em que se acostumar, se o valor não está definido (e ignorado se o valor é passado). Em Ruby, você pode fazê-lo como este:

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

Será que este trabalho em JavaScript?

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

Answer 1

A partir ES6 / ES2015 , parâmetros padrão estão na especificação da linguagem.

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

simplesmente funciona.

Referência: padrão Parâmetros - MDN

parâmetros padrão de função permite que os parâmetros formais a serem inicializados com valores padrão se nenhum valor ou indefinido é passado.

Você também pode simular padrão nome parâmetros via desestruturação :

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

Pré ES2015 ,

Há uma série de maneiras, mas este é o meu método preferido - ele permite que você passar em qualquer coisa que você quiser, incluindo falsa ou nulo. (typeof null == "object")

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

Answer 2

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

Isso atribui a delete_after o valor de delete_after se não for um Falsey valor caso contrário, atribui o "my default here" string. Para mais detalhes, consulte a pesquisa da língua Doug Crockford e confira a seção sobre Operadores .

Esta abordagem não funciona se você quer passar em um Falsey valor ou seja false, null, undefined, 0 ou "". Se você precisar de Falsey valores a serem passados ??em que você precisa usar o método em Tom Ritter resposta .

Ao lidar com uma série de parâmetros para uma função, muitas vezes é útil para permitir que o consumidor passar os argumentos de parâmetro em um objeto e, em seguida, merge estes valores com um objeto que contém os valores padrão para a função

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

Para usar

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

Answer 3

eu encontrar algo simples como este para ser muito mais conciso e legível pessoalmente.

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

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

Answer 4

Em ECMAScript 6 você vai realmente ser capaz de escrever exatamente o que você tem:

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

Isto irá definir delete_after para false se não é presente ou undefined. Você pode usar ES6 apresenta como este hoje com transpilers como Babel .

Veja o artigo MDN para mais informações .

Answer 5

Padrão Valores de Parâmetros

Com ES6, você pode fazer, talvez, um dos mais expressões comuns em JavaScript diz respeito à fixação de um valor padrão para um parâmetro de função. A maneira que temos feito isso há anos deve 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 padrão é mais usado, mas é perigoso quando passar valores como

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

Por quê? Porque o 0 is falsy, e assim o x || 11 results in 11, não o diretamente aprovada em 0. Para corrigir esse gotcha, algumas pessoas vão em vez escrever a verificação mais verbosely assim:

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

podemos agora examinar uma ótima sintaxe útil adicionado como de ES6 para simplificar a atribuição de valores padrão para argumentos ausentes:

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 em uma declaração de função é mais como x !== undefined ? x : 11 do que o muito mais comum idioma x || 11

Valor padrão Expressões

valores padrão Function pode ser mais do que apenas valores simples, como 31; eles podem ser qualquer expressão válida, mesmo um 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 você pode ver, as expressões de valor padrão são preguiçosamente avaliados, o que significa que eles só são executados se e quando eles são necessários -. Isto é, quando o argumento de um parâmetro for omitido ou é indefinido

A expressão valor padrão pode até ser uma chamada de expressão função inline - comumente referido como um (IIFE) Função Expressão Imediatamente Chamado:

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

Answer 6

que a solução é trabalhar para mim em js:

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

Answer 7

Basta usar uma comparação explícita com indefinido.

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

Answer 8

Como uma atualização ... com ECMAScript 6 você pode FINALMENTE definir valores padrão em declarações de parâmetro função assim:

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

f(1) === 50

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

Answer 9

ser um desenvolvedor muito tempo C ++ (Rookie para o desenvolvimento web :)), quando eu cheguei em toda esta situação, eu fiz a atribuição de parâmetros na definição da função, como é mencionado na pergunta, como se segue.

function myfunc(a,b=10)

Mas cuidado que ele não funciona de forma consistente em todos os navegadores. Para mim, trabalhou em cromo no meu desktop, mas não funcionou no Chrome no Android. opção mais segura, como muitos já mencionado acima é -

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

Intenção para esta resposta é não repetir as mesmas soluções, o que outros já mencionados, mas para informar que a atribuição de parâmetro na definição da função pode funcionar em alguns navegadores, mas não confie nele.

Answer 10

Eu recomendo extrema cautela quando se utiliza valores de parâmetros padrão em javascript. É muitas vezes cria erros quando usado em conjunto com as funções de ordem superior como forEach, map e reduce. Por exemplo, considere esta linha de código:

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

parseInt tem um opcional function parseInt(s, [ segundo parâmetro raiz =10]) mas mapear chamadas parseInt com três argumentos: ( elemento , index e array ).

Eu sugiro que você separar seus parâmetros necessários formar seus padrão valorizado argumentos opcionais /. Se a sua função tem 1,2 ou 3 parâmetros necessários para que nenhum valor padrão faz sentido, torná-los parâmetros posicionais para a função, quaisquer parâmetros opcionais deve seguir como atributos nomeados de um único objeto. Se a sua função tem 4 ou mais, talvez faça mais sentido para fornecer todos os argumentos via atributos de um parâmetro único objeto.

No seu caso eu sugiro que você escrever sua função deleteFile assim: ( editada por instead do comentários ) ...

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

A execução do trecho acima ilustra os perigos à espreita atrás de valores de argumento padrão para os parâmetros não utilizados.

Answer 11

Para qualquer pessoa interessada em ter lá código de trabalho no Microsoft Edge, não use defaults nos parâmetros da função.

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

Nesse exemplo Borda irá lançar um erro "Esperando ')'"

Para contornar este uso

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

A partir de 2016 08 de agosto este ainda é um problema

Answer 12

De acordo com a sintaxe

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

Você pode definir o valor padrão de parâmetros formais. e também verificar valor indefinido usando typeof função .

Answer 13

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

Answer 14

Use esta opção se você quiser usar mais recente ECMA6 sintaxe:

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

É chamado default function parameters . Ele permite que os parâmetros formais a serem inicializados com valores padrão se nenhum valor ou indefinida é passado. NOTA : isso não vai funcionar com o Internet Explorer ou navegadores mais antigos.

Para obter o máximo possível compatibilidade usar este:

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 as funções têm exatamente o mesmo comportamento como cada um destes exemplo confiar no fato de que a variável de parâmetro será undefined se nenhum valor de parâmetro foi passado ao chamar essa função.

Answer 15

ES6:. Como já foi mencionado na maioria das respostas, em ES6, você pode simplesmente inicialize um parâmetro junto com um valor

---

ES5: A maioria das respostas dadas não são bons o suficiente para mim, porque há ocasiões em que eu possa ter de passar valores Falsey como 0, null e undefined para uma função. Para determinar se um parâmetro é indefinido porque esse é o valor que passei em vez de indefinida devido a não ter sido definido em tudo o que faço com isto:

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

Answer 16

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

Aqui foo () é uma função que tem um parâmetro chamado argValue. Se não passar nada na chamada de função aqui, então a função throwIfNoValue () será chamado e o resultado retornado será atribuído ao único argValue argumento. Isto é como uma chamada de função pode ser usado como um parâmetro padrão. O que torna o código mais simplificado e de fácil leitura.

Este exemplo foi retirado aqui

Answer 17

Se você estiver usando ES6+ você pode definir os parâmetros padrão da seguinte maneira:

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

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

Se você precisa ES5 sintaxe que você pode fazê-lo da seguinte maneira:

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

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

Na sintaxe acima é usado o operador OR. O operador OR sempre retorna o primeiro valor se este pode ser convertido para true se não retorna o valor righthandside. Quando a função é chamada sem argumento correspondente a variável parâmetro (bar no nosso exemplo) está definido para undefined pelo motor JS. undefined é então convertido em falso e, portanto, é que o operador OR retornar o valor 0.

Answer 18

Se por algum motivo você estiver não em ES6 e são usando lodash aqui é uma maneira concisa para os parâmetros de função padrão via _.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>

O que vai definir o padrão se o valor atual é NaN , nulo ou indefinido

Answer 19

Sim, usando parâmetros padrão é totalmente suportado no ES6 :

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

ou

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

mas antes em ES5 você pode facilmente fazer isso:

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

que significa que se o valor está lá, use o valor, caso contrário, use o segundo valor após a operação || que faz a mesma coisa ...

Nota: , também há uma grande diferença entre aqueles se você passar um valor para ES6 um mesmo valor ser Falsas, que será substituído por novo valor, algo como null ou "" ... mas ES5 só será substituído se apenas o valor passado é truthy, isso é porque o caminho || funcionando ...

Answer 20

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

Na sequência código pode trabalhar nesta situação, incluindo ECMAScript 6 (ES6), bem como versões 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 padrão em linguagens funciona quando o valor do parâmetro da função é ignorado quando chamado, em JavaScript que é atribuído a indefinido . Esta abordagem não olhar atraente programaticamente, mas têm compatibilidade com versões anteriores .

Answer 21

Sim este é referido como um parâmetro padrão

parâmetros padrão de função permite que os parâmetros formais a serem inicializados com valores padrão se nenhum valor ou indefinida é passado.

Sintaxe:

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

Descrição:

Parâmetros de funções padrão para indefinido No entanto, em situações pode ser útil para definir um valor padrão diferente. Este é o lugar onde os parâmetros padrão pode ajudar.

No passado, a estratégia geral para a definição de padrões de era para os valores dos parâmetros de teste no corpo da função e atribuir um valor se forem indefinido. Se nenhum valor é fornecido na chamada, seu valor seria indefinida. Você teria que definir uma verificação condicional para garantir que o parâmetro não é indefinido

Com os parâmetros padrão em ES2015, a verificação no corpo da função não é mais necessário. Agora você pode simplesmente colocar um valor padrão na cabeça função.

Exemplo das diferenças:

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

sintaxe diferente Exemplos:

Padding indefinido vs outros valores Falsas:

Mesmo que o valor é definido explicitamente ao chamar, o valor do argumento num é o padrão.

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)

avaliada em tempo de chamada:

O argumento padrão fica avaliada em tempo de chamada, de modo que diferentemente de outras linguagens, um novo objeto é criado cada vez que a função é chamada.

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

Os parâmetros predefinidos estão disponíveis para parâmetros padrão posteriores:

Params já encontradas estão disponíveis para parâmetros padrão 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.')

funções definidas dentro do corpo da função:

Introduzido em Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Funções declaradas no corpo da função não pode ser encaminhado dentro de parâmetros predefinidos e jogue um ReferenceError (atualmente um TypeError em SpiderMonkey, veja bug 1.022.967). Os parâmetros predefinidos são sempre executadas em primeiro lugar, declarações de função dentro do corpo da função avaliar depois.

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

Parâmetros sem defaults após parâmetros padrão:

Antes gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2,23 / SO Firefox 1.2), o código seguinte resultou em um SintaxError. Isso foi corrigido no bug 777060 e funciona como esperado em versões posteriores. Parâmetros ainda estão ajustados da esquerda para a direita, substituindo os parâmetros padrão, mesmo que haja parâmetros mais tarde sem padrões.

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

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

desestruturada PARAMET com atribuição de valor padrão:

Você pode usar atribuição de valor padrão com a atribuição desestruturação notação

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

f(); // 6

Answer 22

Apenas uma abordagem diferente para definir parâmetros padrão é usar mapa de objeto de argumentos, em vez de argumentos diretamente. Por exemplo,

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

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

Desta forma, é fácil estender os argumentos e não se preocupar com incompatibilidade de comprimento do argumento.

Answer 23

A resposta é sim. Na verdade, há muitas línguas que suportam parâmetros padrão. Python é um deles:

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

Mesmo que esta é Python 3 Código devido aos parênteses, os parâmetros padrão em funções também trabalham em JS.

Por exemplo, e no seu caso:

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

read_file("test.txt");

Mas às vezes você realmente não precisa de parâmetros padrão.

Você pode apenas definir o direito variável após o início da função, assim:

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

read_file("test.txt");

Em ambos os meus exemplos, ele retorna a mesma coisa. Mas às vezes eles realmente poderiam ser úteis, como em projectos muito avançadas.

Assim, em conclusão, os valores dos parâmetros predefinidos podem ser usados ??em JS. Mas é quase a mesma coisa que a definição de um direito variável após o início da função. No entanto, por vezes, eles ainda são muito úteis. Como você tem pode notado, valores de parâmetro padrão tome 1 menos linha de código do que a forma padrão que está definindo o parâmetro logo após o início se a função.

Answer 24

Sim, Isto irá funcionar em Javascript. Você também pode fazer isso:

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