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




passar string como parametro javascript (14)

A partir do ES6 / ES2015, os parâmetros padrão estão na especificação do idioma.

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

apenas funciona.

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

Os parâmetros de função padrão permitem que parâmetros formais sejam inicializados com valores padrão se nenhum valor ou indefinido for passado.

Você também pode simular parâmetros nomeados padrão 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 ,

Existem muitas maneiras, mas esse é o meu método preferido - ele permite que você passe o que quiser, incluindo falso ou nulo. ( typeof null == "object" )

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

https://code.i-harness.com

Eu gostaria que uma função JavaScript tivesse argumentos opcionais nos quais eu defini um padrão, que será usado se o valor não estiver definido. Em Ruby você pode fazer assim:

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

Isso funciona em JavaScript?

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

Acho que algo simples como esse é 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');
} 

Como uma atualização ... com o ECMAScript 6, você pode FINALMENTE definir valores padrão em declarações de parâmetros de função da seguinte forma:

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

f(1) === 50

Conforme mencionado por - http://es6-features.org/#DefaultParameterValues


Conforme a sintaxe

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

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


No ECMAScript 6, você poderá escrever exatamente o que você tem:

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

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

Veja o artigo do MDN para mais informações .


Para qualquer pessoa interessada em ter o trabalho de código no Microsoft Edge, não use padrões em parâmetros de função.

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

Nesse exemplo, Edge 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 08 de agosto de 2016, isso ainda é um problema


Se você estiver usando o ES6+ poderá 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ê precisar da sintaxe ES5 poderá 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, o operador OR é usado. O operador OR sempre retorna o primeiro valor, se puder ser convertido para true se não retornar o valor righthandside. Quando a função é chamada sem argumento correspondente, a variável de parâmetro ( bar em nosso exemplo) é definida como undefined pelo mecanismo JS. undefined É então convertido para false e, portanto, o operador OR retorna o valor 0.


Sendo um desenvolvedor de C ++ muito antigo (Rookie to web development :)), quando me deparei com essa situação, fiz a atribuição de parâmetros na definição da função, como é mencionado na pergunta, como segue.

function myfunc(a,b=10)

Mas cuidado, pois não funciona de forma consistente em todos os navegadores. Para mim funcionou no Chrome no meu desktop, mas não funcionou no Chrome no Android. Opção mais segura, como muitos mencionaram acima é -

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

A intenção para essa resposta é não repetir as mesmas soluções, o que outras pessoas já mencionaram, mas informar que a atribuição de parâmetros na definição da função pode funcionar em alguns navegadores, mas não confie nela.


Sim, isso 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

Use isto se você quiser usar a sintaxe mais recente do ECMA6 :

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 de default function parameters . Permite que parâmetros formais sejam inicializados com valores padrão se nenhum valor ou indefinido for passado. NOTA : Ele não funciona com o Internet Explorer ou navegadores mais antigos.

Para máxima compatibilidade possível, use isto:

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 que cada um desses exemplos dependem do fato de que a variável de parâmetro será undefined se nenhum valor de parâmetro foi passado ao chamar essa função.


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

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

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

Valores de parâmetro padrão

Com o ES6, você pode fazer, talvez, uma das expressões mais comuns em JavaScript se relacionar com a definição de um valor padrão para um parâmetro de função. A maneira como fizemos isso por 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

Esse padrão é mais usado, mas é perigoso quando passamos valores como

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

Por quê? Porque o 0 is falsy , e então o x || 11 results in 11 x || 11 results in 11 , não o diretamente em 0. Para consertar essa pegadinha, algumas pessoas vão escrever o cheque de forma mais grosseira 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

Agora podemos examinar uma sintaxe útil útil adicionada a partir do ES6 para simplificar a atribuição de valores padrão a 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 parecido com x !== undefined ? x : 11 x !== undefined ? x : 11 que o idioma muito mais comum x || 11 x || 11

Expressões de valor padrão

Valores padrão de Function podem ser mais do que valores simples como 31; eles podem ser qualquer expressão válida, até mesmo uma 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 avaliadas preguiçosamente, o que significa que elas só serão executadas se e quando forem necessárias - ou seja, quando o argumento de um parâmetro for omitido ou for indefinido.

Uma expressão de valor padrão pode até ser uma chamada de expressão de função embutida - comumente referida como uma Expressão de Função Imediatamente Invocada (IIFE) :

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

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

O código a seguir pode funcionar nesta situação, incluindo o 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 ao chamar, em JavaScript ele é atribuído a undefined . Essa abordagem não parece atraente programaticamente, mas tem compatibilidade com versões anteriores .


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




default-parameters