JavaScript: ოპერატორები. არითმეტიკული ოპერატორები JavaScript-ში

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

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

სხვა პროგრამირებისგან განსხვავებით, JavaScript-ს აქვს მხოლოდ ერთი ციფრული მონაცემთა ტიპი; ეს არ ეხება მცურავი პუნქტიანი ნომრებს.

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

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

არითმეტიკული ოპერატორები არის სიმბოლოები, რომლებიც წარმოადგენენ მათემატიკურ ოპერაციებს და ატრიალებენ შედეგს. მაგალითად, 3 + 7 = 10 სიმბოლო + მიუთითებს დასაკეცი ოპერაციის სინტაქსზე.

არსებობს მრავალი JavaScript ოპერატორი, რომელსაც იცნობთ საბაზისო მათემატიკიდან, ისევე როგორც რამდენიმე დამატებითი ოპერატორი.

ყველა JavaScript არითმეტიკული ოპერატორი წარმოდგენილია შემდეგ ცხრილში.

ოპერატორი	Სინტაქსი	კონდახი	ვაზნაჩენნია
დოდავანია	+	x+y	ჯამი x და y
Vіdnіmannya	—	x - y	განსხვავება x და y-ს შორის
რეპროდუქცია	*	x*y	ფოხიდნე x და y
პოდილ	/	x/y	პირადი x და y
მოდული	%	x % y	ჭარბი x/y
Აღმასვლა	**	x**y	x საფეხურზე y
მატება	++	x++	x პლუს ერთი
შემცირება	—	x-	x მინუს ერთი

დასაკეცი და მოხსნა

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

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

მარტივი რიცხვებით ოპერაციების გარდა, JavaScript გაძლევთ საშუალებას დაამატოთ რიცხვები მარტივ რიცხვებს და გამოაკლოთ გამოთვლები. მაგალითად, შეგიძლიათ რიცხვითი მნიშვნელობები მიანიჭოთ x-ს და y-ს, ხოლო შედეგი განათავსოთ z-ში.

// მიანიჭეთ მნიშვნელობები x და y
მოდით x = 10;
მოდით y = 20;
//დაამატეთ x და y და მივანიჭეთ ჯამი z-ს
მოდით z = x + y;
console.log(z);
30

// მიანიჭეთ მნიშვნელობები x და y
მოდით x = 10;
მოდით y = 20;
// გამოვაკლოთ x y-ს და სხვაობა მივწეროთ z-ს
მოდით z = y - x;
console.log(z);
10

// მიანიჭეთ მნიშვნელობები x და y
მოდით x = -5,2;
მოდით y = 2,5;
// გამოვაკლოთ y x-ს და სხვაობა მივწეროთ z-ს
მოდით z = x – y;
console.log(z);
-7.7

JavaScript-ს აქვს ერთი განსაკუთრებული ფუნქცია, რომელიც არის რიცხვებისა და სერიების დამატების შედეგი. ვიცით, რომ 1 + 1 უდრის 2-ს, მაგრამ შედეგი განსხვავებულია.

მოდით x = 1 + "1";
console.log(x);
x ტიპის;
11
"სტრიქონი"

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

JavaScript ხშირად გამოიყენება ნავიგაციის ზოლის გადასახვევად.

ფუნქცია scrollToId() (
const navheight = 60;
window.scrollTo(0, window.pageYOffset - navHeight);
}
window.addEventListener("hashchange", scrollToId);

ამ პარამეტრში, პანელი გადახვევს 60 პიქსელს ID-დან.

გამრავლება და გაყოფა

გამრავლება და sub-JavaScript ოპერატორები გამოიყენება მსგავსი და პირადი რიცხვითი მნიშვნელობების მოსაძებნად.

ვარსკვლავი გამრავლების ოპერატორია.

// მიანიჭეთ მნიშვნელობები x და y
მოდით x = 20;
მოდით y = 5;
// გავამრავლოთ x y-ზე, რომ მიიღოთ პროდუქტი
მოდით z = x * y;
console.log(z);
100

გაყიდვების გადასახადის შემოღების შემდეგ შესაძლებელია პროდუქტის ფასის გამრავლება.

const ფასი = 26.5; // ნივთის ფასი გადასახადამდე
const taxRate = 0.082; // 8,2% გადასახადის განაკვეთი
// გამოთვალეთ ჯამი გადასახადის შემდეგ 2 ათწილადამდე
მოდით totalPrice = ფასი + (ფასი *გადასახადის განაკვეთი);
totalPrice.toFixed(2);
console.log("Total:", totalPrice);
სულ: 28.67

Slish არის ქვეოპერატორი.

// მიანიჭეთ მნიშვნელობები x და y
მოდით x = 20;
მოდით y = 5;
// გაყავით y x-ად ციტატის მისაღებად
მოდით z = x/y;
console.log(z);
4

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

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

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

მაგალითად, ვიცით, რომ 9 იყოფა 3-ზე გადაჭარბების გარეშე:

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

// ფუნქციის ინიცირება ტესტირებისთვის, თუ რიცხვი ლუწია
const isEven = x => (
// თუ ნაშთი ორზე გაყოფის შემდეგ არის 0, დააბრუნეთ true
თუ (x % 2 === 0) (
დაბრუნება true;
}
// თუ რიცხვი კენტია, დააბრუნეთ false
დაბრუნება false;
}
// ნომრის ტესტირება
isEven (12);
მართალია

