JavaScripts Numeric Nitty-Gritty.hy.md

Ինչպես մնացորդով թվերից ստանալ ամբողջ թիվ, և ինչ մեթոդներ կան ստուգելու արդյո՞ք թիվը ամբողջ է թե ոչ

Երբեմն լինում են խնդիրներ, երբ անհրաժեշտ է ստուգել ներմուծված թվային տվյալներն արդյոք ամբողջ թվեր են թե ոչ, որոշ դեպքերում նաև դրանք վերածել ամբողջ թվերի, եթե այդպիսին չեն։ JavaScript-ում դրա համար կան ներդրված մեթոդներ, բացի դրանից կան նաև մի շարք հետաքրքիր եղանակներ, որոնց նույնպես կանդրադառնամ։ Եվ այսպես,որպեսզի ստուգենք թիվը ամբողջ է թե ոչ, կարող ենք օգտագործել Number.isInteger(n) մեթոդը։ Այն վերադարձնում է true, եթե թիվն ամբողջ է, հակառակ դեպքում՝ false: Շատ լավ մեթոդ է իրականում, բայց ունի մի հատ բաց, որը բնականաբար կապված է մեր շատ սիրելի «Internet Explorer» բրաուզերի հետ։ Դրա վրա այս մեթոդը չի աշխատում։ Կարող է լուծում լինել պոլիֆիլի օգտագործումը, փորձենք՝

Number.isInteger =
  Number.isInteger ||
  function (value) {
    return (
      typeof value === "number" &&
      isFinite(value) &&
      Math.floor(value) === value
    );
  };

Այն ուղղակի ստուգում է, եթե Number գլոբալ օբյեկտը ունի isInteger մեթոդը, ապա կանչում է այն, իսկ եթե տվյալ մեթոդը բացակայում է, ինչպես որ Internet Explorer-ի ռեալիզացիայի մեջ է, ապա կանչում է մեր ստեղծած անանուն ֆունկցիան, և նրան որպես արգումենտ տալիս է թիվը, որն ուզում ենք ստուգել։ Մեր ֆունկցիան նախ typeof օպերատորի միջոցով ստուգում է, որ դա թիվ է, հետո isFinite(n) մեթոդի միջոցով որ այն անվերջ (infinity) չէ և NaN չէ, ապա Math.floor(n) ներդրված մեթոդի օգնությամբ կլորացնում է դեպի ներքև և համեմատում սկզբնական արժեքի հետ։ Եթե բոլոր երեք ստուգումների արժեքը վերադառնում է true, ապա ֆունկցիան նույնպես true է վերադարձնում։

Հաջորդ տարբերակը՝

n === parseInt(n, 10);

Այստեղ ուղղակի թիվը համեմատում ենք՝ parseInt ներդրված մեթոդին այդ թիվը տալով որպես առաջին արգումենտ, իսկ որպես երկրորդ արգումենտ նշում ենք այն համակարգը, որով թիվը պատկերում ենք, մեր դեպքում՝ տասականը։

Եվս մի տարբերակ՝

Number(n) === n && n % 1 === 0;

Այստեղ նույնպես ամեն ինչ պարզ է, ցանկացած ամբողջ թիվ եթե մնացորդով(%) բաժանենք 1-ի վրա, ապա արդյունքը պետք է լինի 0։ Վերը նշված մեթոդը կարելի է ավելի կարճ գրելաձևով ստանալ՝

!(n % 1);

Այսինքն թիվը մնացորդով բաժանում է կատարվում 1-ի վրա, և արժեքը ժխտման օպերատորի օգնությամբ վերածվում բուլյանի։ Եթե թիվը ամբողջ է, ապա այդ բաժանման արժեքը լինում է 0, 0-ն falsy արժեք է, և դրա ժխտումը բնականաբար վերադարձնում է true: Նախապես կարելի է typeof օպերատորի միջոցով ստուգել, որ մուտքագրված տվյալը անպայման թիվ լինի, այդ դեպքում մեթոդը կարող է անթերի աշխատել։

