Js 2 basamağa yuvarlanıyor. JavaScript'te sayıları yuvarlama yöntemleri. Javascript'te asal sayılar

Math.round() işlevi, bir sayının değerini en yakın tam sayıya yuvarlanmış olarak döndürür.

Bu etkileşimli örneğin kaynağı GitHub deposunda depolanır. Etkileşimli örnekler projesine katkıda bulunmak istiyorsanız lütfen https://github.com/mdn/interactive-examples dosyasını kopyalayın ve bize bir çekme isteği gönderin.

Verilen sayının değeri en yakın tam sayıya yuvarlanır.

Bağımsız değişkenin kesirli kısmı 0,5'ten büyükse, bağımsız değişken bir sonraki daha yüksek mutlak değere sahip tam sayıya yuvarlanır. 0,5'ten küçükse, argüman daha düşük mutlak değere sahip tam sayıya yuvarlanır. Kesirli kısım tam olarak 0,5 ise argüman +∞ yönünde bir sonraki tam sayıya yuvarlanır. Bunun, çoğu zaman bu durumu bir sonraki tam sayıya yuvarlayan birçok dildeki round() işlevlerinden farklı olduğunu unutmayın. sıfırdan uzakta bunun yerine kesirli kısmı tam olarak 0,5 olan negatif sayılar durumunda farklı bir sonuç verir.

round() Math'ın statik bir yöntemi olduğundan, onu oluşturduğunuz Math nesnesinin yöntemi olarak kullanmak yerine her zaman Math.round() olarak kullanırsınız (Math'in yapıcısı yoktur).

Aşağıda, işlevsel olarak math.round'a eşdeğer olan bir kod snippet'i bulunmaktadır ancak aşağıdaki kod snippet'i Math.round'dan daha yavaştır. Aşağıdaki kod parçacığının amacı Math.round'un nasıl çalıştığını göstermektir.

