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

véges függvény

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

Válaszként adott funkciót false értéket ad vissza, ha az argumentum Infinity , -Infinity , NaN , vagy ha ezen speciális numerikus értékek valamelyikére lesz öntve. Ellenkező esetben ez a függvény true -ot ad vissza.

IsFinite(73); // igaz isVéges(-1/0); // false isFinite(Infinite); // false isFinite(NaN); // false isFinite("Szöveg"); // hamis

Az isFinite globális függvényen kívül a JavaScript rendelkezik a Number.isFinite metódussal is. Az isFinite-tel ellentétben nem kényszeríti az argumentum számmá alakítását.

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

isNaN függvény

Az isNaN függvény annak meghatározására szolgál, hogy egy argumentum szám-e, vagy számmá alakítható-e. Ha igen, akkor az isNaN függvény false értéket ad vissza. Ellenkező esetben igazat ad vissza.

IsNaN(NaN); //igaz isNaN("25px"); //igaz, mert 20px nem szám isNaN(25,5); //hamis isNaN("25,5"); //hamis isNaN(" "); //hamis, mert egy szóközt vagy több szóközt 0-ra alakítunk át isNaN(null); //hamis, mert null értéket 0-ra konvertálunk isNaN(igaz); //hamis, mert igaz 1-re konvertálódik isNaN(hamis); //hamis, mert hamis értéket 0-ra konvertálunk

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

Hogyan lehet egy karakterláncot kifejezetten számmá alakítani?

Egy karakterláncot kifejezetten átadhat egy számra a következő módszerekkel:

1. Használja unáris operátor + Az érték elé helyezendő.

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

Ez a módszer figyelmen kívül hagyja a szóközöket a sor elején és végén, valamint a \n-t (soremelés).

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

Használata Ily módon vegye figyelembe, hogy egy üres karakterláncot vagy egy szóközökből és \n-ből álló karakterláncot a rendszer 0 számmá alakítja. Ezenkívül a null adattípust és a logikai értékeket is számmá alakítja.

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

2. ParseInt függvény. Ez a funkció konvertálásra készült argumentum egy egész számra. Használattal szemben unáris operátor +, ez a módszer lehetővé teszi egy karakterlánc számmá alakítását, amelyben nem minden karakter numerikus. Elkezdi konvertálni a karakterláncot, az első karaktertől kezdve. És amint olyan karakterrel találkozik, amely nem numerikus karakter, ez a függvény leállítja a munkáját, és visszaadja a kapott számot.

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

Ez a funkció használható különböző rendszerek számozás (bináris, oktális, decimális, hexadecimális). A számrendszer alapjának jelzése 2 argumentum segítségével történik.

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 a Number.parseInt metódussal. Ez a módszer nem különbözik a parseInt függvénytől, és az ECMASCRIPT 2015(6) specifikációval vezették be a JavaScriptbe.

3. ParseFloat függvény. A parseFloat függvény hasonló a parseInt függvényhez, kivéve, hogy lehetővé teszi az argumentum törtszámmá alakítását.

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

Ezenkívül a parseFloat függvény a parseInt-től eltérően nem rendelkezik 2 argumentummal, ezért mindig megpróbálja a karakterláncot decimális jelölésű számként kezelni.

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

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

Szám konvertálása karakterláncra

Egy számból karakterláncot alakíthat a toString metódussal.

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

A toString metódus lehetővé teszi a számrendszer alapjának megadását is, ennek figyelembevételével a számot kifejezetten a karakterláncba kell önteni:

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

Hogyan ellenőrizhető, hogy egy változó szám-e

A következő módszerek egyikével határozhatja meg, hogy egy változó értéke szám-e:

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

// myVar egy változó if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //sajátVar egy szám vagy átadható rá );

Funkcióként:

// függvény függvény isNumeric(value) ( ​​Return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // usage 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 arra. Ez a változat nem számol számként egy üres karakterláncot, egy szóköz karakterláncot, null , Infinity , -Infinity , igaz és hamis.

2. Használata operátor típusaés függvényei isFinite, isNaN:

// függvény, amely ellenőrzi, hogy az érték szám-e függvény isNumber(value) (érték típusa === "(!LANG:szám" && 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 azt is, hogy az egyikhez tartozik-e különleges értékek Infinity, -Infinity és NaN. Ha igen, akkor ez a függvény igazat ad vissza.

3. Az ECMAScript 6 Number.isInteger(value) metódusának használata. 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 metódus nem fordítja le a karakterláncot számmá Number.isInteger(20); //igaz, mert adott értéket egy szám

Páros és páratlan számok

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

// Függvény annak ellenőrzésére, hogy egy szám páros-e függvény isEven(n) ( return n % 2 == 0; ) // Függvény annak ellenőrzésére, hogy egy szám páratlan-e függvény isOdd(n) ( return Math.abs(n % 2) == 1;)

Az ilyen ellenőrzés elvégzése előtt azonban kívánatos megbizonyosodni arról, hogy a megadott érték egy szám:

érték=20; if (Szám.isegész(érték)) ( if (isEven(érték)) ( console.log("Szám " + value.toString() + " - páros"); ) )

Prímszámok a Javascriptben

Vegyünk egy példát, amelyben a prímszámokat 2-től 100-ig jelenítjük meg Javascript használatával.

// Egy függvény, amely ellenőrzi, hogy egy szám prímfüggvény-e isPrime(érték) (if (isNaN(érték) || !isVéges(é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ám kerekítése Javascriptben

A JavaScriptben többféleképpen is lehet egy törtszámot egész értékre kerekíteni.

1. A kifejezetten erre a célra kialakított Math.floor , Math.ceil és Math.round metódusokkal. A Math.floor módszer egy tört számot lefelé kerekít a legközelebbi egész számra, azaz. egyszerűen elveti a tört részt. A Math.ceil egy tört számot felfelé kerekít a legközelebbi egész számra. A Math.round egy számot felfelé vagy lefelé kerekít a tört rész értékétől függően. Ha egy törtrész nagyobb vagy egyenlő, mint 0,5, majd felfelé, ellenkező esetben a csavar lefelé esik.

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

