Hello, szerelmesek JavaScript-a. Már észrevette, hogy ez a nyelv nagyon rendkívüli és minden szakaszban kiemelkedik sajátosságai és szokatlan technikai megoldásai. Ezért a mai kiadvány a téma: JavaScript kerekítés.
Miután elolvasta az aktuális cikket, meg fogja deríteni, hogy miért kell a számok megfordítását, milyen módszereket és tulajdonságokat hajt végre a JS-ben, és a 0. \\ T az anyagot, és részletesen írja ki az egyes lépéseket. Most kezdjünk tanulni!
Fontos megjegyzések a számokról
Kezdje el, ne feledje, hogy a JS-ben mindenféle szám (frakcionált és egész szám) Lásd a típust Szám. Ezenkívül mindegyikük 64 bites, mivel a "kettős precíziós" formátumban tárolódnak, amelyet az IEEE-754 szabvány alatt is ismertek.
A szokásos módon létrehozott numerikus változókat:
var numb \u003d 35; // természetes szám
var drob \u003d 0,93; // decimális képviselet
var numb16 \u003d 0xff; // 16-szoros rendszer
Támogatja a többi numerikus nézetet. Tehát számokat is létrehozhat egy lebegőponttal (néha "számok tudományos formában").
A nagyon érdekes módszert támogatott tolokalestring ()Ami az ECMA 402-ben előírt műszaki adatokat formátumban formálja. E nagy számok, telefonszámok, pénznemek és még a százalékok miatt gyönyörűen jelenik meg a párbeszédpanelen.
var num \u003d 714000.80;
riasztás (NUM.TOLOCALESTRING ());
A típusszám elemeihez, egy egész globális objektummal, egy csomó matematikai funkcióval, akinek a neve Matematika..
Ezenkívül vannak olyan módszerek, amelyek az egész számok, tized, századok, stb. Fontolja meg őket még.
Nagy és hatalmas matematika
A globális matematikai objektum hatalmas számú különböző matematikai és trigonometrikus funkciót tartalmaz. Ez egy nagyon szükséges objektum, és gyakran csökkenti a fejlesztőket a digitális adatokkal való együttműködés során.
Más platformokon vannak analógiak matematika. Például olyan népszerű nyelveken, mint a Java és a C #, a matematika olyan osztály, amely támogatja az azonos szabványos funkciókat. Tehát, ahogy látja, hogy ez az eszköz nagyon nagy és hatalmas.
Most szeretném átmenni a kerekítésért felelős konkrét módszerek, és részletesen elmondja nekik.
Math.Floor ()
Elkezdem s. Matematika.padló. Figyeljen a módszer nevére. Ez logikusan világossá válik, hogy mióta kerekítésről beszélünk, és a "padló" szó szó szerinti fordítása "padló", akkor ez az eszköz a feldolgozott értékeket egy kisebb egyenesre fordítja.
Az opció akkor is lehetséges, ha a feldolgozott szám ezt a funkciót használja ugyanaz. Minden, mert a kerekítés nem idegi egyenlőtlenséggel történik (<=). Таким образом, при отработке этой строчки кода:
riasztás (Math.Floor (4.5));
a válasz a 4. szám lesz.
Math.ceil ()
Ismét nézd meg a nevet (egy ilyen módszernél az anyag gyorsan felszívódik). Ha valaki nem tudja, a "Ceil" azt jelenti, hogy "mennyezet". Ez azt jelenti, hogy a numerikus adatok kerekítése a legtöbb oldalon kerül végrehajtásra, nem egyenlőtlenség (\u003e \u003d).
riasztás (Math.ceil (4.5));
Ahogy már kitaláltad, a válasz az 5. szám lesz.
Matematika ()
Ez a módszer frakcionális számot fordít a legközelebbi egészre. Tehát, ha a frakcionált rész 0 és 0,5 között van, akkor a kerekítés kisebb értékre fordul. És ha a törtrész tartományban van a befogadó 0,5 és amíg a következő egész szám, akkor le van kerekítve, hogy egy nagyobb egész.
riasztás (Math.Round (4.5));
Remélem, mindenki gondolta, vagy elmondta a helyes választ - 5.
Még több módszer
A JavaScript rendelkezik más 2 módszerrel is, amelyek a numerikus ábrázolások kerekítésével foglalkoznak. Azonban kissé eltérőek.
Ez az ilyen eszközökről lesz tofixed () és toprecision (). Nem csak a kerekítésre válaszolnak, hanem bizonyos jelek pontosságáért. Harcoljunk mélyebben.
tofixed ()
Ezzel a mechanizmussal meg lehet adni, hogy hány jelzés után a vessző szükséges az értéket. A módszer visszaadja az eredményt karakterláncként. Az alábbiakban három különböző opcióval rendelkező opciót csatoltam. Elemezze a kapott válaszokat.
var num \u003d 5656,9393;
document.Writeln (NUM.TOFIXED ()); // 5657.
document.Writeln (NUM.TOFIXED (2)); // 5656.94
dokumentum.Writeln (NUM.TOFIXED (7)); // 5656.9393000
Amint látható, ha nem adja meg az argumentumot, akkor tofixed ()) kerekíti a frakcionált értéket egészében számok. A harmadik sorban befejeződött kerekítés legfeljebb 2 karakterÉs a negyedikben - a "7" paraméter miatt három több 0-at kezeltek.
toprecision ()
Ez a módszer kissé eltérően cselekszik. Az argumentum helyén mindazonáltal üres helyet hagyhat, és beállíthatja a paramétert. Az utóbbi azonban a megadott számú számok előtt kerül sor, nem figyel a vesszőre. Íme a Példa után átírott program eredményei:
var num \u003d 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-as divízió fájlja JS-ben
Amint a matematika óráiról ismert, lehetetlen nullára osztani. Ez a szabály a programozási nyelvek alkotóinak nagy részében vett részt. Ezért, amikor nullára osztva, minden program hibát ad.
Azonban a JavaScript megkülönböztette magát itt. Tehát az ilyen művelet végrehajtása során nem merülnek fel hibaüzenetek ... mert egy ilyen művelet visszatér "Végtelenség"!
Miért is? Amint ugyanezen matematikai tudományokból ismert, annál kisebb az osztó, az eredmény nagyobb szám. Ezért a prototípus-orientált nyelv alkotói úgy döntöttek, hogy elhagyják a sablonokat, és eljutnak a saját utat.
Azok számára, akik először szembesülnek a végtelen értékkel, az alábbiakban kifejtettem annak jellemzőit.
Infinity - a végtelenséget jelenti, és teljes mértékben megegyezik a matematikai jel ∞.
Lehet negatív. Az aritmetikai üzemeltetőkkel való munkavégzés minden szabványos szabálya is mentésre kerül.
riasztás (12/0); // Végtelenség.
riasztás (12.34 / 0); // Végtelenség.
riasztás (-3 / 0); // -VÉGTELENSÉG.
Ezzel talán, és befejezze. Ha tetszik a kiadvány, akkor győződjön meg róla, hogy feliratkozik a blogomra. Ne remegjön egy érdekes cikkekre, és ossza meg őket barátaival. Viszlát!
JavaScript-matematika, akár két tizedesjegyig kerekítve (9)
A következő JavaScript szintaxis van:
Var kedvezmény \u003d math.round (100 - (ár / lista) * 100);
Ez egy egész számra kerekítve. Hogyan küldhetem vissza az eredményt két tizedesjegyvel?
Itt van egy munkapélda
VAR érték \u003d 200.2365455; Eredmény \u003d Math.Round (Érték * 100) / 100 // Az eredmény 200,24
A legtöbb decimális helyekre a legtöbb szükségletre történő feldolgozásához elegendő funkció lesz 2 kódvezetékkel. Itt van a játék példakódja.
Var testnum \u003d 134.9567654; Var decl \u003d 2; var testres \u003d rounddec (testnum, decl); Riasztás (testnum + "kerekített" + decpl + "decimális helyek" + testrezes); Funkció RoundDec (NBR, DEC_PLACES) (var mult \u003d math.pow (10, dec_places); visszatérő matematika. (NBR * MULT) / MULT;)
A legjobb és egyszerű megoldás, amit találtam
Funkció kerek (visszatérési szám (matematika (matematika (érték + e "+ decimálisok) +" e - "+ tizedesjegyek);) kerek (1.005, 2); // 1.01
Az elfogadott válasz kis változata. Tofixed (2) visszaadja a karakterláncot, és mindig két tizedesjegyet kap. Ez lehet nullák. Ha elnyomja a végleges nulla (ek), csak tegye meg:
Var kedvezmény \u003d + ((ár / lista) .tofixed (2));
Szerkesztve: Csak azt találtam, hogy ez a Firefox 35.0.1 hibája, ami azt jelenti, hogy a fentiek nan értékeket adhatnak.
Megváltoztattam a kódomat
Var kedvezmény \u003d math.round (Ár / Listprice * 100) / 100;
Ez két tizedespontos pontossággal rendelkezik. Ha háromra van szüksége, akkor többször is megosztja és megosztja az 1000-et, és így tovább.
Az Op két tizedes lemerülést akar, de ha Tofixed () törött a Firefoxban, akkor először meg kell erősítenie.
Lásd: https://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388.
Ha két tizedesjegyet eredményezne, akkor a következőket teheti:
Var kedvezmény \u003d math.round ((100 - (ár / lista) * 100) * 100) / 100;
A lekerekített értéket 100-mal megszorozzák, hogy megmentjük az első két számjegyet, akkor 100-ra osztjuk, hogy megkapjuk a tényleges eredményt.
Azt hiszem, a legjobb módja, amellyel láttam 10 számonként 10 számmal, majd a matematikát, majd végül 10 számszámmal osztja meg. Itt van egy egyszerű funkció, amelyet írószövegekben használok:
Funkció RoundToxDigits (érték: szám, számjegyek: szám) (Érték \u003d \u003d érték * matematika (10, számjegy); érték \u003d math.round (érték); érték \u003d érték / matematika); )
Vagy egyszerű JavaScript:
Funkció RoundToxDigits (érték, számjegyek) (ha (! Számjegyek) (számjegyek \u003d 2,) érték \u003d érték * matematika (10, számjegy); érték \u003d math.round (érték); érték \u003d érték / matematika. , számjegyek); visszatérési érték;)
JEGYZET. - Lásd a 4. szerkesztést, ha a 3 számjegyű pontosság fontos.
Var kedvezmény \u003d (ár / lista) .tofixed (2);
a tofixed a 2 decimális jelet meghaladó értékektől függően felfelé vagy lefelé kerekítve.
Változás. Amint mások is említettük, átalakítja a karakterlánc eredményét. Ennek elkerülése érdekében:
Var kedvezmény \u003d + ((ár / lista) .tofixed (2));
2. szerkesztés. - Amint azt a megjegyzésekben említettük, ezt a funkciót nem végzik valamilyen pontossággal, például 1,005 esetén 1,00 helyett 1,0-et ad vissza. Ha a pontosság fontos ilyen mértékben, megtaláltam ezt a választ: https: //.com/a/32605063/1726511 Mi úgy tűnik, hogy jól működik az összes teszteléssel.
Az egyik kisebb módosítás megköveteli, de a fent jelzett válasz az egész számokat adja vissza, ha egyre kerekítve, ezért 99.004 visszatér 99 helyett 99,00, ami nem tökéletes az árkijelzéshez.
3. szerkesztés. - Úgy tűnik, hogy a még mindig csavart néhány szám tényleges visszatérése, a végső szerkesztés úgy tűnik, hogy működik. Geez annyi javítást!
Var kedvezmény \u003d kerek ((ár / lista), 2); Funkció (n, számjegyek) (ha (számjegyek \u003d\u003d\u003d nem definiált) (számjegyek \u003d 0;) var multiplicator \u003d math.pow (10, számjegy); n \u003d parsefloat ((n * multiplicator) .tofixed (11)); var teszt \u003d (math.round (N) / multiplicator); Visszatérés + (teszt.tofixed (számjegyek));)
Szerkesztés 4. - Megölsz engem. A 3. szerkesztés sikertelen a negatív számok nélkül, anélkül, hogy ásni szeretnénk, miért könnyebb egyszerűen csak negatív számot pozitívvá tenni a kerekítés előtt, majd visszaküldje vissza az eredmény visszaküldése előtt.
Funkció kerekület (N, számjegyek) (var neat negatív \u003d hamis, ha (számjegyek \u003d\u003d\u003d nem definiált) (számjegyek \u003d 0;), ha (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 út - gyorsabb, mint a tofixed ():
Két dekalitás
x \u003d .123456 Eredmény \u003d math.round (x * 100) / 100 // eredmény .12Három decimászat
x \u003d .123456 Eredmény \u003d Math.Round (x * 1000) / 1000 // eredmény .123Funkció kerek (NUM, DEC) (NUM \u003d MATH.Round (NUM + E '+ DEC) Visszatérési szám (NUM + "E -" + DEC)) // fordítva a választott döntőre: kerek (1.3453.2)
Helló. Ma, a JavaScript oszlop, nézzük meg, hogyan kell beállítani a JavaScript száma seasolines a lebegőpontos számokat. Például 3 decimális jelet kell hagynia, ha megjeleníti, vagy csak kettő.
Feladat: JavaScript-féloolonok száma
Tehát a feladattal szembesülünk: a számítások eredménye, amelyben vannak számok a pontosvessző előtt, és a vessző után. Decimális. Tegyük fel, hogy az eredmény kiderült, hogy ez a 1538.9891200153. De ha a kimenetnek az összeget tükröző számnak kell lennie, ahol a bankjegyek összege a vesszőig, és utána kopecks.
Számos módja van a feladat megoldására.
1. megoldás: JavaScript-féloolonok száma a tofixed módszerrel
a Tofixed egy beágyazott a JavaScript módszerbe, amelyet bármely számra alkalmaznak, a pontosság a pontossági kerekítés (azaz a tengerparti karakterek száma).
Var num \u003d 1538.9891200153; NUM_STR \u003d NUM.TOFIXED (); // NUM_STR \u003d 1538; NUM_STR \u003d NUM.TOFIXED (2); //Num_str\u003d1538.98; NUM_STR \u003d NUM.TOFIXED (5); //Num_str\u003d1538.98912;
A pontossági paraméter ebben a funkciónak legalább 0 (nem szedje negatív értékeket), és legfeljebb 20.
Nem lehet változó nélkül, például így:
NUM_STR \u003d (1538.9891200153) .tofixed (2); //Num_str\u003d1538.98;
2. megoldás: JavaScript-féloolonok száma a toprecision módszerrel
Ez a megoldás ugyanazon beépített JavaScript módszeren alapul. Ennek a módszernek a megkülönböztető jellemzője, hogy a bemenethez vett paraméter nem jelzi a pontosságot (a pontosvolonok számát), hanem a karakterek teljes számát (mind a vesszőhöz, mind utána).
Var num \u003d 1538.9891200153; NUM_STR \u003d NUM.TOPRECISION (5); //Num_str\u003d1538.9; NUM_STR \u003d NUM.TOPRECISION (7); //Num_str\u003d1538.989;
Megoldás jelek nélkül vessző után: JavaScript-féloolonok száma
Ha a tizedesjegyeket teljesen össze kell hajtani, azaz a frakcionális számot az egészre kell fordítani, akkor a matematika funkcióit: kerek, ceil és padlón használhatja.
Kerek - körök nagy vagy kisebb oldalon (a számtól függően). Ha a pontosvessző utáni érték több mint fele, akkor az egész oldalra, ha kevesebb - kisebb. Vagyis, ha 0,51 - lesz 1, ha 0,49 - 0.
Ceil - az angolul. A mennyezet mindig a legnagyobb oldalra kerekítve.
Padló - angolul. A Paul mindig kisebb oldalon van.
Var num \u003d 1538.9891200153; NUM_STR \u003d MATH.Round (Num); // NUM_STR \u003d 1539; NUM_STR \u003d MATH.FLOOR (NUM); // NUM_STR \u003d 1538; NUM_STR \u003d MATH.CEIL (NUM); // NUM_STR \u003d 1539;
Ez minden. Remélem, ez a jegyzet segített megoldani a feladatot. Ha valami sikertelen - kérdéseket tesz fel a zöld gomb segítségével "Kérdezzen meg egy kérdést szakemberrel", vagy a megjegyzésekben.
Gyakran a számítások olyan eredményeket adnak, amelyek nem felelnek meg a kívánt tartományok korlátainak. Ennek eredményeként gyakorolni kell JavaScript kerekítés egy bizonyos értékig.
Miért kerek számok?
A JavaScript nem tárolja az egész számokat, mivel értékeiket lebegőpontos számok formájában mutatják be. Sok frakciók nem lehet egy szám képvisel egy bizonyos véges számú pontosvesszőt, így JavaScript generálhat eredményeket, mint a következő:
0.1 * 0.2; > 0.020000000000000004
A gyakorlatban nem lesz fontos, mivel a hiba 2 kinylone. De ez befolyásolhatja az eredményt, amikor olyan számokkal dolgozik, amelyek szelepértékeket, százalékos vagy fájlméretet jelentenek. Ezért meg kell tennie vagy egy bizonyos tizedesjegyet.
A tizedes számok kerekítése
A tizedes számot, a tofixed () vagy a toprecision () módszereket használják. Mindkettő egy olyan érvet vesz, amely meghatározza a vessző utáni jelentős és jelek számát, amelyet az eredménybe kell venni:
- ha a tofixed () az argumentum nincs meghatározva, az alapértelmezett érték 0, azaz nincs jele a vessző után; Az argumentum maximális értéke 20;
- ha a toprecision () az argumentum nincs megadva, 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
És tofixed () és a toprecision egy lekerekített kisbetűs ábrázolást, és nem számot ad vissza. Ez azt jelenti, hogy a Randnumhoz való rount hozzáadás egy koncentrációs húrot eredményez, és nem egy számot:
konzol.log (randnum + kerekített); \u003e "6.256"
Ha meg kell kapnia egy JavaScript kerekítését a századig, használja a ParseFloat ():
var randnum \u003d 6,25; var rounded \u003d parsefloat (randnum.tofixed (1)); Konzol.log (lekerekített); \u003e 6.3.
a tofixed () és a toprecision () szintén hasznos módszerek a nagyszámú pontosvessző csonkítására. Kényelmes, ha a monetáris egységeket képviselő számokkal dolgozik:
var WHOLENUM \u003d 1 VAR DOLLARSCENT \u003d WHOLENUM.TOFIXED (2); Konzol.log (Dollarscents); \u003e "1.00"
Kérjük, vegye figyelembe, hogy ha több jele van, mint a megadott pontossági paraméter, a TopReCision tudományos formátumú eredményt ad ki:
var szám \u003d 123,435 NUM.TOPRECISION (2); \u003e "1.2E + 2"
Hogyan lehet elkerülni a hibákat a tizedes frakciók kerekítése során
Bizonyos esetekben tofixed és toprecision történik JavaScript 5-ös kerekítés egy kisebb oldalra, nem több:
vAR NumTest \u003d 1.005; numtest.tofixed (2); \u003e 1;
A fenti példa eredménye 1.01, és nem 1. Ha ezt a hibát szeretné elkerülni, javaslom az exponenciális számok használatával:
funkció kerek (visszatérési szám (matematika (matematika (érték + e "+ decimális) +" E - "+ tizedesjegyek);)
Alkalmazás:
kerek (1.005.2); \u003e 1.01
Ha még megbízhatóbb megoldásra van szüksége, mint a kerekítés, elérhető MDN..
Kerekítés epsilonnal
Alternatív módszer JavaScript kerekítés a tizedre az ES6-ban vezették be ( javaScript 2015 néven is ismert). « Gép epsilon»A két lebegő pontosvessző összehasonlításakor ésszerű hibahatárot biztosít. Kerekítés nélkül az összehasonlítások olyan eredményeket adhatnak, mint a következők:
0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e FALSE
Math.epsilon használható a funkcióban, hogy megfelelő összehasonlítást kapjon:
(X, y) függvény (visszaadja a math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
A funkció két argumentumot vesz igénybe: Az egyik számításokat tartalmaz, a második várt (lekerekített) eredményt. Ez a két paraméter összehasonlítása:
eple (0,1 + 0,2, 0,3)\u003e igaz
Minden modern böngésző támogatja az ES6 matematikai funkcióit. De ha támogatni kell a régi böngészők támogatását, akkor a polifillát kell használnia.
A decimális számok csonkítása
A korábban bemutatott összes módszer JavaScript kerekítés a tizedre. Vágásához pozitív szám, legfeljebb két helyen a vessző után, szorozzuk meg 100, vályú, majd ismét a kapott eredményt elosztjuk 100-zal, amire szüksége van:
funkció csonkolt (NUM) (RETURN MATH.TRIRN (NUM * 100) / 100,) csonkolt (3.1416)\u003e 3.14
Ha valami rugalmasabb szükséges, használhatja a törött operátort:
funkció csonkított (var numpowersconverter \u003d math.pow (10, decalpaces); visszatérés ~ ~ (NUM * NUMPOWERCONDERTER) / NUMPOWERCONVERTER;)
A:
var randint \u003d 35.874993; Csonkított (Randint, 3); \u003e 35.874.
Kerekítés a legközelebbi számra
Megvalósít JavaScript kerekítés az egészre, Math.Round () használják:
Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5
Vegye figyelembe, hogy " félértékek", Mint például .5, lekerekített.
A legközelebbi egész számra kerekítve
Ha kisebb oldalon leereszkedni szeretne, használja a Math.Floor () módszert:
Math.Floor (42.23); \u003e 42 Math.Floor (36.93); \u003e 36.
A "Down" kerekítésnek egy iránya van minden számra, beleértve a negatívat is. Ez felhőkarcolóként ábrázolható végtelen számú emeleten, beleértve az Alapítvány szintjét ( negatív számok képviselete). Ha a liftben a 2 és 3 alagsori padló között van ( milyen megfelel -2,5 értékkel), Math.Floor szállít a padlóról -3:
Math.Floor (-2,5); \u003e -3.
Ha ezt meg akarja kerülni, használja a JavaScript Math kerekítést a Math.Trunc () segítségével, amelyet minden modern böngészőben támogatott (kivéve IE / EDGE):
Math.Trunc (-41.43); \u003e -41
Az MDN is megadja három sor polifill, hogy a Math.Trunct támogatja a régi böngészők és az IE / Edge.
A legközelebbi egész számra kerekítés
Ha a decimális számokat felfelé akarja fordítani, használja a Math.Ceil-t. Ennek a módszernek a fellépése végtelen liftként is ábrázolható: a Math.ceil mindig szerencsés "fel", 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 matematika (-36,93); -36
Kerekítés a legközelebbi többszámra
Ha az értéket a legközelebbi számra kell összpontosítania, akkor több 5, hozzon létre egy olyan funkciót, amely az 5-ös számot osztja meg, kerekíti, majd megszorozza az eredményt ugyanolyan értéken:
funkció kerekület (NUM) (RETURN MATH.ROUD (NUM / 5) * 5;)
A:
fordulóban5 (11); \u003e 10.
Ha legfeljebb két karakterig szeretné végrehajtani a JavaScript kerekítését, akkor a funkciókat kezdeti számként és sokféleségként továbbíthatja:
funkció kerekítés (NUM, többszörös) (Return Math.Round (szám / többszörös) * többszörös;)
A funkció használatához kapcsolja be a lekerekített számot és a sokszorosítást a hívásában:
var inicialnumber \u003d 11; var-többszörös \u003d 10; Roundtomultiple (inicialnumber, többszörös); \u003e 10;
Az értékek csak nagy vagy kisebb irányba kerekítve cserélje ki a kerek funkciót a Ceil vagy a padlón.
Kötés a tartományhoz
Néha meg kell kapnia az X értéket, amely egy bizonyos tartományon belül kell lennie. Például 1-től 100-ig értékre van szüksége, de megkapjuk a 123 értéket. Megjavítani, használhatja a min () () () () visszaadja a legkisebb számokat) és max ( visszaadja a megengedett számot).
A:
var lowbound \u003d 1; varibound \u003d 100; var numinput \u003d 123; var clamped \u003d math.Max \u200b\u200b(lowbound, math.min (numinput, highbound)); Konzol.log (szorítva); \u003e 100;
Létrehozhat egy funkciót vagy kiterjesztési osztályszámot.
Nagyon gyakran a JavaScript számításai nem adják meg teljesen az általunk kívánt eredményeket. Természetesen meg tudjuk csinálni a számokat bármi - egy nagy vagy kisebb oldalú kerekítés, állítsa be a tartományokat, vágja le a felesleges számokat egy bizonyos számú tizedes helyen, mindez attól függ, hogy mit akarsz tenni a jövőben ezzel a számmal.Miért van szükséged kerekítésre?
A JavaScript egyik kíváncsi aspektusa az, hogy valójában nem tárolja az egész számokat, azonnal lebegőpontos számokkal dolgozunk. Ez azzal a ténnyel kombinálva, hogy sok frakcionálási értéket nem lehet a tizedesjegyek végső számával expresszálni, ilyen eredményeket kaphatunk a JavaScript alkalmazásban:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Gyakorlati célokra ez a pontatlanság nem számít, ügyünkben a Quintillion dollár hibájáról beszélünk, azonban valaki csalódhat. Kicsit furcsa eredményt kaphatunk, és amikor olyan számokkal dolgozunk, amelyek szelepértékek, százalékos vagy fájlméretek. A pontatlanságok kijavítása érdekében csak meg kell tudnunk az eredményeket megfogalmazni, bár ez elég ahhoz, hogy tizedes pontosságot hozzon létre.
A számok kerekítése gyakorlati alkalmazással rendelkezik, manipulálhatjuk a számot egy bizonyos tartományban, például azt szeretnénk, hogy az értéket a legközelebbi egész számra, és ne működjünk csak a tizedes részkel.
A tizedes számok kerekítése
A tizedes szám levágásához használja a tofixed vagy toprecision módszert. Mindkettőt egyetlen olyan érv veszi figyelembe, amely meghatározza, hogy hány értelmes szám (azaz a számban használt számok száma a szám) vagy a pontosvessző után (a tizedespont után) után (a tizedespont után) tartalmaznia kell az eredményt:- Ha az argumentumot nem határozzák meg a Tofixed () esetében, akkor az alapértelmezés szerint nulla lesz, ami a vessző után 0 jelet jelent, az argumentumnak maximális értéke 20.
- Ha az argumentum nincs megadva a toprecision esetében, akkor a szám érintetlen marad
Mind a tofixed () és a toprecision () módszerek visszaadják az eredmény ábrázolását, nem számot. Ez azt jelenti, hogy a Randnum lekerekített értékének összegzésével a sorok összefűzése lesz, és nem a számok összege:
Legyen Randnum \u003d 6,25; Legyen lekerekített \u003d randnum.tofixed (); // "6" konzol.log (randnum + kerekített); \u003e "6.256"
Ha azt szeretné, hogy az eredménynek numerikus adattípusa legyen, akkor a ParseFloat-ot kell alkalmazni:
Legyen Randnum \u003d 6,25; Legyen lekerekített \u003d parsefloat (randnum.tofixed (1)); Konzol.log (lekerekített); \u003e 6.3.
Kérjük, vegye figyelembe, hogy az 5 érték kerekítve, ritka esetek kivételével.
Tofixed () és toprecision () módszerek hasznosak, mivel nem csak a frakcionált rész levághatják, hanem kiegészítik a jeleket a vessző után, ami kényelmes, ha valutával dolgozik:
Legyen WHOLENUM \u003d 1 Legyen Dollarscents \u003d WHOLENUM.TOFIXED (2); Konzol.log (Dollarscents); \u003e "1.00"
Feltételezzük, hogy a toprecision exponenciális rekordot eredményez, ha az egész számok száma nagyobb, mint maga a pontosság:
Legyen NUM \u003d 123,435 NUM.TOPRECISION (2); \u003e "1.2E + 2"
Hogyan lehet elkerülni a kerekítési hibákat decimális számokkal
Bizonyos esetekben a tofixed és a toprecision az 5-ös értéket egy kisebb oldalra fordítja, és egy nagy:Legyen NumTest \u003d 1.005; numtest.tofixed (2); \u003e "1.00"
A fenti számítás eredménye 1,01 volt, és nem 1. Ha szeretné elkerülni a hasonló hibát, használhatjuk a Jack L Moore által javasolt megoldást, amely exponenciális számokat használ a kiszámításhoz:
Funkció kerek (visszatérési szám (matematika (matematika (érték + e "+ decimális) +" E - "+ tizedesjegyek);)
Most:
Kerek (1.005.2); \u003e 1.01
Ha megbízhatóbb megoldást szeretne, mint a fent látható megoldás, akkor MDN-re is megy.
Gép epsilon kerekítés
A decimális számok kerekítés alternatív módszerét az ES6-ba vezették be. A gép Epsilon kerekítése ésszerű hibahatárot biztosít két lebegőpontos szám összehasonlításakor. Kerekítés nélkül az összehasonlítások olyan eredményeket adhatnak, mint a következők:0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e FALSE
Math.epsilont használunk a funkciónkban, hogy helyes összehasonlítást kapjunk:
(X, y) függvény (visszaadja a math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
A funkció két érvet vesz igénybe: az első - jelenlegi számítás, a második a várt eredmény. A kettő összehasonlítását adja vissza:
Eple (0,1 + 0,2, 0,3)\u003e igaz
Minden modern böngésző már támogatja az ES6 matematikai funkcióit, de ha támogatni szeretné a böngészőket, például az IE 11-et, használja a polifillákat.
A frakcionált rész vágása
A fentiekben bemutatott összes módszer képesek kerekíteni a decimális számokig. Annak érdekében, hogy egyszerűen vágja le a számot két jelzés után a vessző után, először meg kell szednie 100, majd a kapott eredményt már 100:Funkció csonkolt (NUM) (RETURN MATH.TRIRN (NUM * 100) / 100,) csonkolt (3.1416)\u003e 3.14
Ha a módszert bármilyen pontosvesszőhöz kívánja alkalmazni, akkor kettős bitty tagadást használhat:
Funkció csonkolt (Legyen NUMPOWERCONVERTER \u003d MATH.POW (10, DECALMPLACES); Visszatérés ~~ (NumpowerConverter) / NumpowerConverter;)
Most:
Legyen Randint \u003d 35.874993; Csonkított (Randint, 3); \u003e 35.874.
Kerekítés a legközelebbi számra
Annak érdekében, hogy a decimális számot a legközelebbi számra több vagy kisebb oldalon fordítsanak, attól függően, hogy mi a legközelebb, használja a matemath.round ():Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5
Kérjük, vegye figyelembe, hogy a "fele az érték", 0,5 kerekítés nagy irányban a matematika szabályai szerint.
Kerekítés a legközelebbi egész számra
Ha kisebb oldalra akarsz fordulni, használja a Math.Floor-ot:Math.Floor (42.23); \u003e 42 Math.Floor (36.93); \u003e 36.
Kérjük, vegye figyelembe, hogy a kisebb oldalak kerekítése minden számra működik, beleértve a negatívat is. Képzeljen el egy felhőkarcolót egy végtelen számú emeleten, beleértve az alacsony szintű emeleteket (negatív számokat ábrázoló). Ha a liftben a liftben a 2 és 3 közötti alacsonyabb szinten tartózkodik (amely -2,5 érték), a Math.Floor szállít -3-ra:
Math.Floor (-2,5); \u003e -3.
De ha azt akarjuk, hogy elkerülje a hasonló helyzet, használja Math.trunc támogatott minden modern böngésző (kivéve IE / EDGE):
Math.Trunc (-41.43); \u003e -41
A MDN polifillel megtalálja a Math.Trunct támogatást a böngészők és azaz / él.
Kerekítve a legközelebbi egész számra
Másrészt, ha mindig a legnagyobb, használd a matematika. Ismét emlékezzen a végtelen liftre: Math.ceil mindig felmegy, függetlenül attól, hogy a szám negatív vagy nem:Math.ceil (42.23); \u003e 43 Math.ceil (36.93); \u003e 37 matematika (-36,93); \u003e -36
Kerekítés egy nagyobb / kisebb számra
Ha a legközelebbi számra, több 5-ig szeretnénk kerekíteni, akkor a legegyszerűbb módja annak, hogy olyan funkciót hozzunk létre, amely 5 fordulóban osztja meg a számot, majd megszorozza az azonos összeghez:Funkció kerekület (NUM) (RETURN MATH.ROUD (NUM / 5) * 5;)
Most:
Fordulóban5 (11); \u003e 10.
Ha többszörös értékre szeretné kerekíteni, akkor egy általánosabb funkciót használunk a kezdeti érték és a többszörösek átadásával:
Funkció kerekítés (NUM, többszörös) (Return Math.Round (szám / többszörös) * többszörös;)
Most:
Legyen inicialNumber \u003d 11; Legyen többszörös \u003d 10; Roundtomultiple (inicialnumber, többszörös); \u003e 10;
A szám rögzítése a tartományban
Sok esetben van, amikor a tartományon belül fekvő x értékét szeretnénk megkapni. Például szükségünk lehet 1-től 100-ig, ugyanakkor 123 értéket kaptunk. A javításához a minimumot használhatjuk (visszaadjuk a számok legkisebb számát) és a maximális ( visszaadja a legnagyobb több számot). Példánkban az 1-től 100-ig terjedő tartomány:Legyen Lowbound \u003d 1; Hagyja, hogy a highbound \u003d 100; Legyen numinput \u003d 123; Legyen rögzítve \u003d math.Max \u200b\u200b(lowbound, math.min (numinput, highbound)); Konzol.log (szorítva); \u003e 100;
Ismét újra használhatjuk a műveletet, és mindezt a funkcióba csomagolhatjuk, a Daniel X. Moore által javasolt megoldást használjuk:
Szám.prototype.Clamp \u003d funkció (MIN, MAX) (RETURN MATH.MIN (MATH.MAX (ez, min), max););
Most:
Numinput.clamp (lowbound, highbound); \u003e 100;
Gauss-kerekítés
Gauss-kerekítés, más néven bank kerekítés, az, hogy a kerekítés ebben az esetben fordul elő a legközelebbi fekete. Ez a kerekítési módszer statisztikai hiba nélkül működik. A legjobb megoldást Tim le javasolta:Funkció Gaussround (Legyen d \u003d decalpaces || 0, m \u003d math.pow (10, d), n \u003d + (d? Szám * 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
Decimális jel a CSS-ben:
Mivel a JavaScriptet gyakran használják a HTML elemek pozíciós átalakításának létrehozására, akkor kíváncsi lehet, hogy mi történik, ha tizedes értékeket generálunk tételeinkért:
#Box (szélesség: 63.667731993px;)
Jó hír az, hogy a modern böngészők figyelembe veszik a decimális értékeket egy blokkmodellben, beleértve a százalékos vagy pixeles mérési egységeket is.
Válogató
Nagyon gyakran meg kell rendeznünk minden elemet, például van egy sor játékrekordok, míg azokat a játékosok csökkenő sorrendjeként kell megszervezni. Sajnos a Standard Rendezés () módszer néhány csodálatos korlátozással rendelkezik: jól működik a gyakran használt angol szavakkal, de azonnal megszakad egy találkozón számokkal, egyedi karakterekkel vagy szavakkal a nagybetűkkel.Rendezés betűrendben
Úgy tűnik, hogy a tömb rendezés betűrendben kell lennie a legegyszerűbb feladat:Legyen gyümölcs \u003d ["butternut squash", "sárgabarack", "Cantaloupe"]; gyümölcs.Sort (); \u003e "Sárgabarack", "butternut squash", "Cantaloupe"]
Mindazonáltal a problémával szembesülünk, amint az egyik elem a nagybetűs:
Legyen gyümölcs \u003d ["butternut squash", "aprot", "kantalope"]; gyümölcs.Sort (); \u003e "Cantaloupe", "aprot", "butternut squash"]
Ez annak köszönhető, hogy alapértelmezés szerint a Sorter összehasonlítja az Unicode-ban bemutatott első szimbólumot. Az Unicode egyedülálló kód bármely szimbólumhoz, függetlenül a platformtól függetlenül a programtól függetlenül a nyelvtől. Például, ha megnézi az kódtábiázatban az „A” karakter u + 0061 (hexadecimális rendszerben 0x61), míg a „C” kódszámú U + 0043 (0x43), amely jóval korábban a Unicode tábla, mint Az "A" szimbólum.
Az első betűk vegyes nyilvántartásait tartalmazó tömb rendezéséhez az összes elemet átmenetileg át kell konvertálnunk az alsó regiszterbe, vagy határozza meg a rendezési megrendelést a localeCompare () módszerrel néhány argumentummal. Általában egy ilyen esetben jobb azonnal létrehozni az ismételt felhasználás funkcióját:
Funkció AlphaDort (ARR) (RETURN A.LOCALECOMPARE (B, EN ", (" érzékenység ":" bázis ");))))))));) Hagyja, hogy gyümölcs \u003d [" butternut squash "," kagyló "]; Alphasort (gyümölcs)\u003e
Ha egy tömböt szeretne kapni a fordított ábécé sorrendbe, egyszerűen módosítsa az A és B pozíciót a funkcióhoz:
Funkció alphasort (ARR) (RETURN B.LOCALECOMPRE (A, EN ", (" érzékenység ":" bázis ");)))))))););) Hagyja, hogy gyümölcs \u003d [" butternut squash "," kagyló "]; Alphasort (gyümölcs)\u003e ["Cantaloupe", "Butternut squash", "Sárgabarack"]
Érdemes megfizetni a figyelmet arra, hogy a localeCompare-t érvekkel használják, még mindig meg kell emlékezni, hogy az IE11 + támogatja az idősebb, azaz verziók számára, argumentumok nélkül használhatjuk, és az alsó regiszterben:
Funkció Tokok (ARR) (Visszatérés a.tolowercase (). LocalEcompare (b.tolowercase ());)));) Legyen gyümölcs \u003d ["butternut squash", "Cantaloupe"]; Tokok\u003e [Sárgabarack, "butternut squash", "Cantaloupe"]
Numerikus válogatás
Mindez nem vonatkozik arra a példára, amelyre beszéltünk a fenti játékrekordokról. Néhány numerikus tömbökkel a válogatás tökéletesen működik, de valamikor az eredmény kiszámíthatatlan lehet:Hagyja, hogy a highscores \u003d; highscores.Sort (); \u003e
Az a tény, hogy a fajta () módszer lexikográfiai összehasonlítást eredményez: és ez azt jelenti, hogy a számokat egy karakterláncra alakítják át, és az összehasonlításokat újra elvégzik, ha az Unicode asztali szimbólumok első karakterét feltérképezik. Ezért meg kell határoznunk a rendezési sorrendet:
Hagyja, hogy a highscores \u003d; Highscores.Sort (visszatérés a - b;)); \u003e
Ismét, a számok rendezéséhez fordított sorrendben módosítsa az A és B pozíciókat a funkcióhoz.
Rendezés JSON-szerű struktúra
És végül, ha van egy JSON-szerű adatszerkezetünk, mint a játékrekordok tömbjeként:Legyen a pontszámok \u003d [("Név": "Daniel", "pontszám": 21768), ("Név": "Michael", "Score": 33579), ("Név": "Alison", "pontszám": 38395 ]];
Az ES6 + -ban a nyílfunkciókat használhatja:
Scores.Sort ((A, B) \u003d\u003e B.Score - A.Score));
A régi böngészők számára, akiknek nincs ilyen támogatása:
Scores.Sort (Return A.score - B.score));
Amint láthatod, a JavaScript-i válogatás elég nyilvánvaló dolog, remélem, hogy ezek a példák megkönnyítik az életet.
A teljesítményfunkciókkal való munka
A gyakorlat olyan művelet, amelyet eredetileg egy természetes szám többszörös szorzásának eredményeképpen definiált, az A szám négyzetgyöke egy négyzet számára megadott szám. Ezekkel a funkciókkal folyamatosan élvezhetnénk a matematikai órákban a mindennapi életben, beleértve a területek, mennyiségek vagy akár fizikai modellezés kiszámításánál.A JavaScript, a teljesítmény függvényt ábrázoljuk Math.pow (), az új ES7 szabvány, egy új gyakorlat szereplő bemutatták, hogy milyen mértékben - „*”.
Fokozatosan áll
Annak érdekében, hogy egy számot építsen az N-UY fokban, használja a Math.pow () függvényt, ahol az első argumentum az a szám, amelyet egy fokozat, a második argumentum a diploma mutatója:Math.Pow (3.2)\u003e 9
A 3 felvételi eszköz egy négyzet alakú, vagy 3 × 3-as, ami eredményeket eredményez 9. Egy másik példa adható természetesen:
Math.Pow (5.3); \u003e 125.
Azaz, 5 kubában, vagy 5 × 5 × 5, egyenlő 125.
Az Ecmascript 7 a JavaScript következő verziója, elvben az új javasolt gyakorlatüzemeltetőt is használhatjuk - * * -ig, a felvétel ilyen formája lehet vizuális lehet:
3 ** 2
> 9
Jelenleg az üzemeltető támogatása meglehetősen korlátozott, ezért nem ajánlott használni.
Az erőteljes funkció hasznos lehet különböző helyzetekben. Egyszerű példa, számolva másodpercek számát egy óra alatt: Math.Pow (60.2).
Négyzet és köbös gyökér
A Math.Sqrt () és a Math.cbrt () ellentétesek a Math.Pow () függvényekkel. Mint emlékszem, az A szám négyzetgyöke egy olyan szám, amely a négyzet felállt.Math.SQRT (9)\u003e 3
Ugyanakkor az A szám köbös gyökere egy olyan szám, amely a kockát felállítja.
Math.cbrt (125)\u003e 5
A Math.Cbrt () a közelmúltban a JavaScript specifikációba került, ezért csak a modern böngészőkben támogatott: Chrome 38+, Firefox és Opera 25+ és Safari 7.1+. Meg fogja venni, hogy az Internet Explorer hiányzik ebben a listában, azonban megtalálja a polifillet az MDN-en.
Példák
Természetesen használhatjuk és nem egész számot használhatunk az alábbi funkciók egyikében:Math.Pow (1.25, 2); \u003e 1.5625 Math.cbrt (56,57)\u003e 3.8387991760286138
Felhívjuk figyelmét, hogy jól működik, ha negatív érvek használata:
Math.pow (-5.2)\u003e 25 math.pow (10, -2)\u003e 0,01
Azonban egy négyzetgyökért nem fog működni:
Math.sqrt (-9)\u003e NAN
A matematikai elemzésből tudjuk, hogy a képzeletbeli szám alatt a négyzetgyöket negatív számokból értik. És ez egy másik technikához vezethet bonyolult számokkal, de ez egy másik történet.
A Math.Pow-ban () a négyzet és a köbös gyökerek számának keresését használhatja. A négyzetgyökér 0,5 jelzőt használ:
Math.Pow (5, 0,5); // \u003d math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Azonban a lebegőpontos szeszélyek miatt nem lehet pontosan feltételezni a helyes eredményt:
Math.Pow (2.23606797749979,2)\u003e 5.0000000000001
Ilyen helyzetekben a számok vagy a kerekítés bármely értékre kell vágnia.
Néhány, érthetetlen okok miatt a JavaScript összecsapja a Math.Pow () funkciót a Math.EXP (), amely az egész számok exponenciális funkciója. Megjegyzés: Angolul az "Exponent" jelző "exponens" -ként fordítva, így inkább az angol nyelvre utal, bár vannak olyan alternatív mutatónevek, mint az index, a teljesítmény.
Matematikai konstansok
A JavaScript matematikájával való együttműködés számos beépített konstans segítségével megkönnyíti. Ezek a konstansok a matematikai objektum tulajdonságai. Érdemes megjegyezni, hogy a konstansok a nagybetűsek, és nem a tevés jelölés.Math.abs, parseint, parsefloat
A JavaScript számokkal való együttműködés sokkal bonyolultabb lehet, mint amilyennek látszik. A kapott értékek nem mindig esnek a várt tartományba, néha az eredmény nem lehet egyáltalán, amit vártunk.Math.abs ()
Math.Abs \u200b\u200b() módszer visszaadja a szám abszolút értékét, amely ugyanazt a matematikai funkciót emlékezteti az A számnak.Legyen Newval \u003d -57.64; Math.abs (NewVal); \u003e 57.64
Math.abs (0) Mindig visszatér nulla, de ha egy mínusz jelet helyez el a -math.abs funkció (NUM), mindig negatív érték lesz.
Math.abs (0); \u003e -0.
parseint ()
Tudjuk, hogy a JavaScript úgy értelmezi, hogy „15” egy húr, és nem egy számot, és például elemzésekor CSS tulajdonságokat JavaScript közötti értékkel előkészítetlen tömb, eredményeink is kiszámíthatatlan. Meg tudtuk kaphatnánk a "17px" -ként képviselt bejárati vonalat, és számunkra nem ritka. A kérdés az, hogyan lehet ezt a karakterláncot a tényleges értékben konvertálni, és további számításokat használjon.Szintaxis: Parseint (string, radix);
A PARSEINT funkció átalakítja az első argumentumot, amely egy karakterlánc típusba kerül, értelmezi azt, és egész számot vagy nan értéket ad vissza. Az eredmény (ha nem NAN) egész szám, és az első argumentumot (string) jelenti, amelyet a megadott számrendszer (Radix) számának számának számít. Például a 10 bázis egy decimális számból, 8 - oktális, 16 hexadecimális és így tovább konverziót jelez. Ha a bázis nagyobb, mint 10, akkor a betűk több mint 9 számot jelölnek ki. Például hexadecimális számokhoz (16. alap), betűk A-tól F.
Tekintsünk egy példát a CSS tulajdonságokkal való munkavégzésre, ahol hagyományosan beszélhetünk ilyen értéket:
Legyen Elem \u003d Dokumentum. Legyen középpont \u003d window.getcomputedstyle (Elem) .transformorigin; \u003e "454px 2087.19px"
Megoszthatunk értékeket a szóközön:
Legyen Centers \u003d CenterPoint.split (""); \u003e ["454px", "2087.19px"]
Mindazonáltal minden elem még mindig egy karakterlánc, megszabadulhatunk a funkciójuk alkalmazásáról:
Legyen a CenterX \u003d PARSEINT (központok, 10); \u003e 454 Legyen centery \u003d parseint (központok, 10); \u003e 2087.
Amint láthatja, megadjuk a szám számát, amelyhez a szám átalakul, amelyre a paraméter opcionális, de ajánlott használni, ha nem tudja, melyik vonal megy a bemenetre.
parsefloat ()
A fenti példából valószínűleg észrevette, hogy a parseint eldobja a frakcionált részt. A mi esetünkben a ParseFloat úszópontszámokkal működhet. Ismét hasznos lehet a CSS és más feladatok elemzése során, különösen akkor, ha egy lebegőponttal százalékban dolgozik.Szintaxis: ParseFloat (string)
Legyen FP \u003d "33.33333%"; Konzol.log (ParseFloat (FP)); \u003e 33.33333
Felhívjuk figyelmét, hogy nincs második argumentum a ParseFloat szintaxisban.
Tisztában vagyunk azzal, hogy parseInt () és a parseFloat () rendkívül hasznos funkciók, fontos figyelembe venni, hogy ez nem feltétlenül szükséges hiba nélkül, ezért szükséges, hogy ellenőrizze a tartományban várható értékeket és végül elemezzük az eredményt Annak érdekében, hogy az értékek helyesek legyenek.
Névtelenül küld
