JavaScript, dinamik olarak yazılmış bir dildir. Bu, farklı türlerdeki değerlerin aynı değişkene yazılabileceği ve değişkenin türünün kendisinin değişeceği anlamına gelir. Bu davranış genellikle değişkenlerin farklı davranışlarını unutmanıza izin verir. farklı şekiller, ancak yine de bu özelliği hatırlamak gerekir. Bunu aşağıdaki örnekle gösterelim.

console.log (toplam (1, 2)); // 3 (burada her şey yolunda) console.log (sum (1, "2")); // 12 (ama burada çok değil)

Örnekten de görebileceğiniz gibi, işlev toplam bir sayı argümanlarından en az biri olarak aktarılmazsa yanlış davranır. Gerçek şu ki, bir dizgeye bir sayı "eklendiğinde", sayı bir dizeye dönüştürülür ve ikinci işlenenle birleştirilir (yapıştırılır).

Bu tür karmaşıklıklardan kaçınmak için, komut dosyası yürütme sırasında bir değişkenin türünü bulabilir ve davranışını ayarlayabilir veya değişken türlerini dikkatlice izleyebilirsiniz.

Typeof operatörü

Bu tek terimli operatör, işlenen olarak kesinlikle herhangi bir değeri alır ve türünü bir dizge değişkeninde döndürür.

Aşağıdaki veri türleri JavaScript'te mevcuttur:

// 1.) nesne console.log (typeof ()); // nesne var p \u003d (x: 1, y: 3); console.log (typeof p); // nesne // 2.) function function sayHello () (console.log ("Merhaba!");) console.log (typeof sayHello); // function // 3.) string console.log (typeof "JavaScript"); // dize // 4.) sayı console.log (typeof 3.1415); // sayı // 5.) boolean console.log (typeof true); // boolean // 6.) tanımsız var notExistsOne; console.log (typeof notExistsOne); // tanımsız console.log (typeof notExistsTwo); // Tanımsız

// 1.) nesne console.log (typeof ()); // nesne var p \u003d (x: 1, y: 3); console.log (typeof p); // nesne // 2.) function function sayHello () (console.log ("Merhaba!");) console.log (typeof sayHello); // function // 3.) string console.log (typeof "JavaScript"); // dize // 4.) sayı console.log (typeof 3.1415); // sayı // 5.) boolean console.log (typeof true); // boolean // 6.) tanımsız var notExistsOne; console.log (typeof notExistsOne); // tanımsız console.log (typeof notExistsTwo); // Tanımsız

Bunu not et tanımsız aynı zamanda tek bir değerden oluşan bir veri türüdür.

Oyuncular

Programlamada tipleme, bir türdeki bir değişkenin değerini başka bir türden bir değere dönüştürmek olarak anlaşılır.
Genellikle bu dönüşüm programcının kontrolü olmadan gerçekleşir. Bu, işlevli örnekte görülebilir toplam... Orijinal türdeki bir değişken üzerindeki bir işlemin sonucu net değilse tür değişikliği oluşur. Örneğin, bir sayıya bir dize eklemenin sonucunu kesin olarak söyleyemezsiniz, ancak iki sayı ekleme işlemi açıktır ve bu durumda sayıyı bir dizeye dönüştürmek mantıklıdır.

Dizeyi sayıya dönüştür

Bazen programcının kendisi bir değişkenin türünü ona belirli işlemler uygulayarak değiştirebilir. Örneğin, bir dizeyi artırmak veya azaltmak onu bir sayıya dönüştürecektir.

var c \u003d "sayı değil"; ++ c; console.log (typeof c); // NaN

Zayıf okunabilirliği ve açık olmaması nedeniyle bir dizgiyi bir sayıya dönüştürmek için bu yönteme başvurmaya gerek olmadığına dikkat edilmelidir. Js'de bu görev için yerleşik işlevler vardır parseInt ve parseFloat... İlk argüman olarak, bir dizgenin bir sayıya dönüştürülmesini ve isteğe bağlı bir ikinci olarak, sayının ilk bağımsız değişken olarak geçirilen dizeye yazıldığı sayı sisteminin tabanını kabul ederler. İkinci bağımsız değişken belirtilmezse, dizenin ondalık gösterimde bir sayı içerdiği kabul edilecektir.

