Բարեւ, սիրահարներ JavaScript-a. Դուք արդեն նկատել եք, որ այս լեզուն շատ արտառոց է, եւ յուրաքանչյուր բաժնում առանձնանում է իր առանձնահատկությունների եւ անսովոր տեխնիկական լուծումների համար: Հետեւաբար, այսօրվա հրապարակումը նվիրված է թեմային. JavaScript- ի կլորացում:

Ընթացիկ հոդվածը կարդալուց հետո դուք կիմանաք, թե ինչու է անհրաժեշտ թվերը շրջել, ինչ մեթոդներ եւ հատկություններ JS- ում կատարում են այս գործառույթը, ինչպես նաեւ ձեր սկզբունքները փոխելու համար, ես կներկայացնեմ առանցքային կետերի նյութը եւ մանրամասնորեն գրեք յուրաքանչյուր գործողություն: Հիմա եկեք սկսենք սովորել:

Կարեւոր նշումներ թվերի մասին

Սկսելու համար հիշեք, որ JS բոլոր տեսակի համարները (կոտորակային եւ ամբողջական) Տեսակը վերաբերում են Թիվ, Բացի այդ, բոլորը 64-բիթ են, քանի որ դրանք պահվում են «կրկնակի ճշգրտության» ձեւաչափով, որը հայտնի է նաեւ IEEE-754 ստանդարտով:

Սովորական ձեւով թվային փոփոխականներ ստեղծեցին.

var numb \u003d 35; // բնական համար

var drob \u003d 0.93; // տասնորդական ներկայացուցչություն

var numb16 \u003d 0xff; // 16-հարստահարող համակարգ

Աջակցում է այլ թվային դիտումներին: Այսպիսով, դուք կարող եք նաեւ թվեր ստեղծել լողացող կետով (դրանք երբեմն անվանում են «թվեր գիտական \u200b\u200bձեւաչափով»):

Հայտնվեց շատ հետաքրքիր մեթոդի համար Տոլոկալեստ ()Որ ձեւավորում է բոլոր թվային պարամետրերը, համաձայն ECMA 402-ում նախատեսված բնութագրերի: Այս մեծ թվերի, հեռախոսահամարների, արժույթների եւ նույնիսկ տոկոսների պատճառով երկխոսության վանդակում գեղեցիկ ցուցադրվում են:

var num \u003d 714000.80;

alert (num.tolocalestring ());

Աշխատել տիպի համարի տարրերով, մի ամբողջ գլոբալ առարկա `բոլոր տեսակի մաթեմատիկական գործառույթների մի փունջ, որի անունն է Մաթեմատիկա..

Բացի այդ, կան նաեւ այլ մեթոդներ, որոնք կատարում են կլորացման թվային արժեքներ ամբողջ թվերին, մինչեւ տասներորդը, հարյուրերորդը եւ այլն: Բոլորը համարեք դրանք:

Մեծ եւ հզոր մաթեմատիկա

Համաշխարհային մաթեմատիկական օբյեկտը ներառում է մեծ թվով մաթեմատիկական եւ եռանկյունաչափ գործառույթներ: Սա շատ անհրաժեշտ առարկա է եւ հաճախ կրճատում է մշակողներին թվային տվյալների հետ աշխատելիս:

Այլ հարթակներում կան անալոգներ մաթեմատիկա: Օրինակ, հանրաճանաչ լեզուներով, ինչպիսիք են Java եւ C #, մաթեմատիկան այն դաս է, որն աջակցում է բոլոր նույն ստանդարտ գործառույթներին: Այսպիսով, ինչպես տեսնում եք, այս գործիքը իսկապես հիանալի է եւ հզոր:

Այժմ ես ուզում եմ անցնել կլորացման համար պատասխանատու հատուկ մեթոդներով եւ մանրամասն պատմել դրանց մասին:

Math.Floor ()

Ես կսկսեմ Ս. Մաթեմատիկա.Հատակ, Ուշադրություն դարձրեք մեթոդի անունին: Տրամաբանորեն պարզ է դառնում, որ քանի որ մենք խոսում ենք կլորացման մասին, եւ «Հարկ» բառի բառացի թարգմանությունը նշանակում է «հատակ», ապա այս գործիքը ավարտվում է վերամշակված արժեքները ավելի փոքր ուղիղ:

Հնարավոր է նաեւ տարբերակ, երբ այս գործառույթը օգտագործող վերամշակված համարը մնում է նույնը: Բոլորը, քանի որ կլորացումն իրականացվում է ոչ նյարդային անհավասարության վրա (<=). Таким образом, при отработке этой строчки кода:

alert (Math.Floor (4.5));

Պատասխանը կլինի 4 համարը:

Մաթեմատիկա .CEL ()

Կրկին նայեք անունը (նման մեթոդով նյութը արագ ներծծվում է): Եթե \u200b\u200bինչ-որ մեկը չգիտի, «Կեիլ» նշանակում է «առաստաղ»: Դա նշանակում է, որ թվային տվյալների կլորացումը կկատարվի առավելագույնը, օգտագործելով ոչ անհավասարություն (\u003e \u003d):

alert (Math.Ceil (4.5));

Ինչպես արդեն կռահել եք, պատասխանը կլինի 5-րդ համարը:

Math.Round ()

Այս մեթոդը փակցնում է կոտորակային համարը մոտակա ամբողջությանը: Այսպիսով, եթե կոտորակային մասը գտնվում է 0-ից մինչեւ 0,5 սահմաններում, ապա կլորացումը տեղի է ունենում ավելի փոքր արժեքի: Եվ եթե կոտորակային մասը ներառական 0.5-ի սահմաններում է, եւ մինչեւ հաջորդ ամբողջական թիվը, այն կլորացվում է ավելի մեծ ամբողջությամբ:

alert (Math.Round (4.5));

Հուսով եմ, բոլորը մտածել կամ ասել են ճիշտ պատասխանը `5:

Եւս մի քանի մեթոդ

JavaScript- ը ունի նաեւ այլ 2 եղանակ, որոնք զբաղվում են թվային ներկայացուցչություններով կլորացմամբ: Այնուամենայնիվ, դրանք մի փոքր այլ են:

Դա կլինի այնպիսի գործիքների մասին, ինչպիսիք են tofixed () մի քանազոր tOPRECISION (), Նրանք պատասխանում են ոչ միայն կլորացման, այլեւ որոշակի նշանների ճշգրտության համար: Եկեք խորը պայքարենք:

tofixed ()

Այս մեխանիզմով դուք կարող եք նշել, թե որքան նշան է ստորակետից հետո անհրաժեշտության մասին: Մեթոդը արդյունքը վերադարձնում է որպես տող: Ստորեւ ես կցեցի տարբերակ երեք տարբեր տարբերակներով: Վերլուծեք ստացված պատասխանները:

var num \u003d 5656.9393;

document.writeln (num.tofixed ()); // 5657:

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

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

