Is er een voordeel aan het gebruik van een retourverklaring die niets retourneert?

Ik ben een groot javascript-document aan het herstructureren dat ik heb opgehaald uit een open source-project. Een aantal functies gebruiken inconsistente retourinstructies. Hier is een eenvoudig voorbeeld van wat ik bedoel:

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

Soms retourneren de functies boolean, soms strings of andere dingen. Meestal worden ze inconsistent gecombineerd met een eenvoudige return;-instructie in een voorwaardelijke.

Het probleem is dat de code complex is. Het is een parser die een groot aantal unieke RegEx-overeenkomsten gebruikt, DOM-knooppunten on-the-fly maakt en vernietigt, enz. Voorlopige tests tonen aan dat ik in het bovenstaande voorbeeld de return;-instructie zou kunnen veranderen in return false;, maar ik ben bang dat ik me pas veel later realiseer dat het een negatieve invloed had (dwz dat een functie niet meer werkte) op het script.

Dus mijn vragen: Is er een voordeel aan het gebruik van een blanco aangifteformulier? Zou dit opzettelijk op deze manier zijn gecodeerd of was het gewoon lui? Kan ik ze allemaal veranderen in return false;, of return null;of moet ik elke oproep doorzoeken om erachter te komen wat ze doen met de resultaten van die functies ?

Antwoord 1, autoriteit 100%

Als u returngebruikt zonder een waarde, wordt de waarde undefinedgeretourneerd.

Als de waarde wordt geëvalueerd als een boolean, werkt undefinedals false, maar als de waarde bijvoorbeeld wordt vergeleken met false, je krijgt een ander gedrag:

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

Dus hoewel de code logischerwijs trueof falsemoet retourneren, niet trueof undefined, kun je verander niet gewoon return;in return false;zonder te controleren hoe de return-waarde wordt gebruikt.

Antwoord 2, autoriteit 33%

“Blanco return”-statements kunnen worden gebruikt om het besturingselement terug te brengen naar de aanroepende functie (of om de uitvoering van een functie om de een of andere reden te stoppen – bijvoorbeeld: validaties, enz.). In de meeste gevallen gebruik ik een lege retourverklaring wanneer ik een soort validatie doe. Ik maak er echter een punt van om een ​​indicator in te stellen waarom de uitvoering van de functie is gestopt. Stel bijvoorbeeld de eigenschap “innerText” in op een DIV-element met de foutmelding.

In de bovenstaande code lijkt het alsof het een validatie is. De functie retourneert een “true” als alles goed is gegaan. Het lijkt erop dat de aanroepende functie de retourwaarde ontleedt, en als deze “waar” is, wordt de volgende stap van de instructies (in de aanroepende functie) uitgevoerd.

Het is een goede gewoonte om “false” te retourneren in plaats van een lege return in het bovenstaande voorbeeld. Op die manier maak je het allemaal uniform en maak je het leven van andere programmeurs gemakkelijk.

Je zou dergelijke inconsistenties kunnen oplossen; zorg er echter voor dat u alle wijzigingen grondig test. Het is een goede gewoonte om elke wijziging die u aanbrengt in de code te testen, hoe klein deze ook is.

Antwoord 3, autoriteit 12%

Wat hier KAN verloren gaan (niet direct met uw voorbeeld) is dat u dan een object met drie toestanden kunt hebben:

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); 

deze keren terug:

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

opmerking: null retourneert false in dit voorbeeld myfunc(null);