ოპერაციები ცვლადებზე

სწვალა

მათმატიკური ოპერაციები

JavaScript-ს გააჩნია ყველა საბაზისო მათემატიკური ოპერაციის მხარდაჭერა:

შეკრება:

var x = 10;
var y = x + 50;

გამოკლება:

var x = 10;
var y = x – 50;

გამრავლება:

var x = 10;
var y = x * 50;

გაყოფა:

var x = 10;
var y = x / 50;

ნაშთი გაყოფისას (ოპერატორი %):

var x = 41;
var y = 7;
var z = x % y;
console.log(z); // 6

აბრუნებს 6-ს, რადგან 41 ზე ნაკლები ან ტოლი უდიდესი რიცხვი, რომელიც იყოფა 5-ზე არის 35, 41-35=6.

ინკრემენტი:

var x = 5;
x++; // x = 6

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

// პრეფიქსული ინკრემენტი
var x = 5;
var z = ++x;
console.log(x); // 6
console.log(z); // 6

// პოსტფიქსური ინკრემენტი
var a = 5;
var b = a++;
console.log(a); // 6
console.log(b); // 5

პოსტფიქსური ინკრემენტი შემდეგი ოპერაციის ანალოგიურია:

a = a + 1; // a++

დეკრემენტი

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

// პრეფიქსული დეკრემენტი
var x = 5;
var z = –x;
console.log(x); // 4
console.log(z); // 4

// პოსტფიქსური დეკრემენტი
var a = 5;
var b = a–;
console.log(a); // 4
console.log(b); // 5

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

var x = 10;
var y = 5 + (6 – 2) * –x;
console.log(y); //41

მინიჭების ოპერაციები

= : ანიჭებს ცვლადს გარკვეულ მნიშვნელობას:
var x = 10;
+= : შეკრება მნიშვნელობის შემდგომი მინიჭებით:

var a = 23;
a += 5; // იგივეა რაც a = a + 5
console.log(a); // 28

+= : გამოკლება მნიშვნელობის შემდგომი მინიჭებით:

var a = 23;
a -= 5; // იგივეა რაც a = a – 5
console.log(a); // 18

*= : გამრავლება მნიშვნელობის შემდგომი მინიჭებით:

var a = 20;
a *= 5; // იგივეა რაც a = a * 5
console.log(a); // 100

/= : გაყოფა მნიშვნელობის შემდგომი მინიჭებით:

var a = 20;
a /= 5; // იგივეა რაც a = a / 5
console.log(a); // 4

%= : გაყოფის ნაშთი მნიშვნელობის შემდგომი მინიჭებით:

var a = 23;
a % = 5; // იგივეა რაც a = a % 5
console.log(a); // 3

შედარების ოპერატორები

როგორც წესი, პირობის შესამოწმებლად გამოიყენება შედარების ოპერატორები. ისინი ადარებენ ორ მნიშვნელობას და აბრუნებენ true ან false-ს.:

== : ტოლობის ოპერატორი ადარებს ორ მნიშვნელობას და თუ ისინი ტოლია, აბრუნებს true-ს, თუ არა და – false-ს: x == 5.
=== : იგივეობის ოპერატორი ადარებს ორ მნიშვნელობას და მათ ტიპს, და თუ ისინი ტოლია და ერთი და იგივე ტიპი აქვთ, აბრუნებს true-ს, თუ არა და – false-ს: x === 5.
!= : ადარებს ორ მნიშვნელობას და თუ ისინი განსხვავდებიან, აბრუნებს true-ს, თუ არა და – false-ს x != 5.
!== : ადარებს ორ მნიშვნელობას და მათ ტიპს თუ ისინი განსხვავდებიან მნიშვნელობით ან ტიპით, აბრუნებს true-ს, თუ არა და – false-ს x !== 5.
> : ადარებს ორ მნიშვნელობას და თუ პირველი მეტია მეორეზე, აბრუნებს true-ს, თუ არა და – false-ს: x > 5.
< : ადარებს ორ მნიშვნელობას და თუ პირველი ნაკლებია მეორეზე, აბრუნებს true-ს, თუ არა და – false-ს: x < 5.

