JavaScript'te bir string'i tam sayıya nasıl dönüştürürsünüz?

JavaScript'te bir string'i tamsayıya nasıl dönüştürürüm?

Cevap #1

En basit yol, yerel Number işlevini kullanmak olacaktır:

var x = Number("1000")

Eğer bu sizin için işe yaramazsa, o zaman parseInt, unary plus, parseFloat ile floor ve Math.round yöntemleri vardır.

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])

Tekli artı

Eğer dizeniz zaten bir tam sayı biçimindeyse:

var x = +"1000";

floor()

Eğer dizeniz bir kayan nokta sayısı ise veya olabileceğini düşünüyorsanız ve bir tam sayı istiyorsanız:

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

Ya da, Math.floor'u birkaç kez kullanacaksan:

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

parseFloat()

Eğer parseInt çağırdığınızda tabanı eklemeyi unutma türündeyseniz, parseFloat kullanabilir ve istediğiniz şekilde yuvarlayabilirsiniz. Burada floor kullanıyorum.

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

round()

İlginç bir şekilde, Math.round (Math.floor gibi) bir string'i sayıya dönüştürecektir, bu nedenle sayıyı yuvarlamak istiyorsanız (veya string içinde bir tamsayı varsa), bu harika bir yol, belki de en sevdiğim yol:

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

Cevap #2

parseInt fonksiyonunu deneyin:

var number = parseInt("10");

Ama bir problem var. Eğer "010" değerini parseInt fonksiyonunu kullanarak dönüştürmeye çalışırsanız, bu bir sekizlik sayı olarak algılanır ve 8 sayısını döndürür. Bu yüzden bir taban (2 ile 36 arasında) belirtmeniz gerekir. Bu durumda taban 10.

parseInt(string, radix)

Örnek :

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

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

Dikkat edin ki parseInt, geçerli herhangi bir şeyi ayrıştırdıktan sonra kötü verileri yok sayar.
Bu kılavuz 51 olarak ayrıştırılacaktır:

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

Cevap #3

JavaScript'te bir stringi sayıya dönüştürmenin iki ana yolu vardır. Bir yol onu çözümlemek (parse) ve diğer yol ise tipini Number olarak değiştirmektir. Diğer cevaplardaki tüm hileler (örneğin, tekli artı) stringin tipini sayıya dolaylı olarak zorlamayı içerir. Aynı şeyi Number fonksiyonu ile açıkça da yapabilirsiniz.

Çözümleme

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

parseInt ve parseFloat, dizeleri sayılara ayrıştırmak için kullanılan iki işlevdir. Ayrıştırma, tanımadığı bir karakterle karşılaştığında sessizce durur; bu, "92px" gibi dizeleri ayrıştırmak için faydalı olabilir, ancak aynı zamanda biraz tehlikelidir çünkü kötü girişlerde herhangi bir hata vermez; bunun yerine dize bir sayı ile başlamıyorsa NaN sonucu alırsınız. Dizelerin başındaki boşluklar yok sayılır. İşte bunun, istediğinizden farklı bir şekilde çalıştığı ve herhangi bir hatanın olduğunu göstermediği bir örnek:

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

Radix'i ikinci argüman olarak her zaman belirtmek iyi bir uygulamadır. Eski tarayıcılarda, eğer dize 0 ile başlıyorsa ve radix belirtilmemişse, bu durum sekizlik (octal) olarak yorumlanırdı ve bu birçok kişiyi şaşırtıyordu. Onaltılı (hexadecimal) davranışı, eğer radix belirtilmemişse, dizenin 0x ile başlaması tetikler, örneğin 0xff. Standart aslında ECMAScript 5 ile değişti, bu nedenle modern tarayıcılar, radix belirtilmemişse başında 0 olan sekizlik sayıları artık tetiklemiyor. parseInt, 36 tabana kadar olan radixleri anlar ve bu durumda hem büyük hem de küçük harfler eşdeğer olarak kabul edilir.

Bir Dizgiyi Sayıya Dönüştürme

Yukarıda parseInt kullanmayan diğer tüm hileler, stringi sayıya dolaylı olarak zorlamakla ilgilidir. Ben bunu açıkça yapmayı tercih ederim,

var cast = Number("97");

Bu, parse yöntemlerinden farklı bir davranış sergiler (yine de boşlukları yoksayar). Daha katıdır: eğer dizenin tamamını anlayamazsa NaN döndürür, bu yüzden 97px gibi dizeler için kullanamazsınız. Bir Number sarmalayıcı nesne yerine ilkel bir sayı istiyorsanız, Number fonksiyonunun önüne new koymadığınızdan emin olun.

Açıkçası, bir sayıya dönüştürmek size bir tam sayı yerine bir ondalık sayı değeri verebilir, bu yüzden bir tam sayı istiyorsanız, bunu değiştirmeniz gerekir. Bunu yapmanın birkaç yolu vardır:

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

