Strings in Zahlen umwandeln und prüfen

Nur number – kein Integer, kein Floating Point

Anders als die meisten Programmiersprachen kennt Javascript nur einen Typ von Zahlen – keine Integer, Short, Long oder Floating Point- Zahlen. Zahlen sind einfach number, ob mit oder ohne Dezimalstellen.

parseInt, parseFloat, isFinite und encodeURI/decodeURI sind unabhängig von Objekten und werden darum als »Top-Level-Funktionen« bezeichnet. Ansonsten wird der größte Teil der Javascript-Funktionalität von Objekten und ihren Methoden bereitgestellt.

In jedem Fall aber bei Formulareingaben gut aufpassen: Javascript verlangt einen Punkt als Dezimaltrennzeichen!

parseInt ()

Parst (analysiert) einen String "x" und gibt die erste Zahl (Integer) zurück, die gefunden wird.

parseInt( x, [radix] )

Ist das erste Zeichen keine Ziffer, Leerzeichen oder ein führendes Minusszeichen, gibt parseInt() NaN zurück.

parseInt() unterstützt einen zweiten optionalen Parameter radix, um die Basis der geparsten Zahl anzugeben (im Bereich 2-36).

• Mit dem Wert "10" interpretiert der Parser die Zahl im Dezimalsystem, während "16" eine Zahl als Hexadezimalwert interpretiert.
• Ist der Parameter nicht vorhanden, geht parseInt () davon aus, dass Zahlen, die mit "0x" beginnen, radix 16 sind, "0" radix 8 und alle anderen Zahlen radix 10.

parseInt( "50" )                    // liefert 50
parseInt( "3-facher Meister" )      // liefert 3
parseInt( "  5 lebt" )              // liefert 5 
parseInt( "Ich habe 3 Computer" )   // liefert NaN
parseInt( "17", 8 )                 // liefert 15

Vorsichtshalber sollte die Basis 10 bei der Auswertung von Formularfeldern immer angegeben werden, damit führende Nullen nicht zu Fehlern führen.

parseInt('017')     // liefert 15
parseInt('17')      // liefert 17

parseFloat ( x )

Parst einen String x und gibt die erste Fliesskommazahl – also die erste Zahl mit einem Dezimalpunkt – zurück. Ist das erste Zeichen im String keine Ziffer, Weißraum oder ein führendes Minuszeichen, gibt parseFloat() NaN zurück.

parseFloat( "15.87" )            // gibt 15,87 zurück
parseFloat( "-17,8 Meter" )      // gibt -17 zurück
parseFloat( "foo " )             // gibt NaN zurück

parseFloat() wandelt z.B. Eingaben in Formularfeldern in Zahlen um. Javascript interpretiert die Werte von Formularfeldern immer als String, auch wenn der Benutzer '17.87' in ein Feld eingetragen hat. Bei der Transformation von Fliesskommazahlen aus Formularfeldern müssen Kommas vor dem Aufruf von parseInt() in Punkte umgewandelt werden, da parseInt() ansonsten nur die Zahl bis zum Komma umwandelt.

x = x.replace( /,/,"." );
y.value = parseFloat( x );

Number (s)

Die Globale Number() konvertiert eine Variable oder einen Wert in eine Zahl.

• Ein numerischer String von Zahlen wie 17.4050 wird in die Zahl 17.405 umgewandelt.
• Ein String wie "Javascript" gibt NaN (not a number) zurück.
• Ein leerer String "" wird in 0 umgewandelt.

console.log (Number ("17.4050"));    // 
console.log (Number("22,99"));       // 
console.log (Number ("Javascript")); // 
console.log (Number (""));           // 
console.log (Number (Math.PI));      // 

Doppeltilde ~~ und Unärer Plus-Operator

~~ ist eine doppelte bitweise Negation. ~~"42" wertet zuerst ~"42" aus (-(x + 1)) und dann ~"-43". Schnell, aber nicht gerade intuitiv.

const num1 = "42";      // 
const num2 = "17.4050"; // 
const num3 = "22,99";   // 
const num4 = true;      // 
const num5 = false;     // 
const num6 = "-2002";   // 

Ein Plus vor der Variablen wird als Unitary plus operator interpretiert.