ამ შემთხვევაში 12 იყოფა 2-ზე, რაც იგივე რიცხვია.

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

Აღმასვლა

Staged არის JavaScript-ის ერთ-ერთი უახლესი ოპერატორი. შეკრების სინტაქსი არის ორი ვარსკვლავი ყოველი (**) შემდეგ.

მაგალითად, მეხუთე საფეხურზე 10 (10^5) ასე იწერება:

10 ** 5;
100000

ოპერაცია 10**5 იძლევა იგივე შედეგს, რაც 10*10, მეორდება 5-ჯერ.

10 * 10 * 10 * 10 * 10;

ეს ოპერაცია ასევე შეიძლება დაიწეროს Math.pow() მეთოდის გამოყენებით.

Math.pow(10, 5);
100000

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

მატება და შემცირება

ინკრემენტის და შემცირების ოპერატორები ზრდის ან ცვლის ცვლადის რიცხვით მნიშვნელობას ერთით. ისინი წარმოდგენილია ორი პლუსით (++) და ორი მინუსით (-) და ხშირად გამოიყენება ციკლებში.

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

7++
Uncapped ReferenceError: არასწორი მარჯვენა მარცხენა მხარე პოსტფიქსის ოპერაციაში

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

პრეფიქსის ზრდა იწერება როგორც ++x.

//ცვლადის დაყენება
მოდით x = 7;

მოდით პრეფიქსი = ++x;
console.log (პრეფიქსი);
8

x-ის მნიშვნელობა გაიზარდა 1-ით. პოსტფიქსის ზრდა იწერება როგორც y ++.

//ცვლადის დაყენება
მოდით y = 7;
// გამოიყენეთ პრეფიქსის გაზრდის ოპერაცია
მოდით პოსტფიქსი = y++;
console.log(postfix);
7

პოსტფიქსის ოპერაციამ მნიშვნელობა არ გაზარდა. ეს ღირებულება მანამდე არ გაიზრდება და არ იქნება დაფასებული. რისთვისაც საჭიროა dvich ოპერაციის გაშვება:

მოდით y = 7;
y++;
y++;
console.log(y);
8

ყველაზე ხშირად, ეს ოპერატორები კონცენტრირებულია მარყუჟებში. ოპერატორის ეს ციკლი გადის 10-ჯერ, დაწყებული 0-დან.

// მარყუჟის გაშვება ათჯერ
ამისთვის (დავცეთ i = 0; i< 10; i++) {
console.log(i);
}
0
1
2
3
4
5
6
7
8
9

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

უფრო მარტივი სიტყვებით რომ ვთქვათ, x++ შეიძლება შემცირდეს x = x + 1-ით, ხოლო x შეიძლება შემცირდეს x = x – 1-ით.

ოპერატორები არიან პრივილეგირებული

ერთ-ერთი ყველაზე ხშირად გამოყენებული ოპერატორია დანართის ოპერატორი, რომელიც უკვე ნახსენებია ამ სახელმძღვანელოში. წარმოდგენებში არის მონდომების ნიშანი (=). სიმბოლო = vikorystvaetsya მემარჯვენე ცვალებადი ბოროტების ღირებულებისთვის.

// ასაკის ცვლადს მიანიჭეთ 27
ასაკი = 27;

გარდა სტანდარტული JavaScript მინიჭების ოპერატორისა, არსებობს საწყობის მინიჭების ოპერატორები, რომლებიც აერთიანებენ არითმეტიკულ ოპერატორს = ოპერატორთან.

მაგალითად, ოპერატორი ამატებს გამომავალი მნიშვნელობიდან და ამატებს ახალ მნიშვნელობას.

// ასაკის ცვლადს მიანიჭეთ 27
ასაკი = 27;
ასაკი += 3;
console.log(ასაკი);
30

ვლასნე, ასაკი += 3 – იგივეა, რაც i ასაკი = ასაკი + 3.

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

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

ოპერატორის პრიორიტეტი

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

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

// ჯერ გაამრავლეთ 3 5-ზე, შემდეგ დაამატეთ 10
10 + 3 * 5;
25

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

// ჯერ დაამატეთ 10 და 3, შემდეგ გაამრავლეთ 5-ზე
(10 + 3) * 5;
65

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

გაზრდა/კლება, გამრავლება/გაყოფა და დაკეცვა/აცილება მაინც შეიძლება იყოს პრიორიტეტი.

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

ტეგები:

ოპერატორის ასაკი

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

ოპერატორის ასაკი, ყველაზე დაბალიდან ყველაზე მაღალი, იქნება შემდეგი:

მინიჭებული =+=-=*=/=%=<<=>>=>>>=&=^=|=

ვიბრა გონების უკან? :

Logicne ABO ||

ლოგიკური მე&&

პობიტოვი ABO |

ნელ-ნელა გამორთეთ ^

პობიტოვი მე&

Ნერვიული! =

ეჭვიანობა/ნერვიულობა == !=

პორივნიანია<<=>> =

პობიტოვის განადგურება<<>>>>>