Function vanilya_round(x) ( var y = Math.abs(x) + 0,5; // böylece 1/2'den az aşağı yuvarlar; daha büyük yuvarlamalar Math.floor(x+0,5) değerini döndürür)

Yukarıdaki modül operatörü x'in ondalık kısmını alır. Ayrıca yukarıdaki kod parçacığı, bir sayıyı belirli bir kesinliğe yuvarlayacak şekilde değiştirilebilir:

Function round_to_precision(x, hassas) ( var y = +x + (hassasiyet === tanımsız ? 0,5: hassasiyet/2); return y - (y % (hassasiyet === tanımsız ? 1: +hassasiyet)); )

Round_to_precision(11, 2); // çıktı olarak 12 round_to_precision(11, 3); // çıktı olarak 12 round_to_precision(11, 4); // çıktı olarak 12 round_to_precision(11, 5); // çıktı olarak 10 round_to_precision(11, 6); // çıktı olarak 12 round_to_precision(11, 7); // çıktı olarak 14 round_to_precision(11, 8); // çıktı olarak 8 round_to_precision(3,7, 0,5); // 3,5 sonucunu verir round_to_precision(3,75, 0,5); // çıktı olarak 4 round_to_precision(3.8, 0.5); // çıktı 4

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

GitHub'daki uyumluluk verilerini güncelleyin

Bu yazıda sayılara, matematiksel operatörlere, bir sayıyı dizgeye ve tam tersine dönüştürmenin yollarına ve diğer birçok önemli noktaya ayrıntılı olarak bakacağız.

isFinite işlevi, bir argümanın sonlu bir sayı olup olmadığını kontrol etmenizi sağlar.

Yanıt olarak, argüman Infinity, -Infinity, NaN ise veya bu özel sayısal değerlerden birine dönüştürülecekse bu işlev false değerini döndürür. Aksi takdirde bu fonksiyon true değerini döndürecektir.

IsFinite(73); // true isFinite(-1/0); // false isFinite(Sonsuz); // false isFinite(NaN); // false isFinite("Metin"); // YANLIŞ

JavaScript'te global isFinite işlevine ek olarak Number.isFinite yöntemi de vardır. isFinite'ın aksine, argümanı bir sayıya dönüştürülmeye zorlamaz.

IsFinite("73"); // true Number.isFinite("73"); // YANLIŞ

isNaN işlevi, bir argümanın sayı mı olduğunu yoksa bir sayıya mı dönüştürülebileceğini belirlemek için tasarlanmıştır. Eğer öyleyse, isNaN işlevi false değerini döndürür. Aksi takdirde true değerini döndürür.

IsNaN(NaN); //true isNaN("25px"); //doğru çünkü 20px bir sayı değildir: NaN(25,5); //false isNaN("25.5"); //false isNaN(" "); //yanlış çünkü bir boşluk veya birkaç boşluk 0'a dönüştürülür isNaN(null); //yanlış çünkü null, 0'a dönüştürülür isNaN(true); //yanlış çünkü true, 1'e dönüştürülür isNaN(false); //yanlış çünkü yanlış 0'a dönüştürülür

Bu eylemin tür dönüşümü olmadan gerçekleştirilmesi gerekiyorsa Number.isNaN yöntemini kullanın. Bu yöntem dile ECMAScript 6'dan başlayarak tanıtıldı.

Aşağıdaki yöntemleri kullanarak bir dizeyi açıkça bir sayıya dönüştürebilirsiniz:

1. Değerin önüne yerleştirilmesi gereken tekli + operatörünü kullanın.

+"7,35"; // 7.35 +"metin"; // NaN

Bu yöntem, \n'nin (satır besleme) yanı sıra satırın başındaki ve sonundaki boşlukları da yok sayar.

+" 7,35 "; //7.35 +"7.35 \n "; //7.35

Bu yöntemi kullanırken boş bir string veya boşluk ve \n'den oluşan bir stringin 0 sayısına dönüştürülmesine dikkat etmeniz gerekmektedir. Ayrıca null veri tipini ve Boolean değerlerini de bir sayıya dönüştürür. .

Hükümsüz; //0 +doğru; //1 +yanlış; //0 +" "; //0

2. Ayrıştırma işlevi. Bu işlev bir bağımsız değişkeni tam sayıya dönüştürmek için tasarlanmıştır. Tekli + operatörünü kullanmaktan farklı olarak bu yöntem, bir dizeyi, tüm karakterlerin sayısal olmadığı bir sayıya dönüştürmenize olanak tanır. İlk karakterden başlayarak dizeyi dönüştürmeye başlar. Ve sayısal olmayan bir karakterle karşılaştığında bu fonksiyon çalışmasını durdurur ve ortaya çıkan sayıyı döndürür.

ParseInt("18px"); //18 parseInt("%33,3"); //33

Bu fonksiyon farklı sayı sistemleriyle (ikili, sekizli, ondalık, onaltılı) çalışabilir. Sayı sisteminin tabanı 2 argüman kullanılarak belirtilir.

ParseInt("18 piksel", 10); //18 parseInt("%33,3", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

JavaScript'te parseInt işlevine ek olarak Number.parseInt yöntemi de vardır. Bu yöntem parseInt işlevinden farklı değildir ve ECMASCRIPT 2015 (6) spesifikasyonuyla JavaScript'e eklenmiştir.

3. ayrıştırmaFloat işlevi. parseFloat işlevi, bağımsız değişkeni kesirli bir sayıya dönüştürmenize olanak sağlaması dışında parseInt işlevine benzer.

ParseFloat("%33,3"); //33.3

Ayrıca parseFloat işlevi, parseInt'ten farklı olarak 2 bağımsız değişkene sahip değildir ve bu nedenle dizeyi her zaman ondalık gösterim sisteminde bir sayı olarak ele almaya çalışır.

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

JavaScript'te parseFloat işlevine ek olarak Number.parseFloat yöntemi de bulunur. Bu yöntem parseFloat işlevinden farklı değildir ve ECMASCRIPT 2015 (6) spesifikasyonuyla JavaScript'e eklenmiştir.

toString yöntemini kullanarak bir sayıyı dizeye dönüştürebilirsiniz.

(12.8).toString(); //"12,8"

toString yöntemi ayrıca, sayıyı açıkça bir dizeye dönüştürmeniz gerektiğini dikkate alarak sayı sisteminin tabanını belirtmenize de olanak tanır:

(255).toString(16); //"ff"

Bir değişkenin değerinin bir sayı olup olmadığını aşağıdaki yöntemlerden birini kullanarak belirleyebilirsiniz:

1. isNaN ve isFinite işlevlerini kullanma:

// myVar bir değişkendir if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar bir sayıdır veya ona dönüştürülebilir);

İşlev olarak:

// fonksiyon fonksiyon isNumeric(değer) ( dönüş !isNaN(parseFloat(değer)) && isFinite(parseFloat(değer)); ) // var myVar = "12px" kullanın; console.log(isNumeric(myVar)); //doğru

Bu yöntem, belirtilen değerin bir sayı olup olmadığını veya bire dönüştürülüp dönüştürülemeyeceğini belirlemenizi sağlar. Bu seçenek boş dizeyi, boşluk dizesini, null, Infinity, -Infinity, true ve false'u sayı olarak saymaz.

2. typeof operatörünü ve isFinite, isNaN fonksiyonlarını kullanarak:

// değerin sayı olup olmadığını kontrol eden fonksiyon function isNumber(value) ( ​​dönüş typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Bu işlev, belirtilen değerin Number türünde olup olmadığını ve Infinity, -Infinity ve NaN özel değerlerinden biri olup olmadığını belirler. Eğer öyleyse, o zaman bu işlev true değerini döndürür.

3. ECMAScript 6 Number.isInteger(value) yöntemini kullanma. Bu yöntem, belirtilen değerin bir tamsayı olup olmadığını belirlemenizi sağlar.

Number.isInteger("20"); //yanlış çünkü bu yöntem bir dizeyi bir sayıya dönüştürmez Number.isInteger(20); //doğru çünkü bu değer bir sayıdır

Aşağıdaki işlevleri kullanarak bir sayının çift mi yoksa tek mi olduğunu kontrol edebilirsiniz:

// Çift eşlik işlevi için bir sayıyı kontrol etme işlevi isEven(n) ( return n % 2 == 0; ) // Tek eşlik işlevi için bir sayıyı kontrol etme işlevi isOdd(n) ( return Math.abs(n % 2) == 1;)

Ancak böyle bir kontrol yapmadan önce belirtilen değerin bir sayı olduğundan emin olmanız önerilir:

Değer = 20; if (Number.isInteger(value)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " - even"); ) )

