Ez a cikk közelebbről megvizsgálja a számokat, a matematikai operátorokat, a számok karakterláncokká 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álaszként ez a függvény hamis értéket ad vissza, ha az argumentum Infinity, -Infinity, NaN, vagy ha ezeknek a speciális numerikus értékeknek az egyikére adjuk át. Ellenkező esetben ez a függvény igaz lesz.
IsFinite (73); // igaz isFinite (-1/0); // hamis isFinite (Végtelen); // hamis isFinite (NaN); // false isFinite ("Szöveg"); // hamis
Az isFinite globális függvény mellett a JavaScript rendelkezik egy Number.isFinite módszerrel is. Az isFinite-től eltérően nem kényszeríti az argumentumot egy számra.
IsFinite ("73"); // true Number.isFinite ("73"); // hamis
IsNaN függvény
Az isNaN függvény célja annak meghatározása, hogy egy argumentum szám-e vagy konvertálható-e rá. Ha igen, az isNaN függvény hamis értéket ad vissza. Ellenkező esetben igazra tér vissza.
IsNaN (NaN); // igaz isNaN ("25px"); // igaz, mert A 20px nem olyan szám, mintNaN (25,5); // hamis isNaN ("25,5"); // hamis isNaN (""); // hamis, mert a szóköz vagy több szóköz 0-ra konvertálódik isNaN (null); // hamis, mert null nullává alakul át isNaN (true); // hamis, mert a true érték 1-re változikNaN (hamis); // hamis, mert a false értéket 0-ra konvertáljuk
Ha ezt a műveletet típusválogatás nélkül kell végrehajtani, akkor használja a Number.isNaN metódust. Ezt a módszert az ECMAScript 6 óta vezették be a nyelvbe.
Hogyan konvertálhatom kifejezetten a karakterláncot számgá?
A karakterláncot kifejezetten számokká konvertálhatja a következő módszerekkel:
1. Használja unary + operátoraz érték elé kell helyezni.
+ "7,35"; // 7.35 + "szöveg"; NaN
Ez a módszer figyelmen kívül hagyja a vezető és a záró szóközöket és a \\ n (sortáplálást).
+ "7,35"; //7,35 + "7,35 \\ n"; //7.35
Ezzel a módszerrel figyelni kell arra, hogy egy üres karakterláncot vagy egy szóközökből álló \\ n karakterláncot 0-ra fordítanak. Ezenkívül a null adattípust és a logikai értékeket is számokká alakítja.
Nulla; 0 + igaz; 1 + hamis; // 0 + ""; 0
2. A parseInt függvény. Ezt a funkciót konvertálásra tervezték argumentum egész számra... Szemben a használattal unáris operátor +, ez a módszer lehetővé teszi egy karakterlánc konvertálását olyan számgá, amelyben nem minden karakter numerikus... A karakterláncot az első karaktertől kezdve konvertálja. Amint egy nem numerikus karakterrel találkozik, ez a függvény leállítja munkáját és visszaadja az eredményül kapott számot.
ParseInt ("18px"); 18 parseInt ("33,3%"); // 33
Ez a függvény különböző számrendszerekkel működhet (bináris, oktális, decimális, hexadecimális). A radix megadása 2 argumentummal történik.
ParseInt ("18px", 10); 18 parseInt ("33,3%", 10); // 33 parseInt ("101", 2); 5 parseInt ("B5", 16); 181
A parseInt függvény mellett a JavaScript rendelkezik egy Number.parseInt módszerrel. Ez a módszer nem különbözik a parseInt függvénytől, és a JavaScript-ben vezették be az ECMASCRIPT 2015 specifikációval (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-től eltérően, nincs 2 argumentuma, és ezért mindig megpróbálja a karakterláncot számnak tekinteni a tizedesjegyű jelölésben.
ParseFloat ("3.14"); parseFloat ("314e-2"); parseFloat ("0,0314E + 2");
A parseFloat függvény mellett a JavaScript rendelkezik egy Number.parseFloat módszerrel. Ez a módszer nem különbözik a parseFloat függvénytől, és JavaScript-ben vezették be az ECMASCRIPT 2015 specifikációval (6).
Szám konvertálása karakterláncra
A toString módszerrel számot alakíthat át karakterláncra.
(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-e ö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-e szám:
1. Az isNaN és az isFinite függvények használata:
// a myVar változó, ha (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))) (// // myVar egy szám, vagy rá lehet vetni);
Funkcióként:
// függvény függvény isNumeric (érték) (return! isNaN (parseFloat (érték)) && isFinite (parseFloat (érték));) // használja var myVar \u003d "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 konvertálható-e rá. Ez az opció nem kezeli számként az üres karakterláncot, a szóközök számát, a , Infinity, -Infinity, true vagy false értékeket.
2. A typeof operátor és az isFinite használatával az isNaN függvények:
// függvény, amely ellenőrzi, hogy az érték-e a szám függvény-e aNumber (érték) (return typeof érték \u003d\u003d\u003d "(! 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 meghatározza, hogy a megadott érték száma típusú-e, és hogy ez-e az Infinity, -Infinity és NaN speciális értékek egyike. Ha igen, akkor ez a függvény igazra tér vissza.
3. Az ECMAScript 6 Number.isInteger (érték) módszer használata. Ez a módszer lehetővé teszi annak meghatározását, hogy a megadott érték egész szám-e.
Szám.isInteger ("20"); // hamis, mert ez a módszer nem hajt végre sort a Number.isInteger (20) felé; // igaz, mert az adott érték egy szám
Páros és páratlan számok
A következő funkciók segítségével ellenőrizheti, hogy egy szám páros vagy páratlan-e.
// Az egyenletességi függvény számának ellenőrzésére szolgáló funkció: isEven (n) (return n% 2 \u003d\u003d 0;) // Funkció a párosság függvény számának ellenőrzéséhez isOdd (n) (return Math.abs (n% 2) \u003d\u003d 1; )
De mielőtt elvégezne egy ilyen ellenőrzést, tanácsos megbizonyosodni arról, hogy a megadott érték szám:
Érték \u003d 20; if (Szám.isInteger (érték)) (if (isEven (érték)) (konzol.log ("Szám" + érték.String () + "- páros");))
Javascript primes
Vegyünk egy példát, amelyben 2 és 100 közötti prímeket jelenítünk meg a Javascript segítségével.
// A függvény, amely ellenőrzi, hogy a szám elsődleges-e, a functionPrime (érték) (ha (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ám kerekítése Javascriptben
Számos módon lehet egy tört számot egész számra kerekíteni a JavaScript-ben.
1. Kifejezetten a Math.floor, a Math.ceil és a Math.round módszerek alkalmazásával. A Math.floor módszer a tört számot kerekíti a legközelebbi egész számra, azaz egyszerűen eldobja a töredékes részt. A Math.ceil egy tört számot 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 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)); // 8
2. A toFixed (precíziós) módszer használata. Ez a módszer kerekíti a szám törtrészét a megadott pontossággal. A kerekítési eredmény karakterláncként kerül visszaadásra.
Console.log (7.987.toFixed (2)); //"7.99 "
Ha nincs elég tizedesjegy a szám megadott pontosságának kialakításához, akkor nullával 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 képviseli. Sőt, nem csak a törtet, hanem a szám egész részét is kerekítheti. 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" konzol.log ((12.4) .toPrecision (3)); //"12.4 "console.log ((12.4) .toPrecision (5)); //"12.400 "
4. A NOT vagy OR logikai operátorok használata.
// kettős logikai tagadással konzolon keresztül.log (~~ 7.9); // 7 // logikai VAGY nulla használatával: console.log (7.9 ^ 0); // 7
Szám egész és tört része
A szám egész részét a Math.floor () metódus és a parseInt () használatával 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örtrészét. Ez az operátor adja vissza a maradékot, amelyet akkor kapunk, ha az első számot elosztjuk a másodikkal. Ebben az esetben 1-et kell használni a 2-es 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örtrész számítások segítségével is megszerezhető:
Var szám \u003d 7,21; var frakcióNumber \u003d szám - Math.floor (Math.abs (szám)); console.log (frakciószám); 0.20999999999999996
Még osztható-e a szám?
A százalék operátor segítségével meghatározhatja, hogy egy szám egyenletesen osztható-e:
Var szám \u003d 9; // ha a szám 3-mal való felosztásának fennmaradó része 0, akkor igen, különben nem, ha (% 3 \u003d\u003d 0 szám) (console.log (a "Szám" + szám + "osztható 3-mal");) else (konzol. log (a "Szám" + szám + "nem osztható 3-mal");)
Számok formázása
A JavaScript-ben a toLocaleString () metódus lehetővé teszi egy szám kimenetének formázását a regionális (operációs rendszer) nyelvi beállítások szerint.
Formázzuk például a számot a rendszerre alapértelmezés szerint telepített regionális szabványoknak megfelelően:
Var-szám \u003d 345,46; console.log (szám.toLocaleString ()); // "345,46"
Formázzuk például a számot Oroszország regionális normáinak 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: "valuta", pénznem: "RUB"))); // "2 540,13 ₽" console.log ((89.3) .toLocaleString ("ru-RU", (stílus: "valuta", pénznem: "USD"))); // "89,30 $" console.log ((2301.99) .toLocaleString ("ru-RU", (stílus: "valuta", valuta: "EUR"))); // "2 301,99 €"
Szám ábrázolása százalékban:
Console.log ((0,45) .toLocaleString ("ru-RU", (stílus: "százalék"))); // "45%"
Ossza fel a számot számjegyekre (useGrouping tulajdonság):
Console.log ((125452.32) .toLocaleString ("ru-RU", (useGrouping: true))); // "125 452,32"
Számot nyomtasson a tizedesjegy után bizonyos számú számjeggyel (2):
Console.log ((1240.4564) .toLocaleString ("ru-RU", (minimumFractionDigits: 2, maximumFractionDigits: 2)); // "1 240,46"
Számok összehasonlítása
A JavaScript a következő operátorokat használja a számok összehasonlításához: \u003d\u003d (egyenlő) ,! \u003d (Nem egyenlő),\u003e (nagyobb mint),< (меньше), >\u003d (nagyobb vagy egyenlő),<= (меньше или равно).
Például hasonlítsunk össze két számot:
Console.log (2\u003e 3); // hamis konzol.log (5\u003e \u003d 3); // igaz
A számok törtrészekkel történő összehasonlításakor figyelembe kell venni az e számítások során felmerülő hibákat.
Például a JavaScript-ben a számok összege (0,2 + 0,4) nem 0,6:
Console.log ((0,2 + 0,4) \u003d\u003d 0,6); // hamis
Hibák fordulnak elő, mert az összes számítást egy számítógép vagy más elektronikus eszköz végzi a 2. számrendszerben. Azok. bármilyen művelet végrehajtása előtt a számítógépnek először a kifejezésben szereplő számokat kell 2 számrendszerré alakítania. De egyetlen törtrészes tizedesszám sem ábrázolható pontosan 2 számrendszerben.
Például a 0,25 10 számot pontosan bináris rendszerré konvertáljuk.
0,125 × 2 \u003d 0,25 | 0 0,25 × 2 \u003d 0,5 | 0 0,5 × 2 \u003d 1 | 1 0,125 10 \u003d 0,001 2
Például a 0,2 10 szám csak bizonyos pontossággal konvertálható 2 rendszerre:
0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 ... 0,2 10 \u003d 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ült, hogy valójában a JavaScript a következőképpen fogja látni ezt a rekordot:
0.6000000000000001==0.6
A számok törtrészes számításakor vagy megjelenítésekor mindig meg kell jelölni, hogy pontosan milyen pontossággal kell elvégezni.
Például hasonlítsa össze a számokat legfeljebb 2 tizedesjegyig a toFixed () és aPrecision () módszerekkel:
// metódus toFixed () console.log ((0.2 + 0.4) .toFixed (2) \u003d\u003d (0.6) .toFixed (2)); // true // metódus toPrecision () console.log ((0,2 + 0,4) .toPrecision (2) \u003d\u003d (0,6) .toPrecision (2)); // igaz
Alapvető matematikai műveletek
A következő matematikai operátorok léteznek a JavaScript-ben: + (összeadás), - (kivonás), * (szorzás), / (osztás),% (modulo), ++ (érték növelése 1-vel), - (érték csökkentése 1-vel ).
6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, azaz 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e pihenés (0) 5% 2 // 1, azaz 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e pihenés (1) 7,3% 2 //1,3, azaz 7,3: 2 \u003d 3 (, 65) \u003d\u003e 7,3-2 * 3 \u003d\u003e pihenés (1,3) // a% művelet eredményének jele megegyezik az első érték előjellel -9% 2,5 //-1,5, azaz 9: 2,5 \u003d 3 (, 6) \u003d\u003e 9-2,5 * 3 \u003d\u003e pihenés (1,5) -9% -2,5 //-1,5, azaz 9: 2,5 \u003d 3 (, 6) \u003d\u003e 9-2,5 * 3 \u003d\u003e pihenés (1,5) -2% 5 // - 2, azaz 2: 5 \u003d 0 (, 4) \u003d\u003e 2-5 * 0 \u003d\u003e pihenés (2) x \u003d 3; console.log (x ++); // kinyomtatja a 3-at, y beállít 4 későbbi konzolt.log (x); 4 x \u003d 3; console.log (++ x); // 4-et állít és x \u003d 5-et nyomtat; console.log (x--); // kinyomtatja az 5-et, y beállít 4 későbbi konzolt.log (x); 4 x \u003d 5; konzol.log (- x); // 4-et és kimenetet állít be Ezenkívül a JavaScript kombinálta az operátorokat: x + \u003d y (x \u003d x + y), x- \u003d y (x \u003d xy), x * \u003d y (x \u003d x * y), x / \u003d y (x \u003d x / y), x% \u003d y (x \u003d x% y). x \u003d 3; y \u003d 6; x + \u003d y; console.log (x); 9 x \u003d 3; y \u003d 6; x- \u003d y; console.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; console.log (x); 18 x \u003d 3; y \u003d 6; x / \u003d y; console.log (x); //0,5 x \u003d 3; y \u003d 6; x% \u003d y; console.log (x); 3
Gyakran előfordul, hogy a JavaScript-ben végzett számítások nem adják meg pontosan azokat az eredményeket, amelyeket szeretnénk. Természetesen bármit megtehetünk a számokkal - felfelé vagy lefelé, tartományokat állíthatunk be, felesleges számokat vághatunk el egy bizonyos tizedesjegyig, minden attól függ, hogy mit akarunk kezdeni ezzel a számmal a jövőben.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 azzal a ténnyel kombinálva, hogy sok törtérték nem fejezhető ki véges számú tizedesjegyben, a JavaScript-ben ilyen eredményeket kaphatunk:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Gyakorlati célokból ez a pontatlanság egyáltalán nem számít, esetünkben kvintmillió rész hibájáról beszélünk, ez azonban csalódást okozhat valakinek. Kissé furcsa eredményt kaphatunk, ha olyan számokkal dolgozunk, amelyek a pénznemek, százalékok vagy fájlméretek értékét képviselik. Ezen pontatlanságok kijavításához csak képesnek kell lenniünk az eredmények kerekítésére, miközben elegendő a tizedes pontosság megadásához.
A számok kerekítésének gyakorlati alkalmazása van, manipulálhatunk egy számot egy bizonyos tartományban, például szeretnénk kerekíteni az értéket a legközelebbi egész számra, és nem csak a tizedes résszel dolgozni.
Tizedesjegyek kerekítése
Tizedes szám törléséhez használja a toFixed vagy a toPrecision metódust. Mindkettő egyetlen argumentumot vesz fel, amely meghatározza, hogy az eredménynek hány jelentős számjegynek (azaz a számban használt összes számjegy számának) vagy tizedesjegynek (a tizedesjegy utáni számnak) kell tartalmaznia:- Ha az argumentum nincs definiálva a toFixed () számára, akkor alapértelmezés szerint nulla lesz, ami 0 tizedesjegyet jelent, az argumentum maximális értéke 20.
- Ha a toPrecision mellett nem adunk meg argumentumot, a szám érintetlen marad
A toFixed () és a toPrecision () karakterek az eredmény karakterlánc-ábrázolását adják vissza, nem számot. Ez azt jelenti, hogy amikor a kerekített összeget összegezzük a randNummal, akkor a húrok összefűznek, nem pedig a számok összege:
Legyen randNum \u003d 6,25; legyen kerekítve \u003d randNum.toFixed (); // "6" konzol.log (randNum + kerekítve); \u003e "6.256"
Ha azt szeretné, hogy az eredmény numerikus adattípussal rendelkezzen, akkor a parseFloat parancsot kell használnia:
Legyen randNum \u003d 6,25; legyen kerekítve \u003d parseFloat (randNum.toFixed (1)); console.log (kerekítve); \u003e 6.3
Vegye figyelembe, hogy az 5 érték kerek, kivéve ritka eseteket.
A toFixed () és toPrecision () metódusok azért hasznosak, mert nemcsak a töredékes részt képesek leválasztani, hanem a tizedesjegyeket is kitölthetik, ami kényelmes, ha valutával dolgoznak:
Legyen egészNum \u003d 1 legyen dollárCents \u003d egészNum.toFixed (2); console.log (dollárCents); \u003e "1.00"
Felhívjuk figyelmét, hogy a toPrecision exponenciális jelöléssel adja az eredményt, ha az egész számok nagyobbak, mint maga a pontosság:
Legyen a num \u003d 123.435 szám a Precision (2) -ig; \u003e "1.2e + 2"
Hogyan kerülhető el a tizedes számokkal való kerekítési hiba
Bizonyos esetekben a toFixed és aPrecision az 5. lefelé és felfelé kerekíti:Legyen a numTest \u003d 1.005; numTest.toFixed (2); \u003e "1.00"
A fenti számítási eredménynek 1.01-nek kellett volna lennie, nem 1. Ha el akarja kerülni ezt a hibát, használhatjuk Jack L Moore által javasolt megoldást, amely exponenciális számokat használ a számításhoz:
Funkció kör (érték, tizedesjegyek) (visszatérési szám (Math.round (érték + "e" + tizedesek) + "e -" + tizedesek);)
Most:
Forduló (1.005,2); \u003e 1.01
Ha a fentieknél robusztusabb megoldást szeretne, akkor áttérhet az MDN-re.
Gépi epsilon kerekítés
Az ES6-ban alternatív módszert vezettek be a tizedesjegyek kerekítésére. A gépi epsilon 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 \u003d\u003d\u003d 0,3\u003e hamis
A Math.EPSILON funkciót használjuk a megfelelő összehasonlítás eléréséhez:
EpsEqu (x, y) függvény (adja vissza 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. Visszaadja a kettő összehasonlítását:
EpsEqu (0,1 + 0,2, 0,3)\u003e igaz
Minden modern böngésző már támogatja az ES6 matematikai függvényeket, de ha támogatást szeretne az olyan böngészőkben, mint az IE 11, használja a többszörös kitöltéseket.
Töredékes nyírás
A fenti módszerek mindegyike tudja, hogyan kell kerekíteni a tizedesjegyekre. A szám két tizedesjegyre történő levágásához először meg kell szorozni 100-zal, majd el kell osztani az eredményt 100-mal:Funkció csonka (szám) (visszatér Math.trunc (szám * 100) / 100;) csonka (3.1416)\u003e 3.14
Ha tetszőleges számú tizedesjegyet szeretne elhelyezni, használjon dupla bitenkénti tagadásokat:
Csonkolt függvény (num, decimalPlaces) (legyen numPowerConverter \u003d Math.pow (10, decimalPlaces); adja vissza ~~ (num * numPowerConverter) / numPowerConverter;)
Most:
Legyen randInt \u003d 35.874993; csonka (randInt, 3); \u003e 35,874
Kerekítés a legközelebbi számra
A tizedesjegy felfelé vagy lefelé kerekítéséhez a legközelebbi számra, attól függően, melyikhez legközelebb vagyunk, használja a Math.round () parancsot:Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5
Ne feledje, hogy az "érték felét", a 0,5-et felfelé kerekítik a matematika szabályai szerint.
Kerekítsen lefelé a legközelebbi egész számra
Ha mindig lefelé akar kerekíteni, használja a Math.floor alkalmazást:Math.floor (42,23); \u003e 42 Math.floor (36.93); \u003e 36
Vegye figyelembe, hogy a lefelé kerekítés minden számra érvényes, beleértve a negatív számokat is. Képzeljünk el egy felhőkarcolót, amelynek végtelen sok emelete van, beleértve az alsó szintet (negatív számokat képvisel). Ha a liftben van az alsó szinten 2 és 3 között (ami -2,5 érték), a Math.floor -3-ra visz:
Math.floor (-2,5); \u003e -3
De ha el akarja kerülni ezt a helyzetet, használja a Math.trunc fájlt, amelyet minden modern böngésző támogat (kivéve az IE / Edge-t):
Math.trunc (-41,43); \u003e -41
Az MDN-en található egy polifill, amely Math.trunc támogatást nyújt a böngészőkben és az IE / Edge-ben.
Kerekítse fel a legközelebbi egész számra
Másrészt, ha mindig fel kell kerekednie, használja a Math.ceil fájlt. Ismét emlékezve a végtelen emelésre: A Math.ceil mindig fel fog emelkedni, függetlenül attól, hogy a szám negatív-e vagy sem:Math.ceil (42,23); \u003e 43 Math.ceil (36,93); \u003e 37 Math.ceil (-36,93); \u003e -36
Szükség szerint kerekítés fel / le
Ha az 5 legközelebbi többszörösére akarunk kerekíteni, akkor a legegyszerűbb módszer egy olyan függvény létrehozása, amely egy számot eloszt 5-gyel, kerekíti azt, majd megszorozza ugyanezzel az összeggel:Funkció roundTo5 (num) (adja vissza Math.round (num / 5) * 5;)
Most:
RoundTo5 (11); \u003e 10
Ha értékének többszörösére akarja kerekíteni, használunk egy általánosabb függvényt, amely beírja a kezdeti és a többszörös értékeket:
Funkció roundToMultiple (szám, többszörös) (adja vissza a Math.round (szám / többszörös) * többszöröset;)
Most:
Legyen kezdeti szám \u003d 11; legyen többszörös \u003d 10; roundToMultiple (kezdőszám, többszörös); \u003e 10;
Szám javítása egy tartományban
Sok esetben x-et szeretnénk elérni egy tartományon belül. Például szükségünk lehet 1 és 100 közötti értékre, de 123. értéket kaptunk. Ennek kijavításához használhatjuk a min (a számhalmaz közül a legkisebbet adja vissza) és a max értéket (bármelyik számhalmazból a legnagyobbat adja vissza). Példánkban a tartomány 1 és 100 között van:Legyen lowBound \u003d 1; legyen highBound \u003d 100; legyen numInput \u003d 123; let clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (befogva); \u003e 100;
Ismét felhasználhatjuk a műveletet, és az egészet egy függvénybe csomagolhatjuk, használjuk a Daniel X. Moore által javasolt megoldást:
Number.prototype.clamp \u003d function (min, max) (return Math.min (Math.max (ez, min), max););
Most:
NumInput.clamp (lowBound, highBound); \u003e 100;
Gauss-kerekítés
A Gauss-féle kerekítés, más néven banki kerekítés az, ahol a kerekítés a legközelebbi párosra történik. Ez a kerekítési módszer statisztikai hiba nélkül működik. A legjobb megoldást Tim Down javasolta:Funkció gaussRound (num, decimalPlaces) (legyen d \u003d decimalPlaces || 0, m \u003d Math.pow (10, d), n \u003d + (d? Num * m: num). ToFixed (8), i \u003d Math.floor (n), f \u003d n - i, e \u003d 1e-8, r \u003d (f\u003e 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)\u003e 2 gaussRound (3.5)\u003e 4 gaussRound (2.57,1)\u003e 2.6
Tizedespont a CSS-ben:
Mivel a JavaScript-et gyakran használják a HTML elemek helyzetbeli transzformációinak létrehozására, elgondolkodhat azon, mi történik, ha tizedes értékeket állítunk elő elemeink számára:
#box (szélesség: 63.667731993px;)
Jó hír, hogy a modern böngészők a dobozmodellben figyelembe veszik a tizedes értékeket, beleértve a százalékos vagy képpontos egységeket is.
Válogatás
Nagyon gyakran válogatnunk kell néhány elemet, például van egy tömb játékrekordunk, és ezeket a játékosok rangjának csökkenő sorrendjében kell rendezni. Sajnos a standard sort () módszernek meglepő korlátai vannak: jól működik az általánosan használt angol szavakkal, de számokkal, egyedi karakterekkel vagy nagybetűs szavakkal szembesül.Rendezés ábécé sorrendben
Úgy tűnik, hogy a tömb betűrend szerinti rendezése legyen a legegyszerűbb feladat:Legyen gyümölcs \u003d ["butternut squash", "barack", "sárgadinnye"]; gyümölcs.válogatás (); \u003e "barack", "butternut squash", "sárgadinnye"]
Azonban problémába ütközünk, amint az egyik elem nagybetűvel jelenik meg:
Legyen gyümölcs \u003d ["butternut squash", "barack", "Cantalope"]; gyümölcs.válogatás (); \u003e "Sárgadinnye", "sárgabarack", "butternut tök"]
Ennek oka, hogy a válogató alapértelmezés szerint összehasonlítja az Unicode-ban ábrázolt első karaktert. Az Unicode egy egyedi kód minden karakterhez, platformtól függetlenül, programtól és nyelvtől függetlenül. Például, ha megnézzük a kódtáblát, az "a" karakter U + 0061 értékkel rendelkezik (0x61 hexadecimális rendszerben), míg a "C" karakter U + 0043 (0x43) kóddal rendelkezik, amely korábban az Unicode táblában jelenik meg, mint a karakter "A".
Az első betűk vegyes betűit tartalmazó tömb rendezéséhez vagy átmenetileg át kell alakítanunk az összes elemet kisbetűvé, vagy meg kell határoznunk saját rendezési sorrendünket a localeCompare () metódus segítségével, néhány argumentummal. Általános szabály, hogy ilyen esetekben jobb, ha azonnal létrehozunk egy funkciót ismételt használatra:
AlphaSort (arr) (arr.sort (function (a, b) (return a.localeCompare (b, "en", ("érzékenység": "alap")) függvény);));) hagyja gyümölcs \u003d ["butternut squash "," barack "," sárgadinnye "]; alphaSort (gyümölcs)\u003e
Ha egy tömböt fordított ábécé sorrendbe akar rendezni, akkor egyszerűen cserélje le az a és b pozíciókat 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 \u003d ["butternut squash "," barack "," sárgadinnye "]; alphaSort (gyümölcs)\u003e ["sárgadinnye", "butternut tök", "sárgabarack"]
Itt érdemes megjegyezni, hogy a localeCompare argumentumokkal van használva, emlékeznie kell arra is, hogy az IE11 + támogatja, az IE régebbi verziói esetén argumentumok nélkül használhatjuk kisbetűvel:
Funkció caseSort (arr) (arr.sort (függvény (a, b) (adja vissza a.toLowerCase (). LocaleCompare (b.toLowerCase ());)););) hagyja gyümölcs \u003d ["butternut squash", "barack", "Kantalup dinnye"]; caseSort (gyümölcs)\u003e ["barack", "butternut squash", "sárgadinnye"]
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öknél a rendezés rendben működik, de valamikor az eredmény kiszámíthatatlan lehet:Legyen highScores \u003d; highScores.sort (); \u003e
Az a tény, hogy a sort () módszer lexikográfiai összehasonlítást hajt végre: ez azt jelenti, hogy a számokat karakterláncokká konvertáljuk, és az összehasonlításokat újra elvégezzük, ha ennek a karakterláncnak az első karakterét Unicode tábla karakterek sorrendjében illesztjük össze. Ezért ismét meg kell határoznunk a rendezési sorrendünket:
Legyen highScores \u003d; highScores.sort (függvény (a, b) (visszatér a - b;)); \u003e
Ismét fordított sorrendben rendezheti a számokat, cserélje ki a és b pozícióit a függvényben.
JSON-szerű struktúra rendezése
Végül, ha van egy JSON-szerű adatstruktúra, amelyet játékrekordok tömbjeként ábrázolunk:Legyen pontszám \u003d [("név": "Daniel", "pontszám": 21768), ("név": "Michael", "pontszám": 33579), ("név": "Alison", "pontszám": 38395 )];
Az ES6 + rendszerben nyílfüggvényeket használhat:
Scores.sort ((a, b) \u003d\u003e b.core - a.score));
Régebbi böngészők számára, amelyek nem rendelkeznek ezzel a támogatással:
Scores.sort (függvény (a, b) (return a.score - b.score));
Mint látható, a JavaScript-ben történő válogatás nem nyilvánvaló dolog, remélem, hogy ezek a példák valahogy megkönnyítik az életet.
Az energiafüggvényekkel való munka
A hatványozás egy olyan művelet, amelyet eredetileg egy természetes szám többszörös szorzásának eredményeként határoztak meg, az a négyzetgyöke pedig az a szám, amely négyzetre adva adja meg az. Ezeket a funkciókat folyamatosan használhatnánk a mindennapi életben a matematika órákon, beleértve a területek, a térfogatok kiszámítását vagy akár a fizikai modellezést is.A JavaScript-ben az exponenciális függvény Math.pow () néven jelenik meg, az új ES7 szabványban egy új hatványozási operátor kerül bevezetésre - "* *".
Hatványozás
Ha egy számot az n-edik hatványra szeretne emelni, használja a Math.pow () függvényt, ahol az első argumentum a hatványra emelendő szám, a második argumentum a kitevő:Math.pow (3,2)\u003e 9
Ez a jelölési forma 3 négyzetet vagy 3 × 3-at jelent, ami a 9. eredményhez vezet. Természetesen adhatsz még egy példát:
Math.pow (5,3); \u003e 125
Vagyis 5 kockás 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 a jelölés leíróbb lehet:
3 ** 2
> 9
Jelenleg ennek a kezelőnek a támogatása meglehetősen korlátozott, ezért nem ajánlott használni.
A teljesítmény funkció sokféle helyzetben jól jöhet. Egyszerű példa az másodpercek számának kiszámítására egy órában: Math.pow (60,2).
Négyzet és kocka gyökér
A Math.sqrt () és a Math.cbrt () ellentéte a Math.pow () függvénynek. Ne felejtsük el, hogy az a négyzetgyöke az a szám, amely négyzetet ad.Math.sqrt (9)\u003e 3
Ugyanakkor az a szám kocka gyökere az a szám, amely a kockára emelve a-t adja.
Math.cbrt (125)\u003e 5
A Math.cbrt () a közelmúltban került bevezetésre a JavaScript specifikációba, ezért csak a modern böngészőkben támogatott: Chrome 38+, Firefox és Opera 25+, valamint Safari 7.1+. Észre fogja venni, hogy az Internet Explorer nem szerepel ezen a listán, azonban az MDN-n talál polifillet.
Példák
Természetesen nem egész értékeket is használhatunk az alábbi függvények egyikében:Math.pow (1,25, 2); \u003e 1,5625 Math.cbrt (56,57)\u003e 3,8387991760286138
Vegye figyelembe, hogy ez a negatív argumentumértékek esetében is jól működik:
Math.pow (-5,2)\u003e 25 Math.pow (10, -2)\u003e 0,01
Négyzetgyök esetén azonban ez nem fog működni:
Math.sqrt (-9)\u003e NaN
Matematikai elemzésből tudjuk, hogy egy képzeletbeli számot a negatív számok négyzetgyökeként értünk. És ez vezethet egy másik technikához a komplex számokkal való munkavégzéshez, de ez egy másik történet.
A Math.pow () töredékértékeit felhasználhatja a számok négyzet- és kocka gyökereinek megtalálásához. A négyzetgyök 0,5 kitevőt használ:
Math.pow (5, 0,5); // \u003d Math.sqrt (5) \u003d 5 ** (1/2)\u003e 2,23606797749979
A lebegőpont szeszélye miatt azonban nem tudja pontosan kitalálni a helyes eredményt:
Math.pow (2.23606797749979.2)\u003e 5.000000000000001
Ilyen helyzetekben a jelek számtól való csonkolásához vagy valamilyen értékre való kerekítéshez kell folyamodnia.
Egyesek valamilyen ismeretlen okból a JavaScript-ben összekeverik a Math.pow () függvényt a Math.exp () függvénnyel, amely általában a számok exponenciális függvénye. Megjegyzés: angolul az "exponent" fordítása "exponens", tehát ez inkább az angolul beszélőkre vonatkozik, bár vannak alternatív nevei a kitevőnek, például index, power.
Matematikai állandók
A matematika használatát a JavaScript-ben számos beépített állandó megkönnyíti. Ezek az állandók a Math objektum tulajdonságai. Vegye figyelembe, hogy az állandókat nagybetűvel írják, nem a CamelCase jelöléssel.Math.abs, parseInt, parseFloat
A JavaScript-számokkal való munka sokkal bonyolultabb lehet, mint amilyennek hangzik. A kapott értékek nem mindig esnek a várt tartományok közé, néha az eredmény egyáltalán nem biztos, hogy vártuk.Math.abs ()
A Math.abs () metódus egy szám abszolút értékét adja vissza, ami emlékeztet bennünket a szám modulusának analóg matematikai függvényére.Legyen newVal \u003d -57,64; Math.abs (newVal); \u003e 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ívak leszünk.
Math.abs (0); \u003e -0
parseInt ()
Tudjuk, hogy a JavaScript megérti, hogy a "15" egy karakterlánc, nem pedig egy szám, és például ha CSS tulajdonságokat elemezünk JavaScript használatával, vagy valamilyen értéket nyerünk egy előkészítetlen tömbből, akkor eredményeink kiszámíthatatlanok lehetnek. Kaphatunk egy karakterláncot, amelyet "17px" -ként képviselünk bemenetként, és ez nem ritka számunkra. A kérdés az, hogyan lehet ezt a karakterláncot tényleges értékre konvertálni és felhasználni a további számítások során.Szintaxis: parseInt (string, radix);
A parseInt függvény az első neki átadott argumentumot karakterláncokká alakítja, értelmezi és egész vagy NaN értéket ad vissza. Az eredmény (ha nem NaN) egész szám, és ez az első argumentum (karakterlánc), amelyet számként kezelünk a megadott számrendszerben (radix). Például a 10 bázis tizedesből, 8-ból oktálissá, 16-ból hexává alakul, és így tovább. Ha az alap nagyobb, mint 10, akkor betűket használunk a 9-nél nagyobb számok jelölésére. Például a hexadecimális számok (16. alap) az A – F betűket használják.
Vegyünk egy példát a CSS tulajdonságokkal való együttműködésre, ahol viszonylagosan ilyen értéket kaphatunk:
Legyen elem \u003d document.body; hagyja a centerPoint \u003d window.getComputedStyle (elem) .transformOrigin; \u003e "454px 2087.19px"
Az értékeket szóközökre oszthatjuk:
Legyen központok \u003d centerPoint.split (""); \u003e ["454px", "2087.19px"]
Mindazonáltal minden elem továbbra is karakterlánc, ettől függvényünk alkalmazásával megszabadulhatunk:
Legyen centerX \u003d parseInt (középpontok, 10); \u003e 454 let centerY \u003d parseInt (középpontok, 10); \u003e 2087
Mint látható, második érvként azt a számrendszert jelezzük, amelyre a számot átváltják, ez a paraméter nem kötelező, de ajánlott használni, ha nem tudja, melyik karakterlánc kerül a bemenetre.
parseFloat ()
A fenti példa alapján észrevehette, hogy a parseInt eldobja a töredékes részt. Esetünkben a parseFloat lebegőpontos számokkal képes dolgozni. Ez megint hasznos lehet CSS és egyéb feladatok elemzésekor, különösen lebegőpontos százalékok kezelésekor.Szintaxis: parseFloat (string)
Legyen FP \u003d "33,33333%"; console.log (parseFloat (FP)); \u003e 33,33333
Vegye figyelembe, hogy a parseFloat szintaxisban nincs második argumentum.
Megértjük, hogy a parseInt () és a parseFloat () rendkívül hasznos függvények, fontos szem előtt tartani, hogy ez nem hibátlan, ezért ellenőrizni kell a várható értékek tartományát, és végül elemezni kell az eredményt, hogy a kapott értékek helyesek legyenek.
Küldje névtelenül
A számítások gyakran olyan eredményeket hoznak, amelyek a kívánt tartományon kívül esnek. Ennek eredményeként 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ámot, mert értékeik lebegőpontos számként vannak feltüntetve. Számos törtet nem lehet véges számú tizedesjegygel ábrázolni, így a JavaScript az alábbihoz hasonló eredményeket generálhat:
0.1 * 0.2; > 0.020000000000000004
A gyakorlatban ez nem okoz különbséget, mivel 2 kvintmilliárdos hibáról beszélünk. Ez azonban befolyásolhatja az eredményt, ha olyan számokkal dolgozik, amelyek a pénznem értékét, százalékát vagy fájlméretét képviselik. Ezért meg kell tennie, vagy egy bizonyos tizedesjegyig.
Tizedesjegyek kerekítése
Tizedesszám "kivágásához" használja a toFixed () vagy toPrecision () metódusokat. Mindkettő egy érvet vesz fel, amely meghatározza az eredményben szerepeltetendő jelentős és tizedesjegyek számát:
- ha a toFixed () számára nincs megadva argumentum, akkor az alapértelmezett érték 0, azaz nincs tizedesjegy; az argumentum maximális értéke 20;
- ha a toPrecision () számára nincs megadva argumentum, a szám nem változik.
var randNum \u003d 6,25; randNum.toFixed (); \u003e "6" Math.PI.toPrecision (1); \u003e "3" var randNum \u003d 87,335; randNum.toFixed (2); \u003e "87,33" var randNum \u003d 87,337; randNum.toPrecision (3); \u003e "87,3"
jegyzet
A toFixed () és a toPrecision is az eredmény kerekített karakterlánc-ábrázolását adja vissza, nem számot. Ez azt jelenti, hogy a kerekített szám hozzáadása a randNumhoz karakterlánc összefűzést eredményez, nem pedig egyetlen számot:
console.log (randNum + kerekítve); \u003e "6.256"
Ha azt szeretné, hogy a JavaScript a legközelebbi századikra \u200b\u200bkerekítsen, használja a parseFloat () parancsot:
var randNum \u003d 6,25; var kerekítve \u003d parseFloat (randNum.toFixed (1)); console.log (kerekítve); \u003e 6.3
a toFixed () és a toPrecision () szintén hasznos módszerek nagyszámú tizedesjegy csonkolásához. Ez akkor hasznos, ha olyan számokkal dolgozunk, amelyek monetáris egységeket képviselnek:
var egészNum \u003d 1 var dollárCents \u003d egészNum.toFixed (2); console.log (dollárCents); \u003e "1.00"
Vegye figyelembe, hogy ha a számban több számjegy van, mint amennyit a precíziós paraméter megad, a toPrecision az eredményt tudományos formátumban adja vissza:
var num \u003d 123.435 szám a Precision (2) -ig; \u003e "1.2e + 2"
Hogyan lehet elkerülni a hibákat a tizedesjegyek kerekítésekor
Bizonyos esetekben a toFixed és a toPrecision implementáció JavaScript lekerekítése 5 lefelé, és nem többre:
var numTest \u003d 1,005; numTest.toFixed (2); \u003e 1;
A fenti példa az 1.01, nem pedig 1. értéket eredményezi. Ha el akarja kerülni ezt a hibát, javasoljuk az exponenciális számok használatát:
függvény kerek (érték, tizedesjegyek) (visszatérési szám (Math.round (érték + "e" + tizedesek) + "e -" + tizedesek);)
Alkalmazás:
kör (1.005.2); \u003e 1.01
Ha még megbízhatóbb megoldásra van szüksége, mint a kerekítés, akkor az elérhető MDN.
Epsilon kerekítés
Alternatív módszer A tizedekre kerekítő JavaScript ES6-ban vezették be ( más néven JavaScript 2015). « Gépi 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 a következőkhöz hasonló eredményeket hozhatnak:
0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e hamis
A Math.EPSILON használható egy függvényben a helyes összehasonlítás érdekében:
függvény epsEqu (x, y) (return Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
A függvénynek két argumentuma van: az egyik számításokat tartalmaz, a második a várható (kerekített) eredményt jelenti. E két paraméter összehasonlítását adja vissza:
epsEqu (0,1 + 0,2, 0,3)\u003e 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 többszörös kitöltéseket kell használnia.
Tizedes számok csonkolása
A korábban bemutatott összes módszer teljesít A tizedekre kerekítő JavaScript... A pozitív szám két tizedesjegyig történő csonkításához szorozzuk meg 100-zal, csonkoljuk meg újra, majd osszuk el az eredményt 100-zal:
függvény csonka (num) (visszatér Math.trunc (szám * 100) / 100;) csonka (3.1416)\u003e 3.14
Ha valami rugalmasabbra van szüksége, használhatja a bitenkénti operátort:
függvény csonkítva (num, decimalPlaces) (var numPowerConverter \u003d Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Használata:
var randInt \u003d 35,874993; csonka (randInt, 3); \u003e 35,874
Kerekítés a legközelebbi számra
Végrehajtani A JavaScript egész számra kerekítve, amelyet a Math.round () használ:
Math.round (4.3)\u003e 4 Math.round (4.5)\u003e 5
Vegye figyelembe, hogy " félértékek- Például a .5 fel van kerekítve.
Kerekítse a legközelebbi egész számra
Ha lefelé akar kerekíteni, használja a Math.floor () metódust:
Math.floor (42,23); \u003e 42 Math.floor (36.93); \u003e 36
A lefelé kerekítésnek egy iránya van minden számra, beleértve a negatívakat is. Ezt úgy lehet elképzelni, mint egy felhőkarcolót, amelynek végtelen sok emelete van, beleértve az alapzat szintje alatt ( negatív számokat képviselve). Ha a liftben van az alagsori 2. és 3. emelet között ( ami -2,5 értéknek felel meg), A Math.floor a -3. Emeletre visz:
Math.floor (-2,5); \u003e -3
Ha ezt el kell kerülnie, használja a JavaScript Math kerekítést a Math.trunc () paranccsal, amelyet minden modern böngésző támogat (kivéve IE / Edge):
Math.trunc (-41,43); \u003e -41
Az MDN is biztosítja 3 soros polifill a Math.trunc támogatásához a régebbi böngészőkben és az IE / Edge szolgáltatásban.
Kerekítse fel a legközelebbi egész számra
Ha tízes számokat akar felfelé kerekíteni, használja a Math.ceil fájlt. Ezt a módszert végtelen emelésnek is tekinthetjük: a Math.ceil mindig felfelé hajt, függetlenül attól, hogy a szám negatív vagy pozitív:
Math.ceil (42,23); \u003e 43 Math.ceil (36,93); \u003e 37 Math.ceil (-36,93); -36
Kerekítsük a legközelebbi többszörösig
Ha egy értéket az 5 legközelebbi többszörösére kell kerekítenie, hozzon létre egy olyan függvényt, amely elosztja a számot 5-tel, kerekíti, majd az eredményt megszorozza ugyanazzal az értékkel:
függvény roundTo5 (num) (return Math.round (num / 5) * 5;)
Használata:
roundTo5 (11); \u003e 10
Ha két számjegyű kerekítésre van szüksége JavaScript-re, akkor a magot és a sokaságot is átadhatja a függvénynek:
függvény roundToMultiple (szám, többszörös) (adja vissza a Math.round (szám / többszörös) * többszöröset;)
A függvény használatához tegye a hívásba a kerekítendő számot és a sokaságot:
var kezdőszám \u003d 11; var többszörös \u003d 10; roundToMultiple (kezdőszám, többszörös); \u003e 10;
Az értékek csak felfelé vagy lefelé kerekítéséhez cserélje ki a kereket mennyezetre vagy padlóra a funkcióban.
Range Snap
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 számok közül a legkisebbet adja vissza) és max ( a maximálisan megengedett számot adja vissza).
Használata:
var lowBound \u003d 1; var highBound \u003d 100; var numInput \u003d 123; var clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (befogva); \u003e 100;
Létrehozhat egy függvényt vagy a Szám osztály kiterjesztését.
A Math.round () függvény adja vissza a legközelebbi egész számra kerekített szám értékét.
Ennek az interaktív példának a forrása egy GitHub-adattárban van tárolva. Ha hozzá szeretne járulni az interaktív példák projektjéhez, klónozza a https://github.com/mdn/interactive-examples címet, és küldjön nekünk egy lekérési kérelmet.
Szintaxis
Math.round (x)Paraméterek
x A szám.Visszatérési érték
Az adott szám értéke a legközelebbi egész számra kerekítve.
Leírás
Ha az argumentum tört része nagyobb, mint 0,5, akkor az argumentumot a következő magasabb abszolút értékkel egész számra kerekítjük. Ha ez kisebb, mint 0,5, akkor az argumentumot az alacsonyabb abszolút értékű egész számra kerekítjük. Ha a tört rész pontosan 0,5, akkor az argumentumot a következő egész számra kerekítjük + + irányába. Ne feledje, hogy ez különbözik sok nyelv "round () függvényétől, amelyek gyakran ezt az esetet a következő egész számra kerekítik távol a nullától , ehelyett más eredményt ad negatív számok esetén, ha a tört része pontosan 0,5.
Mivel a round () a matematika statikus módszere, mindig Math.round () néven használja, nem pedig az Ön által létrehozott Math objektum metódusaként (a Mathnak nincs konstruktora).
Példák
Math.forduló (20.49); 20 matematikai kör (20,5); // 21 Math.forduló (42); // 42 Matematika.forduló (-20,5); // -20 Math.round (-20.51); // -21Demonstratív megvalósítás
Az alábbiakban látható egy kódrészlet, amely funkcionálisan megegyezik a math.round funkcióval, azzal a különbséggel, hogy az alábbi kódrészlet lassabb, mint a Math.round. Az alábbi kódrészlet célja bemutatni a Math.round működését.
Funkció vanilla_round (x) (var y \u003d Math.abs (x) + 0,5; // úgy, hogy kevesebb, mint 1/2 kerek lefelé; nagyobb felfelé kerekítve a Math.floor (x + 0,5) értéket adja vissza)
A fenti modulus operátor megkapja az x tizedes részét. Ezenkívül a fenti kódrészlet módosítható úgy, hogy egy bizonyos pontosságra kerekítsen:
Funkció kerek_precízióig (x, pontosság) (var y \u003d + x + (pontosság \u003d\u003d\u003d undefined? 0,5: precízió / 2); y visszatérés - (y% (pontosság \u003d\u003d\u003d undefined? 1: + precízió));)
Pontosság (11, 2); // 12 eredményt ad ki körbe-pontosságra (11, 3); // 12 eredményt ad ki körbe-pontosságra (11, 4); // 12 eredményt ad ki a pontosságra (11, 5); // 10 eredményt ad ki a pontosságra (11, 6); // 12 eredményt ad ki a precíziós (11, 7) körbe; // kimenetet eredményez 14 kör-pontosságra (11, 8); // 8 eredményt ad ki pontosságra (3.7, 0.5); // kimenetet eredményez 3,5 kör-pontosságra (3,75, 0,5); // 4 eredményt ad ki pontosságra (3.8, 0.5); // kimenetek 4
Specifikációk
| Leírás | Állapot | Megjegyzés |
|---|---|---|
| ECMAScript 1. kiadás (ECMA-262) | Alapértelmezett | Kezdeti meghatározás. Megvalósítva a JavaScript 1.0-ban. |
| ECMAScript 5.1 (ECMA-262) |
Alapértelmezett | |
| ECMAScript 2015 (6. kiadás, ECMA-262) A "Math.round" meghatározása ebben a specifikációban. |
Alapértelmezett | |
| ECMAScript legújabb tervezet (ECMA-262) A "Math.round" meghatározása ebben a specifikációban. |
Piszkozat |
Böngésző kompatibilitás
Az ezen az oldalon található kompatibilitási táblázat strukturált adatokból készül. Ha hozzá szeretne járulni az adatokhoz, nézze meg a https://github.com/mdn/browser-compat-data webhelyet, és küldjön nekünk egy lekérési kérelmet.
Frissítse a kompatibilitási adatokat a GitHubon
| Asztal | Mobil | szerver | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Króm | Él | Firefox | internet böngésző | Opera | Szafari | Android webnézete | Chrome Androidhoz | Firefox Androidra | Opera Androidra | Safari iOS rendszeren | Samsung Internet | Node.js | |
| kerek | Chrome teljes támogatása 1 | Edge Teljes támogatás 12 | Firefox teljes támogatás 1 | IE teljes támogatás 3 | Opera teljes támogatás Igen | A Safari teljes támogatása Igen | WebView Android Teljes támogatás 1 | Chrome Android Teljes támogatás 18 | Firefox Android Teljes támogatás 4 | Opera Android Teljes támogatás Igen | Safari iOS Teljes támogatás: Igen | Samsung Internet Android Teljes támogatás 1.0 | nodejs teljes támogatás Igen |
Most nézzük meg a padló módszerét (nemként fordítva)amely a mennyezeti módszer ellentéte, azaz ő tört számot kerekít lefelé.
Amint láthatja, a padló módszer 35,97-et kerekített lefelé 35-re, azaz lefelé. Bár 0,97 nagyobb, mint 0,5 (cm.).
Ez a lecke a Math objektum módszereit ismertette, lehetővé teszi a tört tizedesjegyek kerekítését.
Most meg kell tennie a házi feladatát.
Az Ön feladata egy olyan függvény megírása, amely két paramétert vesz fel.
1. Tömbök, amelyek törtekből álló számokból állnak.
2. "Kerek", "mennyezeti" vagy "padlós" kerekítési módszer.
A kimeneten a függvénynek ugyanazt a tömböt kell kiadnia, de a tömb összes elemét le kell kerekíteni a módszer második paraméterében megadott Math objektummal.
Forrás tömb:
var numberArray \u003d;
Eleinte a probléma megoldása szinte azonosnak tűnik a háztartási problémák megoldásával a téma első három leckéjében. De nem minden ilyen egyszerű ...
1. megoldás - Figyelem
A probléma állapota szerint a függvénynek két paramétert kell megadnia - az eredeti tömb és az egyik módszer: "kerek", "mennyezet" vagy "padló". Ennek alapján én megpróbálta megtenni...
Ebben a megoldásban két paraméteres függvényt hozunk létre, és amikor meghívjuk, megpróbáljuk megadni az egyik tömböt és a NEVET függvényparaméterként:
decimális (számTömb, kerek) - ebben az esetben kerek.
De az eredményt nem fogjuk megkapni, hiszen NE adja meg a NAME metódust függvényparaméterként.
Felhívjuk figyelmét: nem véletlen, hogy a "kör", "mennyezet" és "emelet" metódusok neve a problémamegállapodásban idézőjelek közé csatolva.
decimális (numberArray, "round") - de ez sem lesz helyes !!!
2. megoldás - Javítsa ki az előző megoldást
Megoldhatja a problémát egy paraméter megadásával a függvényhez.
35 - Lekerekített elem
13 - Lekerekített elem
17 - Lekerekített elem
79 - Lekerekített elem
Itt sikerült elérni a kívánt eredményt: a kerek módszer az összes számot kerekítette. De feltétel nem teljesülmivel a függvény csak egy paramétert vesz fel.
3. megoldás - Funkció két paraméterrel
Itt a probléma helyesen megoldódott. Ehhez emlékeznie kellett a feltételek témájára javascriptben, és egyszerre több feltételt is alkalmazni.
34,82 - a tömb eredeti eleme
35 - felfelé
12.9 - a tömb eredeti eleme
13 - felfelé
17.01 - a tömb eredeti eleme
18 - felfelé
78.51 - a tömb eredeti eleme
79 - felfelé
azt a helyes döntés Házi feladat. Itt a függvényhez két paramétert adunk meg a feltételnek megfelelően.
Próbálja ki a megoldás utolsó sorát:
a decimális (numberArray, "ceil") a függvény második paramétereként adja meg a Math objektum többi metódusának "kerek" és "padlója" nevét.
4. megoldás - Funkció két paraméterrel + gyors módszer
Úgy döntöttem, hogy kissé módosítom az előző megoldást, és hozzáadtam egy gyors módszert, amely modális ablakot hív meg, amely mezőt tartalmaz az információk megadásához.
Ennek köszönhetően lehetőség nyílik a beviteli mezőbe a forduló, a padló vagy a mennyezet egyik metódusának nevét megadni, és megkapni a megfelelő eredményt.
Így működnek a Math objektum kerek, padló vagy felső módszerei, amelyek kerekítik a tört számokat.