დამატება/გაგზავნა + -

გამრავლება/ქვე*/%

ჩამოთვლილი/დამატებითი/ერთიანი მინუს/ნამატი/კლება! ~ - ++ --

დააწკაპუნეთ, დაამატეთ პარამეტრები () .

დაჯავშნილი საკვანძო სიტყვები JavaScript-ში.

JavaScript-ს აქვს საკვანძო სიტყვების დაბალი რეზერვები. ეს სიტყვები სამი ტიპისაა: ჯავასკრიპტის რეზერვირებული სიტყვები, მომავლისთვის დაცული სიტყვები და საცხოვრებლად უნიკალური სიტყვები. JavaScript საკვანძო სიტყვები

break false ამ სიცარიელეში

გააგრძელეთ ახალი ჭეშმარიტი ხოლო

წაშალეთ ფუნქცია null typeof with

სხვა თუ დაბრუნების var

JavaScript საკვანძო სიტყვები მომავლისთვის

ქეისის გამართვის ექსპორტი სუპერ

catch default extends switch

კლასმა საბოლოოდ ჩააგდოს

const enum import try

ცხოვრებაში უნიკალური სიტყვები არის ის, რაც უკვე ჩანს შიდა ობიექტებისა და JavaScript ფუნქციების სახელებში. ეს მოიცავს სიტყვებს, როგორიცაა String და parseInt.

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

var text = new String("ეს არის სიმებიანი ობიექტი");

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

სცენარები. სცენარების შექმნა.

JavaScript არის ჩემი სკრიპტი (სკრიპტები), რომლებიც ძირითადად გამოიყენება ვებ გვერდებზე ინტერაქტიული ელემენტების შესაქმნელად. მისი გამოყენება შეგიძლიათ მენიუს საჩვენებლად, შეამოწმოთ, რომ ფორმები სწორად არის შევსებული, შეცვალოთ სურათი ან სხვა რამ, რისი გაკეთებაც შეგიძლიათ ვებსაიტზე. თუ გადახედავთ GoogleMaps-ს ან Google-ის GMail სერვისს, ხედავთ, რისთვის გამოიყენება დღეს JavaScript.

