Qual è la convenzione JavaScript per nessuna operazione?

Qual è la convenzione JavaScript per nessuna operazione?

  • Un'opzione è semplicemente una function vuota: function() {}
  • jQuery offre $.noop() , che chiama semplicemente la function vuota sopra.
  • È accettabile inserire semplicemente un valore false o 0 ?

Nel context … tutti questi funzionano senza lanciare un errore in Chrome:

 var a = 2; (a === 1) ? alert(1) : function() {}; (a === 1) ? alert(1) : $.noop(); (a === 1) ? alert(1) : false; (a === 1) ? alert(1) : 0; 

EDIT: Molte persone hanno risposto con: "non farlo! Cambia la struttura del codice!" Questo mi ricorda un post in cui qualcuno ha chiesto come sniff il browser. Ha ricevuto una baraccia di messaggi che dicono: "NON FARE QUELLO, È MALATO", ma nessuno gli ha detto come annusare il browser . Questa non è una revisione del codice. Immaginate di avere a che fare con codice legacy che non può essere modificato e senza alcuna function passata, lancerà un errore. Oppure, immaginate semplicemente se questo è il modo in cui il cliente lo vuole . Quindi, rispettosamente, rispondi alla domanda : qual è il modo migliore per specificare una function "nessuna operazione" in JavaScript?

EDIT2: come su uno di questi?

 true; false; 

O minimamente:

 0; 1; 

In realtà non hai neanche bisogno del punto e virgola, quindi il minimo assoluto sarebbe:

 0 1 

Pensavo di me stesso come un ragazzo "one-liner"; ora, penso a me stesso come un "ragazzo di un carattere": D

Per rispondere alla domanda originale, il modo più elegante e ordinato definisce una function di noop nel puro Javascript (come si parla anche qui ) è usare Function.prototype e viene mostrato nello snippet di seguito:

 setTimeout(Function.prototype, 10000); 

Tutti e tre i browser (Chrome, Firefox e IE 11) non provocano l'interpnetworking di tornare dopo 10 secondi quando si esegue l'esecuzione di quanto sopra (è ansible verificare gradualmente con "step over" nel debugger).

Quindi, questo sembra essere un "noop vero" poiché la maggior parte dei browser sembra non fare nulla per eseguire il noop definito in questo modo (e quindi salvare i loops della CPU), anche se Node.js sembra essere un'exception.

Inoltre, sia jQuery che Angular JS definiscono una function globale noop come function vuota – function () {} come mostrato qui e qui . Queste o la function pura JS vuota possono essere utilizzate come segue:

 setTimeout(angular.noop, 10000); // Using angular setTimeout(jQuery.noop, 10000); // Using jQuery setTimeout(function () {} , 10000); // Using the pure JS empty function 

Tuttavia, utilizzando una delle due tecniche di cui sopra, la maggior parte degli interpreti effettua l'esecuzione del "noop" dopo 10 secondi.

Quindi, a mio parere, utilizzare Function.prototype per una function TRUE noop. In alternativa, utilizzare una delle tecniche di cui sopra o alcune delle altre opzioni discusse nella domanda originale.

qualunque cosa si tende a raggiungere qui è sbagliato. Le espressioni ternarie non devono essere utilizzate come una dichiarazione completa, solo in termini di espressione, quindi la risposta alla tua domanda è:

nessuno dei tuoi suggerimenti, invece:

 var a = 2; if (a === 1) alert(1) // else do nothing! 

allora il codice è facilmente comprensibile, leggibile e quanto più efficace ansible.

Perché rendere più difficile, quando può essere semplice?

edit:

Quindi, un command "no-operation" fondamentalmente indica una struttura di codice inferiore?

Lei manca il mio punto. Tutto quanto sopra si riferisce all'espressione ternaria x ? y : z x ? y : z .

Ma un command di funzionamento non ha senso nei linguaggi di livello superiore come Javascript.

Viene di solito utilizzato in linguaggi di livello inferiore come l'assemblaggio o C, in modo da rendere il processre non facendo nulla per un'istruzione per scopi di temporizzazione.

