Was ist die JavaScript-Konvention für keine Operation? Wie ein Python- passBefehl.

• Eine Option ist einfach eine leere Funktion: function() {}
• jQuery bietet an $.noop(), die einfach die obige leere Funktion aufruft.
• Ist es akzeptabel, einfach einen Wert von falseoder einzugeben 0?

Im Kontext ... all dies funktioniert ohne einen Fehler in Chrome auszulösen:

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

EDIT: Viele Leute antworteten mit: "Tu das nicht! Ändere die Codestruktur!" Dies erinnert mich an einen Beitrag, in dem jemand gefragt hat, wie man den Browser schnüffelt. Er erhielt eine Flut von Posts mit der Aufschrift "TUN SIE DAS NICHT! ES IST BÖSE", aber niemand sagte ihm, wie man am Browser schnüffelt . Dies ist keine Codeüberprüfung. Stellen Sie sich vor, Sie haben es mit Legacy-Code zu tun, der nicht geändert werden kann, und ohne eine übergebene Funktion wird ein Fehler ausgegeben. Oder einfach, so will es der Kunde und er bezahlt mich . Beantworten Sie daher respektvoll die Frage : Wie kann eine Funktion "keine Operation" in JavaScript am besten angegeben werden?

EDIT2: Wie wäre es mit einem davon?

true;
false;
0;
1;
null;

Um die ursprüngliche Frage zu beantworten, ist Function.prototype die eleganteste und sauberste Implementierung einer Noop-Funktion in reinem Javascript (wie auch hier erläutert ) . Das ist weil:

1. Function.prototype ist eine Funktion:

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

2. Es kann als Funktion aufgerufen werden und führt im Wesentlichen nichts aus, wie hier gezeigt:

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

Obwohl dies ein "echtes Noop" ist, da die meisten Browser anscheinend nichts tun, um das auf diese Weise definierte Noop auszuführen (und damit CPU-Zyklen zu sparen), kann dies zu Leistungsproblemen führen (wie auch von anderen in Kommentaren oder in erwähnt) Andere Antwort).

Allerdings können Sie leicht Ihre eigene Noop-Funktion definieren, und tatsächlich bieten viele Bibliotheken und Frameworks auch Noop-Funktionen. Nachfolgend einige Beispiele:

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

Hier ist eine alphabetische Liste verschiedener Implementierungen von Noop-Funktionen (oder verwandten Diskussionen oder Google-Suchen):

AngularJS 1.x , Angular 2+ (scheint keine native Implementierung zu haben - verwenden Sie Ihre eigene wie oben gezeigt), Ember , jQuery , Lodash , NodeJS , Ramda , React (scheint keine native Implementierung zu haben - verwenden Sie Ihre eigene wie oben gezeigt), RxJS , Unterstrich

BOTTOM LINE : Obwohl Function.prototype eine elegante Möglichkeit ist, ein Noop in Javascript auszudrücken, kann es im Zusammenhang mit seiner Verwendung zu Leistungsproblemen kommen. Sie können also Ihre eigenen definieren und verwenden (wie oben gezeigt) oder eine verwenden, die von der Bibliothek / dem Framework definiert wird, die Sie möglicherweise in Ihrem Code verwenden.

Das prägnanteste und performanteste Noop ist eine leere Pfeilfunktion : ()=>{}.

Pfeilfunktionen funktionieren nativ in allen Browsern außer IE (es gibt eine Babel-Transformation, wenn Sie müssen):

()=>{} vs. Function.Prototype

• ()=>{}ist 87% schneller als Function.prototypein Chrome 67.
• ()=>{} ist 25% schneller als Function.prototypein Firefox 60.
• ()=>{}ist 85% schneller als Function.prototypein Edge (15.06.2008) .
• ()=>{} ist 65% weniger Code als Function.prototype.

Der folgende Test wird mithilfe der Pfeilfunktion aufgeheizt, um eine Verzerrung zu Function.prototypeerzielen. Die Pfeilfunktion ist jedoch der klare Gewinner:

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

Was immer Sie hier erreichen wollen, ist falsch. Ternäre Ausdrücke sollen nicht als vollständige Aussage verwendet nur als Ausdruck. Die Antwort auf Ihre Frage lautet daher:

Keiner Ihrer Vorschläge, stattdessen:

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

dann ist der Code leicht verständlich, lesbar und so effizient wie möglich.

Warum es schwieriger machen, wenn es einfach sein kann?

bearbeiten:

Zeigt ein Befehl "keine Operation" im Grunde genommen eine minderwertige Codestruktur an?

Du vermisst meinen Standpunkt. Bei alledem geht es um den ternären Ausdruck x ? y : z.

In höheren Sprachen wie Javascript ist ein Befehl no operation jedoch nicht sinnvoll.

Es wird normalerweise in untergeordneten Sprachen wie Assembly oder C verwendet, um den Prozessor zu veranlassen, für Timing-Zwecke nichts für einen Befehl zu tun.