ვინაიდან JavaScript ამჟამად ერთადერთი სკრიპტია, რომელსაც მხარს უჭერს ყველა ძირითადი ვებ ბრაუზერი (Internet Explorer, Firefox, Netscape, Safari, Opera, Camino და ა.

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

JavaScript კოდის დაწერისას საჭიროა მხოლოდ ტექსტური რედაქტორი და ვებ ბრაუზერი. HTML-ისა და CSS-ის ცოდნა ძალიან დადებით როლს თამაშობს და თუ გსურთ ისწავლოთ JavaScript-ის უნარები ვებსაიტზე, ასევე დაგჭირდებათ ვებ-გვერდი. თუ უკვე გაქვთ ვებსაიტი, ეს მშვენიერია! ამასთან, არ არსებობს ჰონორარის გარეშე სერვერები, რომელთა გამოყენება შეგიძლიათ თქვენი გვერდების განსათავსებლად.

რაც შეეხება ტექსტის რედაქტორს, Windows არის NotePad რედაქტორი. თუ გსურთ JavaScript, HTML და CSS რედაქტირება, უფრო მძლავრი რედაქტორი, როგორიცაა EditPlus ან სხვა, შეიძლება იყოს მოსახერხებელი.

ახლა თქვენ შეგიძლიათ გადახვიდეთ JavaScript სკრიპტის შექმნაზე!

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

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

ქვემოთ მოცემულია JavaScript კოდის დასაკავშირებლად ორი გზა:

სკრიპტის ფუნქციები.

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

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

ქვემოთ მოცემული წარმომადგენლობების დავალების ფუნქციის ფარული ფორმა:

ფუნქციის სახელი ([პარამეტრი 1] [, პარამეტრი 2] [..., პარამეტრი N])

სხეულის ფუნქციების რიგები

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

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

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

1. ფილმის ობიექტების გაცნობა. ეს ობიექტები გამოიყენება სხვა ტიპის მონაცემებთან მუშაობისთვის ან სტანდარტული ამოცანების შესაქმნელად (მაგალითად, Math, String, Date და ა.შ. ობიექტები). ობიექტების შექმნამდე ხშირად საჭიროა ობიექტის (ან მათემატიკის) დუბლიკატის ასლის შექმნა.

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

3. კორისტუვაჩის საგნები. ისინი შექმნილია როგორც საცალო ვაჭრობა ნებისმიერი კონკრეტული საჭიროებისთვის. ძლიერი ობიექტების შექმნას დასჭირდება პირველი პრინციპები და სრული განვითარება.

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

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

ობიექტი

object.method()

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

// ვიკლიშის თარჯიმანი METHOD open()

// თარჯიმანი shukatime Power ღია,

// არ ვიცი რას აკეთებ

8. სპეციალური JavaScript ოპერატორები.

?: საშუალებას გაძლევთ viscont უბრალოდ "თუ...მაშინ...სხვა"

აფასებს ორ გამონათქვამს და აბრუნებს მეორე გამონათქვამის შედეგს.

delete გაძლევთ საშუალებას წაშალოთ ობიექტის ან ელემენტის სიმძლავრე მასივში წინა ინდექსით.

ახალი გაძლევთ საშუალებას შექმნათ სურათები ობიექტის ტიპისთვის, რომელიც მითითებულია მომხმარებლის მიერ, ან შექმნილი ობიექტების ერთ-ერთი ტიპი.

ეს არის საკვანძო სიტყვა, ასე რომ თქვენ შეგიძლიათ გამოიყენოთ იგი ობიექტის დინებაში მისასვლელად.

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

void void ოპერატორი ნიშნავს ტიპს, რომელიც შეიძლება შეფასდეს მნიშვნელობის შეცვლის გარეშე.

9. ოპერატორის პრიორიტეტები JavaScript-ში.

ოპერატორის ასაკი

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

ოპერატორის ასაკი, ყველაზე დაბალიდან ყველაზე მაღალი, იქნება შემდეგი:

მინიჭებული =+=-=*=/=%=<<=>>=>>>=&=^=|=

ვიბრა გონების უკან? :

Logicne ABO ||

უფრო ლოგიკური &&&

პობიტოვი ABO |

ნელ-ნელა გამორთეთ ^

პობიტოვი მე &

Ნერვიული! =

ეჭვიანობა/ნერვიულობა == !=

პორივნიანია<<=>> =

პობიტოვის განადგურება<< >> >>>

დამატება/გაგზავნა + -

გამრავლება/ქვე*/%

ჩამოთვლილი/დამატებითი/ერთიანი მინუს/ნამატი/კლება! ~ - ++ --

დააწკაპუნეთ, დაამატეთ პარამეტრები () .

JavaScript ვირუსებიარის კომბინაციები ოპერანდებიі ოპერატორები.

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

ბრინჯი.

1. JavaScript ვირუსის სტრუქტურაოპერანდი

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

ოპერანდების რაოდენობის მიხედვით განასხვავებენ ოპერატორების შემდეგ ტიპებს:
ერთიანი- ოპერაცია მოიცავს ერთ ოპერანდს;
ორობითი- ოპერაციაში მონაწილეობს ორი ოპერანდი;
სამეული— აერთიანებს სამ ოპერანდს.

გამოხატვის უმარტივესი ფორმა სიტყვასიტყვით- კარგად, თავისთავად შეიძლება გამოითვალოს, მაგალითად, რიცხვი 100, "გამარჯობა სამყაროს" რიგი. ცვლილება ასევე შეიძლება იყოს ვირუსი, რადგან ის გამოითვლება მოცემული მნიშვნელობით.

ვირუსები და ოპერატორები JavaScript-ში

1. არითმეტიკული ოპერატორები

არითმეტიკული ოპერატორებიშექმნილია მათემატიკური ოპერაციებისთვის, ისინი მუშაობენ რიცხვითი ოპერანდებით (ან ცვლადი ოპერანდებით, რომლებიც ინახავენ რიცხვით მნიშვნელობებს), რომლებიც ბრუნავენ რიცხვითი მნიშვნელობის შედეგად.

თუ ერთ-ერთი ოპერანდი მწკრივშია, JavaScript თარჯიმანი შეეცდება გადაიყვანოს იგი ციფრულ ტიპად და შემდეგ შეასრულოს შესაბამისი ოპერაცია. თუ შეუძლებელია ტიპების ხელახლა შექმნა, შედეგი იქნება NaN (არა რიცხვი).

ცხრილი 1. არითმეტიკული ოპერატორები

ოპერატორი/ოპერაცია	აღწერა	პრიორიტეტი
+ადდავანია	ამატებს რიცხვითი ოპერანდებს. თუ ერთ-ერთი ოპერანდი არის მწკრივი, მაშინ გამოხატვის შედეგი იქნება მწკრივი.	12
- ვიდნიმანია	გარდაქმნის სხვა ოპერანდს პირველიდან.	12
- უნიალური მინუსი	ის აქცევს დადებით რიცხვს უარყოფითად და იგივე მიზეზის გამო.	14
* გამრავლება	ამრავლებს ორ ოპერანდს.	13
/ პოდილ	ყოფს პირველ ოპერანდს მეორეზე. გაყოფის შედეგი შეიძლება იყოს მთელი რიცხვი ან რიცხვი მცურავი წერტილით.	13
% დაყოფა მოდულზე (ჭარბი ქვედანაყოფში)	ითვლის ჭარბი რაოდენობას, რომელიც ამოღებულია, როდესაც პირველი ოპერანდი მთლიანად იყოფა მეორეზე. ის შემოიფარგლება როგორც მთელი რიცხვებით, ასევე მცურავი წერტილის მქონე რიცხვებით.	13

var x = 5, y = 8, z; z = x + y; // როტაცია 13 z = x - y; // როტაცია -3 z = - y; // როტაცია -8 z = x * y; // როტაცია 40 z = x / y; // როტაცია 0,625 z = y% x; // შემობრუნება 3

2. ოპერატორები არიან პრივილეგირებული

ოპერატორები არიან პრივილეგირებული Vykoristovyvayutsya მინიჭება მნიშვნელობა ცვლილებები. კომბინირებული ოპერატორები საშუალებას გაძლევთ შეინახოთ პირველი და ბოლო მნიშვნელობები ერთ ცვლილებაში.

var a = 5; // ცვლადს მივანიჭოთ რიცხვითი მნიშვნელობა 5 var b = "hello"; // მწკრივის შენახვა hellow var m = n = z = 10; // ექვემდებარება ცვლადს m, n, z რიცხვით მნიშვნელობებს 10 x + = 10; // ტოლია x = x + 10; x -= 10; // ტოლია x = x – 10; x * = 10; // ტოლია x = x * 10; x /= 10; // უდრის x = x/10; x% = 10; // უდრის x = x%10;

3. ზრდა და შემცირება ოპერატორები

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

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* ბოლოს გამოთვალეთ საპირისპირო მნიშვნელობა z = 12, x = 6, შემდეგ. x-ის მნიშვნელობა თავდაპირველად იზრდება 1-ით, შემდეგ კი გამრავლების ოპერაცია მთავრდება */s = y++*2; /* საბოლოოდ გამოთვალეთ საპირისპირო მნიშვნელობები s = 10, y = 6, შემდეგ. თავდაპირველად სრულდება გამრავლების ოპერაცია და y-ის შეცვლის შემდეგ შეინახება 1 მნიშვნელობის ზრდა */ k = --m * 2; // მნიშვნელობების როტაცია k = 8, m = 4 l = n-- * 2; // მნიშვნელობების როტაცია l = 10, n = 4

4. ნიველირებადი ოპერატორები

ოპერატორები vykoristovuyutsya ოპერანდების კორექტირებისთვის, გამოხატვის შედეგი შეიძლება იყოს ორი მნიშვნელობიდან ერთ-ერთი - true ან false. ოპერანდები შეიძლება იყოს არა მხოლოდ რიცხვები, არამედ რიგები, ლოგიკური მნიშვნელობები და ობიექტები. განტოლება ასევე შეიძლება გამოითვალოს რიცხვებისა და მწკრივებისთვის, ასე რომ, ოპერანდები, როგორიცაა რიცხვები და რიგები, გარდაიქმნება.

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

ვინაიდან ოპერანდები არის რიგები/ნომრები ან შეიძლება გარდაიქმნას მწკრივებად/ციფრებად, ისინი მორგებული იქნება მწკრივების/ნომრების მსგავსად.

თუ ერთი ოპერანდი არის მწკრივი / გარდაიქმნება მწკრივად, ხოლო მეორე არის რიცხვი / გარდაიქმნება რიცხვად, ოპერატორი შეეცდება მწკრივი გადაიყვანოს რიცხვად და შემდეგ გაათანაბროს რიცხვები. თუ სერია არ არის რიცხვი, ის გარდაიქმნება NaN-ში და კორექტირების შედეგი იქნება ყალბი.

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

ცხრილი 4. ოპერატორები

ოპერატორი/ოპერაცია	აღწერა	პრიორიტეტი
== ეჭვიანობა	ამოწმებს ორ მნიშვნელობას აღდგენისთვის, რაც იძლევა ტიპების შებრუნების საშუალებას. გამოდის true, თუ ოპერანდები თავიდან არის აცილებული, და false, თუ ისინი განსხვავებულია.	9
!= ნერვიულობა	აბრუნებს true, რადგან ოპერანდები არ არის ტოლი	9
=== ვინაობა	ის ამოწმებს ორ ოპერანდს „იდენტურობაზე“, რაც უზრუნველყოფს ერთსა და იმავე შედეგებს. ბრუნავს true ტოლ ოპერანდებზე დაყრდნობით, ტიპების შებრუნების გარეშე.	9
!== არაიდენტურობა	ამთავრებს პირადობის შემოწმებას. აბრუნებს true, რადგან ოპერანდები არ არის ტოლი ტიპების შებრუნების გარეშე.	9
> მეტი	აბრუნებს true თუ პირველი ოპერანდი მეორეზე დიდია, წინააღმდეგ შემთხვევაში აბრუნებს false.	10
>= ერთზე მეტი	აბრუნებს true, თუ პირველი ოპერანდი არ არის ნაკლები მეორეზე და აბრუნებს false-ს მეორე შემთხვევაში.	10
	აბრუნებს true თუ პირველი ოპერანდი მეორეზე ნაკლებია, ხოლო მეორე შემთხვევაში აბრუნებს false.	10
	აბრუნებს true, თუ პირველი ოპერანდი არ არის მეორეზე დიდი, წინააღმდეგ შემთხვევაში, აბრუნებს false;	10

5 == "5"; // ჩართეთ სიმართლე 5! = -5.0; // Turn true 5 === "5"; // turn false false === false; // ჩართეთ სიმართლე 1! == მართალია; // ჩართეთ სიმართლე 1! = მართალია; // turn false, ფრაგმენტები true გარდაიქმნება 1 3 > -3; // turn true 3> = "4"; // ცრუ გადაქცევა

5. ლოგიკური ოპერატორები

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

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); // ჩართეთ true, თუ x-ის მნიშვნელობა არის 0-დან 10-მდე! ყალბი; // ჭეშმარიტი