In JS, se si fa 0; , null; , function () {}; o una dichiarazione vuota, ci sono grandi possibilità che l'interpnetworking verrà ignorata quando la legge, ma prima che venga interpretata, in tal modo, alla fine, farà solo che il tuo programma venga caricato più lentamente da un importo davvero minuscolo di tempo. Nota Bene : Sto assumendo questo, poiché non sono coinvolto in alcun interpnetworking JS ampiamente utilizzato, e ci sono possibilità che each interpnetworking abbia una propria strategia.

Nel caso in cui si utilizza qualcosa di più complicato, come $.noop() o var foo = function () {}; foo() var foo = function () {}; foo() , allora l'interpnetworking può fare una chiamata di function inutilizzabile che finirà per rovinare alcuni byte della tua stack di funzioni e alcuni loops.

L'unica ragione per cui vedo una function come $.noop() esisterebbe, sarebbe quella di poter ancora dare una function di richiamata a una function di evento che avrebbe lanciato un'exception se non è ansible call tale callback. Ma allora è necessariamente una function che devi dare e dargli il nome noop è una buona idea, perciò stai dicendo ai tuoi lettori (e forse sei in sei mesi) che volete dare una function vuota.

Alla fine, non esiste una forma di codice "inferiore" o "superiore". Tu sei giusto o sbagliato nel modo in cui utilizza i tuoi strumenti. Utilizzando un ternario per il tuo esempio è come usare un martello quando vuoi annodare. Funzionerà, ma non sei sicuro di poter appendere qualcosa su quella vite.

Quello che potrebbe essere considerato "inferiore" o "superiore" è l'algorithm e le idee che hai inserito nel codice. Ma questa è un'altra cosa.

Non andrà molto più semplice di call () => {} .

Funziona nel tuo browser (se non, torna in un mese).

EDIT: () => {} può anche eseguire più velocemente di Function.prototype , a seconda dell'ambiente. Il test riportto di seguito mostra che il primo esegue costantemente circa il 20% più veloce in Chrome 55, anche quando il browser è autorizzato a riscaldarsi per quest'ultimo.

 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}`) } const iterations = 10000000 console.info(`==NOOP TEST @ ${iterations.toLocaleString()}==`) test(noop, iterations) test(noopProto, iterations) 

Penso che jQuery noop() sia destinato in gran parte a impedire che il codice si blocchi fornendo una function predefinita quando la richiesta non è disponibile. Ad esempio, considerando il seguente esempio di codice, $.noop viene scelto se fakeFunction non è definito, impedendo alla chiamata successiva a fn di arrestarsi:

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

Quindi, noop() consente di salvare la memory evitando di scrivere la stessa function vuota più volte ovunque nel codice. A proposito, $.noop è un po 'più corto della function(){} (6 byte salvato per token). Quindi, non esiste alcuna relazione tra il codice e il model di function vuota. Utilizza null , false o 0 se vuoi, nel tuo caso non avrà alcun effetto collaterale. Inoltre, vale la pena notare che questo codice …

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

… è completamente inutile dal momento che non chiamerai mai la function, e questa …

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

… è ancora più inutile in quanto chiamate una function vuota, che è esattamente la stessa …

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

Sostituiamo l'espressione ternaria con un'istruzione if per vedere quanto è inutile:

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

Potresti semplicemente scrivere:

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

O ancora più corto:

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

Per rispondere finalmente alla tua domanda, credo che una "convenzionale non operazione" è quella che non è mai scritta.

Io uso:

  (0); // nop 

Per verificare il tempo di esecuzione di questa esecuzione come:

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

risultato: contrassegno: 0.000ms

L'utilizzo di Boolean( 10 > 9) può essere ridotto semplicemente ( 10 > 9) che restituisce true . Cominciando con l'idea di utilizzare un singolo operando che mi aspettavo (0); restituirebbe false , ma semplicemente restituisce l'argomento come può essere riesaminato eseguendo questo test alla console.

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