Js მთელი ნაწილი გაყოფისას. რიცხვების დამრგვალების მეთოდები JavaScript-ში

ამ სტატიაში დეტალურად განვიხილავთ ციფრებს, მათემატიკურ ოპერატორებს, რიცხვის სტრიქონად გადაქცევის გზებს და პირიქით, ასევე ბევრ სხვა მნიშვნელოვან პუნქტს.

არის სასრული ფუნქცია

IsFinite ფუნქცია საშუალებას გაძლევთ შეამოწმოთ არის თუ არა არგუმენტი სასრული რიცხვი.

როგორც პასუხი ამ ფუნქციასაბრუნებს false-ს, თუ არგუმენტი არის Infinity, -Infinity, NaN ან გადაიცემა ერთ-ერთ ამ სპეციალურზე რიცხვითი მნიშვნელობები. IN წინააღმდეგ შემთხვევაშიეს ფუნქცია დაბრუნდება true.

IsFinite(73); // true isfinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("ტექსტი"); // ცრუ

გარდა გლობალური ფუნქცია isFinite JavaScript-ს ასევე აქვს მეთოდი სახელწოდებით Number.isFinite. isFinite-ისგან განსხვავებით, ის არ აიძულებს არგუმენტს გადაიყვანოს რიცხვად.

IsFinite ("73"); // true Number.isFinite("73"); // ცრუ

isNaN ფუნქცია

isNaN ფუნქცია შექმნილია იმის დასადგენად, არის თუ არა არგუმენტი რიცხვი ან შეიძლება გადაკეთდეს ერთში. თუ ასეა, მაშინ isNaN ფუნქცია აბრუნებს false-ს. წინააღმდეგ შემთხვევაში, ის უბრუნდება სიმართლეს.

IsNaN(NaN); //true isNaN("25px"); //მართალია, რადგან 20px არ არის რიცხვი isNaN(25.5); //false isNaN("25.5"); //false isNaN(" "); //ცრუ, რადგან სივრცე ან რამდენიმე სივრცე გარდაიქმნება 0-ში isNaN(null); //ცრუ, რადგან null გარდაიქმნება 0-ად isNaN(true); //ცრუ, რადგან true გარდაიქმნება 1-ად isNaN(false); //ცრუ, რადგან მნიშვნელობა ყალბიგადაკეთდა 0-ზე

თუ ეს მოქმედება უნდა შესრულდეს ტიპის cast-ის გარეშე, გამოიყენეთ Number.isNaN მეთოდი. ეს მეთოდი დაინერგა ენაში ECMAScript 6-დან დაწყებული.

როგორ გადავიტანოთ სტრიქონი რიცხვად?

თქვენ შეგიძლიათ ცალსახად გადაიყვანოთ სტრიქონი რიცხვად შემდეგი მეთოდების გამოყენებით:

1. გამოყენება ერთიანი ოპერატორი +, რომელიც უნდა განთავსდეს მნიშვნელობამდე.

+"7.35"; // 7.35 +"ტექსტი"; // NaN

ეს მეთოდი იგნორირებას უკეთებს სივრცეებს ​​ხაზის დასაწყისში და ბოლოს, ისევე როგორც \n (ხაზის მიწოდება).

+" 7.35"; //7.35 +"7.35 \n"; //7.35

გამოყენება ამ მეთოდითგაითვალისწინეთ, რომ ცარიელი სტრიქონი ან სტრიქონი, რომელიც შედგება შუალედებისგან და \n, გარდაიქმნება რიცხვად 0. გარდა ამისა, ის ასევე გარდაქმნის ნულოვანი მონაცემების ტიპს და ლოგიკურ მნიშვნელობებს რიცხვად.

ნულოვანი; //0 +true; //1 +მცდარი; //0 +" "; //0

2. ParseInt ფუნქცია. ეს ფუნქცია შექმნილია კონვერტაციისთვის არგუმენტი მთელ რიცხვამდე. გამოყენებისგან განსხვავებით ერთიანი ოპერატორი +, ამ მეთოდითსაშუალებას გაძლევთ გადაიყვანოთ სტრიქონი რიცხვად, რომელშიც ყველა სიმბოლო არ არის რიცხვითი. ის იწყებს სტრიქონის გარდაქმნას, დაწყებული პირველი სიმბოლოდან. და როგორც კი შეხვდება არარიცხოვან სიმბოლოს, ეს ფუნქცია წყვეტს მუშაობას და აბრუნებს მიღებულ რიცხვს.

ParseInt ("18px"); //18 parseInt("33.3%"); //33

ამ ფუნქციას შეუძლია იმუშაოს სხვადასხვა სისტემებირიცხვები (ორობითი, რვადი, ათობითი, თექვსმეტობითი). რიცხვითი სისტემის საფუძველი მითითებულია 2 არგუმენტის გამოყენებით.

ParseInt("18px", 10); //18 parseInt("33.3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

გარდა parseInt ფუნქციისა, JavaScript-ს აქვს Number.parseInt მეთოდი. ეს მეთოდი არაფრით განსხვავდება parseInt ფუნქციისგან და დაინერგა JavaScript-ში ECMASCRIPT 2015 (6) სპეციფიკაციით.

3. parseFloat ფუნქცია. parseFloat ფუნქცია მსგავსია parseInt-ის, გარდა იმისა, რომ ის საშუალებას გაძლევთ გადაიყვანოთ არგუმენტი წილად რიცხვად.

ParseFloat ("33.3%"); //33.3

გარდა ამისა, parseFloat ფუნქციას, parseInt-ისგან განსხვავებით, არ აქვს 2 არგუმენტი და ამიტომ ის ყოველთვის ცდილობს სტრიქონი განიხილოს, როგორც რიცხვი ათობითი აღნიშვნის სისტემაში.

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

გარდა parseFloat ფუნქციისა, JavaScript-ს აქვს Number.parseFloat მეთოდი. ეს მეთოდი არაფრით განსხვავდება parseFloat ფუნქციისგან და დაინერგა JavaScript-ში ECMASCRIPT 2015 (6) სპეციფიკაციით.

რიცხვის სტრიქონად გადაქცევა

შეგიძლიათ რიცხვი გადააქციოთ სტრიქონად toString მეთოდის გამოყენებით.

(12.8).toString(); //"12.8"

toString მეთოდი ასევე საშუალებას გაძლევთ მიუთითოთ რიცხვითი სისტემის საფუძველი, იმის გათვალისწინებით, თუ რომელი რიცხვი მკაფიოდ უნდა გადაიყვანოთ სტრინგად:

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

როგორ შევამოწმოთ არის თუ არა ცვლადი რიცხვი

თქვენ შეგიძლიათ განსაზღვროთ არის თუ არა ცვლადის მნიშვნელობა რიცხვი შემდეგი მეთოდის გამოყენებით:

1. isNaN და isFinite ფუნქციების გამოყენება:

// myVar არის ცვლადი, თუ (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar არის რიცხვი ან შესაძლებელია მასზე გადაცემა);

როგორც ფუნქცია:

// ფუნქციის ფუნქცია არის Numeric(მნიშვნელობა) (დაბრუნება !isNaN(parseFloat(მნიშვნელობა)) && isFinite(parseFloat(მნიშვნელობა)); ) // გამოიყენეთ var myVar = "12px"; console.log(isNumeric(myVar)); //მართალია

ეს მეთოდი საშუალებას გაძლევთ განსაზღვროთ არის თუ არა მითითებული მნიშვნელობა რიცხვი ან შეიძლება გადაიზარდოს ერთზე. ეს ოფცია არ ითვლის ცარიელ სტრიქონს, სივრცეების სტრიქონს, null, Infinity, -Infinity, true და false რიცხვად.

2. ოპერატორის ტიპისა და isFinite, isNaN ფუნქციების გამოყენებით:

// ფუნქცია, რომელიც ამოწმებს არის თუ არა მნიშვნელობა რიცხვითი ფუნქცია არისNumber(მნიშვნელობა) (დაბრუნების მნიშვნელობის ტიპი ==="number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

ეს ფუნქცია განსაზღვრავს არის თუ არა მითითებული მნიშვნელობა Number-ის ტიპის და ასევე ეკუთვნის თუ არა ერთ-ერთ მათგანს განსაკუთრებული მნიშვნელობები Infinity, -Infinity და NaN. თუ ასეა, მაშინ ეს ფუნქცია ბრუნდება true.

3. ECMAScript 6 Number.isInteger(მნიშვნელობის) მეთოდის გამოყენებით. ეს მეთოდი საშუალებას გაძლევთ განსაზღვროთ არის თუ არა მითითებული მნიშვნელობა მთელი რიცხვი.

Number.isInteger("20"); //ცრუ, რადგან ეს მეთოდი არ გარდაქმნის სტრიქონს რიცხვად Number.isInteger(20); //მართალია, რადგან ეს მნიშვნელობა არის რიცხვი

ლუწი და კენტი რიცხვები

შეგიძლიათ შეამოწმოთ რიცხვი ლუწი თუ კენტი შემდეგი ფუნქციების გამოყენებით:

// ლუწი პარიტეტის ფუნქციისთვის რიცხვის შემოწმების ფუნქცია არისEven(n) ( აბრუნებს n % 2 == 0; ) // კენტი პარიტეტის ფუნქციისთვის რიცხვის შემოწმების ფუნქცია isOdd(n) ( დაბრუნება Math.abs(n % 2) == 1;

მაგრამ ასეთი შემოწმების ჩატარებამდე მიზანშეწონილია დარწმუნდეთ, რომ მითითებული მნიშვნელობა არის რიცხვი:

მნიშვნელობა = 20; if (Number.isInteger(მნიშვნელობა)) (if (isEven(მნიშვნელობა)) ( console.log("Number" + value.toString() + " - ლუწი"); ) )

ძირითადი რიცხვები Javascript-ში

მოდით შევხედოთ მაგალითს, რომელშიც გამოვაჩენთ მარტივ რიცხვებს 2-დან 100-მდე Javascript-ის გამოყენებით.

// ფუნქცია, რომელიც ამოწმებს არის თუ არა რიცხვი პირველი ფუნქცია არისPrime(მნიშვნელობა) (if (isNaN(მნიშვნელობა) || !isFinite(მნიშვნელობა) || მნიშვნელობა%1 || მნიშვნელობა< 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);

რიცხვის დამრგვალება Javascript-ში

JavaScript-ში წილადის მთელ რიცხვზე დამრგვალების სხვადასხვა გზა არსებობს.

1. ამისთვის სპეციალურად შექმნილი Math.floor, Math.ceil და Math.round მეთოდების გამოყენება. Math.floor მეთოდი ამრგვალებს წილადს უახლოეს მთელ რიცხვამდე, ე.ი. უბრალოდ უგულებელყოფს წილადის ნაწილს. Math.ceil ამრგვალებს წილადს უახლოეს მთელ რიცხვამდე. Math.round ამრგვალებს რიცხვს ზემოთ ან ქვემოთ, წილადი ნაწილის მნიშვნელობიდან გამომდინარე. თუ წილადი ნაწილი მეტია ან ტოლია 0,5-ზე, მაშინ ზემოთ, წინააღმდეგ შემთხვევაში გადახვევა არის ქვემოთ.

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

2. toFixed (ზუსტი) მეთოდის გამოყენებით. ეს მეთოდი ამრგვალებს რიცხვის წილად ნაწილს მითითებულ სიზუსტემდე. დამრგვალების შედეგი ბრუნდება სტრიქონის სახით.

Console.log(7.987.toFixed(2)); //"7.99"

თუ არ არის საკმარისი ათწილადი რიცხვის განსაზღვრული სიზუსტის ფორმირებისთვის, მაშინ ის ივსება ნულებით.

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

3. toPrecision(accuracy) მეთოდის გამოყენება. ეს მეთოდი წარმოადგენს რიცხვს მითითებული სიზუსტით. ამავდროულად, მას შეუძლია დამრგვალოს არა მხოლოდ წილადი, არამედ რიცხვის მთელი ნაწილი. შედეგიდან გამომდინარე, ამ მეთოდს შეუძლია წარმოადგინოს მიღებული რიცხვი ფიქსირებული წერტილით ან ექსპონენციალური ფორმით.

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

4. ლოგიკური ოპერატორების NOT ან OR გამოყენება.

//ორმაგი ლოგიკური უარყოფის კონსოლის მეშვეობით.log(~~7.9); //7 // ლოგიკური ან ნულის გამოყენებით: console.log(7.9^0); //7

რიცხვის მთელი და წილადი ნაწილი

შეგიძლიათ მიიღოთ რიცხვის მთელი ნაწილი Math.floor() და parseInt() მეთოდების გამოყენებით:

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

თქვენ შეგიძლიათ მიიღოთ რიცხვის წილადი ნაწილი პროცენტული (%) ოპერატორის გამოყენებით. ეს ოპერატორი აბრუნებს ნარჩენს, რომელიც მიიღება პირველი რიცხვის მეორეზე გაყოფით. ამ შემთხვევაში, თქვენ უნდა გამოიყენოთ 1, როგორც მე-2 ნომერი.

Console.log (7.21%1); // 0.20999999999999996 // ზუსტი 2 ათობითი ადგილის ჩათვლით console.log((7.21%1).toFixed(2)); // "0.21"

გარდა ამისა, წილადი ნაწილის მიღება ასევე შესაძლებელია გამოთვლების გამოყენებით:

Var ნომერი = 7.21; var fractionNumber = ნომერი - Math.floor(Math.abs(number)); console.log(fractionNumber); // 0.20999999999999996

რიცხვი იყოფა მთელ რიცხვზე?

თქვენ შეგიძლიათ განსაზღვროთ არის თუ არა რიცხვი მთელ რიცხვზე პროცენტული ოპერატორის გამოყენებით:

Var ნომერი = 9; // თუ 3-ზე გაყოფილი რიცხვის ნაშთი არის 0, მაშინ დიახ, წინააღმდეგ შემთხვევაში არა, თუ (number%3==0) ( console.log ("რიცხვი " + რიცხვი + " იყოფა 3-ზე); ) else ( კონსოლი log ("ნომერი " + ნომერი + " არ იყოფა 3-ზე" );

ნომრების ფორმატირება

JavaScript-ში, toLocaleString() მეთოდი საშუალებას გაძლევთ დაფორმატოთ რიცხვის გამომავალი რეგიონალური სტანდარტების შესაბამისად (ოპერაციული სისტემის ენობრივი პარამეტრები).

მაგალითად, მოდით დავაფორმოთ ნომერი რეგიონალური სტანდარტების შესაბამისად, რომლებიც სისტემაში სტანდარტულად არის დაინსტალირებული:

Var ნომერი = 345,46; console.log(number.toLocaleString()); //"345.46"

