JavaScriptで文字列を整数に変換するにはどうすればよいですか？

最も簡単な方法は、ネイティブNumber関数を使用することです。

var x = Number("1000")

それでもうまくいかない場合は、parseInt、unary plus、parseFloat with floor、Math.roundメソッドがあります。

parseInt：

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

文字列がすでに整数の形式である場合、単項プラス：

var x = +"1000";

文字列が浮動小数点数または浮動小数点数であり、整数が必要な場合：

var x = Math.floor("1000.01"); //floor automatically converts string to number

または、Math.floorを数回使用する場合：

var floor = Math.floor;
var x = floor("1000.01");

parseIntを呼び出すときに基数を入れるのを忘れるタイプの場合は、parseFloatを使用して好きなように丸めることができます。ここでは床を使います。

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

興味深いことに、Math.round（Math.floorのような）は文字列から数値への変換を行うので、数値を丸めたい場合（または文字列に整数がある場合）、これは素晴らしい方法で、おそらく私のお気に入りです。

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)

parseInt関数を試してください：

var number = parseInt("10");

しかし問題がある。parseInt関数を使用して「010」を変換しようとすると、8進数として検出され、8を返します。したがって、基数（2から36）を指定する必要があります。この場合、ベースは10です。

parseInt(string, radix)

例：

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

parseIntは有効なものを解析した後、不良データを無視することに注意してください。
このGUIDは51として解析されます。

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

JavaScriptで文字列を数値に変換するには、主に2つの方法があります。1つはそれを解析する方法で、もう1つはそのタイプを数値に変更する方法です。他の答えのすべてのトリック（たとえば、単項プラス）は、文字列の型を暗黙的に数値に強制します。Number関数を使用して、同じことを明示的に行うこともできます。

解析中

var parsed = parseInt("97", 10);

parseIntとparseFloatは、文字列を数値に解析するために使用される2つの関数です。認識できない文字にぶつかると、解析はサイレントに停止します。これは、「92px」のような文字列を解析するのに役立ちますが、不正な入力に対してなんらかの種類のエラーが発生しないため、やや危険です。 '文字列が数字で始まらない限り、NaNを返します。文字列の先頭の空白は無視されます。これはあなたが望むものとは異なる何かをしていて、何かがうまくいかなかったことを示さない例です：

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

基数を常に2番目の引数として指定することをお勧めします。古いブラウザでは、文字列が0で始まる場合、基数が指定されていないと8進数として解釈され、多くの人が驚いた。16進数の動作は、基数が指定されていない場合、文字列が0xで始まることでトリガーされます0xff。標準はecmascript 5で実際に変更されたため、基数が指定されていない場合、最新のブラウザーは先行する0があるときに8進数をトリガーしなくなりました。parseIntは基数36までの基数を認識します。この場合、大文字と小文字の両方が同等として扱われます。

文字列のタイプを数値に変更する

parseIntを使用しない上記の他のすべてのトリックには、暗黙的に文字列を数値に強制変換することが含まれます。私はこれを明示的に行うことを好む、

var cast = Number("97");

これは解析メソッドとは動作が異なります（ただし、空白は無視されます）。それはより厳密です：それが返すよりも文字列全体を理解していない場合はNaN、のような文字列には使用できません97px。Numberラッパーオブジェクトではなくプリミティブ番号が必要なためnew、Number関数の前に配置しないでください。

明らかに、数値に変換すると、整数ではなく浮動小数点の値が得られるため、整数が必要な場合は、その値を変更する必要があります。これにはいくつかの方法があります。

var rounded = Math.floor(Number("97.654"));  // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0;  // do not use for large numbers

任意のビット演算子（ここではビット演算子を使用していますが、以前の回答やビットシフトのように二重否定を実行することもできます）は値を32ビット整数に変換し、それらのほとんどは符号付き整数に変換されます。これは大きな整数には必要ないことに注意してください。整数が32ビットで表現できない場合、ラップされます。

