Merhaba JavaScript severler. Bu dilin çok sıra dışı olduğunu ve her bölümde kendine has özellikleri ve sıra dışı teknik çözümleri ile öne çıktığını fark etmişsinizdir. Bu nedenle, bugünün gönderisi şu konuya ayrılmıştır: "JavaScript yuvarlama".

Bu makaleyi okuduktan sonra sayıları neden yuvarlamamız gerektiğini, js'deki hangi metot ve özelliklerin bu işlevi yerine getirdiğini ve 0'a bölmenin ne kadar öne çıktığını öğreneceksiniz.İlkelerimi değiştirmeden, püf noktalarına örnekler ekleyeceğim. materyal ve her eylemi ayrıntılı olarak açıklayın. Şimdi öğrenmeye başlayalım!

Sayılarla ilgili önemli notlar

İlk olarak, js'de her türlü sayının (kesirler ve tam sayılar) şu tipte olduğunu unutmayın. Numara... Ayrıca, IEEE-754 standardı olarak da bilinen "çift duyarlık" biçiminde depolandıkları için hepsi 64 bittir.

Sayısal değişkenler olağan şekilde oluşturulur:

var hissiz = 35; // doğal sayı

var drob = 0.93; // ondalık gösterim

var uyuşma16 = 0xFF; // onaltılık sayı sistemi

Diğer sayısal gösterimleri de destekler. Böylece, yine de kayan noktalı sayılar oluşturabilirsiniz (bunlara bazen "bilimsel biçimde sayılar" da denir).

Çok ilginç bir yöntem için destek var toLocaleString (), tüm sayısal parametreleri ECMA 402'de belirtilen özelliklere göre biçimlendirir. Bu sayede büyük sayılar, telefon numaraları, para birimleri ve hatta yüzdeler iletişim kutusunda güzel bir şekilde görüntülenir.

var sayı = 714000.80;

uyarı (num.toLocaleString());

Number türündeki öğelerle çalışmak için, tüm küresel bir nesneye, adı şu şekilde olan bir dizi her türlü matematiksel işlev sağlandı. Matematik.

Ek olarak, sayısal değerleri tam sayılara, ondalıklara, yüzdeliklere vb. Yuvarlayan başka yöntemler de vardır. Hepsini daha ayrıntılı olarak ele alalım.

Büyük ve güçlü Matematik

Global Math nesnesi, çok çeşitli matematiksel ve trigonometrik işlevler içerir. Bu çok kullanışlı bir nesnedir ve genellikle geliştiricilere dijital verilerle çalışırken yardımcı olur.

Diğer platformlarda Math için analojiler var. Örneğin Java ve C# gibi popüler dillerde Math, aynı standart işlevlerin tümünü destekleyen bir sınıftır. Gördüğünüz gibi, bu enstrüman gerçekten harika ve güçlü.

Şimdi belirli yuvarlama yöntemlerinden geçmek ve onlar hakkında ayrıntılı olarak konuşmak istiyorum.

Matematik.kat ()

ile başlayacağım Matematik.zemin... Yöntemin adına dikkat edin. Mantıksal olarak, yuvarlamadan bahsettiğimiz ve "zemin" kelimesinin gerçek çevirisinin "zemin" anlamına geldiği için, bu aracın işlenmiş değerleri aşağı doğru yuvarlayacağı açıktır.

Bu fonksiyon kullanılarak işlenen numaranın aynı kalması da mümkündür. Bunun nedeni, yuvarlamanın katı olmayan bir eşitsizliğe göre yapılmasıdır (<=). Таким образом, при отработке этой строчки кода:

uyarı (Math.floor (4.5));

cevap 4 numara olacak.

Matematik.ceil ()

Yine isme bakın (bu şekilde malzeme daha hızlı emilir). Bilmiyorsa tavan tavan demektir. Bu, sayısal verilerin gevşek bir eşitsizlik (> =) kullanılarak yuvarlanacağı anlamına gelir.

uyarı (Math.ceil (4.5));

Tahmin edebileceğiniz gibi, cevap 5 numara olacak.

Matematik turu ()

Bu yöntem, kesirli sayıyı en yakın tam sayıya yuvarlar. Bu nedenle, kesirli kısım 0 ile 0,5 aralığındaysa (dahil değil), aşağı yuvarlama gerçekleşir. Kesirli kısım, 0,5'ten sonraki tam sayıya kadar olan aralıktaysa, daha büyük tam sayıya yuvarlanır.

uyarı (Math.round (4.5));

Umarım herkes doğru cevabı düşünmüştür veya söylemiştir - 5.

Birkaç yöntem daha

JavaScript'te ayrıca sayısal gösterimlerin yuvarlanmasıyla ilgilenen 2 yöntem daha vardır. Ancak, biraz farklıdırlar.

Gibi araçlar hakkında olacak tamir edildi () ve toPrecision ()... Sadece yuvarlamadan değil, belirli işaretlere olan doğruluğundan da sorumludurlar. Daha derine inelim.

tamir edildi ()

Bu mekanizmayı kullanarak, değerin kaç ondalık basamağa yuvarlanacağını belirleyebilirsiniz. Yöntem, sonucu bir dize olarak döndürür. Aşağıda üç farklı varyantı olan bir varyant ekledim. Aldığınız cevapları analiz edin.

var sayı = 5656.9393;

belge.writeln (sayıdan Sabit ()); // 5657

belge.writeln (Sayıdan Sabit (2)); // 5656.94

belge.writeln (Sayıya Sabit (7)); // 5656.9393000

Gördüğünüz gibi, bir argüman belirtmezseniz, toFixed ()) kesirli değeri yuvarlayacaktır. bütüne sayılar. Üçüncü satır yuvarlanır 2 karaktere kadar, ve dördüncüsü - "7" parametresi nedeniyle üç tane daha 0 eklendi.

toPrecision ()

Bu yöntem biraz farklı bir şekilde çalışır. Argüman yerine boş bir alan bırakabilir veya bir parametre ayarlayabilirsiniz. Ancak, ikincisi, virgülü yok sayarak sayıları belirtilen basamak sayısına yuvarlar. İşte önceki örnekten yeniden yazılan programın sonuçları:

var sayı = 5656.9393;

belge.writeln (num.toPrecision()); // 5656.9393

document.writeln (num.toPrecision (2)); // 5.7e + 3

document.writeln (num.toPrecision (7)); // 5656.939

js'de 0'a bölme özelliği

