JavaScript ცვლადები. მუდმივები

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

ცვლადი შექმნა

ცვლადი იქმნება ორ ეტაპად: ცვლადის გამოცხადება და სახელის მინიჭება.

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

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

• პირველი წესი, მოერიდეთ დაცული სიტყვების გამოყენებას... JavaScript– ის გარკვეული სიტყვები გამოიყენება სისტემაში, მაგალითად, სიტყვა var, რომლითაც ვაცხადებთ ცვლადს. გარდა ამისა, ზოგიერთი სიტყვა, როგორიცაა გაფრთხილება, დოკუმენტი, ფანჯარა, ითვლება ვებ – გვერდის სპეციალურ თვისებად. თუ ცდილობთ გამოიყენოთ ისინი ცვლადებად, მიიღებთ შეცდომის შეტყობინებას. აქ შეგიძლიათ იხილოთ დაცული სიტყვების სია.
• მეორე წესი, ცვლადის სახელი უნდა დაიწყოს ასოთი, $ ან _... ანუ, ცვლადი ვერ იწყება რიცხვით ან პუნქტუაციის ნიშნით: სახელი 1dwstv და & dwstv არ იმუშავებს, მაგრამ სახელები $ dwstv და _dwstv იმუშავებს.
• მესამე წესი, ცვლადი სახელები შეიძლება შეიცავდეს ასოებს, რიცხვებს, $ და _ სიმბოლოებს, ხოლო ინტერფეისი ან სხვა სპეციალური სიმბოლოები არ შეიძლება გამოყენებულ იქნეს სახელით: dws & tv და dws tv არასწორი სახელებია, მაგრამ ეს ფორმატი შეიძლება იყოს dws_tv და dwstv1 ან dws_tv_1.
• მეოთხე წესი, ცვლადი სახელები მგრძნობიარეა ასოზე... JavaScript თარჯიმანი განსხვავებულად ინტერპრეტაციას უკეთებს მცირე და დიდი ასოებს, ანუ DWSTV ცვლადი განსხვავდება dwstv ცვლადისგან და ასევე DwStv და Dwstv ცვლადებისგან.
• მეხუთე წესი, ნ არ არის რეკომენდებული ლათინური გარდა სიმბოლოების გამოყენება, კირილიცაზე დაწერილი ცვლადები, მიუხედავად იმისა, რომ იმუშავებენ, არ არის გარანტირებული, გარდა ამისა, მათ ვერ გაიგებენ სხვა ქვეყნების კოლეგები.

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

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

ცვლადების გამოყენება

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

იმისათვის, რომ მონაცემები შეიტანოს ცვლადში, გამოიყენება სპეციალური სიმბოლო, ტოლობის ნიშანი (\u003d), მას ეწოდება დავალების ოპერაციარადგან ის გამოიყენება ცვლადისთვის მნიშვნელობის მისაცემად.

მაგალითად, ჩასვით ციფრული მნიშვნელობა dwstv ცვლადში, აბონენტების რაოდენობაა 8500, გამოაცხადეთ var dwstv ცვლადი; და მეორე სტრიქონში ჩვენ ვაყენებთ მნიშვნელობას dwstv \u003d 8500;

ვარ dwstv; dwstv \u003d 7200;

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

Var dwstv \u003d 7200;

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

Var dwstv \u003d 7200; var გაკვეთილები \u003d "JavaScript"; var youtubeKanal \u003d 'DwsTV'; var აბონენტები \u003d '7700'; var შინაარსი \u003d ჭეშმარიტი;

ასევე შეგვიძლია დაზოგოთ დრო და დრო ცვლადების გამოცხადებით ერთი var გასაღებით, მაგალითად:

Var გაკვეთილები \u003d "JavaScript", youtubeKanal \u003d "DwsTV", აბონენტები \u003d "7700", შინაარსი \u003d ნამდვილი;

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

მაგალითად, თუ საჭიროა განგაშის დიალოგური ფანჯრის გახსნა და არხის ცვლადში შენახული მნიშვნელობის ჩვენება, საჭიროა გაფრთხილების ფუნქციაში ჩავწეროთ ცვლადის სახელი.

გაფრთხილება (არხი);

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

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

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

გამომწერები \u003d '10000';

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

პრაქტიკული დავალება:

შექმენით სამი ცვლადი, ერთი რიცხვითი მნიშვნელობით, მეორე სიმების მნიშვნელობით და მესამე ლოგიკური მნიშვნელობით. ყველა ცვლადი გამოაცხადეთ ერთი საკვანძო სიტყვით var და აჩვენეთ ისინი გვერდზე. შემდეგ შეცვალეთ ცვლადი რიცხვითი მნიშვნელობით და აჩვენეთ შედეგი alert () ფუნქციის გამოყენებით.

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

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