~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

より大きい数を正しく処理するには、丸め方法を使用する必要があります

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

これらのメソッドのすべてが指数表記を理解していることを念頭に置いてクマは、そう2e2で200はNaNではなく。また、数値は「無限大」を理解しますが、解析メソッドは理解しません。

カスタム

これらの方法のいずれかが、まさにあなたが望んでいることをすることはまずありません。たとえば、通常は解析が失敗した場合にエラーをスローする必要があります。また、無限大、指数、または先行空白のサポートは必要ありません。ユースケースによっては、カスタム変換関数を作成することが理にかなっている場合があります。

常にNumberの出力またはいずれかの解析メソッドが期待どおりの数であることを確認してください。ほとんどの場合isNaN、数値がNaNでないことを確認するために使用する必要があります（通常、解析が失敗したことを確認する唯一の方法です）。

ParseInt（）と+は異なります

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

古い質問ですが、多分これは誰かに役立つかもしれません。

私はに文字列を変換するこの方法を使用int型の数を

var str = "25";       // string
var number = str*1;   // number

したがって、1を掛けても値は変わりませんが、jsは自動的に数値を返します。

ただし、以下に示すように、これがstr数値である（または数値として表すことができる）場合は、これを使用してください。そうでない場合は、数値ではなくNaNが返されます。

使用する簡単な関数を作成できます。

function toNumber(str) {
   return str*1;
}

最速

var x = "1000"*1;

テスト

以下は速度の比較です（Mac Osのみ）... :)

クロムの場合、「plus」と「mul」が最も速く（> 700,000,00 op / sec）、「Math.floor」が最も遅くなります。Firefoxの場合、「plus」が最も遅い（！）「mul」が最も速い（> 900,000,000 op / sec）。Safariでは、「parseInt」は高速ですが、「number」は最も低速です（ただし、resulatsは非常によく似ており、> 13,000,000 <31,000,000）。したがって、文字列をintにキャストするSafariは、他のブラウザよりも10倍以上遅くなります。したがって、勝者は ' mul 'です:)

このリンクhttps://jsperf.com/js-cast-str-to-number/1をブラウザで実行できます 。

更新

私もテストvar x = ~~"1000";します-ChromeとSafariはvar x = "1000"*1（<1％）より少し遅いですが、Firefoxは少し速い（<1％）です。上記の画像を更新してテストします

parseIntを試してください。

var number = parseInt("10", 10); //number will have value of 10.

ここに間違った答えを投稿しました。修繕。

これは古い質問ですが、私はこのトリックが大好きです：

~~"2.123"; //2
~~"5"; //5

二重のビットごとの負の値は、小数点以下をすべて切り捨て、数値形式に変換します。私はそれが関数を呼び出すよりも少し速いと言われていますが、私は完全には確信していません。

編集：私がここで見たもう1つの方法（ゼロフィル右シフトであるjavascript >>>演算子についての質問）は、この演算子で数値を0シフトすると、数値がuint32に変換されることを示していますまた、無署名が必要です。繰り返しになりますが、これは符号なし整数に変換されます。これは、符号付きの数値を使用すると奇妙な動作を引き起こす可能性があります。

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

parseIntを使用して浮動小数点数を科学表記に変換する場合は注意してください。例えば：

parseInt("5.6e-14") 

結果になります

5 

の代わりに

0

文字列を整数に変換するには、私はparseFloatはして使用することをお勧めしないのparseIntを。理由は次のとおりです。

parseFloatの使用：

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

parseIntの使用：

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

したがって、parseIntは小数部の後の値を破棄することに気付いた場合、parseFloatは浮動小数点数を処理できるため、小数部の後の値を保持したい場合により適しています。整数値が必要な場合にのみ、parseIntを使用してください。

また、補足として：Mootoolsには、ネイティブ文字列（またはfloat（または整数））で使用される関数toInt（）があります。

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

