Számok kerekítése a JavaScriptben. Javascript - oldalsó - gépíró kerekítés felfelé a legközelebbi egész számra

Ez a cikk közelebbről megvizsgálja a számokat, a matematikai operátorokat, a számok karakterlánccá alakításának módjait és fordítva, valamint sok más fontos pontot.

IsFinite függvény

Az isFinite függvény lehetővé teszi annak ellenőrzését, hogy egy argumentum véges -e.

Válaszul ez a függvény hamis értéket ad vissza, ha az argumentum Infinity, -Infinity, NaN, vagy a speciális számértékek egyikére lesz átadva. Ellenkező esetben ez a függvény igaz lesz.

IsFinite (73); // true isFinite (-1/0); // hamis isVéges (Végtelen); // hamis isVéges (NaN); // hamis isFinite ("Szöveg"); // hamis

Az isFinite globális függvényen kívül a JavaScript rendelkezik Number.isFinite metódussal is. Az isFinite -től eltérően nem kényszeríti az érvet egy számra.

IsFinite ("73"); // true Number.isFinite ("73"); // hamis

IsNaN függvény

Az isNaN függvény célja annak megállapítása, hogy egy argumentum szám -e vagy átalakítható -e belőle. Ha igen, az isNaN függvény hamis értéket ad vissza. Ellenkező esetben igazként tér vissza.

IsNaN (NaN); // true isNaN ("25px"); // igaz, mert 20px nem szám isNaN (25,5); // hamis isNaN ("25,5"); // hamis isNaN (""); // hamis, mert a szóközt vagy több teret 0 isNaN (null) értékre alakítjuk át; // hamis, mert a null 0 -ra konvertálódik isNaN (igaz); // hamis, mert a true -t 1 isNaN -ra (hamis) konvertálják; // hamis, mert hamis 0 -ra konvertál

Ha ezt a műveletet típusküldés nélkül kell végrehajtani, akkor használja a Number.isNaN metódust. Ezt a módszert az ECMAScript 6 óta vezetik be a nyelvbe.

Hogyan tudom kifejezetten átalakítani a karakterláncot számmá?

A karakterláncot kifejezetten számgá alakíthatja a következő módszerekkel:

1. Használja unary + operátor az érték elé kell helyezni.

+ "7,35"; // 7.35 + "szöveg"; // NaN

Ez a módszer figyelmen kívül hagyja a kezdő és a végső szóközöket és a \ n (sor előtolás) lehetőséget.

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

Ezzel a módszerrel figyelnie kell arra a tényre, hogy egy üres karakterlánc vagy szóközökből álló karakterlánc és \ n le lesz fordítva 0 -ra. Ezenkívül a null adattípust és a logikai értékeket is számgá alakítja .

Nulla; // 0 + igaz; // 1 + hamis; // 0 + ""; 0

2. A parseInt függvény. Ez a funkció átalakításra szolgál érv egész számra... Használattal szemben unary operátor +, ez a módszer lehetővé teszi a karakterlánc számmá alakítását, amelyben nem minden karakter numerikus... Elkezdi a karakterlánc átalakítását, az első karaktertől kezdve. És amint találkozik egy nem digitális karakterrel, ez a funkció leáll, és visszaadja a kapott számot.

ParseInt ("18 képpont"); // 18 parseInt ("33,3%"); 33

Ez a funkció különböző számrendszerekkel (bináris, oktális, decimális, hexadecimális) működhet. A radix két argumentum használatával van megadva.

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

A parseInt függvényen kívül a JavaScript rendelkezik Number.parseInt metódussal. Ez a módszer nem különbözik a parseInt függvénytől, és a JavaScriptben az ECMASCRIPT 2015 specifikációval vezették be (6).

3. A parseFloat függvény. A ParseFloat hasonló a parseInt -hez, azzal a különbséggel, hogy az argumentumot töredékké alakítja.

ParseFloat ("33,3%"); 33.3

Ezenkívül a parseFloat függvénynek - a parseInt -el ellentétben - nincs két argumentuma, ezért mindig megpróbálja tizedes számként kezelni a karakterláncot.

ParseFloat ("3.14"); parseFloat ("314e-2"); parseFloat ("0,0314E + 2");

A parseFloat függvényen kívül a JavaScript rendelkezik Number.parseFloat metódussal. Ez a módszer nem különbözik a parseFloat függvénytől, és a JavaScriptben az ECMASCRIPT 2015 specifikációval vezették be (6).

