MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

Parâmetros Predefinidos

Esta tradução está incompleta. Por favor, ajude a traduzir este artigo.

This is a new technology, part of the ECMAScript 2015 (ES6) standard.
This technology's specification has been finalized, but check the compatibility table for usage and implementation status in various browsers.

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.

Síntaxe

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

Descrição

Em JavaScript, os parâmetros de functions 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 segundo linha definindo um valor padrão para b:

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

  return a*b;
}

multiply(5); // 5

Com o parâmetro padrão, a checagem do 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); // 5

Exemplos

Passando undefined

Na segunda chamada aqui, mesmo se o segundo argumento é definido explicitamente para undefined quando chamado, o valor para o agumento color será o padrão.

function setBackgroundColor(element, color = 'rosybrown') {
  element.style.backgroundColor = color;
}

setBackgroundColor(someDiv);            // color set to 'rosybrown'
setBackgroundColor(someDiv, undefined); // color set to 'rosybrown' too
setBackgroundColor(someDiv, 'blue');    // color set to 'blue' 

Avaliado em tempo de chamada

O argumento padrão é avaliado no momento da chamada, 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 padrão estão disponíveis depois

Parâmetros que já foram encontrados ficam disponíveis depois de parâmetros padrão:

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 dendo do corpo da função

Inserido 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 throw uma ReferenceError (currently a TypeError in SpiderMonkey, see 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 codigo resultaria em uma 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

Especificação Status Comentário
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'Function Definitions' in that specification.
Standard Definição Inicial.

Compatibilidade

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support Não suportado 15.0 (15.0) Não suportado Não suportado Não suportado
Parameters without defaults after default parameters ? 26.0 (26.0) ? ? ?
Destructured parameter with default value assignment ? 41.0 (41.0) ? ? ?
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Yes) (Yes) 15.0 (15.0) Não suportado Não suportado Não suportado
Parameters without defaults after default parameters ? ? 26.0 (26.0) ? ? ?
Destructured parameter with default value assignment ? ? 41.0 (41.0) ? ? ?

See also

Etiquetas do documento e colaboradores

 Colaboradores desta página: KennyMack, AlanCezarAraujo
 Última atualização por: KennyMack,