= : ადარებს ორ მნიშვნელობას და თუ პირველი მეტია ან ტოლი მეორეზე, აბრუნებს true-ს, თუ არა და – false-ს: x >= 5.
<= : ადარებს ორ მნიშვნელობას და თუ პირველი ნაკლებია ან ტოლი მეორეზე, აბრუნებს true-ს, თუ არა და – false-ს: x <= 5.
ყველა ეს ოპერატორი საკმაოდ მარტივია, გარდა ტოლობის და იგივეობის ოპერატორებისა. ისინი ორივე ადარებენ მნიშვნელობას, მაგრამ მეორე მწედველობაში იღებს ასევე მნიშვნელობის ტიპს. მაგალითად:

var income = 100;
var strIncome = “100”;
var result1 = income == strIncome;
var result2 = income === strIncome;
console.log(result1); //true
console.log(result2); //false

ორივე შემთხვევაში ხდება ორი ცვლადის შედარება, პირველ შემთხვევაში ტოლობის, მეორე შემთხვევაში – იგივეობის ოპერატორით. პირველ შემთხვევაში ვღებულობთ true-ს, რადგან მათი მნიშვნელობები ტოლია, ხოლო მეორე შემთხვევაში false-ს, რადგან მიუხედავად მნიშვნელობების ტოლობისა, მათ გააჩნიათ სხვადასხვა ტიპი (ერთი რიცხვია, მეორე – სტრიქონი).

ანალოგიურად მუშაობს უტოლობის ოპერატორები != და !==.

ლოგიკური ოპერაციები

ლოგიკური ოპერაციები გამოიყენება ორი შედარების ოპერაციის შედეგის გასაერთიანებლად. ჯავასკრიპტში არის შემდეგი შედარების ოპერაციები:

&&: აბრუნებს true-ს, თუ შედარების ორივე ოპერაცია აბრუნებს true-ს, წინააღმდეგ შემთხვევაში აბრუნებს false-ს:

var income = 100;
var percent = 10;
var result = income > 50 && percent < 12;
console.log(result); //true

||: აბრუნებს true-ს, თუ შედარების ერთ-ერთი ოპერაცია მაინც აბრუნებს true-ს, წინააღმდეგ შემთხვევაში აბრუნებს false-ს:

var income = 100;
var isDeposit = true;
var result = income > 50 || isDeposit == true;
console.log(result); //true

! : აბრუნებს true-ს, თუ შედარების ეოპერაცია აბრუნებს false-ს, წინააღმდეგ შემთხვევაშია ბრუნებს false-ს:

var income = 100;
var result1 = !(income > 50);
console.log(result1); // false, რადგანაც income > 50 აბრუნებს true

var isDeposit = false;
var result2 = !isDeposit;
console.log(result2); // true

ოპერაციები სტრიქონებზე

სტრიქონებს შეუძლიათ გამოიყენონ ოპერატორი + სტრიქონების გასაერთიანებლად. მაგალითად:

var name = “ტომ”;
var surname = “სოიერი”
var fullname = name + ” ” + surname;
console.log(fullname); //ტომ სოიერი

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

var name = “ტომ”;
var fullname = name + 256;
console.log(fullname); //ტომ256

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

<!DOCTYPE html>
<html>
<head>
<meta charset=”utf-8″ />
<title>JavaScript</title>
</head>
<body>
<script>
var sum = 500; // ანაბრის თანხა
var percent = 10; // პროცენტი ანაბარზე
var income = sum * percent / 100; //შემოსავალი ანაბრის მიხედვით
sum = sum + income; // განვსაზღვროთ ახალი თანხა
console.log(“შემოსავალი ანაბარზე: ” + income);
console.log(“ანაბრის თანხა პირველი წლის შემდეგ: ” + sum);
</script>
</body>
</html>

წყარო: webschool.ge