Szám átalakítása karakterlánccá

Egy számot karakterlánccá alakíthat a toString módszerrel.

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

A toString módszer lehetővé teszi a számrendszer alapjának megadását is, figyelembe véve, hogy a számot kifejezetten karakterláncba kell helyezni:

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

Hogyan lehet ellenőrizni, hogy a változó szám -e

Az alábbi módszerek egyikével határozhatja meg, hogy egy változó értéke szám -e:

1. Az isNaN és isFinite függvények használata:

// a myVar változó, ha (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))))

Funkcióként:

// függvény függvény isNumeric (érték) (return! isNaN (parseFloat (érték)) && isFinite (parseFloat (érték));) // use var myVar = "12px"; console.log (isNumeric (myVar)); // igaz

Ez a módszer lehetővé teszi annak meghatározását, hogy a megadott érték szám -e vagy átalakítható -e belőle. Ez az opció nem kezeli számként az üres karakterláncot, a szóközök sorát, a null -t, a végtelenséget, a -Infinity -t, igaz vagy hamis.

2. A typeof operátor és az isFinite, isNaN függvények használatával:

// függvény, amely ellenőrzi, hogy az érték számfüggvény -e" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

Ez a függvény határozza meg, hogy a megadott érték Number típusú -e, és hogy az Infinity, -Infinity és NaN speciális értékek egyike. Ha igen, akkor ez a függvény igaz értéket ad vissza.

3. Az ECMAScript 6 Number.isInteger (érték) módszer használatával. Ez a módszer lehetővé teszi annak meghatározását, hogy a megadott érték egész szám -e.

Number.isInteger ("20"); // hamis, mert ez a módszer nem fordítja le a karakterláncot a Number.isInteger (20) számra; // igaz, mert a megadott érték egy szám

Páros és páratlan számok

A következő funkciókkal ellenőrizheti, hogy egy szám páros vagy páratlan -e:

// Az egyenletfüggvény számának ellenőrzésére szolgáló függvény isEven (n) (return n% 2 == 0;) // Funkció a páratlan függvény számának ellenőrzésére isOdd (n) (return Math.abs (n% 2) == 1;)

De az ilyen ellenőrzés elvégzése előtt tanácsos meggyőződni arról, hogy a megadott érték egy szám:

Érték = 20; if (Number.isInteger (érték)) (if (isEven (érték)) (console.log ("Szám" + érték.toString () + "- páros");))

Javascript primes

Tekintsünk egy példát, amelyben a Javascript használatával 2 és 100 közötti prímszámokat jelenítünk meg.

// Egy függvény, amely ellenőrzi, hogy a szám elsődleges függvénye isPrime (érték) (if (isNaN (érték) ||! IsFinite (érték) || érték% 1 || érték< 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 <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

Számok kerekítése Javascriptben

A törtszám egész számra történő kerekítésére számos módszer létezik a JavaScriptben.

1. A Math.floor, Math.ceil és Math.round speciálisan tervezett módszerek alkalmazásával. A Math.floor módszer a tört számot a legközelebbi egész számra kerekíti, azaz egyszerűen elveti a tört részt. A Math.ceil tört számot kerekít fel a legközelebbi egész számra. A Math.round felfelé vagy lefelé kerekít egy számot a törtrész értékétől függően. Ha a törtrész nagyobb vagy egyenlő, mint 0,5, akkor felfelé, különben a göndör lefelé.

Console.log (Math.floor (7.9)); // 7 console.log (Math.ceil (7.2)); // 8 console.log (Math.round (7.5)); //nyolc

2. A toFixed módszer használata (pontosság). Ez a módszer a szám tört részét a megadott pontosságra kerekíti. A kerekítési eredmény karakterláncként kerül visszaadásra.

Console.log (7.987.toFixed (2)); 7,99 "

Ha nincs elegendő tizedesjegy a szám megadott pontosságának meghatározásához, akkor a szám nullákkal van kitöltve.

Console.log (7.987.toFixed (5)); //"7.98700 "

3. A toPrecision módszerrel. Ez a módszer a megadott pontosságú számot ábrázolja. Ugyanakkor nemcsak a töredéket, hanem a szám egész részét is le tudja kerekíteni. Ez a módszer az eredménytől függően rögzített ponttal vagy exponenciális formában ábrázolhatja a kapott számot.