Fonksiyon parseInt bir dizeyi bir tam sayıya ve işlevine dönüştürmek için kullanılır parseFloat kesirli dönüştürmek için.

var a \u003d parseInt ("10"); console.log (["a \u003d", a, "; typeof a:", typeof a] .join ("")); // a \u003d 10; typeof a: sayı var pi \u003d parseInt ("3,1415"); console.log ("pi \u003d" + pi); // pi \u003d 3 pi \u003d parseFloat ("3.1415"); console.log ("pi \u003d" + pi); // pi \u003d 3.1415

var a \u003d parseInt ("10"); console.log (["a \u003d", a, "; typeof a:", typeof a] .join ("")); // a \u003d 10; typeof a: sayı var pi \u003d parseInt ("3,1415"); console.log ("pi \u003d" + pi); // pi \u003d 3 pi \u003d parseFloat ("3.1415"); console.log ("pi \u003d" + pi); // pi \u003d 3.1415

Dizenin onaltılık, sekizlik veya üstel dahil olmak üzere herhangi bir değişmez sayısal değer içerebileceğini unutmayın.

a \u003d parseInt ("010"); console.log ("a \u003d" + a); // a \u003d 8 a \u003d parseInt ("0xAA"); console.log ("a \u003d" + a); // a \u003d 170 a \u003d parseFloat ("1e-10"); console.log ("a \u003d" + a); // a \u003d 1e-10 (1e-10 \u003d 1 * 10 ^ -10 \u003d 0.0000000001)

a \u003d parseInt ("010"); console.log ("a \u003d" + a); // a \u003d 8 a \u003d parseInt ("0xAA"); console.log ("a \u003d" + a); // a \u003d 170 a \u003d parseFloat ("1e-10"); console.log ("a \u003d" + a); // a \u003d 1e-10 (1e-10 \u003d 1 * 10 ^ -10 \u003d 0.0000000001)

Fonksiyonların ikinci parametresi olarak parseInt ve parseFloat sayı sisteminin tabanını belirtebilirsiniz.

a \u003d parseInt ("10", 8); console.log ("a \u003d" + a); // a \u003d 8 a \u003d parseInt ("010", 10); console.log ("a \u003d" + a); // a \u003d 10 a \u003d parseInt ("ff", 16); console.log ("a \u003d" + a); // a \u003d 255

a \u003d parseInt ("10", 8); console.log ("a \u003d" + a); // a \u003d 8 a \u003d parseInt ("010", 10); console.log ("a \u003d" + a); // a \u003d 10 a \u003d parseInt ("ff", 16); console.log ("a \u003d" + a); // a \u003d 255

Dizedeki değer, hangi işlevler parseInt ve parseFloat ilk parametre olarak alın, sayısal bir değişmez değeri temsil etmez, bu durumda bu işlevlerin sonucu değer olacaktır NaN.

a \u003d parseInt ("sayı değil"); console.log ("a \u003d" + a); // a \u003d NaN a \u003d parseFloat ("sayı değil"); console.log ("a \u003d" + a); // a \u003d NaN

a \u003d parseInt ("sayı değil"); console.log ("a \u003d" + a); // a \u003d NaN a \u003d parseFloat ("sayı değil"); console.log ("a \u003d" + a); // a \u003d NaN

Dize dönüşümü

JavaScript'te, her türden bir değer bir dizeye dönüştürülebilir. Yukarıda, bir dizgeyi bir sayı ile birleştirirken, sayının bir dizeye dönüştürüldüğü ve ancak o zaman birleştirme gerçekleştiği belirtilmişti. Bu, her türden bir değerle gerçekleşecektir.

var str \u003d "Nesne:" + (); console.log (str); // Nesne: str \u003d "Dizi:" + [1, 2, 3]; console.log (str); // Dizi: 1,2,3 function sum (a, b) (return a + b;) str \u003d "Function:" + sum; console.log (str); / * İşlev: işlev toplamı (a, b) (döndür a + b;) * /

var str \u003d "Nesne:" + (); console.log (str); // Nesne: str \u003d "Dizi:" +; console.log (str); // Dizi: 1,2,3 function sum (a, b) (return a + b;) str \u003d "Function:" + sum; console.log (str); / * İşlev: işlev toplamı (a, b) (döndür a + b;) * /