Herhangi bir bit düzeyinde işlemci (burada bir bit düzeyinde veya yaptım, ancak daha önceki bir yanıtta olduğu gibi çift olumsuzlama veya bir bit kaydırma da yapabilirsiniz) değeri 32 bitlik bir tam sayıya dönüştürecektir ve çoğu işaretli tam sayıya dönüştürür. Büyük tam sayılar için bunu yapmak istediğiniz şeyi yapmayacağını unutmayın. Eğer tam sayı 32 bitte temsil edilemiyorsa, taşar.

~~"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

Daha büyük sayılarla doğru çalışmak için yuvarlama yöntemlerini kullanmalısınız

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

Zorlamanın üssel gösterimi ve Sonsuzluğu anladığını unutmayın, bu yüzden 2e2 NaN yerine 200 olur, oysa ayrıştırma yöntemleri bunu anlamaz.

Özel

Bu yöntemlerden hiçbirinin tam olarak istediğinizi yapması olası değildir. Örneğin, genellikle ayrıştırma başarısız olursa bir hata yakalanmasını isterim ve Infinity, üstel ifadeler veya baştaki boşluklar için desteğe ihtiyacım yoktur. Kullanım durumunuza bağlı olarak, bazen özel bir dönüştürme fonksiyonu yazmak mantıklı olabilir.

Her zaman Number'ın veya parse yöntemlerinden birinin çıktısının beklediğiniz türde bir sayı olduğunu kontrol edin. Sayının NaN olmadığından emin olmak için neredeyse kesin olarak isNaN kullanmak isteyeceksiniz (genellikle parse işleminin başarısız olduğunu öğrendiğiniz tek yol budur).

Cevap #4

ParseInt() ve + farklıdır.

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Cevap #5

En hızlı

var x = "1000"*1;

Test

İşte küçük bir hız karşılaştırması (sadece macOS)... :)

Chrome için, 'plus' ve 'mul' en hızlıdır (>700.000.000 op/sn), 'Math.floor' en yavaştır. Firefox için, 'plus' en yavaştır (!) 'mul' en hızlıdır (>900.000.000 op/sn). Safari'de 'parseInt' en hızlı, 'number' en yavaştır (ama sonuçlar oldukça benzerdir, >13.000.000 <31.000.000). Yani Safari'de string'i int'e dönüştürmek diğer tarayıcılardan 10 kat daha yavaştır. Bu yüzden kazanan 'mul' :)

Bunu bu bağlantı üzerinden tarayıcınızda çalıştırabilirsiniz https://jsperf.com/js-cast-str-to-number/1