In JS, ob Sie tun 0;, null;, function () {};oder eine leere Aussage, gibt es große Chancen , dass es durch die interpretor ignoriert wird, wenn er sie liest, aber bevor es, so dass am Ende interpretiert wird, müssen Sie nur Ihr Programm machen sein langsamer geladen durch eine wirklich winzige Zeitspanne. Nota Bene : Ich gehe davon aus, da ich an keinem weit verbreiteten JS-Interpreter beteiligt bin und es Chancen gibt, dass jeder Interpreter seine eigene Strategie hat.

Wenn Sie etwas Komplizierteres wie $.noop()oder verwenden var foo = function () {}; foo(), führt der Interpreter möglicherweise einen nicht nützlichen Funktionsaufruf aus, der einige Bytes Ihres Funktionsstapels und einige Zyklen beeinträchtigt.

Der einzige Grund, warum ich eine Funktion sehe, wie $.noop()sie existieren würde, wäre, einer Ereignisfunktion, die eine Ausnahme auslösen würde, wenn sie diesen Rückruf nicht aufrufen kann, weiterhin eine Rückruffunktion geben zu können. Aber dann ist es notwendigerweise eine Funktion, die Sie geben müssen, und geben Sie ihr dienoop ist eine gute Idee Namen damit Sie Ihren Lesern (und das können Sie in 6 Monaten sein) sagen, dass Sie absichtlich eine leere Funktion geben.

Am Ende gibt es keine "minderwertige" oder "überlegene" Codestruktur. Sie haben entweder Recht oder Unrecht in der Art und Weise, wie Sie Ihre Werkzeuge verwenden. Die Verwendung eines Ternärs für Ihr Beispiel ist wie die Verwendung eines Hammers, wenn Sie schrauben möchten. Es wird funktionieren, aber Sie sind sich nicht sicher, ob Sie etwas an diese Schraube hängen können.

Was als "minderwertig" oder "überlegen" angesehen werden kann, ist der Algorithmus und die Ideen, die Sie in Ihren Code einfügen. Aber das ist eine andere Sache.

Ich denke, jQuery noop()soll hauptsächlich verhindern, dass Code abstürzt, indem eine Standardfunktion bereitgestellt wird, wenn die angeforderte nicht verfügbar ist. Unter Berücksichtigung des folgenden Codebeispiels $.noopwird beispielsweise ausgewählt, wenn fakeFunctiones nicht definiert ist, um zu verhindern, dass der nächste Aufruf fnvon abstürzt:

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

Dann noop()können Speicher sparen , indem die Vermeidung der gleichen leeren Funktion mehrere Male überall in Ihrem Code zu schreiben. Ist übrigens $.noopetwas kürzer als function(){}(6 Bytes pro Token gespeichert). Es gibt also keine Beziehung zwischen Ihrem Code und dem leeren Funktionsmuster. Verwenden Sie null, falseoder 0wenn Sie in Ihrem Fall mögen, wird es keine Nebenwirkung sein. Darüber hinaus ist es erwähnenswert, dass dieser Code ...

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

... ist völlig nutzlos, da Sie die Funktion niemals aufrufen werden, und diese ...

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

... ist noch nutzloser, da Sie eine leere Funktion aufrufen, die genau das gleiche ist wie ...

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

Ersetzen wir den ternären Ausdruck durch eine ifAussage, um zu sehen, wie nutzlos er ist:

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

Sie könnten einfach schreiben:

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

Oder noch kürzer:

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

Um Ihre Frage endgültig zu beantworten, denke ich, dass eine "konventionelle No-Operation" diejenige ist, die niemals geschrieben wird.

Ich benutze:

 (0); // nop

So testen Sie die Ausführungszeit dieses Laufs wie folgt:

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

Ergebnis: Marke: 0,000ms

Die Verwendung Boolean( 10 > 9)kann auf einfach reduziert werden, ( 10 > 9)was zurückgibt true. Die Idee, einen einzelnen Operanden zu verwenden, den ich voll und ganz erwartet hatte, (0);würde zurückkehren false, aber das Argument wird einfach zurückgegeben, wie durch Ausführen dieses Tests an der Konsole überprüft werden kann.

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

Es gibt absolut kein Problem oder Leistungseinbußen bei der Verwendung von Function.prototypeOver () => {}.

Der Hauptvorteil Function.prototypebesteht darin, eine Singleton-Funktion zu haben, anstatt jedes Mal eine neue anonyme Funktion neu zu definieren. Es ist besonders wichtig, ein No-Op wie Function.prototypebeim Definieren von Standardwerten und beim Speichern zu verwenden, da Sie einen konsistenten Objektzeiger erhalten, der sich nie ändert.

Den Grund empfehle ich Function.prototype eher als, Functionist, dass sie nicht gleich sind:

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

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

Ebenfalls, Benchmarks aus anderen Antworten sind irreführend . Tatsächlich ist Function.prototypedie Leistung schneller als () => {}je nachdem, wie Sie den Benchmark schreiben und ausführen:

Sie können JS-Benchmarks nicht vertrauen. << Speziell Benchmarks für diese Frage aufrufen.

Gestalten Sie Ihren Code nicht anhand von Benchmarks. Tun Sie alles, was wartbar ist, und lassen Sie den Dolmetscher herausfinden, wie er langfristig optimieren kann.