Aslında, bir nesneyi bir dizeye çevirirken, yöntem örtük olarak çağrılır toStringbu ayrıca açıkça çağrılabilir.

var p \u003d (x: 2, y: 4), str; str \u003d p.toString (); console.log (typeof str); // string console.log (str); // str \u003d [1, 2, 3] .toString (); console.log (typeof str); // string console.log (str); // 1,2,3

var p \u003d (x: 2, y: 4), str; str \u003d p.toString (); console.log (typeof str); // string console.log (str); // str \u003d .toString (); console.log (typeof str); // string console.log (str); // 1,2,3

Sayısal dönüşüm

Bir sayıya dönüştürme, matematiksel işlemler gerçekleştirirken ve tür dönüştürme (\u003d\u003d ,! \u003d) ile bir karşılaştırma işlemi gerçekleştirirken gerçekleşir. yanlış ve boş bir dizi 0 türünde bir değere dönüştürülür numara.

var a \u003d doğru + doğru + doğru; // 1 + 1 + 1 console.log (a); // 3

Boş olmayan bir dizi, nesne ve işlev, aritmetik ifadelerde kullanıldığında bir dizeye dönüştürülür.

var arr \u003d [1, 2, 3]; console.log (arr + 4); // 1,2,34 function sum (a, b) (return a + b;) console.log (toplam + 5); // fonksiyon toplamı (a, b) (dönüş a + b;) 5

var arr \u003d; console.log (arr + 4); // 1,2,34 function sum (a, b) (return a + b;) console.log (toplam + 5); // fonksiyon toplamı (a, b) (dönüş a + b;) 5

Gördüğünüz gibi, js'de örtük tür dönüşümü her zaman açık olmaktan uzaktır, bu nedenle açık tür dönüşümü için işlevler kullanarak bundan kaçınmalısınız parseInt, parseFloat ve toString.

Bu kadar. Her zamanki gibi sana bol şans!

parseInt () işlev bir dize bağımsız değişkenini çözümler ve belirtilen tabanın (matematiksel sayı sistemlerinde taban) bir tamsayısını döndürür.

Bu etkileşimli örneğin kaynağı bir GitHub deposunda saklanır. Etkileşimli örnekler projesine katkıda bulunmak isterseniz, lütfen https://github.com/mdn/interactive-examples klonlayın ve bize bir istek gönderin.

Sözdizimi

parseInt (dize, radix)

Parametreler

dize Ayrıştırılacak değer. Bu bağımsız değişken bir dizge değilse, ToString özet işlemi kullanılarak birine dönüştürülür. Bu argümandaki baştaki boşluk yok sayılır. radix İsteğe Bağlı Dizenin tabanını (matematiksel sayı sistemlerindeki taban) temsil eden 2 ile 36 arasında bir tamsayı. Dikkatli olun, bu yapar değil varsayılan olarak 10! , Taban sağlanmadığında ne olacağını daha ayrıntılı olarak açıklar.

Geri dönüş değeri

Verilen dizeden ayrıştırılan bir tamsayı.

Taban 11'den küçükse ve boşluk olmayan ilk karakter sayıya dönüştürülemiyorsa, NaN döndürülür.

Açıklama

ParseInt işlevi, ilk argümanını bir dizeye dönüştürür, bu dizeyi ayrıştırır ve ardından bir tamsayı veya NaN döndürür.