Console.log ((1001). ToPrecision (2)); //"1.0e+3 "console.log ((1001) .toPrecision (5)); //"1001.0 "console.log ((12.4) .toPrecision (1)); // "1e + 1" konzol.log ((12.4) .toPrecision (2)); // "12" console.log ((12.4) .toPrecision (3)); //" 12.4 "console.log ((12.4) .toPrecision (5)); // 12.1200 "

4. NEM vagy VAGY logikai operátorok használata.

// kettős logikai tagadási konzolon keresztül.log (~~ 7.9); // 7 // logikai VAGY használatával nullával: console.log (7.9 ^ 0); 7

Egy szám egész és tört része

Egy szám egész részét a Math.floor () metódussal és a parseInt () módszerrel kaphatja meg:

Console.log (Math.floor (7.21)); // 7 console.log (parseInt (7.21)); 7

A szám tört részét a százalékos (%) operátor segítségével szerezheti be. Ez az operátor visszaadja a maradékot, amelyet az első szám elosztásával a másodikkal kapunk. Ebben az esetben 1 -et kell használni 2 -es számként.

Console.log (7,21% 1); // 0.20999999999999996 // 2 tizedesjegyig pontos console.log ((7,21% 1). ToFixed (2)); // "0,21"

Ezenkívül a törtrész számításokkal is megszerezhető:

Var szám = 7,21; var frakciószám = szám - Math.floor (Math.abs (szám)); console.log (frakciószám); 020999999999999996

A szám még osztható is

A százalék operátor segítségével meghatározhatja, hogy egy szám egyenlően osztható -e:

Var szám = 9; // ha a szám 3 -mal való osztásának maradéka 0, akkor igen, különben nem, ha (szám% 3 == 0) (console.log ("Szám" + szám + "osztható 3" -al);) else (konzol . log ("Szám" + szám + "nem osztható 3 -mal");)

Számok formázása

JavaScriptben a toLocaleString () metódus lehetővé teszi, hogy egy szám kimenetét a regionális (operációs rendszer) nyelvi beállításoknak megfelelően formázza.

Például formázzuk a számot a rendszerre alapértelmezés szerint telepített regionális szabványoknak megfelelően:

Var szám = 345,46; console.log (number.toLocaleString ()); // "345.46"

Például formázzuk meg a számot Oroszország regionális szabványainak megfelelően (ru):

Console.log ((108.1) .toLocaleString ("ru-RU")); "108,1"

Ez a módszer használható egy szám pénznemként történő formázására is:

Console.log ((2540.125) .toLocaleString ("ru-RU", (stílus: "currency", pénznem: "RUB"))); // "2 540,13 ₽" console.log ((89.3) .toLocaleString ("ru-RU", (stílus: "currency", pénznem: "USD"))); // "89.30 $" console.log ((2301.99) .toLocaleString ("ru-RU", (stílus: "currency", pénznem: "EUR"))); // "2 301,99 EUR"

Egy szám százalékos ábrázolása:

Console.log ((0.45) .toLocaleString ("ru-RU", (stílus: "százalék"))); // "45%"

Ossza fel a számokat számjegyekre (useGrouping tulajdonság):

Console.log ((125452.32) .toLocaleString ("ru-RU", (useGrouping: true))); "125 452,32"

Nyomtasson ki egy bizonyos számjegyű számot (2) a tizedespont után:

Console.log ((1240.4564) .toLocaleString ("ru-RU", (minimumFractionDigits: 2, maximumFractionDigits: 2))); // "1 240,46"

A számok összehasonlítása

A JavaScript a következő operátorokat használja a számok összehasonlításához: == (egyenlő) ,! = (Nem egyenlő),> (nagyobb, mint),< (меньше), >= (nagyobb vagy egyenlő),<= (меньше или равно).

Például hasonlítsunk össze két számot:

Console.log (2> 3); // hamis konzol.log (5> = 3); // igaz

A számok töredékrészekkel való összehasonlításakor figyelembe kell venni a számítások során felmerülő hibákat.

Például a JavaScriptben a számok összege (0,2 + 0,4) nem 0,6:

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

