Start · Sprachen · JavaScript · Referenz · Unäres Minus (-)

Unäres Minus (-)

Operator

Der unäre Minus-Operator <code>-</code> wandelt seinen Operanden in einen numerischen Wert (Number oder BigInt) um und kehrt dessen Vorzeichen um.

seit JavaScript ES1 (BigInt-Unterstützung seit ES2020) – Baseline: Kategorie: syntax

Signatur

-operand

Beschreibung

Der unäre Minus-Operator steht vor genau einem Operanden und liefert dessen negierten Wert. Intern wird der Operand zuerst mit der abstrakten Operation ToNumeric umgewandelt: Zahlen bleiben Zahlen, BigInts bleiben BigInts, alle anderen Werte werden wie bei Number() in eine Zahl umgewandelt. Danach wird das Vorzeichen umgekehrt.

Deshalb eignet sich - nicht nur zum Negieren, sondern wandelt nebenbei auch um: -"42" ergibt -42, -true ergibt -1 und -"abc" ergibt NaN. Objekte werden über valueOf() bzw. toString() (genauer: Symbol.toPrimitive) in einen primitiven Wert umgewandelt.

Anders als das unäre Plus funktioniert das unäre Minus auch mit BigInt: -10n ist gültig und ergibt einen negativen BigInt. Typische Einsatzfälle sind Vorzeichenwechsel in Berechnungen, das Umkehren von Sortierreihenfolgen und das Invertieren von Richtungen oder Offsets (z. B. bei Animationen oder Koordinaten).

Zu beachten: Das Negieren von 0 ergibt -0, das sich mit === nicht von 0 unterscheiden lässt, wohl aber mit Object.is() oder bei Division (1 / -0 === -Infinity).

Parameter

Name Typ Default Beschreibung
$operand Pflicht any Beliebiger Ausdruck. Wird per ToNumeric in eine Number oder einen BigInt umgewandelt und anschließend negiert. Ein Symbol führt zu einem TypeError.

Rückgabewert

Typ
number | bigint
Beschreibung
Der negierte numerische Wert. Ein BigInt als Operand ergibt einen BigInt; alle anderen Werte ergeben eine Number (ggf. NaN oder -0).

Beispiele

Grundlagen und Typumwandlung

const x = 5;
console.log(-x);          // Vorzeichen umkehren
console.log(-(-x));       // doppelt negiert
console.log(-"42");       // String → Number
console.log(-true);       // Boolean → Number
console.log(-null);       // null → 0 → -0
console.log(-undefined);  // undefined → NaN
console.log(-"abc");      // nicht numerisch
console.log(-[]);         // [] → "" → 0 → -0
console.log(-25n);        // BigInt bleibt BigInt
-5 5 -42 -1 -0 NaN NaN -0 -25n

Absteigend sortieren durch Negieren des Vergleichs

const produkte = [
  { name: "Tastatur", preis: 49 },
  { name: "Monitor", preis: 199 },
  { name: "Maus", preis: 25 }
];

const aufsteigend = (a, b) => a.preis - b.preis;
const absteigend = (a, b) => -aufsteigend(a, b);

const sortiert = [...produkte].sort(absteigend);
console.log(sortiert.map(p => p.name));
[ 'Monitor', 'Tastatur', 'Maus' ]

-0 erkennen

const istNegativeNull = (n) => Object.is(n, -0);

const geschwindigkeit = -0 * 3;
console.log(geschwindigkeit === 0);          // === unterscheidet nicht
console.log(istNegativeNull(geschwindigkeit));
console.log(1 / geschwindigkeit);
true true -Infinity

Objekte mit eigener Umwandlung negieren

class Betrag {
  constructor(cent) { this.cent = cent; }
  [Symbol.toPrimitive](hint) {
    return hint === "string" ? `${this.cent / 100} €` : this.cent;
  }
}

const gutschrift = new Betrag(1999);
console.log(-gutschrift);
-1999

// Wichtig · Fallstricke

  • Potenz-Falle: -2 ** 2 ist ein SyntaxError, weil nicht eindeutig ist, was gemeint ist. Klammern setzen: (-2) ** 2 (= 4) oder -(2 ** 2) (= -4).
  • Nicht mit Dekrement verwechseln: --x ist der Dekrement-Operator und verändert die Variable. Wer doppelt negieren will, schreibt -(-x) oder - -x (mit Leerzeichen).
  • -0: -0 entsteht u. a. bei -0, -null, -\"\" oder -[]. === hält -0 und 0 für gleich, Object.is() nicht. JSON.stringify(-0) ergibt \"0\", (-0).toString() ergibt \"0\".
  • BigInt: -1n ist gültig, im Gegensatz zu +1n (TypeError). Mischen mit Number in weiteren Rechnungen führt aber weiterhin zu einem TypeError.
  • Symbol: -Symbol() wirft einen TypeError.
  • Zum reinen Umwandeln in eine Zahl sind Number(wert) oder das unäre Plus lesbarer; - nur verwenden, wenn wirklich negiert werden soll.