Եվ ևս մի տարբերակ՝ այս անգամ օգտագործելով բիթային | օպերատորը․

n === +n && n === (n | 0);

Այս տարբերակում նախ n-ը վերածում ենք թվի ունար + օպերատորի միջոցով, և եթե այն թիվ չլինի, կստանանք false, և արտահայտությունը այլևս չի շարունակվի։ Եթե n-ը այնուամենայնիվ թիվ է, ապա (n | 0) ենթաարտահայտությունը վերադարձնում է այդ թվի միայն ամբողջ մասը, հետևաբար եթե թիվը ամբողջ թիվ չէ, n === (n | 0) -ն վերադարձնում է false:

Այժմ դիտարկենք թե ինչպես կարել է մնացորդով թվից ստանալ ամբողջ թիվ։ JavaScript-ի դեռևս առաջին ստանդարտից գոյություն ունի Math ներդրված օբյեկտի 3 մեթոդներ, որոնց օգնությամբ թիվը կլորացնում են, դրանք են՝

Math.ceil(n);
Math.floor(n);
Math.round(n);

Կախված խնդրի բնույթից մենք կարող ենք օգտագործել այն մեթոդը, որը մեզ տվյալ պարագայում պետք է։ Նրանք թիվը կլորացնում են համապատասխանաբար դեպի վերին սահման, ներքին սահման և վերջինը՝ ինչպես որ մաթեմատիկայում ընդունված է՝ դեպի ամենամոտ ամբողջը։ Բացի այս 3 մեթոդից, ES6 ստանդարտում ավելացել է ևս մեկ մեթոդ՝ Math.trunc(n): Այն թվից դեն է նետում մնացորդը և վերադարձնում ամբողջ մասը, օրինակ՝

Math.trunc(3, 25) === 3; // true
Math.trunc(3.75) === 3; // true

Հաջորդ մեթոդը՝ parseInt(n, 10) - օգնությամբ։ Օրինակ՝

parseInt(3.25, 10) === 3; // true
parseInt(3.75, 10) === 3; // true

Կարող ենք օգտագործել նաև բիթային | օպերատորը։ Օրինակ՝

let num = 3.85 | 0; // 3
let anotherNum = 5.45 | 0; // 5

Բիթային **~ (tilde)** օպերատորը նույպես կարող է կիրառվել մնացորդով թվից ամբողջ մաս ստանալու համար։ Այն ուղղակի բիթային ոչ-ն է, և օգտագործվում է երկուական համակարգում աշխատելու համար։ Որպեսզի նրա աշխատանքի սկզբունքը պարզ լինի, բերեմ մի օրինակ․ 8 թիվը երկուական համակարգում պատկերվում է որպես 1000։ Երբ մենք այդ թվի նկատմամբ կիրառենք ~ օպերատորը, ապա այն քանի-որ ինչպես ասվեց բիթային ոչն է, բոլոր բիթերում 0-ները կվերածի 1-ի, իսկ 1-երը՝ 0-ների։ Եվ 8 թիվը, որի երկուական պատկերը 1000-ն է, կդառնա 0111, այսինքն տասական համակարգի 7-ը։ Սակայն պրոբլեմը կայանում է նրանում, որ JavaScript-ը որպեսզի կարողանա բացասական թվերը ներկայացնել երկուական համակարգով, օգտագործում է two’s complement միջոցը, այդ պատճառով էլ օրինակ ~7-ը վերածվում է -8-ի։

Եվ այսպիսով թվից առաջ երկու անգամ օգտագործելով ~ օպերատորը, մենք դեն ենք նետում մնացորդը, և ստանում թվի ամբողջ մասը։ Օրինակ՝

~~4.25 === 4; // true
~~4.85 === 4; // true
~~-7.45 === -7; // true