Hibák fordulnak elő, mert minden számítást számítógép vagy más elektronikus eszköz hajt végre a 2. számrendszerben. Azok. mielőtt bármilyen műveletet elvégezne, a számítógépnek először át kell alakítania a kifejezésben szereplő számokat 2 számrendszerbe. A 2 -es számrendszerben azonban egyetlen tört tört tizedes szám sem ábrázolható pontosan.

Például a 0,25 10 számot pontosan bináris rendszerré alakítjuk át.

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

Például a 0,2 10 szám csak bizonyos pontossággal konvertálható 2 -es rendszerré:

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

Ennek eredményeként ezek a hibák befolyásolják a két szám összegének kiszámítását és az összehasonlítási eredményeket. Azok. kiderül, hogy valójában a JavaScript a következőképpen fogja látni ezt a rekordot:

0.6000000000000001==0.6

A törtrészes számok kiszámításakor vagy megjelenítésekor mindig meg kell adnia a pontosságot.

Például hasonlítsa össze a számokat legfeljebb két tizedesjegyig a toFixed () és a toPrecision () módszerrel:

// metódus toFixed () konzol.log ((0,2 + 0,4) .toFixed (2) == (0,6) .toFixed (2)); // true // metódus toPrecision () console.log ((0,2 + 0,4) .toPrecision (2) == (0,6) .toPrecision (2)); // igaz

Alapvető matematikai műveletek

A JavaScriptben a következő matematikai operátorok léteznek: + (összeadás), - (kivonás), * (szorzás), / (osztás),% (modulo), ++ (1 -gyel nő), - (1 -gyel csökken).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, azaz 6: 3 = 2 => 6-3 * 2 => pihenés (0) 5% 2 // 1, azaz 5: 2 = 2 (.5) => 5-2 * 2 => pihenés (1) 7,3% 2 // 1,3, azaz 7.3: 2 = 3 (.65) => 7.3-2 * 3 => pihenő (1.3) // a% művelet eredményének előjele megegyezik az első érték előjelével -9% 2.5 //-1.5 , azaz 9: 2,5 = 3 (.6) => 9-2,5 * 3 => pihenés (1,5) -9% -2,5 //-1,5, azaz 9: 2,5 = 3 (.6) => 9-2,5 * 3 => pihenés (1,5) -2% 5 // -2, azaz 2: 5 = 0 (.4) => 2-5 * 0 => pihenés (2) x = 3; console.log (x ++); // kinyomtat 3, y beállítja a 4 későbbi konzolt.log (x); // 4 x = 3; console.log (++ x); // beállítja a 4 -et és kinyomtat x = 5; console.log (x--); // kinyomtat 5, y beállítja a 4 későbbi konzolt.log (x); // 4 x = 5; console.log (- x); // beállítja a 4-et és a kimeneteket Ezenkívül a JavaScript kombinált operátorokkal rendelkezik: x + = y (x = x + y), x- = y (x = xy), 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

A számítások gyakran olyan eredményeket hoznak, amelyek kívül esnek a kívánt tartományokon. Ennek eredményeképpen végre kell hajtania JavaScript kerekítés egy bizonyos értékre.

Miért kell kerekíteni a számokat?

A JavaScript nem tárol egész számokat, mert azok értékei lebegőpontos számok. Sok törtet nem lehet véges tizedesjegyekkel ábrázolni, ezért a JavaScript az alábbihoz hasonló eredményeket hozhat létre:

0.1 * 0.2; > 0.020000000000000004

A gyakorlatban ez nem fog változtatni, mivel 2 quintillion hibáról beszélünk. Ez azonban befolyásolhatja az eredményt, ha olyan számokkal dolgozik, amelyek pénznemi értékeket, százalékokat vagy fájlméretet képviselnek. Ezért meg kell tennie, vagy egy bizonyos tizedesjegyig.

A tizedes számok kerekítése

Egy tizedes szám "vágásához" használja a toFixed () vagy a toPrecision () metódust. Mindketten egy érvet vesznek fel, amely meghatározza, hogy hány jelentős és tizedesjegy szerepel az eredményben:

• ha nincs megadva argumentum a toFixed () paraméterhez, akkor az alapértelmezett érték 0, azaz nincs tizedesjegy; az argumentum maximális értéke 20;
• ha nincs megadva argumentum a toPrecision () paraméterhez, akkor a szám nem változik.

var randNum = 6,25; randNum.toFixed (); > "6" Math.PI.toPrecision (1); > "3" var randNum = 87,335; randNum.toFixed (2); > "87.33" var randNum = 87.337; randNum.toPrecision (3); > "87,3"