6. ბიტის ოპერატორები

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

ცხრილი 6. ბიტის ოპერატორები

ოპერატორი/ოპერაცია	აღწერა	პრიორიტეტი
&ბიტიურად მე	თუ დანაშაული უდრის 1-ს, მაშინ მიღებული ბიტი უდრის 1-ს. წინააღმდეგ შემთხვევაში, შედეგი იგივე იქნება, რაც 0.	8
| Bitwise ABO	თუ რომელიმე ოპერანდი ათავსებს 1-ს პოზიციაზე, შედეგი ასევე დააყენებს 1-ს ამ პოზიციაზე, წინააღმდეგ შემთხვევაში ამ პოზიციაზე შედეგი იქნება 0-ის ტოლი.	6
↑ Wiklyuchne ABO	თუ ერთი და მხოლოდ ერთი მნიშვნელობა მოთავსებულია 1 ნებისმიერ პოზიციაზე, მაშინ შედეგი განთავსდება 1 ამ პოზიციაზე, წინააღმდეგ შემთხვევაში ამ პოზიციაზე შედეგი იქნება 0-ის ტოლი.	7
~ ზაპერეჩენნია	ვირუსის მნიშვნელობის ორ გამონათქვამზე ბიტური აღრიცხვის ოპერაცია დასრულებულია. ნებისმიერი პოზიცია, რომელიც ათავსებს 1-ს გამომავალ გამოსახულებაში, იცვლება 0-ით. ნებისმიერი პოზიცია, რომელიც ათავსებს 0-ს გამომავალ გამოსახულებაში, უდრის 0-ს. დადებითი რიცხვები იწყება 0-ით, უარყოფითი რიცხვები იწყება -1-ით და ~ n == -(n+1) .	14
	ოპერატორი ანიჭებს პირველი ოპერანდის ბიტებს მარცხნივ მეორე ოპერანდის მიერ ჩასმული ბიტების პოზიციების რაოდენობის მიხედვით. მარჯვენა ხელის პოზიციის დასასრულებლად გამოიყენება ნულები. შეატრიალეთ შედეგი იმავე ტიპზე, როგორც მარცხენა ოპერანდი.	11