მაგალითად, მოდით დავაფორმოთ ნომერი რუსეთის რეგიონალური სტანდარტების შესაბამისად (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

ეს მეთოდი ასევე შეიძლება გამოყენებულ იქნას რიცხვის ვალუტად ფორმატირებისთვის:

Console.log((2540.125).toLocaleString("ru-RU",(სტილი:"ვალუტა", ვალუტა:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(სტილი:"ვალუტა", ვალუტა:"USD"))); //"89.30 $" console.log((2301.99).toLocaleString("ru-RU",(სტილი:"ვალუტა", ვალუტა:"EUR"))); //"2,301,99 ევრო"

რიცხვის პროცენტულად წარმოდგენა:

Console.log((0.45).toLocaleString("ru-RU",(სტილი:"პროცენტი"))); //"45%"

დაყავით რიცხვი ციფრებად (useGrouping თვისება):

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

დაბეჭდეთ რიცხვი გარკვეული რაოდენობის ციფრებით (2) ათობითი წერტილის შემდეგ:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1,240.46"

რიცხვების შედარება

JavaScript-ში რიცხვების შესადარებლად გამოიყენება შემდეგი ოპერატორები: == (ტოლი), != (არა ტოლი), > (უფრო მეტი),< (меньше), >= (უფრო მეტი ან ტოლი),<= (меньше или равно).

მაგალითად, შევადაროთ ორი რიცხვი:

Console.log(2>3); //false console.log(5>=3); //მართალია

წილადის ნაწილთან რიცხვების შედარებისას აუცილებელია გავითვალისწინოთ ის შეცდომები, რომლებიც შეიძლება წარმოიშვას ამ გამოთვლების დროს.

მაგალითად, JavaScript-ში რიცხვების ჯამი (0.2 + 0.4) არ უდრის 0.6-ს:

Console.log((0.2+0.4)==0.6); //ცრუ

შეცდომები ხდება იმის გამო, რომ კომპიუტერი ან სხვა ელექტრონული მოწყობილობა ასრულებს ყველა გამოთვლას მე-2 ნომრის სისტემაში. იმათ. ნებისმიერი მოქმედების შესრულებამდე კომპიუტერმა ჯერ უნდა გადაიყვანოს გამოთქმაში წარმოდგენილი რიცხვები მე-2 რიცხვების სისტემაში. მაგრამ ყველა წილადი ათობითი რიცხვი არ შეიძლება ზუსტად იყოს წარმოდგენილი მე-2 რიცხვთა სისტემაში.

მაგალითად, რიცხვი 0.25 10 გარდაიქმნება ბინარულად ზუსტად.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0.5 × 2 = 1 | 1 0,125 10 = 0,001 2

მაგალითად, რიცხვი 0.2 10 შეიძლება გარდაიქმნას 2 სისტემაში მხოლოდ გარკვეული სიზუსტით:

0,2 × 2 = 0,4 | 0 0.4 × 2 = 0.8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0.4 × 2 = 0.8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0.4 × 2 = 0.8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0.2 10 = 0.001100110011... 2

შედეგად, ეს შეცდომები გავლენას მოახდენს ორი რიცხვის ჯამის გამოთვლაზე და შედარების შედეგებზე. იმათ. გამოდის, რომ JavaScript რეალურად დაინახავს ამ ჩანაწერს შემდეგნაირად:

0.6000000000000001==0.6

წილადი ნაწილებით რიცხვების გამოთვლის ან ჩვენებისას ყოველთვის უნდა მიუთითოთ სიზუსტით, რომლითაც გსურთ ამის გაკეთება.

მაგალითად, შეადარეთ რიცხვები 2 ათობითი ადგილამდე toFixed() და toPrecision() მეთოდების გამოყენებით:

//მეთოდი toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metod toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //მართალია

ძირითადი მათემატიკის ოპერაციები

შემდეგი მათემატიკური ოპერატორები არსებობს JavaScript-ში: + (მიმატება), - (გამოკლება), * (გამრავლება), / (გაყოფა), % (მოდული), ++ (მნიშვნელობის გაზრდა 1-ით), -- (მნიშვნელობის შემცირება 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, ე.ი. 6:3=2 => 6-3*2 => დასვენება(0) 5%2 //1, ე.ი. 5:2=2(.5) => 5-2*2 => დანარჩენი (1) 7.3%2 //1.3, ე.ი. 7.3:2=3(.65) => 7.3-2*3 => დასვენება(1.3) //% ოპერაციის შედეგის ნიშანი უდრის პირველი მნიშვნელობის ნიშანს -9%2.5 //-1.5 , ე.ი. 9:2.5=3(.6) => 9-2.5*3 => დასვენება (1.5) -9%-2.5 //-1.5, ე.ი. 9:2.5=3(.6) => 9-2.5*3 => დასვენება (1.5) -2%5 //-2, ე.ი. 2:5=0(.4) => 2-5*0 => დასვენება(2) x = 3; console.log(x++); //გამოსცემს 3, შემდეგ აყენებს 4 console.log(x); //4 x = 3; console.log(++x); //ნაკრები 4 და გამოაქვს x = 5; console.log(x--); //გამოაქვს 5, შემდეგ აყენებს 4 console.log(x); //4 x = 5; console.log(--x); //4 ნაკრები და გამომავალი გამომავალი გარდა ამისა, JavaScript-ს აქვს კომბინირებული ოპერატორები: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y).

x = 3; y = 6; x+=y; console.log(x); //9 x = 3; y = 6; x-=y; console.log(x); //-3 x = 3; y = 6; x*=y; console.log(x); //18 x = 3; y = 6; x/=y; console.log(x); //0,5 x = 3; y = 6; x%=y; console.log(x); //3 ხშირად გამოთვლები იძლევა შედეგებს, რომლებიც სასურველი დიაპაზონის მიღმაა. შედეგად, აუცილებელია მისი განხორციელება JavaScript დამრგვალება

გარკვეულ ღირებულებამდე.

რატომ მრგვალდება რიცხვები?

0.1 * 0.2; > 0.020000000000000004

JavaScript არ ინახავს მთელ რიცხვებს, რადგან მათი მნიშვნელობები წარმოდგენილია როგორც მცურავი წერტილის რიცხვები. ბევრი წილადი არ შეიძლება იყოს წარმოდგენილი, როგორც რიცხვი ათწილადების კონკრეტული სასრული რაოდენობით, ამიტომ JavaScript-ს შეუძლია შემდეგი შედეგების გამომუშავება:

პრაქტიკაში, ეს არანაირ განსხვავებას არ გამოიწვევს, რადგან ჩვენ ვსაუბრობთ 2 კვინტილიონედის შეცდომაზე. მაგრამ ამან შეიძლება გავლენა მოახდინოს შედეგებზე ციფრებთან მუშაობისას, რომლებიც წარმოადგენს ვალუტის მნიშვნელობებს, პროცენტებს ან ფაილის ზომას. აქედან გამომდინარე, თქვენ უნდა გააკეთოთ ან გარკვეული ათობითი ადგილი.

ათობითი რიცხვების დამრგვალება

• თუ toFixed()-ს არ აქვს მითითებული არგუმენტი, ნაგულისხმევი მნიშვნელობა არის 0, ანუ არ არის ათობითი ადგილები; მაქსიმალური არგუმენტის მნიშვნელობა არის 20;
• თუ არგუმენტი არ არის მოცემული toPrecision(), რიცხვი არ იცვლება.

var randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87.335; randNum.toFixed(2); > "87.33" var randNum = 87.337; randNum.toPrecision(3); > "87.3"

შენიშვნა

ორივე toFixed() და toPrecision აბრუნებს შედეგის მომრგვალებულ სტრიქონს, ვიდრე რიცხვს. ეს ნიშნავს, რომ randNum-ზე დამრგვალების დამატება გამოიწვევს სტრიქონების შეერთებას და არა ერთ რიცხვს:

console.log(randNum + დამრგვალებული); > "6.256"

თუ გსურთ JavaScript-მა დაამრგვალოს რიცხვი უახლოეს მეასედამდე, გამოიყენეთ parseFloat():

var randNum = 6.25; var მომრგვალებული = parseFloat(randNum.toFixed(1)); console.log (დამრგვალებული); > 6.3

toFixed() და toPrecision() ასევე სასარგებლო მეთოდებია მორთვისთვის დიდი რაოდენობითათობითი ადგილები. ეს სასარგებლოა ფულადი ერთეულების წარმომადგენლობით რიცხვებთან მუშაობისას:

var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log($Cents); > "1.00"

გაითვალისწინეთ, რომ თუ რიცხვს აქვს მითითებულ სიზუსტეზე მეტი ციფრი, toPrecision გამოსცემს შედეგს სამეცნიერო ფორმატში:

var num = 123.435 num.toPrecision(2); > "1.2e+2"

როგორ ავიცილოთ შეცდომები ათწილადების დამრგვალებისას

ზოგიერთ შემთხვევაში toFixed და toPrecision განხორციელება JavaScript დამრგვალება 5 ქვემოთ, და არა მეტი:

var numTest = 1.005; numTest.toFixed(2); > 1;

ზემოთ მოყვანილი მაგალითის შედეგი უნდა იყოს 1.01 და არა 1. თუ გსურთ ამ შეცდომის თავიდან აცილება, გირჩევთ გამოიყენოთ ექსპონენციალური რიცხვები:

ფუნქცია round(მნიშვნელობა, ათწილადები) ( დაბრუნება Number(Math.round(მნიშვნელობა+"e"+ათწილადები)+"e-"+ათწილადები); )

განაცხადი:

რაუნდი(1.005,2); > 1.01

თუ დამრგვალებაზე უფრო მტკიცე გადაწყვეტა გჭირდებათ, ის ხელმისაწვდომია მისამართზე MDN.

დამრგვალება epsilon-ით

ალტერნატიული მეთოდი JavaScript დამრგვალება მეათედებადდაინერგა ES6-ში ( ასევე ცნობილია როგორც JavaScript 2015). « მანქანა epsilon" იძლევა შეცდომის გონივრულ ზღვარს ორი მცურავი წერტილის შედარებისას. დამრგვალების გარეშე, შედარებამ შეიძლება გამოიწვიოს შემდეგი შედეგები:

0.1 + 0.2 === 0.3 > მცდარი

Math.EPSILON შეიძლება გამოყენებულ იქნას ფუნქციაში სწორი შედარების მისაღებად:

ფუნქცია epsEqu(x, y) (დაბრუნება Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

ფუნქცია იღებს ორ არგუმენტს: ერთი შეიცავს გამოთვლებს, მეორე - მოსალოდნელ (დამრგვალებულ) შედეგს. ის აბრუნებს ამ ორი პარამეტრის შედარებას:

epsEqu(0.1 + 0.2, 0.3) > true

ყველა თანამედროვე ბრაუზერი მხარს უჭერს ES6 მათემატიკის ფუნქციებს. მაგრამ თუ თქვენ გჭირდებათ მხარდაჭერის უზრუნველყოფა ძველ ბრაუზერებში, მაშინ უნდა გამოიყენოთ პოლიფილები.

ათობითი რიცხვების შეკვეცა

ადრე წარმოდგენილი ყველა მეთოდი მუშაობს JavaScript დამრგვალება მეათედებად. დადებითი რიცხვის ორ ათწილადამდე შესაკვეცად, გაამრავლეთ იგი 100-ზე, კვლავ შეაკვეცეთ და შემდეგ გაყავით შედეგი 100-ზე:

ფუნქცია truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14

თუ რამე უფრო მოქნილი გჭირდებათ, შეგიძლიათ გამოიყენოთ bitwise ოპერატორი:

ფუნქცია truncated (num, decimalPlaces) ( var numPowerConverter = Math.pow (10, decimalPlaces); დაბრუნება ~~ (num * numPowerConverter)/numPowerConverter; )

გამოყენება:

var randInt = 35.874993; truncated(randInt,3); > 35.874

დამრგვალეთ უახლოეს რიცხვამდე

განსახორციელებლად JavaScript დამრგვალება უახლოეს მთელ რიცხვზე, Math.round() გამოიყენება:

მათემატიკის რაუნდი(4.3) > 4 მათემატიკის რაუნდი(4.5) > 5

გაითვალისწინეთ, რომ " ნახევარი ღირებულებები“, როგორიცაა .5, მრგვალდება.

დამრგვალეთ ქვემოთ უახლოეს მთელ რიცხვამდე

თუ გსურთ დამრგვალება, გამოიყენეთ Math.floor() მეთოდი:

მათე.სართული(42.23); > 42 მათემ.სართული(36.93); > 36

დამრგვალებას აქვს ერთი მიმართულება ყველა რიცხვისთვის, მათ შორის უარყოფითი. ეს შეიძლება წარმოვიდგინოთ, როგორც ცათამბჯენი უსასრულო რაოდენობის სართულებით, მათ შორის საძირკვლის დონის ქვემოთ ( წარმოადგენს უარყოფით რიცხვებს). თუ იმყოფებით ლიფტში მე-2 და მე-3 სართულებს შორის ( რომელიც შეესაბამება -2,5 მნიშვნელობას), Math.floor მიგიყვანთ -3 სართულზე:

მათე.სართული(-2.5); > -3

თუ ამის თავიდან აცილება გჭირდებათ, გამოიყენეთ JavaScript მათემატიკის დამრგვალება Math.trunc()-ის გამოყენებით, რომელიც მხარდაჭერილია ყველაში თანამედროვე ბრაუზერები(გარდა IE/Edge):

Math.trunc(-41.43); > -41

MDN ასევე გთავაზობთ სამხაზიანი პოლიფილი, რათა უზრუნველყოს Math.trunc-ის მხარდაჭერა ძველ ბრაუზერებში და IE/Edge-ში.

დამრგვალეთ ზევით უახლოეს მთელ რიცხვამდე

თუ გსურთ ათობითი რიცხვების დამრგვალება, გამოიყენეთ Math.ceil . ეს მეთოდი ასევე შეიძლება ჩაითვალოს უსასრულო ლიფტად: Math.ceil ყოველთვის მიგიყვანთ მაღლა, მიუხედავად იმისა, რიცხვი უარყოფითია თუ დადებითი:

მათემატიკა.ჭერი(42.23); > 43 Math.ceil(36.93); > 37 მათემატ.ceil(-36.93); -36

დამრგვალეთ უახლოეს ჯერადამდე

თუ მნიშვნელობის დამრგვალება გჭირდებათ 5-ის უახლოეს ჯერადამდე, შექმენით ფუნქცია, რომელიც ყოფს რიცხვს 5-ზე, ამრგვალებს მას და შემდეგ ამრავლებს შედეგს იმავე მნიშვნელობით:

ფუნქცია roundTo5(num) (დაბრუნება Math.round(num/5)*5;)

გამოყენება:

roundTo5(11); > 10

თუ გჭირდებათ JavaScript ორ ციფრამდე დასამრგვალებლად, შეგიძლიათ გადასცეთ როგორც Seed, ასევე მრავალჯერადი ფუნქციას:

ფუნქცია roundToMultiple(num, multiple) (დაბრუნება Math.round(num/multiple)*multiple;)

ფუნქციის გამოსაყენებლად, შეიტანეთ დასამრგვალებელი ნომერი და მრავალჯერადი მის ზარში:

var საწყისიNumber = 11; var მრავალჯერადი = 10; roundToMultiple(initialNumber, მრავალჯერადი); > 10;

მნიშვნელობების მხოლოდ ზემოთ ან ქვემოთ დასამრგვალებლად, ფუნქციაში მრგვალი ჩაანაცვლეთ ჭერით ან იატაკით.

დიაპაზონის შეკვრა

ზოგჯერ თქვენ უნდა მიიღოთ x-ის მნიშვნელობა, რომელიც უნდა იყოს გარკვეულ დიაპაზონში. მაგალითად, ჩვენ გვჭირდება მნიშვნელობა 1-დან 100-მდე, მაგრამ ვიღებთ მნიშვნელობას 123. ამის გამოსასწორებლად შეგიძლიათ გამოიყენოთ min() ( აბრუნებს უმცირეს რიცხვს) და მაქსიმუმ ( აბრუნებს მაქსიმალურ დასაშვებ რაოდენობას).

გამოყენება:

var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;

შეგიძლიათ შექმნათ Number კლასის ფუნქცია ან გაფართოება.

რატომ არის საჭირო დამრგვალება?

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
პრაქტიკული მიზნებისთვის, ამ უზუსტობას მნიშვნელობა არ აქვს, ჩვენს შემთხვევაში ვსაუბრობთ შეცდომაზე კვინტილიონ ნაწილებში, თუმცა, ამან შეიძლება ზოგიერთს იმედი გაუცრუოს. ჩვენ ასევე შეგვიძლია მივიღოთ გარკვეულწილად უცნაური შედეგები ციფრებთან მუშაობისას, რომლებიც წარმოადგენს ვალუტას, პროცენტს ან ფაილის ზომას. ამ უზუსტობების გამოსასწორებლად საჭიროა მხოლოდ შედეგების დამრგვალება და საკმარისია ათობითი სიზუსტის დაყენება.

რიცხვების დამრგვალებას აქვს პრაქტიკული გამოყენება, ჩვენ შეგვიძლია რიცხვით მანიპულირება გარკვეულ დიაპაზონში, მაგალითად, გვინდა დავამრგვალოთ მნიშვნელობა უახლოეს მთელ რიცხვამდე, ვიდრე მხოლოდ ათობითი ნაწილით ვიმუშაოთ.

ათობითი რიცხვების დამრგვალება

1. თუ არგუმენტი არ არის განსაზღვრული toFixed(-ისთვის), ის ნაგულისხმევად იქნება ნული, რაც ნიშნავს 0 ათობითი ადგილებს, არგუმენტს აქვს მაქსიმალური მნიშვნელობა 20.
2. თუ ზუსტი არგუმენტი არ არის მოცემული, რიცხვი ხელუხლებელი რჩება

მოდით randNum = 6.25; მრგვალდება = randNum.toFixed(); // "6" console.log(randNum + მომრგვალებული); > "6.256"
თუ გსურთ, რომ შედეგი იყოს რიცხვითი მონაცემების ტიპი, მაშინ მოგიწევთ გამოიყენოთ parseFloat:

მოდით randNum = 6.25; მრგვალდება = parseFloat(randNum.toFixed(1)); console.log (დამრგვალებული); > 6.3
გთხოვთ გაითვალისწინოთ, რომ 5-ის მნიშვნელობები მრგვალდება, გარდა იშვიათი შემთხვევებისა.

toFixed() და toPrecision() მეთოდები სასარგებლოა, რადგან მათ შეუძლიათ არა მხოლოდ წილადის ნაწილის ამოჭრა, არამედ ათობითი ადგილების დამატება, რაც მოსახერხებელია ვალუტასთან მუშაობისას:

მოდით wholeNum = 1 დოლარიCents = wholeNum.toFixed(2); console.log($Cents); > "1.00"
გაითვალისწინეთ, რომ toPrecision მისცემს შედეგს სამეცნიერო აღნიშვნით, თუ მთელი რიცხვების რაოდენობა უფრო მეტია, ვიდრე თავად სიზუსტე:

მოდით num = 123.435 num.toPrecision(2); > "1.2e+2"

როგორ ავიცილოთ თავიდან დამრგვალების შეცდომები ათწილადებით

მოდით numTest = 1.005; numTest.toFixed(2); > "1.00"
ზემოთ მოყვანილი გამოთვლის შედეგი უნდა ყოფილიყო 1.01 და არა 1. თუ გსურთ მსგავსი შეცდომის თავიდან აცილება, შეგვიძლია გამოვიყენოთ ჯეკ ლ მურის მიერ შემოთავაზებული გამოსავალი, რომელიც გამოთვლებისთვის იყენებს ექსპონენციალურ რიცხვებს:

ფუნქციის მრგვალი (მნიშვნელობა, ათწილადები) (დაბრუნება Number(Math.round(მნიშვნელობა+"e"+ათწილადები)+"e-"+ათწილადები); )
ახლა:

რაუნდი(1.005,2); > 1.01
თუ გსურთ უფრო ძლიერი გადაწყვეტა, ვიდრე ზემოთ ნაჩვენები, შეგიძლიათ გადახვიდეთ MDN-ზე.

მანქანა epsilon დამრგვალება

0.1 + 0.2 === 0.3 > მცდარი
ჩვენ ვიყენებთ Math.EPSILON-ს ჩვენს ფუნქციაში სწორი შედარების მისაღებად:

ფუნქცია epsEqu(x, y) ( დაბრუნება Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
ფუნქცია იღებს ორ არგუმენტს: პირველი არის მიმდინარე გაანგარიშება, მეორე არის მოსალოდნელი შედეგი. აბრუნებს ამ ორის შედარებას:

EpsEqu(0.1 + 0.2, 0.3) > true
ყველა თანამედროვე ბრაუზერი უკვე მხარს უჭერს ES6 მათემატიკის ფუნქციებს, მაგრამ თუ გსურთ მხარდაჭერა ბრაუზერებში, როგორიცაა IE 11, გამოიყენეთ პოლიფილები.

წილადი ნაწილის მორთვა

ფუნქცია truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
თუ გსურთ მეთოდის ადაპტირება ათწილადების ნებისმიერ რაოდენობაზე, შეგიძლიათ გამოიყენოთ ბიტიანი ორმაგი უარყოფა:

ფუნქცია truncated (num, decimalPlaces) ( მოდით, numPowerConverter = Math.pow (10, ათობითი ადგილები); დაბრუნება ~~ (num * numPowerConverter)/numPowerConverter; )
ახლა:

მოდით randInt = 35.874993; truncated(randInt,3); > 35.874

დამრგვალეთ უახლოეს რიცხვამდე

მათემატიკის რაუნდი(4.3) > 4 მათემატიკის რაუნდი(4.5) > 5
გთხოვთ გაითვალისწინოთ, რომ „მნიშვნელობის ნახევარი“, 0.5 მრგვალდება მათემატიკის წესების მიხედვით.

დამრგვალეთ ქვემოთ უახლოეს მთელ რიცხვამდე

მათე.სართული(42.23); > 42 მათემ.სართული(36.93); > 36
გთხოვთ გაითვალისწინოთ, რომ დამრგვალება მუშაობს ყველა რიცხვზე, მათ შორის უარყოფით რიცხვებზე. წარმოიდგინეთ ცათამბჯენი უსასრულო რაოდენობის სართულებით, სართულების ჩათვლით ქვედა დონეზე (ასახავს უარყოფით რიცხვებს). თუ ლიფტში იმყოფებით ყველაზე დაბალ დონეზე 2-დან 3-მდე (რაც წარმოადგენს -2.5 მნიშვნელობას), Math.floor მიგიყვანთ -3-მდე:

მათე.სართული(-2.5); > -3
მაგრამ თუ გსურთ ამ სიტუაციის თავიდან აცილება, გამოიყენეთ Math.trunc, რომელიც მხარდაჭერილია ყველა თანამედროვე ბრაუზერში (გარდა IE/Edge):

Math.trunc(-41.43); > -41
MDN-ზე ნახავთ პოლიფილს, რომელიც უზრუნველყოფს Math.trunc-ის მხარდაჭერას ბრაუზერებში და IE/Edge-ში.

დამრგვალეთ ზევით უახლოეს მთელ რიცხვამდე

მათემატიკა.ჭერი(42.23); > 43 Math.ceil(36.93); > 37 მათემატ.ceil(-36.93); > -36

დამრგვალება ზევით/ქვევით საჭირო რაოდენობამდე

ფუნქცია roundTo5(num) (დაბრუნება Math.round(num/5)*5;)
ახლა:

RoundTo5(11); > 10
თუ გსურთ თქვენი მნიშვნელობის ჯერადად დამრგვალება, ჩვენ ვიყენებთ უფრო ზოგად ფუნქციას, გადავცემთ მას საწყის მნიშვნელობას და მრავალჯერადს:

ფუნქცია roundToMultiple(num, multiple) (დაბრუნება Math.round(num/multiple)*multiple;)
ახლა:

მოდით საწყისიNumber = 11; მრავალჯერადი = 10; roundToMultiple(initialNumber, მრავალჯერადი); > 10;

რიცხვის დაფიქსირება დიაპაზონში

მოდით lowBound = 1; მოდით highBound = 100; მოდით numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
ისევ, ჩვენ შეგვიძლია ხელახლა გამოვიყენოთ ოპერაცია და შევფუთოთ მთლიანი ფუნქცია დენიელ X. მურის მიერ შემოთავაზებული ხსნარის გამოყენებით:

Number.prototype.clamp = ფუნქცია(min, max) ( return Math.min(Math.max(this, min), max); );
ახლა:

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

გაუსის დამრგვალება

ფუნქცია gaussRound(num, ათობითი ადგილები) (დავუშვათ d = ათობითი ადგილები || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.სართული (n), f = n - i, e = 1e-8, r = (f > 0.5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
ახლა:

გაუსმრგვალი(2.5) > 2 გაუსმრგვალი(3.5) > 4 გაუსმრგვალი(2.57,1) > 2.6
ათწილადი CSS-ში:

იმის გამო, რომ JavaScript ხშირად გამოიყენება HTML ელემენტების პოზიციური რუკების შესაქმნელად, შეიძლება გაინტერესებთ, რა მოხდებოდა, თუ ჩვენ შევქმნით ათობითი მნიშვნელობებს ჩვენი ელემენტებისთვის:

#box (სიგანე: 63.667731993px; )
კარგი ამბავი ის არის, რომ თანამედროვე ბრაუზერები პატივს სცემენ ათობითი მნიშვნელობებს ბლოკის მოდელში, პროცენტული ან პიქსელის ერთეულების ჩათვლით.

დახარისხება

დახარისხება ანბანურად

მოდით ხილი = ["კარაქიანი გოგრა", "გარგარი", "კანტალუპი"]; ხილი.დახარისხება(); > "გარგარი", "კარაქიანი გოგრა", "კანტალუპი"]
თუმცა, პრობლემას ვაწყდებით, როგორც კი ერთ-ერთი ელემენტი არის დიდი:

მოდით ნაყოფი = ["კარაქიანი გოგრა", "გარგარი", "კანტალოპა"]; ხილი.დახარისხება(); > "კანტოლუპი", "გარგარი", "კარაქიანი გოგრა"]
ეს იმიტომ ხდება, რომ ნაგულისხმევად, დამხარისხებელი ადარებს უნიკოდში წარმოდგენილ პირველ სიმბოლოს. Unicode არის უნიკალური კოდინებისმიერი სიმბოლოსთვის, მიუხედავად პლატფორმისა, პროგრამისა, ენის მიუხედავად. მაგალითად, თუ დააკვირდებით კოდების ცხრილს, სიმბოლოს "a" აქვს მნიშვნელობა U+0061 (თექვსმეტობით 0x61), ხოლო სიმბოლოს "C" აქვს კოდი U+0043 (0x43), რომელიც უფრო ადრე მოდის Unicode-ში. ცხრილი ვიდრე პერსონაჟი "ა".

მასივის დასალაგებლად, რომელიც შეიძლება შეიცავდეს შერეულ პირველ ასოებს, ან უნდა გადავიყვანოთ ყველა ელემენტი დროებით პატარა ასო, ან განსაზღვრეთ თქვენი დალაგების თანმიმდევრობა localeCompare() მეთოდის გამოყენებით რამდენიმე არგუმენტით. როგორც წესი, ასეთ შემთხვევაში, უმჯობესია დაუყოვნებლივ შექმნათ ფუნქცია განმეორებითი გამოყენებისთვის:

ფუნქცია alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "გარგარი", "კანტალუპი"]; alphaSort (ხილი) >
თუ გსურთ, რომ მასივი დალაგდეს საპირისპირო ანბანის მიხედვით, უბრალოდ შეცვალეთ a და b პოზიციები ფუნქციაში:

ფუნქცია alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash ", "გარგარი", "კანტალუპი"]; alphaSort(ხილი) > ["Cantaloupe", "butternut squash", "Aprico"]
აქვე აღსანიშნავია, რომ localeCompare გამოიყენება არგუმენტებით, ასევე უნდა გვახსოვდეს, რომ მას მხარს უჭერს IE11+, IE-ს ძველი ვერსიებისთვის შეგვიძლია გამოვიყენოთ არგუმენტების გარეშე და მცირე რეგისტრით:

ფუნქცია caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "Apricot", "კანტალუპი"]; caseSort(ხილი) > ["გარგარი", "კარაქიანი გოგრა", "კანტალუპი"]

რიცხვითი დალაგება

მოდით მაღალი ქულები = ; highScores.sort(); >
საქმე ისაა, რომ sort() მეთოდი ახორციელებს ლექსიკოგრაფიულ შედარებას: რაც ნიშნავს, რომ რიცხვები გადაიქცევა სტრიქონად და შედარება კვლავ მოხდება ამ სტრიქონის პირველი სიმბოლოს უნიქოდის ცხრილის სიმბოლოების თანმიმდევრობით. . ამიტომ, ჩვენ კვლავ უნდა განვსაზღვროთ ჩვენი დალაგების თანმიმდევრობა:

მოდით მაღალი ქულები = ; highScores.sort(function(a,b) ( return a - b; )); >
ისევ, რიცხვების საპირისპიროდ დასალაგებლად, შეცვალეთ a და b პოზიციები ფუნქციაში.

JSON-ის მსგავსი სტრუქტურის დალაგება

Let scores = [ ( "სახელი": "დანიელი", "სკორი": 21768 ), ( "სახელი": "მაიკლ", "ქულა": 33579 ), ( "სახელი": "ალისონი", "სკორ": 38395 ) ];
ES6+-ში შეგიძლიათ გამოიყენოთ ისრის ფუნქციები:

Scores.sort((a, b) => b.score - a.score));
ძველი ბრაუზერებისთვის, რომლებსაც არ აქვთ ეს მხარდაჭერა:

Scores.sort(function(a, b) ( return a.score - b.score ));
როგორც ხედავთ, JavaScript-ში დალაგება საკმაოდ ბუნდოვანია, იმედი მაქვს, რომ ეს მაგალითები ცხოვრებას რაღაცნაირად გაუადვილებს.

დენის ფუნქციებთან მუშაობა

JavaScript-ში სიმძლავრის ფუნქცია წარმოდგენილია როგორც Math.pow(), ხოლო ახალ ES7 სტანდარტში დაინერგა ახალი ექსპონენტაციის ოპერატორი - " * *".

ექსპონენტაცია

Math.pow(3,2) > 9
აღნიშვნის ეს ფორმა ნიშნავს 3 კვადრატს, ან 3 × 3, რაც იწვევს შედეგს 9. სხვა მაგალითი შეიძლება მოყვანილი იყოს, რა თქმა უნდა:

Math.pow(5,3); > 125
ანუ 5 კუბური, ანუ 5 × 5 × 5, უდრის 125-ს.

ECMAScript 7 არის JavaScript-ის შემდეგი ვერსია, პრინციპში, ჩვენ შეგვიძლია გამოვიყენოთ ახალი შემოთავაზებული ექსპონენტაციის ოპერატორი - * *, აღნიშვნის ეს ფორმა შეიძლება უფრო აღწერითი იყოს:

3 ** 2 > 9
ჩართულია მომენტშიამ ოპერატორის მხარდაჭერა საკმაოდ შეზღუდულია, ამიტომ მისი გამოყენება არ არის რეკომენდებული.

დენის ფუნქცია ყველაზე მეტად შეიძლება სასარგებლო იყოს სხვადასხვა სიტუაციები. მარტივი მაგალითი, ერთ საათში წამების რაოდენობის გამოთვლა: Math.pow (60,2).

კვადრატული და კუბური ფესვები

მათემატიკა.sqrt(9) > 3
ამავდროულად, a-ს კუბური ფესვი არის რიცხვი, რომელიც იძლევა a-ს კუბამდე აწევისას.

მათემატიკა.cbrt(125) > 5
Math.cbrt() ახლახან დაინერგა JavaScript-ის სპეციფიკაციაში და, შესაბამისად, მხარდაჭერილია მხოლოდ თანამედროვე ბრაუზერებში: Chrome 38+, Firefox და Opera 25+ და Safari 7.1+. ამას შეამჩნევთ Internet Explorerარ არის ამ სიაში, მაგრამ თქვენ იპოვით პოლიფილს MDN-ზე.

მაგალითები

Math.pow(1.25, 2); > 1.5625 მათემატიკა.cbrt(56.57) > 3.8387991760286138
გთხოვთ გაითვალისწინოთ, რომ ეს ასევე კარგად მუშაობს უარყოფითი არგუმენტების მნიშვნელობების გამოყენებისას:

Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
თუმცა, ეს არ იმუშავებს კვადრატული ფესვისთვის:

მათე.sqrt(-9) > NaN
მათემატიკური ანალიზიდან ვიცით, რომ წარმოსახვითი რიცხვი აღნიშნავს უარყოფითი რიცხვების კვადრატულ ფესვებს. და ამან შეიძლება მიგვიყვანოს კომპლექსურ რიცხვებთან მუშაობის სხვა ტექნიკამდე, მაგრამ ეს სხვა ამბავია.

თქვენ შეგიძლიათ გამოიყენოთ წილადები Math.pow()-ში, რათა იპოვოთ რიცხვების კვადრატული და კუბური ფესვები. კვადრატული ფესვი იყენებს 0,5 მაჩვენებელს:

Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
თუმცა, მცურავი წერტილის ცვალებადობის გამო, ზუსტად ვერ გამოიცნობთ სწორ შედეგს:

Math.pow(2.23606797749979,2) > 5.0000000000000001
ასეთ სიტუაციებში მოგიწევთ მიმართოთ ნიშნების ამოჭრას რიცხვიდან ან დამრგვალებამდე.

ზოგიერთი ადამიანი, გაურკვეველი მიზეზების გამო, JavaScript-ში ურევს Math.pow() ფუნქციას Math.exp()-თან, რომელიც ზოგადად რიცხვების ექსპონენციალური ფუნქციაა. შენიშვნა: in ინგლისური"ექსპონენტი" ითარგმნება როგორც "ექსპონენტი", ამიტომ ეს უფრო მეტად ეხება ინგლისურენოვანებს, თუმცა არსებობს მაჩვენებლის ალტერნატიული სახელები, როგორიცაა ინდექსი, სიმძლავრე.

მათემატიკური მუდმივები

Math.abs, parseInt, parseFloat

Math.abs()

მოდით newVal = -57.64; Math.abs(newVal); > 57.64
Math.abs(0) ყოველთვის აბრუნებს ნულს, მაგრამ თუ -Math.abs(NUM) ფუნქციის წინ დავაყენებთ მინუს ნიშანს, ყოველთვის მივიღებთ უარყოფით მნიშვნელობას.

მათემატიკა.აბს(0); > -0

parseInt()

სინტაქსი: parseInt(სტრიქონი, რადიქსი);

parseInt ფუნქცია გარდაქმნის მასზე გადაცემულ პირველ არგუმენტს სტრიქონის ტიპად, ინტერპრეტაციას უკეთებს მას და აბრუნებს მთელ რიცხვს ან NaN მნიშვნელობას. შედეგი (თუ არა NaN) არის მთელი რიცხვი და არის პირველი არგუმენტი (სტრიქონი), რომელიც განიხილება როგორც რიცხვი მითითებულ რადიქსში. მაგალითად, ფუძე 10 მიუთითებს კონვერტაციაზე ათობითიდან, 8 რვადან, 16 თექვსმეტობით და ა.შ. თუ საფუძველი 10-ზე მეტია, მაშინ ასოები გამოიყენება 9-ზე მეტი რიცხვების გამოსასახად. მაგალითად, თექვსმეტობითი რიცხვებისთვის (ფუძე 16) გამოიყენება ასოები A-დან F-მდე.

მოდით შევხედოთ CSS თვისებებთან მუშაობის მაგალითს, სადაც, შედარებით რომ ვთქვათ, შეგვიძლია მივიღოთ შემდეგი მნიშვნელობა:

მოდით elem = დოკუმენტი.სხეული; მოდით centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
ჩვენ შეგვიძლია გავყოთ მნიშვნელობები ინტერვალით:

მოდით ცენტრები = centerPoint.split(" "); > ["454px", "2087.19px"]
თუმცა, თითოეული ელემენტი მაინც არის სტრიქონი, ჩვენ შეგვიძლია მოვიშოროთ ეს ჩვენი ფუნქციის გამოყენებით:

მოდით ცენტრიX = parseInt(ცენტრები, 10); > 454 მოდით centerY = parseInt(ცენტრები, 10); > 2087 წ
როგორც ხედავთ, მეორე არგუმენტით მივუთითებთ რიცხვთა სისტემას, რომელშიც გადაიყვანება ეს პარამეტრი, მაგრამ რეკომენდებულია მისი გამოყენება, თუ არ იცით რომელი სტრიქონი მიიღება შეყვანის სახით.

parseFloat()

სინტაქსი: parseFloat (სტრიქონი)

მოდით FP = "33.33333%"; console.log(parseFloat(FP)); > 33.33333
გაითვალისწინეთ, რომ არ არის მეორე არგუმენტი parseFloat სინტაქსში.

ჩვენ გვესმის, რომ parseInt() და parseFloat() უკიდურესადაა სასარგებლო თვისებები, მნიშვნელოვანია აღინიშნოს, რომ ჯერ კიდევ არის გარკვეული შეცდომები, ამიტომ აუცილებელია შეამოწმოთ მოსალოდნელი მნიშვნელობების დიაპაზონი და საბოლოოდ გავაანალიზოთ შედეგი, რათა დარწმუნდეთ, რომ მიღებული მნიშვნელობები სწორია.
გაგზავნეთ ანონიმურად

ამ სტატიაში დეტალურად განვიხილავთ ციფრებს, მათემატიკურ ოპერატორებს, რიცხვის სტრიქონად გადაქცევის გზებს და პირიქით, ასევე ბევრ სხვა მნიშვნელოვან პუნქტს.

არის სასრული ფუნქცია

IsFinite ფუნქცია საშუალებას გაძლევთ შეამოწმოთ არის თუ არა არგუმენტი სასრული რიცხვი.

საპასუხოდ, ეს ფუნქცია აბრუნებს false-ს, თუ არგუმენტი არის Infinity, -Infinity, NaN, ან გადაიცემა ერთ-ერთ ამ სპეციალურ ციფრულ მნიშვნელობაზე. წინააღმდეგ შემთხვევაში, ეს ფუნქცია დაბრუნდება true.

IsFinite(73); // true isfinite(-1/0); // false isFinite(Infinity); // false isFinite(NaN); // false isFinite("ტექსტი"); // ცრუ

გლობალური isFinite ფუნქციის გარდა, JavaScript-ს აქვს Number.isFinite მეთოდიც. isFinite-ისგან განსხვავებით, ის არ აიძულებს არგუმენტს გადაიყვანოს რიცხვად.

IsFinite ("73"); // true Number.isFinite("73"); // ცრუ

isNaN ფუნქცია

isNaN ფუნქცია შექმნილია იმის დასადგენად, არის თუ არა არგუმენტი რიცხვი ან შეიძლება გადაკეთდეს ერთში. თუ ასეა, მაშინ isNaN ფუნქცია აბრუნებს false-ს. წინააღმდეგ შემთხვევაში, ის უბრუნდება სიმართლეს.

IsNaN(NaN); //true isNaN("25px"); //მართალია, რადგან 20px არ არის რიცხვი isNaN(25.5); //false isNaN("25.5"); //false isNaN(" "); //ცრუ, რადგან სივრცე ან რამდენიმე სივრცე გარდაიქმნება 0-ში isNaN(null); //ცრუ, რადგან null გარდაიქმნება 0-ად isNaN(true); //ცრუ, რადგან true გარდაიქმნება 1-ად isNaN(false); //ცრუ, რადგან false გარდაიქმნება 0-ად

თუ ეს მოქმედება უნდა შესრულდეს ტიპის cast-ის გარეშე, გამოიყენეთ Number.isNaN მეთოდი. ეს მეთოდი დაინერგა ენაში ECMAScript 6-დან დაწყებული.

როგორ გადავიტანოთ სტრიქონი რიცხვად?

თქვენ შეგიძლიათ ცალსახად გადაიყვანოთ სტრიქონი რიცხვად შემდეგი მეთოდების გამოყენებით:

1. გამოყენება ერთიანი ოპერატორი +, რომელიც უნდა განთავსდეს მნიშვნელობამდე.

+"7.35"; // 7.35 +"ტექსტი"; // NaN

ეს მეთოდი იგნორირებას უკეთებს სივრცეებს ​​ხაზის დასაწყისში და ბოლოს, ისევე როგორც \n (ხაზის მიწოდება).

+" 7.35"; //7.35 +"7.35 \n"; //7.35

ამ მეთოდის გამოყენებით, ყურადღება უნდა მიაქციოთ იმ ფაქტს, რომ ცარიელი სტრიქონი ან სტრიქონი, რომელიც შედგება შუალედებისგან და \n, გარდაიქმნება რიცხვად 0. გარდა ამისა, ის ასევე გარდაქმნის null მონაცემთა ტიპს და ლოგიკურ მნიშვნელობებს რიცხვად. .

ნულოვანი; //0 +true; //1 +მცდარი; //0 +" "; //0

2. ParseInt ფუნქცია. ეს ფუნქცია შექმნილია კონვერტაციისთვის არგუმენტი მთელ რიცხვამდე. გამოყენებისგან განსხვავებით ერთიანი ოპერატორი +, ეს მეთოდი საშუალებას გაძლევთ გადაიყვანოთ სტრიქონი რიცხვად, რომელშიც ყველა სიმბოლო არ არის რიცხვითი. ის იწყებს სტრიქონის გარდაქმნას, დაწყებული პირველი სიმბოლოდან. და როგორც კი შეხვდება არარიცხოვან სიმბოლოს, ეს ფუნქცია წყვეტს მუშაობას და აბრუნებს მიღებულ რიცხვს.

ParseInt ("18px"); //18 parseInt("33.3%"); //33

ამ ფუნქციას შეუძლია იმუშაოს სხვადასხვა რიცხვების სისტემებთან (ორობითი, ოქტალური, ათობითი, თექვსმეტობითი). რიცხვითი სისტემის საფუძველი მითითებულია 2 არგუმენტის გამოყენებით.

ParseInt("18px", 10); //18 parseInt("33.3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

გარდა parseInt ფუნქციისა, JavaScript-ს აქვს Number.parseInt მეთოდი. ეს მეთოდი არაფრით განსხვავდება parseInt ფუნქციისგან და დაინერგა JavaScript-ში ECMASCRIPT 2015 (6) სპეციფიკაციით.

3. parseFloat ფუნქცია. parseFloat ფუნქცია მსგავსია parseInt-ის, გარდა იმისა, რომ ის საშუალებას გაძლევთ გადაიყვანოთ არგუმენტი წილად რიცხვად.

ParseFloat ("33.3%"); //33.3

გარდა ამისა, parseFloat ფუნქციას, parseInt-ისგან განსხვავებით, არ აქვს 2 არგუმენტი და ამიტომ ის ყოველთვის ცდილობს სტრიქონი განიხილოს, როგორც რიცხვი ათობითი აღნიშვნის სისტემაში.

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

გარდა parseFloat ფუნქციისა, JavaScript-ს აქვს Number.parseFloat მეთოდი. ეს მეთოდი არაფრით განსხვავდება parseFloat ფუნქციისგან და დაინერგა JavaScript-ში ECMASCRIPT 2015 (6) სპეციფიკაციით.

რიცხვის სტრიქონად გადაქცევა

შეგიძლიათ რიცხვი გადააქციოთ სტრიქონად toString მეთოდის გამოყენებით.

(12.8).toString(); //"12.8"

toString მეთოდი ასევე საშუალებას გაძლევთ მიუთითოთ რიცხვითი სისტემის საფუძველი, იმის გათვალისწინებით, თუ რომელი რიცხვი მკაფიოდ უნდა გადაიყვანოთ სტრინგად:

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

როგორ შევამოწმოთ არის თუ არა ცვლადი რიცხვი

თქვენ შეგიძლიათ განსაზღვროთ არის თუ არა ცვლადის მნიშვნელობა რიცხვი შემდეგი მეთოდის გამოყენებით:

1. isNaN და isFinite ფუნქციების გამოყენება:

// myVar არის ცვლადი, თუ (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar არის რიცხვი ან შესაძლებელია მასზე გადაცემა);

როგორც ფუნქცია:

// ფუნქციის ფუნქცია არის Numeric(მნიშვნელობა) (დაბრუნება !isNaN(parseFloat(მნიშვნელობა)) && isFinite(parseFloat(მნიშვნელობა)); ) // გამოიყენეთ var myVar = "12px"; console.log(isNumeric(myVar)); //მართალია

ეს მეთოდი საშუალებას გაძლევთ განსაზღვროთ არის თუ არა მითითებული მნიშვნელობა რიცხვი ან შეიძლება გადაიზარდოს ერთზე. ეს ოფცია არ ითვლის ცარიელ სტრიქონს, სივრცეების სტრიქონს, null, Infinity, -Infinity, true და false რიცხვად.

2. ოპერატორის ტიპისა და isFinite, isNaN ფუნქციების გამოყენებით:

// ფუნქცია, რომელიც ამოწმებს არის თუ არა მნიშვნელობა რიცხვითი ფუნქცია არისNumber(მნიშვნელობა) (დაბრუნების მნიშვნელობის ტიპი ==="number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

ეს ფუნქცია განსაზღვრავს არის თუ არა მითითებული მნიშვნელობა Number-ის ტიპისა და არის თუ არა ერთ-ერთი სპეციალური მნიშვნელობა Infinity, -Infinity და NaN. თუ ასეა, მაშინ ეს ფუნქცია ბრუნდება true.

3. ECMAScript 6 Number.isInteger(მნიშვნელობის) მეთოდის გამოყენებით. ეს მეთოდი საშუალებას გაძლევთ განსაზღვროთ არის თუ არა მითითებული მნიშვნელობა მთელი რიცხვი.

Number.isInteger("20"); //ცრუ, რადგან ეს მეთოდი არ გარდაქმნის სტრიქონს რიცხვად Number.isInteger(20); //მართალია, რადგან ეს მნიშვნელობა არის რიცხვი

ლუწი და კენტი რიცხვები

შეგიძლიათ შეამოწმოთ რიცხვი ლუწი თუ კენტი შემდეგი ფუნქციების გამოყენებით:

// ლუწი პარიტეტის ფუნქციისთვის რიცხვის შემოწმების ფუნქცია არისEven(n) ( აბრუნებს n % 2 == 0; ) // კენტი პარიტეტის ფუნქციისთვის რიცხვის შემოწმების ფუნქცია isOdd(n) ( დაბრუნება Math.abs(n % 2) == 1;

მაგრამ ასეთი შემოწმების ჩატარებამდე მიზანშეწონილია დარწმუნდეთ, რომ მითითებული მნიშვნელობა არის რიცხვი:

მნიშვნელობა = 20; if (Number.isInteger(მნიშვნელობა)) (if (isEven(მნიშვნელობა)) ( console.log("Number" + value.toString() + " - ლუწი"); ) )

ძირითადი რიცხვები Javascript-ში

მოდით შევხედოთ მაგალითს, რომელშიც გამოვაჩენთ მარტივ რიცხვებს 2-დან 100-მდე Javascript-ის გამოყენებით.

// ფუნქცია, რომელიც ამოწმებს არის თუ არა რიცხვი პირველი ფუნქცია არისPrime(მნიშვნელობა) (if (isNaN(მნიშვნელობა) || !isFinite(მნიშვნელობა) || მნიშვნელობა%1 || მნიშვნელობა< 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);

რიცხვის დამრგვალება Javascript-ში

JavaScript-ში წილადის მთელ რიცხვზე დამრგვალების სხვადასხვა გზა არსებობს.

1. ამისთვის სპეციალურად შექმნილი Math.floor, Math.ceil და Math.round მეთოდების გამოყენება. Math.floor მეთოდი ამრგვალებს წილადს უახლოეს მთელ რიცხვამდე, ე.ი. უბრალოდ უგულებელყოფს წილადის ნაწილს. Math.ceil ამრგვალებს წილადს უახლოეს მთელ რიცხვამდე. Math.round ამრგვალებს რიცხვს ზემოთ ან ქვემოთ, წილადი ნაწილის მნიშვნელობიდან გამომდინარე. თუ წილადი ნაწილი მეტია ან ტოლია 0,5-ზე, მაშინ ზემოთ, წინააღმდეგ შემთხვევაში გადახვევა არის ქვემოთ.

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

2. toFixed (ზუსტი) მეთოდის გამოყენებით. ეს მეთოდი ამრგვალებს რიცხვის წილად ნაწილს მითითებულ სიზუსტემდე. დამრგვალების შედეგი ბრუნდება სტრიქონის სახით.

Console.log(7.987.toFixed(2)); //"7.99"

თუ არ არის საკმარისი ათწილადი რიცხვის განსაზღვრული სიზუსტის ფორმირებისთვის, მაშინ ის ივსება ნულებით.

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

3. toPrecision(accuracy) მეთოდის გამოყენება. ეს მეთოდი წარმოადგენს რიცხვს მითითებული სიზუსტით. ამავდროულად, მას შეუძლია დამრგვალოს არა მხოლოდ წილადი, არამედ რიცხვის მთელი ნაწილი. შედეგიდან გამომდინარე, ამ მეთოდს შეუძლია წარმოადგინოს მიღებული რიცხვი ფიქსირებული წერტილით ან ექსპონენციალური ფორმით.

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

4. ლოგიკური ოპერატორების NOT ან OR გამოყენება.

//ორმაგი ლოგიკური უარყოფის კონსოლის მეშვეობით.log(~~7.9); //7 // ლოგიკური ან ნულის გამოყენებით: console.log(7.9^0); //7

რიცხვის მთელი და წილადი ნაწილი

შეგიძლიათ მიიღოთ რიცხვის მთელი ნაწილი Math.floor() და parseInt() მეთოდების გამოყენებით:

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

თქვენ შეგიძლიათ მიიღოთ რიცხვის წილადი ნაწილი პროცენტული (%) ოპერატორის გამოყენებით. ეს ოპერატორი აბრუნებს ნარჩენს, რომელიც მიიღება პირველი რიცხვის მეორეზე გაყოფით. ამ შემთხვევაში, თქვენ უნდა გამოიყენოთ 1, როგორც მე-2 ნომერი.

Console.log (7.21%1); // 0.20999999999999996 // ზუსტი 2 ათობითი ადგილის ჩათვლით console.log((7.21%1).toFixed(2)); // "0.21"

გარდა ამისა, წილადი ნაწილის მიღება ასევე შესაძლებელია გამოთვლების გამოყენებით:

Var ნომერი = 7.21; var fractionNumber = ნომერი - Math.floor(Math.abs(number)); console.log(fractionNumber); // 0.20999999999999996

რიცხვი იყოფა მთელ რიცხვზე?

თქვენ შეგიძლიათ განსაზღვროთ არის თუ არა რიცხვი მთელ რიცხვზე პროცენტული ოპერატორის გამოყენებით:

Var ნომერი = 9; // თუ 3-ზე გაყოფილი რიცხვის ნაშთი არის 0, მაშინ დიახ, წინააღმდეგ შემთხვევაში არა, თუ (number%3==0) ( console.log ("რიცხვი " + რიცხვი + " იყოფა 3-ზე); ) else ( კონსოლი log ("ნომერი " + ნომერი + " არ იყოფა 3-ზე" );

ნომრების ფორმატირება

JavaScript-ში, toLocaleString() მეთოდი საშუალებას გაძლევთ დაფორმატოთ რიცხვის გამომავალი რეგიონალური სტანდარტების შესაბამისად (ოპერაციული სისტემის ენობრივი პარამეტრები).

მაგალითად, მოდით დავაფორმოთ ნომერი რეგიონალური სტანდარტების შესაბამისად, რომლებიც სისტემაში სტანდარტულად არის დაინსტალირებული:

Var ნომერი = 345,46; console.log(number.toLocaleString()); //"345.46"

მაგალითად, მოდით დავაფორმოთ ნომერი რუსეთის რეგიონალური სტანდარტების შესაბამისად (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

ეს მეთოდი ასევე შეიძლება გამოყენებულ იქნას რიცხვის ვალუტად ფორმატირებისთვის:

Console.log((2540.125).toLocaleString("ru-RU",(სტილი:"ვალუტა", ვალუტა:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(სტილი:"ვალუტა", ვალუტა:"USD"))); //"89.30 $" console.log((2301.99).toLocaleString("ru-RU",(სტილი:"ვალუტა", ვალუტა:"EUR"))); //"2,301,99 ევრო"

რიცხვის პროცენტულად წარმოდგენა:

Console.log((0.45).toLocaleString("ru-RU",(სტილი:"პროცენტი"))); //"45%"

დაყავით რიცხვი ციფრებად (useGrouping თვისება):

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

დაბეჭდეთ რიცხვი გარკვეული რაოდენობის ციფრებით (2) ათობითი წერტილის შემდეგ:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1,240.46"

რიცხვების შედარება

JavaScript-ში რიცხვების შესადარებლად გამოიყენება შემდეგი ოპერატორები: == (ტოლი), != (არა ტოლი), > (უფრო მეტი),< (меньше), >= (უფრო მეტი ან ტოლი),<= (меньше или равно).

მაგალითად, შევადაროთ ორი რიცხვი:

Console.log(2>3); //false console.log(5>=3); //მართალია

წილადის ნაწილთან რიცხვების შედარებისას აუცილებელია გავითვალისწინოთ ის შეცდომები, რომლებიც შეიძლება წარმოიშვას ამ გამოთვლების დროს.

მაგალითად, JavaScript-ში რიცხვების ჯამი (0.2 + 0.4) არ უდრის 0.6-ს:

Console.log((0.2+0.4)==0.6); //ცრუ

შეცდომები ხდება იმის გამო, რომ კომპიუტერი ან სხვა ელექტრონული მოწყობილობა ასრულებს ყველა გამოთვლას მე-2 ნომრის სისტემაში. იმათ. ნებისმიერი მოქმედების შესრულებამდე კომპიუტერმა ჯერ უნდა გადაიყვანოს გამოთქმაში წარმოდგენილი რიცხვები მე-2 რიცხვების სისტემაში. მაგრამ ყველა წილადი ათობითი რიცხვი არ შეიძლება ზუსტად იყოს წარმოდგენილი მე-2 რიცხვთა სისტემაში.

მაგალითად, რიცხვი 0.25 10 გარდაიქმნება ბინარულად ზუსტად.

0,125 × 2 = 0,25 | 0 0,25 × 2 = 0,5 | 0 0.5 × 2 = 1 | 1 0,125 10 = 0,001 2

მაგალითად, რიცხვი 0.2 10 შეიძლება გარდაიქმნას 2 სისტემაში მხოლოდ გარკვეული სიზუსტით:

0,2 × 2 = 0,4 | 0 0.4 × 2 = 0.8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0.4 × 2 = 0.8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 0,2 × 2 = 0,4 | 0 0.4 × 2 = 0.8 | 0 0,8 × 2 = 1,6 | 1 0,6 × 2 = 1,2 | 1 ... 0.2 10 = 0.001100110011... 2

შედეგად, ეს შეცდომები გავლენას მოახდენს ორი რიცხვის ჯამის გამოთვლაზე და შედარების შედეგებზე. იმათ. გამოდის, რომ JavaScript რეალურად დაინახავს ამ ჩანაწერს შემდეგნაირად:

0.6000000000000001==0.6

წილადი ნაწილებით რიცხვების გამოთვლის ან ჩვენებისას ყოველთვის უნდა მიუთითოთ სიზუსტით, რომლითაც გსურთ ამის გაკეთება.

მაგალითად, შეადარეთ რიცხვები 2 ათობითი ადგილამდე toFixed() და toPrecision() მეთოდების გამოყენებით:

//მეთოდი toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //metod toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //მართალია

ძირითადი მათემატიკის ოპერაციები

შემდეგი მათემატიკური ოპერატორები არსებობს JavaScript-ში: + (მიმატება), - (გამოკლება), * (გამრავლება), / (გაყოფა), % (მოდული), ++ (მნიშვნელობის გაზრდა 1-ით), -- (მნიშვნელობის შემცირება 1).

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0, ე.ი. 6:3=2 => 6-3*2 => დასვენება(0) 5%2 //1, ე.ი. 5:2=2(.5) => 5-2*2 => დანარჩენი (1) 7.3%2 //1.3, ე.ი. 7.3:2=3(.65) => 7.3-2*3 => დასვენება(1.3) //% ოპერაციის შედეგის ნიშანი უდრის პირველი მნიშვნელობის ნიშანს -9%2.5 //-1.5 , ე.ი. 9:2.5=3(.6) => 9-2.5*3 => დასვენება (1.5) -9%-2.5 //-1.5, ე.ი. 9:2.5=3(.6) => 9-2.5*3 => დასვენება (1.5) -2%5 //-2, ე.ი. 2:5=0(.4) => 2-5*0 => დასვენება(2) x = 3; console.log(x++); //გამოსცემს 3, შემდეგ აყენებს 4 console.log(x); //4 x = 3; console.log(++x); //ნაკრები 4 და გამოაქვს x = 5; console.log(x--); //გამოაქვს 5, შემდეგ აყენებს 4 console.log(x); //4 x = 5; console.log(--x); //4 ნაკრები და გამომავალი გამომავალი გარდა ამისა, JavaScript-ს აქვს კომბინირებული ოპერატორები: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y).