Javascript logischer Operator || liest 0 als falschen Wert. Gibt es einen schönen Weg?

Question

Sorry, ich bin ein bisschen wie ein Anfänger, wenn es um Javascript geht. Aber hier ist mein Problem: Die folgende Funktion gibt -1, wenn 0 inputed wird

function foo(bar){ 
    return bar || -1; 
} 

foo(0); 

gibt es eine schöne und elegante Weise, die zu erlauben || Der Operator liest 0 (speziell 0, nicht alle falschen Werte) als gültigen Wert, so dass die Funktion 0 zurücksendet. Oder muss ich dies tun:

function foo(bar){ 
    if(bar === 0){ 
     return 0; 
    } else { 
     return bar || -1; 
    } 

} 

foo(0); 

Edit:

Vielen Dank an alle für eure Antworten! Für diejenigen, die sich wundern, wurde die Frage gestellt, um die Lösung für das gleiche Problem mit optionalen Parametern zu finden. Der folgende Code ist ein Beispiel dafür, wie er angewendet werden könnte.

function Point(x,y,meta){ //meta is an optional parameter. In this case I wanted to set meta to 0, but it was being set to null. 
    this.x = x; 
    this.y = y; 
    //this.meta = meta || null; This line is the old code that would set meta to null when 0 is inputed. 
    this.meta = meta === 0 ? 0 : (meta || null); //the fix suggested by many users is applied here. 
}; 

var foo = new Point(1,2,0); 
console.log(foo.meta); //foo.meta is now 0 instead of null! 

Answer 1

Die engster Sie erhalten können, ist Ihre zusammenzubrechen if-else in zu einem einzigen Rückkehr, a la:

return bar === 0 ? bar : (bar || -1); 

Da || vergleicht truthy/falsy-Werte, Sie müssen den Fall 0 explizit behandeln (mit starker Typisierung).

Es ist schwer zu sagen von Ihrer Frage, aber in der Regel, wenn ich die truthy/falsy Art von Vergleichen überschreibe, ist es einen Wert zu default. In diesem Fall muss festgestellt werden, ob meine Funktion einen undefinierten Wert erhalten hat, und stattdessen ein normaler Standard verwendet werden.

Answer 2

Sie könnten foo wie folgt neu schreiben den ternären Operator:

function foo(bar) { 
    return bar === 0 ? 0 : (bar || -1) 
} 

Die Syntax für den ternären Operator ist condition ? expr1 : expr2. Wenn condition truthy ist, gibt es expr1 zurück, andernfalls wird expr2 zurückgegeben.

Here's more information on the ternary operator

Answer 3

Das ist die Art und Weise JavaScript funktioniert. Alle Werte sind entweder truthy oder falsy. Null ist zufällig ein falscher Wert. Sie können Ihre Funktion jedoch mit einem Ternär vereinfachen.

function foo(bar) { 
    return bar === 0 ? 0 : (bar || -1); 
} 

Answer 4

function foo(bar){ 
    return typeof bar === "undefined" || bar === null ? -1 : bar; 
} 

foo(0); // should give 0 
foo(false); // should give false 
var a; // undefined variable 
foo(a); // should give -1 
foo(null); // should give -1 
var b = {}; // object 
foo(b.a); // should give -1 (undefined property) 

Nun, die Absicht dieser if ist für fehlende (nicht vorhanden) Wert zu überprüfen. In JavaScript fehlt der Wert, wenn er:

1. undefined
2. null

Der beste Weg, etwas für undefined zu überprüfen ist zu streng (===) zur Überprüfung seiner Typ für die Gleichstellung auf "undefined" string - so erhalten Sie keine Ausnahme, wenn bar nicht ausgewertet werden kann.

Aber, wenn Ihr Ausdruck nicht undefined ist, können Sie dann sicher seinen Wert mit Vergleich bar===null überprüfen.

So haben wir beide Fälle abgedeckt und wir erhalten keine Ausnahmen.

Answer 5

Der andere Ansatz besteht darin, die Anzahl der empfangenen Argumente zu betrachten und den Wert default auf diese Weise festzulegen.

function foo(bar){ 
    if (arguments.length === 0) { 
     return -1; 
    } 
    return bar; 
}