Ինչպես երեւում է, եթե դուք չեք նշում փաստարկը, ապա Tofixed ()) Կոտորգերի արժեքը ամբողջովին համարներ: Երրորդ տողում ավարտված կլորացումը Մինչեւ 2 նիշԵվ չորրորդում `« 7 »պարամետրերի պատճառով, եւս երեքը հասցեագրված էր:

tOPRECISION ()

Այս մեթոդը ինչ-որ չափով այլ կերպ է գործում: Վատարարի տեղում կարող եք թողնել ինչպես դատարկ տեղ, այնպես էլ սահմանել պարամետրը: Այնուամենայնիվ, վերջինս կլորացնի թվերը մինչեւ նշված թվերի քանակը, ուշադրություն չդարձնելով ստորակետին: Ահա ծրագրի անցյալից վերաշարադրված ծրագրի արդյունքները.

var num \u003d 5656.9393;

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

document.writeln (num.toprecision (2)); // 5.7E + 3

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

Division- ի ֆայլը js 0-ում

Ինչպես հայտնի է մաթեմատիկայի դասերից, անհնար է բաժանել զրոյի: Այս կանոնը հիմք ընդունեց ծրագրավորման լեզուների ստեղծողների մեծ մասը: Հետեւաբար, զրոյի բաժանելիս բոլոր ծրագրերը սխալ են տալիս:

Այնուամենայնիվ, JavaScript- ը հայտնվեց այստեղ: Այսպիսով, նման գործողության կատարման ընթացքում ոչ մի վրիպակի հաղորդագրություն չի առաջանում ... որովհետեւ այդպիսի գործողություն վերադառնում է «Անսահմանություն»!

Ինչու այդպես? Ինչպես հայտնի է նույն մաթեմատիկական գիտություններից, այնքան փոքր է բաժանարարը, արդյունքը ավելի մեծ թիվ է: Այդ իսկ պատճառով այս նախատիպային կողմնորոշված \u200b\u200bլեզվով ստեղծողները որոշեցին հրաժարվել կաղապարներից եւ գնալ իրենց ձեւով:

Նրանց համար, ովքեր առաջին հերթին բախվում են անսահմանության արժեքին, ստորեւ բացատրեցի դրա առանձնահատկությունները:

Infinity - նշանակում է անսահմանություն եւ լիովին համընկնում է մաթեմատիկական նշանի հետ:

Կարող է լինել բացասական: Փրկված են նաեւ թվաբանական օպերատորների հետ աշխատելու բոլոր ստանդարտ կանոնները:

alert (12/0); // անսահմանություն

Ահազանգ (12.34/0); // անսահմանություն:

alert (-3/0); // -infinity:

Այս, գուցե եւ ավարտեք: Եթե \u200b\u200bՁեզ դուր է գալիս հրապարակումը, ապա համոզվեք, որ բաժանորդագրվեք իմ բլոգին: Մի արեք հղում կատարել հետաքրքիր հոդվածներին եւ կիսել դրանք ընկերների հետ: Ցտեսություն!

JavaScript- մաթեմատիկա, կլորացնելով մինչեւ երկու տասնորդական տեղ (9)

Ես ունեմ հետեւյալ JavaScript շարահյուսությունը.

Var զեղչ \u003d Math.Round (100 - (Գինը / ցուցակ) * 100);

Սա կլորացվում է ամբողջ թվով: Ինչպես կարող եմ վերադարձնել արդյունքը երկու տասնորդական նշաններով:

Ահա աշխատանքային օրինակ

Var արժեք \u003d 200.2365455; Արդյունք \u003d Math.Round (արժեք * 100) / 100 // Արդյունքը կլինի 200.24

Շատ կարիքների համար ցանկացած թվով տասնորդական վայրերի կլորացման համար մշակելու համար բավարար գործառույթ կլինի 2 կոդ գծերով: Ահա խաղի օրինակ կոդը:

Var testnum \u003d 134.9567654; Var decpl \u003d 2; var Testres \u003d RoundDec (Testnum, Decpl); Alert- ը (Testnum + - ը կլորացված է «+ Decpl +» տասնորդական տեղերում, «+ փորձարկումներ է». Գործառույթի շրջագիծ (NBR, Dec_Places) (var mult \u003d math.pow (10, dec_places); վերադարձիր Math.Round (nbr * mult) / mult;)

Ես գտա լավագույն եւ պարզ լուծումը

Գործառույթի կլոր (վերադարձի համարը (Match.Round (արժեք + e "+ տասնորդական) +" E - "+ տասնորդականներ);) փուլ (1.005, 2); // 1.01

Ընդունված պատասխանի փոքր տատանում: Tofixed (2) վերադարձնում է լարը, եւ դուք միշտ կստանաք երկու տասնորդական նշան: Դա կարող է լինել զրո: Եթե \u200b\u200bցանկանում եք ճնշել վերջնական զրոյական (ներ) ը, պարզապես դա արեք.

Var Զեղչ \u003d + ((Գինը / երթ.) .Առաջացված (2));

Խմբագրվել եմ. Ես պարզապես գտա, որ դա սխալ է թվում Firefox 35.0.1-ում, ինչը նշանակում է, որ վերը նշվածը կարող է նանին տալ որոշ արժեքներ:
Ես փոխեցի իմ ծածկագիրը

Var Զեղչ \u003d Math.Round (Գինը / երթ. * 100) / 100;

Սա տալիս է մի շարք երկու տասնորդական տեղերի ճշգրտությամբ: Եթե \u200b\u200bՁեզ անհրաժեշտ է երեք, բազմապատկեք եւ բաժանեք 1000-ը եւ այլն:
OP- ն ցանկանում է, որ միշտ երկու տասնորդական արտանետում միշտ, բայց եթե Tofixed () կոտրված է Firefox- ում, նախ պետք է շտկել այն:
Տես HTTPS://bugzilla.mozilla.org/show_bug.cgi?id\u003d1134388:

Երկու տասնորդական նշաններով արդյունքի արդյունքում կարող եք անել հետեւյալը.

Var Զեղչ \u003d Math.Round ((100 - (Գինը / ցուցակագրող) * 100) * 100) / 100;

Առաջին երկու թվանշանները պահպանելու համար բազմապատկվում է 100-ով կլորացված արժեքը 100-ով: Այնուհետեւ մենք բաժանվում ենք 100-ի:

Կարծում եմ, որ իմ տեսած լավագույն ձեւը բազմապատկվում է թվերի համար 10 թվով, այնուհետեւ Math.Round- ը դարձրեք, այնուհետեւ վերջապես բաժանեք թվով 10-ը: Ահա մի պարզ գործառույթ, որը ես օգտագործում եմ գրամեքենաների տեքստերում.

Գործառույթի կլորսդիգիտներ (արժեք, համարը, թվանշանները, համարը) (արժեքը \u003d արժեք * մաթեմատիկա (10, թվանշան); վերադարձի արժեքը. )

Կամ պարզ JavaScript:

Գործառույթի կլորսդիգիտ (արժեք, թվանշան) (եթե (! Թվանշան) (թվանշան \u003d 2;) արժեք \u003d արժեք * մաթեմատիկա (արժեքը); , թվանշաններ); վերադարձի արժեքը;)

ՆՇՈՒՄ. - Տես 3-նիշ ճշգրտությունը:

Var Զեղչ \u003d (գինը / երթ.) .Առաջացված (2);

tofixed- ը կլորացվում է կամ իջնում \u200b\u200bէ ձեզ համար `կախված 2 տասնորդական նշաններից ավելի քան 1-ից:

Փոփոխություն: Ինչպես նշեց ուրիշների կողմից, այն բերում է տողի արդյունքը: Խուսափելու համար.

Var Զեղչ \u003d + ((Գինը / երթ.) .Առաջացված (2));

Խմբագրում 2. - Ինչպես նշվեց մեկնաբանություններում, այս գործառույթը չի կատարվում որոշակի ճշգրտությամբ, օրինակ, 1.005-ի դեպքում այն \u200b\u200b1.00-ի փոխարեն կվերադառնա 1.00: Եթե \u200b\u200bճշգրտությունը կարեւոր է նման չափով, ես գտա այս պատասխանը, https: //.com/a/32605063/1726511 Ինչը կարծես լավ աշխատի բոլոր փորձությունների հետ:

Մեկ փոքր փոփոխություն է պահանջում, բայց վերոհիշյալ պատասխանը վերադառնում է ամբողջ թվերը, երբ այն կլորացվում է մեկ, հետեւաբար, 99.004-ը 99.00-ի փոխարեն կվերադառնա 99.00-ի փոխարեն 99.004-ը:

Խմբագրել 3-ը: - Թվում է, թե տոֆիքսը դեռ որոշ թվերի իրական վերադարձի վերաբերյալ, վերջնական խմբագրումը, կարծես, աշխատում է: Geez այնքան շատ հատուցումներ:

