So konvertieren Sie eine Zeichenfolge in Javascript in eine Zahl

Konvertierungsmethode: 1. Verwenden Sie Operatoren wie „-“, „*“, „/“, „%“, „++“, „--“ 2. Verwenden Sie die Anweisung „Zahl (Wert)“; . Verwenden Sie die Anweisung „parseInt(stringNum)“;

Die Betriebsumgebung dieses Tutorials: Windows 7-System, JavaScript-Version 1.8.5, Dell G3-Computer.

Javascript wandelt Zeichenfolgen in Zahlen um

Methode 1: Verwenden Sie Operatoren wie -、*、/、%、++, -- usw.

JavaScript wandelt Zeichenfolgen automatisch in Zahlen um, und diejenigen, die nicht in Zahlen umgewandelt werden können, werden konvertiert in NaN . Zum Beispiel:

alert("30"/5);   //除运算，结果为：6
alert("15"-5);   //减运算，结果为：10
alert("20"*"a"); //乘运算，结果为：NaN
alert("20"%"3"); //取模运算，结果为：2

var num1 = "6";
var num2 = "6";
var num3 = "a";
alert(++num1);  //将字符串转换为数字再进行++运算，结果为：7
alert(--num2);  //将字符串转换为数字再进行--运算，结果为：5
alert(++num3);  //字符串无法转换为数字，结果为：NaN

Methode 2: Verwenden Sie die Funktion Number()

Die Funktion Number() kann den Parameter in eine Zahl umwandeln

Das Format ist wie folgt:

Number(value)

Number() führt einen Gesamtdurchlauf durch Konvertierung des Parameterwerts, wenn der Parameterwert ein Symbol enthält, das nirgendwo in eine Zahl konvertiert werden kann, schlägt die Konvertierung fehl und NaN wird zurückgegeben. Andernfalls wird die konvertierte Zahl zurückgegeben.

Number() folgt bei der Konvertierung von Parametern in Zahlen den folgenden Regeln:

• Wenn der Parameter nur Zahlen enthält, wird er in Dezimalzahlen umgewandelt, wobei führende Nullen und führende Leerzeichen ignoriert werden, wenn der Zahl ein -, - vorangestellt ist; Wird im Konvertierungsergebnis beibehalten; wenn der Zahl ein + vorangestellt ist, wird das +-Zeichen nach der Konvertierung gelöscht.

• Wenn der Parameter eine gültige Gleitkommazahl enthält, wird er in die entsprechende Gleitkommazahl konvertiert und ignoriert Die führende 0 und die führenden Leerzeichen werden im Konvertierungsergebnis beibehalten, wenn der Zahl ein + vorangestellt ist.

• Wenn der Parameter enthält Eine gültige Hexadezimalzahl wird in eine Dezimalzahl der entsprechenden Größe umgewandelt.

• Wenn der Parameter eine leere Zeichenfolge ist, wird er in 0 umgewandelt;

• Wenn der Parameter ein boolescher Wert ist, wird er wahr wird in 1 umgewandelt und false wird in 0 umgewandelt;

• Wenn der Parameter null ist, wird er in 0 umgewandelt; Der Parameter ist ein Datumsobjekt und wird vom 1. Januar 1970 bis zum Zeitpunkt der Konvertierung in die Anzahl der Millisekunden konvertiert.

• Wenn der Parameter eine Funktion ist, ein Array-Objekt, das mehr als zwei Elemente enthält, und andere Objekte außer Datumsobjekten werden in NaN konvertiert.

• Wenn der Parameter andere Sonderzeichen außer Leerzeichen, + und - oder nicht numerische Zeichen oder Sonderzeichen oder nicht numerische Zeichen einschließlich Leerzeichen, + enthält, und - in der Mitte des Parameters, wird in NaN konvertiert.

Konvertierungsbeispiel:

• alert(Number("0010"));  //去掉两个前导0，结果为：10
  alert(Number("+010"));  //去掉前导0和+，结果为：10
  alert(Number("-10"));  //转换后保留“-”号，结果为：-10
  alert(Number(''));      //空字符串的转换结果为：0
  alert(Number(true));   //布尔值true的转换结果为：1
  alert(Number(null));   //null值的转换结果为：0
  var d = new Date();      //创建一个Date对象
  alert(Number(d));     //转换Date对象，结果为1970.1.1至执行转换时的毫秒数：1511351635179
  alert(Number("100px"));   //参数中包含了不能转换为数字的字符px，结果为：NaN
  alert(Number("100 01"));  //参数中包含了空格，导致整个参数不能转换，结果为：NaN
  alert(Number("100-123")); //参数中包含了“-”，导致整个参数不能转换，结果为：NaN
  var a;                   //声明变量
  alert(Number(a));     //变量a没有赋值，因而a的值为undefined,转换undefined的结果为：NaN
  var fn = function (){alert(1);}; //创建一个函数对象
  alert(Number(fn));     //转换函数，结果为:NaN
  alert(Number(window)); //转换window对象，结果为:NaN

  Aus dem obigen Beispiel können wir auch sehen, dass Number() als Ganzes konvertiert wird und alle an einer beliebigen Stelle enthaltenen illegalen Zeichen dazu führen, dass die Konvertierung fehlschlägt. Der Unterschied zwischen den beiden als nächstes vorgestellten Funktionen und Number() besteht darin, dass die Konvertierung bitweise von links nach rechts durchgeführt wird. Wenn ein Bit nicht konvertiert werden kann, wird die Konvertierung sofort gestoppt und der erfolgreich konvertierte Wert zurückgegeben.