jegyzet

A toFixed () és a toPrecision is az eredmény lekerekített karakterlánc -visszaadását adja vissza, nem pedig számot. Ez azt jelenti, hogy a kerekítés hozzáadása a randNumhoz karakterlánc -összefűzést eredményez, nem pedig egyetlen számot:

console.log (randNum + lekerekített); > "6.256"

Ha azt szeretné, hogy a JavaScript a századik pontosságig kerekítse, használja a parseFloat () parancsot:

var randNum = 6,25; var lekerekített = parseFloat (randNum.toFixed (1)); console.log (lekerekített); > 6.3

A toFixed () és a toPrecision () szintén hasznos módszerek nagyszámú tizedesjegy csonkítására. Ez akkor hasznos, ha pénzegységeket ábrázoló számokkal dolgozik:

var egészNum = 1 var dollárCents = egészNum.toFixed (2); console.log (dollárcent) > "1.00"

Ne feledje, hogy ha a számban több számjegy található, mint a precíziós paraméter, a toPrecision az eredményt tudományos formátumban adja vissza:

var szám = 123,435 szám. pontosságig (2); > "1.2e + 2"

Hogyan kerülhetjük el a hibákat a tizedes törtek kerekítésekor

Bizonyos esetekben a toFixed és a toPrecision eszköz JavaScript lefelé kerekítés 5, és nem több:

var numTest = 1,005; numTest.toFixed (2); > 1;

A fenti példa 1.01 -t eredményez, nem pedig 1. Ha el kell kerülnie ezt a hibát, javaslom az exponenciális számok használatát:

függvénykör (érték, tizedesjegyek) (visszatérési szám (Math.round (érték + "e" + tizedesjegyek) + "e -" + tizedesjegyek);)

Alkalmazás:

forduló (1.005,2); > 1.01

Ha a kerekítésnél is megbízhatóbb megoldásra van szüksége, akkor a címen kapható MDN.

Epsilon kerekítés

Alternatív módszer JavaScript kerekítés tizedekre ES6 -ban mutatták be ( más néven JavaScript 2015). « Gép epsilon»Ésszerű hibahatárt biztosít két lebegőpontos szám összehasonlításakor. Kerekítés nélkül az összehasonlítások az alábbihoz hasonló eredményeket hozhatnak:

0,1 + 0,2 === 0,3> hamis

A Math.EPSILON használható egy függvényben a helyes összehasonlításhoz:

function epsEqu (x, y) (return Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

A függvény két érvet tartalmaz: az egyik számításokat tartalmaz, a második a várt (kerekített) eredményt. E két paraméter összehasonlítását adja vissza:

epsEqu (0,1 + 0,2, 0,3)> igaz

Minden modern böngésző támogatja az ES6 matematikai funkciókat. De ha támogatást kell nyújtania a régebbi böngészőkben, akkor polifill -eket kell használnia.

Tizedes számok csonkítása

A korábban bemutatott összes módszer teljesít JavaScript kerekítés tizedekre... Ha egy pozitív számot két tizedesjegyre kíván csonkolni, szorozza meg 100 -zal, csonkítsa le újra, majd ossza el az eredményt 100 -zal:

függvény csonka (szám) (return Math.trunc (szám * 100) / 100;) csonka (3.1416)> 3.14

Ha valami rugalmasabbra van szüksége, használhatja a bitszerű operátort:

függvény csonka (num, decimalPlaces) (var numPowerConverter = Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)

Használat:

var randInt = 35,874993; csonka (randInt, 3); > 35,874

Kerekítés a legközelebbi számra

Végrehajtani JavaScript kerekítés egész számra, a Math.round () használta:

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

Vegye figyelembe, hogy " fél értékek„Például a .5 -öt felfelé kerekítik.

Kerekítse le a legközelebbi egész számra

Ha lefelé szeretne kerekíteni, használja a Math.floor () metódust:

Math.floor (42.23); > 42 Math.floor (36,93); > 36

A lefelé kerekítésnek egy iránya van minden számra, beleértve a negatívokat is. Ez felhőkarcolónak képzelhető el, végtelen számú emelettel, beleértve az alapítvány szintjét ( negatív számokat képvisel). Ha a liftben tartózkodik az alagsori 2. és 3. emelet között ( ami -2,5 értéknek felel meg), A Math.floor a 3. emeletre visz:

Matematika.padló (-2,5); > -3

Ha ezt el kell kerülnie, használja a JavaScript matematikai kerekítést a Math.trunc () programmal, amelyet minden modern böngésző támogat (kivéve IE / Edge):

Math.trunc (-41,43); > -41

Az MDN is biztosítja 3 soros polifill, amely Math.trunc támogatást nyújt a régebbi böngészőkben és az IE / Edge -ben.

Kerekítse fel a legközelebbi egész számra

Ha tizedesjegyeket szeretne kerekíteni, használja a Math.ceil parancsot. Ez a módszer egy végtelen emelkedésnek is felfogható: A Math.ceil mindig felveszi Önt, függetlenül attól, hogy a szám negatív vagy pozitív:

Matematikai cecil (42,23); > 43 Math.ceil (36,93); > 37 Math.ceil (-36,93); -36

Kerekítse a legközelebbi többszörösre

Ha az értéket az 5 legközelebbi többszörösére kell kerekítenie, hozzon létre egy függvényt, amely elosztja a számot 5 -tel, kerekíti, majd megszorozza az eredményt ugyanazzal az értékkel:

függvény roundTo5 (szám) (visszatér Math.round (szám / 5) * 5;)

Használat:

roundTo5 (11); > 10

Ha JavaScriptre van szüksége a két számjegyű kerekítéshez, akkor a vetőmag és a többszörös is átadható a függvénynek:

function roundToMultiple (szám, többszörös) (return Math.round (szám / többszörös) * többszörös;)

A függvény használatához adja meg a kerekítendő számot és a többszöröst a hívásban:

var kezdeti szám = 11; var multiple = 10; roundToMultiple (kezdeti szám, többszörös); > 10;

Ha csak felfelé vagy lefelé szeretné kerekíteni az értékeket, cserélje le a kört mennyezetre vagy padlóra a funkcióban.

Hatótávolság -csattanás

Néha meg kell kapnia az x értékét, amelynek egy bizonyos tartományon belül kell lennie. Például 1 és 100 közötti értékre van szükségünk, de 123 értéket kapunk. Ennek kijavításához használhatja a min () ( a legkisebb számot adja vissza) és max ( a megengedett maximális számot adja vissza).

Használat:

var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max (lowBound, Math.min (numInput, highBound)); konzol.napló (befogva); > 100;

Létrehozhat egy funkciót vagy kiterjesztést a Számosztályhoz.

Szia. Ma a Javascript oszlopban megvizsgáljuk, hogyan lehet beállítani a tizedesjegyek számát a lebegőpontos számokban a javascriptben. Például 3 tizedesjegyet kell hagynia a kimenetben, vagy csak kettőt.

Probléma: javascript tizedesjegyek

Tehát egy feladattal kell szembenéznünk: van egy számítási eredmény, amelyben számok vannak a tizedespont előtt és után. Decimális. Tegyük fel, hogy az eredmény ilyen: 1538.9891200153. Visszavonáskor azonban olyan számot kell kapnia, amely tükrözi az összeget, ahol a tizedesvessző előtt a bankjegyek száma, és utána - kopecks.

Ennek a problémának többféle módja van.

Megoldás: javascript tizedesjegyek toFixed módszerrel

A toFixed egy beépített javascript módszer, amely bármilyen számra vonatkozik, és a kerekítési pontosságot (azaz a tizedesjegyek számát) veszi paraméterként.

Var szám = 1538.9891200153; num_str = szám.toFixed (); // num_str = 1538; szám_str = szám.helyes (2); //num_str=1538.98; szám_str = szám.helyes (5); //num_str=1538.98912;

Ennek a funkciónak a pontossági paramétere nem lehet kevesebb 0 -nál (nem fogad el negatív értékeket), és nem lehet több 20 -nál.

Változó nélkül is megteheti, például:

Num_str = (1538.9891200153). To Fixed (2); //num_str=1538.98;

2. megoldás: javascript tizedesjegyek a toPrecision módszerrel

Ez a megoldás ugyanazon a beépített javascript módszeren alapul. Ennek a módszernek a megkülönböztető jellemzője, hogy a bemenetként használt paraméter nem a pontosságot (a tizedespont utáni számjegyek számát) jelenti, hanem a számjegyek teljes számát (a tizedespont előtt és után is).

Var szám = 1538.9891200153; szám_str = szám.Pontos (5); //num_str=1538.9; szám_str = szám.Pontos (7); //num_str=1538.989;

Tizedespont megoldás: tizedesjegyek javascript száma

Ha a tizedesjegyeket teljesen el kell dobni, azaz egész törtre kell kerekíteni a tört számot, akkor használhatja a Math osztály funkcióit: kerek, mennyezet és padló.
Kerek - felfelé vagy lefelé kerekít (a számtól függően). Ha a tizedesvessző utáni érték több mint a fele, akkor felfelé, ha kevésbé - lefelé kerekít. Vagyis, ha 0,51 - 1 lesz, ha 0,49 - 0.

Ceil - az angolból. a mennyezet mindig felfelé kerekedik.

Emelet - az angolból. a padló mindig lefelé kerekedik.

Var szám = 1538.9891200153; num_str = Math.round (szám); // num_str = 1539; num_str = Math.floor (szám); // num_str = 1538; szám_str = Math.ceil (szám); // num_str = 1539;

Ez minden. Remélem, ez a bejegyzés segített megoldani a problémát. Ha valami nem sikerült - tegyen fel kérdéseket a "Kérdezzen egy szakembert" zöld gombbal vagy a megjegyzésekben.

Üdv a JavaScript szerelmesei. Ön már észrevette, hogy ez a nyelv nagyon szokatlan, és minden szakaszban kiemelkedik sajátosságaival és szokatlan technikai megoldásaival. Ezért a mai bejegyzés a "JavaScript kerekítés" témának szentelt.

Az aktuális cikk elolvasása után megtudhatja, hogy miért kell kerekíteni a számokat, mely metódusok és tulajdonságok hajtják végre a js -ben ezt a funkciót, valamint azt is, hogy miben különbözik a 0 -val való osztás. Az elveim megváltoztatása nélkül példákat csatolok a az anyagot, és részletesen írja le az egyes műveleteket. Most kezdjük a tanulást!

Fontos megjegyzések a számokkal kapcsolatban

Először is ne feledje, hogy a js -ben mindenféle szám (tört és egész szám) ilyen típusú Szám... Ezenkívül mindegyik 64 bites, mivel a „kettős pontosságú” formátumban vannak tárolva, amelyet IEEE-754 szabványnak is neveznek.

A numerikus változókat a szokásos módon hozzuk létre:

var zsibbadt = 35; // természetes szám

var drob = 0,93; // tizedes ábrázolás

var numb16 = 0xFF; // hexadecimális számrendszer

Támogat más numerikus ábrázolásokat is. Tehát továbbra is létrehozhat lebegőpontos számokat (ezeket néha "tudományos formátumú számoknak" is nevezik).

Van egy nagyon érdekes módszer támogatása toLocaleString (), amely az összes numerikus paramétert az ECMA 402 -ben megadott specifikációk szerint formázza. Ennek köszönhetően a nagy számok, telefonszámok, pénznemek és még százalékok is szépen megjelennek a párbeszédpanelen.

var szám = 714000,80;

alert (num.toLocaleString ());

A Number típusú elemekkel való munkához egy egész globális objektumot kaptak egy csomó mindenféle matematikai függvénnyel, amelyek neve Math.

Ezen kívül vannak más módszerek is, amelyek a számértékeket egész számokra, tizedekre, századokra stb. Tekintsük mindegyiket részletesebben.

Nagy és hatalmas matek

A globális matematikai objektum sokféle matematikai és trigonometriai függvényt tartalmaz. Ez egy nagyon hasznos objektum, és gyakran segít a fejlesztőknek, amikor digitális adatokkal dolgoznak.

Más platformokon a Math analógiái vannak. Például a népszerű nyelveken, mint a Java és a C #, a Math egy olyan osztály, amely ugyanazokat a szabványos funkciókat támogatja. Tehát, mint láthatja, ez a hangszer valóban nagyszerű és erős.

Most szeretném végiggondolni a konkrét kerekítési módszereket, és részletesen beszélni róluk.

Math.floor ()

Kezdem Math.padló... Ügyeljen a módszer nevére. Logikailag világossá válik, hogy mivel kerekítésről beszélünk, és a "floor" szó szó szerinti fordítása "padlót" jelent, akkor ez az eszköz lefelé kerekíti a feldolgozott értékeket.

Az is lehetséges, hogy a funkcióval feldolgozott szám ugyanaz marad. Ez azért van, mert a kerekítést nem szigorú egyenlőtlenség szerint hajtják végre (<=). Таким образом, при отработке этой строчки кода:

riasztás (Math.floor (4.5));

a válasz a 4 -es szám lesz.

Math.ceil ()

Ismét nézze meg a nevet (ily módon az anyag gyorsabban szívódik fel). Ha valaki nem tudja, a mennyezet mennyezetet jelent. Ez azt jelenti, hogy a numerikus adatokat felfelé kerekítik, laza egyenlőtlenség (> =) használatával.

riasztás (matematikai ceil (4.5));

Ahogy sejtette, a válasz az 5 -ös szám lesz.

Math.round ()

Ez a módszer a tört számot a legközelebbi egész számra kerekíti. Tehát, ha a tört rész 0 és 0,5 között van, nem tartalmazza, akkor lefelé kerekít. És ha a törtrész a 0,5 -től a következő egész számig terjedő tartományban van, akkor felfelé kerekítjük a nagyobb egész számra.

riasztás (Math.round (4.5));

Remélem, mindenki gondolta vagy mondta a helyes választ - 5.

Még néhány módszer

A JavaScript rendelkezik 2 másik módszerrel is, amelyek a numerikus ábrázolások kerekítésével foglalkoznak. Ezek azonban némileg különböznek.

Olyan eszközökről lesz szó, mint pl toFixed ()és toPrecision ()... Nemcsak a kerekítésért, hanem bizonyos jelek pontosságáért is felelősek. Vájjunk mélyebbre.

toFixed ()

Ezzel a mechanizmussal megadhatja, hogy hány tizedesjegyig kell kerekíteni az értéket. A metódus karakterláncként adja vissza az eredményt. Az alábbiakban csatoltam egy változatot három különböző változatból. Elemezze a kapott válaszokat.

var szám = 5656,9393;

document.writeln (num.toFixed ()); 5657

document.writeln (szám: fix (2)); 5656.94

document.writeln (szám: fix (7)); 5656.9393000

Mint látható, ha nem ad meg argumentumot, akkor a toFixed ()) kerekíti a törtértéket az egészre számokat. A harmadik sor lekerekített legfeljebb 2 karakter,és a negyedikben - a "7" paraméter miatt további három 0 -t adtak hozzá.