Var զեղչ \u003d կլոր ((Գինը / երթ.), 2); Գործառույթի կլոր (n, թվանշան) (եթե (թվանշան \u003d\u003d\u003d չճշտված) (թվանշան \u003d 0; var test \u003d (Math.Round (n) / բազմապատկիչ); վերադարձիր + (test.tofixed (թվանշան));)

Խմբագրել 4: «Դուք տղաներ եք սպանում ինձ»: Խմբագրել 3-ը ձախողվում է բացասական թվերի վրա, առանց փորելու, թե ինչու ավելի հեշտ է պարզապես բացասական թվով դրական դարձնել նախքան կլորացումը կատարելուց առաջ, այնուհետեւ վերադարձնելուց առաջ այն վերադարձնել:

Գործառույթի կլորոց (n, թվանշան) (var բացասական \u003d կեղծ; եթե (թվանշան \u003d\u003d\u003d չճշտված) (թվանշան \u003d 0;), եթե (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; }

Ամենաարագ ճանապարհը - ավելի արագ, քան tofixed ().

Երկու դեկալիլ

x \u003d .123456 արդյունք \u003d Math.Round (x * 100) / 100 // Արդյունք .12

Երեք տասնորդություն

x \u003d .123456 արդյունք \u003d Math.Round (x * 1000) / 1000 // Արդյունք .123

Գործառույթի կլոր (Num, Dec) (Num \u003d Math.Round (Num \u003d Math.Round (Num + E "+ դեկտեմբեր

Բարեւ. Այսօր, JavaScript սյունակում, մենք կանդրադառնանք, թե ինչպես կարելի է JavaScript- ին սահմանել լողացող կետի համարների սեզոնապատման քանակը: Օրինակ, ցուցադրման ժամանակ անհրաժեշտ է թողնել 3 տասնորդական նշան, կամ միայն երկուսը:

Առաջադրանք. JavaScript- ի կիսամյակային քանակը

Այսպիսով, մենք բախվում ենք առաջադրանքի հետ. Կա հաշվարկների արդյունք, որում կան կիսամյակների առաջ թվեր, իսկ ստորակետից հետո: Տասնորդական: Ենթադրենք, արդյունքը պարզվեց 1538.9891200153: Բայց երբ արդյունքը պետք է լինի այն թիվը, որն արտացոլում է այն գումարը, որտեղ թղթադրամների քանակը կախված է ստորակետից, իսկ հետո `Kopecks:

Այս առաջադրանքը լուծելու մի քանի եղանակներ կան:

Լուծում 1. JavaScript- ի կիսամյակների քանակը `տոֆիքսված մեթոդով

tofixed- ը javaScript- ի մեթոդով ներկառուցված է, որը կիրառվում է ցանկացած համարի վրա, ճշգրտությունը ճշգրտության կլորացում է պահանջում (այսինքն `ծովային նիշերի քանակը):

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;

Այս գործառույթի ճշգրտության պարամետրը պետք է լինի առնվազն 0 (բացասական արժեքներ չի վերցնում), եւ ոչ ավելի, քան 20:

Կարող եք նաեւ անել առանց փոփոխականի, օրինակ, այսպես.

Num_str \u003d (1538.9891200153) .Տրոֆիլ (2); //Num_str\u003d1538.98;

Լուծում 2. JavaScript- ի կիսամյակների քանակը `տրեկեսիայի մեթոդով

Այս լուծումը հիմնված է նույն ներկառուցված JavaScript մեթոդի վրա: Այս մեթոդի առանձնահատկությունն այն է, որ մուտքագրմանը տեղափոխված պարամետրը ցույց է տալիս ճշգրտությունը (կիսահոլների քանակը), բայց նիշերի ընդհանուր քանակը (եւ դրանից հետո):

Var num \u003d 1538.9891200153; num_str \u003d num.toPrecion (5); //Num_str\u003d1538.9; num_str \u003d num.toprecion (7); //Num_str\u003d1538.989;

Լուծում առանց ստորակետից հետո ստորակետից հետո. JavaScript Semicolons

Եթե \u200b\u200bտասնորդական նշանները պետք է ամբողջությամբ ծալվեն, այսինքն, անհրաժեշտ է կլորացնել կոտորակային համարը ամբողջը, ապա կարող եք օգտագործել մաթեմատիկայի գործառույթները, կլոր, կեիլ եւ հատակ:
Կլոր - փուկեր մեծ կամ փոքր կողմում (կախված թվից): Եթե \u200b\u200bկիսագնդերից հետո արժեքը կեսից ավելին է, ապա կլոր է դեպի ամբողջ կողմը, եթե ավելի քիչ է փոքր: Այսինքն, եթե 0,51-ը կլինի 1, եթե 0,49 - 0:

CEIL - անգլերենից: Առաստաղը միշտ կլորացվում է ամենամեծ կողմում:

Հարկ - անգլերենից: Պողոս փուլերը միշտ ավելի փոքր կողմում են:

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 մաթեմատիկա .CEL (Num); // num_str \u003d 1539;

Այս ամենը: Հուսով եմ, որ այս գրությունը կօգնի ձեզ լուծել առաջադրանքը: Եթե \u200b\u200bինչ-որ բան ձախողվեց. Հարցեր տվեք, օգտագործելով կանաչ կոճակը, «Հարց տվեք մասնագետի կողմից» կամ մեկնաբանություններում:

Հաճախ հաշվարկները արդյունք են տալիս, որոնք չեն համապատասխանում ցանկալի տիրույթների սահմաններին: Արդյունքում, դուք պետք է իրականացնեք JavaScript- ի կլորացում մինչեւ որոշակի արժեք:

Ինչու կլոր համարներ:

JavaScript- ը չի պահում ամբողջ թվերը, քանի որ դրանց արժեքները ներկայացված են լողացող կետի համարների տեսքով: Բազմաթիվ ֆրակցիաները չեն կարող ներկայացվել որոշակի վերջավոր քանակությամբ կիսահաղորդիչներով մի շարք, ուստի JavaScript- ը կարող է արդյունքներ առաջացնել, ինչպես հետեւյալը.

0.1 * 0.2; > 0.020000000000000004

Գործնականում դա որեւէ նշանակություն չի ունենա, քանի որ 2 Quinylonne- ում սխալ է ընթանում: Բայց դա կարող է ազդել այն արդյունքների վրա, երբ աշխատում է այն թվերի հետ, որոնք ներկայացնում են փական արժեքներ, տոկոս կամ ֆայլի չափ: Հետեւաբար, դուք պետք է անեք կամ մինչեւ որոշակի տասնորդական նշան:

Կլորացնել տասնորդական թվերը

Օգտագործվում են «զարդարելու» տասնորդական համարը, տոֆիքս () կամ TOPRECISION () մեթոդներ: Նրանք երկուսն էլ վերցնում են մեկ փաստարկ, որը որոշում է ստորակետից հետո նշանակալի եւ նշանների քանակը, որը պետք է ներառվի արդյունքի մեջ.

• Եթե \u200b\u200bTofixed- ի համար () փաստարկը սահմանված չէ, լռելյայն արժեքը 0 է, այսինքն `ստորակետից հետո նշաններ չկան: Փաստարկի առավելագույն արժեքը 20 է.
• Եթե \u200b\u200bToPrecible () փաստարկը չի նշվում, թիվը չի փոխվում:

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.toPrecion (3); \u003e "87.3"

Նշում

Եւ tofixed (), եւ ToPrecision- ը վերադառնում է կլորացված ստորին ներկայացուցչություն եւ ոչ մի թիվ: Սա նշանակում է, որ Randnum- ի համար առաջարկություն ավելացնելը կհանգեցնի կոնկոնտինի տողի, եւ ոչ թե մեկ համարի.

console.Log (Randnum + կլորացված); \u003e "6.256"

Եթե \u200b\u200bձեզ հարկավոր է JavaScript- ը շրջել հարյուրերորդին, օգտագործեք մաղադանթ ().

var randnum \u003d 6.25; var կլորացված \u003d parsefloat (randnum.tofixed (1)); Վահանակ.լոգ (կլորացված); \u003e 6.3.

tofixed () եւ TOPRECISION () նույնպես մեծ քանակությամբ կիսահոլներներ կրճատելու օգտակար մեթոդներ են: Դա հարմար է դրամական միավորներ ներկայացնող թվերի հետ աշխատելիս.

var մեծացրեք \u003d 1 var Dooncents \u003d wholzium.tofixed (2); Վահանակ.լոգ (դոլար); \u003e "1.00"

Խնդրում ենք նկատի ունենալ, որ եթե ճշգրտության պարամետրը ավելի շատ նշաններ կան, ապա TOPRECISION- ը արդյունք կտա գիտական \u200b\u200bձեւաչափով.

var num \u003d 123.435 num.toprecion (2); \u003e "1.2E + 2"

Ինչպես խուսափել սխալներից, տասնորդական ֆրակցիաները կլորացնելիս

Որոշ դեպքերում իրականացվում են տոֆիքս եւ տրոկիա JavaScript- ը կլորացվում է 5-ից ավելի կողմ, ոչ ավելին.

var NumTest \u003d 1.005; numtest.tofixed (2); \u003e 1;

Վերոնշյալ օրինակի արդյունքը պետք է լինի 1.01, եւ ոչ թե 1. Եթե ցանկանում եք խուսափել այս սխալից, խորհուրդ եմ տալիս օգտագործել էքսպոնենտիվ համարներ.

Գործառույթի կլոր (վերադարձի համարը (Math.Round (արժեք + E "+ տասնորդականներ) +" E - "+ տասնորդականներ);)

Դիմում.

Տուր (1.005.2); \u003e 1.01

Եթե \u200b\u200bձեզ հարկավոր է ավելի հուսալի լուծում, քան կլորացնելը, այն հասանելի է MDN:.

Կլորացում Epsilon- ի հետ

Այլընտրանքային մեթոդ JavaScript- ը կլորացվում է մինչեւ տասներորդ ներդրվել է ES6- ում ( Հայտնի է նաեւ որպես JavaScript 2015). « Machine Epsilon»Ապահովում է սխալ սխալի սահմանափակում, երկու լողացող կիսագնդի համեմատությամբ: Առանց կլորացման, համեմատությունները կարող են արդյունք տալ հետեւյալ կերպ.

0,1 + 0.2 \u003d\u003d\u003d 0.3\u003e Կեղծ

Math.epsilon- ը կարող է օգտագործվել գործառույթում `ճիշտ համեմատություն ստանալու համար.

Ֆունկցիա Հետագա (x, y) (վերադարձի մաթեմատիկա (X - Y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

Գործառույթը երկու փաստարկ է պահանջումՄեկը պարունակում է հաշվարկներ, երկրորդ սպասվող (կլորացված) արդյունքը: Այն վերադարձնում է այս երկու պարամետրերի համեմատությունը.

Հետilt շգկային (0,1 + 0.2, 0.3)\u003e True շմարիտ

Բոլոր ժամանակակից զննարկիչները աջակցում են ES6 մաթեմատիկական գործառույթներին: Բայց եթե ձեզ հարկավոր է աջակցություն ցուցաբերել հին զննարկիչներում, ապա հարկավոր է օգտագործել պոլիլիա:

Տասնորդների թվերի կրճատում

Ավելի վաղ ներկայացված բոլոր մեթոդները JavaScript- ը կլորացվում է մինչեւ տասներորդ, Կոնգրեսից հետո մինչեւ երկու տեղ դրական թվով կտրեք, այն բազմապատկեք 100-ի համար, այնուհետեւ ձեռք բերված արդյունքը բաժանվում է 100-ով, ձեզ հարկավոր է.

Գործառույթը կրճատվել է (Num) (վերադարձնել Math.trunc (համարը * 100) / 100;) կրճատված (3.1416)\u003e 3.14

Եթե \u200b\u200bինչ-որ ճկուն բան է պահանջվում, կարող եք օգտագործել կոտրված օպերատորը.

Գործառույթը կրճատված է (var numpowerconverter \u003d Math.Pow (10, տասնորդական տեղադրում); վերադարձը ~~ (num * numpowerconverter) / numpowerconverter;)

Օգտագործելով.

var randint \u003d 35.874993; Կրճատված (ռանդինտ, 3); \u003e 35.874:

Կլորացնել մոտակա համարին

Իրականացնել JavaScript- ը կլորացվում է ամբողջին, Math.Round () օգտագործվում է.

Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5

Նշեք, որ « Կես արժեքներ«Այնպիսին, ինչպիսին է .5, կլորացված:

Կլորացնելով մոտակա ամբողջ թվին

Եթե \u200b\u200bցանկանում եք ավելի փոքր կողմում շրջել, օգտագործեք մաթեմատիկա:

Math.Floor (42.23); \u003e 42 Math.Floor (36.93); \u003e 36:

«Down» կլորացումը բոլոր համարների համար ունի մեկ ուղղություն, ներառյալ բացասական: Սա կարող է ներկայացվել որպես երկնաքեր `անսահման թվով հատակներ, ներառյալ հիմնադրման մակարդակից ցածր ( Բացասական թվեր ներկայացնող): Եթե \u200b\u200bնկուղային հատակների միջեւ 2-րդ եւ 3-ը գտնվում եք վերելակի մեջ ( Ինչը համապատասխանում է արժեքին -2.5), Math.Floor- ը ձեզ կհանձնի հատակին -3:

Math.Floor (-2.5); \u003e -3:

Եթե \u200b\u200bցանկանում եք խուսափել դրանից, օգտագործել JavaScript Math Roating- ը `օգտագործելով Math.Trunc () աջակցվող բոլոր ժամանակակից զննարկիչներում (բացառությամբ Այսինքն / եզրը):

Math.Trunc (-41.43); \u003e -41

MDN- ն նաեւ տրամադրում է Երեք տողի պոլիա `մաթեմատիկա.trunc- ի աջակցությունը հին զննարկիչներում եւ այսինքն / եզրին.

Կլորացնելով մոտակա ամբողջ թիվը

Եթե \u200b\u200bցանկանում եք քանդել տասնորդական թվերը, օգտագործեք մաթեմատիկա: Այս մեթոդի գործողությունը կարող է ներկայացվել նաեւ որպես անվերջ վերելակ. Math.CEL- ը միշտ հաջողակ «վեր է», անկախ նրանից, թե համարը բացասական է կամ դրական է.

Մաթեմատիկա.Կարս (42.23); \u003e 43 մաթեմատիկա (36.93); \u003e 37 մաթեմատիկա (-36.93); -36

Կլորացնել մոտակա բազմակի համարին

Եթե \u200b\u200bՁեզ անհրաժեշտ է արժեքը կլորացնել մոտակա համարին, բազմակի 5-ը, ստեղծեք գործառույթ, որը բաժանում է թիվը 5-ի, այնուհետեւ նույն արժեքի մեջ է:

Գործառույթի կլոր 5 (համարը) (վերադարձի մաթեմատիկա (համարը / 5) * 5;)

Օգտագործելով.

Շուրջօրյա (11); \u003e 10.

Եթե \u200b\u200bցանկանում եք կատարել JavaScript- ի շուրջ երկու նիշ, ապա կարող եք գործառույթները փոխանցել որպես նախնական համար եւ բազմապատկություն.

Գործառույթի կլորթոմուլղետ (Num, բազմակի) (վերադարձի մաթեմատիկա (համարը / բազմակի) * բազմակի;)

Գործառույթը օգտագործելու համար միացրեք կլորացված համարը եւ բազմապատկումը իր զանգում.

var նախաձեռնություն \u003d 11; var բազմակի \u003d 10; Կլորթոմուլլի (նախաձեռնություն, բազմակի); \u003e 10;

Արժեքները կլրացնելու միայն մեծ կամ փոքր ուղղությամբ, կլոր գործառույթը փոխարինեք առաստաղի կամ հատակին:

Պարտադիր է միջակայքի

Երբեմն պետք է ստանաք x արժեքը, որը պետք է լինի որոշակի տիրույթում: Օրինակ, ձեզ հարկավոր է 1-ից 100 արժեք, բայց մենք ստանում ենք 123 արժեքը: Այն շտկելու համար կարող եք օգտագործել min () ( Վերադարձնում է թվերի ամենափոքրը) եւ առավելագույնը ( Վերադարձնում է առավելագույն թույլատրելի համարը).

Օգտագործելով.

var lowbound \u003d 1; var բարձրացնել \u003d 100; var Numinput \u003d 123; var clamped \u003d math.max (ցածր մակարդակ, մաթեմատիկա ..in (Numinpt, բարձրակարգ)); Console.Log (սեղմված); \u003e 100;

Կարող եք ստեղծել գործառույթի կամ երկարացման դասի համարը:

JavaScript- ում շատ հաճախ հաշվարկները այնքան էլ չեն տալիս մեր ուզած արդյունքները: Իհարկե, մենք կարող ենք անել որեւէ բանի հետ `մեծ կամ փոքր կողմում կլորացնելը, սահմանեք միջակայքերը, կտրեք անտեղի թվերը որոշակի թվով տասնորդական տեղերում:

Ինչու եք անհրաժեշտ կլորացման:

JavaScript- ի հետաքրքրաշարժ կողմերից մեկը այն է, որ այն իրականում չի պահում ամբողջ թվերը, մենք անմիջապես աշխատում ենք լողացող կետի համարներով: Սա, այն բանի հետ, որ շատ կոտորակային արժեքներ չեն կարող արտահայտվել տասնորդական նշանների վերջնական թվով, մենք կարող ենք նման արդյունքներ ստանալ JavaScript- ում.

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Գործնական նպատակներով այս անճշտությունը նշանակություն չունի, մեր դեպքում մենք խոսում ենք Quintillion Dolls- ի սխալի մասին, սակայն ինչ-որ մեկը կարող է հիասթափեցնել: Մենք կարող ենք մի փոքր տարօրինակ արդյունքներ ձեռք բերել եւ փականի արժեքներ ունենալիս աշխատելիս, տոկոսային արժեքներ կամ ֆայլերի չափսեր: Այս անճշտությունները շտկելու համար մենք պարզապես պետք է կարողանանք շրջանցել արդյունքների շուրջը, մինչդեռ դա բավարար է տասնորդական ճշգրտություն հաստատելու համար:

Համարների կլորացումը գործում է գործնական կիրառություն, մենք կարող ենք որոշակի միջակայքով շահարկել թիվը, օրինակ, մենք ուզում ենք արժեքը կլորացնել մոտակա ամբողջ թվին եւ ոչ թե աշխատել միայն տասնորդական մասի հետ:

Կլորացնել տասնորդական թվերը

Թվական թիվը կտրելու համար օգտագործեք Tofixed կամ ToPrecible մեթոդը: Երկուսն էլ վերցված են մեկ փաստարկով, որը որոշում է համապատասխանաբար, քանի իմաստալից համարներ (այսինքն, համարի ընդհանուր քանակը) կամ կիսամյակային կետից հետո օգտագործված համարների ընդհանուր քանակը (տասնորդական կետից հետո քանակը) պետք է ներառի արդյունքը.

1. Եթե \u200b\u200bփաստարկը սահմանված չէ Tofixed- ի համար (), ապա `լռելյայն, այն կլինի զրոյական, ինչը ստորակետից հետո նշանակում է 0 նշան, փաստարկն առավելագույն արժեք ունի 20-ի:
2. Եթե \u200b\u200bփաստարկը նշվում է տրոհման համար, թիվը մնում է անպաշտպան

Թող Randnum \u003d 6.25; randnum.tofixed (); \u003e "6" math.pi.toprecision (1); \u003e "3" Randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" Randnum \u003d 87.337; Randnum.toPrecion (3); \u003e "87.3"
Ինչպես tofixed () եւ toPrecision () մեթոդները վերադարձնում են արդյունքի լարային ներկայացում, ոչ թե: Սա նշանակում է, որ կլորացված արժեքը Randnum- ի հետ ամփոփելիս կկայացվի շարքեր, եւ ոչ թե թվերի քանակը.

Թող Randnum \u003d 6.25; Թող կլորացված \u003d randnum.tofixed (); // "6" Console.Log (Randnum + կլորացված); \u003e "6.256"
Եթե \u200b\u200bցանկանում եք արդյունքը ունենալ թվային տվյալների տեսակը, ապա ձեզ հարկավոր է կիրառել պարսլած.

Թող Randnum \u003d 6.25; Թող կլորացված \u003d պարիսպ (randnum.tofixed (1)); Վահանակ.լոգ (կլորացված); \u003e 6.3.
Խնդրում ենք նկատի ունենալ, որ 5 արժեքներ կլորացվում են, բացառությամբ հազվագյուտ դեպքերի:

Tofixed () եւ TOPRECISION () մեթոդները օգտակար են, քանի որ նրանք կարող են ոչ միայն կտրել կոտորակային մասը, այլեւ լրացնել ստորակետից հետո նշանները, ինչը հարմար է արժույթով աշխատելիս.

Թող մեծացրեք \u003d 1-ը թող դոլարներ \u003d wholzized.tofixed (2); Վահանակ.լոգ (դոլար); \u003e "1.00"
Վիճակը նշում է, որ ToPrec- ը արդյունքը կտա էքսպոնենտալ ռեկորդում, եթե ամբողջական թվերի քանակը ավելի մեծ է, քան ճշգրտությունը.

Թող Num \u003d 123.435 num.toprecion (2); \u003e "1.2E + 2"

Ինչպես խուսափել տասնորդական թվերով կլորացման սխալներից

Որոշ դեպքերում, տոֆիքսը եւ TOPRECISION- ը 5-ի արժեքը կազմում են ավելի փոքր կողմում, իսկ մեծ քանակությամբ.

Թող Numpest \u003d 1.005; numtest.tofixed (2); \u003e "1.00"
Վերոնշյալ հաշվարկի արդյունքը պետք է լինի 1.01, եւ ոչ թե 1. Եթե ցանկանում եք խուսափել նմանատիպ սխալից, մենք կարող ենք օգտագործել Jack L Moore- ի առաջարկած լուծումը, որն օգտագործում է էքսպոնենտալ համարներ.

Գործառույթի կլոր (վերադարձի համարը (Math.Round (արժեք + E "+ տասնորդականներ) +" E - "+ տասնորդականներ);)
Հիմա:

Տուր (1.005.2); \u003e 1.01
Եթե \u200b\u200bցանկանում եք ավելի հուսալի լուծում, քան վերեւում ցուցադրված լուծումը, կարող եք գնալ MDN:

Machine Epsilon կլորացում

Տվյալների համարների կլորացման այլընտրանքային մեթոդը ներմուծվեց ES6- ում: Machine Epsilon կլորացումը ապահովում է սխալ սխալի սահման, երբ համեմատվում է երկու լողացող կետի համար: Առանց կլորացման, համեմատությունները կարող են արդյունք տալ հետեւյալ կերպ.

0,1 + 0.2 \u003d\u003d\u003d 0.3\u003e Կեղծ
Մեր գործառույթում մենք օգտագործում ենք Math.epsilon- ը `ճիշտ համեմատություն ստանալու համար.

Ֆունկցիա Հետագա (x, y) (վերադարձի մաթեմատիկա (X - Y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Գործառույթը երկու փաստարկ է պահանջում. Առաջին ընթացիկ հաշվարկը, երկրորդը `սպասվող արդյունքն է: Այն վերադարձնում է երկուսի համեմատությունը.

Հետilt շգկային (0,1 + 0.2, 0.3)\u003e True շմարիտ
Բոլոր ժամանակակից զննարկիչներն արդեն իսկ աջակցում են ES6 մաթեմատիկական գործառույթներին, բայց եթե ցանկանում եք աջակցություն ստանալ բրաուզերում, ինչպիսիք են 11-ը, օգտագործեք պոլիաներ:

Կոտորային մասի կտրում

Վերը ներկայացված բոլոր մեթոդները կարող են շրջանցել մինչեւ տասնորդական համարներ: Որպեսզի ստորակետից հետո ընդամենը երկու ցուցանակ կտրենք, նախ պետք է այն բազմապատկեք 100-ով, ապա ձեռք բերված արդյունքն արդեն բաժանված է 100-ով:

Գործառույթը կրճատվել է (Num) (վերադարձնել Math.trunc (համարը * 100) / 100;) կրճատված (3.1416)\u003e 3.14
Եթե \u200b\u200bցանկանում եք հարմարեցնել մեթոդը ցանկացած քանակի կիսագնդի համար, կարող եք օգտագործել կրկնակի BITTY DENIA:

Գործառույթը կրճատվել է (թող Numpowerconverter \u003d Math.Pow (10, տասնորդական տեղադրում); վերադարձը ~~ (numpowerconverter) / numpowerconverter;)
Հիմա:

Թող Randint \u003d 35.874993; Կրճատված (ռանդինտ, 3); \u003e 35.874:

Կլորացնել մոտակա համարին

Որպեսզի տասնորդական թիվը ավելի շատ կամ ավելի փոքր կողմում կլորացվի ավելի փոքր կողմում, կախված նրանից, թե ինչից ենք ամենամոտ, օգտագործեք Math.Round ().

Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5
Խնդրում ենք նկատի ունենալ, որ «արժեքի կեսը», 0,5-ը կլորացվում է մեծ ուղղությամբ `համաձայն մաթեմատիկայի կանոնների:

Կլորացնելով ավելի փոքր, մոտակա ամբողջ թվին

Եթե \u200b\u200bցանկանում եք միշտ փակել ավելի փոքր կողմում, օգտագործեք մաթեմատիկա:

Math.Floor (42.23); \u003e 42 Math.Floor (36.93); \u003e 36:
Խնդրում ենք նկատի ունենալ, որ փոքր կողմում կլորացումը աշխատում է բոլոր համարների համար, ներառյալ բացասական: Պատկերացրեք երկնաքեր, անսահման թվով հատակներ, ներառյալ ցածր մակարդակի հատակները (բացասական թվեր ներկայացնող): Եթե \u200b\u200b2-ից 3-ի սահմաններում գտնվող վերելակի մեջ եք (որը արժեք է -2.5), մաթեմատիկա: Floor- ը ձեզ կհանձնի -3:

Math.Floor (-2.5); \u003e -3:
Բայց եթե ցանկանում եք խուսափել նման իրավիճակից, օգտագործեք Math.Trunc, բոլոր ժամանակակից զննարկիչներում աջակցված (բացառությամբ IE / EDGE).

Math.Trunc (-41.43); \u003e -41
Դուք կգտնեք Polyfilish- ը MDN- ի վրա `մաթեմատիկական.

Կլորացնել ավելի շատ մոտակա ամբողջ թիվ

Մյուս կողմից, եթե միշտ անհրաժեշտ է հավաքել ամենամեծը, օգտագործել մաթեմատիկան: Կրկին, հիշեք անվերջ վերելակը. Մաթեմատիկա .Կարքը միշտ կբարձրանա, անկախ նրանից, թե համարը բացասական է, թե ոչ:

Մաթեմատիկա.Կարս (42.23); \u003e 43 մաթեմատիկա (36.93); \u003e 37 մաթեմատիկա (-36.93); \u003e -36

Կլորացնել ավելի մեծ / փոքր թվին

Եթե \u200b\u200bմենք ուզում ենք համակերպվել մոտակա համարին, բազմակի 5-ը, գործառույթ ստեղծելու ամենահեշտ ձեւը, որը կազմում է թիվը 5-րդ տուրում, այնուհետեւ այն բազմապատկում է.

Գործառույթի կլոր 5 (համարը) (վերադարձի մաթեմատիկա (համարը / 5) * 5;)
Հիմա:

Շուրջօրյա (11); \u003e 10.
Եթե \u200b\u200bցանկանում եք ավելի շատ հավաքել ձեր արժեքը, մենք օգտագործում ենք ավելի ընդհանուր գործառույթ, անցնելով նախնական արժեքը եւ դրա բազմակի:

Գործառույթի կլորթոմուլղետ (Num, բազմակի) (վերադարձի մաթեմատիկա (համարը / բազմակի) * բազմակի;)
Հիմա:

Թող նախաձեռնությունը \u003d 11; Թող բազմակի \u003d 10; Կլորթոմուլլի (նախաձեռնություն, բազմակի); \u003e 10;

Սահմանի քանակը ամրացնելով

Շատ դեպքեր կան, երբ մենք ցանկանում ենք ստանալ x- ի արժեքը սահմանի սահմաններում: Օրինակ, մեզ կարող է անհրաժեշտ լինել 1-ից 100 արժեք, բայց միեւնույն ժամանակ մենք ստացանք 123 արժեք: Այն շտկելու համար մենք կարող ենք օգտագործել նվազագույնը (վերադարձնում է թվերի քանակը) եւ առավելագույնը ( Վերադարձնում է ցանկացած բազմակի համարներից ամենամեծը): Մեր օրինակում տատանվում է 1-ից 100-ը.

Թող ցածրացրեք \u003d 1; Թող բարձրացրեք \u003d 100; Թող Numinput \u003d 123; Թող սեղմեք \u003d մաթեմատիկա. Մաթեմա (ցածր մակարդակ, մաթեմատիկա: Console.Log (սեղմված); \u003e 100;
Կրկին, մենք կարող ենք նորից օգտագործել գործողությունը եւ ամբողջը փաթեթավորել գործառույթի մեջ, մենք օգտագործում ենք Դանիել X- ի առաջարկած լուծումը.

Number.prototype.clamp \u003d գործառույթ (Min, Max) (Վերադարձի մաթեմատիկա (Math.max (սա, min);););
Հիմա:

Numinput.Clamp (ցածր մակարդակի բարձրացում); \u003e 100;

Գաուսյան կլորացում

Գաուսյան կլորացումը, որը նաեւ հայտնի է որպես բանկի կլորացում, այն է, որ այս գործի կլորացումը տեղի է ունենում մոտակա սեւերին: Այս կլորացման մեթոդը աշխատում է առանց վիճակագրական սխալի: Լավագույն լուծումը առաջարկվել է ԹԻՄ-Ն.

Գործառույթի gaussround (թող D \u003d Decimalplaces || 0, մ \u003d մաթեմատիկա: \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; }
Հիմա:

Gaussround (2.5)\u003e 2 Gaussround (3.5)\u003e 4 Gaussround (2.57,1)\u003e 2.6
Dubim նշան CSS- ում.

Քանի որ JavaScript- ը հաճախ օգտագործվում է HTML տարրերի դիրքային փոխարկումը ստեղծելու համար, կարող եք զարմանալ, թե ինչ է պատահում, եթե մենք մեր տարրերի համար տասնորդական արժեքներ ստեղծենք.

#Box (Լայնություն, 63.667731993PX;)
Լավ նորությունն այն է, որ ժամանակակից զննարկիչները հաշվի կառնեն «Թվական արժեքները» բլոկային մոդելի մեջ, ներառյալ չափման տոկոսային կամ պենսիլային միավորներով:

Տեսակավորում

Շատ հաճախ, մենք պետք է դասակարգենք որեւէ տարրեր, օրինակ, խաղային գրառումների մի շարք ունենք, մինչդեռ դրանք պետք է կազմակերպվեն որպես խաղացողների իջնող կարգ: Դժբախտաբար, ստանդարտ տեսակավորման () մեթոդը զարմանալի սահմանափակումներ ունի. Այն լավ է աշխատում հաճախ օգտագործվող անգլերեն բառերով, բայց անմիջապես բախվում է թվերի, եզակի կերպարների կամ բառերի հետ:

Տեսակավորել այբբենական կարգով

Թվում է, թե զանգվածային տեսակավորումը այբբենական կարգով պետք է լինի ամենապարզ առաջադրանքը.

Թող պտուղը \u003d [«Butternut Squash», «Ծիրան», «Cantaloupe»]; Fruit.Sort (); \u003e «Ծիրան», «Butternut Squash», «Cantaloupe»]
Այնուամենայնիվ, մենք դիմակայում ենք խնդրի հետ, հենց որ տարրերից մեկը վերին դեպքում է.

Թող մրգերը \u003d [«butternut squash», «aprot», «Cantalope»]; Fruit.Sort (); \u003e "Cantaloupe", "Aprot", "Butternut Squash"]]
Դա պայմանավորված է նրանով, որ դեֆոլտը համեմատում է Unicode- ում ներկայացված առաջին խորհրդանիշը: Unicode- ը եզակի կոդ է ցանկացած խորհրդանիշի համար, անկախ հարթակից, անկախ ծրագրից, անկախ լեզվից: Օրինակ, եթե նայեք կոդի սեղանին, «Ա» կերպարը U + 0061 է (Hexadecimal համակարգում 0x61), մինչդեռ «C» խորհրդանիշն ունի Code U + 0043 (0x43), որն անցնում է Unicode աղյուսակում «Ա» խորհրդանիշը:

Մի զանգված տեսակավորելու համար, որը կարող է պարունակել առաջին տառերի խառը գրանցամատյաններ, մենք պետք է կամ բոլոր իրերը վերափոխենք ստորին գրանցամատյանում, կամ որոշենք որոշ փաստարկներով օգտագործելով ձեր տեսակավորման կարգը: Որպես կանոն, նման դեպքի համար ավելի լավ է անհապաղ ստեղծել գործառույթ, կրկնակի օգտագործման համար.

Ֆունկցիայի այբուբորտ (arr) (վերադարձը A.LocaleCompare (B, EN ", (« Սենսիտիվություն ».« Հիմք »));). AlphaSort (մրգեր)\u003e
Եթե \u200b\u200bցանկանում եք զանգված հավաքել, որը դասավորվում է հակադարձ այբբենական կարգով, պարզապես գործառույթների համար փոխեք դիրքերը A եւ B դիրքերը.

Ֆունկցիայի այբուբորտ (arr) (վերադարձը B.LocaleCompare (A, EN ", (« զգայունություն ». AlphaSort (մրգեր)\u003e [«Cantaloupe», «Butternut Squash», «Ծիրան»]
Արժե ուշադրություն դարձնել այդ տեղական առեւտրի գերեզմանատներին, որոնք օգտագործվում են փաստարկներով, դեռ անհրաժեշտ է հիշել, որ այն աջակցվում է IE11 + - ին, ավելի հին տարբերակների համար, մենք կարող ենք օգտագործել այն առանց փաստարկների, եւ ստորին ռեգիստրում մենք կարող ենք օգտագործել:

Գործառույթի դեպքեր (arr) (վերադարձնել A.ToLowercase- ը (): LocaleCompare (B.Tolowerce ());)); Թող մրգեր \u003d [«Butternut Squeash»; Հորտ\u003e [Ծիրան, «Butternut Squash», «Cantaloupe»]

Թվային տեսակավորում

Այս ամենը չի տարածվում այն \u200b\u200bօրինակին, որի մասին մենք խոսեցինք խաղի գրառումների վերը նշված զանգվածի մասին: Որոշ թվային զանգվածներով, տեսակավորումը շատ կատարյալ է, բայց ինչ-որ պահի արդյունքը կարող է անկանխատեսելի լինել.

Թող բարձրորակություն \u003d; բարձրորակ (); Միջոց
Փաստն այն է, որ տեսակավորումը () մեթոդը արտադրում է բառագրական համեմատություն. Եվ սա նշանակում է, որ թվերը կվերափոխվեն լարային եւ համեմատություններ կանցկացվեն այս տողի առաջին բնույթը `Unicode աղյուսակի խորհրդանիշներով: Հետեւաբար, մենք պետք է որոշենք ձեր տեսակ կարգը.

Թող բարձրորակություն \u003d; Highscores.sort (վերադարձը A - B;)); Միջոց
Կրկին, հակառակ կարգով թվերը դասավորելու համար, գործառույթների համար փոխեք դիրքերը A եւ B դիրքերը:

Տեսակավորել JSON- ի նման կառուցվածքը

Վերջապես, եթե մենք ունենք JSON- ի նման տվյալների կառուցվածքը, ներկայացված է որպես խաղային գրառումների շարք.

Թող գնահատականներ \u003d [(«Անուն», «Դանիել», «Հաշվարկ», 21768), («Անուն». )];
ES6 + - ում կարող եք օգտագործել սլաքի գործառույթները.

Scores.Sort ((A, B) \u003d\u003e B.Score - A.Score));
Հին զննարկիչների համար, ովքեր նման աջակցություն չունեն.

Scores.Sort (Return A.Score - B.Score));
Ինչպես տեսնում եք, JavaScript- ում տեսակավորումը բավականին ակնհայտ բան է, հուսով եմ, որ այս օրինակները դա հեշտացնում են կյանքի համար:

Աշխատեք էլեկտրաէներգիայի գործառույթների հետ

Զորավարժությունը գործողություն է, որն ի սկզբանե սահմանվում է ինքնին բնական համարի բազմակի բազմացման արդյունքում, թիվ A քառակուսի արմատը քառակուսի է: Այս գործառույթներով մենք կարող էինք անընդհատ վայելել մաթեմատիկայի դասերի առօրյայում, ներառյալ տարածքներ, ծավալներ կամ նույնիսկ ֆիզիկական մոդելավորում հաշվարկելիս:

JavaScript- ում էլեկտրաէներգիայի գործառույթը ներկայացված է որպես Math.Pow (), նոր ES7 ստանդարտում, կոչվում է նոր վարժությունների օպերատոր `« * * »:

Erend աստիճանի

N-yy աստիճանի մի շարք կառուցելու համար օգտագործեք Math.Pow () գործառույթը, որտեղ առաջին փաստարկը այն թիվը է, որը կկառուցվի աստիճանի, երկրորդ փաստարկը աստիճանի ցուցանիշ է.

Math.pow (3.2)\u003e 9
Ձայնագրման այդպիսի ձեւը նշանակում է 3-ը քառակուսի կամ 3 × 3, ինչը հանգեցնում է արդյունքի 9-ի: Իհարկե, եւս մեկ օրինակ կարող է տրվել.

Math.pow (5.3); \u003e 125.
Այսինքն, Կուբայում 5-ը, կամ 5 × 5 × 5, հավասար է 125-ի:

ECMAMECT 7-ը JavaScript- ի հետեւյալ տարբերակն է, սկզբունքորեն, մենք կարող ենք օգտագործել նոր առաջարկվող վարժությունների օպերատորը աստիճանի - * *, ձայնագրման այսպիսի ձեւը կարող է ավելի տեսողական լինել.

3 ** 2 > 9
Այս պահին այս օպերատորի աջակցությունը բավականին սահմանափակ է, ուստի խորհուրդ չի տրվում օգտագործել այն:

Հզոր գործառույթը կարող է օգտակար լինել տարբեր իրավիճակներում: Պարզ օրինակ, մեկ ժամվա ընթացքում հաշվարկելով վայրկյանների քանակը. Math.pow (60.2):

Քառակուսի եւ խորանարդ արմատ

Math.Sqrt () եւ Math.CBRT () հակառակն են մաթեմատիկայի () գործառույթները: Ինչպես հիշում ենք, համարի քառակուսի արմատը մի շարք է, որը տալիս է հրապարակը:

Math.Sqrt (9)\u003e 3
Միեւնույն ժամանակ, համարի խորանարդ արմատը մի շարք է, որը տալիս է խորանարդը:

Math.cbrt (125)\u003e 5
Math.CBRT () Վերջերս JavaScript- ի ճշգրտման մեջ մտցվեց միայն ժամանակակից զննարկիչներում. Chrome 38+, Firefox եւ Opera 25+ եւ Safari 7.1+: Դուք կնկատեք, որ Internet Explorer- ը բացակայում է այս ցուցակում, այնուամենայնիվ, դուք կգտնեք Polyfilish- ը MDN- ում:

Օրինակներ

Իհարկե, մենք կարող ենք օգտագործել եւ ոչ ամբողջ թվով այդ գործառույթներից մեկում.

Math.pow (1.25, 2); \u003e 1.5625 Math.CBRT (56.57)\u003e 3.8387991760286138
Խնդրում ենք նկատի ունենալ, որ այն բավականին լավ է աշխատում փաստարկների բացասական արժեքներ օգտագործելիս.

Math.pow (-5.2)\u003e 25 Math.pow (10, -2)\u003e 0.01
Այնուամենայնիվ, քառակուսի արմատի համար այն չի գործի.

Math.sqrt (-9)\u003e Nan
Մաթեմատիկական վերլուծությունից մենք գիտենք, որ երեւակայական թվով նրանք հասկանում են քառակուսի արմատները բացասական թվերից: Եվ սա կարող է մեզ տանել բարդ թվերի հետ աշխատելու մեկ այլ տեխնիկայի, բայց սա եւս մեկ պատմություն է:

Դուք կարող եք օգտագործել Math.Pow- ի ֆրակցիոն արժեքները () `քառակուսի եւ խորանարդ արմատների համարներ գտնելու համար: Քառակուսի արմատը օգտագործում է ցուցիչ 0.5:

Math.pow (5, 0,5); // \u003d math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Այնուամենայնիվ, լողացող կետի քմահաճույքի պատճառով դուք չեք կարող ճշգրիտ ենթադրել ճիշտ արդյունքը.

Math.pow (2.2360679774979,2)\u003e 5.0000000000001
Նման իրավիճակներում դուք ստիպված կլինեք դիմել կրճատման նշանների թվերի կամ ցանկացած արժեքի կլորացման:

Ոմանք JavaScript- ում անհասկանալի պատճառներով շփոթում են մաթեմատիկայի () գործառույթը Math.Exp- ի հետ (), ինչը որպես ընդհանուր առմամբ ցուցահանդեսային գործառույթ է: Նշում. Անգլերենում «Exponent» ցուցանիշը թարգմանվում է որպես «ցուցիչ», ուստի այն ավելի շուտ վերաբերում է անգլիախոսներին, չնայած կա այլընտրանքային ցուցանիշների անուններ, ինչպիսիք են ինդեքսը, իշխանությունը:

Մաթեմատիկական հաստատուններ

JavaScript- ում մաթեմատիկայի հետ աշխատելը հեշտացնում է մի շարք ներկառուցված հաստատուններ: Այս հաստատունները մաթեմատիկայի օբյեկտի հատկություններն են: Հատկանշական է, որ հաստատունները գրված են վերին դեպքում, եւ ոչ թե ուղտերի նոտան:

Math.abs, parseint, parsefloat

JavaScript- ում թվերի հետ աշխատելը կարող է շատ ավելի բարդ լինել, քան թվում է: Ձեռք բերված արժեքները միշտ չէ, որ ընկնում են սպասվող տողերի մեջ, երբեմն արդյունքը կարող է ընդհանրապես չլինել այն, ինչ մենք սպասում էինք:

Math.abs ()

Math.abs- ը () Մեթոդը վերադարձնում է այն համարի բացարձակ արժեքը, որը մեզ հիշեցնում է նույն մաթեմատիկական գործառույթը `Ա համարի համար:

Թող NewVal \u003d -57.64; Math.abs (Newval); \u003e 57.64
Math.abs- ը (0) միշտ վերադառնում է զրոյական, բայց եթե մինուս նշան եք դնում-Math.abs Function (Num) Մենք միշտ բացասական արժեք կլինենք:

Math.abs (0); \u003e -0

parseint ()

Մենք գիտենք, որ JavaScript- ը հասկանում է, որ «15» -ը տող է, եւ ոչ մի թիվ, եւ, օրինակ, CSS հատկությունները javaScript- ի միջոցով անպատրաստ զանգվածի միջոցով կարող է լինել անկանխատեսելի: Մենք կարող էինք ընդունել մուտքի գիծը, որը ներկայացված է որպես «17px», իսկ մեզ համար դա հազվադեպ չէ: Հարցն այն է, թե ինչպես փոխել այս տողը իրական արժեքով եւ օգտագործել այն հետագա հաշվարկներով:

Syntax. Parseint (լարային, ռադիքս);

Պարսնդի հատկությունը վերափոխում է դրանով փոխանցվող առաջին փաստարկը լարային տիպի մեջ, մեկնաբանում է այն եւ վերադարձնում ամբողջ թիվ կամ նան արժեք: Արդյունքը (եթե ոչ NAN) թիվ է եւ ներկայացնում է առաջին փաստարկը (լարային), որը համարվում է նշված համարի համակարգում (Radix): Օրինակ, 10-րդ բազան ցույց է տալիս տասնորդական համարի վերափոխում, 8 - օկտալ, 16 վեցանկյուն եւ այլն: Եթե \u200b\u200bհիմքը 10-ից մեծ է, ապա տառերն օգտագործվում են 9-ից ավելի թվեր նշանակելու համար: Օրինակ, Hexadecimal համարների համար (հիմք 16), նամակներ A- ից F- ից:

Դիտարկենք CSS հատկությունների հետ աշխատելու օրինակ, որտեղ, պայմանականորեն խոսելով, մենք կարող ենք նման արժեք ստանալ.

Թող elem \u003d փաստաթուղթը. Թող կենտրոնացինպոտը \u003d պատուհան: artMuxputStyle (elem) .transformorigin; \u003e "454px 2087.19px"
Մենք կարող ենք արժեքներ բաժանել տարածությունների վրա.

Թող կենտրոններ \u003d centerpoint.split (""); \u003e [«454px», «2087.19px»]
Այնուամենայնիվ, յուրաքանչյուր տարր դեռ տող է, մենք կարող ենք ազատվել դրանից `կիրառելով մեր գործառույթը.

Թող Centerx \u003d Parseint (կենտրոններ, 10); \u003e 454 LET CENTERS \u003d PARSEINT (կենտրոններ, 10); \u003e 2087:
Ինչպես տեսնում եք, մենք նշում ենք այն համարի քանակը, որով կվերափոխվի թիվը, որի ընտրությունը պարտադիր չէ, բայց խորհուրդ է տրվում այն \u200b\u200bօգտագործել, թե որ գիծը կգնա մուտքային:

parsefloat ()

Վերոնշյալ օրինակից, հավանաբար նկատեցիք, որ փարեխը խանգարում է կոտորակային մասը: Մեր դեպքում պարաշերտը կարող է աշխատել լողացող կետի համարներով: Կրկին, դա կարող է օգտակար լինել CSS- ի եւ այլ առաջադրանքների վերլուծության ժամանակ, հատկապես փոխադրման կետով աշխատելիս:

Syntax: Parsefloat (լարային)

Թող FP \u003d "33.33333%"; Console.Log (Parsefloat (FP)); \u003e 33.33333
Խնդրում ենք նկատի ունենալ, որ Parsefloat շարահյուսության մեջ երկրորդ փաստարկ չկա:

Մենք հասկանում ենք, որ փորվածքը () եւ պարսլոտը () չափազանց օգտակար հատկություններ են, անհրաժեշտ է հաշվի առնել, որ անհրաժեշտ չէ անել առանց սխալների տեսականին եւ ի վերջո վերլուծել արդյունքը Ապահովելու համար, որ արժեքները ճիշտ են:
Ուղարկեք անանուն