Methode 3: Verwenden Sie die Funktion parseInt()

Die Funktion parseInt() kann den Parameter in eine Ganzzahl konvertieren

Das Format ist wie folgt:

parseInt(stringNum,[radix])

stringNum-Parameter ist die Zeichenfolge, die in eine Ganzzahl konvertiert werden muss; Der Basisparameter ist 2~. Die Zahl zwischen 36 stellt die Basisnummer des stringNum-Parameters dar, der weggelassen werden kann, wenn der Wert 10 ist. parseInt() wird verwendet, um den String-Parameter stringNum mit Radix als Basis in eine Dezimalzahl zu analysieren. Wenn die stringNum-Zeichenfolge nicht mit einem zulässigen Zeichen beginnt, wird NaN zurückgegeben. Wenn während des Analysevorgangs ein unzulässiges Zeichen auftritt, wird die Analyse sofort beendet und der analysierte Wert zurückgegeben.

parseInt() befolgt beim Parsen einer Zeichenfolge in eine Ganzzahl die folgenden Regeln:

Beim Parsen einer Zeichenfolge werden Leerzeichen vor und nach der Zeichenfolge ignoriert. Wenn der Zeichenfolge ein - vorangestellt ist, bleiben sie erhalten Konvertierungsergebnis; wenn der Zahl ein + vorangestellt ist, wird das +-Zeichen nach der Konvertierung gelöscht.

Wenn der Zeichenfolge andere Sonderzeichen als Leerzeichen, + und - oder nicht numerische Zeichen außer a～f ( oder A～F), Die Zeichenfolge wird nicht analysiert und das Ergebnis ist NaN; wird auf diese Zeichen stoßen Stoppen und das analysierte Ergebnis zurückgeben

• Wenn die Zeichenfolge eine leere Zeichenfolge ist, ist das Rückgabeergebnis NaN.

• Konvertierungsbeispiel:

  alert(parseInt("1101",2));  //以2为基数的1101字符串解析后的结果为：13
  alert(parseInt("a37f",16)); //以16为基数的a37f字符串解析后的结果为：41855
  alert(parseInt("123"));     //以10为基数的123字符串解析后的结果为：123
  alert(parseInt("  123"));   //字符串前面的空格会被忽略，结果为：123
  alert(parseInt("12 3"));    //字符串中包含了空格，解析到空格时停止，结果为12
  alert(parseInt("12.345")); //字符串中包含了小数点，解析到小数点时停止，结果为12
  alert(parseInt("xy123"));  //字符串前面包含了非数字字符“x”，无法解析，返回结果为：NaN
  alert(parseInt("123xy4")); //字符串中包含了非数字字符“xy”，解析到“x”时停止，结果为：123

Aus dem obigen Beispiel können wir sehen, dass beim Parsen von Gleitkommazahlen der Dezimalteil der Daten abgeschnitten wird. In diesem Fall müssen Sie parseFloat() verwenden. was weiter unten vorgestellt wird, anstelle von parseInt().

• Methode 4: Verwenden Sie die Funktion parseFloat()

• Die Funktion parseFloat() kann den Parameter in eine Gleitkommazahl umwandeln

Das Format ist wie folgt:

parseFloat(stringNum)

stringNum Der Parameter ist eine Zeichenfolge, die sein muss in eine Gleitkommazahl geparst.

parseFloat() 的作用是将首位为数字的字符串转解析成浮点型数。若 stringNum 字符串不是以合法的字符开头，则返回 NaN；解析过程中如果遇到不合法的字符，将马上停止解析，并返回已经解析的值。

parseFloat() 在解析字符串为整数时，遵循以下规则：

• 解析字符串时，会忽略字符串前后的空格；如果字符串前面为-，-会保留在转换结果中；如果数字前面为+，转换后将删掉+号；如果字符串前面为小数点.转换结果会在小数点前面添加 0；

• 如果字符串前面为除空格、+、-和。以外的特殊符号，字符串将不会被解析，返回结果为 NaN；

• 在字符串中包含了空格、+和-等特殊符号或非数字的字符时，解析将在遇到这些字符时停止，并返回已解析的结果；

• 在字符串中包含两个以上为小数点时，解析到第二个小数点时将停止解析，并返回已解析的结果；

• 如果字符串是空字符串，返回结果为 NaN。

转换示例：

alert(parseFloat("312.456"));//结果为：312.456
alert(parseFloat("-3.12"));//字符串前面的“-”将保留，结果为：-3.12
alert(parseFloat("+3.12"));//字符串前面的“-”将保留，结果为：3.12
alert(parseFloat(".12"));//在小数点前面添加0，结果为：0.12
alert(parseFloat("  3.12"));//截掉字符串前面的空格，结果为：3.12
alert(parseFloat("312.4A56"));//字符串中包含非数字字符A，解析到A时停止，结果为：312.4
alert(parseFloat("31 2.4A56"));//字符串中包含空格，解析到空格时停止，结果为：31
alert(parseFloat("31.2.5"));//字符串中包含两个小数点，解析到第二个小数点时停止，结果为：31.2
alert(parseFloat("a312.456"));//字符串前面为非数字字符a，解析无法进行，结果为：NaN

【推荐学习：javascript高级教程】

Das obige ist der detaillierte Inhalt vonSo konvertieren Sie eine Zeichenfolge in Javascript in eine Zahl. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!