გაკვეთილი მოამზადა გორელოვ დენისმა.

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

ეს სახელმძღვანელო გაგაცნობთ ცვლადებს, როგორ გამოაცხადოთ და დაასახელოთ ისინი, და ახსნა განსხვავება var, let და const შორის. გარდა ამისა, თქვენ შეისწავლით რა არის ცვლადი ამწეობა და როგორ მოქმედებს მოქმედების არეალი ცვალებად ქცევაზე.

რა არის ცვლადები

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

ECMAScript 2015 (ES6) ენის სპეციფიკაციამდე, რომელსაც JavaScript ამჟამად ემყარება, ცვლადის დეკლარირების მხოლოდ ერთი გზა არსებობდა - var საკვანძო სიტყვის გამოყენება. ამიტომ, ძველი კოდების და სახელმძღვანელოების უმეტესობა იყენებს მხოლოდ var– ს ცვლადების დეკლარირებისთვის. მოდით შევხედოთ განსხვავებებს var, let და const შორის.

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

// სტრიქონის მნიშვნელობის 8host მიამაგრეთ მომხმარებლის სახელის იდენტიფიკატორს
var მომხმარებლის სახელი \u003d "8host_blog";

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

• ცვლადის გამოცხადება var საკვანძო სიტყვის გამოყენებით;
• ცვლადი სახელი (ან იდენტიფიკატორი), მომხმარებლის სახელი;
• დავალების ოპერატორი, წარმოდგენილი სინტაქსით \u003d;
• მინიჭებული მნიშვნელობაა "8host_blog".

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

// შეამოწმეთ არის თუ არა ცვლადი მნიშვნელობის ტოლი
თუ (მომხმარებლის სახელი \u003d\u003d\u003d "8host_blog") (
console.log (მართალია);
}
მართალია

როგორც ადრე აღვნიშნეთ, ცვლადების გამოხატვა შესაძლებელია JavaScript მონაცემთა ნებისმიერი ტიპით. ამ მაგალითში ცვლადები გამოხატულია string, number, object, boolean და null.

// სხვადასხვა ცვლადის დანიშვნა
var name \u003d "მკვდარი";
var spartans \u003d 300;
var სამეფო \u003d ["ძუძუმწოვრები", "ფრინველები", "თევზი"];
var ლექსი \u003d (ვარდები: "წითელი", იისფერი: "ცისფერი");
var წარმატება \u003d ჭეშმარიტი;
var არაფერი \u003d null;

Console.log- ის გამოყენებით შეგიძლიათ ნახოთ ნებისმიერი ცვლადის მნიშვნელობა:

// spartans ცვლადის გაგზავნა კონსოლში
console.log (სპარტელები);
300

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

// მნიშვნელობის მინიჭება პაროლის ცვლადზე
var პაროლი \u003d "hunter2";
// ცვლადის მნიშვნელობის გადანაწილება ახალი მნიშვნელობით
პაროლი \u003d "hunter3";
console.log (პაროლი);
"hunter3"

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

ცვლადი დასახელების

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

• ცვლადი სახელები შეიძლება შეიცავდეს მხოლოდ ასოებს, რიცხვებს (0-9), დოლარის ნიშანს ($) და ხაზგასმას (_).
• ცვლადი სახელები არ შეიძლება შეიცავდეს თეთრი სივრცის სიმბოლოებს.
• ცვლადი სახელები არ უნდა დაიწყოს რიცხვით.
• არსებობს რამდენიმე დაცული საკვანძო სიტყვა, რომელთა გამოყენება შეუძლებელია ცვლადის სახელებად.
• ცვალებადი სახელები მგრძნობიარეა ასოებით.

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

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

განსხვავება var, let და const შორის

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

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

JavaScript არეალი

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

• გლობალური ცვლადები არის ის, ვინც დეკლარირებულია ბლოკის გარეთ.
• ადგილობრივი ცვლადები არის ის, ვინც დეკლარირებულია ბლოკის შიგნით.

ქვემოთ მოყვანილ მაგალითში, ჩვენ შევქმნით გლობალურ ცვლადს.

var არსება \u003d "მგელი";

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

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

// გლობალური ცვლადის ინიციალიზაცია
var სახეობა \u003d "ადამიანი";
ფუნქციის გარდაქმნა () (
// ადგილობრივი, ფუნქციური მასშტაბის ცვლადის ინიციალიზაცია
var სახეობა \u003d "მაქცია";
console.log (სახეობები);
}
// გლობალური და ადგილობრივი ცვლადი შესვლა
console.log (სახეობები);
გარდაქმნა ();
console.log (სახეობები);
ადამიანური
მაქცია
ადამიანური

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

