Estilo JavaScript para callbacks opcionais


93

Tenho algumas funções que ocasionalmente (nem sempre) recebem um retorno de chamada e o executam. Verificar se o retorno de chamada está definido / função é um bom estilo ou existe uma maneira melhor?

Exemplo:

function save (callback){
   .....do stuff......
   if(typeof callback !== 'undefined'){
     callback();
   };
};

em navegadores modernos que você poderia usar apenas typeof callback !== undefinedassim deixar de fora o'
Snickbrack

1
e se você simplesmente ligar save()? Isso não gerará um erro ou aviso de linting porque um argumento está faltando? Ou está perfeitamente ok e o callback é simples undefined?
João Pimentel Ferreira

Respostas:


139

Eu pessoalmente prefiro

typeof callback === 'function' && callback();

O typeofcomando é duvidoso, no entanto, deve ser usado apenas para "undefined"e"function"

O problema do typeof !== undefinedé que o usuário pode passar um valor que está definido e não uma função


3
typeofnão é duvidoso. É vago às vezes, mas eu não diria que é duvidoso. Porém, concordou que, se você for chamar o retorno de chamada como uma função, é melhor verificar se é realmente uma função e não, você sabe, um número. :-)
TJ Crowder

1
@TJCrowder dodgy pode ser a palavra errada, é bem definida, mas inútil devido ao boxe e retornar "object"95% das vezes.
Raynos

1
typeofnão causa boxe. typeof "foo"é "string", não "object". Na verdade, é a única maneira real de saber se está lidando com um primitivo ou Stringobjeto string . (Talvez você esteja pensando em Object.prototype.toString, o que é muito útil , mas causa boxe.)
TJ Crowder

4
A &&propósito, uso maravilhosamente idiomático de .
TJ Crowder

@TJCrowder Você tem razão, não sei qual é o valor de comparar primitivos de string e objetos String em caixa. Também concordo que .toStringé adorável para encontrar o [[Class]].
Raynos

50

Você também pode fazer:

var noop = function(){}; // do nothing.

function save (callback){
   callback = callback || noop;
   .....do stuff......
};

É especialmente útil se você usar o callbackem alguns lugares.

Além disso, se você estiver usando jQuery, você já tem uma função como essa, é chamada $ .noop


4
Na minha opinião, esta é a solução mais elegante.
Nicolas Le Thierry d'Ennequin

2
Acordado. Isso também torna o teste mais fácil, porque não há condição if.

5
mas isso não resolve o problema do tipo, não é? e se eu passar um array? ou uma corda?
Zerho

1
Simplifique paracallback = callback || function(){};
NorCalKnockOut

1
Você também pode tornar um argumento opcional, dando a ele um valor padrão na declaração:function save (callback=noop) { ...
Keith

39

Simplesmente faça

if (callback) callback();

Eu prefiro chamar o retorno de chamada, se fornecido, não importa o tipo. Não deixe que ele falhe silenciosamente, para que o implementador saiba que transmitiu um argumento incorreto e possa corrigi-lo.


11

ECMAScript 6

// @param callback Default value is a noop fn.
function save(callback = ()=>{}) {
   // do stuff...
   callback();
}

3

Em vez de tornar o retorno de chamada opcional, basta atribuir um padrão e chamá-lo de qualquer maneira

const identity = x =>
  x

const save (..., callback = identity) {
  // ...
  return callback (...)
}

Quando usado

save (...)              // callback has no effect
save (..., console.log) // console.log is used as callback

Esse estilo é chamado de estilo de passagem de continuação . Aqui está um exemplo real combinations, que gera todas as combinações possíveis de uma entrada Array

const identity = x =>
  x

const None =
  Symbol ()

const combinations = ([ x = None, ...rest ], callback = identity) =>
  x === None
    ? callback ([[]])
    : combinations
        ( rest
        , combs =>
            callback (combs .concat (combs .map (c => [ x, ...c ])))
        )

console.log (combinations (['A', 'B', 'C']))
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]

Como combinationsé definido no estilo de passagem de continuação, a chamada acima é efetivamente a mesma

combinations (['A', 'B', 'C'], console.log)
// [ []
// , [ 'C' ]
// , [ 'B' ]
// , [ 'B', 'C' ]
// , [ 'A' ]
// , [ 'A', 'C' ]
// , [ 'A', 'B' ]
// , [ 'A', 'B', 'C' ]
// ]

Também podemos passar uma continuação personalizada que faz outra coisa com o resultado

console.log (combinations (['A', 'B', 'C'], combs => combs.length))
// 8
// (8 total combinations)

O estilo de aprovação de continuação pode ser usado com resultados surpreendentemente elegantes

const first = (x, y) =>
  x

const fibonacci = (n, callback = first) =>
  n === 0
    ? callback (0, 1)
    : fibonacci
        ( n - 1
        , (a, b) => callback (b, a + b)
        )
        
console.log (fibonacci (10)) // 55
// 55 is the 10th fibonacci number
// (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...)


1

Fiquei tão cansado de ver o mesmo trecho repetidamente que escrevi isto:

  var cb = function(g) {
    if (g) {
      var args = Array.prototype.slice.call(arguments); 
      args.shift(); 
      g.apply(null, args); 
    }
  };

Eu tenho centenas de funções fazendo coisas como

  cb(callback, { error : null }, [0, 3, 5], true);

como queiras...

Eu sou cético em relação a toda a estratégia "certifique-se de que funcione". Os únicos valores legítimos são uma função ou falsos. Se alguém passar um número diferente de zero ou uma string não vazia, o que você vai fazer? Como ignorar o problema o resolve?


A função pode ser sobrecarregada para aceitar algum valor como o primeiro argumento, a função como o primeiro argumento ou ambos os parâmetros. Existe um caso de uso para verificar se é uma função. Também é melhor ignorar o parâmetro errado do que lançar um erro ao executar uma função não
Raynos

@Raynos - Esse é um caso de uso muito específico. JavaScript, sendo de digitação fraca, não é bom em distinguir tipos, e geralmente é melhor passar parâmetros nomeados do que tentar distinguir os tipos e adivinhar o que o chamador deseja:save( { callback : confirmProfileSaved, priority: "low" })
Malvolio

Eu discordo, há capacidade de verificação de tipo suficiente. Eu prefiro a sobrecarga de método, mas isso é preferência pessoal. Esse é o tipo de coisa que o jQuery faz muito.
Raynos

@Raynos - É pior ignorar o parâmetro errado do que lançar um erro ao executar uma não função. Considere um caso típico: a função de biblioteca está executando alguma atividade assíncrona e a função de chamada precisa ser notificada. Portanto, um usuário não sofisticado, ignorar e falhar parece o mesmo: a atividade parece nunca ser concluída. No entanto, para um usuário sofisticado (por exemplo, o programador original), uma falha fornece uma mensagem de erro e um rastreamento de pilha que aponta diretamente para o problema; ignorar o parâmetro significa uma análise tediosa para determinar o que fez com que "nada" acontecesse.
Malvolio

há uma troca a ser feita. Lançar um erro irá travar o tempo de execução, mas ignorá-lo permitirá que outro código em torno dele seja executado normalmente.
Raynos

1

Uma função válida é baseada no protótipo de Função, use:

if (callback instanceof Function)

para ter certeza de que o retorno de chamada é uma função


0

Se o critério para executar o retorno de chamada for definido ou não, você está bem. Além disso, sugiro verificar se é realmente uma função adicional.


0

Eu mudei para o script de café e descobri que os argumentos padrão são uma boa maneira de resolver este problema

doSomething = (arg1, arg2, callback = ()->)->
    callback()

0

Isso pode ser feito facilmente com o ArgueJS :

function save (){
  arguments = __({callback: [Function]})
.....do stuff......
  if(arguments.callback){
    callback();
  };
};
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.