ტიპების გარდაქმნა

რას ისწავლი

• როგორ გაიგო მნიშვნელობის ტიპი typeof-ით
• როგორ გადააქციო ტექსტი რიცხვად და პირიქით
• რა არის NaN და როდის ჩნდება

მნიშვნელობის ტიპი

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

console.log(typeof 42);       // number
console.log(typeof "42");     // string
console.log(typeof true);     // boolean
console.log(typeof (2 > 1));  // boolean

42 და "42" ეკრანზე ერთნაირად ჩანს, მაგრამ პირველი რიცხვია, მეორე ტექსტი. ამიტომ მათთან + სხვადასხვანაირად იქცევა.

წარმოიდგინე ორი ყუთი: ერთში ორმოცდაორი ვაშლი დევს, მეორეში ქაღალდი, რომელზეც წერია „42“. ვაშლებს დაითვლი და დაამატებ, ქაღალდს კი მხოლოდ სხვა ქაღალდს მიაწებებ. ტიპების გარდაქმნა (type conversion) ქაღალდზე დაწერილი რიცხვის ვაშლებად „გადაქცევაა“ ან პირიქით. როცა პროგრამა უცნაურად ითვლის, პირველი კითხვა ასეთია: რა ტიპისაა ეს მნიშვნელობა სინამდვილეში?

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

ტექსტი ხშირად მოდის იქ, სადაც რიცხვს ელი: მომხმარებლის მიერ ფორმაში ჩაწერილი ასაკი ყოველთვის სტრიქონია. მის რიცხვად გადასაქცევად გამოიყენე Number():

console.log(Number("42"));      // 42
console.log(Number("12.5"));    // 12.5
console.log(Number("  7  "));   // 7: ინტერვალებს უგულებელყოფს
console.log(Number("ათი"));     // NaN

ბოლო ხაზში ტექსტი რიცხვად ვერ იქცევა, ამიტომ შედეგია NaN (Not a Number), „რიცხვი არ არის“. ეს სპეციალური მნიშვნელობაა, რომელიც ცუდი გამოთვლის ნიშანია.

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

console.log(Number("42px"));        // NaN
console.log(parseInt("42px"));      // 42
console.log(parseFloat("3.5 კგ"));  // 3.5

რიცხვიდან ტექსტი და ლოგიკური მნიშვნელობა

String() ნებისმიერ მნიშვნელობას ტექსტად აქცევს: String(42) არის "42". Boolean() კი ლოგიკურ მნიშვნელობად: 0, ცარიელი სტრიქონი "" და NaN ხდება false, თითქმის ყველაფერი დანარჩენი true.

console.log(Boolean(0));      // false
console.log(Boolean(""));     // false
console.log(Boolean("ა"));    // true
console.log(Boolean(15));     // true

ავტომატური გარდაქმნა

ზოგჯერ JavaScript ტიპს შენი თხოვნის გარეშე ცვლის. წესი ასეთია: თუ +-ის ერთი მხარე ტექსტია, ორივე ტექსტად იქცევა და ერთდება. -, * და / კი მხოლოდ რიცხვებთან მუშაობს, ამიტომ ტექსტს რიცხვად აქცევს:

console.log("5" + 2);   // 52
console.log("5" * 2);   // 10
console.log("5" - 2);   // 3

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

სცადე თავად

გაუშვი და შეადარე ორი ჯამი. მერე b-ში ჩაწერე "ოთხი" და ნახე, რა მოუვა რიცხვით ჯამს.

ხშირი შეცდომები

• ფორმიდან მოსული რიცხვების შეკრება. ველიდან წაკითხული "10" და "5" +-ით იძლევა "105"-ს. ჯერ Number(), მერე შეკრება.
• NaN-ის შემოწმება ===-ით. NaN === NaN არის false: NaN საკუთარ თავსაც არ უდრის. შემოწმებისთვის გამოიყენე Number.isNaN(x).
• Number(""). ცარიელი სტრიქონი რიცხვად 0 ხდება და არა NaN. თუ ცარიელი ველი უნდა დაიჭირო, ეს ცალკე შეამოწმე.

let price = "12.5";
let count = "3";

let total = Number(price) * Number(count);
console.log("ჯამი:", total);
console.log(typeof total);

მინი-ქვიზი

შეჯამება

• typeof გეუბნება მნიშვნელობის ტიპს: number, string, boolean.
• Number() ტექსტს რიცხვად აქცევს, String() რიცხვს ტექსტად. ვერ გარდაქმნილი რიცხვი NaN-ია.
• + ტექსტთან აერთებს, -, * და / ტექსტს რიცხვად აქცევს.
• ფორმიდან მოსული მონაცემი ტექსტია: გამოთვლამდე გარდაქმნა.