:::: MENU ::::

ECMAScript 6: default values of parameters

Antes do ECMAScrit6 não havia uma maneira nativa de definir valores padrão para parâmetros, ou seja, precisávamos implementar nossa própria lógica. Uma solução muito utilizada era nomear os parâmetros e testá-los dentro da função para verificar se possuíam algum valor e caso não possuíssem um valor default seria atribuído. Como por exemplo:

function criarEstoque(produto, quantidade, callback) {
  quantidade = quantidade || 1;
  callback = callback || function() {};
  //lógica da função
}

Nesse exemplo “quantidade” e “callback” são opcionais, usando o operador “||” testamos se a variável possui valor, se possuir sera true e usara o valor do argumento, caso não, um valor default sera atribuído para ela. O problema é que se a “quantidade” for o operador entendera que é false e o nosso teste vai atribuir o valor default para a variável “quantidade”.

Uma forma de contornar isso é testar se o argumento não é do tipo undefined. Vamos refatorar nosso teste:

function criarEstoque(produto, quantidade, callback) {
  quantidade = (typeof quantidade !== 'undefined') ? quantidade : 1;
  callback = (typeof callback !== "undefined") ? callback : function() {};
  //lógica da função
}

Essa solução é segura mas ainda precisamos escrever muito código para fazer uma coisa relativamente simples. Pensando nisso o ES6 adicionou o default values of parameters que além de funcionar como em diversas outras linguagens ainda adicionou mais algumas particularidades que irão nos ajudar no dia a dia.

Valores padrão em parâmetros

Vamos refatorar nosso exemplo seguindo os padrões do es6:

function criarEstoque(produto, quantidade = 1, callback = function(){}) {
  //faz a lógica da função
}

//vai usar o callback default
criarEstoque("Produto x", 5);

//vai usar a quantidade e estoque default
criarEstoque("Produto y");

//não vai usar os valores default
criarEstoque("Produto z", 5, function(data));

//vai usar a quantidade default
criarEstoque("Produto w", undefined, function(data));

Como só o argumento “produto” é obrigatório, os outros argumentos podem variar e usar o valor default quando necessário. Outro ponto interessante é que podemos passar um valor undefined para que seja usado o valor default e passar um valor para o próximo argumento como no ultimo exemplo.

Usando argumentos em outros argumentos

Também é possível usar outros argumentos  como valor default:

function testArgs(primeiro, segundo = primeiro) {
  //segundo sera 1
  console.log(segundo);
}

No exemplo anterior o argumento “primeiro” está sendo atribuído ao argumento “segundo” . Um argumento pode acessar um argumento anterior sem problemas, mas não pode usar um argumento seguinte como no exemplo:

//Vai dar erro dizendo que terceiro não está definido
function testArgs(primeiro, segundo = terceiro, terceiro) {
}

Isso acontece porque o argumento “terceiro” ainda não foi inicializado, logo o argumento “segundo” não poderá fazer referência a ele.

Usando funções como valor padrão

Alem de atribuir argumentos para outros argumentos também podemos chamar funções que irão realizar a lógica no momento da construção da função:

function soma(numero) {
  return numero+1;
}

function testArgs(primeiro, segundo = soma(primeiro)) {
  //segundo sera 2
  console.log(segundo);
}

Aqui estamos chamando uma função nos argumentos da função testArgs, isso significa que a função “soma” vai ser executada e vai receber o argumento “primeiro” que a função recebe e o argumento “segundo”  vai ser a soma do argumento “primeiro” + 1.

 

Bom, espero que esse post tenha ajudado no entendimento dessa novidade do ES6 que vem para facilitar nossas vidas. Até a próxima galera!