>> Bitwise zsuv მარჯვენა ხელი	ოპერატორი ანიჭებს პირველი ოპერანდის ბიტებს მარჯვნივ მეორე ოპერანდის მიერ ჩასმული ბიტების პოზიციების რაოდენობას. დიაპაზონს შორის მოთავსებული ნომრები ჩანს. უმაღლესი ბიტი (32-ე) არ იცვლება შედეგის ნიშნის შესანარჩუნებლად. თუ პირველი ოპერანდი დადებითია, შედეგის უმაღლესი ბიტები შეიცვლება ნულებით; თუ პირველი ოპერანდი უარყოფითია, შედეგის უმაღლესი ბიტები დაყენდება ერთზე. მარჯვნივ მნიშვნელობის დამატება ერთი პოზიციით უდრის 2-ის გაყოფას (დამატებული მონაცემებით), ხოლო მარჯვნივ გადასასვლელი ორი პოზიციით არის 4-ის გაყოფის ტოლფასი და ა.შ.	11
>>> Bitwise zsuv მარჯვენა ხელით ნიშნის გარეშე	ოპერატორი ანიჭებს პირველი ოპერანდის ბიტებს მარჯვნივ მეორე ოპერანდის მიერ ჩასმული ბიტების პოზიციების რაოდენობას. მარცხნივ, ნულები ემატება პირველი ოპერანდის ნიშნისგან დამოუკიდებლად. დიაპაზონს შორის მოთავსებული ნომრები ჩანს.	11

var x = 9, y = 5, z = 2, s = -5, შედეგი; // 9 უდრის 1001-ს; 5 უდრის 0101 შედეგს = x & y; // როტაცია 1 (ექვივალენტური 0001) შედეგი = x | y; // როტაცია 13 (ექვივალენტური 1101) შედეგი = x ^ y; // მხრივ 12 (ექვივალენტური 1100) შედეგი = ~ y; // შემობრუნება -6 (ექვივალენტური 1100) შედეგი = x<< y; // вернет 288 (эквивалентно 100100000) result = x >> z; // Turn 2 (10-ის ექვივალენტი) შედეგი = s >>> z; // შემობრუნება 1073741822 (ექვივალენტური)

7. სიმებიანი ოპერატორები

არსებობს მთელი რიგი ოპერატორები, რომლებიც მუშაობენ რიგებში სპეციალურად.

"1" + "10"; // როტაცია "110" "1" + 10; // შემობრუნება "110" 2 + 5 + "ფერადი ზეთისხილი"; // ჩართეთ "7 ფერადი ზეთისხილი" "ფერადი ზეთისხილი" + 2 + 5; // Turn "Color olives 25" "1" > "10"; // ცრუ "10"<= 10; // вернет true "СССР" == "ссср"; // вернет false x = "micro"; x+= "soft"; // вернет "microsoft"

8. სპეციალური ოპერატორები

ცხრილი 8. სპეციალური ოპერატორები

