function funções nativas - Definir um valor de parâmetro padrão para uma função JavaScript





10 Answers

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

Isto atribui a delete_after o valor de delete_after se não for um valor de falsey, caso contrário ele atribuirá a string "my default here" . Para mais detalhes, confira a pesquisa de Doug Crockford sobre o idioma e confira a seção sobre Operadores .

Essa abordagem não funciona se você quiser passar um valor false , ou seja, false , null , undefined , 0 ou "" . Se você exigir que os valores de falsey sejam passados, você precisará usar o método na resposta de Tom Ritter .

Ao lidar com um número de parâmetros para uma função, geralmente é útil permitir que o consumidor passe os argumentos do parâmetro em um objeto e, em seguida, mescle esses valores com um objeto que contenha 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;
};

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" }); 
html com parametro

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
}



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 .




essa solução é trabalho para mim em js:

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



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.




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 .




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



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.




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 .




Se por algum motivo você não estiver no ES6 e estiver usando o lodash aqui está uma maneira concisa para os parâmetros padrão da função através do método _.defaultTo :

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>

Qual definirá o padrão se o valor atual for NaN , null ou undefined




Related