Javascript kullanarak 2'den 100'e kadar asal sayıları göstereceğimiz bir örneğe bakalım.

// Bir sayının asal olup olmadığını kontrol eden fonksiyon isPrime(value) ( ​​if (isNaN(value) || !isFinite(value) || değer%1 || değer< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i (больше), < (меньше), >= (büyük veya eşit), 3); //false console.log(5>=3); //doğru

Sayıları kesirli kısımlarla karşılaştırırken bu hesaplamalar sırasında ortaya çıkabilecek hataları dikkate almak gerekir.

Örneğin, JavaScript'te sayıların toplamı (0,2 + 0,4) 0,6'ya eşit değildir:

Console.log((0,2+0,4)==0,6); //YANLIŞ

Hatalar, bir bilgisayar veya başka bir elektronik cihazın tüm hesaplamaları 2. sayı sisteminde yapması nedeniyle ortaya çıkar. Onlar. Herhangi bir işlem yapmadan önce bilgisayarın öncelikle ifadede sunulan sayıları 2. sayı sistemine dönüştürmesi gerekir. Ancak her kesirli ondalık sayı 2. sayı sisteminde tam olarak temsil edilemez.

Örneğin 0,25 10 sayısı tam olarak ikili sayıya dönüştürülür.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0,5 × 2 = 1 | 1 0,125 10 = 0,001 2