2. A toFixed (precíziós) módszer használata. Ez a módszer egy szám tört részét a megadott pontosságra kerekíti. A kerekítés eredménye karakterláncként jelenik meg.

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

Ha nincs elég tizedesjegy a szám meghatározott pontosságának kialakításához, akkor a szám nullákkal lesz kitöltve.

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

3. A toPrecision(precision) módszerrel. Ez a módszer a megadott pontossággal ábrázol egy számot. Ugyanakkor nem csak a tört, hanem a teljes számrészt is tudja kerekíteni. A kapott számot ezzel a módszerrel az eredménytől függően fixpontban vagy exponenciális formában is ábrázolhatjuk.

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

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

//kettős logikai negáción keresztül console.log(~~7.9); //7 // logikai VAGY 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() és a parseInt() metódusokkal kaphatja meg:

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

A százalékos (%) operátor segítségével megkaphatja a szám tört részét. Ez az operátor azt a maradékot adja vissza, amelyet az első szám másodikkal való elosztásából kapunk. Ebben az esetben az 1-et kell használni második számként.

Console.log(7,21%1); // 0.20999999999999996 // 2 tizedesjegy pontossággal console.log((7.21%1).toFixed(2)); // "0,21"

Ezenkívül a tört részt számításokkal is megkaphatjuk:

var szám = 7,21; var fractionNumber = szám - Math.floor(Math.abs(szám)); console.log(törtszám); // 0,20999999999999996

Osztható-e a szám

A százalékos operátor segítségével meghatározhatja, hogy egy szám egyenletesen osztható-e:

varszám = 9; // ha a szám 3-mal való osztásának maradéka 0, akkor igen, egyébként nem if (szám%3==0) ( console.log ("A " + szám + " szám osztható 3-mal"); ) else ( console. log("Szám " + szám + " nem osztható 3-mal"); )

Szám formázása

A JavaScriptben a toLocaleString() metódus lehetővé teszi, hogy egy szám kimenetét a területi beállítások (az operációs rendszer nyelvi beállításai) szerint formázza.

Például formázzunk egy számot a rendszerbe 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ázzunk egy 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ó számok pénznemként való formázására is:

Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", pénznem:"RUB"))); //"2 540,13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", pénznem:"USD"))); //"89,30 USD" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", pénznem:"EUR"))); //"2301,99 €"

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

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

Osszuk fel a számot számjegyekre (useGrouping tulajdonság):

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

Nyomtasson ki egy bizonyos számú számjegyet (2) a tizedesvessző után:

Console.log((1240.4564).toLocaleString("ru-RU",(minimális Törtszámjegyek:2, maximum Törtszámjegyek:2))); //"1240.46"

Számok összehasonlítása

A következő operátorok használhatók a számok összehasonlítására JavaScriptben: == (egyenlő), != (nem egyenlő), > (nagyobb, mint),< (меньше), >= (nagyobb vagy egyenlő),<= (меньше или равно).

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

Console.log(2>3); //false console.log(5>=3); //igaz

A számok törtrésszel való összehasonlításakor figyelembe kell venni a számítások során előforduló hibákat.

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

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

Hibák azért fordulnak elő, mert minden számítás számítógépes vagy egyéb elektronikai eszköz 2 számrendszerben termel. Azok. Mielőtt bármilyen műveletet végrehajtana, a számítógépnek először át kell alakítania a kifejezésben szereplő számokat 2-es számrendszerré. De a 2. számrendszerben egyetlen tört decimális szám sem ábrázolható pontosan.

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

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 két szám összegének kiszámítását és az összehasonlítási eredményeket. Azok. kiderül, hogy a JavaScript a következőképpen fogja látni ezt a bejegyzést:

0.6000000000000001==0.6

Törtrészes számok kiszámításakor vagy megjelenítésekor mindig meg kell adni, hogy ezt milyen pontossággal kell elvégezni.

Hasonlítsa össze például a számokat 2 tizedesjegyig a toFixed() és toPrecision() metódusokkal:

//method toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //toPrecision() metódus console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //igaz

Alapvető matematikai műveletek