const plus1 = ~~"42";      // +plus1 = 
const plus2 = ~~"17.4050"; // +plus2 = 
const plus3 = ~~"22,99";   // +plus3 = 
const plus4 = ~~true;      // +plus4 = 
const plus5 = ~~"false";   // +plus5 = 
const plus6 = ~"-2002";   // +plus6 = 

isNaN ()

isNaN () prüft, ob x den Wert NaN (Not a Number) aufweist – eine illegale Zahl.

isNaN (document.getElementById('nannum').value)

isNaN gibt true zurück, wenn x keine ordentliche Zahl (NaN) ist und ansonsten false. Ein typisches Beispiel für NaN ist »0 dividiert durch 0«, aber auch beim Prüfen von Eingaben in Formularfeldern muss geprüft werden, ob sich die Eingabe tatsächlich in eine Zahl umwandeln lässt. Für die Prüfung ist isNaN erforderlich, da die Gleichheitsoperatoren sowohl bei einer Abfrage if (num == NaN) als auch bei if (num === Nan) nicht funktionieren.

isFinite(x)

Stellt fest, ob eine Zahl endlich (finit) ist. Gibt false zurück, wenn x +infinity, -infinity oder NaN ist (ab JavaScript 1.3).

console.log (isFinite (2.17424));	// true
console.log (isFinite (1.5E+317));	// false
console.log (isFinite (17/3));		// true
console.log (isFinite (0/0));		// false

eval (s)

Javascript eval prüft zuerst, ob s ein String ist, entwickelt den String und führt ihn aus, wenn der String Javascript-Anweisungen enthält. Am Ende gibt eval() den Wert der letzten Anweisung aus – d.h. eval() führt Anweisungen aus, die als Zeichenkette – z.B. aus einer Benutzereingabe – vorliegen. eval() erlaubt die dynamische Konstruktion von JavaScript-Anweisungen und -Ausdrücken.

eval() erwartet einen String. Wenn der String einen gültigen Ausdruck darstellt, führt eval() den Ausdruck aus. Das Argument ist optional – wenn kein Argument übergeben wird, gibt eval() undefined zurück. Wenn das Argument kein String ist, gibt eval() das Argument unverändert zurück.

function quad( num ) {
   return ( num*num ); 
}
let sinn = 42;

eval( "42 + 8 * 2" );                                   // gibt 58 zurück
eval( "sinn - quad( 3 )" );                             // gibt 33 zurück
eval( "let z= 0; for (let i=0; i<sinn; i++) z++;" )  // gibt 41 zurück
eval( alert( sinn ) )                                   // gibt 42 aus

Natürlich wird eval() nicht wie in diesen Beispielen aufgerufen, um einen Ausdruck auszuführen. Javascript führt Ausdrücke automatisch aus. Sinnvoll ist eval() z.B., wenn Ausdrücke als Benutzereingabe aus einem Formularfeld als String übernommen werden.

eval() gilt als bedenklich, unsauber bis böse: Im Eingabefeld des Beispiels werden nicht nur fromme mathematische Ausdrücke entwickelt und harmlose Javascript-Anweisungen wie alert( 'Hallo Welt' ), sondern jede Anweisung. Javascript eval (s) ist eine beliebte Basis für die Verschleierung von Hacks und Trojanern, z.B. für Umleitungen auf Werbe-Popups aus einem externen Javascript.

Number (obj)

Javascript Number (obj) konvertiert das Objekt im Argument in eine Zahl, die das Objekt darstellt. Wenn sich das Objekt nicht in eine Zahl umwandeln läßt, gibt Number() NaN (not a number) zurück. Das Objekt muss ein Javascript-Objekt sein. Wenn kein Argument übergeben wird, gibt Number() 0 zurück.

let foo = new Boolean( "true" );
console.log ( Number( foo ) );

gibt 1 zurück

String ( obj )

Javascript String( obj ) erzeugt einen String aus einem beliebigen Objekt.

Das Argument obj muss ein Javascript-Objekt sein. Wenn kein Argument übergeben wird, gibt String() einen leeren String zurück.

const items = new Array ("Elvira", "Rosinante", 14, true);
console.log (String(items));

gibt Elvira,Rosinante,14,true aus.