Örneğin 0,2 10 sayısı ancak belirli bir doğrulukla 2 sistemine dönüştürülebilir:

0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0,4 × 2 = 0,8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0,2 10 = 0,001100110011... 2

Sonuç olarak bu hatalar iki sayının toplamının hesaplanmasını ve karşılaştırma sonuçlarını etkileyecektir. Onlar. Görünüşe göre JavaScript bu girişi aslında şu şekilde görecek:

0.6000000000000001==0.6

Kesirli kısımlara sahip sayıları hesaplarken veya görüntülerken, her zaman bunu yapmak istediğiniz kesinliği belirtmelisiniz.

Örneğin, toFixed() ve toPrecision() yöntemlerini kullanarak 2 ondalık basamağa kadar olan sayıları karşılaştırın:

//yöntem toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //method toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //doğru

JavaScript'te aşağıdaki matematiksel operatörler mevcuttur: + (toplama), - (çıkarma), * (çarpma), / (bölme), % (modülo), ++ (bir değeri 1 artırma), -- (bir değeri azaltma) 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 %63 //0, yani. 6:3=2 => 6-3*2 => geri kalan(0) %52 //1, yani. 5:2=2(.5) => 5-2*2 => geri kalan(1) %7.32 //1.3, yani. 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //% işleminin sonucunun işareti ilk değerin işaretine eşittir -9%2.5 //-1.5 yani 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -9%-2.5 //-1.5, yani. 9:2.5=3(.6) => 9-2.5*3 => rest(1.5) -2%5 //-2, yani. 2:5=0(.4) => 2-5*0 => kalan(2) x = 3; console.log(x++); //3'ün çıktısını alır, ardından 4'ü ayarlar console.log(x); //4 x = 3; console.log(++x); //4'ü ayarlıyoruz ve x = 5 çıktısını alıyoruz; console.log(x--); //5 çıktısını alır, sonra 4'ü ayarlar console.log(x); //4 x = 5; console.log(--x); //4'ü ayarlar ve çıktılar Ek olarak, JavaScript'in kombinasyon operatörleri vardır: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y). x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3

Genellikle hesaplamaların sonucu, çok sayıda ondalık basamağa sahip bir sayıdır. Bu sayı daha sonraki hesaplamalar için kullanılırsa olduğu gibi bırakılabilir. Ancak bazen bir sayının, örneğin bir sayfada görüntülenmesi için yuvarlanması gerekir. JavaScript sayıları çeşitli yöntemler kullanarak yuvarlar.

Math.round() yöntemi, değeri bir tamsayıya yuvarlar.

Matematik turu (sayı)

Sayılar matematik kurallarına göre yuvarlanır. Yani, ondalık noktadan sonra 0'dan 4'e kadar bir sayı varsa, kesirli kısım basitçe atılır. Ve eğer ondalık noktadan sonra 5'ten 9'a kadar bir sayı varsa, o zaman kesirli kısım atılır ve bütün kısma bir eklenir. örnek:

JavaScript:

Bir sayıyı tam sayıya yuvarlayan iki yöntem daha vardır. Math.floor() yöntemi aşağı yuvarlar. Sayının kesirli kısmını atar. Ve Math.ceil() yöntemi yuvarlanır. Kesirli kısım atılır ve bütün kısma bir eklenir. Örnek:

Elbette 5 - (-2) 5+2'dir. Bu formülde 5 sayısını elde edemeyeceğinizi unutmayın. Maksimum 4,999999999 olacaktır. Ortaya çıkan değerler gerekli doğruluğa yuvarlanabilir.

Yalnızca tam sayılara ihtiyaç duyulursa, elde edilen değerler en yakın tam sayıya yuvarlanabilir. Bu maksimumun da mümkün olabilmesi için maksimuma bir eklenmelidir. Formül şuna benzer:

tamsayı = Math.floor(min + Math.random() * (max + 1 - min)

10'dan 15'e kadar sayıları yazdıralım: