Para responder à pergunta original, a implementação mais elegante e limpa de uma função noop em Javascript puro (como também é discutido aqui) é a função .protótipo Isto é porque:

1. função.o protótipo é uma função:

typeof Function.prototype === "function" // returns true

1. pode ser invocado como uma função e essencialmente não faz nada como mostrado aqui:

setTimeout(function() {
      console.log('Start: ', Date.now());
      Function.prototype();
      console.log('End  : ', Date.now());
    }, 1000);

Embora isto seja um "verdadeiro noop" já que a maioria dos navegadores parecem não fazer nada para executar o noop definido desta forma (e, portanto, salvar ciclos de CPU), pode haver alguns problemas de desempenho associados a este (como também é mencionado por outras pessoas em comentários ou em outras respostas).

Entretanto, dito isto, você pode facilmente definir sua própria função noop e, na verdade, muitas bibliotecas e frameworks também fornecem funções noop. Abaixo estão alguns exemplos:

var noop = function () {};           // Define your own noop in ES3 or ES5
const noop = () => {};               // Define in ES6 as Lambda (arrow function)
setTimeout(noop, 10000);             // Using the predefined noop

setTimeout(function () {} , 10000);  // Using directly in ES3 or ES5
setTimeout(() => {} , 10000);        // Using directly in ES6 as Lambda (arrow function)

setTimeout(angular.noop, 10000);     // Using with AngularJS 1.x
setTimeout(jQuery.noop, 10000);      // Using with jQuery

Aqui está uma lista alfabética de várias implementações de funções noop (ou relacionadas discussões ou pesquisas no google):

AngularJS 1.x, Angular 2+ (não parece ter um nativo implementação - usar a sua própria, como mostrado acima), Ember, jQuery, Lodash, NodeJS, Ramda, Reagir (não parece ter um nativo de implementação - usar a sua própria, como mostrado acima), RxJS, Sublinhado

Conclusão : Embora a função.prototype é uma forma elegante de expressar um noop em Javascript, no entanto, pode haver alguns problemas de desempenho relacionados com o seu uso. Assim, você pode definir e usar o seu próprio (como mostrado acima) ou usar um definido pela biblioteca/framework que você pode estar usando em seu código.

O mais conciso e executante noop é uma função de seta vazia: ()=>{}.

Funções de seta funcionam nativamente em todos os navegadores, excepto IE (existe uma transformação de babel se for necessário):

()=>{} vs. Function.Prototype

• ()=>{} é87% mais rápido do que Function.prototype no cromo 67.
• ()=>{} é25% mais rápido do que Function.prototype no Firefox 60.
• ()=>{} é 85% mais rápido do que Function.prototype na borda (6/15/2018).
• ()=>{} é 65% menos Código do que Function.prototype.

O teste abaixo aquece usando a função seta para dar viés a Function.prototype, mas a função seta é o vencedor claro:

const noop = ()=>{};
const noopProto = Function.prototype;

function test (_noop, iterations) {
    const before = performance.now();
    for(let i = 0; i < iterations; i++) _noop();
    const after = performance.now();
    const elapsed = after - before;
    console.info(`${elapsed.toFixed(4)}MS\t${_noop.toString().replace('\n', '')}\tISNOOP? ${_noop() === undefined}`);
    return elapsed;
}

const iterations = 10000000
console.info(`noop time for ${iterations.toLocaleString()} iterations`)
const timings = {
    noop: test(noop, iterations),
    noopProto: test(noopProto, iterations)
}

const percentFaster = ((timings.noopProto - timings.noop)/timings.noopProto).toLocaleString("en-us", { style: "percent" });
console.info(`()=>{} is ${percentFaster} faster than Function.prototype in the current browser!`)

Eu acho que jQuery noop() é principalmente destinado a evitar que o código de colidir, fornecendo uma função padrão quando o pedido não está disponível. Por exemplo, considerando a seguinte amostra de código, $.noop é escolhido se fakeFunction não estiver definido, impedindo que a próxima chamada para fn caia:

var fn = fakeFunction || $.noop;
fn() // no crash

Então, noop() permite salvar a memória evitando escrever a mesma função vazia várias vezes em todo o lado no seu código. A propósito, $.noop é um pouco mais curto que function(){} (6 bytes salvos por ficha). Então, não há nenhuma relação entre o seu código e o padrão de função vazio. Utilização null, false ou 0 Se quiser, no seu caso não haverá efeitos secundários. Além disso, vale a pena notar que este código...

true/false ? alert('boo') : function(){};

... é completamente inútil, já que você nunca vai chamar a função, e este aqui...

true/false ? alert('boo') : $.noop();

... é ainda mais inútil uma vez que você chama uma função vazia, que é exatamente o mesmo que...

true/false ? alert('boo') : undefined;

if (true/false) {
    alert('boo');
} else {
    $.noop(); // returns undefined which goes nowhere
}

Podias simplesmente escrever:

if (true/false) alert('boo');

Ou ainda mais curto:

true/false && alert('boo');

Eu uso:

 (0); // nop

Para testar o tempo de execução desta execução como:

console.time("mark");
(0); // nop
console.timeEnd("mark");

Resultado: marca: 0, 1000 ms

A utilização de Boolean( 10 > 9) pode ser reduzida para ( 10 > 9) o que devolve true. Chegando com a idéia de usar um único operando que eu esperava completamente (0); retornaria false, mas simplesmente retorna o argumento de volta como pode ser revisto executando este teste na consola.

> var a = (0);
< undefined
> a
< 0

Não há absolutamente nenhum problema ou penalidade de desempenho de usar Function.prototype sobre () => {}.

O principal benefício de Function.prototype é ter uma função singleton em vez de redefinir uma nova função anónima de cada vez. É especialmente importante usar um no-op como Function.prototype ao definir valores padrão e memorizar como ele lhe dá um ponteiro de objeto consistente que nunca muda.

Function() === Function()
// false

Function.prototype() === Function.prototype()
// true

Além disso, Os valores de referência de outras respostas são enganadores . Na verdade, Function.prototype tem um desempenho mais rápido do que () => {} dependendo de como escrever e executar a referência:

Você não pode confiar em benchmarks JS Não use o seu código de benchmarks, faça o que for possível e deixe o intérprete descobrir como otimizar a longo prazo.