Gibt es einen Vorteil bei der Verwendung einer return-Anweisung, die nichts zurückgibt?

Ich überarbeite ein großes Javascript-Dokument, das ich aus einem Open-Source-Projekt übernommen habe. Eine Reihe von Funktionen verwenden inkonsistente Rückgabeanweisungen. Hier ist ein einfaches Beispiel dafür, was ich meine:

var func = function(param) {
    if (!param) {
        return;
    }
    // do stuff
    return true;
}

Manchmal geben die Funktionen boolesche Werte zurück, manchmal Strings oder andere Dinge. Normalerweise werden sie uneinheitlich mit einem einfachen gepaart return; Anweisung innerhalb einer Bedingung.

Das Problem ist, dass der Code komplex ist. Es ist ein Parser, der eine Vielzahl eindeutiger RegEx-Übereinstimmungen verwendet, DOM-Knoten im laufenden Betrieb erstellt und zerstört usw. Vorläufige Tests zeigen, dass ich im obigen Beispiel die ändern könnte return; Aussage zu werden return false;aber ich mache mir Sorgen, dass ich vielleicht erst viel später merke, dass es negative Auswirkungen auf das Skript hatte (dh einige Funktionen funktionierten nicht mehr).

Also meine Fragen: Gibt es einen Vorteil, eine leere Rücksendeerklärung zu verwenden? Könnte das absichtlich so codiert worden sein oder war es nur faul? Kann ich sie alle zu ändern return false;oder return null; oder muss ich jeden Aufruf durchsuchen und herausfinden, was sie mit den Ergebnissen dieser Funktionen machen?

Verwenden return ohne Wert wird der Wert zurückgegeben undefined.

Wenn der Wert als boolescher Wert ausgewertet wird, undefined wird funktionieren als falseaber wenn der Wert zum Beispiel mit verglichen wird falseerhalten Sie ein anderes Verhalten:

var x; // x is undefined
alert(x); // shows "undefined"
alert(!x); // shows "true"
alert(x==false); // shows "false"

Während der Code also logisch zurückkehren sollte true oder falsenicht true oder undefineddu kannst dich nicht einfach ändern return; zu return false; ohne zu prüfen, wie der Rückgabewert verwendet wird.

“Blank return”-Anweisungen können verwendet werden, um die Steuerung zurück an die aufrufende Funktion zu übertragen (oder die Ausführung einer Funktion aus irgendeinem Grund zu stoppen – z. B. Validierungen usw.). In den meisten Fällen verwende ich eine leere Return-Anweisung, wenn ich eine Art Validierung durchführe. Ich lege jedoch Wert darauf, einen Indikator dafür zu setzen, warum die Ausführung der Funktion gestoppt wird. Setzen Sie beispielsweise die Eigenschaft „innerText“ auf ein DIV-Element mit der Fehlermeldung.

Im obigen Code sieht es so aus, als wäre es eine Validierung. Die Funktion gibt ein “true” zurück, wenn alles geklappt hat. Es sieht so aus, als würde die aufrufende Funktion den Rückgabewert analysieren, und wenn er “true” ist, wird der nächste Schritt der Anweisungen (in der aufrufenden Funktion) ausgeführt.

Es empfiehlt sich, im obigen Beispiel “false” anstelle eines Leerzeichens zurückzugeben. So machen Sie alles einheitlich und machen anderen Programmierern das Leben leicht.

Sie könnten solche Inkonsistenzen beheben; Stellen Sie jedoch sicher, dass Sie alle Änderungen gründlich testen. Es empfiehlt sich, jede Änderung, die Sie am Code vornehmen, zu testen, egal wie klein sie auch sein mag.

Es gibt überhaupt keinen Unterschied zwischen return; und return undefined;. Das Ergebnis des Aufrufs beider Funktionen besteht darin, den Wert zu erhalten undefined.

(Da ist ein sehr klein Unterschied auf Spezifikationsebene zwischen einem Funktionsrumpf, der mit endet return vs. nur am Ende des Codes, aber es ist nichts, was im Code erkannt werden kann.¹ Der Aufruf einer Funktion, bei der die Ausführung am Ende des Codes liegt, führt ebenfalls zu dem Wert undefined.)

"use strict";

// Implicit return of `undefined`
function x() {
    return;
}
// Explicit return of `undefined`
function y() {
    return undefined;
}
// Execution falls off the end
function z() {
}
console.log(typeof x() === "undefined"); // true
console.log(typeof y() === "undefined"); // true
console.log(typeof z() === "undefined"); // true

Wenn nichtnatürlich hat etwas beschattet undefined. Was leider immer noch möglich ist (wenn auch nicht gerne auf globaler Ebene). Darin sehr kantiger Randfall, es gibt einen Unterschied:

"use strict";
(function() {
    const undefined = 42;
//  ^^^^^^^^^^^^^^^---- shadowing `undefined`
    // Implicit return of `undefined`
    function x() {
        return;
    }
    // Explicit return of `undefined`
    function y() {
        return undefined;
    }
    // Execution falls off the end
    function z() {
    }
    console.log(typeof x() === "undefined"); // true, `x` returns the canonical `undefined`
    console.log(typeof y() === "undefined"); // false, `y` returns 42
    console.log(typeof z() === "undefined"); // true, `z` (effectively) returns the canonical `undefined`
})();

¹ Verwenden return ist ein abrupter Abschluss das [[Call]]wird in eine normale Vervollständigung mit Wert umgewandelt. Das Herunterfallen des Endes des Codes ist a normaler Abschluss (spez) (das [[Call]]sorgt für Nachschub undefined für den Wert). Aber auch hier handelt es sich um einen Unterschied auf Spezifikationsebene, nicht um etwas, das im Code beobachtbar ist.

Was hier verloren gehen KÖNNTE (nicht direkt mit Ihrem Beispiel), ist, dass Sie dann ein Tri-State-Objekt haben können:

var myfunc = function(testparam) {
    if (typeof testparam === 'undefined') return;
    if (testparam) {
        return true;
    }
    else {
        return false;
    }
};

var thefirst = myfunc(true)
var thesecond = myfunc(false);
var thelast = myfunc();
alert("type:" + typeof thefirst+" value:"+thefirst);
alert("type:" + typeof thesecond+" value:"+thesecond);  
alert("type:" + typeof thelast+" value:"+thelast); 

diese kehren zurück:

> type:boolean:true 
> type:boolean:false
> type:undefined:undefined

Hinweis: null würde in diesem Beispiel false zurückgeben myfunc(null);

Das Ändern Ihrer Funktionen ändert tatsächlich den Code, weil return; und return false; verschiedene Datentypen ausgeben.

var test = function (x) {
    if (!x) {
        return;
    }
    else {
        return false;
    }
};

var a = test(true), b = test(false);

console.log(typeof b); // undefined
console.log(typeof a); // boolean