ამ სტატიაში უფრო დეტალურად გაეცნობიან ციფრებს, მათემატიკურ ოპერატორებს, რიცხვის სიმებად გადაქცევის გზებს და პირიქით, ისევე როგორც ბევრ სხვა მნიშვნელოვან პუნქტს.
IsFinite ფუნქცია
IsFinite ფუნქცია საშუალებას გაძლევთ შეამოწმოთ არის თუ არა არგუმენტი სასრული.
ამის საპასუხოდ, ეს ფუნქცია ცრუ ბრუნდება, თუ არგუმენტი Infinity, -Infinity, NaN, ან გადაეცემა რომელიმე ამ სპეციალურ ციფრულ მნიშვნელობას. წინააღმდეგ შემთხვევაში, ეს ფუნქცია დაბრუნდება ჭეშმარიტი.
IsFinite (73); // true isFinite (-1/0); // false isFinite (უსასრულობა); // false isFinite (NaN); // false isFinite ("ტექსტი"); // ყალბი
გლობალური ფუნქციის გარდა isFinite, JavaScript– ს ასევე აქვს Number.isFinite მეთოდი. IsFinite- ისგან განსხვავებით, იგი არ აიძულებს არგუმენტს რიცხვისკენ.
IsFinite ("73"); // ნამდვილი რიცხვი. დაუსრულებელია ("73"); // ყალბი
IsNaN ფუნქცია
IsNaN ფუნქცია შექმნილია იმის დასადგენად, არის თუ არა არგუმენტი რიცხვი ან შეიძლება გარდაიქმნას მასში. თუ ასეა, მაშინ isNaN ფუნქცია ცრუ ხდება. წინააღმდეგ შემთხვევაში, ის ნამდვილი ხდება.
IsNaN (NaN); // true isNaN ("25px"); // მართალია, რადგან 20px არ არის რიცხვი isNaN (25.5); // false isNaN ("25.5"); // false isNaN (""); // ყალბი, რადგან სივრცე ან რამდენიმე სივრცე გარდაიქმნება 0 isNaN (null); // ყალბი, რადგან null გადაკეთებულია 0 isNaN (ნამდვილი); // ყალბი, რადგან true გადაკეთებულია 1 isNaN- ში (false); // ყალბი, რადგან false გადაქცეულია 0-ად
თუ ეს მოქმედება უნდა შესრულდეს ტიპის კასტინგის გარეშე, გამოიყენეთ Number.isNaN მეთოდი. ეს მეთოდი შემოვიდა ენაში ECMAScript 6-ის შემდეგ.
როგორ შემიძლია მკაფიოდ გარდაქმნას სიმები რიცხვში?
შეგიძლიათ მკაფიოდ გადააკეთოთ სიმები რიცხვში შემდეგი მეთოდების გამოყენებით:
1. გამოიყენეთ უნარი + ოპერატორიუნდა განთავსდეს მნიშვნელობამდე.
+ "7.35"; // 7.35 + "ტექსტი"; // NaN
ეს მეთოდი უგულებელყოფს წამყვანი და ჩამორჩენილი თეთრი სივრცის და \\ n (ხაზის არხი).
+ "7.35"; //7.35 + "7.35 \\ n"; //7.35
ამ მეთოდის გამოყენებით ყურადღება უნდა მიაქციოთ იმ ფაქტს, რომ ცარიელი სტრიქონი ან სტრიქონი, რომელიც შედგება სივრცეებისაგან და \\ n ითარგმნება რიცხვში 0. გარდა ამისა, იგი ასევე გარდაქმნის მონაცემთა ნულოვან ტიპს და ლოგიკურ მნიშვნელობებს რიცხვში. .
ნული; // 0 + სიმართლე; // 1 + ყალბი; // 0 + ""; // 0
2. parseInt ფუნქცია. ეს ფუნქცია შექმნილია გარდაქმნისთვის არგუმენტი მთელი რიცხვისთვის... გამოყენებას ეწინააღმდეგებოდა უნიარული ოპერატორი +, ეს მეთოდი საშუალებას გაძლევთ სტრიქონი გადააკეთოთ რიცხვში, რომელშიც ყველა სიმბოლო არ არის რიცხვითი... ის სტრიქონის გარდაქმნას იწყებს პირველი სიმბოლოდან. როგორც კი მას წააწყდება სიმბოლო, რომელიც არ არის ციფრული, ეს ფუნქცია აჩერებს მის მუშაობას და აბრუნებს მიღებულ რიცხვს.
ParseInt ("18 პიქსელი"); // 18 parseInt ("33.3%"); // 33
ამ ფუნქციას შეუძლია იმუშაოს სხვადასხვა რიცხვითი სისტემებით (ორობითი, ოქტალი, ათობითი, თექვსმეტობითი). რადიქსი მითითებულია 2 არგუმენტის გამოყენებით.
ParseInt ("18 პიქსელი", 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). To String (); // "12.8"
ToString მეთოდი ასევე საშუალებას გაძლევთ მიუთითოთ რიცხვითი სისტემის საფუძველი, იმის გათვალისწინებით, რომ საჭიროა რიცხვის პირდაპირ სტრიქონირება სტრიქონზე:
(255). To String (16); // "ff"
როგორ გადავამოწმოთ არის თუ არა ცვლადი რიცხვი
შეგიძლიათ დაადგინოთ არის თუ არა ცვლადი მნიშვნელობა რიცხვი შემდეგი მეთოდების გამოყენებით:
1. isNaN და isFinite ფუნქციების გამოყენება:
// myVar არის ცვლადი, თუ (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar)))) (// myVar არის რიცხვი, ან მისი გადაცემა შესაძლებელია);
როგორც ფუნქცია:
// ფუნქციის ფუნქცია არისNumeric (მნიშვნელობა) (დაბრუნება! isNaN (parseFloat (მნიშვნელობა)) && isFinite (parseFloat (მნიშვნელობა));) // გამოიყენოთ var myVar \u003d "12px"; console.log (isNumeric (myVar)); // მართალია
ეს მეთოდი საშუალებას გაძლევთ დაადგინოთ, არის თუ არა მითითებული მნიშვნელობა რიცხვი, ან შეიძლება მისი გარდაქმნა. ეს ვარიანტი არ განიხილავს ცარიელ სტრიქონს, სივრცის სტრიქონს, null- ს, Infinity, -Infinity, true ან false როგორც რიცხვს.
2. ოპერატორის ტიპის და isFinite, isNaN ფუნქციების გამოყენება:
// ფუნქცია, რომელიც ამოწმებს არის თუ არა მნიშვნელობა რიცხვის ფუნქცია არის ნომერი (მნიშვნელობა) (მნიშვნელობის დაბრუნების ტიპი \u003d\u003d\u003d "(! LANG: number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}
ეს ფუნქცია განსაზღვრავს არის თუ არა მითითებული მნიშვნელობა ტიპის Number და ერთ-ერთი განსაკუთრებული მნიშვნელობა Infinity, -Infinity და NaN. თუ ასეა, მაშინ ეს ფუნქცია უბრუნდება სიმართლეს.
3. ECMAScript 6 ნომრის გამოყენება. არის ინტეგრირებული (მნიშვნელობა) მეთოდი. ეს მეთოდი საშუალებას გაძლევთ დაადგინოთ არის თუ არა მითითებული მნიშვნელობა მთელი რიცხვი.
Number.isInteger ("20"); // ყალბი, რადგან ეს მეთოდი არ ასრულებს Number.isInteger (20) ხაზის მიწოდებას. // მართალია, რადგან მოცემული მნიშვნელობა არის რიცხვი
ლუწი და კენტი რიცხვები
შეგიძლიათ შეამოწმოთ არის თუ არა რიცხვი ლუწი ან კენტი შემდეგი ფუნქციების გამოყენებით:
// ფუნქციის თანაბარი ფუნქციის ნომრის შემოწმება არის even (n) (დაბრუნების n% 2 \u003d\u003d 0;) // უცნაური ფუნქციის ნომრის შემოწმების ფუნქცია არისOdd (n) (დაბრუნება Math.abs (n% 2) \u003d\u003d 1;)
მაგრამ ასეთი შემოწმების გაკეთებამდე სასურველია დარწმუნდეთ, რომ მითითებული მნიშვნელობა არის რიცხვი:
მნიშვნელობა \u003d 20; if (Number.isInteger (მნიშვნელობა)) (if (isEven (მნიშვნელობა)) (console.log ("Number" + value.toString () + "- even");))
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 მრგვალდება ფრაქციული რიცხვის უახლოეს მთელ რიცხვამდე. მათემატიკა. გარშემო მრგვალდება რიცხვი ზემოთ ან ქვემოთ, ფრაქციული ნაწილის მნიშვნელობის მიხედვით. თუ ფრაქციული ნაწილი უფრო დიდია ან ტოლი 0,5-ისა, მაშინ ზემოთ, წინააღმდეგ შემთხვევაში დახვევა ქვევით.
Console.log (მათემატიკის სართული (7.9)); // 7 console.log (Math.ceil (7.2)); // 8 console.log (მათემატიკის გარშემო (7.5)); // 8
2. ფიქსირებული (ზუსტი) მეთოდის გამოყენება. ეს მეთოდი მრგვალდება რიცხვის ფრაქციულ ნაწილზე მითითებული სიზუსტით. დამრგვალების შედეგი ბრუნდება სიმებად.
Console.log (7.987.toFixed (2)); // "7.99"
თუ არ არის საკმარისი ათობითი ადგილები, რომ განსაზღვროს რიცხვის მითითებული სიზუსტე, მაშინ ის ივსება ნულებით.
Console.log (7.987.toFixed (5)); // "7.98700"
3. toPrecision მეთოდით. ეს მეთოდი წარმოადგენს რიცხვს მითითებული სიზუსტით. უფრო მეტიც, მას შეუძლია რიცხვის არა მხოლოდ წილადის, არამედ მთლიანი ნაწილის დამრგვალება. ამ მეთოდს შეუძლია წარმოადგინოს მიღებული რიცხვი, შედეგის მიხედვით, ფიქსირებული წერტილით ან ექსპონენციალური ფორმით.
Console.log ((1001). ზუსტი (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 (მათემატიკის სართული (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"
გარდა ამისა, ფრაქციული ნაწილის მიღება ასევე შეგიძლიათ გამოთვლების გამოყენებით:
ვარი ნომერი \u003d 7,21; var fractionNumber \u003d number - Math.floor (მათემატიკის აბები (რიცხვი)); console.log (ფრაქცია ნომერი); // 0.20999999999999996
რიცხვიც კი იყოფა
შეგიძლიათ განსაზღვროთ, თანაბრად იყოფა თუ არა რიცხვი პროცენტული ოპერატორის გამოყენებით:
ვარი ნომერი \u003d 9; // თუ რიცხვის გაყოფის დარჩენილი ნაწილი 3-ზე არის 0, მაშინ კი, წინააღმდეგ შემთხვევაში არა თუ (რიცხვი% 3 \u003d\u003d 0) (console.log ("ნომერი" + რიცხვი + "იყოფა 3-ზე);) სხვა (კონსოლი. ჟურნალი ("ნომერი" + ნომერი + "არ იყოფა 3-ზე");)
ციფრების ფორმატირება
JavaScript- ში, toLocaleString () მეთოდი საშუალებას გაძლევთ დააფორმატოთ რიცხვის გამომუშავება რეგიონალური (ოპერაციული სისტემის) ენის პარამეტრების შესაბამისად.
მაგალითად, მოდით ფორმატში გავაფორმოთ ნომერი რეგიონული სტანდარტების შესაბამისად, რომლებიც სტანდარტულად არის დაინსტალირებული სისტემაში:
ვარი ნომერი \u003d 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%"
რიცხვის გაყოფა ციფრებად (გამოიყენეთ ჯგუფის თვისება):
Console.log ((125452.32) .toLocaleString ("ru-RU", (useGroupping: true))); // "125 452.32"
ათობითი წერტილიდან ციფრის გარკვეული რაოდენობის (2) დაბეჭდვა:
Console.log ((1240.4564) .toLocaleString ("ru-RU", (minimumFactionDigits: 2, maximumFactionDigits: 2))); // "1 240.46"
რიცხვების შედარება
JavaScript იყენებს შემდეგ ოპერატორებს ციფრების შედარების მიზნით: \u003d\u003d (ტოლი),! \u003d (არ არის ტოლი),\u003e (მეტია),< (меньше), >\u003d (მეტია ან ტოლი),<= (меньше или равно).
მაგალითად, მოდით შევადაროთ ორი რიცხვი:
Console.log (2\u003e 3); // false console.log (5\u003e \u003d 3); // მართალია
რიცხვების ფრაქციულ ნაწილებთან შედარებისას საჭიროა გაითვალისწინოთ შეცდომები, რომლებიც შეიძლება წარმოიშვას ამ გამოთვლების დროს.
მაგალითად, JavaScript– ში, რიცხვების ჯამი (0,2 + 0,4) არ არის 0,6:
Console.log ((0.2 + 0.4) \u003d\u003d 0.6); // ყალბი
შეცდომები ხდება, რადგან ყველა გამოთვლა ხორციელდება კომპიუტერის ან სხვა ელექტრონული მოწყობილობის მიერ მე -2 ნომრის სისტემაში. იმ რაიმე მოქმედებების შესრულებამდე, კომპიუტერმა ჯერ უნდა გადააქციოს გამოხატვაში წარმოდგენილი რიცხვები 2 რიცხვით სისტემაში. მაგრამ, არავითარი ფრაქციული ათობითი რიცხვი არ შეიძლება იყოს ზუსტად წარმოდგენილი 2 რიცხვის სისტემაში.
მაგალითად, რიცხვი 0.25 10 ზუსტად გადაქცეულია ორობით სისტემაში.
0,125 2 \u003d 0,25 | 0 0,25 × 2 \u003d 0,5 | 0 0,5 × 2 \u003d 1 | 1 0.125 10 \u003d 0.001 2
მაგალითად, ნომერი 0.2 10 შეიძლება მხოლოდ გარკვეული სიზუსტით გადაიქცეს 2 სისტემად:
0.2 × 2 \u003d 0.4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 0,2 × 2 \u003d 0,4 | 0 0,4 × 2 \u003d 0,8 | 0 0,8 × 2 \u003d 1,6 | 1 0,6 × 2 \u003d 1,2 | 1 ... 0.2 10 \u003d 0.001100110011 ... 2
შედეგად, ეს შეცდომები გავლენას მოახდენს ორი რიცხვის ჯამის გამოთვლასა და შედარების შედეგებზე. იმ აღმოჩნდება, რომ სინამდვილეში JavaScript ამ ჩანაწერს შემდეგნაირად ნახავს:
0.6000000000000001==0.6
წილადური ნაწილის რიცხვების გამოთვლის ან ჩვენებისას, ყოველთვის უნდა მიუთითოთ ის სიზუსტე, რომლითაც ის უნდა გაკეთდეს.
მაგალითად, შეადარეთ რიცხვები 2-მდე ათობითი წერტილით toFixed () და toPrecision () მეთოდების გამოყენებით:
// მეთოდი ფიქსირებული () console.log ((0.2 + 0.4) .toFixed (2) \u003d\u003d (0.6) .toFixed (2)); // true // მეთოდი to Precision () console.log ((0.2 + 0.4). toPrecision (2) \u003d\u003d (0.6) .toPrecision (2)); // მართალია
მათემატიკის ძირითადი მოქმედებები
JavaScript– ში არსებობს შემდეგი მათემატიკური ოპერატორები: + (დამატება), - (გამოკლება), * (გამრავლება), / (გაყოფა),% (მოდული), ++ (მნიშვნელობის გაზრდა 1 – ით), - (მნიშვნელობის შემცირება 1 – ით).
6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, ე.ი. 6: 3 \u003d 2 \u003d\u003e 6-3 * 2 \u003d\u003e დასვენება (0) 5% 2 // 1, ე.ი. 5: 2 \u003d 2 (.5) \u003d\u003e 5-2 * 2 \u003d\u003e დასვენება (1) 7.3% 2 //1.3, ე.ი. 7.3: 2 \u003d 3 (.65) \u003d\u003e 7.3-2 * 3 \u003d\u003e დანარჩენი (1.3) //% ოპერაციის შედეგის ნიშანი უდრის პირველი მნიშვნელობის ნიშანს -9% 2.5 //-1.5 , ე.ი. 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e დასვენება (1.5) -9% -2.5 //-1.5, ე.ი. 9: 2.5 \u003d 3 (.6) \u003d\u003e 9-2.5 * 3 \u003d\u003e დასვენება (1.5) -2% 5 // - 2, ე.ი. 2: 5 \u003d 0 (.4) \u003d\u003e 2-5 * 0 \u003d\u003e დანარჩენი (2) x \u003d 3; console.log (x ++); // ბეჭდავს 3, y ადგენს 4 მოგვიანებით console.log (x); // 4 x \u003d 3; console.log (++ x); // ადგენს 4-ს და ბეჭდავს x \u003d 5; console.log (x--); // ბეჭდავს 5, y ადგენს 4 მოგვიანებით console.log (x); // 4 x \u003d 5; console.log (- x); // ადგენს 4 და შედეგებს. გარდა ამისა, JavaScript– ს აქვს კომბინირებული ოპერატორები: x + \u003d y (x \u003d x + y), x- \u003d y (x \u003d xy), x * \u003d y (x \u003d x * y), x / \u003d y (x \u003d x / y), x% \u003d y (x \u003d x% y). x \u003d 3; y \u003d 6; x + \u003d y; console.log (x); // 9 x \u003d 3; y \u003d 6; x- \u003d y; console.log (x); // - 3 x \u003d 3; y \u003d 6; x * \u003d y; console.log (x); // 18 x \u003d 3; y \u003d 6; x / \u003d y; console.log (x); //0.5 x \u003d 3; y \u003d 6; x% \u003d y; console.log (x); // 3
ხშირად JavaScript– ში გამოთვლები ზუსტად არ იძლევა ჩვენთვის სასურველ შედეგებს. რა თქმა უნდა, ჩვენ შეგვიძლია ყველაფერი გავაკეთოთ ციფრებით - დავაბრუნოთ ზემოთ ან ქვემოთ, დავაყენოთ დიაპაზონები, დავჭრათ ზედმეტი რიცხვები ათწილადი ციფრების გარკვეულ რაოდენობამდე, ეს ყველაფერი დამოკიდებულია იმაზე, თუ რისი გაკეთება გსურთ ამ რიცხვთან მომავალში.რატომ არის საჭირო დამრგვალება?
JavaScript– ის ერთ – ერთი საინტერესო ასპექტი ის არის, რომ ის სინამდვილეში არ ინახავს მთელ რიცხვებს, ჩვენ დაუყოვნებლივ ვმუშაობთ მცურავი წერტილების ციფრებზე. ეს, ამასთან ერთად, რომ მრავალი წილადი მნიშვნელობის გამოხატვა არ შეიძლება ათწილადი სასრული რიცხვებით, JavaScript– ში შეგვიძლია მივიღოთ ასეთი შედეგები:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
პრაქტიკული მიზნებისათვის, ამ უზუსტობას საერთოდ არ აქვს მნიშვნელობა, ჩვენს შემთხვევაში საუბარია კვინტილიონის ნაწილების შეცდომაზე, თუმცა, ამან შეიძლება ვინმეს იმედი გაუცრუოს. ჩვენ შეგვიძლია მივიღოთ ოდნავ უცნაური შედეგი იმ ციფრებთან მუშაობისას, რომლებიც წარმოადგენს ვალუტის, პროცენტის ან ფაილის ზომის მნიშვნელობებს. ამ უზუსტობების გამოსასწორებლად, ჩვენ უბრალოდ უნდა შეგვეძლოს შედეგების დამრგვალება, ხოლო საკმარისია ათობითი სიზუსტის დაყენება.
რიცხვების დამრგვალებას აქვს პრაქტიკული გამოყენება, ჩვენ შეგვიძლია გარკვეულ დიაპაზონში მანიპულირება გავაკეთოთ, მაგალითად, გვინდა მნიშვნელობა დავამრგვალოთ უახლოეს მთელ რიცხვამდე და არ ვიმუშაოთ მხოლოდ ათობითი ნაწილისთვის.
ათობითი რიცხვების დამრგვალება
ათობითი რიცხვის გასაცნობად გამოიყენეთ toFixed ან toPrecision მეთოდი. ორივე იღებს ერთ არგუმენტს, რომელიც განსაზღვრავს, შესაბამისად, რამდენი მნიშვნელოვანი ციფრია (რიცხვში გამოყენებული ციფრების საერთო რაოდენობა) ან ათობითი ადგილებში (ათწილადის შემდეგ) უნდა შეიცავდეს შედეგს:- თუ არგუმენტი არ არის მითითებული toFixed- ისთვის (), მაშინ ის ნაგულისხმევი იქნება ნულის ტოლი, რაც ნიშნავს 0 ათობითი ნიშანს, არგუმენტის მაქსიმალური მნიშვნელობაა 20.
- თუ სიზუსტისთვის არგუმენტი არ არის მოცემული, ნომერი დარჩება ხელუხლებელი
ToFixed () და toPrecision () აბრუნებს შედეგის სტრიქონულ გამოსახულებას და არა რიცხვს. ეს ნიშნავს, რომ როდესაც მომრგვალებული მნიშვნელობა შეაჯამებს randNum- ს, ეს იქნება სტრიქონების შერწყმა და არა ციფრების ჯამი:
მოდით randNum \u003d 6,25; მოდით rounded \u003d randNum.toFixed (); // "6" console.log (randNum + მომრგვალებული); \u003e "6.256"
თუ გსურთ შედეგს ჰქონდეს ციფრული მონაცემების ტიპი, მაშინ უნდა გამოიყენოთ parseFloat:
მოდით randNum \u003d 6,25; მოდით მომრგვალებული \u003d parseFloat (randNum.toFixed (1)); console.log (მომრგვალებული); \u003e 6.3
გაითვალისწინეთ, რომ 5 მნიშვნელობა მრგვალდება, გარდა იშვიათი შემთხვევებისა.
ToFixed () და toPrecision () მეთოდები სასარგებლოა, რადგან მათ არა მხოლოდ ფრაქციული ნაწილის ჩამოხსნა, არამედ ათწილადების დასრულება შეუძლიათ, რაც მოსახერხებელია ვალუტასთან მუშაობისას:
მოდით wholeNum \u003d 1 მოდით dollarCents \u003d wholeNum.toFixed (2); console.log (დოლარი ცენტი); \u003e "1.00"
გთხოვთ გაითვალისწინოთ, რომ toPrecision მისცემს შედეგს ექსპონენციალური აღნიშვნით, თუ მთელი რიცხვის რიცხვი უფრო მეტია ვიდრე თვით სიზუსტე:
მოდით num \u003d 123.435 num.toPrecision (2); \u003e "1.2e + 2"
როგორ ავიცილოთ თავიდან შეცდომები ათობითი რიცხვებით
ზოგიერთ შემთხვევაში, toFixed და toPrecision ტურში 5 ქვემოთ და ზემოთ:მოდით numTest \u003d 1.005; numTest.toFixed (2); \u003e "1.00"
ზემოთ გაანგარიშების შედეგი უნდა ყოფილიყო 1.01, და არა 1. თუ გსურთ შეცდომა თავიდან აიცილოთ, ჩვენ შეგვიძლია გამოვიყენოთ ჯეკ ლ მურის მიერ შემოთავაზებული გამოსავალი, რომელიც გამოსაანგარიშებლად იყენებს ექსპონენციალურ ციფრებს:
ფუნქციის რაუნდი (მნიშვნელობა, ათწილადები) (დაბრუნების რიცხვი (მათემატიკა. მიწის (მნიშვნელობა + "ე" + ათწილადი) + "ე -" + ათწილადი);)
ახლა:
მრგვალი (1.005.2); \u003e 1.01
თუ გსურთ უფრო ძლიერი გადაწყვეტა, ვიდრე ზემოთ ნაჩვენები, შეგიძლიათ გადახვიდეთ MDN- ზე.
მანქანა epsilon დამრგვალება
ES6- ში შემოღებულია ათობითი რიცხვების დამრგვალების ალტერნატიული მეთოდი. მანქანა epsilon დამრგვალება იძლევა მცდარი გონივრული ზღვარის შეცდომას ორი მცურავი წერტილის რიცხვის შედარებისას. დამრგვალების გარეშე, შედარებებმა შეიძლება შექმნას შემდეგი შედეგების მსგავსი შედეგები:0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e ყალბი
ჩვენ ვიყენებთ მათემატიკას. 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)\u003e მართალია
ყველა თანამედროვე ბრაუზერი უკვე მხარს უჭერს ES6 მათემატიკის ფუნქციებს, მაგრამ თუ გსურთ მხარდაჭერა ისეთ ბრაუზერებში, როგორიცაა IE 11, გამოიყენეთ პოლიფილები.
ფრაქციული დაჭრილი
ზემოთ წარმოდგენილი ყველა მეთოდი იცის, თუ როგორ უნდა დამრგვალოს ათობითი რიცხვები. იმისათვის, რომ მარტივად გაჭრა რიცხვი ორ ათობით წერტილამდე, ჯერ უნდა გავამრავლოთ ის 100-ზე, შემდეგ კი გავყოთ შედეგი 100-ზე:ფუნქცია შეკვეცილი (რიცხვი) (დაბრუნება Math.trunc (რიცხვი * 100) / 100;) შეკვეცილი (3.1416)\u003e 3.14
თუ გსურთ ნებისმიერი რაოდენობის ათობითი ადგილის განთავსება, შეგიძლიათ გამოიყენოთ ორმაგი ბიტიანი უარყოფა:
ფუნქცია შეკვეცილი (რიცხვი, ათწილადი ადგილები) (მოდით numPowerConverter \u003d Math.pow (10, ათობითი ადგილები); დაბრუნება ~~ (num * numPowerConverter) / numPowerConverter;)
ახლა:
მოდით randInt \u003d 35.874993; შეკვეცილი (randInt, 3); \u003e 35.874
მრგვალდება უახლოეს ნომრამდე
ათობითი რიცხვის დამრგვალებისთვის ზემოთ ან ქვემოთ, რომელი უახლოვდება, გამოიყენეთ Math.round ():მათემატიკა. გარშემო (4.3)\u003e 4 მათემატიკა. გარშემო (4.5)\u003e 5
გაითვალისწინეთ, რომ "მნიშვნელობის ნახევარი", 0.5 მრგვალდება მათემატიკის წესების შესაბამისად.
დაახვიეთ უახლოეს მთელ რიცხვამდე
თუ გსურთ ყოველთვის შემოხვიდეთ ქვემოთ, გამოიყენეთ Math.floor:მათემატიკა. სართული (42.23); \u003e 42 მათემატიკა. სართული (36,93); \u003e 36
გაითვალისწინეთ, რომ დამრგვალება მუშაობს ყველა რიცხვისთვის, მათ შორის უარყოფითიც. წარმოიდგინეთ ცათამბჯენი უსასრულო რაოდენობის სართულებით, მათ შორის ქვედა დონეზე (წარმოადგენს უარყოფით რიცხვებს). თუ ქვედა დონის ლიფტში ხართ 2 – სა და 3 – ს შორის (რაც არის -2,5 მნიშვნელობა), Math.floor მიგიყვანთ –3 – მდე:
მათემატიკა. სართული (-2.5); \u003e -3
თუ გსურთ ამ სიტუაციის თავიდან აცილება, გამოიყენეთ Math.trunc, რომელიც მხარდაჭერილია ყველა თანამედროვე ბრაუზერში (გარდა IE / Edge):
მათემატიკა. ტრუნკი (-41,43); \u003e -41
MDN– ზე ნახავთ პოლიფილს, რომელიც უზრუნველყოფს Math.trunc– ის მხარდაჭერას ბრაუზერებში და IE / Edge– ში.
მრგვალდება უახლოეს მთლიან რიცხვამდე
მეორეს მხრივ, თუ ყოველთვის გჭირდებათ დამრგვალება, გამოიყენეთ Math.ceil. კიდევ ერთხელ, ახსოვს უსასრულო ლიფტი: მათემატიკა. ცისფერი ყოველთვის აიწევს, განურჩევლად იმისა, რიცხვი უარყოფითია თუ არა:მათემატიკა. ჭერი (42.23); \u003e 43 მათემატიკა. ჭერი (36,93); \u003e 37 მათემატიკის ჭერი (-36,93); \u003e -36
დამრგვალება ზემოთ / ქვემოთ, როგორც საჭიროა
თუ გვინდა 5-ის უახლოეს მრავლზე დამრგვალება, უმარტივესი გზაა ფუნქციის შექმნა, რომელიც რიცხვს ყოფს 5-ზე, ამრგვალებს მას და შემდეგ ამრავლებს იმავე რაოდენობაზე:ფუნქციის რაუნდი Too 5 (რიცხვი) (დაბრუნების მათემატიკა. გარშემო (რიცხვი / 5) * 5;)
ახლა:
RoundTo5 (11); \u003e 10
თუ გსურთ თქვენი მნიშვნელობის ჯერადი გამრავლება, ჩვენ ვიყენებთ უფრო ზოგად ფუნქციას, გადავცემთ საწყის მნიშვნელობას და ჯერადს:
ფუნქცია roundToMultiple (num, multiple) (დაბრუნების მათემატიკა. Ground (num / multiple) * multiple;)
ახლა:
მოდით საწყისი ნომერი \u003d 11; მოდით მრავლობითი \u003d 10; roundToMultiple (საწყისი რიცხვი, მრავალჯერადი); \u003e 10;
რიცხვის დაფიქსირება დიაპაზონში
ბევრი შემთხვევაა, როდესაც გვინდა მივიღოთ x მნიშვნელობა, რომელიც დიაპაზონშია. მაგალითად, შეიძლება დაგვჭირდეს მნიშვნელობა 1-დან 100-მდე, მაგრამ მივიღეთ 123 მნიშვნელობა. ამის გამოსასწორებლად, ჩვენ შეგვიძლია გამოვიყენოთ min (რიცხვების სიმცირის უმცირესი ბრუნება) და max (აბრუნებს ციფრების სიმრავლედან ყველაზე დიდს) ) ჩვენს მაგალითში, დიაპაზონი არის 1-დან 100-მდე:მოდით lowBound \u003d 1; მოდით highBound \u003d 100; ნება numInput \u003d 123; მოდით clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (clamped); \u003e 100;
კიდევ ერთხელ, ჩვენ შეგვიძლია გამოვიყენოთ ოპერაცია და ყველაფერი ჩავრთოთ ფუნქციაში, გამოვიყენოთ დენიელ X. მურის მიერ შემოთავაზებული გამოსავალი:
Number.prototype.clamp \u003d ფუნქცია (წთ, მაქსიმუმი) (დაბრუნება Math.min (Math.max (ეს, წთ), მაქს););
ახლა:
NumInput.clamp (lowBound, highBound); \u003e 100;
გაუსის დამრგვალება
გაუსის დამრგვალება, ასევე ცნობილი როგორც ბანკის დამრგვალება, არის ის, სადაც ის მრგვალდება უახლოეს ლენტამდე. დამრგვალების ეს მეთოდი მუშაობს სტატისტიკური შეცდომის გარეშე. საუკეთესო გამოსავალი შემოგვთავაზა ტიმ დაუნმა:ფუნქცია gauss მრგვალი (რიცხვი, ათობითი ადგილები) (მოდით d \u003d ათობითი ადგილები || 0, მ \u003d მათემატიკა. ძრავა (10, დ), n \u003d + (დ? რიცხვი * მ: რიცხვი). ფიქსირებული (8), i \u003d მათემატიკის იატაკი (n), f \u003d n - i, e \u003d 1e-8, r \u003d (f\u003e 0,5 - e && f< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
ახლა:
გაუსი რაუნდი (2.5)\u003e 2 გაუსი რაუნდი (3.5)\u003e 4 გაუსი რაუნდი (2.57,1)\u003e 2.6
ათობითი წერტილი CSS– ში:
მას შემდეგ, რაც JavaScript ხშირად გამოიყენება HTML ელემენტებზე პოზიციური გარდაქმნების წარმოსაქმნელად, შეიძლება გაგიჩნდეთ კითხვა, თუ რა ხდება, თუ ჩვენი ელემენტების ათობითი მნიშვნელობებს ვაწარმოებთ:
# ყუთი (სიგანე: 63.667731993px;)
კარგი ამბავი ის არის, რომ თანამედროვე ბრაუზერები განიხილავს ათობითი მნიშვნელობებს უჯრის მოდელში, პროცენტული ან პიქსელური ერთეულების ჩათვლით.
დალაგება
ხშირად ჩვენ გვჭირდება გარკვეული ელემენტების დალაგება, მაგალითად, ჩვენ გვაქვს მასივი თამაშის ჩანაწერები და ისინი უნდა იყოს ორგანიზებული მოთამაშეთა წოდების კლებადობით. სამწუხაროდ, სტანდარტული დალაგების () მეთოდს აქვს გასაკვირი შეზღუდვები: იგი კარგად მუშაობს ინგლისურენოვან სიტყვებთან, მაგრამ მაშინვე წყვეტს რიცხვების, უნიკალური სიმბოლოების ან დიდი ზომის სიტყვების წინაშე.ანბანის მიხედვით დალაგება
როგორც ჩანს, მასივის ანბანის დალაგება უნდა იყოს უმარტივესი ამოცანა:მოდით ხილი \u003d ["butternut squash", "გარგარი", "cantaloupe"]; ხილი. დალაგება (); \u003e "გარგარი", "butternut squash", "cantaloupe"]
ამასთან, პრობლემა შეგვექმნა, როგორც კი ერთ-ერთი ელემენტი დიდია:
მოდით ხილი \u003d ["butternut squash", "გარგარი", "Cantalope"]; ხილი. დალაგება (); \u003e "კანტალუპა", "გარგარი", "ზეთოხალი გოგრა"]
ეს იმიტომ ხდება, რომ, სტანდარტულად, გამყოფი ადარებს უნიკოდში წარმოდგენილ პირველ სიმბოლოს. უნიკოდი უნიკალური კოდია ნებისმიერი სიმბოლოსთვის, პლატფორმისგან დამოუკიდებლად, პროგრამისაგან, ენისგან დამოუკიდებლად. მაგალითად, თუ გადავხედავთ კოდების ცხრილს, სიმბოლო "a" - ს აქვს მნიშვნელობა U + 0061 (თექვსმეტობით სისტემაში 0x61), ხოლო სიმბოლო "C" - ს კოდი U + 0043 (0x43), რომელიც უფრო ადრე მოდის უნიკოდის ცხრილი ვიდრე სიმბოლო "A".
მასივის დასალაგებლად, რომელიც შეიძლება შეიცავდეს პირველი ასოების შერეულ ასოებს, ან დროებით უნდა გადავაქციოთ ყველა ელემენტი მცირე ასოში, ან განვსაზღვროთ საკუთარი დალაგების რიგი ლოკალიზების () მეთოდის გამოყენებით, რამდენიმე არგუმენტით. როგორც წესი, ასეთ შემთხვევაში უმჯობესია დაუყოვნებლივ შექმნათ განმეორებითი გამოყენების ფუნქცია:
ფუნქცია alphaSort (arr) (arr.sort (ფუნქცია (a, b) (დაბრუნება a.locale შედარება (b, "en", ("მგრძნობელობა": "ბაზა");));) მოდით ხილი \u003d ["butternut squash "," გარგარი "," კანტალუსი "]; alphaSort (ხილი)\u003e
თუ გსურთ მიიღოთ მასივი დალაგებული ანბანური თანმიმდევრობით, უბრალოდ შეცვალეთ a და b პოზიციები ფუნქციაში:
ფუნქცია alphaSort (arr) (arr.sort (ფუნქცია (a, b) (დაბრუნების b.locale შედარება (a, "en", ("მგრძნობელობა": "ბაზა");));) მოდით ხილი \u003d ["butternut squash "," გარგარი "," კანტალუსი "]; alphaSort (ხილი)\u003e ["Cantaloupe", "butternut squash", "გარგარი"]
აქვე უნდა აღინიშნოს, რომ locale შედარება გამოიყენება არგუმენტებით, ასევე უნდა გახსოვდეთ, რომ მას მხარს უჭერს IE11 +, IE– ს ძველი ვერსიებისთვის, შეგვიძლია გამოვიყენოთ არგუმენტების გარეშე და მცირე ასოებით:
ფუნქციის შემთხვევა დალაგება (arr) (arr.sort (ფუნქცია (a, b) "კანტალუპა"]; caseSort (ხილი)\u003e ["გარგარი", "butternut squash", "Cantaloupe"]
რიცხვითი დალაგება
ეს ყველაფერი არ ეხება მაგალითს, რომელზეც ზემოთ ვისაუბრეთ თამაშის ჩანაწერების მასივზე. ზოგიერთ ციფრულ მასივთან ერთად დახარისხება კარგად მუშაობს, მაგრამ გარკვეულ მომენტში შედეგი შეიძლება არაპროგნოზირებადი იყოს:მოდით highScores \u003d; highScores.sort (); \u003e
ფაქტია, რომ დალაგების () მეთოდი ახორციელებს ლექსიკოგრაფიულ შედარებას: ეს ნიშნავს, რომ ციფრები გადაიქცევა სიმებად და შედარებები კვლავ შესრულდება ამ სტრიქონის პირველი სიმბოლოს უნიკოდის ცხრილის სიმბოლოების თანმიმდევრობით. ამიტომ, ჩვენ კვლავ უნდა განვსაზღვროთ ჩვენი დალაგების წესი:
მოდით highScores \u003d; highScores.sort (ფუნქცია (a, b) (დაბრუნება a - b;)); \u003e
ისევ, რიცხვების საპირისპირო რიგის დასალაგებლად, შეცვალეთ a და b პოზიციები ფუნქციაში.
JSON მსგავსი სტრუქტურის დალაგება
დაბოლოს, თუ გვაქვს JSON მსგავსი მონაცემების სტრუქტურა, წარმოდგენილია როგორც თამაშის ჩანაწერების მასივი:მოდით ქულები \u003d [("სახელი": "დანიელი", "ანგარიში": 21768), ("სახელი": "მაიკლი", "ანგარიში": 33579), ("სახელი": "ალისონი", "ანგარიში": 38395 )];
ES6 + - ში შეგიძლიათ გამოიყენოთ ისრის ფუნქციები:
ქულები.დალაგება ((a, b) \u003d\u003e b.score - a.score));
ძველი ბრაუზერებისათვის, რომლებსაც არ აქვთ ეს მხარდაჭერა:
ქულები.დალაგება (ფუნქცია (a, b) (დაბრუნება a.score - b.score));
როგორც ხედავთ, JavaScript- ში დალაგება აშკარა არ არის, იმედი მაქვს, ეს მაგალითები როგორმე გაგიმარტივებთ ცხოვრებას.
დენის ფუნქციებთან მუშაობა
ექსპონენტაცია არის ოპერაცია, რომელიც თავდაპირველად განისაზღვრა, როგორც ბუნებრივი რიცხვის თავისთავად მრავალჯერადი გამრავლების შედეგი, a– ის კვადრატული ფესვი არის რიცხვი, რომელიც იძლევა a– ს კვადრატში. ამ ფუნქციების გამოყენება ყოველდღიურ ცხოვრებაში შეგვეძლო, მათემატიკის გაკვეთილებზე, მათ შორის, უბნების, ტომის გამოთვლის ან ფიზიკური მოდელირების დროსაც.JavaScript- ში, ექსპონენციალური ფუნქცია წარმოდგენილია Math.pow () - ით, ახალ ES7 სტანდარტში შემოაქვთ გამოხატვის ახალი ოპერატორი - "* *".
გამოხატვა
რიცხვის მე -9 ხარისხში ასამაღლებლად გამოიყენეთ Math.pow () ფუნქცია, სადაც პირველი არგუმენტია სიმძლავრეზე ასამაღლებელი რიცხვი, მეორე არგუმენტი არის მაჩვენებელი:მათემატიკა. ძალა (3,2)\u003e 9
აღნიშვნის ეს ფორმა ნიშნავს 3 კვადრატს, ან 3 × 3, რაც 9 შედეგამდე მიდის. რა თქმა უნდა შეგიძლიათ კიდევ ერთი მაგალითი მოიყვანოთ:
მათემატიკა.ძალა (5.3); \u003e 125
ანუ 5 კუბიკი, ანუ 5 × 5 × 5, უდრის 125-ს.
ECMAScript 7 არის JavaScript– ის შემდეგი ვერსია, პრინციპში, ჩვენ შეგვიძლია გამოვიყენოთ ახალი შემოთავაზებული გამოხატვის ოპერატორი - * *, ეს აღნიშვნა უფრო აღწერითი შეიძლება იყოს:
3 ** 2
> 9
ამ მომენტისთვის ამ ოპერატორის მხარდაჭერა საკმაოდ შეზღუდულია, ამიტომ არ არის რეკომენდებული მისი გამოყენება.
დენის ფუნქცია შეიძლება გამოდგეს სხვადასხვა სიტუაციაში. მარტივი მაგალითი, წამში წამების რაოდენობის გამოთვლა საათში: მათემატიკა. ძრავა (60,2).
კვადრატული და კუბის ფესვი
Math.sqrt () და Math.cbrt () Math.pow () ფუნქციის საპირისპიროა. გახსოვდეთ, რომ a- ის კვადრატული ფესვი არის რიცხვი, რომელიც აძლევს a- ს კვადრატში.მათემატიკა. სქრტ (9)\u003e 3
ამავე დროს, a რიცხვის კუბური ფესვი არის ის რიცხვი, რომელიც აძლევს a– ს, როდესაც ის იზრდება კუბურზე.
მათემატიკა. Cbrt (125)\u003e 5
Math.cbrt () JavaScript– ის სპეციფიკაციებში ძალიან ცოტა ხნის წინ გაეცნო და, შესაბამისად, იგი მხარს უჭერს მხოლოდ თანამედროვე ბრაუზერებში: Chrome 38+, Firefox და Opera 25+ და Safari 7.1+. შეამჩნევთ, რომ Internet Explorer ამ სიაში არ არის, თუმცა MDF– ზე ნახავთ პოლიფილს.
მაგალითები
რა თქმა უნდა, ჩვენ შეგვიძლია გამოვიყენოთ არაინტეგრაციული მნიშვნელობები ერთ-ერთ ამ ფუნქციაში:მათემატიკა. ძრავა (1.25, 2); \u003e 1.5625 მათემატიკა. Cbrt (56.57)\u003e 3.8387991760286138
გაითვალისწინეთ, რომ ეს ასევე მუშაობს უარყოფითი არგუმენტის მნიშვნელობებისთვის:
მათემატიკის ძრავა (-5,2)\u003e 25 მათემატიკის ძაბვა (10, -2)\u003e 0,01
თუმცა, კვადრატული ფესვისთვის, ეს არ იმუშავებს:
მათემატიკა. სქრტ (-9)\u003e NaN
მათემატიკური ანალიზით ვიცით, რომ წარმოსახვითი რიცხვი გაგებულია როგორც უარყოფითი რიცხვების კვადრატული ფესვები. ამან შეიძლება კომპლექსურ რიცხვებთან მუშაობის სხვა ტექნიკამდე მიგვიყვანოს, მაგრამ ეს სხვა ამბავია.
შეგიძლიათ გამოიყენოთ ფრაქციული მნიშვნელობები Math.pow () - ში, რომ იპოვოთ კვადრატული და კუბური რიცხვები. კვადრატული ფესვი იყენებს 0,5-ს გამოხატულებას:
მათემატიკა. ძროხა (5, 0,5); // \u003d მათემატიკა. სქრტ (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
ამასთან, მცურავი წერტილის უცნაურობის გამო, ზუსტად ვერ გამოიცნობთ სწორ შედეგს:
მათემატიკა. ძაბვა (2.23606797749979.2)\u003e 5.000000000000001
ასეთ სიტუაციებში, თქვენ მოგიწევთ რიცხვის ნიშნების შემცირება ან დამრგვალება რაიმე მნიშვნელობამდე.
ზოგი JavaScript– ში გაურკვეველი მიზეზების გამო, აურევს Math.pow () ფუნქციას Math.exp (), რაც არის ექსპონენციალური ფუნქცია ზოგადად ციფრებისთვის. შენიშვნა: ინგლისურად, "exponent" ითარგმნება როგორც "exponent", ასე რომ, ეს უფრო ეხება ინგლისურენოვან ენებს, თუმცა არსებობს ალტერნატიული სახელები exponent, როგორიცაა ინდექსი, ძალა.
მათემატიკური მუდმივები
JavaScript- ში მათემატიკასთან მუშაობა გაადვილებულია მრავალი ჩამონტაჟებული მუდმივის საშუალებით. ეს მუდმივები მათემატიკის ობიექტის თვისებებია. გაითვალისწინეთ, რომ მუდმივები იწერება დიდი ასოებით და არა CamelCase ნოტაციით.მათემატიკა. Abs, parseInt, parseFloat
JavaScript- ში ციფრებთან მუშაობა შეიძლება ბევრად უფრო რთული იყოს, ვიდრე ჟღერს. მიღებული მნიშვნელობები ყოველთვის არ მოდის მოსალოდნელ დიაპაზონში, ზოგჯერ შედეგი შეიძლება არ იყოს ის, რასაც ველოდით.Math.abs ()
Math.abs () მეთოდი აბრუნებს რიცხვის აბსოლუტურ მნიშვნელობას, რომელიც გვახსენებს ანალოგურ მათემატიკურ ფუნქციას რიცხვის მოდულისთვის.მოდით newVal \u003d -57.64; მათემატიკა. აბები (newVal); \u003e 57,64
Math.abs (0) ყოველთვის აბრუნებს ნულს, მაგრამ თუ –Math.abs (NUM) ფუნქციის წინ დავუშვებთ მინუს ნიშანს, ჩვენ ყოველთვის უარყოფითი ვიქნებით.
მათემატიკა. აბები (0); \u003e -0
parseInt ()
ჩვენ ვიცით, რომ JavaScript– ს ესმის, რომ ”15” არის სტრიქონი და არა რიცხვი და, მაგალითად, JavaScript– ის გამოყენებით CSS თვისებების ანალიზისას ან მოუმზადებელი მასივიდან გარკვეული მნიშვნელობის მიღებისას, ჩვენი შედეგები შეიძლება არაპროგნოზირებადი იყოს. შეგვიძლია მივიღოთ სტრიქონი, როგორც "17px", როგორც შეყვანა, და ეს ჩვენთვის არც ისე იშვიათია. საკითხავია, თუ როგორ უნდა გადავაკეთოთ ეს სტრიქონი რეალურ მნიშვნელობად და გამოვიყენოთ იგი შემდგომ გამოთვლებში.სინტაქსი: parseInt (სიმებიანი, რადიქსი);
ParseInt ფუნქცია გარდაქმნის მასზე გადაცემულ პირველ არგუმენტს სტრიქონში, ახსნის მას და აბრუნებს მთელ ან NaN მნიშვნელობას. შედეგი (თუ არა NaN) არის მთელი რიცხვი და არის პირველი არგუმენტი (სტრიქონი), რომელიც განიხილება როგორც რიცხვი მითითებულ რიცხვთა სისტემაში (რადიქსი). მაგალითად, ბაზა 10 მიუთითებს გარდაქმნის ათობითიდან, 8-დან ოქტალიდან, 16-დან ექვსკუთხედად და ა.შ. თუ ფუძე 10-ზე მეტია, მაშინ ასოები გამოიყენება 9-ზე მეტი რიცხვების აღსანიშნავად. მაგალითად, თექვსმეტობითი რიცხვები (ბაზა 16) იყენებს ასოებს A- დან F- მდე.
მოდით განვიხილოთ CSS თვისებებთან მუშაობის მაგალითი, სადაც, შედარებით რომ ვთქვათ, ასეთი მნიშვნელობის მიღება შეგვიძლია:
მოდით elem \u003d დოკუმენტი. სხეული; let centerPoint \u003d window.getCompulatedStyle (elem) .transformOrigin; \u003e "454px 2087.19px"
შეგვიძლია მნიშვნელობები გავყოთ ფართების მიხედვით:
მოდით ცენტრები \u003d centerPoint.split (""); \u003e ["454px", "2087.19px"]
ამასთან, თითოეული ელემენტი კვლავ სტრიქონია, ამისგან თავის დაღწევა შეგვიძლია ჩვენი ფუნქციის გამოყენებით:
მოდით centerX \u003d parseInt (ცენტრები, 10); \u003e 454 მოდით centerY \u003d parseInt (ცენტრები, 10); \u003e 2087 წ
როგორც ხედავთ, როგორც მეორე არგუმენტი, ჩვენ მიუთითეთ რიცხვითი სისტემა, რომელშიც ნომერი გადაკეთდება, ეს პარამეტრი არასავალდებულოა, მაგრამ მისი გამოყენება რეკომენდებულია იმ შემთხვევაში, თუ არ იცით რომელი სტრიქონი შემოვა შეყვანაში.
parseFloat ()
ზემოთ მოყვანილი მაგალითიდან თქვენ ალბათ შენიშნეთ, რომ parseInt უყრის ფრაქციულ ნაწილს. ჩვენს შემთხვევაში, parseFloat– ს შეუძლია მუშაობა მცურავი წერტილების ციფრებთან. კიდევ ერთხელ, ეს შეიძლება სასარგებლო იყოს CSS და სხვა ამოცანების ანალიზისას, განსაკუთრებით მაშინ, როდესაც საქმე გვაქვს მცურავი წერტილის პროცენტულ მაჩვენებლებთან.სინტაქსი: parseFloat (სიმებიანი)
მოდით FP \u003d "33.33333%"; console.log (parseFloat (FP)); \u003e 33.33333
გაითვალისწინეთ, რომ parseFloat სინტაქსში არ არსებობს მეორე არგუმენტი.
ჩვენ გვესმის, რომ parseInt () და parseFloat () ძალიან სასარგებლო ფუნქციებია, მნიშვნელოვანია გვახსოვდეს, რომ ეს არ შეიძლება იყოს შეცდომების გარეშე, ამიტომ საჭიროა შემოწმდეს მოსალოდნელი მნიშვნელობების დიაპაზონი და საბოლოოდ გავაანალიზოთ შედეგი, რათა დარწმუნდეთ, რომ მიღებული მნიშვნელობები სწორია.
ანონიმურად გაგზავნა
გამოთვლები ხშირად იძლევა შედეგებს, რომლებიც არ არიან სასურველი დიაპაზონის მიღმა. შედეგად, თქვენ უნდა განახორციელოთ JavaScript დამრგვალება გარკვეულ ღირებულებამდე.
რატომ მრგვალდება რიცხვები?
JavaScript არ ინახავს მთელ რიცხვებს, რადგან მათი მნიშვნელობები წარმოდგენილია როგორც მოძრავი წერტილის რიცხვები. ბევრი ფრაქცია ვერ იქნება წარმოდგენილი ათობითი ათობითითა სასრული რაოდენობით, ამიტომ JavaScript– ს შეუძლია ისეთი შედეგების გამომუშავება, როგორიც მოცემულია ქვემოთ:
0.1 * 0.2; > 0.020000000000000004
პრაქტიკაში, ამას არანაირი მნიშვნელობა არ ექნება, რადგან ჩვენ ვსაუბრობთ 2 კვინტილიონის შეცდომაზე. ამასთან, ამან შეიძლება გავლენა იქონიოს შედეგზე, როდესაც მუშაობს ციფრებთან, რომლებიც წარმოადგენს ვალუტის მნიშვნელობებს, პროცენტულ მაჩვენებლებს ან ფაილის ზომას. ამიტომ, თქვენ უნდა გააკეთოთ ან გარკვეული ათობითი ადგილი.
ათობითი რიცხვების დამრგვალება
ათობითი რიცხვის "შესამცირებლად" გამოიყენეთ toFixed () ან toPrecision () მეთოდები. ორივე იღებს ერთ არგუმენტს, რომელიც განსაზღვრავს მნიშვნელოვანი და ათობითი ადგილების რაოდენობას, რომლებიც უნდა შეიტანოთ შედეგში:
- თუ toFixed- ისთვის არგუმენტი არ არის განსაზღვრული, ნაგულისხმევი არის 0, ანუ ათწილადი არ არის; არგუმენტის მაქსიმალური მნიშვნელობაა 20;
- თუ არ არის მითითებული toPrecision () არგუმენტი, ნომერი არ შეიცვლება.
var randNum \u003d 6,25; randNum.toFixed (); \u003e "6" Math.PI.toPrecision (1); \u003e "3" var randNum \u003d 87.335; randNum.toFixed (2); \u003e "87.33" var randNum \u003d 87.337; randNum.toPrecision (3); \u003e "87.3"
შენიშვნა
ToFixed () და toPrecision აბრუნებს შედეგის მომრგვალებული სტრიქონის გამოსახულებას და არა რიცხვს. ეს ნიშნავს, რომ randNum- ის მომრგვალებული დამატება გამოიწვევს სიმების შერწყმას და არა ერთ რიცხვს:
console.log (randNum + მომრგვალებული); \u003e "6.256"
თუ გსურთ JavaScript მრგვალი გადახდეს მეასედამდე, გამოიყენეთ parseFloat ():
var randNum \u003d 6,25; var მრგვალდება \u003d parseFloat (randNum.toFixed (1)); console.log (მომრგვალებული); \u003e 6.3
toFixed () და toPrecision () ასევე სასარგებლო მეთოდებია დიდი ათწილადების შემცირებისთვის. ეს გამოდგება იმ ციფრებთან მუშაობისას, რომლებიც წარმოადგენს მონეტარულ ერთეულებს:
var wholeNum \u003d 1 var dollarCents \u003d wholeNum.toFixed (2); console.log (დოლარი ცენტი); \u003e "1.00"
გაითვალისწინეთ, რომ თუ რიცხვში მეტი ციფრია, ვიდრე მითითებულია სიზუსტის პარამეტრით, toPrecision დაუბრუნებს შედეგს სამეცნიერო ფორმატში:
var num \u003d 123.435 num.toPrecision (2); \u003e "1.2e + 2"
როგორ ავიცილოთ თავიდან შეცდომები ათეულების დამრგვალებისას
ზოგიერთ შემთხვევაში toFixed და toPrecision ახორციელებს JavaScript დამრგვალება 5 ქვემოთდა არა უფრო მეტის:
var numTest \u003d 1.005; numTest.toFixed (2); \u003e 1;
ზემოთ მოყვანილ მაგალითს უნდა მოჰყვეს 1.01 და არა 1. თუ გსურთ შეცდომა თავიდან აიცილოთ, გირჩევთ გამოიყენოთ ექსპონენციალური ციფრები
ფუნქციის რაუნდი (მნიშვნელობა, ათწილადები) (დაბრუნების რიცხვი (მათემა. მიწის (მნიშვნელობა + "ე" + ათწილადი) + "ე -" + ათწილადი);)
განცხადება:
მრგვალი (1.005.2); \u003e 1.01
თუ დამრგვალებაზე უფრო საიმედო გამოსავალიც გჭირდებათ, ის ხელმისაწვდომია მისამართზე: MDN.
Epsilon დამრგვალება
ალტერნატიული მეთოდი JavaScript დამრგვალება მეათედამდე დაინერგა ES6- ში ( ასევე ცნობილი როგორც JavaScript 2015). « მანქანა epsilon»უზრუნველყოფს შეცდომის გონივრულ ზღვარს მცურავი წერტილის ორი რიცხვის შედარებისას. დამრგვალების გარეშე, შედარებებმა შეიძლება შემდეგი შედეგების მსგავსი შედეგები გამოიწვიოს:
0,1 + 0,2 \u003d\u003d\u003d 0,3\u003e ყალბი
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)\u003e მართალია
ყველა თანამედროვე ბრაუზერი მხარს უჭერს ES6 მათემატიკის ფუნქციებს. თუ თქვენ გჭირდებათ ძველი ბრაუზერების მხარდაჭერა, მაშინ უნდა გამოიყენოთ პოლიფილები.
ათობითი რიცხვების შემცირება
ადრე წარმოდგენილი ყველა მეთოდი ასრულებს JavaScript დამრგვალება მეათედამდე... პოზიტიური რიცხვის ორ ათეულზე შემცირებისთვის, გამრავლეთ იგი 100-ზე, კვლავ შეკვეცით და შემდეგ გაყავით შედეგი 100-ზე, გჭირდებათ:
ფუნქცია შეკვეცილი (რიცხვი) (დაბრუნება Math.trunc (რიცხვი * 100) / 100;) შეკვეცილი (3.1416)\u003e 3.14
თუ თქვენ გჭირდებათ უფრო მოქნილი რამე, შეგიძლიათ გამოიყენოთ bitwise ოპერატორი:
ფუნქცია შეკვეცილი (რიცხვი, ათწილადი ადგილები) (var numPowerConverter \u003d მათემატიკა. ძალა (10, ათწილადი ადგილები); დაბრუნება ~~ (num * numPowerConverter) / numPowerConverter;)
გამოყენება:
var randInt \u003d 35.874993; შეკვეცილი (randInt, 3); \u003e 35.874
მრგვალდება უახლოეს ნომრამდე
Განხორციელება JavaScript დამრგვალება მთელ რიცხვში, გამოიყენება Math.round () ():
მათემატიკა. გარშემო (4.3)\u003e 4 მათემატიკა. გარშემო (4.5)\u003e 5
Გაითვალისწინე " ნახევარი ღირებულებები”მაგალითად .5 არის მომრგვალებული.
შემოიხვიეთ უახლოეს მთელ რიცხვამდე
თუ გსურთ შემოხვიდეთ, გამოიყენეთ Math.floor () მეთოდი:
მათემატიკა. სართული (42.23); \u003e 42 მათემატიკა. სართული (36,93); \u003e 36
დამრგვალებას აქვს ერთი მიმართულება ყველა რიცხვისთვის, მათ შორის უარყოფითიც. ეს შეიძლება წარმოვიდგინოთ, როგორც ცათამბჯენი უსასრულო რაოდენობის იატაკებით, მათ შორის საძირკვლის დონის ქვემოთ ( წარმოადგენს უარყოფით რიცხვებს) თუ ლიფტში ხართ სარდაფის 2 და 3 სართულებს შორის ( რაც შეესაბამება -2,5 მნიშვნელობას), Math.floor მიგიყვანთ სართულზე -3:
მათემატიკა. სართული (-2.5); \u003e -3
თუ ამის თავიდან აცილება გჭირდებათ, გამოიყენეთ JavaScript მათემატიკის დამრგვალება Math.trunc () - ით, რომელიც მხარდაჭერილია ყველა თანამედროვე ბრაუზერში (გარდა IE / Edge):
მათემატიკა. ტრუნკი (-41,43); \u003e -41
MDN ასევე უზრუნველყოფს 3 სტრიქონიანი პოლიფილმი Math.trunc მხარდაჭერის უზრუნველსაყოფად ძველ ბრაუზერებში და IE / Edge.
მრგვალდება უახლოეს მთელ რიცხვამდე
თუ გსურთ ათწილადი რიცხვების დამრგვალება, გამოიყენეთ Math.ceil. ეს მეთოდი შეიძლება ასევე განვიხილოთ, როგორც დაუსრულებელი ლიფტი: მათემატიკის. ზღაპარი ყოველთვის გიბიძგებთ, განურჩევლად იმისა, რიცხვი უარყოფითია თუ დადებითი:
მათემატიკა. ჭერი (42.23); \u003e 43 მათემატიკა. ჭერი (36,93); \u003e 37 მათემატიკის ჭერი (-36,93); -36
მრგვალდება უახლოეს ჯერადად
თუ საჭიროა მნიშვნელობის დამრგვალება 5 – ის უახლოეს ჯერადთან, შექმენით ფუნქცია, რომელიც ყოფს რიცხვს 5 – ზე, აამრგვალებს მას და შემდეგ ამრავლებს შედეგს იმავე მნიშვნელობით:
ფუნქცია roundTo5 (num) (დაბრუნების მათემატიკა .round (num / 5) * 5;)
გამოყენება:
roundTo5 (11); \u003e 10
თუ JavaScript გჭირდებათ ორ ციფრზე დასალაგებლად, შეგიძლიათ თესლიც და სიმრავლეც გადასცეთ ფუნქციას:
ფუნქცია roundToMultiple (num, multiple) (დაბრუნების მათემატიკა .round (num / multiple) * multiple;)
ფუნქციის გამოსაყენებლად, მის ზარში ჩასვით გასამრგვალებელი რიცხვი და სიმრავლე:
var თავდაპირველი ნომერი \u003d 11; var მრავლობითი \u003d 10; roundToMultiple (საწყისი რიცხვი, მრავალჯერადი); \u003e 10;
მნიშვნელობების მრგვალდება მხოლოდ ზემოთ ან ქვემოთ, ფუნქცია შეცვალეთ მრგვალი ჭერით ან იატაკით.
დიაპაზონი
ზოგჯერ თქვენ უნდა მიიღოთ x მნიშვნელობა, რომელიც უნდა იყოს გარკვეულ დიაპაზონში. მაგალითად, ჩვენ გვჭირდება მნიშვნელობა 1 – დან 100 – მდე, მაგრამ ვიღებთ 123 მნიშვნელობას. ამის გამოსასწორებლად შეგიძლიათ გამოიყენოთ min () ( აბრუნებს რიცხვებს შორის ყველაზე მცირედ) და მაქსიმალური ( აბრუნებს დაშვებულ მაქსიმალურ რაოდენობას).
გამოყენება:
var lowBound \u003d 1; var highBound \u003d 100; var numInput \u003d 123; var clamped \u003d Math.max (lowBound, Math.min (numInput, highBound)); console.log (clamped); \u003e 100;
შეგიძლიათ შექმნათ Number კლასის ფუნქცია ან გაფართოება.
მათემატიკა. გარშემო () ფუნქცია აბრუნებს რიცხვის მნიშვნელობას, რომელიც მომრგვალებულია უახლოეს მთელ რიცხვამდე.
ამ ინტერაქტიული მაგალითის წყარო ინახება GitHub საცავში. თუ გსურთ მონაწილეობა მიიღოთ ინტერაქტიული მაგალითების პროექტში, გთხოვთ, შეაჯგუფოთ https://github.com/mdn/interactive-examples და გამოგვიგზავნოთ მოთხოვნის მოთხოვნა.
Სინტაქსი
მათემატიკა. გარშემო (x)Პარამეტრები
x რიცხვი.დაბრუნების მნიშვნელობა
მოცემული რიცხვის მნიშვნელობა მომრგვალებულია უახლოეს მთელ რიცხვამდე.
აღწერა
თუ არგუმენტის ფრაქციული ნაწილი მეტია 0,5-ზე, არგუმენტი მრგვალდება მთელ რიცხვთან შემდეგი უფრო მაღალი აბსოლუტური მნიშვნელობით. თუ ის 0,5-ზე ნაკლებია, არგუმენტი მრგვალდება მთელი აბსოლუტური ქვედა მნიშვნელობით. თუ ფრაქციული ნაწილი ზუსტად 0,5-ია, არგუმენტი მრგვალდება მომდევნო მთელი რიცხვით + direction მიმართულებით. გაითვალისწინეთ, რომ ეს განსხვავდება მრავალი ენისგან "round () ფუნქციებისგან, რომლებიც ხშირად ამ შემთხვევაში ასწორებს შემდეგ მთლიან რიცხვს ნულის დაშორებით , ამის ნაცვლად განსხვავებული შედეგის მიცემა უარყოფითი რიცხვების შემთხვევაში, ზუსტად 0.5-ის წილადური ნაწილით.
იმის გამო, რომ round () მათემატიკის სტატიკური მეთოდია, მას ყოველთვის იყენებთ როგორც Math.round (), ვიდრე თქვენს მიერ შექმნილი მათემატიკის ობიექტის მეთოდად (მათემატიკას კონსტრუქტორი არ აქვს).
მაგალითები
მათემატიკა. გარშემო (20.49); // 20 მათემატიკა. გარშემო (20.5); // 21 მათემატიკა. გარშემო (42); // 42 მათემატიკა .round (-20.5); // -20 მათემატიკა .round (-20.51); // -21დემონსტრაციული განხორციელება
ქვემოთ მოცემულია კოდის ფრაგმენტი, რომელიც ფუნქციურად ტოლფასია მათემატიკასთან. გარდა ამისა, ქვემოთ მოცემული კოდის ნანგრევი უფრო ნელია, ვიდრე Math.round. ქვემოთ მოყვანილი კოდის მიზანია იმის დემონსტრირება, თუ როგორ მუშაობს Math.round.
ფუნქცია vanilla_round (x) (var y \u003d მათემატიკა. Abs (x) + 0,5; // ისე, რომ 1/2-ზე ნაკლები ტრიალებს ქვემოთ; უფრო მეტი რაუნდი ზემოთ დაბრუნდება მათემატიკის იატაკი (x + 0,5))
ზემოთ მოყვანილი მოდულის ოპერატორი იღებს x ნაწილის ათობითი ნაწილს. გარდა ამისა, კოდის ზემოთ მოყვანილი ფრაგმენტი შეიძლება შეიცვალოს გარკვეული სიზუსტით მრგვალდება რიცხვზე:
ფუნქცია მრგვალი_ ზუსტი
მრგვალი_ ზუსტი (11, 2); // გამოდის 12 მრგვალი_ზუსტი (11, 3); // გამოდის 12 მრგვალი_ზუსტი (11, 4); // გამოაქვს 12 მრგვალი_ზუსტი (11, 5); // გამოაქვს 10 მრგვალი_ზუსტი (11, 6); // გამოდის 12 მრგვალი_ზუსტი (11, 7); // გამოდის 14 მრგვალი_ზუსტი (11, 8); // გამოაქვს 8 მრგვალი_ზუსტი (3.7, 0.5); // გამოდის 3.5 მრგვალი_ ზუსტი (3.75, 0.5); // გამოაქვს 4 მრგვალი_ზუსტი (3.8, 0.5); // შედეგები 4
სპეციფიკაციები
| სპეციფიკაცია | სტატუსი | კომენტარი |
|---|---|---|
| ECMAScript პირველი გამოცემა (ECMA-262) | სტანდარტული | საწყისი განმარტება დანერგილია JavaScript 1.0 – ში. |
| ECMAScript 5.1 (ECMA-262) |
სტანდარტული | |
| ECMAScript 2015 (მე -6 გამოცემა, ECMA-262) განმარტება "Math.round" ამ სპეციფიკაციაში. |
სტანდარტული | |
| ECMAScript უახლესი პროექტი (ECMA-262) განმარტება "Math.round" ამ სპეციფიკაციაში. |
პროექტი |
ბრაუზერის თავსებადობა
ამ გვერდზე თავსებადობის ცხრილი აგებულია სტრუქტურირებული მონაცემებიდან. თუ გსურთ წვლილი შეიტანოთ მონაცემებში, გთხოვთ, გაეცნოთ https://github.com/mdn/browser-compat-data და გამოგვიგზავნეთ მოთხოვნის მოთხოვნა.
განაახლეთ თავსებადობის მონაცემები GitHub- ზე
| სამუშაო მაგიდა | მობილური | სერვერი | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ქრომი | პირას | Firefox | Internet Explorer | ოპერა | Safari | Android ვებგვერდი | Chrome for Android | Firefox Android- ისთვის | ოპერა Android- ისთვის | Safari iOS- ზე | სამსუნგის ინტერნეტი | კვანძი. Js | |
| მრგვალი | Chrome სრული მხარდაჭერა 1 | Edge სრული მხარდაჭერა 12 | Firefox სრული მხარდაჭერა 1 | IE სრული მხარდაჭერა 3 | ოპერა სრული მხარდაჭერა დიახ | Safari სრული მხარდაჭერა დიახ | WebView Android სრული მხარდაჭერა 1 | Chrome Android სრული მხარდაჭერა 18 | Firefox Android სრული მხარდაჭერა 4 | Opera Android სრული მხარდაჭერა დიახ | Safari iOS სრული მხარდაჭერა დიახ | Samsung ინტერნეტ Android სრული მხარდაჭერა 1.0 | nodejs სრული მხარდაჭერა დიახ |
ახლა გადავხედოთ იატაკის მეთოდს (ნათარგმნია როგორც სქესი)რომელიც მუშაობს ჭერის მეთოდის საპირისპიროდ, ე.ი. არის ის ამრგვალებს წილადობრივ რიცხვს.
როგორც ხედავთ, იატაკის მეთოდი 35.97-ით მრგვალდება 35-ით ქვემოთ, რაც ქვევით არის. მიუხედავად იმისა, რომ 0,97 0,5-ზე მეტია (სმ. ).
ეს გაკვეთილი მოიცავს მათემატიკის ობიექტის მეთოდებს, წილადური ათობითი რიცხვების დამრგვალების საშუალებას.
ახლა თქვენ უნდა შეასრულოთ თქვენი საშინაო დავალება.
თქვენი ამოცანაა დაწეროთ ფუნქცია, რომელიც ორ პარამეტრს მიიღებს.
1. მასივი, რომელიც შედგება წილადების მქონე რიცხვებისგან.
2. დამრგვალების მეთოდი "მრგვალი", "ჭერი" ან "იატაკი".
გამოსასვლელში, ფუნქციამ უნდა გამოუშვას იგივე მასივი, მაგრამ ამავდროულად მასივის ყველა ელემენტი უნდა მომრგვალდეს მათემატიკის ობიექტის მეორე პარამეტრში მითითებული მეთოდის გამოყენებით.
წყაროს მასივი:
var numberArray \u003d;
თავდაპირველად, ამ პრობლემის მოგვარება შეიძლება თითქმის იდენტური ჩანდეს ამ თემის პირველ სამ გაკვეთილზე საყოფაცხოვრებო პრობლემების გადაჭრის შესახებ. მაგრამ ყველაფერი ასე მარტივად არ არის ...
გამოსავალი # 1 - ყურადღება
პრობლემის პირობით ფუნქციამ უნდა მიიღოს ორი პარამეტრი - ორიგინალი მასივი და ერთ-ერთი მეთოდი: "მრგვალი", "ჭერი" ან "იატაკი". ამის საფუძველზე, მე ამის გაკეთება სცადა...
ამ ამოხსნისას ჩვენ ვქმნით ფუნქციას ორი პარამეტრით და როდესაც მას ვუწოდებთ, ვცდილობთ მიუთითოთ ორიგინალი მასივი და ერთი მეთოდის NAME ფუნქციის პარამეტრებად:
ათობითი (numberArray, round) - ამ შემთხვევაში მრგვალი.
მაგრამ შედეგს ვერ მივიღებთ, მას შემდეგ ნუ მიუთითებთ NAME მეთოდს, როგორც ფუნქციის პარამეტრს.
ყურადღება მიაქციეთ: შემთხვევითი არ არის, რომ პრობლემის შინაარსში მოცემულია მეთოდების სახელები "მრგვალი", "ჭერი" და "იატაკი" ბრჭყალებში ჩასმული.
ათობითი (numberArray, "round") - მაგრამ არც ეს იქნება სწორი !!!
გამოსავალი # 2 - შეასწორეთ წინა გამოსავალი
პრობლემის მოგვარება შეგიძლიათ ფუნქციის ერთი პარამეტრის მითითებით.
35 - მომრგვალებული ელემენტი
13 - მომრგვალებული ელემენტი
17 - მომრგვალებული ელემენტი
79 - მომრგვალებული ელემენტი
აქ ჩვენ მივაღწიეთ სასურველ შედეგს: მრგვალი მეთოდით ყველა რიცხვი შემოვიდა. მაგრამ პირობა არ არის დაკმაყოფილებულირადგან ფუნქცია მხოლოდ ერთ პარამეტრს იღებს.
ამოხსნა # 3 - ფუნქცია ორი პარამეტრით
აქ პრობლემა მოგვარებულია სწორად. ამისათვის თქვენ უნდა გახსოვდეთ Javascript– ში არსებული პირობების თემა და ერთდროულად გამოიყენოთ რამდენიმე პირობა.
34.82 - მასივის საწყისი ელემენტი
35 - დამრგვალება
12.9 - მასივის საწყისი ელემენტი
13 - მრგვალი
17.01 - მასივის საწყისი ელემენტი
18 - მრგვალი
78.51 - მასივის საწყისი ელემენტი
79 - მრგვალი
ის სწორი გამოსავალი Საშინაო დავალება. აქ ფუნქციისთვის მითითებულია ორი პარამეტრი პირობითობის შესაბამისად.
სცადეთ ამ ამოხსნის ბოლო ხაზი:
ათობითი (numberArray, "ceil"), როგორც ფუნქციის მეორე პარამეტრი, მიუთითეთ სხვა მეთოდების სახელები მათემატიკის ობიექტის "მრგვალი" და "იატაკი".
ამოხსნა # 4 - ფუნქცია ორი პარამეტრით + სწრაფი მეთოდი
გადავწყვიტე ცოტათი ოპტიმიზირებული ვიყო წინა გამოსავალი და დავამატე სწრაფი მეთოდი, რომელიც მოწოდებს მოდალურ ფანჯარაში, რომელიც შეიცავს ინფორმაციის შესატან ველს.
ახლა ამის წყალობით შეყვანის ველში შესაძლებელი იქნება ერთ-ერთი მეთოდის მრგვალი, იატაკის ან ჭერის შეყვანა და შესაბამისი შედეგის მიღება.
ასე მუშაობს მათემატიკის ობიექტის მრგვალი, იატაკის ან ჭერის მეთოდები, რომლებიც მრგვალდება ფრაქციული რიცხვებით.