Matematik derslerinden bildiğiniz gibi sıfıra bölemezsiniz. Bu kural, programlama dillerinin yaratıcılarının çoğu tarafından temel alınmıştır. Bu nedenle, sıfıra bölündüğünde tüm programlar bir hata üretir.

Ancak JavaScript burada da kendini farklılaştırmıştır. Bu nedenle, böyle bir işlemin yürütülmesi sırasında hiçbir hata mesajı görünmez ... çünkü böyle bir işlem geri döner "Sonsuzluk"!

Neden böyle? Aynı matematik bilimlerinden bildiğiniz gibi, bölen ne kadar küçükse sayı o kadar büyüktür. Bu nedenle, bu prototip odaklı dilin yaratıcıları, şablonları terk etmeye ve kendi yollarına gitmeye karar verdiler.

Infinity'nin değeriyle ilk karşılaşanlar için aşağıda özelliklerini anlattım.

Sonsuzluk - sonsuzluk anlamına gelir ve ∞ matematiksel işaretine tamamen karşılık gelir.

Negatif olabilir. Aritmetik operatörlerle çalışmak için tüm standart kurallar da korunur.

uyarı (12/0); // Sonsuzluk

uyarı (12.34 / 0); // Sonsuzluk

uyarı (-3 / 0); // -Sonsuz

Bu konuda, belki ve bitirin. Yayını beğendiyseniz, bloguma abone olduğunuzdan emin olun. İlginç makalelere bağlantı vererek açgözlü olmayın ve arkadaşlarınızla paylaşın. Güle güle!

JavaScript matematiği, 2 ondalık basamağa yuvarlama (9)

Aşağıdaki JavaScript sözdizimine sahibim:

Var indirim = Math.round (100 - (fiyat / liste fiyatı) * 100);

Bu, en yakın tam sayıya yuvarlanır. İki ondalık basamaklı bir sonucu nasıl döndürebilirim?

İşte çalışan bir örnek

Var değeri = 200.2365455; sonuç = Math.round (değer * 100) / 100 // sonuç 200,24 olacaktır

Herhangi bir sayıda ondalık basamağa yuvarlamayı işlemek için, çoğu ihtiyaç için 2 satır kodlu bir işlev yeterli olacaktır. İşte oyun için bazı örnek kodlar.

Var testNum = 134.9567654; var decPl = 2; var testRes = roundDec (testNum, decPl); uyarı (testNum + "yuvarlatılmış" + decPl + "ondalık basamaklar" + testRes); function roundDec (nbr, dec_places) (var mult = Math.pow (10, dec_places); dönüş Math.round (nbr * multi) / multi;)

Bulduğum en iyi ve en basit çözüm

Yuvarlak fonksiyon (değer, ondalık sayılar) (dönüş Sayı (Math.round (değer + "e" + ondalık sayılar) + "e -" + ondalık sayılar);) yuvarlak (1.005, 2); // 1.01

Kabul edilen cevapta küçük bir değişiklik. toFixed (2) bir dize döndürür ve her zaman iki ondalık basamak alırsınız. Bunlar sıfır olabilir. Sondaki sıfırları bastırmak istiyorsanız, şunu yapın:

Var indirim = + ((fiyat / liste fiyatı) .toSabit (2));

Düzenlendi: Firefox 35.0.1'de bir hata gibi görünen şeyi keşfettim, yani yukarıdakiler NaN'a bazı değerler verebilir.
kodumu şöyle değiştirdim

Var indirim = Math.round (fiyat / liste fiyatı * 100) / 100;

Bu, sayıyı iki ondalık basamağa verir. Üçe ihtiyacınız varsa, 1000 ile çarpacak ve böleceksiniz, vb.
OP her zaman iki ondalık basamak ister, ancak Firefox'ta toFixed () bozulursa, önce düzeltilmesi gerekir.
https://bugzilla.mozilla.org/show_bug.cgi?id=1134388 adresine bakın.

Sonucu iki ondalık basamakla almak için aşağıdakileri yapabilirsiniz:

Var indirim = Math.round ((100 - (fiyat / liste fiyatı) * 100) * 100) / 100;

Yuvarlanacak değer ilk iki basamağı tutmak için 100 ile çarpılır, ardından gerçek sonucu elde etmek için 100'e bölünür.

Gördüğüm en iyi yol, basamak sayısını 10 ile çarpmak, sonra Math.round yapmak ve son olarak da basamak sayısını 10'a bölmek. TypeScript'te kullandığım basit bir işlev:

RoundToXDigits işlevi (değer: sayı, basamak: sayı) (değer = değer * Math.pow (10, basamak); değer = Math.round (değer); değer = değer / Math.pow (10, basamak); dönüş değeri; )

Veya basit javascript:

fonksiyon roundToXDigits (değer, rakamlar) (if (! Rakamlar) (rakamlar = 2;) değer = değer * Math.pow (10, basamak); değer = Math.round (değer); değer = değer / Math.pow (10 , basamak); dönüş değeri;)

NOT. - 3 basamaklı hassasiyet önemliyse Düzenleme 4'e bakın.

Var indirim = (fiyat / liste fiyatı) .toSabit (2);

2 ondalık basamaktan büyük değerlere göre sizin için yukarı veya aşağı yuvarlamalar düzeltildi.

Değişiklik. Başkaları tarafından belirtildiği gibi, bu sonucu bir dizgeye dönüştürecektir. Bundan kaçınmak için:

Var indirim = + ((fiyat / liste fiyatı) .toSabit (2));

2'yi düzenleme- Yorumlarda belirtildiği gibi, bu işlev belirli bir hassasiyetle yürütülmez, örneğin 1.005 olması durumunda 1.01 yerine 1.00 döndürür. Doğruluk çok önemliyse, şu yanıtı buldum: https://.com/a/32605063/1726511 Denediğim tüm testlerle iyi çalışıyor gibi görünüyor.

Küçük bir değişiklik gereklidir, ancak yukarıdaki yanıttaki işlev bire yuvarlandığında tamsayılar döndürür, bu nedenle örneğin 99.004, fiyatları görüntülemek için ideal olmayan 99,00 yerine 99 döndürür.

3'ü düzenle- Görünüşe göre gerçek dönüşte sabitlenmiş STILL bazı sayıları büküyordu, bu son düzenleme işe yarıyor gibi görünüyor. Tanrım, çok fazla tazminat!