下記の例をご覧ください。疑問を解消するのに役立ちます

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

parseint関数を使用することで、存在する整数のopのみを提供し、文字列は提供しません

使用する+(stringOfNumber)代わりに使用できますparseInt(stringOfNumber)

例：の+("21")ように21のintを返しますparseInt("21")。

この単項「+」演算子を使用して、フロートを解析することもできます...

str - 0に変換stringしてみてくださいnumber。

> str = '0'
> str - 0
  0
> str = '123'
> str - 0
  123
> str = '-12'
> str - 0
  -12
> str = 'asdf'
> str - 0
  NaN
> str = '12.34'
> str - 0
  12.34

文字列をintに変換するいくつかの方法のパフォーマンスを比較する2つのリンクを次に示します

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

JavaScriptには、文字列を数値に変換する方法がたくさんあります...シンプルで便利な方法で、自分に合った方法を選択してください：

var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5

また、任意の数学演算は、たとえばそれらを数値に変換します...

var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999

私の好みの方法は+、JavaScriptで文字列を数値に変換するエレガントな方法である符号を使用することです。

結果としてGoogleがこの答えをくれたので...

CとJavaScriptの間のバインディングのために、実際には文字列を整数として「保存」する必要があったので、文字列を整数値に変換します。

/*
    Examples:
        int2str( str2int("test") ) == "test" // true
        int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
    Limitations:
        max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
    var ret = 0;
    var len = the_str.length;
    if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) <<  0;
    if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) <<  8;
    if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
    if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
    return ret;
}
function int2str(the_int) {
    var tmp = [
        (the_int & 0x000000ff) >>  0,
        (the_int & 0x0000ff00) >>  8,
        (the_int & 0x00ff0000) >> 16,
        (the_int & 0xff000000) >> 24
    ];
    var ret = "";
    for (var i=0; i<4; i++) {
        if (tmp[i] == 0)
            break;
        ret += String.fromCharCode(tmp[i]);
    }
    return ret;
}

私の意見では、浮動小数点数を解析するとエラーが発生するため、すべてのエッジケースをカバーする答えはありません。

function parseInteger(value) {
    if(value === '') return NaN;
    const number = Number(value);
    return Number.isInteger(number) ? number : NaN;
}

parseInteger("4")            // 4
parseInteger("5aaa")         // NaN
parseInteger("4.33333")      // NaN
parseInteger("aaa");         // NaN

これが最も簡単な解決策です

let myNumber = "123" | 0;

より簡単な解決策

let myNumber = +"123";

上記のすべてが正しいです。「typeot x === 'number'」を実行して文字列内の数値であることを確認してから、NaNを返します。

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

もう1つのオプションは、値とそれ自体のXORを2倍にすることです。

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

これは出力します：

i = 12.34
i ⊕ i ⊕ i = 12

文字列の前に1つだけプラス（+）を追加しましたが、それが解決策でした！

+"052254" //52254

それが役に立てば幸い ;）

桁の乗算とそれぞれの10の累乗の合計：

つまり、123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 *（10 ^ 2）+ 2 *（10 ^ 1）+ 3 *（10 ^ 0）

function atoi(array) {

// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum

let sum = 0;

for (let i = 0; i < array.length; i++) {
    let exp = array.length-(i+1);
    let value = array[i] * Math.pow(10,exp);
    sum+=value;
}

return sum;

}

私はこれを使います

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

このようにして、常にintを返します。

有効な整数を取得するための最も安全な方法：

let integer = (parseInt(value, 10) || 0);

例：

// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0

// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230

// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0

function parseIntSmarter(str) {
    // ParseInt is bad because it returns 22 for "22thisendsintext"
    // Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
    return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}

プラスを使用できます。たとえば、=>

var personAge = '24'; var personAge1 =（+ personAge）

次に、typeof personAgeが数値であることがわかります。