Parâmetros Predefinidos

Os parâmetros predefinidos de uma função permitem que parâmetros regulares sejam inicializados com com valores iniciais caso undefined ou nenhum valor seja passado.

Sintaxe

function [nome]([param1[ = valorPredefinido1 ][, ..., paramN[ = valorPredefinidoN ]]]) {
   instruções
}

Descrição

Em JavaScript, os parâmetros de funções tem undefined como valor predefinido. Contudo, em alguns casos pode ser útil utilizar algum outro valor. É nesta situação em que os parâmetros predefinidos podem ser úteis.

No passado, a estratégia de definir valores padrão para parâmetros era testar os valores do parâmetros no corpo da função e atribuir um valor se este for undefined. No exemplo a seguir, se nenhum valor for fornecido para b na chamada, este valor será undefined, quando a*b for calculado resultaria em NaN. No entanto, isto é capturado na segunda linha definindo um valor padrão para b:

function multiply(a, b) {
  b = (typeof b !== 'undefined') ? b : 1;

  return a * b;
}

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

Com o parâmetros predefinidos a checagem no corpo da função nao é mais necessária. Agora você pode simplesmente colocar 1 como valor padrão para b na declaração da função:

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

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

Exemplos

Passando undefined vs. outros valores "falsy"

Na segunda chamada aqui, mesmo se o segundo argumento é definido explicitamente como undefined (com exceção de null) quando chamado, o valor para o argumento num será o padrão.

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

test();          // 'number' (num é definido para 1)
test(undefined); // 'number' (num é definido para 1 também)

// teste com outros values "falsy":
test('');        // 'string' (num é definido para '')
test(null);      // 'object' (num é definido para null)

Avaliado em tempo de chamada

Os parâmetros predefinidos são avaliados no momento da chamada da função, então diferente de ex.: Python, um novo objeto é criado cada vez que a funçao é chamada.

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

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

Este mesmo comportamento é aplicado para funções e variáveis:

function callSomething(thing = something()) { return thing }

function something(){
  return "sth";
}

callSomething();  //sth

Parâmetros predefinidos estão disponíveis para os parâmetros seguintes à sua definição

Parâmetros que já foram avaliados ficam disponíveis para uso para os parâmetros seguintes:

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

Esta funcionalidade torna-se uma maneira direta e demonstra quantos casos extremos são manipulados.

function go() {
  return ":P"
}

function withDefaults(a, b = 5, c = b, d = go(), e = this,
                      f = arguments, g = this.value) {
  return [a,b,c,d,e,f,g];
}
function withoutDefaults(a, b, c, d, e, f, g){
  switch(arguments.length){
    case 0:
      a
    case 1:
      b = 5
    case 2:
      c = b
    case 3:
      d = go();
    case 4:
      e = this
    case 5:
      f = arguments
    case 6:
      g = this.value;
    default:
  }
  return [a,b,c,d,e,f,g];
}

withDefaults.call({value:"=^_^="});
// [undefined, 5, 5, ":P", window, arguments, "=^_^="]


withoutDefaults.call({value:"=^_^="});
// [undefined, 5, 5, ":P", window, arguments, "=^_^="]

Funções definidadas dentro do corpo da função

Introduzido no Gecko 33 (Firefox 33 / Thunderbird 33 / SeaMonkey 2.30). Funções declaradas no corpo da função não podem ser referenciada dentro de parâmetos padrão e lançará um ReferenceError (atualmente um TypeError no SpiderMonkey, veja bug 1022967). Parâmetros padrão são sempre executados primeiro, declarações de funções dentro do corpo de outra função são avaliadas depois.

// Não funciona! Throws ReferenceError.
function f(a = go()) {
  function go(){return ":P"}
}

Parâmetros sem valor padrão depois de parâmetros com valores padrão

Antes do Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2), o seguinte código resultaria em um SyntaxError. Isto foi corrigido no bug 777060 e funciona como esperado em versões posteriores:

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

f(); // [1, undefined]

Parâmetro desestruturado com valores padrões

É possível definir valores padrões com a notação destructuring assignment:

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

f(); // 6

Especificações

Compatibilidade nos navegadores

BCD tables only load in the browser

Veja também