A JavaScript a következő matematikai operátorokkal rendelkezik: + (összeadás), - (kivonás), * (szorzás), / (osztás), % (osztás maradéka), ++ (érték növelése 1-gyel), -- (érték csökkentése 1-gyel) ).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, azaz 6:3=2 => 6-3*2 => rest(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 => rest(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; konzolnapló(x++); //3-at jelenít meg, majd y-t 4-re állítja console.log(x); //4 x = 3; konzolnapló(++x); //4-et állít be, és x = 5-öt ad ki; konzolnapló(x--); //5-öt ad ki, y ezután 4-et állít be console.log(x); //4 x = 5; konzolnapló(--x); //4-re állítja be, és a kimenetek Ezen kívül vannak kombinált operátorok a JavaScriptben: 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; konzolnapló(x); //9 x = 3; y=6; x-=y; konzolnapló(x); //-3 x = 3; y=6; x*=y; konzolnapló(x); //18 x = 3; y=6; x/=y; konzolnapló(x); //0,5 x = 3; y=6; x%=y; konzolnapló(x); //3

Szia. Ma a Javascript rovatban megnézzük, hogyan lehet beállítani a tizedesjegyek számát a lebegőpontos számokban a javascriptben. Például kiíráskor 3 tizedesjegyet kell hagynia, vagy csak kettőt.

Feladat: javascript tizedesjegyek száma

Tehát egy feladat előtt állunk: van egy számítási eredmény, amelyben vannak számok a tizedesvessző előtt és a tizedesvessző után. Decimális. Tegyük fel, hogy az eredmény a következő: 1538.9891200153. De amikor a kimenetet, akkor kap egy számot, amely tükrözi az összeget, ahol a tizedesvessző előtt a bankjegyek száma, és utána - kopecks.

Számos módja van ennek a probléma megoldásának.

1. megoldás: javascript tizedesjegyek száma toFixed metódussal

A toFixed egy beépített javascript metódus, amely tetszőleges számra alkalmazható, és a kerekítési pontosságot (vagyis a tizedesjegyek számát) veszi paraméterként.

Varnum=1538,9891200153; num_str=num.toFixed(); //num_str=1538; szm_szt=szm.toFixed(2); //num_str=1538,98; szm_szt=szm.toFixed(5); //num_str=1538.98912;

Ebben a függvényben a precíziós paraméternek legalább 0-nak kell lennie (nem vesz fel negatív értékeket), és legfeljebb 20-nak.

Megteheti változó nélkül is, például:

Num_str=(1538.9891200153).toFixed(2); //num_str=1538,98;

2. megoldás: javascript tizedesjegyek száma toPrecision metódussal

Ez a megoldás ugyanazon a beépítettségen alapul javascript módszer. Megkülönböztető tulajdonság Ennek a módszernek az a lényege, hogy a bemenetként vett paraméter nem a pontosságot (tizedesjegyek számát) jelzi, hanem a karakterek teljes számát (a tizedesvessző előtt és után egyaránt).

Varnum=1538,9891200153; szm_szt=szm.toPrecision(5); //num_str=1538.9; szm_szt=szm.toPrecision(7); //num_str=1538.989;

Megoldás tizedesjegyek nélkül: javascript tizedesjegyek száma

Ha a tizedesjegyeket teljesen el kell hagyni, vagyis egy tört számot egész számra kell kerekíteni, akkor használhatja a Math osztály függvényeit: round, ceil és floor.
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é kerekít, ha kisebb, akkor lefelé. Vagyis ha 0,51 - 1 lesz, ha 0,49 - 0.

Mennyezet – angolból. a mennyezet mindig felfelé kerekedik.

Emelet - angolból. A nem mindig lefelé kerekedik.

Varnum = 1538,9891200153; num_str=math.round(szám); //num_str=1539; num_str=Math.floor(szám); //num_str=1538; num_str=Math.ceil(szám); //num_str=1539;

Ez minden. Remélem, hogy ez a megjegyzés segített megoldani a problémát. Ha valami nem sikerült, tegye fel kérdéseit a zöld „Kérdés a szakembernek” gombbal vagy a megjegyzésekben.

Nagyon gyakran a JavaScriptben végzett számítások nem pontosan azt az eredményt adják, amit szeretnénk. Természetesen a számokkal bármit megtehetünk - felfelé vagy lefelé kerekíthetünk, tartományokat állíthatunk be, a szükségtelen számokat bizonyos tizedesjegyig levághatjuk, minden attól függ, hogy a jövőben mit akarunk ezzel a számmal kezdeni.

Miért szükséges a kerekítés?

A JavaScript egyik érdekessége, hogy valójában nem tárol egész számokat, azonnal lebegőpontos számokkal dolgozunk. Ez, kombinálva azzal a ténnyel, hogy sok törtérték nem fejezhető ki véges számú tizedesjegyekkel, JavaScriptben a következő eredményeket kaphatjuk:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Gyakorlati szempontból ez a pontatlanság nem számít, esetünkben ötmilliárd részvény hibájáról beszélünk, azonban ez valakit csalódást okozhat. Különös eredményeket is kaphatunk, ha olyan számokkal dolgozunk, amelyek pénznemeket, százalékokat vagy fájlméreteket jelentenek. Ahhoz, hogy ezeket a pontatlanságokat kijavítsuk, csak kerekíteni kell az eredményeket, és elég beállítani a tizedespontosságot.

A számok kerekítésének gyakorlati haszna van, manipulálhatunk egy számot valamilyen tartományban, például egy értéket a legközelebbi egészre szeretnénk kerekíteni ahelyett, hogy csak a tizedes résszel dolgoznánk.

Tizedesjegyek kerekítése

Tizedes szám vágásához használja a toFixed vagy a toPrecision módszert. Mindkettő egyetlen argumentumot vesz fel, amely meghatározza, hogy hány jelentős számjegyet (vagyis a számban használt számjegyek teljes számát) vagy tizedesjegyet (a tizedesvessző utáni számot) tartalmazzon az eredmény:

1. Ha az argumentum nincs megadva a toFixed()-hez, akkor alapértelmezés szerint nulla lesz, ami 0 tizedesjegyet jelent, az argumentum maximális értéke 20.
2. Ha nem ad meg argumentumot a toPrecisionhoz, akkor a szám érintetlenül marad

legyen randNum = 6,25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87,335; randNum.toFixed(2); > "87,33" randNum = 87,337; randNum.toPrecision(3); > "87.3"
Mind a toFixed() mind a toPrecision() metódus az eredmény karakterlánc-ábrázolását adja vissza, nem pedig számot. Ez azt jelenti, hogy ha a kerekített értéket a randNum -mal összegzi, akkor a karakterláncok összefűződnek, nem pedig számok adódnak hozzá:

Legyen randNum = 6,25; legyen kerekítve = randNum.toFixed(); // "6" console.log(randNum + kerekített); > "6.256"
Ha azt szeretné, hogy az eredmény numerikus adattípus legyen, akkor a parseFloat-ot kell használnia:

Legyen randNum = 6,25; legyen kerekítve = parseFloat(randNum.toFixed(1)); konzolnapló (lekerekített); > 6.3
Vegye figyelembe, hogy ritka esetek kivételével 5 érték kerekítve van.

A toFixed() és toPrecision() metódusok azért hasznosak, mert nem csak a töredéket tudják levágni, hanem a tizedesjegyeket is kitöltik, ami kényelmes a pénznemekkel való munka során:

Legyen teljesSzam = 1 legyen dollarCents = teljesSzam.toFixed(2); console.log(dollárCents); > "1.00"
Vegye figyelembe, hogy a toPrecision az eredményt exponenciális jelöléssel adja vissza, ha az egész számok száma nagyobb, mint maga a pontosság:

Legyen num = 123,435 num.toPrecision(2); > "1.2e+2"

Hogyan kerüljük el a tizedesjegyekkel történő kerekítési hibákat

Egyes esetekben a toFixed és toPrecision az 5-ös értéket lefelé és felfelé kerekíti:

Legyen numTest = 1,005; számTest.toFixed(2); > "1.00"
A fenti számítás eredményének 1,01-nek kellett volna lennie, nem 1-nek. Ha el akarja kerülni ezt a fajta hibát, használhatja a Jack L Moore által javasolt megoldást, amely exponenciális számokat használ a számításhoz:

Függvény kör(érték, tizedesjegy) ( return Number(Math.round(érték+"e"+tizedes)+"e-"+tizedes); )
Most:

forduló(1,005,2); > 1.01
Ha a fentinél robusztusabb megoldást szeretne, lépjen az MDN-re.

Gépi epszilon kerekítés

Az ES6-ban egy alternatív módszert vezettek be a decimális számok kerekítésére. A gépi epszilon kerekítés ésszerű hibahatárt biztosít két lebegőpontos szám összehasonlításakor. Kerekítés nélkül az összehasonlítások a következőkhöz hasonló eredményeket hozhatnak:

0,1 + 0,2 === 0,3 > hamis
A megfelelő összehasonlítás érdekében a Math.EPSILON-t használjuk függvényünkben:

epsEqu(x, y) függvény ( visszatér Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
A függvénynek két argumentuma van: az első az aktuális számítás, a második a várt eredmény. A kettő összehasonlítását adja vissza:

EpsEqu(0,1 + 0,2; 0,3) > igaz
Az összes modern böngésző már támogatja az ES6 matematikai függvényeit, de ha olyan böngészőket szeretne támogatni, mint az IE 11, használjon többkitöltést.

Frakcionált vágás

Az összes fent bemutatott módszer képes decimális számokra kerekíteni. Ahhoz, hogy egy számot egyszerűen két tizedesjegyre levághasson, először meg kell szoroznia 100-zal, majd el kell osztania az eredményt 100-zal:

Függvény csonka(szám) ( return Math.trunc(num * 100) / 100; ) csonka(3,1416) > 3,14
Ha a módszert tetszőleges számú tizedesjegyhez szeretné igazítani, használhatja a bitenkénti kettős tagadást:

Függvény csonkolt(szám, decimalPlaces) ( legyen numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Most:

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

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

Egy tizedes szám felfelé vagy lefelé kerekítéséhez a legközelebbi számra, attól függően, hogy mi áll a legközelebb, használja a Math.round():

Math.round(4.3) > 4 Math.round(4.5) > 5
Megjegyzendő, hogy az "érték felét", 0,5-öt a matematika szabályai felfelé kerekítik.

Lefelé kerekítés a legközelebbi egész számra

Ha mindig lefelé szeretné kerekíteni, használja a Math.floor-t:

matek.emelet(42,23); > 42 Math.floor(36,93); > 36
Vegye figyelembe, hogy a lefelé kerekítés minden számra működik, beleértve a negatív számokat is. Képzeljen el egy felhőkarcolót végtelen számú emelettel, beleértve az alsó szinteket is (negatív számokat jelent). Ha egy liftben tartózkodik az alsó szinten 2 és 3 között (ami -2,5 érték), a Math.floor a -3-ba viszi:

Math.floor(-2,5); > -3
De ha el akarja kerülni az ilyen helyzeteket, használja a Math.trunc fájlt, amelyet minden modern böngésző támogat (kivéve IE/Edge):

Math.trunc(-41,43); > -41
Az MDN-en található egy polifill, amely támogatja a Math.trunc fájlt a böngészőkben és az IE/Edge-ben.

Felkerekítés a legközelebbi egész számra

Másrészt, ha mindig felfelé kell kerekíteni, használja a Math.ceil-t. Ismét emlékezve a végtelen liftre: a Math.ceil mindig "felfelé" fog menni, függetlenül attól, hogy a szám negatív-e vagy sem:

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

Szükség szerint kerekítse fel/le

Ha fel akarunk kerekíteni 5 legközelebbi többszörösére, akkor a legegyszerűbb, ha létrehozunk egy függvényt, amely eloszt egy számot 5-tel, felfelé kerekíti, majd megszorozza ugyanannyival:

Funkció roundTo5(num) ( return Math.round(num/5)*5; )
Most:

RoundTo5(11); > 10
Ha az érték többszörösére szeretne kerekíteni, akkor egy általánosabb függvényt használunk, amely a kezdeti értéket és a többszörösét adja meg:

Funkció roundToMultiple(szám, többszörös) ( visszatér Math.round(szám/többes)*multiple; )
Most:

Legyen kezdetiSzám = 11; legyen többszörös = 10; roundToMultiple(kezdetiSzam, többszörös); > 10;

Egy szám rögzítése egy tartományban

Sok olyan eset van, amikor egy tartományon belüli x értéket szeretnénk kapni. Például lehet, hogy szeretnénk egy értéket 1 és 100 között, de végül 123-at kaptunk. Ennek kijavításához használhatjuk a min (egy számhalmaz legkisebb értékét adja vissza) és max (bármely halmaz közül a legnagyobbat adja vissza) számok). Példánkban a tartomány 1 és 100 között van:

Legyen alsó határ = 1; legyen highBound = 100; legyen numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); konzolnapló (befogott); > 100;
Ismét felhasználhatjuk a műveletet, és az egészet egy függvénybe csomagolhatjuk, a Daniel X. Moore által javasolt megoldást használva:

Number.prototype.clamp = függvény(min, max) ( return Math.min(Math.max(this, min), max); );
Most:

NumInput.clamp(lowBound, highBound); > 100;

Gauss-féle kerekítés

A Gauss-féle kerekítés, más néven bankári kerekítés, az, hogy ebben az esetben a kerekítés a legközelebbi páros számra történik. Ez a kerekítési módszer statisztikai hiba nélkül működik. A legjobb megoldás Tim Down javasolta:

GaussRound(szám, decimális Helyek) függvény ( legyen d = decimális Helyek || 0, m = Math.pow(10, d), n = +(d ? szm * m: szám).toFixed(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; }
Most:

GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Tizedespont a CSS-ben:

Mivel a JavaScriptet gyakran használják HTML-elemek helyzeti transzformációinak létrehozására, felmerülhet a kérdés, mi történik, ha decimális értékeket generálunk elemeinkhez:

#box (szélesség: 63,667731993px; )
A jó hír az, hogy a modern böngészők tiszteletben tartják a dobozos modellben a decimális értékeket, beleértve a százalékos vagy pixel egységeket.

Válogató

Nagyon gyakran kell rendeznünk egyes elemeket, például van egy sor játékrekordunk, miközben azokat a játékosok rangja szerint csökkenő sorrendbe kell rendezni. Sajnos a standard sort() metódusnak van néhány meglepő korlátja: jól működik a gyakori angol szavakkal, de azonnal lebomlik, ha számokkal, egyedi karakterekkel vagy nagybetűs szavakkal találkozik.

Rendezés ábécé szerint

Úgy tűnik, hogy a tömb ábécé szerinti rendezése a legegyszerűbb feladat:

Legyen gyümölcs = ["vajtök", "sárgabarack", "sárgabarack"]; gyümölcs rendezés(); > "sárgabarack", "vajtök", "sárgabarack"]
Problémába ütközünk azonban, amint az egyik elem nagybetűs:

Legyen gyümölcs = ["vajtök", "sárgabarack", "Sárgaszárú"]; gyümölcs rendezés(); > "Mendridinnye", "sárgabarack", "vajtök"]
Ennek az az oka, hogy alapértelmezés szerint a rendező a Unicode-ban szereplő első karaktert hasonlítja össze. Az Unicode minden karakter egyedi kódja, platformtól, programtól, nyelvtől függetlenül. Például, ha a kódtáblázatot nézzük, az "a" karakter értéke U+0061 (hexadecimális 0x61), míg a "C" karakter U+0043 (0x43) kódja, amely a Unicode-ban a karakter előtt áll. táblázat. „a”.

Egy vegyes kis- és nagybetűket tartalmazó tömb rendezéséhez vagy ideiglenesen az összes elemet kisbetűssé kell alakítanunk, vagy meg kell határoznunk a saját rendezési sorrendünket a localeCompare() metódussal néhány argumentummal. Általában ilyen esetben jobb, ha azonnal létrehoz egy funkciót többszörös használatra:

függvény alphaSort(arr) ( arr.sort(függvény (a, b) ( return a.localeCompare(b, "en", ("érzékenység": "alap")); )); ) hagyja gyümölcs = ["vajtök ", "sárgabarack", "Menderdinnye"]; alphaSort(gyümölcs) >
Ha egy tömböt fordított ábécé sorrendbe szeretne rendezni, egyszerűen cserélje fel a és b pozícióit a függvényben:

függvény alphaSort(arr) ( arr.sort(függvény (a, b) ( return b.localeCompare(a, "en", ("érzékenység": "alap")); )); ) hagyja gyümölcs = ["vajtök ", "sárgabarack", "Menderdinnye"]; alphaSort(gyümölcs) > ["Santaloupe", "vajtök", "sárgabarack"]
Itt érdemes megjegyezni, hogy a localeCompare-t argumentumokkal használjuk, emlékeznünk kell arra is, hogy az IE11+ támogatja, az IE régebbi verzióinál használhatjuk argumentumok nélkül, kisbetűvel:

Függvény caseSort(arr) ( arr.sort(függvény (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["vajtök", "barack", "Kantalup dinnye"]; caseSort(fruit) > ["sárgabarack", "vajtök", "kantalop"]

Numerikus rendezés

Mindez nem vonatkozik arra a példára, amelyről fentebb a játékrekordok tömbjéről beszéltünk. Egyes numerikus tömbökkel a rendezés jól működik, de egy ponton az eredmény megjósolhatatlan lehet:

Legyen highScores = ; fajta(); >
A helyzet az, hogy a sort() metódus lexikográfiai összehasonlítást hajt végre: ami azt jelenti, hogy a számok karakterláncokká alakulnak, és ismét az összehasonlítások történnek úgy, hogy ennek a karakterláncnak az első karakterét a Unicode tábla karaktereinek sorrendjében egyeztetjük. Ezért ismét meg kell határoznunk a rendezési sorrendet:

Legyen highScores = ; highScores.sort(függvény(a,b) ( return a - b; )); >
Ismételten a számok rendezéséhez fordított sorrendben, felcseréli a és b pozícióját a függvényben.

JSON-szerű struktúra rendezése

És végül, ha van egy JSON-szerű adatszerkezetünk játékrekordok tömbjeként:

Legyen pontszámok = [ ( "név": "Daniel", "pontszám": 21768 ), ( "név": "Michael", "pontszám": 33579 ), ( "név": "Alison", "pontszám": 38395 )];
Az ES6+-ban a nyíl függvényeket használhatja:

Scores.sort((a, b) => b.score - a.score));
Régebbi böngészők esetén, amelyek nem rendelkeznek ezzel a támogatással:

Scores.sort(függvény(a, b) ( return a.score - b.score ));
Amint látja, a JavaScript-ben való rendezés meglehetősen nem magától értetődő dolog, remélem, ezek a példák valahogy megkönnyítik az életet.

Munka a teljesítmény függvényekkel

A hatványozás egy olyan művelet, amelyet eredetileg egy természetes szám önmagával való szorzásának eredményeként határoztak meg. Ezeket a függvényeket folyamatosan használhatjuk a mindennapi életben matematika órán, így terület-, térfogatszámításnál, vagy akár fizikai modellezésnél is.

A JavaScriptben a hatványfüggvényt Math.pow()-ként ábrázolják, az új ES7 szabványban került bevezetésre új kezelő hatványozás - " * * ".

Hatványozás

Egy szám n-edik hatványra emeléséhez használja a Math.pow() függvényt, ahol az első argumentum a hatványra emelendő szám, a második argumentum pedig a kitevő:

Math.pow(3,2) > 9
Ez a jelölés 3 négyzetet, vagy 3 × 3-at jelent, ami 9-es eredményt ad. Természetesen egy másik példa is megadható:

Math.pow(5,3); > 125
Vagyis 5 kocka vagy 5 × 5 × 5 egyenlő 125-tel.

Az ECMAScript 7 a JavaScript következő verziója, elvileg használhatjuk az új javasolt hatványozási operátort - * *, ez az írási forma leíróbb lehet:

3 ** 2 > 9
A Ebben a pillanatban ennek az operátornak a támogatása meglehetősen korlátozott, ezért használata nem ajánlott.

A teljesítmény funkció sokféle helyzetben jól jöhet. Egy egyszerű példa, egy óra másodpercek számának kiszámítása: Math.pow(60,2).

Négyzet- és kockagyökér

A Math.sqrt() és a Math.cbrt() a Math.pow() ellentéte. Emlékszünk rá, hogy az a négyzetgyöke az a szám, amely négyzetre emelve a-t ad.

Math.sqrt(9) > 3
Ugyanakkor az a kockagyöke az a szám, amely kockára téve a-t ad.

Math.cbrt(125) > 5
A Math.cbrt() nemrég került be a JavaScript specifikációjába, ezért csak a modern böngészők támogatják: Chrome 38+, Firefox és Opera 25+, valamint Safari 7.1+. Észre fogja venni internet böngésző nem szerepel ezen a listán, de az MDN-en találhat polifilt.

Példák

Természetesen használhatunk nem egész értékeket is az alábbi függvények egyikében:

Math.pow(1,25; 2); > 1,5625 Math.cbrt(56,57) > 3,8387991760286138
Vegye figyelembe, hogy ez ugyanúgy működik, ha negatív argumentumértékeket használ:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0,01
Négyzetgyök esetén azonban ez nem működik:

Math.sqrt(-9) > NaN
A matematikai elemzésből tudjuk, hogy a képzeletbeli szám alatt negatív számok négyzetgyökét értjük. És ez elvezethet bennünket egy másik összetett számtechnikához, de ez egy másik történet.

A Math.pow() törtértékekkel megkeresheti a számok négyzet- és kockagyökét. A négyzetgyök 0,5 kitevőt használ:

Math.pow(5; 0,5); // = Math.sqrt(5) = 5 ** (1/2) > 2,23606797749979
A lebegőpontos különbségek miatt azonban nem lehet pontosan kitalálni a helyes eredményt:

Math.pow(2,23606797749979.2) > 5,000000000000001
Ilyen helyzetekben a jelek számból való levágásához vagy valamilyen értékre kerekítéséhez kell folyamodnia.

Egyesek, a JavaScriptben megmagyarázhatatlan módon, összekeverik a Math.pow() függvényt a Math.exp() -vel, amely általában a számok exponenciális függvénye. Megjegyzés: angolul a "kitevő" szót "kitevő"-nek fordítják, így ez inkább az angolul beszélőkre vonatkozik, bár a kitevőnek vannak alternatív nevei is, például index, hatvány.

Matematikai állandók

A matematikával való munkát a JavaScriptben számos beépített konstans könnyíti meg. Ezek az állandók a Math objektum tulajdonságai. Érdemes megjegyezni, hogy az állandókat nagybetűvel írjuk, nem CamelCase jelöléssel.

Math.abs, parseInt, parseFloat

A számokkal való munka a JavaScriptben sokkal bonyolultabb lehet, mint gondolná. A kapott értékek nem mindig esnek a várt tartományokba, előfordulhat, hogy az eredmény egyáltalán nem az, amit vártunk.

Math.abs()

A Math.abs() metódus egy szám abszolút értékét adja vissza, ami az analóg matematikai modulo a függvényre emlékeztet.

Legyen newVal = -57,64; Math.abs(newVal); > 57,64
A Math.abs(0) mindig nullát ad vissza, de ha mínuszjelet teszünk a -Math.abs(NUM) függvény elé, akkor mindig negatív értéket kapunk.

Math.abs(0); > -0

parseInt()

Tudjuk, hogy a JavaScript megérti, hogy a "15" egy karakterlánc, nem pedig egy szám, és például a CSS-tulajdonságok JavaScript használatával történő elemzésekor, vagy egy előkészítetlen tömbből kapunk valamilyen értéket, eredményeink kiszámíthatatlanok lehetnek. Kaphatunk egy "17px" karakterláncot bemenetként, és ez nem ritka nálunk. A kérdés az, hogy ezt a karakterláncot hogyan lehet tényleges értékre konvertálni és felhasználni a további számításokhoz.

Szintaxis: parseInt(string, radix);

A parseInt függvény a neki átadott első argumentumot karakterlánctípussá alakítja, értelmezi, és egész számot vagy NaN értéket ad vissza. Az eredmény (ha nem NaN) egy egész szám, és az első argumentum (karakterlánc), amelyet számként kezelnek a megadott számrendszerben (radix). Például a 10-es bázis a decimálisból, a 8-as az oktálisból, a 16-os a hexadecimálisból való átváltást jelöli, és így tovább. Ha az alap nagyobb, mint 10, akkor a 9-nél nagyobb számokat betűkkel jelöljük. Például a hexadecimális számok (16-os bázis) A-tól F-ig terjedő betűket használnak.

Vegyünk egy példát a CSS-tulajdonságokkal való munkavégzésre, ahol viszonylagosan a következő értéket kaphatjuk:

Legyen elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087,19px"
Az értékeket szóközzel elválaszthatjuk:

Legyen centers = centerPoint.split(" "); > ["454px", "2087,19px"]
Azonban minden elem továbbra is egy karakterlánc, ettől megszabadulhatunk a függvényünk segítségével:

Legyen centerX = parseInt(centers, 10); > 454 legyen centerY = parseInt(centers, 10); > 2087
Mint látható, második argumentumként megadjuk azt a számrendszert, amelyre a szám konvertálásra kerül, ez a paraméter nem kötelező, de akkor ajánlott használni, ha nem tudja, hogy melyik karakterlánc kerül beírásra.

parseFloat()

A fenti példából észrevehette, hogy a parseInt elveti a tört részt. Esetünkben a parseFloat működhet lebegőpontos számokkal. Ez ismét hasznos lehet a CSS-elemzésben és más feladatokban, különösen a lebegőpontos százalékok kezelésekor.

Szintaxis: parseFloat(karakterlánc)

LetFP = "33,33333%"; console.log(parseFloat(FP)); > 33,33333
Vegye figyelembe, hogy a parseFloat szintaxisban nincs második argumentum.

Megértjük, hogy a parseInt() és a parseFloat() rendkívüli hasznos funkciókat, fontos szem előtt tartani, hogy biztosan előfordulhatnak hibák, ezért ellenőriznie kell a várható értékek tartományát, és végül elemeznie kell az eredményt, hogy megbizonyosodjon arról, hogy a kapott értékek helyesek.
Névtelenül küldje el

JavaScript matematikai kerekítés két tizedesjegyre (9)

A következő JavaScript szintaxisom van:

Vardiscount = Math.round(100 - (ár / listaár) * 100);

Ez egész számra kerekít. Hogyan adhatok vissza két tizedesjegyű eredményt?

Íme egy működő példa

varvalue=200,2365455; eredmény=Math.round(érték*100)/100 //az eredmény 200,24 lesz

A tetszőleges számú tizedesjegyre történő kerekítés kezeléséhez a legtöbb igényhez elegendő egy 2 soros kóddal rendelkező függvény. Itt van egy példakód a játékhoz.

var tesztNum = 134,9567654; var decPL = 2; var testRes = roundDec(tesztNum,decPl); figyelmeztetés (testNum + " kerekítve " + decPl + " tizedesjegyek értéke " + testRes); function roundDec(nbr,dec_places)( var mult = Math.pow(10,dec_places); return Math.round(nbr * mult) / mult; )

A legjobb és legegyszerűbb megoldás, amit találtam

Funkció round(érték, decimális) ( return Number(Math.round(érték+"e"+tizedes)+"e-"+tizedesek; ) round(1.005, 2); 1.01

Egy kis eltérés az elfogadott választól. A toFixed(2) egy karakterláncot ad vissza, és mindig két tizedesjegyet kapunk. Lehet nulla is. Ha el akarja tiltani a záró null(oka)t, tegye a következőket:

Var kedvezmény = + ((ár / listaár).toFixed(2));

Szerkesztve: Most fedeztem fel, hogy a Firefox 35.0.1 hibája lehet, ami azt jelenti, hogy a fentiek bizonyos értékeket adhatnak a NaN-nek.
A kódomat erre változtattam

Vardiscount = Math.round(ár / listaár * 100) / 100;

Ez két tizedesjegy pontosságú számot ad. Ha háromra van szüksége, akkor szoroz és oszt 1000-rel, és így tovább.
Az OP mindig két tizedesjegyet akar, de ha a toFixed() hibás a Firefoxban, először ki kell javítani.
Lásd: https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Ha az eredményt 2 tizedesjegy pontossággal szeretné megkapni, tegye a következőket:

Vardiscount = Math.round((100 - (ár / listaár) * 100) * 100) / 100;

A kerekítendő értéket megszorozzuk 100-zal, hogy az első két számjegy megmaradjon, majd elosztjuk 100-zal, hogy megkapjuk a tényleges eredményt.

azt gondolom A legjobb mód Az egyik, amit láttam, szorozzuk meg 10-zel a számjegyek számával, majd végezzük el a Math.round-ot, végül elosztjuk 10-zel a számjegyek számával. Itt egyszerű funkció, amit gépírással használok:

Funkció roundToXDigits(érték: szám, számjegyek: szám) ( érték = érték * Math.pow(10, számjegy); érték = Math.round(érték); érték = érték / Math.pow(10, számjegy); visszatérési érték; )

Vagy egyszerű javascript:

Funkció roundToXDigits(érték, számjegyek) ( if(!számjegyek)( számjegyek = 2; ) érték = érték * Math.pow(10, számjegyek); érték = Math.round(value); érték = érték / Math.pow(10 , számjegyek); visszatérési érték; )

JEGYZET. - Ha fontos a 3 számjegy pontossága, lásd a 4. szerkesztést.

Vardiscount = (ár / listaár).toFixed(2);

Rögzített kerekítések felfelé vagy lefelé a 2 tizedesjegynél nagyobb értékektől függően.

Változás. Amint azt mások is említették, ez az eredményt karakterláncsá alakítja. Ennek elkerülése érdekében:

Vardiscount = +((ár / listaár).Fixed(2));

Szerkesztés 2- Ahogy a megjegyzésekben említettük, ez a függvény nem hajtódik végre bizonyos pontossággal, például 1.005 esetén 1.01 helyett 1.00-at ad vissza. Ha ennyire fontos a pontosság, ezt a választ találtam: https://.com/a/32605063/1726511. Úgy tűnik, hogy az általam kipróbált összes teszttel jól működik.

Egy kisebb módosításra van szükség, de a fenti válasz függvénye egész számokat ad vissza, amikor egyre kerekít, így például a 99.004 99.00 helyett 99-et ad vissza, ami nem ideális az árak megjelenítéséhez.

Szerkesztés 3- Úgy tűnik, hogy a tényleges STILL visszatérési toFixed elrontott néhány számot, ez a végső szerkesztés úgy tűnik, működik. Hú, annyi jóvátételt!

Vardiscount = roundTo((ár / listaár), 2); függvény roundTo(n, számjegyek) ( if (számjegyek === undefined) ( számjegyek = 0; ) var multiplicator = Math.pow(10, számjegyek); n = parseFloat((n * szorzó).toFixed(11)); var teszt =(Math.round(n) / szorzó); return +(test.toFixed(digits)); )

Szerkesztés 4- Megölsz srácok. A 3. szerkesztés sikertelen negatív számok esetén anélkül, hogy megvizsgálná, miért egyszerűbb a negatív számot pozitívvá tenni a kerekítés előtt, majd visszadobni az eredmény visszaadása előtt.

Funkció roundTo(n, számjegy) ( var negatív = false; if (számjegyek === meghatározatlan) ( számjegyek = 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; }

A leggyorsabb módja- gyorsabb, mint a toFixed():

KÉT DECALYS

x = .123456 eredmény = Math.round(x * 100) / 100 // eredmény .12

HÁROM Tizedesjegy

x = .123456 eredmény = Math.round(x * 1000) / 1000 // eredmény .123

Függvény round(num,dec) ( num = Math.round(num+"e"+dec) return Number(num+"e-"+dec) ) //Kerekítés tetszés szerinti tizedesjegyre: round(1,3453,2)

Sziasztok JavaScript szerelmesei. Már észrevetted, hogy ez a nyelv rendkívül rendkívüli, és minden szekcióban kiemelkedik a saját jellemzőivel és szokatlan műszaki megoldások. Ezért a mai kiadvány a "JavaScript kerekítés" témának szól.

Az aktuális cikk elolvasása után megtudhatja, miért van szükség a számok kerekítésére, a js-ben milyen metódusok és tulajdonságok hajtják végre ezt a funkciót, és mi különbözteti meg a 0-val való osztást. Elveim megváltoztatása nélkül, példákat csatolok a számok kulcspontjaihoz. anyagot, és írja le részletesen az egyes műveleteket. Most pedig kezdjük el 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) típusú szám. Ráadásul ezek mind 64 bitesek, mivel „kettős pontosságú” formátumban vannak tárolva, amely IEEE-754 szabványként is ismert.

A numerikus változók létrehozása a szokásos módon történik:

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

vardrob = 0,93; //tizedes ábrázolás

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

Támogatja a többi numerikus megjelenítést is. Tehát továbbra is létrehozhat lebegőpontos számokat (ezeket néha "tudományos formátumú számoknak" nevezik).

Hozzáadott támogatás egy nagyon érdekes módszerhez toLocaleString(), amely az összes numerikus paramétert az ECMA 402-ben előírt előírások szerint formázza. Emiatt nagy számok, telefonszámok, a pénznemek, sőt a százalékok is szépen megjelennek a párbeszédpanelen.

varnum = 714000,80;

alert(num.toLocaleString());

A Number típusú elemekkel való munkavégzéshez egy egész globális objektumot számos különféle elemmel láttunk el matematikai függvények, kinek a neve Math.

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

Nagyszerű és hatalmas matematika

A globális matematikai objektum számos matematikai és trigonometrikus függvényt tartalmaz. Ez egy nagyon szükséges objektum, és gyakran segít a fejlesztőknek a digitális adatokkal való munka során.

Más platformokon vannak analógiák a matematikával. Például az olyan népszerű nyelveken, mint a Java és a C#, a Math egy olyan osztály, amely ugyanazokat a szabványos függvényeket támogatja. Tehát amint látja, ez az eszköz igazán nagyszerű és erős.

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

Math.floor()

azzal kezdem Math.padló. Ügyeljen a módszer nevére. Logikusan ez világossá válik beszélgetünk a kerekítésről, é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 előfordulhat, hogy az ezzel a funkcióval feldolgozott szám változatlan marad. Ennek az az oka, hogy a kerekítés nem szigorú egyenlőtlenség szerint történik (<=). Таким образом, при отработке этой строчки кода:

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

a válasz a 4-es lesz.

Math.ceil()

Ismét nézd meg a címet (ilyen módon gyorsabban szívódik fel az anyag). Ha valaki nem tudja, akkor a "plafon" azt jelenti, hogy "plafon". Ez azt jelenti, hogy a numerikus adatokat egy nem szigorú egyenlőtlenség (>=) alkalmazásával felfelé kerekítjük.

alert(Math.ceil(4.5));

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

matek forduló()

Ez a módszer egy törtszámot a legközelebbi egész számra kerekít. Tehát, ha a tört rész 0 és 0,5 közötti tartományban van, akkor a kerekítés kisebb értékre történik. És ha a tört rész a 0,5-től a következő egészig terjedő tartományban van, akkor a rendszer felkerekíti egy nagyobb egész számra.

alert(Math.round(4.5));

Remélem mindenki azt gondolta vagy mondta, hogy a helyes válasz az 5.

Még néhány módszer

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

Olyan eszközökről beszélünk, mint pl javítva()és Precision(). Nemcsak a kerekítésért, hanem bizonyos jelek pontosságáért is felelősek. Ássunk mélyebbre.

javítva()

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

varnum = 5656,9393;

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

document.writeln(num.toFixed(2)); // 5656.94

document.writeln(num.toFixed(7)); // 5656.9393000

Amint láthatja, ha nem ad meg argumentumot, akkor a toFixed ()) kerekíti a tört értéket az egészhez számok. A harmadik sor lekerekített legfeljebb 2 karakter, a negyedikben pedig a „7” paraméter miatt még három 0-t adtak hozzá.

Precision()

Ez a módszer egy kicsit másképp működik. Az argumentum helyett hagyhat üres helyet és beállíthat egy paramétert. Ez utóbbi azonban a számokat a megadott számú számjegyre kerekíti, függetlenül a vesszőtől. Íme az előző példából átírt program eredménye:

varnum = 5656,9393;

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

document.writeln(num.toPrecision(2)); // 5,7e+3

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

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

A matematika órákból tudja, hogy nem lehet nullával osztani. Ezt a szabályt vette alapul a legtöbb programozási nyelv alkotója. Ezért nullával való osztásakor minden program hibát produkál.

A JavaScript azonban itt is remekelt. Tehát egy ilyen művelet végrehajtása során nem történik hibajelentés ... mert egy ilyen művelet visszatér "Végtelenség"!

Miért is? Amint az ugyanezen matematikai tudományokból ismeretes, minél kisebb az osztó, az eredmény több. Ezért döntöttek úgy a prototípus-alapú nyelv készítői, hogy elhagyják a sablonokat, és a saját útjukat járják.

Azok számára, akik még nem ismerik az Infinity jelentését, az alábbiakban ismertetem a jellemzőit.

Végtelen - a végtelent jelenti, és teljes mértékben megfelel a ∞ matematikai jelnek.

Lehet negatív. Az aritmetikai operátorokkal való munkavégzés összes szabványos szabálya szintén megmarad.

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

figyelmeztetés(12.34/0); // Végtelenség

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

Ezzel talán befejezem. Ha tetszett a bejegyzés, feltétlenül iratkozz fel a blogomra. Nyugodtan hivatkozzon érdekes cikkekre, és ossza meg azokat barátaival. Viszlát!