ოპერატორი/ოპერაცია	აღწერა	პრიორიტეტი
. სიმწარემდე დადუღდა	უზრუნველყოფს წვდომას ობიექტის ბირთვთან.	15
, მრავალჯერადი გამოთვლები	ითვლის მთელ რიგ დამოუკიდებელ გამონათქვამებს, რომლებიც დაწერილია ერთ რიგში.	1
მასივის ინდექსაცია	ეს საშუალებას აძლევს წვდომას ობიექტის მასივის ელემენტებზე ან ავტორიტეტებზე.	15
() ვიკლიკის ფუნქციები, დაჯგუფება	ჯგუფური ოპერაციები იძახებს ფუნქციას.	15
typeof მითითებულია მონაცემთა ტიპზე	უნარული ოპერატორი აბრუნებს ოპერანდის მონაცემთა ტიპს.	14
ობიექტის ტიპის შემოწმების მაგალითი	ოპერატორი ამოწმებს არის თუ არა ობიექტი სასიმღერო კლასის მაგალითი. მარცხენა ოპერანდი არის ობიექტი, მარჯვენა ოპერანდი დამნაშავეა ობიექტის კლასის მიმართ. შედეგი იქნება ჭეშმარიტი, თუ ობიექტი, რომელიც მინიჭებულია მემარცხენეზე, არის კლასის მაგალითი, რომელიც მინიჭებულია მემარჯვენეზე, წინააღმდეგ შემთხვევაში ის იქნება false.	10
სიყვითლის არსებობის შემოწმებაში	მარცხენა ოპერანდი არის მწკრივი, ხოლო მარჯვენა არის მასივი ან ობიექტი. ვინაიდან მარცხენა მნიშვნელობა არის ობიექტის სიმძლავრე, შედეგი არის ჭეშმარიტი შემობრუნებისთვის.	10
ობიექტის ახალი შექმნა	ოპერატორი ქმნის ახალ ობიექტს უმნიშვნელო ავტორიტეტებით, შემდეგ იძახებს კონსტრუქტორის ფუნქციას მისი ინიციალიზაციისთვის (პარამეტრების გადაცემა). თქვენ ასევე შეგიძლიათ ჩაერთოთ მასივის შექმნაში.	1
წაშალე Vidalennya	ოპერატორი საშუალებას გაძლევთ ამოიღოთ ობიექტის ან ელემენტის სიმძლავრე მასივიდან. აბრუნებს true თუ ოპერაცია წარმატებული იყო, წინააღმდეგ შემთხვევაში აბრუნებს false. მოცემული ელემენტის არჩევის შემდეგ, მისი dowzhin-ის მასივი არ იცვლება.	14
void მნიშვნელობა viraz მნიშვნელობის გარეშე, რომელიც ბრუნავს	უნარული ოპერატორი, რომელიც აგდებს ოპერანდის მნიშვნელობას და ატრიალებს ქვედახაზულს.	14
?: გონებრივი გამოხატვის ოპერაცია	სამეული ოპერატორი საშუალებას გაძლევთ მოაწყოთ მარტივი დაშლა. გამოთქმას აქვს სამი ოპერანდი, პირველი ექვემდებარება ლოგიკურ მნიშვნელობებს ან გარდაიქმნება ახალში, ხოლო მეორე და მესამე ექვემდებარება ნებისმიერ მნიშვნელობას. თუ პირველი ოპერანდი იგივეა, რაც ჭეშმარიტი, მაშინ გონებრივი გამოხატულება იქნება სხვა ოპერანდის მნიშვნელობა; თუ ის ყალბია - მაშინ მესამე.	3

document.write("Hello World"); // ეკრანზე მწკრივის ჩვენება hello world i = 0, j = 1; // ინახავს ცვლადის მნიშვნელობების ფუნქცია1(10, 5); // დააწკაპუნეთ ფუნქცია function1 პარამეტრებით 10 და 5 var წელი = ; // მასივის შექმნა typeof (a:1) ელემენტებით; // Turn "object" var d = new Date(); // ახალი ობიექტის შექმნა Date() კონსტრუქტორის d instanceof Date-ის გამოყენებით; // turn true var mycar = (make: "Honda", მოდელი: "Accord", წელი: 2005); "make" in mycar; // Turn true var obj = new Object (); // ქმნის ცარიელ საგანს var food = ["რძე", "პური", "ხორცი", "ზეითუნის ზეთი", "ყველი"]; წაშალეთ საკვები; // იხილეთ მასივის საკვების მეოთხე ელემენტი x > 10? x*2: x/2; // აბრუნებს x * 2 მნიშვნელობებს, თუ x > 10, წინააღმდეგ შემთხვევაში x / 2

9. კომენტარები JavaScript-ში

ერთსტრიქონიანი კომენტარი: კომენტარის ტექსტის წინ უნდა დააყენოთ სიმბოლოები // .

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

ოპერატორებს შეუძლიათ ავტომატურად გადაიყვანონ თავიანთი ოპერანდების ტიპები საჭიროებისამებრ. მაგალითად, გამრავლების ოპერატორი * გამოიყენება რიცხვების გამოკლებისთვის, ამიტომ გამოთქმა "2" * "3" სრულიად მისაღებია, რადგან ინტერპრეტატორი ავტომატურად გარდაქმნის რიცხვის რიგებს.

ოპერატორის პრიორიტეტი

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

ოპერატორის სვეტში სამი წერტილი აჩვენებს ოპერატორების განლაგებას ოპერატორზე დაყრდნობით.