ამასთან, ახალი let და const საკვანძო სიტყვები ბლოკ-სქეპულია. ეს ნიშნავს, რომ ნებისმიერი ადგილობრივი ბლოკიდან შეიქმნება ახალი ადგილობრივი მოქმედების არე, ფუნქციური ბლოკის ჩათვლით, თუ მითითებები, და for და while მარყუჟებიდან.

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

var fullMoon \u003d მართალია;
// გლობალური ცვლადის ინიციალიზაცია
მოდით სახეობა \u003d "ადამიანი";
თუ (fullMoon) (
// ბლოკის მასშტაბის ცვლადის ინიციალიზაცია
მოდით სახეობა \u003d "მაქცია";

}


ეს არ არის სავსე მთვარე. ამჟამად ლუპინი ადამიანია.

ამ მაგალითში ცვლადის სახეობას აქვს ერთი გლობალური მნიშვნელობა (ადამიანი) და ერთი ადგილობრივი მნიშვნელობა (მაქცია). ამასთან, თუ იყენებთ var- ს, სხვაგვარ შედეგს მიიღებთ.

// გამოიყენეთ var ცვლადის ინიციალიზაციისთვის
var სახეობა \u003d "ადამიანი";
თუ (fullMoon) (
// ბლოკში ახალი ცვლადის შექმნის მცდელობა
var სახეობა \u003d "მაქცია";
console.log ("ეს არის სავსე მთვარე. ლუპინი ამჟამად არის $ (სახეობა).");
}
console.log ("ეს არ არის სავსე მთვარე. ლუპინი ამჟამად არის $ (სახეობა).");
სავსე მთვარეა. ამჟამად ლუპინი მაქცია.
ეს არ არის სავსე მთვარე. ამჟამად ლუპინი მაქცია.

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

ცვლადების ამაღლება

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

თუ თქვენ ცდილობთ გამოიყენოთ ცვლადი, სანამ იგი გამოცხადდება და ინიციალირდება, ის დაბრუნდება განუსაზღვრელი.

console.log (x);
// ცვლადი დავალება
var x \u003d 100;
განუსაზღვრელი

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

// ცვლადის გამოყენების მცდელობა მისი გამოცხადებამდე
console.log (x);
// ცვლადი დავალება ვარისის გარეშე
x \u003d 100;
ReferenceError: x არ არის განსაზღვრული

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

ამ კონცეფციის უკეთ წარმოსაჩენად დავწერე შემდეგი კოდი და ავუხსენით როგორ კითხულობს მას JavaScript:

// კოდი, რომელიც ჩვენ დავწერეთ
console.log (x);
var x \u003d 100;
// როგორ განმარტა იგი JavaScript- მა
var x;
console.log (x);
x \u003d 100;

JavaScript ინახავს x მეხსიერებაში, როგორც ცვლადი სკრიპტის შესრულებამდე. მას შემდეგ, რაც ცვლადი გამოიძახეს მის განსაზღვრამდე, შედეგი უბრუნდება განუსაზღვრელი და არა 100. თუმცა, ეს არ ზრდის ReferenceError- ს ან სკრიპტს აჩერებს. მიუხედავად იმისა, რომ var საკვანძო სიტყვას რეალურად არ შეცვლილა var– ის ადგილმდებარეობა, ის აჩვენებს თუ როგორ მუშაობს ამწეობა. ამ საქციელმა შეიძლება პრობლემები გამოიწვიოს, რადგან პროგრამისტი, რომელმაც ეს კოდი დაწერა, სავარაუდოდ, მოელის x გამოსვლას ჭეშმარიტი და არა განსაზღვრული.

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

var x \u003d 100;
ფუნქციის ამწე () (
// მდგომარეობა, რომელიც არ უნდა მოქმედებდეს კოდის შედეგზე
თუ (ყალბი) (
var x \u003d 200;
}
console.log (x);
}
ამწე ();
განუსაზღვრელი

ამ მაგალითში, გლობალური ცვლადი x არის 100. დამოკიდებულია if მითითებაზე, x შეიძლება შეიცვალოს 200-ით, მაგრამ რადგან მდგომარეობა ცრუ იყო, ეს გავლენას არ უნდა ახდენდეს x- ის მნიშვნელობაზე. ამის ნაცვლად, x აიმაღლეს ამწე () ფუნქციის დაწყებამდე და მნიშვნელობა განუსაზღვრელი გახდა.

ამ არაპროგნოზირებადმა საქციელმა შეიძლება გამოიწვიოს პროგრამის შეცდომები. მას შემდეგ, რაც let და const განისაზღვრება ბლოკის დონეზე, ისინი არ აიყვანება ისევე, როგორც ქვემოთ მოცემულ მაგალითში.