Var indirim = roundTo ((fiyat / liste fiyatı), 2); function roundTo (n, basamak) (if (rakam === tanımsız) (rakam = 0;) var çarpan = Math.pow (10, basamak);n = parseFloat ((n * çarpan) .toFixed (11); var test = (Math.round (n) / çarpan); return + (test.toFixed (rakamlar));)

4'ü düzenle"Beni öldürüyorsunuz çocuklar. Düzenleme 3, negatif sayıyı yuvarlamadan önce pozitif yapmanın ve ardından sonucu döndürmeden önce geri koymanın neden daha kolay olduğunu araştırmadan negatif sayılarda başarısız olur.

İşlev roundTo (n, basamak) (var negatif = yanlış; if (rakam === tanımsız) (rakam = 0;) if (n< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

en hızlı yol- toFixed'den () daha hızlı:

İKİ DEKALİYET

x = .123456 sonuç = Math.round (x * 100) / 100 // sonuç .12

ÜÇ ONDALIK

x = .123456 sonuç = Math.round (x * 1000) / 1000 // sonuç .123

fonksiyon round (sayı, dec) (sayı = Math.round (sayı + "e" + aralık) dönüş Sayısı (sayı + "e -" + aralık)) // Seçtiğiniz bir ondalık sayıya yuvarlayın: yuvarlak (1.3453,2) )

Merhaba. Bugün Javascript'teki sütunda, javascript'te kayan noktalı sayılarda ondalık basamak sayısının nasıl ayarlanacağına bakacağız. Örneğin, çıktıda 3 veya yalnızca iki ondalık basamak bırakmanız gerekir.

Sorun: javascript ondalık basamakları

Yani, bir görevle karşı karşıyayız: ondalık noktadan önce ve ondalık noktadan sonra sayıların olduğu bir hesaplama sonucu var. Ondalık. Diyelim ki sonuç böyle 1538.989100153. Ancak para çekerken, ondalık noktadan önce banknot sayısı ve sonra - kopek olan miktarı yansıtan bir sayı almalısınız.

Bu sorunu çözmenin birkaç yolu vardır.

Çözüm 1: toFixed yöntemini kullanarak javascript ondalık basamakları

toFixed, yuvarlama hassasiyetini (yani ondalık basamak sayısını) parametre olarak alarak herhangi bir sayıya uygulanan yerleşik bir javascript yöntemidir.

Var num = 1538.989100153; num_str = num.toSabit (); // say_str = 1538; num_str = num.toSabit (2); //num_str=1538.98; num_str = num.toSabit (5); //num_str=1538.98912;

Bu fonksiyondaki kesinlik parametresi 0'dan az (negatif değerleri kabul etmez) ve 20'den fazla olmamalıdır.

Bir değişken olmadan da yapabilirsiniz, örneğin şöyle:

Num_str = (1538.9891200153) .toSabit (2); //num_str=1538.98;

Çözüm 2: toPrecision yöntemini kullanarak javascript ondalık basamakları

Bu çözüm, aynı yerleşik javascript yöntemini temel alır. Bu yöntemin ayırt edici bir özelliği, girdi olarak alınan parametrenin kesinlik (ondalık noktadan sonraki basamak sayısı) değil, toplam basamak sayısı (ondalık noktadan önce ve sonra) anlamına gelmesidir.

Var num = 1538.989100153; num_str = num.toPrecision (5); //num_str=1538.9; num_str = num.toPrecision (7); //num_str=1538.989;

Ondalık basamak çözümü: javascript ondalık basamak sayısı

Ondalık basamakları tamamen atmanız gerekiyorsa, yani kesirli sayıyı bir tam sayıya yuvarlamanız gerekiyorsa, o zaman Math sınıfının işlevlerini kullanabilirsiniz: yuvarlak, tavan ve zemin.
Yuvarlak - yukarı veya aşağı yuvarlar (sayıya bağlı olarak). Ondalık noktadan sonraki değer yarıdan fazlaysa yukarı, daha azsa aşağı yuvarlar. Yani, eğer 0,51 - 0,49 - 0 ise 1 olur.

Tavan - İngilizceden. tavan her zaman yukarı yuvarlanır.

Zemin - İngilizceden. zemin her zaman aşağı yuvarlanır.

Var num = 1538.989100153; num_str = Math.round (sayı); // say_str = 1539; num_str = Math.floor (sayı); // say_str = 1538; num_str = Math.ceil (sayı); // say_str = 1539;

Bu kadar. Umarım bu yazı sorunu çözmenize yardımcı olmuştur. Bir şey yolunda gitmediyse - "Bir uzmana soru sorun" yeşil düğmesini kullanarak veya yorumlarda sorular sorun.

Hesaplamalar genellikle istenen aralıkların dışında kalan sonuçlar üretir. Sonuç olarak, yapmanız gereken JavaScript yuvarlama belirli bir değere.

Rakamlar neden yuvarlanır?

JavaScript tamsayıları saklamaz çünkü değerleri kayan nokta sayıları olarak temsil edilir. Birçok kesir sınırlı sayıda ondalık basamakla temsil edilemez, bu nedenle JavaScript aşağıdaki gibi sonuçlar üretebilir:

0.1 * 0.2; > 0.020000000000000004

Pratikte 2 kentilyonluk bir hatadan bahsettiğimiz için bu bir fark yaratmayacaktır. Ancak bu, para birimi değerlerini, yüzdeleri veya dosya boyutunu temsil eden sayılarla çalışırken sonucu etkileyebilir. Bu nedenle, yapmanız veya belirli bir ondalık basamağa ihtiyacınız var.

Ondalık sayıları yuvarlama

Bir ondalık sayıyı "kırpmak" için toFixed () veya toPrecision () yöntemlerini kullanın. Her ikisi de sonuca dahil edilecek önemli ve ondalık basamak sayısını belirten bir argüman alır:

• toFixed () için herhangi bir bağımsız değişken belirtilmemişse, varsayılan değer 0'dır, yani ondalık basamak yoktur; argümanın maksimum değeri 20'dir;
• toPrecision () için herhangi bir bağımsız değişken belirtilmemişse, sayı değişmez.

var randNum = 6.25; randNum.toSabit (); > "6" Math.PI.toPrecision (1); > "3" var randNum = 87.335; randNum.toSabit (2); > "87.33" var randNum = 87.337; randNum.toPrecision (3); > "87,3"

Not

Hem toFixed () hem de toPrecision, bir sayı değil, sonucun yuvarlatılmış bir dize temsilini döndürür. Bu, randNum'a yuvarlatılmış eklemenin tek bir sayı yerine dize bitiştirmeyle sonuçlanacağı anlamına gelir:

konsol.log (randNum + yuvarlatılmış); > "6.256"

JavaScript'in en yakın yüzdeliğe yuvarlanmasını istiyorsanız, parseFloat() kullanın:

var randNum = 6.25; var yuvarlatılmış = parseFloat (randNum.toFixed (1)); konsol.log (yuvarlak); > 6.3

toFixed() ve toPrecision() ayrıca çok sayıda ondalık basamağı kesmek için kullanışlı yöntemlerdir. Bu, para birimlerini temsil eden sayılarla çalışırken yararlıdır:

var bütünNum = 1 var dolarCents = bütünNum.toFixed (2); konsol.log (dolar sent); > "1.00"

Sayıda kesinlik parametresi tarafından belirtilenden daha fazla basamak varsa, toPrecision'ın sonucu bilimsel biçimde döndüreceğini unutmayın:

var num = 123.435 num.toPrecision (2); > "1.2e + 2"

Ondalık kesirleri yuvarlarken hatalardan nasıl kaçınılır

Bazı durumlarda toFixed ve toPrecision uygulaması JavaScript yuvarlama 5, ve daha fazlası için değil:

var numTest = 1.005; numTest.toSabit (2); > 1;

Yukarıdaki örnek 1 değil, 1.01 ile sonuçlanmalıdır. Bu hatadan kaçınmanız gerekiyorsa, üstel sayıları kullanmanızı öneririm:

fonksiyon turu (değer, ondalık sayılar) (dönüş Sayısı (Math.round (değer + "e" + ondalık sayılar) + "e -" + ondalık sayılar);)

Uygulama:

yuvarlak (1.005.2); > 1.01

Yuvarlamadan daha güvenilir bir çözüme ihtiyacınız varsa, şu adreste mevcuttur: MDN.

Epsilon yuvarlama

alternatif yöntem JavaScript'i onda birine yuvarlama ES6'da tanıtıldı ( JavaScript 2015 olarak da bilinir). « makine epsilon»İki kayan noktalı sayıyı karşılaştırırken makul bir hata payı sağlar. Yuvarlama olmadan, karşılaştırmalar aşağıdakine benzer sonuçlar verebilir:

0.1 + 0.2 === 0.3> yanlış

Math.EPSILON, doğru bir karşılaştırma elde etmek için bir işlevde kullanılabilir:

işlev epsEqu (x, y) (Math.abs (x - y) döndürür< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

İşlev iki argüman alır: biri hesaplamaları içerir, ikincisi beklenen (yuvarlak) sonuçtur. Bu iki parametrenin bir karşılaştırmasını döndürür:

epsEqu (0,1 + 0,2, 0,3)> doğru

Tüm modern tarayıcılar ES6 matematik işlevlerini destekler. Ancak eski tarayıcılarda destek sağlamanız gerekiyorsa, çoklu dolgu kullanmanız gerekir.

Ondalık sayıları kesme

Daha önce sunulan tüm yöntemler, JavaScript'i onda birine yuvarlama... Pozitif bir sayıyı iki ondalık basamağa kesmek için 100 ile çarpın, tekrar kısaltın ve sonucu 100'e bölün:

işlev kesildi (sayı) (dönüş Math.trunc (sayı * 100) / 100;) kesildi (3.1416)> 3.14

Daha esnek bir şeye ihtiyacınız varsa, bitsel operatörü kullanabilirsiniz:

işlev kesildi (num, decimalPlaces) (var numPowerConverter = Math.pow (10, decimalPlaces); dönüş ~~ (num * numPowerConverter) / numPowerConverter;)

Kullanım:

var randInt = 35.874993; kesilmiş (randInt, 3); > 35.874

En yakın sayıya yuvarlama

yürütmek JavaScript tam sayıya yuvarlama, Math.round () tarafından kullanılır:

Math.round (4.3)> 4 Math.round (4.5)> 5

Bunu not et " yarı değerler“.5 gibi yuvarlanır.

En yakın tam sayıya yuvarlama

Aşağı yuvarlamak istiyorsanız Math.floor () yöntemini kullanın:

Math.floor (42.23); > 42 Math.floor (36.93); > 36

Aşağı yuvarlamanın, negatif olanlar da dahil olmak üzere tüm sayılar için bir yönü vardır. Bu, temel seviyesinin altı da dahil olmak üzere sonsuz sayıda katlı bir gökdelen olarak hayal edilebilir ( negatif sayıları temsil eden). 2. ve 3. bodrum katlar arasında asansörde iseniz ( ki bu -2,5 değerine karşılık gelir), Math.floor sizi 3. kata götürecektir:

Math.floor (-2.5); > -3

Bundan kaçınmanız gerekiyorsa, tüm modern tarayıcılarda desteklenen Math.trunc () ile JavaScript Math yuvarlama kullanın (hariç IE / Kenar):

Math.trunc (-41.43); > -41

MDN ayrıca sağlar Eski tarayıcılarda ve IE / Edge'de Math.trunc desteği sağlamak için 3 satırlı çoklu dolgu.

En yakın tam sayıya yuvarlama

Ondalık sayıları toplamak istiyorsanız Math.ceil kullanın. Bu yöntem aynı zamanda sonsuz bir kaldırma olarak da düşünülebilir: Math.ceil, sayının negatif veya pozitif olmasına bakılmaksızın sizi her zaman alır:

Math.ceil (42.23); > 43 Math.ceil (36.93); > 37 Math.ceil (-36.93); -36

En yakın çarpana yuvarlama

Bir değeri 5'in en yakın katına yuvarlamanız gerekiyorsa, sayıyı 5'e bölen, yuvarlayan ve ardından sonucu aynı değerle çarpan bir işlev oluşturun:

function roundTo5 (sayı) (Math.round'u döndür (sayı / 5) * 5;)

Kullanım:

roundTo5 (11); > 10

İki basamağa yuvarlamak için JavaScript'e ihtiyacınız varsa, işleve hem bir tohum hem de çokluk iletebilirsiniz:

function roundToMultiple (sayı, çoklu) (Math.round'u döndür (sayı / çoklu) * çoklu;)

İşlevi kullanmak için, yuvarlanacak sayıyı ve çokluğu çağrısına ekleyin:

var initialNumber = 11; var çoklu = 10; roundToMultiple (ilkSayı, çoklu); > 10;

Değerleri yalnızca yukarı veya aşağı yuvarlamak için işlevde yuvarlamayı tavan veya zemin ile değiştirin.

Aralık yakalama

Bazen belirli bir aralıkta olması gereken x değerini almanız gerekir. Örneğin, 1 ile 100 arasında bir değere ihtiyacımız var ama 123 değerini alıyoruz. Bunu düzeltmek için min () ( sayıların en küçüğünü döndürür) ve maksimum ( izin verilen maksimum sayıyı döndürür).

Kullanım:

var lowBound = 1; var highBound = 100; var numInput = 123; var kenetli = Math.max (lowBound, Math.min (numInput, highBound)); konsol.log (kenetlenmiş); > 100;

Number sınıfının bir işlevini veya uzantısını oluşturabilirsiniz.

Çoğu zaman, JavaScript'teki hesaplamalar tam olarak istediğimiz sonuçları vermez. Elbette sayılarla her şeyi yapabiliriz - yukarı veya aşağı yuvarlama, aralıkları ayarlama, gereksiz sayıları belirli sayıda ondalık basamağa kesme, bunların hepsi gelecekte bu sayı ile ne yapmak istediğinize bağlıdır.

Yuvarlama neden gereklidir?

JavaScript'in merak uyandıran yönlerinden biri, aslında tamsayıları saklamamasıdır, hemen kayan noktalı sayılarla çalışıyoruz. Bu, birçok kesirli değerin sonlu sayıda ondalık basamakta ifade edilememesi gerçeğiyle birleştiğinde, JavaScript'te şöyle sonuçlar elde edebiliriz:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Pratik amaçlar için, bu yanlışlık hiç önemli değil, bizim durumumuzda kentilyonluk bir hatadan bahsediyoruz, ancak bu birilerini hayal kırıklığına uğratabilir. Para birimlerinin, yüzdelerin veya dosya boyutlarının değerlerini temsil eden sayılarla çalışırken biraz garip bir sonuç alabiliriz. Bu yanlışlıkları düzeltmek için, ondalık kesinliği ayarlamak yeterliyken, sonuçları yuvarlamamız yeterlidir.

Yuvarlama sayıları pratik bir uygulamaya sahiptir, belirli bir aralıktaki bir sayıyı değiştirebiliriz, örneğin değeri en yakın tam sayıya yuvarlamak istiyoruz ve sadece ondalık kısımla çalışmıyoruz.

Ondalık sayıları yuvarlama

Ondalık bir sayıyı çıkarmak için toFixed veya toPrecision yöntemini kullanın. Her ikisi de, sırasıyla, kaç tane anlamlı basamak (yani, sayıda kullanılan toplam basamak sayısı) veya ondalık basamak (ondalık noktadan sonraki sayı) sonucun içermesi gerektiğini belirleyen tek bir argüman alır:

1. Argüman toFixed () için tanımlanmadıysa, varsayılan olarak sıfır olacaktır, bu da 0 ondalık basamak anlamına gelir, argümanın maksimum değeri 20'dir.
2. toPrecision için herhangi bir argüman verilmezse, numaraya dokunulmaz

randNum = 6.25 olsun; randNum.toSabit (); > "6" Math.PI.toPrecision (1); > "3" randNum = 87.335; randNum.toSabit (2); > "87.33" randNum = 87.337; randNum.toPrecision (3); > "87,3"
Hem toFixed () hem de toPrecision (), bir sayı değil, sonucun bir dize temsilini döndürür. Bu, yuvarlanan değer randNum ile toplandığında, sayıların toplamı değil, dizelerin birleştirileceği anlamına gelir:

randNum = 6.25 olsun; yuvarlatalım = randNum.toFixed(); // "6" console.log (randNum + yuvarlatılmış); > "6.256"
Sonucun sayısal bir veri türüne sahip olmasını istiyorsanız, parseFloat kullanmanız gerekir:

randNum = 6.25 olsun; let yuvarlatılmış = parseFloat (randNum.toFixed (1)); konsol.log (yuvarlak); > 6.3
Nadir durumlar dışında 5 değerin yuvarlandığını unutmayın.

toFixed () ve toPrecision () yöntemleri, yalnızca kesirli kısmı çıkarmakla kalmayıp, aynı zamanda para birimiyle çalışırken uygun olan ondalık basamakları da tamamladıkları için yararlıdır:

BütünNum = 1 olsun dolarCents = bütünNum.toFixed (2); konsol.log (dolar sent); > "1.00"
Tam sayıların sayısı kesinliğin kendisinden büyükse, toPrecision'ın sonucu üstel gösterimde vereceğini lütfen unutmayın:

Sayı = 123.435 num.toPrecision (2) olsun; > "1.2e + 2"

Ondalık sayılarla yuvarlama hatalarından nasıl kaçınılır

Bazı durumlarda, toFixed ve toPrecision 5'i aşağı ve yukarı yuvarlar:

numTest = 1.005 olsun; numTest.toSabit (2); > "1.00"
Yukarıdaki hesaplama sonucu 1 değil 1.01 olmalıydı. Bu hatayı önlemek istiyorsanız, Jack L Moore'un önerdiği, üstel sayıları hesaplamak için kullanan çözümü kullanabiliriz:

Fonksiyon turu (değer, ondalık sayılar) (dönüş Sayısı (Math.round (değer + "e" + ondalık sayılar) + "e -" + ondalık sayılar);)
Şimdi:

Tur (1.005.2); > 1.01
Yukarıda gösterilenden daha sağlam bir çözüm istiyorsanız, MDN'ye gidebilirsiniz.

Makine epsilon yuvarlama

ES6'da ondalık sayıları yuvarlamak için alternatif bir yöntem tanıtıldı. Makine epsilon yuvarlaması, iki kayan noktalı sayıyı karşılaştırırken makul bir hata payı sağlar. Yuvarlama olmadan, karşılaştırmalar aşağıdakine benzer sonuçlar verebilir:

0.1 + 0.2 === 0.3> yanlış
Doğru karşılaştırmayı elde etmek için fonksiyonumuzda Math.EPSILON kullanıyoruz:

epsEqu (x, y) işlevi (Math.abs (x - y) döndürür)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
İşlev iki argüman alır: ilki mevcut hesaplama, ikincisi ise beklenen sonuçtur. İkisinin bir karşılaştırmasını döndürür:

EpsEqu (0,1 + 0,2, 0,3)> doğru
Tüm modern tarayıcılar zaten ES6 matematik işlevlerini destekler, ancak IE 11 gibi tarayıcılarda destek istiyorsanız çoklu dolgu kullanın.

kesirli kırpma

Yukarıda sunulan tüm yöntemler, ondalık sayılara nasıl yuvarlanacağını bilir. Sayıyı iki ondalık basamağa kesmek için önce 100 ile çarpmanız ve ardından sonucu 100'e bölmeniz gerekir:

İşlev kısaltıldı (sayı) (dönüş Math.trunc (num * 100) / 100;) kısaltıldı (3.1416)> 3.14
Herhangi bir sayıda ondalık basamağa yerleştirmek istiyorsanız, çift bit düzeyinde olumsuzlamayı kullanabilirsiniz:

İşlev kesildi (num, decimalPlaces) (let numPowerConverter = Math.pow (10, decimalPlaces); dönüş ~~ (num * numPowerConverter) / numPowerConverter;)
Şimdi:

randInt = 35.874993 olsun; kesilmiş (randInt, 3); > 35.874

En yakın sayıya yuvarlama

Bir ondalık sayıyı yukarı veya aşağı yuvarlamak için, hangisi en yakınsa, Math.round() öğesini kullanın:

Math.round (4.3)> 4 Math.round (4.5)> 5
"Yarı değerin" 0,5'in matematik kurallarına göre yuvarlandığına dikkat edin.

En yakın tam sayıya yuvarlama

Her zaman aşağı yuvarlamak istiyorsanız Math.floor'u kullanın:

Math.floor (42.23); > 42 Math.floor (36.93); > 36
Negatif olanlar da dahil olmak üzere tüm sayılar için aşağı yuvarlamanın işe yaradığını unutmayın. Alt kattakiler de dahil (negatif sayıları temsil eden) sonsuz sayıda katı olan bir gökdelen hayal edin. Asansörün alt katında 2 ile 3 arasında (ki bu -2,5 değerindedir) ise Math.floor sizi -3'e indirecektir:

Math.floor (-2.5); > -3
Ancak bu durumdan kaçınmak istiyorsanız, tüm modern tarayıcılarda (IE/Edge hariç) desteklenen Math.trunc'u kullanın:

Math.trunc (-41.43); > -41
MDN üzerinde, tarayıcılarda ve IE/Edge'de Math.trunc desteği sağlayacak bir çoklu dolgu bulacaksınız.

En yakın tam sayıya yuvarlama

Öte yandan, her zaman toplamanız gerekiyorsa Math.ceil'i kullanın. Yine, sonsuz artışı hatırlayalım: Math.ceil, sayının negatif olup olmadığına bakılmaksızın her zaman yukarı çıkacaktır:

Math.ceil (42.23); > 43 Math.ceil (36.93); > 37 Math.ceil (-36.93); > -36

Gerektiğinde yukarı / aşağı yuvarlama

5'in en yakın katına yuvarlamak istiyorsak, en basit yol bir sayıyı 5'e bölen, yuvarlayan ve sonra aynı miktarla çarpan bir fonksiyon oluşturmaktır:

RoundTo5 (sayı) işlevi (dönüş Math.round (sayı / 5) * 5;)
Şimdi:

RoundTo5 (11); > 10
Değerinizin katlarına yuvarlamak istiyorsanız, daha genel bir işlev kullanırız, bir başlangıç ​​değeri ve bir kat geçirerek:

roundToMultiple (sayı, çoklu) işlevi (Math.round'u (sayı / çoklu) * çoklu döndür;)
Şimdi:

initialNumber = 11 olsun; çoklu = 10 olsun; roundToMultiple (ilkSayı, çoklu); > 10;

Bir aralıktaki bir sayıyı sabitleme

Bir aralıkta x almak istediğimiz birçok durum vardır. Örneğin, 1 ile 100 arasında bir değer isteyebiliriz, ancak 123 değerini aldık. Bunu düzeltmek için min (bir sayı kümesinin en küçüğünü döndürür) ve max (herhangi bir sayı kümesinin en büyüğünü döndürür) kullanabiliriz. ). Örneğimizde, aralık 1 ile 100 arasındadır:

lowBound = 1 olsun; yüksekBound = 100 olsun; numInput = 123 olsun; let kenetlenmiş = Math.max (lowBound, Math.min (numInput, highBound)); konsol.log (kenetlenmiş); > 100;
Yine, işlemi yeniden kullanabilir ve her şeyi bir fonksiyona sarabiliriz, hadi Daniel X tarafından önerilen çözümü kullanalım. Moore:

Number.prototype.clamp = fonksiyon (min, maks) (dönüş Math.min (Math.maks (bu, min), maks););
Şimdi:

NumInput.clamp (düşükBound, yüksekBound); > 100;

Gauss yuvarlaması

Yuva yuvarlama olarak da bilinen Gauss yuvarlaması, yuvarlamanın en yakın çifte gerçekleştiği yerdir. Bu yuvarlama yöntemi istatistiksel hata olmadan çalışır. En iyi çözüm Tim Down tarafından önerildi:

gaussRound (num, decimalPlaces) işlevi (let d = decimalPlaces || 0, m = Math.pow (10, d), n = + (d? Num * m: num) .toSabit (8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f> 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Şimdi:

GaussRound (2.5)> 2 gaussRound (3.5)> 4 gaussRound (2.57,1)> 2,6
CSS'de ondalık nokta:

JavaScript genellikle HTML öğelerinin konumsal dönüşümlerini oluşturmak için kullanıldığından, öğelerimiz için ondalık değerler oluşturduğumuzda ne olacağını merak edebilirsiniz:

#kutu (genişlik: 63.667731993 piksel;)
İyi haber şu ki, modern tarayıcılar, yüzde veya piksel birimleri dahil olmak üzere kutu modelindeki ondalık değerleri dikkate alacaktır.

sıralama

Çoğu zaman bazı öğeleri sıralamamız gerekir, örneğin, bir dizi oyun kaydımız var ve bunlar oyuncuların sıralamasına göre azalan düzende düzenlenmelidir. Ne yazık ki, standart sıralama () yönteminin bazı şaşırtıcı sınırlamaları vardır: yaygın olarak kullanılan İngilizce sözcüklerle iyi çalışır, ancak sayılar, benzersiz karakterler veya büyük harflerle karşılaşıldığında hemen bozulur.

Alfabetik olarak sırala

Bir diziyi alfabetik olarak sıralamanın en basit görev olması gerektiği anlaşılıyor:

Let meyve = ["balkabağı", "kayısı", "kavun"]; meyve.sort(); > "kayısı", "balkabağı", "kavun"]
Ancak, öğelerden biri büyük harf olduğunda bir sorunla karşılaşıyoruz:

Let meyve = ["butternut squash", "kayısı", "Cantalope"]; meyve.sort(); > "Kavun", "kayısı", "balkabağı"]
Bunun nedeni, sıralayıcının varsayılan olarak Unicode'da temsil edilen ilk karakteri karşılaştırmasıdır. Unicode, platformdan bağımsız olarak, programdan bağımsız olarak, dilden bağımsız olarak herhangi bir karakter için benzersiz bir koddur. Örneğin, kod tablosuna bakarsanız, "a" karakteri U + 0061 değerine sahiptir (onaltılık sistemde 0x61), "C" karakteri ise U + 0043 (0x43) koduna sahiptir. "A" karakterinden daha Unicode tablosu.

İlk harflerin karışık durumda olduğu bir diziyi sıralamak için, tüm öğeleri geçici olarak küçük harfe dönüştürmemiz veya bazı argümanlarla localeCompare () yöntemini kullanarak kendi sıralama düzenimizi tanımlamamız gerekir. Kural olarak, böyle bir durumda, tekrarlanan kullanım için hemen bir işlev oluşturmak daha iyidir:

işlev alphaSort (dizi) (dizi.sort (a, b) (dönüş a.localeCompare (b, "en", ("duyarlılık": "taban"));));) let meyve = ["butternut squash "," kayısı "," Kavun "]; alphaSort (meyve)>
Ters alfabetik sıraya göre sıralanmış bir dizi elde etmek istiyorsanız, işlevde a ve b konumlarını değiştirmeniz yeterlidir:

işlev alphaSort (dizi) (dizi.sort (a, b) işlevi (dönüş b.localeCompare (a, "tr", ("duyarlılık": "taban"));) let meyve = ["butternut squash "," kayısı "," Kavun "]; alphaSort (meyve)> ["kavun", "butternut squash", "kayısı"]
Burada localeCompare'in argümanlarla kullanıldığını belirtmekte fayda var, ayrıca IE11 + tarafından desteklendiğini de hatırlamanız gerekir, IE'nin eski sürümleri için argümanlar olmadan kullanabiliriz ve küçük harflerle:

caseSort (arr) (arr.sort (a, b) (return a.toLowerCase (). LocaleCompare (b.toLowerCase ());));) let meyve = ["butternut squash", "kayısı", "Kavun"]; caseSort (meyve)> ["kayısı", "butternut squash", "Cantaloupe"]

sayısal sıralama

Bütün bunlar, oyun kayıtları dizisi hakkında yukarıda bahsettiğimiz örnek için geçerli değildir. Bazı sayısal dizilerde sıralama gayet iyi çalışır, ancak bir noktada sonuç tahmin edilemez olabilir:

Yüksek Skorlar olsun =; yüksekSkorlar.sort(); >
Gerçek şu ki, sort () yöntemi sözlükbilimsel bir karşılaştırma gerçekleştirir: bu, sayıların bir dizeye dönüştürüleceği ve bu dizenin ilk karakterini Unicode tablo karakterlerinin sırasına göre eşleştirerek karşılaştırmaların yeniden gerçekleştirileceği anlamına gelir. Bu nedenle, sıralama düzenimizi tekrar tanımlamamız gerekiyor:

Yüksek Skorlar olsun =; highScores.sort (işlev (a, b) (dönüş a - b;)); >
Yine sayıları ters sırada sıralamak için fonksiyonda a ve b'nin yerlerini değiştirin.

JSON benzeri bir yapıyı sıralama

Son olarak, bir dizi oyun kaydı olarak temsil edilen JSON benzeri bir veri yapımız varsa:

Let puanları = [("isim": "Daniel", "puan": 21768), ("isim": "Michael", "puan": 33579), ("isim": "Alison", "puan": 38395 )];
ES6 +'da ok işlevlerini kullanabilirsiniz:

Skorlar.sort ((a, b) => b.score - a.score));
Bu desteğe sahip olmayan eski tarayıcılar için:

Skorlar.sort (işlev (a, b) (dönüş a.score - b.score));
Gördüğünüz gibi JavaScript'te sıralama yapmak bariz bir şey değil, umarım bu örnekler hayatı bir şekilde kolaylaştırır.

Güç fonksiyonlarıyla çalışma

Üs alma, başlangıçta bir doğal sayının kendisiyle birden çok çarpımının sonucu olarak tanımlanan bir işlemdir, a'nın karekökü, karesi alındığında a veren sayıdır. Alanları, hacimleri hesaplarken ve hatta fiziksel modellemede dahil olmak üzere matematik derslerinde bu işlevleri günlük hayatta her zaman kullanabiliriz.

JavaScript'te üstel işlev Math.pow () olarak temsil edilir, yeni ES7 standardında yeni bir üstel alma operatörü sunulur - "* *".

üs alma

Bir sayıyı n'inci kuvvete yükseltmek için Math.pow() işlevini kullanın; burada ilk argüman, kuvvete yükseltilecek sayıdır, ikinci argüman üsdür:

Matematik.güç (3,2)> 9
Bu yazı şekli 3 kare ya da 3×3 anlamına geliyor ve bu da 9 sonucunu veriyor. Başka bir örnek de verebilirsiniz tabii ki:

Math.pow (5.3); > 125
Yani 5 küp veya 5 × 5 × 5 125'e eşittir.

ECMAScript 7, JavaScript'in sonraki sürümüdür, prensipte, önerilen yeni üs alma operatörünü kullanabiliriz - * *, bu gösterim şekli daha açıklayıcı olabilir:

3 ** 2 > 9
Şu anda, bu operatör için destek oldukça sınırlıdır, bu nedenle kullanılması önerilmez.

Bir güç işlevi, çok çeşitli durumlarda kullanışlı olabilir. Basit bir örnek, bir saatteki saniye sayısını hesaplamak: Math.pow (60,2).

Kare ve küp kök

Math.sqrt() ve Math.cbrt(), Math.pow() işlevinin tersidir. A'nın karekökünün, karesi alındığında a'yı veren sayı olduğunu unutmayın.

Matematik.sqrt (9)> 3
Aynı zamanda a sayısının küp kökü, küp haline getirildiğinde a veren sayıdır.

Math.cbrt (125)> 5
Math.cbrt (), JavaScript spesifikasyonuna çok yakın bir zamanda tanıtıldı ve bu nedenle yalnızca modern tarayıcılarda destekleniyor: Chrome 38+, Firefox ve Opera 25+ ve Safari 7.1+. Internet Explorer'ın bu listede olmadığını fark edeceksiniz, ancak MDN'de bir çoklu dolgu bulacaksınız.

Örnekleri

Elbette tamsayı olmayan değerleri de şu fonksiyonlardan birinde kullanabiliriz:

Math.pow (1.25, 2); > 1.5625 Math.cbrt (56.57)> 3.8387991760286138
Bunun, negatif bağımsız değişken değerleri için de iyi çalıştığını unutmayın:

Math.pow (-5,2)> 25 Math.pow (10, -2)> 0.01
Ancak, bir karekök için bu işe yaramaz:

Math.sqrt (-9)> NaN
Matematiksel analizden, hayali bir sayının negatif sayıların karekökleri olarak anlaşıldığını biliyoruz. Ve bu bizi karmaşık sayılarla çalışmak için başka bir tekniğe götürebilir, ama bu başka bir hikaye.

Sayıların kare ve küp köklerini bulmak için Math.pow() içindeki kesirli değerleri kullanabilirsiniz. Karekök, 0,5'lik bir üs kullanır:

Math.pow (5, 0,5); // = Math.sqrt (5) = 5 ** (1/2)> 2.23606797749979
Ancak, kayan nokta değişkenleri nedeniyle, doğru sonucu doğru bir şekilde tahmin edemezsiniz:

Math.pow (2.23606797749979.2)> 5.00000000000001
Bu gibi durumlarda, sayıdan veya bir değere yuvarlamadan işaretleri kısaltmaya başvurmanız gerekecektir.

Bazıları, JavaScript'te bilinmeyen bir nedenle Math.pow() işlevini, genel olarak sayılar için üstel bir işlev olan Math.exp() ile karıştırır. Not: İngilizce'de "üs", "üs" olarak çevrilir, bu nedenle üs için indeks, güç gibi alternatif isimler olmasına rağmen, bunun İngilizce konuşanlara atıfta bulunması daha olasıdır.

matematiksel sabitler

JavaScript'te matematikle çalışmak, bir dizi yerleşik sabit tarafından kolaylaştırılmıştır. Bu sabitler Math nesnesinin özellikleridir. Sabitlerin CamelCase notasyonu değil büyük harfle yazıldığını belirtmekte fayda var.

Math.abs, ayrıştırma, ayrıştırmaFloat

JavaScript'te sayılarla çalışmak göründüğünden çok daha karmaşık olabilir. Elde edilen değerler her zaman beklenen aralıklar içerisine girmez, bazen sonuç hiç de beklediğimiz gibi olmayabilir.

Matematik.abs ()

Math.abs () yöntemi, bize bir sayının modülü için benzer matematik işlevini hatırlatan bir sayının mutlak değerini döndürür.

YeniVal = -57.64 olsun; Math.abs (yeniVal); > 57.64
Math.abs (0) her zaman sıfır döndürür, ancak -Math.abs (NUM) işlevinin önüne eksi işareti koyarsak her zaman negatif oluruz.

Matematik.abs (0); > -0

ayrıştırma ()

JavaScript'in "15"in bir sayı değil bir dize olduğunu anladığını biliyoruz ve örneğin JavaScript kullanarak CSS özelliklerini ayrıştırırken veya hazırlıksız bir diziden herhangi bir değer alırken sonuçlarımız tahmin edilemez olabilir. Girdi olarak "17px" olarak temsil edilen bir dize alabiliriz ve bu bizim için alışılmadık bir durum değildir. Soru, bu dizginin gerçek bir değere nasıl dönüştürüleceği ve sonraki hesaplamalarda nasıl kullanılacağıdır.

Sözdizimi: parseInt (dize, sayı tabanı);

parseInt işlevi, kendisine iletilen ilk bağımsız değişkeni bir dize türüne dönüştürür, yorumlar ve bir tamsayı veya NaN değeri döndürür. Sonuç (NaN değilse) bir tamsayıdır ve belirtilen tabanda bir sayı olarak ele alınan ilk argümandır (dize). Örneğin, 10 tabanı ondalık, 8'den sekizliye, 16'dan onaltılıya vb. bir dönüşümü belirtir. Taban 10'dan büyükse, 9'dan büyük sayıları belirtmek için harfler kullanılır. Örneğin, onaltılık sayılar (taban 16) A'dan F'ye kadar olan harfleri kullanır.

Göreceli olarak konuşursak, aşağıdaki değeri alabileceğimiz CSS özellikleriyle çalışma örneğini ele alalım:

Elem = Document.body olsun; let centerPoint = window.getComputedStyle (elem) .transformOrigin; > "454 piksel 2087.19 piksel"
Değerleri boşluklara bölebiliriz:

Merkezler = centerPoint.split (""); > ["454 piksel", "2087.19 piksel"]
Ancak, her öğe hala bir dizedir, işlevimizi uygulayarak bundan kurtulabiliriz:

centerX = ayrıştırma (merkezler, 10) olsun; > 454 let centerY = ayrıştırma (merkezler, 10); > 2087
Gördüğünüz gibi ikinci argüman olarak sayının dönüştürüleceği sayı sistemini belirtiyoruz, bu parametre isteğe bağlı ancak hangi stringin girişe geleceğini bilmiyorsanız kullanmanız tavsiye edilir.

parseFloat ()

Yukarıdaki örnekte, parseInt'in kesirli kısmı attığını fark etmiş olabilirsiniz. Bizim durumumuzda parseFloat kayan nokta sayılarıyla çalışabilir. Yine, bu, özellikle kayan nokta yüzdeleriyle uğraşırken, CSS ve diğer görevleri ayrıştırırken yararlı olabilir.

Sözdizimi: parseFloat (dize)

FP = "33,33333%" olsun; konsol.log (parseFloat (FP)); > 33.33333
parseFloat sözdiziminde ikinci bir argüman olmadığını unutmayın.

parseInt() ve parseFloat() fonksiyonlarının son derece faydalı fonksiyonlar olduğunu anlıyoruz, burada bazı hataların olduğunu unutmamak önemlidir, bu nedenle beklenen değerlerin aralığını kontrol etmek ve sonuçta sonucu analiz etmek gerekir. elde edilen değerler doğrudur.
anonim olarak gönder