A სვეტი მიუთითებს ოპერატორის ასოციაციაზე. ასოციაცია- ეს არის თანმიმდევრობა, რომლითაც ოპერატორები ერთნაირი პრიორიტეტით არის გამოყოფილი. მაგალითად, ოპერატორი ნათლად აჩვენებს ბოროტების ასოციაციას მარჯვნივ, შემდეგ არის ორი ექვივალენტური გამონათქვამი:

X - y - z (x - y) - ზ

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

W = x = y = z w = (x = (y = z))

Pro სვეტს აქვს რამდენიმე ოპერანდი.

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

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

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

ოპერატორი	ოპერატორის ტიპი	ა	შესახებ	Tipi მნიშვნელობა
(…)	დაჯგუფება	კვირის დღე	1	be-yake → be-yake
… . … … […] ახალი...()	წვდომის ოპერატორი წვდომის ოპერატორი ახალი (არგუმენტების სიით)	ბოროტება მარჯვნივ ბოროტება მარჯვნივ კვირის დღე	2 2 1	lval, lval → რაც არ უნდა lval, რიგის chi ნომერი → რაც არ უნდა იყოს კონსტრუქტორი → ობიექტი
… () ახალი...	Viklik ფუნქციები ახალი (არგუმენტების გარეშე)	ბოროტება მარჯვნივ მარჯვნიდან მარცხნივ	1 1	ფუნქცია → რაც არ უნდა კონსტრუქტორი → ობიექტი
… ++ … --	პოსტფიქსის ზრდა პოსტფიქსის შემცირება	კვირის დღე კვირის დღე	1 1	lval → რიცხვი lval → რიცხვი
! … ~ … + … - … ++ … -- … წაშლა... ტიპი... ბათილად...	ლოგიკური NOT (ინვერსია) Bitwise NOT (ინვერსია) უნივერსალური პლუსი უნივერსალური მინუსი პრეფიქსის ზრდა პრეფიქსის შემცირება ვიდალენნია ნიშნავს მონაცემთა ტიპს ხელმოუწერელი მნიშვნელობის შემობრუნება	მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ	1 1 1 1 1 1 1 1 1	be-yake → bulovo მთელი → მთელი ნომერი → ნომერი ნომერი → ნომერი lval → რიცხვი lval → რიცხვი lval → boolovo be-yake → მწკრივი be-yake → განუსაზღვრელი
… ** … … * … … / … … % …	Აღმასვლა რეპროდუქცია პოდილ Podil IZ ძალიან ბევრი	მარჯვნიდან მარცხნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ	2 2 2 2	ნომერი, ნომერი → ნომერი ნომერი, ნომერი → ნომერი ნომერი, ნომერი → ნომერი ნომერი, ნომერი → ნომერი
… + … … - … … + …	დოდავანია Vіdnіmannya შეერთება	ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ	2 2 2	ნომერი, ნომერი → ნომერი ნომერი, ნომერი → ნომერი მწკრივი, მწკრივი → მწკრივი
… << … … >> … … >>> …	Zsuv beativ წავიდა Zsuv betiv მარჯვენა ხელი შემნახველი ნიშანი Zsuv bitiv მარჯვენა ხელით სავსე ნულები	ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ	2 2 2	წილე, წილე → ცილი წილე, წილე → ცილი წილე, წილე → ცილი
… < … … <= … … > … … >= … ...ში... ... მაგალითად...	Ნაკლები ვიდრე ნაკლებად ან უფრო ძველი მეტი ქვემოთ მეტ-ნაკლებად უძველესი სიყვითლის არსებობის შემოწმება ამ ტიპის სისწორის შემოწმება	ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ	2 2 2 2 2 2	რიცხვი, რიცხვი → ლოგიკური რიცხვი, რიცხვი → ლოგიკური რიცხვი, რიცხვი → ლოგიკური რიცხვი, რიცხვი → ლოგიკური რიგი, ობიექტი → ობიექტი, კონსტრუქტორი → boolovo
… == … … != … … === … … !== …	რივნო არ ადარებს მკაცრად ერთი რამ მკაცრად არა ერთი	ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ ბოროტება მარჯვნივ	2 2 2 2	be-yake, be-yake → ლოგიკური be-yake, be-yake → ლოგიკური be-yake, be-yake → ლოგიკური be-yake, be-yake → ლოგიკური
… & …	პობიტოვი ი	ბოროტება მარჯვნივ	2	წილე, წილე → ცილი
… ^ …	Pobitowe Viklyuchne ABO	ბოროტება მარჯვნივ	2	წილე, წილე → ცილი
… | …	ოპერაცია შვილობილი კომპანიებისგან ოპერაცია შვილობილი კომპანიებისგან ოპერაცია შვილობილი კომპანიებისგან	მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ	2 2 2 2 2 2 2 2 2 2 2 2 2	ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე ლვალ, ბე-იაკე → ბე-იაკე
მოსავლიანობა... მოსავლიანობა*...	მოსავლიანობა მოსავლიანობა *	მარჯვნიდან მარცხნივ მარჯვნიდან მარცხნივ	1 1
... …	გაფართოება	კვირის დღე	1
… , …	კომა	ბოროტება მარჯვნივ	2	be-yake, be-yake → be-yake