// x ინიციალიზაცია გლობალური მასშტაბით
მოდით x \u003d სიმართლე;
ფუნქციის ამწე () (
// x ინიცირება ფუნქციის ფარგლებში
თუ (3 \u003d\u003d\u003d 4) (
მოდით x \u003d false;
}
console.log (x);
}
ამწე ();
მართალია

ცვლადი დეკლარაციების დუბლიკატი, რომლებიც შესაძლებელია var- ით, შეცდომას აყენებს let და const- ით.

// ცვლადი შეცვალა დეკლარირებული var
var x \u003d 1;
var x \u003d 2;
console.log (x);
2
// let შეცვლილი ცვლადის გადაწერის მცდელობა
მოდით y \u003d 1;
მოდით y \u003d 2;
console.log (y);

Uncaught SyntaxError: იდენტიფიკატორი 'y' უკვე გამოცხადებულია
ასე რომ, var– ით დეკლარირებულ ცვლადებზე შეიძლება გავლენა იქონიოს ამწეობით. ამწეობა არის JavaScript– ის მექანიზმი, სადაც ცვლადი დეკლარაციები ინახება მეხსიერებაში. ამან შეიძლება გამოიწვიოს თქვენი კოდის განუსაზღვრელი ცვლადები. Let და const საკვანძო სიტყვები ამ პრობლემას აგვარებს შეცდომით, როდესაც ცვლადის გამოყენებას ცდილობ მის გამოცხადებამდე ან ცვლადის ერთჯერადად გამოცხადებამდე.

მუდმივები

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

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

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

// მნიშვნელობის მინიჭება კონსტ
const სახეობები \u003d "ადამიანი";
// მნიშვნელობის გადანაწილების მცდელობა
სახეობები \u003d "მაქცია";
console.log (სახეობები);
Uncaught TypeError: დანიშნულება მუდმივ ცვლადზე.

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

// დეკლარირება, მაგრამ კონსტიტუციის ინიცირება არ ხდება
const TODO;
console.log (TODO);
Uncaught SyntaxError: დეკლარაციაში არ არის საწყისი შემქმნელი

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

// შექმენით CAR ობიექტი ორი თვისებით
const CAR \u003d (
ფერი: "ლურჯი",
ფასი: 15000
}
// CAR– ის ქონების შეცვლა
CAR. ფასი \u003d 20000;
console.log (CAR);
(ფერი: "ლურჯი", ფასი: 20000)

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

დასკვნა

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

ცვლადები ინფორმაციის შენახვის "კონტეინერებს" ემსახურება.

გახსოვთ სკოლის ალგებრა?

გახსოვთ სკოლის ალგებრა? x \u003d 5, y \u003d 6, z \u003d x + y

გახსოვთ, რომ ასო (მაგ. X) შეიძლება გამოყენებულიყო მნიშვნელობის შესანახად (მაგალითად, 5), და რომ ზემოთ მოცემული ინფორმაციის გამოყენებით შეგიძლიათ გამოთვალოთ, რომ z არის 11?

ამ ასოებს უწოდებენ ცვლადები, და ცვლადების გამოყენება შესაძლებელია მნიშვნელობების (x \u003d 5) ან გამოთქმების (z \u003d x + y) შესანახად.

JavaScript ცვლადები

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

ცვლადს შეიძლება ჰქონდეს მოკლე სახელი, მაგალითად x, ან უფრო აღწერითი სახელი, როგორიცაა carname.

JavaScript ცვლადის სახელების წესები:

• ცვლადი სახელები მგრძნობიარეა ასოზე (y და Y ორი განსხვავებული ცვლადია)
• ცვლადი სახელები უნდა დაიწყოს ასოთი ან ხაზგასმით

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

მაგალითი

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

JavaScript ცვლადების გამოცხადება (შექმნა)

ცვლადების შექმნა JavaScript– ში უფრო ხშირად მოიხსენიება როგორც ცვლადი „დეკლარირება“.

თქვენ აცხადებთ JavaScript ცვლადებს საკვანძო სიტყვის გამოყენებით ვარი:

ზემოთ შემოთავაზებული შენიშვნების შესრულების შემდეგ, ცვლადი x შეიცავს მნიშვნელობას 5 და მანქანის სახელი შეიცავს მნიშვნელობას მერსედესი.

კომენტარი: ცვლადისთვის ტექსტის მნიშვნელობის მინიჭებისას, ჩასვით ბრჭყალებში.

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

JavaScript ადგილობრივი ცვლადები

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

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

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

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