Ben ayrıca var x=~~"1000"; kodunu da test ettim. Chrome ve Safari'de, var x="1000"*1'den (%1'den daha az) biraz daha yavaştır ve Firefox'ta (%1'den daha az) biraz daha hızlıdır.

Cevap #6

String'i sayıya dönüştürmenin bu yolunu kullanıyorum:

var str = "25";       // String
var number = str*1;   // Number

Yani, 1 ile çarptığınızda değer değişmez, ama JavaScript otomatik olarak bir sayı döndürür.

Ama aşağıda gösterildiği gibi, bu, str'nin bir sayı olduğundan (veya sayı olarak temsil edilebileceğinden) emin olduğunuzda kullanılmalıdır, aksi takdirde NaN - sayı değil - döndürecektir.

Kullanmak için basit bir fonksiyon oluşturabilirsiniz, örneğin,

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

Cevap #7

parseInt'i dene.

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

Cevap #8

Bu hileyi çok seviyorum:

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

Çifte bit düzeyi negatif, ondalık noktadan sonraki her şeyi düşürür VE bunu sayı formatına çevirir. Bana bunun fonksiyonları çağırmaktan ve benzer şeylerden biraz daha hızlı olduğu söylendi, ama tamamen ikna olmuş değilim.

Burada az önce gördüğüm bir başka yöntem (JavaScript >>> operatörü hakkında bir soru, bu operatör bir sıfır-doldurmalı sağ kaydırmadır) gösteriyor ki bu operatörle bir sayıyı 0 ile kaydırmak, sayıyı uint32’ye dönüştürüyor, bu da eğer onu işaretsiz olarak istiyorsanız hoş bir durum. Yine, bu bir işaretsiz tam sayıya dönüştürür, bu da işaretli bir sayı kullanırsanız garip davranışlara yol açabilir.

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

Cevap #9

Lütfen aşağıdaki örneğe bakın. Sorunuzu yanıtlamanıza yardımcı olacaktır.

Example                  Result

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

Parseint fonksiyonunu kullanarak, yalnızca mevcut olan tam sayıyı verir ve stringi vermez.

Cevap #10

JavaScript'te aşağıdakileri yapabilirsiniz:

ParseInt

parseInt("10.5") // Returns 10

1 ile çarpma

var s = "10";
s = s*1;  // Returns 10

Tekli operatör (+) kullanmak

var s = "10";
s = +s;  // Returns 10

Bit düzeyinde bir operatör kullanmak

(Not: 2140000000'den sonra bozulmaya başlar. Örnek: ~~"2150000000"=-2144967296)

var s = "10.5";
s = ~~s; // Returns 10

Math.floor() veya Math.ceil() kullanmak

var s = "10";
s = Math.floor(s) || Math.ceil(s); // Returns 10

Cevap #11

Eğer bir kayan noktayı bilimsel gösterimde dönüştürmek için parseInt kullanırsanız dikkat edin! Örneğin:

parseInt("5.6e-14")

sonuçlanacak

5

yerine

0

Cevap #12

Bir String'i Integer'a dönüştürmek için, parseInt yerine parseFloat kullanmanızı tavsiye ederim. İşte nedeni:

parseFloat kullanarak:

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

parseInt kullanarak:

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

Yani, eğer fark ettiyseniz parseInt ondalıkların sonrasındaki değerleri atar, oysa parseFloat ondalık sayılarla çalışmanıza izin verir ve bu nedenle ondalık değerleri korumak istiyorsanız daha uygundur. Sadece ve sadece tam sayı değerini istediğinizden emin olduğunuzda parseInt kullanın.

Cevap #13

parseInt(stringOfNumber) kullanmak yerine +(stringOfNumber) kullanabiliriz.

Örnek: +("21") 21 tam sayısını döner, parseInt("21") gibi.

Bu tekli "+" operatörünü ondalık sayıları ayrıştırmak için de kullanabiliriz...

Cevap #14

JavaScript'te bir stringi sayı değerine dönüştürmenin birçok yolu vardır... Hepsi basit ve kullanışlıdır. Sizin için işe yarayan yolu seçin:

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

Ayrıca, herhangi bir Matematik işlemi bunları sayıya dönüştürür, örneğin...

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

Benim tercih ettiğim yol, bir stringi JavaScript'te sayıya dönüştürmenin zarif yolu olan + işaretini kullanmaktır.

Cevap #15

Ayrıca bir yan not olarak: MooTools, herhangi bir yerleşik dize (veya ondalık sayı (veya tam sayı)) üzerinde kullanılan toInt() işlevine sahiptir.

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

Cevap #16

JavaScript'te String'i Sayıya Çevirme:

Tekli + (en çok önerilen)

  • +numStr kullanımı kolaydır ve diğerlerine göre daha iyi performansa sahiptir
  • Hem tam sayıları hem de ondalıkları destekler
console.log(+'123.45') // => 123.45

Bazı diğer seçenekler:

Dizeleri Ayrıştırma:

  • Tam sayılar için parseInt(numStr)
  • parseFloat(numStr) hem tam sayılar hem de ondalık sayılar için
console.log(parseInt('123.456')) // => 123
console.log(parseFloat('123'))   // => 123

JavaScript Fonksiyonları

  • Tamsayılar için round(numStr), floor(numStr), ceil(numStr) gibi matematiksel fonksiyonlar

  • Number(numStr) hem tam sayılar hem de ondalık sayılar için

console.log(Math.floor('123'))     // => 123
console.log(Math.round('123.456')) // => 123
console.log(Math.ceil('123.454'))  // => 124
console.log(Number('123.123'))     // => 123.123

Tekli Operatörler

  • Tüm temel tekli operatörler, +numStr, numStr-0, 1*numStr, numStr*1 ve numStr/1

  • Hem tam sayıları hem de ondalıkları destekler

  • numStr+0 konusunda dikkatli olun. Bu bir string döndürür.

console.log(+'123')  // => 123
console.log('002'-0) // => 2
console.log(1*'5')   // => 5
console.log('7.7'*1) // => 7.7
console.log(3.3/1)   // =>3.3
console.log('123.123'+0, typeof ('123.123' + 0)) // => 123.1230 string

Bit Düzeyinde Operatörler

  • İki tilda ~~numStr veya sola kaydırma 0, numStr<<0
  • Sadece tam sayıları destekler, ondalıkları desteklemez
console.log(~~'123')      // => 123
console.log('0123'<<0)    // => 123
console.log(~~'123.123')  // => 123
console.log('123.123'<<0) // => 123


// Parsing
console.log(parseInt('123.456')) // => 123
console.log(parseFloat('123'))   // => 123

// Function
console.log(Math.floor('123'))     // => 123
console.log(Math.round('123.456')) // => 123
console.log(Math.ceil('123.454'))  // => 124
console.log(Number('123.123'))     // => 123.123

// Unary
console.log(+'123')  // => 123
console.log('002'-0) // => 2
console.log(1*'5')   // => 5
console.log('7.7'*1) // => 7.7
console.log(3.3/1)   // => 3.3
console.log('123.123'+0, typeof ('123.123'+0)) // => 123.1230 string

// Bitwise
console.log(~~'123')      // => 123
console.log('0123'<<0)    // => 123
console.log(~~'123.123')  // => 123
console.log('123.123'<<0) // => 123

Cevap #17

string değerini number'a dönüştürmek için str - 0 deneyin.

> 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

İşte bir dizgiyi tamsayıya dönüştürmenin birkaç farklı yolunun performansını karşılaştırmak için iki bağlantı

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

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

Cevap #18

Benim görüşüme göre, hiçbir cevap tüm uç durumları kapsamaz çünkü bir float ayrıştırmak bir hatayla sonuçlanmalıdır.

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

Cevap #19

İşte en kolay çözüm

let myNumber = "123" | 0;

Daha kolay çözüm

let myNumber = +"123";

İlgili makaleler