toPrecision ()

Ez a módszer kissé más módon működik. Az argumentum helyett hagyhat üres teret, vagy beállíthat egy paramétert. Ez utóbbi azonban a számokat a megadott számjegyre kerekíti, figyelmen kívül hagyva a vesszőt. Íme az előző példából átírt program eredményei:

var szám = 5656,9393;

document.writeln (szám.toPrecision ()); 5656.9393

document.writeln (szám: toPrecision (2)); 5.7e + 3

document.writeln (szám: pontosság (7)); 5656.939

A 0 -val való osztás jellemző a js -ben

Mint matematikaórákból tudja, nem lehet osztani nullával. Ezt a szabályt vette alapul a programozási nyelvek legtöbb alkotója. Ezért nullával osztva minden program hibát generál.

A JavaScript azonban itt is kitüntette magát. Tehát egy ilyen művelet végrehajtása során nem jelennek meg hibaüzenetek ... mert egy ilyen művelet visszatér "Végtelenség"!

Miért van így? Mint ugyanazokból a matematikai tudományokból tudja, minél kisebb az osztó, annál nagyobb a szám. Ezért a prototípus-orientált nyelv alkotói úgy döntöttek, hogy felhagynak a sablonokkal, és a saját útjukat járják.

Azok számára, akik először találkoznak az Infinity értékével, az alábbiakban kifejtettem jellemzőit.

Végtelen - a végtelenséget jelenti, és teljes mértékben megfelel az ∞ matematikai előjelnek.

Lehet negatív is. Az aritmetikai operátorokkal való munkavégzésre vonatkozó összes szabványos szabályt is megőrzik.

riasztás (12/0); // Végtelenség

riasztás (12.34 / 0); // Végtelenség

riasztás (-3 / 0); // -Végtelenség

Ezen talán, és fejezd be. Ha tetszett a kiadvány, akkor iratkozzon fel a blogomra. Ne légy mohó az érdekes cikkekre mutató linkekkel, és oszd meg barátaiddal. Viszlát!