JavaScript გლობალური ცვლადები

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

გლობალური ცვლადები განადგურებულია გვერდის დახურვისას.

თუ ცვლადს გამოაცხადებთ "var" - ის გამოყენების გარეშე, ცვლადი ყოველთვის ხდება გლობალური.

მნიშვნელობების მინიჭება გამოუცხადებელი JavaScript ცვლადებისთვის

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

ეს შემოთავაზებები:

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

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

Საფუძვლები

JavaScript თავისი სინტაქსის უმეტეს ნაწილს სესხავს Java– სგან, მაგრამ ასევე გავლენა მოახდინა ისეთმა ენებმა, როგორიცაა Awk, Perl და Python.

JavaScript მგრძნობიარეა ასოებზე და იყენებს პერსონაჟის კოდირებას უნიკოდი... მაგალითად, სიტყვა Früh (ადრეული გერმანული ენა) შეიძლება გამოყენებულ იქნას როგორც ცვლადი სახელი.

Var Früh \u003d "ფოობარი";

მაგრამ, ცვლადი früh არ არის იგივე, რაც Früh, რადგან JavaScript მგრძნობიარეა დიდი ზომის მიხედვით.

კომენტარები

Სინტაქსი კომენტარები იგივეა რაც C ++ და ბევრ სხვა ენაზე:

// კომენტარი ერთ სტრიქონზე. / * კომენტარი მოიცავს მრავალ სტრიქონს. * / / * თქვენ არ შეგიძლიათ ბუდე გააკეთოთ / * კომენტარის გაკეთება კომენტარში * / Სინტაქსური შეცდომა * /

რეკლამები

JavaScript– ში სამი სახის დეკლარაციაა:

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

ცვლადები

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

JavaScript იდენტიფიკატორი უნდა დაიწყოს ასოთი, ხაზგასმით (_) ან დოლარის ნიშნით ($); შემდეგი სიმბოლოები ასევე შეიძლება იყოს რიცხვები (0-9). იმის გამო, რომ JavaScript მგრძნობიარეა დიდი ასოებით, ასოები შეიცავს სიმბოლოებს "A" - დან "Z" - ის (დიდი) და სიმბოლოებს "a" - ს "z" (პატარა).

შეგიძლიათ გამოიყენოთ ISO 8859-1 ან Unicode ასოები იდენტიფიკატორებში, როგორიცაა å ან ü. იდენტიფიკატორებში ასევე შეგიძლიათ გამოიყენოთ ორივე სიმბოლო.

მოქმედი სახელების რამდენიმე მაგალითი: Number_hits, temp99, _ name.

ცვლადი დეკლარაცია

ცვლადის გამოცხადება შეგიძლიათ სამი გზით:

• იყენებენ var საკვანძო სიტყვას. მაგალითად var x \u003d 42. ეს სინტაქსი შეიძლება გამოყენებულ იქნას როგორც ადგილობრივი, ასევე გლობალური ცვლადების დეკლარირებისთვის.
• უბრალოდ ცვლადს მიანიჭეთ მნიშვნელობა. მაგალითად, x \u003d 42. ამ გზით დეკლარირებული ცვლადები გლობალურია. ასეთი დეკლარაცია ქმნის მკაცრ რეჟიმს. ეს მეთოდი არ არის რეკომენდებული.
• Let სიტყვის გამოყენებით. მაგალითად მოდით y \u003d 13. ეს სინტაქსი შეიძლება გამოყენებულ იქნას ბლოკის მასშტაბით ადგილობრივი ცვლადის დეკლარირებისთვის.

მნიშვნელობების მინიჭება

Var ან გამოცხადებული ცვლადის საწყისი მნიშვნელობის გარეშე დანიშვნისას განუსაზღვრელია.

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

ვარ ა; console.log ("ა-ს მნიშვნელობაა" + ა); // ცვლადის მნიშვნელობა განუსაზღვრელია console.log ("b- ის მნიშვნელობაა" + b); // Uncaught ReferenceError: b არ არის განსაზღვრული console.log ("c- ის მნიშვნელობაა" + c); // ც ცვლადის მნიშვნელობა განუსაზღვრელია var c; console.log ("x- ის მნიშვნელობაა" + x); // Uncaught ReferenceError: x არ არის განსაზღვრული let x;

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

var შეყვანა; თუ (შეყვანა \u003d\u003d\u003d განუსაზღვრელი) (doThis ( ) ) სხვა (გააკეთე ეს ( ) ; }

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

var myArray \u003d; თუ (! myArray [0]) (myFunction ( ) ; }

განუსაზღვრელი მნიშვნელობა გარდაიქმნება NaN- ში, როდესაც გამოიყენება ციფრულ კონტექსტში:

