მინი-კალკულატორი

რას ისწავლი

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

გეგმა

წინა თავების მეთოდით დავგეგმოთ:

• შეტანა: ორი რიცხვი და მოქმედების ნიშანი: +, -, * ან /.
• გამოტანა: შედეგი, ან გასაგები შეტყობინება, თუ გამოთვლა შეუძლებელია.
• მაგალითები: 6 + 2 = 8, 6 - 2 = 4, 6 * 2 = 12, 6 / 2 = 3, 6 / 0 → შეცდომა, 6 ^ 2 → უცნობი მოქმედება.

ერთი ფუნქცია calculate(a, op, b) გამოთვლას გააკეთებს და შედეგს დააბრუნებს. ბეჭდვა მის გარეთ იქნება, ისე, როგორც ფუნქციების მოდულში ვისწავლეთ.

გამოთვლა switch-ით

მოქმედების ნიშანი რამდენიმე ზუსტ ვარიანტს შორის ირჩევს, ამიტომ switch აქ იდეალურია:

function calculate(a, op, b) {
  switch (op) {
    case "+":
      return a + b;
    case "-":
      return a - b;
    case "*":
      return a * b;
    case "/":
      return a / b;
    default:
      return "უცნობი მოქმედება: " + op;
  }
}

console.log(calculate(6, "+", 2));   // 8
console.log(calculate(6, "*", 2));   // 12

ყურადღება მიაქციე: break აქ საჭირო არ არის. return ფუნქციას მაშინვე ასრულებს, ამიტომ შემდეგ case-ში „ჩავარდნა“ ვერ მოხდება.

ნულზე გაყოფა

რას იზამს JavaScript, თუ ნულზე გაყოფ? 6 / 0 შეცდომას არ იძლევა, არამედ აბრუნებს სპეციალურ რიცხვს Infinity, „უსასრულობა“. მათემატიკურად ეს უაზროა, მომხმარებლისთვის კი დამაბნეველი. ჯობს, ეს შემთხვევა ცალკე დავამუშაოთ:

function calculate(a, op, b) {
  switch (op) {
    case "+":
      return a + b;
    case "-":
      return a - b;
    case "*":
      return a * b;
    case "/":
      if (b === 0) {
        return "ნულზე გაყოფა შეუძლებელია";
      }
      return a / b;
    default:
      return "უცნობი მოქმედება: " + op;
  }
}

console.log(calculate(6, "/", 0));   // ნულზე გაყოფა შეუძლებელია

ასეთ შემოწმებას დაცვითი შემოწმება (guard) ჰქვია: ცუდ შემთხვევას თავიდანვე ვიჭერთ, სანამ ის რამეს გააფუჭებს.

შემოწმება მაგალითების სიით

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

let tests = [
  { a: 6, op: "+", b: 2, expected: 8 },
  { a: 6, op: "-", b: 2, expected: 4 },
  { a: 6, op: "/", b: 0, expected: "ნულზე გაყოფა შეუძლებელია" }
];

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

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

სცადე თავად

გაუშვი: ყველა ტესტი უნდა იყოს ✓. მერე დაამატე ტესტი, რომელიც უცნობ მოქმედებას ამოწმებს.

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

• ბეჭდვა ფუნქციის შიგნით. თუ calculate თვითონ ბეჭდავს, მისი შედეგით ტესტს ვეღარ გააკეთებ.
• case +: ბრჭყალების გარეშე. ნიშანი ტექსტია, ამიტომ case "+":.
• მხოლოდ „კარგი“ მაგალითების შემოწმება. ყველაზე მნიშვნელოვანი ტესტები ცუდ შემთხვევებზეა: ნული, უცნობი ნიშანი.

function calculate(a, op, b) {
  switch (op) {
    case "+":
      return a + b;
    case "-":
      return a - b;
    case "*":
      return a * b;
    case "/":
    case "%":
      if (b === 0) {
        return "ნულზე გაყოფა შეუძლებელია";
      }
      return op === "/" ? a / b : a % b;
    case "**":
      return a ** b;
    default:
      return "უცნობი მოქმედება: " + op;
  }
}

console.log(calculate(10, "%", 3));
console.log(calculate(2, "**", 5));
console.log(calculate(10, "%", 0));

მინი-ქვიზი

შეჯამება

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