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

20
21
22
23
24

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

მაგალითად, 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).

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
რატომ არის საჭირო დამრგვალება?

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

მოდით randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87.335; randNum.toFixed(2); > "87.33" randNum = 87.337; randNum.toPrecision(3); > "87.3"
ორივე toFixed() და toPrecision() მეთოდი აბრუნებს შედეგის სტრიქონულ წარმოდგენას და არა რიცხვს. ეს ნიშნავს, რომ დამრგვალებული მნიშვნელობის შეჯამებისას randNum-ით, ის წარმოქმნის სტრიქონების შეერთებას და არა რიცხვების ჯამს: მოდით 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-ზე.

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 პოზიციები ფუნქციაში.

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 ინგლისური"ექსპონენტი" ითარგმნება როგორც "ექსპონენტი", ამიტომ ეს უფრო მეტად ეხება ინგლისურენოვანებს, თუმცა არსებობს მაჩვენებლის ალტერნატიული სახელები, როგორიცაა ინდექსი, სიმძლავრე.

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

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

სინტაქსი: 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 (სტრიქონი)

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

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