var a; a + 2; // NaN

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

დამატებითი მძიმეები მასივის ასოებში

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

var fish \u003d ["ლომი", "ანგელოზი"]; // ["ლომი", განუსაზღვრელი, "ანგელოზი"]

ამ მასივს აქვს 2 ელემენტი მნიშვნელობებით და ერთი ცარიელი (თევზი არის "ლომი", თევზი განუსაზღვრელია და თევზი "ანგელოზი").

თუ ნივთების ჩამონათვალის ბოლოს მძიმით დააყენებთ, ის იგნორირდება. შემდეგ მაგალითში, მასივის სიგრძეა 3. არა myList. სიაში ყველა სხვა მძიმით მიეთითება ახალი ელემენტი.

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

var myList \u003d ["სახლი", "სკოლა",]; // ["სახლი", განუსაზღვრელი, "სკოლა"]

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

var myList \u003d [, "სახლი", "სკოლა"]; //

შემდეგ მაგალითში, მასივის სიგრძეა ოთხი და myList და myList ელემენტები განუსაზღვრელია. მხოლოდ ბოლო მძიმით იგნორირებულია.

var myList \u003d ["სახლი", "სკოლა",]; // ["სახლი", განუსაზღვრელი, "სკოლა", განუსაზღვრელი]

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

ლოგიკური ლიტერატურა

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

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

მთელი რიცხვი

მთელი რიცხვების ჩაწერა შეიძლება ათობითი, თექვსმეტობითი, ოქტალი და ორობითი სისტემებით.

• ათობითი მთელი რიცხვი შედგება ციფრების მიმდევრობისგან, რომელსაც არ აქვს წამყვანი ნული.
• მთლიანი რიცხვის პირდაპირი ნულოვანი მიუთითებს იმაზე, რომ ის ოქტანშია. ოქტალური მთელი რიცხვები შედგება მხოლოდ 0-7 ციფრებისგან.
• წამყვანი სიმბოლოები 0x (ან 0X) მიუთითებს, რომ რიცხვი თექვსმეტობითია. თექვსმეტობითი რიცხვი შეიძლება შედგებოდეს ციფრებისგან: 0-9 და ასოები a-f და A-F.
• წამყვანი სიმბოლოები 0b (ან 0B) მიუთითებენ, რომ რიცხვი ორობითია. ორობითი რიცხვები შეიძლება შეიცავდეს მხოლოდ ციფრებს 0 და 1.

მთლიანი ლიტერატურის რამდენიმე მაგალითი:

0, 117 და -345 (ათობითი) 015, 0001 და -077 (ოქტალური) 0x1123, 0x00111 და -0xF1A7 (ექვსკუთხა) 0b11, 0b0011 და -0b11 (ორობითი)

მცურავი წერტილი პირდაპირი მნიშვნელობით

მცურავი წერტილების ნომრები შეიძლება შედგებოდეს შემდეგი ნაწილებისგან:

• ათობითი მთელი რიცხვი, რომელსაც შეიძლება ჰქონდეს ნიშანი (რიცხვის წინა "+" ან "-" სიმბოლო),
• ათწილადი წერტილი ("."),
• ფრაქციული ნაწილი (სხვა ათობითი რიცხვი),
• გამოფენა.

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

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

[(+ | -)] [. ციფრები] [(E | e) [(+ | -)] ციფრები]

3.14 -3.1E + 12 -.333333333333333333333 .1e-23

ობიექტი სიტყვასიტყვით

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

შემდეგ მაგალითში, მანქანის ობიექტის myCar თვისება დაყენებულია სტრიქონზე "Saturn", getCar თვისება CarTypes ("ჰონდა") ფუნქციის გამოძახების შედეგია, ხოლო სპეციალური თვისება არის Sales ცვლადის მნიშვნელობა:

var გაყიდვები \u003d "ტოიოტა"; ფუნქცია CarTypes ( სახელი) (თუ (სახელი \u003d\u003d "ჰონდა") (დაბრუნების სახელი;) სხვაგან (დაბრუნება "უკაცრავად, ჩვენ არ ვყიდით" + სახელი + "." ; )) var car \u003d (myCar: "Saturn", getCar: CarTypes ( "ჰონდა"), სპეციალური: გაყიდვები); კონსოლი ჟურნალი ( მანქანა ჩემი მანქანა); // სატურნის კონსოლი. ჟურნალი ( მანქანა getCar); // ჰონდას კონსოლი. ჟურნალი ( მანქანა განსაკუთრებული); // ტოიოტა

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