NaN değilse, dönüş değeri, belirtilen tabanda bir sayı olarak alınan ilk argüman olan tamsayı olacaktır. (Örneğin, 10'luk bir tabanda ondalık bir sayı, 8 sekizlik tabandan, 16 onaltılık sayıdan dönüştürülür vb.)

10'un üzerindeki radisler için, İngilizce alfabenin harfleri 9'dan büyük sayıları gösterir. Örneğin, onaltılık sayılar için (16 tabanı), A'dan F'ye kadar kullanılır.

ParseInt, belirtilen tabanda sayı olmayan bir karakterle karşılaşırsa, onu ve sonraki tüm karakterleri yok sayar ve o noktaya kadar ayrıştırılan tamsayı değerini döndürür. parseInt, sayıları tam sayı değerlerine kısaltır. Baştaki ve sondaki boşluklara izin verilir.

Çünkü bazı sayılar dize gösterimlerinde e karakterini kullanır (ör. 6.022e23 6.022 × 10 23 için), sayıları kesmek için parseInt kullanmak çok büyük veya çok küçük sayılarda kullanıldığında beklenmedik sonuçlar üretecektir. parseInt gerekir değil Math.floor () yerine kullanılabilir.

parseInt tam olarak iki işareti anlar: pozitif için + ve - negatif için (ECMAScript 1'den beri). Beyaz boşluk kaldırıldıktan sonra ayrıştırmada ilk adım olarak yapılır. Herhangi bir işaret bulunmazsa, algoritma aşağıdaki adıma geçer; aksi takdirde, işareti kaldırır ve dizenin geri kalanında sayı çözümlemeyi çalıştırır.

Sayı tabanı tanımlanmamışsa, 0 ise veya belirtilmemişse, JavaScript aşağıdakileri varsayar:

1. Girdi dizesi "0x" veya "0X" ile başlıyorsa (sıfır, ardından küçük veya büyük X), tabanın 16 olduğu varsayılır ve dizenin geri kalanı onaltılık sayı olarak ayrıştırılır.
2. Giriş dizesi "0" (sıfır) ile başlıyorsa, tabanın 8 (sekizlik) veya 10 (ondalık) olduğu varsayılır. Tam olarak hangi tabanın seçildiği uygulamaya bağlıdır. ECMAScript 5, 10 (ondalık) meli kullanılabilir, ancak henüz tüm tarayıcılar bunu desteklemiyor. Bu yüzden, parseInt kullanırken her zaman bir taban belirtin.
3. Girdi dizesi başka herhangi bir değerle başlıyorsa, radix 10'dur (ondalık).

İlk karakter sayıya dönüştürülemiyorsa, parseInt, radix 10'dan büyük olmadığı sürece NaN'yi döndürür.

Aritmetik amaçlar için, NaN değeri herhangi bir tabandaki bir sayı değildir. ParseInt sonucunun NaN olup olmadığını belirlemek için isNaN işlevini çağırabilirsiniz. NaN aritmetik işlemlere aktarılırsa, işlem sonucu da NaN olacaktır.

Bir sayıyı belirli bir tabandaki değişmez dizesine dönüştürmek için, thatNumber .toString (radix) kullanın.

Örnekler

ParseInt kullanma

Aşağıdaki örneklerin tümü 15 değerini döndürür:

ParseInt ("0xF", 16) parseInt ("F", 16) parseInt ("17", 8) parseInt (021, 8) parseInt ("015", 10) // ama `parseInt (015, 10)` olacak return 13 parseInt (15.99, 10) parseInt ("15.123", 10) parseInt ("FXX123", 16) parseInt ("1111", 2) parseInt ("15 * 3", 10) parseInt ("15e2", 10) parseInt ("15px", 10) parseInt ("12", 13)

Aşağıdaki örneklerin tümü NaN döndürür:

ParseInt ("Merhaba", 8) // Hiçbir sayı değil parseInt ("546", 2) // 0 veya 1 dışındaki rakamlar ikili radix için geçersizdir

Aşağıdaki örneklerin tümü -15 döndürür:

ParseInt ("- F", 16) parseInt ("- 0F", 16) parseInt ("- 0XF", 16) parseInt (-15.1, 10) parseInt ("- 17", 8) parseInt ("- 15", 10) parseInt ("- 1111", 2) parseInt ("- 15e1", 10) parseInt ("- 12", 13)

Aşağıdaki örneklerin tümü 4 değerini döndürür:

ParseInt (4.7, 10) parseInt (4.7 * 1e22, 10) // Çok büyük sayı 4'e dönüşür parseInt (0.00000000000434, 10) // Çok küçük sayı 4 olur

Aşağıdaki örnek 224 değerini döndürür:

ParseInt ("0e0"; 16) parseInt ("123_456") // 123

Tabansız sekizli yorumlar

ECMAScript 3 tarafından önerilmemesine ve ECMAScript 5 tarafından yasaklanmasına rağmen, birçok uygulama, başında 0 ile başlayan sayısal bir dizeyi sekizlik olarak yorumlar. Aşağıdakilerin sekizlik bir sonucu olabilir veya ondalık bir sonucu olabilir. Her zaman bir taban belirtin bu güvenilmez davranıştan kaçınmak için.

ParseInt ("0e0") // 0 parseInt ("08") // 0, çünkü "8" sekizlik bir rakam değil.

ECMAScript 5 sekizlik yorumlamayı kaldırır

ParseInt işlevinin ECMAScript 5 belirtimi, uygulamaların 0 karakteriyle başlayan Dizeleri sekizlik değerler olarak işlemesine artık izin vermemektedir. ECMAScript 5 şunu belirtir:

ParseInt işlevi, belirtilen tabana göre dize bağımsız değişkeninin içeriğinin yorumlanmasıyla dikte edilen bir tamsayı değeri üretir. Dizede baştaki beyaz boşluk yok sayılır. Radix tanımsız veya 0 ise, sayının 0x veya 0X karakter çiftleriyle başlaması dışında 10 olduğu varsayılır, bu durumda 16 radix varsayılır.

Bu, cesaretini kıran ancak sekizlik yorumlamaya izin veren ECMAScript 3'ten farklıdır.

Çoğu uygulama 2013 itibariyle bu davranışı benimsememiştir ve eski tarayıcıların desteklenmesi gerektiğinden, her zaman bir taban belirtin.

Daha katı bir ayrıştırma işlevi

Bazen tam sayıları ayrıştırmanın daha katı bir yolunun olması yararlı olabilir.

Normal ifadeler yardımcı olabilir:

Function filterInt (değer) (if (/ ^ [- +]? (\\ D + | Infinity) $ /. Test (değer)) (dönüş Numarası (değer)) else (dönüş NaN)) console.log (filterInt ("421 ")) // 421 console.log (filterInt (" - 421 ")) // -421 console.log (filterInt (" + 421 ")) // 421 console.log (filterInt (" Infinity ")) // Infinity console.log (filterInt ("421e + 0")) // NaN console.log (filterInt ("421hop")) // NaN console.log (filterInt ("hop1.61803398875")) // NaN console.log (filterInt ("1.61803398875")) // NaN

Teknik Özellikler

Şartname	Durum	Yorum Yap
ECMAScript 1. Baskı (ECMA-262)	Standart	İlk tanım.
ECMAScript 5.1 (ECMA-262)	Standart
ECMAScript 2015 (6. Baskı, ECMA-262) Bu spesifikasyondaki "parseInt" tanımı.	Standart
ECMAScript Son Taslak (ECMA-262) Bu spesifikasyondaki "parseInt" tanımı.	Taslak

Tarayıcı Uyumluluğu

Bu sayfadaki uyumluluk tablosu, yapılandırılmış verilerden oluşturulmuştur. Verilere katkıda bulunmak isterseniz, lütfen https://github.com/mdn/browser-compat-data sayfasına bakın ve bize bir çekme isteği gönderin.

GitHub'da uyumluluk verilerini güncelleyin

	Masaüstü Bilgisayar						Cep Telefonu						Sunucu
	Krom	Kenar	Firefox	Internet Explorer	Opera	Safari	Android web görünümü	Android için Chrome	Android için Firefox	Android için Opera	İOS'ta Safari	Samsung İnternet	Node.js
parseInt	Chrome Tam desteği 1	Edge Tam destek 12	Firefox Tam destek 1	IE Tam destek 3	Opera Tam destek Evet	Safari Tam destek Evet	WebView Android Tam destek 1	Chrome Android Tam desteği 18	Firefox Android Tam destek 4		Safari iOS Tam destek Evet	Samsung Internet Android Tam destek 1.0	nodejs Tam destek Evet
Parses baştaki sıfır dizeleri ondalıktır, sekizlik değil	Chrome Tam desteği 23	Edge Tam destek 12	Firefox Tam destek 21	IE Tam destek 9	Opera Tam destek Evet	Safari Tam destek 6	WebView Android Tam desteği 4.4	Chrome Android Tam desteği 25	Firefox Android Tam destek 21	Opera Android Tam destek Evet	Safari iOS Tam destek 6	Samsung Internet Android Tam destek Evet	nodejs Tam destek Evet

Merhaba sevgili okuyucular. Bugün nasıl dönüştüğünü yazacağım javascript sayı dizesi. Bu, Sayı işlevi kullanılarak yapılır, şimdilik size bir örnekle göstereceğim.
Ayrıca bu makalenin video versiyonunu da izlemenizi öneririm:

Veri türleri hakkında biraz

Bildiğiniz gibi javascript sayısal ve string veri tiplerine sahiptir. Sayıları sakladığımız iki değişken oluşturmaya çalışalım ve ardından sonucu ekranda görüntüleyelim.

Var a \u003d 5; var b \u003d 12; document.write (a + b);

Sonuç ne olacak? 17, tarayıcının bize getirdiği şey buydu. Yani bu sayısal veriler, yani tarayıcı bunu başarıyla ekledi. Şimdi aynı değerleri tırnak içinde koyduğumuz iki değişken daha oluşturalım. Javascript'teki tüm dizelerin tırnak içinde yazıldığını hatırlatmama izin verin.

Var c \u003d "5"; var d \u003d "12"; document.write ("
"+ c + d);

Artık tarayıcı verilerimizi dizeler olarak kabul ediyor ve eğer onları eklersek, o zaman iki satır eklenecek ve 512 elde ediyoruz, bu sayılar eklendiğinde doğru sonuç değil, iki satırı bir araya getirirsek doğrudur.

JavaScript'te bir dizeyi sayıya nasıl dönüştürebilirim?

Burada her şey basit, c ve d değişkenlerine setle aynı değeri yazdığımız, ancak onları Number yönteminden geçirdiğimiz iki değişken daha oluşturalım:

Var e \u003d Sayı (c); var f \u003d Sayı (d); document.write (e + f);

Şimdi bu eklemenin sonucunu ekranda görüntülemeye çalışırsanız, 17 görüntülenecektir Bunun nedeni, yöntemimizin başarılı bir şekilde çalışıp dizeyi bir sayıya dönüştürmesidir. Şöyle yazarsan şunu not etmek isterim:

Document.write ("
"+ e + f);

Ardından ekranda 512 görüntülenecektir çünkü dizeler ve sayılar eklerken HER ZAMAN sonuç bir dizeye dönüştürülür. Bir satır sonu eklemek ve yine de doğru sonucu korumak istiyorsanız, her şeyi iki satırda veya bir satırda şu şekilde yazabilirsiniz:

Document.write ("
"+ (e + f));

Sayıları köşeli parantez içine koyarsanız, dizelere dönüştürülmezler ve özelliklerini başarıyla kaydederler. İşte bugün sahip olduğum çok kısa bir makale. Umarım javascript sizin için biraz daha netleşmiştir.

Bir ifadede hangi tür değişkenin kullanıldığı fark etmez. İfade matematiksel ise, tüm değişkenleri otomatik olarak sayısal olarak yorumlanacaktır. Dizeler işlenirse, ifadenin tüm "katılımcıları" dizeler olarak değerlendirilir. Bununla birlikte, JavaScript dizeden numaraya dönüştürme sorunu çok daha geniş bir bağlamda mevcuttur.

Dizeleri sayılara dönüştürmek için JavaScript yöntemleri

Dizeleri sayılara dönüştürme yöntemlerinin cephaneliği harika değil, ancak tüm basit durumlar için yeterli. Burada JavaScript (özellikle yeni başlayanlar için), pratik örneklerle basitten karmaşığa giden bir yoldur.

İlgileneceksiniz:

Örnek dört farklı satırı açıklamaktadır. İlk çıktı bloğunda, her birinin türü değişken işlev typeof, dizge olarak tanımlanır. Daha sonra her satır çok kolay bir şekilde sayıya dönüştürülür. İkinci çıktı bloğunda, dönüşümden sonra değişkenlerdeki değişiklikleri görebilirsiniz, türleri bir sayı haline gelmiştir. JavaScript parseFloat dönüşümünün bir örneği özellikle açıklayıcıdır: "12e + 3", şimdi "12000" idi.

Bir dizeyi bir sayıya dönüştürürken meydana gelen değişiklikler önemli olabilir! Ancak yalnızca ilk karakterler önemlidir: sayısal olmalıdır. Sayısal karakter yoksa sonuç NaN olur.

Bir sayı "haline gelen" bir dizenin ters dönüşümü her zaman aynı dizge değildir. Bu an, sayısal bilgi girişinin doğruluğunu kontrol etmek için kullanılabilir.

JavaScript'in dizeleri sayılara dönüştürmek için 2 yerleşik işlevi vardır: parseFloat () ve parseInt ().

parseFloat (), sayısal bir türe dönüştürülecek bir dizeyi bağımsız değişken olarak alır ve bir kayan nokta döndürür. Numara satırın başında olmalıdır. Dizede sayıdan sonra başka karakterler varsa bunlar kesilir. Kesirli kısım numaralar nokta ile ayrılmış olarak yazılmalıdır (virgül ayırıcı olarak algılanmaz). ParseFloat () dizeyi dönüştüremiyorsa, NaN döndürür.

Ayrıca, işlev, programlamada genellikle E harfiyle yazılan "n sayısını 10 ile x'in üssüne çarptı" işleyebilir, örneğin: 0.5E6 veya 0.5E + 6. Derece negatif de olabilir: 0.5E-6, bu da 0.5 * 10 ^ -6 veya 0.5 / 1.000.000'e eşittir.

ParseFloat ("" 3.78kg "") // 3.78 parseFloat ("" kg33 "") // NaN parseFloat ("" 0004.111 "") // 4.111 parseFloat ("" 0x66 "") // 0 parseFloat ("". 5 "") // 0.5 parseFloat ("" -. 5 "") // -0.5 parseFloat ("" 0.5e6 "") // 500000 parseFloat ("" 0.03E + 2 "") // 3 parseFloat (" "3E-4" ") // 0.0003 parseFloat (" "- 3E-4" ") // -0.0003

ParseInt (string [, radix]) işlevi bir dizeyi ilk argüman olarak alır, ayrıştırır ve bir tamsayı (tamsayı türü) döndürür. İşlev, orijinal dizedeki sayının yazıldığı sayı sistemini ayrıştırmaya çalışır (örneğin, ondalık, sekizlik veya onaltılık, ancak yalnızca bunlar değil). Sayı sistemini, ikinci parametre tabanı olarak geçirerek de açıkça belirtebilirsiniz. Radix parametresi 2 ile 36 arasında herhangi bir sayıyı alabilir (10'un üzerindeki sistemler A'dan Z'ye İngilizce alfabeyi kullanır).

İşlev, 1.5e6 gibi sayıları parseFloat () ile aynı şekilde işlemez.

ParseInt () işlevinde gizlenen tuzaklara takılıp kalmamak için lütfen aşağıdaki örnekleri okuyun.

ParseInt ("" 25 "") // 25 parseInt ("" - 25 "") // -25 parseInt ("" 45.12 "") // 45 parseInt ("" 045 "", 10) // 45 parseInt ( "" 70 "", 8) // 56 (sekizlik tabanda 70, onluk tabanda 56'dır) parseInt ("" 070 "") // 56 (ÖNEMLİ !!! ilk sıfır, fonksiyonun dizeyi sekizlik sayı olarak ayrıştırmasına neden olur) parseInt (" "88" ", 8) // NaN (sekizlik sistemde 8 yok) parseInt (" "a1" ") // NaN (ÖNEMLİ !!! Başına eklemezseniz, işlev varsayılan olarak bir sayıyı onaltılık olarak değerlendirmez satırlar 0x) parseInt ("" a1 "", 16) // 161 (sayı sistemi burada açıkça belirtilmiştir) parseInt ("" 0xa1 "") // 161 (onaltılık biçimi doğru, ikinci parametreyi atlayabilirsiniz) parseInt ( "" 099 "") // 0 (ÖNEMLİ !!! Sayı sekizlik olarak yorumlanır, ancak geçersiz karakterler içerir) parseInt ("" 0.5e6 "") // 0 (ÖNEMLİ !!! parseFloat olarak çalışmaz) parseInt ("" ZZ "", 36) // 1295 ayrıştırmaInt ("" - FF "") // NaN ayrıştırma ("" - FF "", 16) // -255

Kullanıcının girdiği bir metin alanındaki verileri işliyorsanız, her zaman ikinci radix parametresiyle parseInt () kullanın, bu, kodunuzu beklenmedik sonuçlardan koruyacaktır.