var car \u003d (manyCars: (a: "Saab", "b": "Jeep"), 7: "Mazda"); კონსოლი ჟურნალი ( მანქანა ბევრი მანქანა ბ) // ჯიპის კონსოლი. ჟურნალი ( მანქანა [7]); // მაზდა

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

var unusualPropertyNames \u003d ("" ":" ცარიელი სტრიქონი ","! ":" Bang! ") კონსოლი. ჟურნალი ( უჩვეულო საკუთრების სახელები. ""); // SyntaxError: მოულოდნელი სტრიქონიკონსოლი ჟურნალი ( unusualPropertyNames [""]); // "ცარიელი სტრიქონის" კონსოლი. ჟურნალი ( უჩვეულო საკუთრების სახელები. ! ) // სინტაქსის შეცდომა: მოულოდნელი ჟეტონი!კონსოლი ჟურნალი ( unusualPropertyNames ["!" ]); // "აფეთქება!"

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

Var obj \u003d (// __proto__ __proto__: theProtoObj, // მოკლე ნოტაცია 'handler: handler' მმართველი, // Methods toString () (// სუპერ ზარები ბრუნდება "d" + super.toString ();), // Dynamic ქონების სახელების გაანგარიშება ["prop_" + (() \u003d\u003e 42) ()]: 42);

გადახედეთ შემდეგ მაგალითს:

var foo \u003d (ა: "ალფა", 2: "ორი"); კონსოლი ჟურნალი ( ფუი ა) // ალფა კონსოლი. ჟურნალი ( foo [2]); // ორი // console.log (foo.2); // სინტაქსის შეცდომა: მოულოდნელი ნომერი// console.log (foo [a]); // ReferenceError: a არ არის განსაზღვრულიკონსოლი ჟურნალი ( foo ["ა"]); // ალფა კონსოლი. ჟურნალი ( foo ["2"]); // ორი

RegExp პირდაპირი

Regexp ლიტერატურა არის შაბლონებს შრეებს შორის. შემდეგი მაგალითია პირდაპირი მნიშვნელობით regex:

Var re \u003d / ab + c /;

სიმები სიტყვასიტყვით

სტრიქონი არის ნულოვანი ან მეტი სიმბოლო, რომელიც ორმაგად (") ან ერთჯერადი (") ბრჭყალებით არის ჩასმული. სტრიქონი უნდა შემოიფარგლოს ცალკეული ბრჭყალებით, ე.ი. ან ორივე ერთად, ან ორივე ორმაგი. Მაგალითად:

"foo" "bar" "1234" "one line \\ n მეორე ხაზი" "John" s cat "

სტრიქონის ობიექტის რომელიმე მეთოდს სტრიქონის საშუალებით შეგიძლიათ დარეკოთ: JavaScript ავტომატურად გარდაქმნის სტრიქონს სტრიქონს დროებით სიმების ობიექტად, ურეკავს მეთოდს და ანადგურებს დროებითი სიმების ობიექტს. ასევე შეგიძლიათ გამოიყენოთ String.length თვისება string ლიტერატურულით:

კონსოლი ჟურნალი ( "იოანეს კატა". სიგრძე); // სიმების სიმბოლოების რაოდენობა, სივრცის ჩათვლით.// ამ შემთხვევაში, სტრიქონის სიგრძეა 10.

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

// სტრიქონის მარტივი შექმნა სტრიქონის სტრიქონის საშუალებით "JavaScript- ში" \\ n "არის სტრიქონი." // მრავალსტრიქონიანი სტრიქონები "JavaScript- ში ეს არ არის იურიდიული." // სტრიქონის ინტერპოლაცია var name \u003d "Bobby", დრო \u003d "დღეს" "; "გამარჯობა $ (სახელი), როგორ ხარ $ (დრო)?" // ააშენეთ HTTP მოთხოვნის პრეფიქსი, რომელიც გამოიყენება ჩანაცვლების ინტერპრეტაციისთვის და POST- ების შესაქმნელად. Http://foo.org/bar? A \u003d $ (a) & b \u003d $ ( ბ) შინაარსის ტიპი: განცხადება / json X- რწმუნებათა სიგელები: $ (რწმუნებათა სიგელები) ("foo": $ (foo), "bar": $ (bar)) "(myOnReadyStateChangeHandler);

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

სტრიქონებში სპეციალური სიმბოლოების გამოყენება

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

"ერთი ხაზი \\ n სხვა ხაზი"

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

სპეციალური სიმბოლოები JavaScript- ში

სიმბოლო	მნიშვნელობა
\\ ბ	უკანა სივრცე
\\ ვ	თარგმანი ან გვერდის არხი (ფორმის არხი)
\\ n	ხაზის არხი (ახალი ხაზი)
\\ r	ვაგონის დაბრუნება
\\ ტ	ჩანართი (ჩანართი)
\\ v	ვერტიკალური ჩანართი
\"	აპოსტროფი ან ცალკეული ციტატა
\"	ორმაგი ციტატა
\\	უკუსვლის ხაზი (უკუქცევა)
\XXX	ლათინურ –1 სიმბოლო წარმოდგენილია სამი ოქტალით XXX 0-დან 377-მდე. მაგალითად, \\ 251 (სიმბოლო ©).
\\ x XX	ლათინური -1 სიმბოლო წარმოდგენილია ორი თექვსმეტობითი რიცხვით XX 00-დან FF- მდე. მაგალითად, \\ xA9 (© სიმბოლო).
\\ u XXXX	უნიკოდის სიმბოლო წარმოდგენილია თექვსმეტობითი რიცხვით XXXX... მაგალითად, \\ u00A9 (© სიმბოლო).
\\ u (XXXXX)	სიმბოლო არის UTF-32BE. მაგალითად, \\ u (2F804) ნიშნავს იგივე, რაც ჩვეულებრივი \\ uD87E \\ uDC04.

გაქცევა სიმბოლოებისგან

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

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

var ციტირება \u003d ”მან წაიკითხა R.W. Service- ის მიერ” სემ მაკგის კრემი ”.”; კონსოლი ჟურნალი ( ციტირება); // მან წაიკითხა R.W. "სემ მაკგის კრემაცია". მომსახურება

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

var home \u003d "c: \\\\ temp"; // გ: \\ ტემპ

ასევე შეგიძლიათ გაქცევა ხაზის არხიდან. უკანა ხაზი და ხაზის არხი ამოიშლება სიმების შინაარსიდან. Მაგალითად:

var str \u003d "ეს სტრიქონი \\ გატეხილია \\ მრავალ ხაზში." კონსოლი. ჟურნალი ( ქუჩა); // ეს სტრიქონი გაყოფილია მრავალ ხაზს შორის.

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

var poem \u003d "ვარდები წითელია, \\ n \\ იისფერი ლურჯია. \\ n \\ მე" შიზოფრენიული ვარ, \\ n \\ და მეც ასე ვარ. "

დამატებითი ინფორმაცია

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

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

ბოლო განახლება: 05.04.2018

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

ჩემი myIncome; // სხვა ვარიანტი მოდით myIncome2;

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

მაგალითად, ცვლადის სწორი სახელებია:

$ კომისია ზოგიერთი ცვლადი პროდუქტი_ მაღაზიის შემოსავალი 2 myIncome_from_deposit

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

222lol @someVariable ჩემი% პროცენტი

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

ვარ ამისთვის;

დაცული სიტყვების ჩამონათვალი JavaScript- ში:

აბსტრაქტული, boolean, break, byte, case, catch, char, class, const, გაგრძელება, debugger, default, delete, do, double, else, enum, ექსპორტი, ვრცელდება, false, საბოლოო, საბოლოოდ, float, for, function, goto, if, ახორციელებს, იმპორტი, მაგალითად, int, inteface, long, native, new, , pack, private, protection, public, return, short, static, super, super, switch, synchronized, this, throws, throws, გარდამავალი, მართალი, ცდა, typeof, var, არასტაბილური, ბათილი, ხოლო, ერთად

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

ჩემი myIncome; var MyIncome;

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

Var myIncome, procent, sum; მოდით a, b, c;

ტოლობის ნიშნის გამოყენება (ასევე მოუწოდა დავალების ოპერატორი) შეგიძლიათ ცვლადს მიანიჭოთ მნიშვნელობა:

Var შემოსავალი \u003d 300; მოდით ფასი \u003d 76;

ცვლადის ინიციალიზაციის პროცესს ინიციალიზაცია ეწოდება.

ახლა ცვლადი შემოსავალი შეინახავს 300 ნომერს, ხოლო ცვლადი ფასი შეინახავს ნომერს 76.

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

Var შემოსავალი \u003d 300; შემოსავალი \u003d 400; console.log (შემოსავალი); მოდით ფასი \u003d 76; ფასი \u003d 54; console.log (ფასი);

მუდმივები

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

კონსტრუქციული მაჩვენებელი \u003d 10;

თუ ჩვენ ვცდილობთ შეცვალოთ მისი მნიშვნელობა, შეგვხვდება შეცდომა:

კონსტრუქციული მაჩვენებელი \u003d 10; მაჩვენებელი \u003d 23; // შეცდომა, სიჩქარე მუდმივია, ამიტომ მის მნიშვნელობას ვერ შევცვლით

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

კონსტრუქციული კურსი; // შეცდომა, მაჩვენებელი არ არის ინიცირებული