ბოლო განახლება: 04/08/2018

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

ობიექტები

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

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

ახალი ობიექტის შექმნა

ახალი ობიექტის შექმნის რამდენიმე გზა არსებობს.

პირველი გზა არის Object კონსტრუქტორის გამოყენება:

Var user = new Object();

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

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

ობიექტის შექმნის მეორე გზა არის ხვეული ბრეკეტების გამოყენება:

Var მომხმარებელი = ();

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

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

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

Var მომხმარებელი = (); user.name = "ტომ"; მომხმარებლის.ასაკი = 26;

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

Console.log (user.name); console.log (user.age);

თქვენ ასევე შეგიძლიათ განსაზღვროთ თვისებები ობიექტის განსაზღვრისას:

Var user = (სახელი: "ტომ", ასაკი: 26 );

ამ შემთხვევაში, ორწერტილი გამოიყენება თვისებისთვის მნიშვნელობის მინიჭებისთვის, ხოლო მძიმით (და არა მძიმით) იდება თვისების განსაზღვრის შემდეგ.

გარდა ამისა, არსებობს თვისებების განსაზღვრის მალსახმობი გზა:

Var name = "ტომ"; ვარაუდი = 34; var user = (სახელი, ასაკი); console.log (user.name); // Tom console.log (user.age); // 34

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

Var name = "ტომ"; ვარაუდი = 34; var user = (სახელი, ასაკი); var მასწავლებელი = (მომხმარებელი, კურსი: "JavaScript"); console.log(teacher.user); // (სახელი: "ტომ", ასაკი: 34) console.log(teacher.course); // JavaScript

ობიექტის მეთოდები

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

Var მომხმარებელი = (); user.name = "ტომ"; მომხმარებლის.ასაკი = 26; user.display = ფუნქცია())( console.log(user.name); console.log(user.age); ); // მეთოდის გამოძახება user.display();

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

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

Var user = ( სახელი: "ტომ", ასაკი: 26, ჩვენება: ფუნქცია())( console.log(this.name); console.log(this.age); ) );

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

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

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

Var user = ( სახელი: "ტომ", ასაკი: 26, display())( console.log(this.name, this.age); ), move(place)( console.log(this.name, "მიდის ", ადგილი); user.display(); // Tom 26 user.move("მაღაზია"); //ტომი მიდის მაღაზიაში

მასივის სინტაქსი

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

Var მომხმარებელი = (); user["name"] = "ტომ"; მომხმარებელი["ასაკი"] = 26; მომხმარებელი["ჩვენება"] = ფუნქცია())( console.log(user.name); console.log(user.age); ); // მეთოდის მომხმარებლის გამოძახება["display"]();

თითოეული თვისების ან მეთოდის დასახელება მოთავსებულია ბრჭყალებში და კვადრატულ ფრჩხილებში, შემდეგ მას ასევე ენიჭება მნიშვნელობა. მაგალითად, მომხმარებელი["ასაკი"] = 26 .

ამ თვისებებზე და მეთოდებზე წვდომისას შეგიძლიათ გამოიყენოთ წერტილის აღნიშვნა (user.name) ან გამოიყენოთ: user["name"]

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

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

Var user = ( "სახელი": "ტომ", "ასაკი": 26, "ჩვენება": ფუნქცია())( console.log(user.name); console.log(user.age); ) ); // მეთოდის გამოძახება user.display();

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

Var user = ( სახელი: "ტომ", ასაკი: 26, "სრული სახელი": "ტომ ჯონსი", "ინფორმაციის ჩვენება": function())( console.log(user.name); console.log(user.age ) ;) ); console.log(მომხმარებელი["სრული სახელი"]); მომხმარებელი["ინფორმაციის ჩვენება"]();

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

თვისებების ამოღება

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

ობიექტის.საკუთრების წაშლა

ან გამოიყენეთ მასივის სინტაქსი:

ობიექტის წაშლა ["საკუთრება"]

მაგალითად, მოვიშოროთ ქონება:

Var მომხმარებელი = (); user.name = "ტომ"; მომხმარებლის.ასაკი = 26; user.display = ფუნქცია())( console.log(user.name); console.log(user.age); ); console.log (user.name); // ტომ წაშალე user.name; // თვისების წაშლა // ალტერნატივა // მომხმარებლის წაშლა ["სახელი"]; console.log (user.name); // განუსაზღვრელი

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

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

თვისებების წვდომა

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

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

ობიექტი["ფუ"] = ობიექტი ["ფუ"] + 1.

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

ობიექტი = "ბარი".

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

ობიექტი["!@#$% &*()."] = მართალია.

ჩადგმული JavaScript ობიექტების თვისებებზე წვდომა შესაძლებელია წერტილებით და/ან ფრჩხილებით. მაგალითად, შემდეგი ობიექტი შეიცავს ჩადგმულ ობიექტს სახელად baz, რომელიც შეიცავს სხვა ობიექტს სახელად foo, რომელსაც აქვს თვისება სახელად bar, რომელიც შეიცავს მნიშვნელობას ხუთი:

var ობიექტი = ( baz: ( foo: ( bar: 5 ) ) ).

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

• ობიექტი.ბაზ.ფოო.ბარი;
• ობიექტი["ბაზ"]["ფუ"]["ბარი"];
• ობიექტი["ბაზ"].ფოო["ბარი"].

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

ფუნქციონირება, როგორც მეთოდი

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

var ობიექტი = ( ჯამი: ფუნქცია(foo, bar) ( return foo + bar; ) ).

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

• ობიექტი.ჯამ (1, 2);
• ობიექტი["ჯამ"](1, 2).

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

• var ობიექტი = ();
• ობიექტი.foo = 1;
• ობიექტი.ბარი = null;
• object.baz = function() ( return "hello from baz()"; ).

პროგრამის ინკაფსულაცია

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

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

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

Თვისებები

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

ნება მომხმარებელმა = ( // ობიექტის სახელი: "ჯონ", // გასაღების "სახელი" შეინახოს მნიშვნელობა "John" age: 30 // by key "age" store value 30 }.!}

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

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

1. Syntax Error ობიექტი მემკვიდრეობით იღებს Error ობიექტის.
2. JSON სინტაქსის შეცდომის ობიექტის გარკვეული ტიპის გაანალიზების შეცდომა.

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

შეცდომის შეტყობინებები, რომლებიც მომხმარებელმა შეიძლება მიიღოს JavaScript ობიექტის წაშლამდე:

1. ცუდი საკონტროლო სიმბოლო სიტყვასიტყვით სტრიქონში.
2. ცუდი პერსონაჟი სტრიქონში.
3. ცუდი Unicode გამომავალი.
4. ცუდი გაქცევის პერსონაჟი.
5. შეუწყვეტელი სტრიქონი.
6. მოულოდნელი არაციფრული კოდი.
7. ათობითი წერტილის შემდეგ რიცხვები არ არის.
8. დაუსრულებელი წილადი რიცხვი.
9. ხარისხის ინდიკატორის შემდეგ რიცხვები არ არის.
10. მაჩვენებლის ნიშნის შემდეგ რიცხვები არ არის.
11. ექსპონენციალურ ნაწილს არ აქვს რიცხვი.
12. მონაცემთა მოულოდნელი დასასრული.
13. მოულოდნელი საკვანძო სიტყვა.
14. მოულოდნელი სიმბოლო.
15. მონაცემთა დასასრული ობიექტის შინაარსის წაკითხვისას.
16. ქონების მოსალოდნელი სახელი ან ")".

გამოთვლითი თვისებები

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

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

მოდით ხილი = "ვაშლი";

: 5 // ჩანთა.appleკომპიუტერები = 5

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

სიტყვების დაჯავშნა

ცვლადს არ შეიძლება ჰქონდეს ერთ-ერთი რეზერვირებული სიტყვის ტოლი სახელი, როგორიცაა "for", "let", "return" და ა.შ. მაგრამ JavaScript ობიექტების დახარისხებისას ასეთი შეზღუდვა არ არსებობს.

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

obj.__proto__ = 5;

alert(obj.__proto__); // არ მუშაობდა ისე, როგორც იყო დაგეგმილი

როგორც კოდიდან ხედავთ, პრიმიტიული 5-ის დანიშნულება იგნორირებულია. ეს შეიძლება იყოს შეცდომების და თუნდაც დაუცველობის წყარო, თუ ოპერატორი აპირებს შეინახოს თვითნებური გასაღები-მნიშვნელობის წყვილები ობიექტში და მისცეს ვიზიტორს, მიუთითოს გასაღებები. ამ შემთხვევაში ვიზიტორს შეუძლია ამოირჩიოს „პროტო“ გასაღებად და დაამატოთ JavaScript ობიექტში. არსებობს გზა, რომ ობიექტები განიხილებოდეს __proto__-ით, როგორც რეგულარულ თვისებად. ასევე არსებობს მონაცემთა სტრუქტურების კიდევ ერთი რუკა, რომელიც მხარს უჭერს თვითნებურ გასაღებებს.

მთელი რიცხვი თვისებები

ტერმინი "მთლიანი თვისება" აქ ნიშნავს სტრიქონს, რომელიც შეიძლება გადაკეთდეს მთელი რიცხვიდან ცვლილების გარეშე. მაგალითად, "49" არის მთელი რიცხვის საკუთრების სახელი, რადგან როდესაც ის გადაიქცევა მთელ რიცხვად და ისევ უკან, ის კვლავ იგივეა. მაგრამ "+49" და "1.2" ასე არ არის. მეორეს მხრივ, თუ გასაღებები არ არის მთელი რიცხვი, მაშინ ისინი ჩამოთვლილია მათი შექმნის თანმიმდევრობით. მაგალითი ქვემოთ.

აკრიფეთ კოდების პრობლემის გადასაჭრელად, შეგიძლიათ „მოტყუება“ კოდების არასრული დაყენებით. ყოველი კოდის წინ "+" (პლუს ნიშანი) დამატება საკმარისია. ახლა ის იმუშავებს როგორც დაგეგმილი იყო.

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

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

თანასწორობის ოპერატორები == და მკაცრი თანასწორობა === ობიექტებისთვის ერთნაირად მუშაობს. ორი ობიექტი ტოლია მხოლოდ იმ შემთხვევაში, თუ ისინი ერთი და იგივე ობიექტია. შედარებისთვის, როგორიცაა obj1 > obj2 ან პრიმიტიულ obj == 5-თან შედარებისთვის, ობიექტები გარდაიქმნება პრიმიტივებად. მართალი გითხრათ, ასეთი შედარებები ძალიან იშვიათად არის საჭირო და, როგორც წესი, კოდირების შეცდომის შედეგია.

JavaScript ობიექტის ვალიდაცია

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

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

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

"for..in" მარყუჟი

იმისათვის, რომ გადავიდეთ ყველა კლავიშზე ობიექტიდან ობიექტზე, არსებობს მარყუჟის სპეციალური ფორმა: for..in. ეს არის სრულიად განსხვავებული რამ for(;;) კონსტრუქციისგან.

ქვემოთ მოცემულია მაგალითი.

გთხოვთ გაითვალისწინოთ, რომ ყველა "for" კონსტრუქტორი საშუალებას გაძლევთ გამოაცხადოთ მარყუჟის ცვლადი მარყუჟის შიგნით, როგორც let key. ალტერნატიულად, შეგიძლიათ გამოიყენოთ სხვა ცვლადის სახელი, გასაღები.

მაგალითად, for(let prop in obj) ასევე ფართოდ გამოიყენება.

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

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

let key = "მოწონს ჩიტები";

// იგივეა, რაც მომხმარებელი ["likes birds"] = true;

მომხმარებელი = მართალია.

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

Const ობიექტი

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

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

თქვენ ასევე შეგიძლიათ გამოიყენოთ Object.assign მეთოდი ამისთვის. არგუმენტები dest და src1, ..., srcN არის ობიექტები. ის აკოპირებს ყველა ობიექტის თვისებებს src1, ..., srcNINTO dest. სხვა სიტყვებით რომ ვთქვათ, ყველა არგუმენტის თვისება, მეორიდან დაწყებული, კოპირებულია 1-ში. შემდეგ ის უბრუნდება დანიშნულებას. მაგალითად, შეგიძლიათ გამოიყენოთ იგი რამდენიმე ობიექტის ერთში გაერთიანებისთვის.

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

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

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

გაფართოებული მეთოდები

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

გაფართოებული ობიექტის მეთოდები ეხება ცნებებს, რომლებიც იშვიათად გამოიყენება JavaScripting-ში. ეს იმიტომ ხდება, რომ ნორმალურ სცენარებში ეს ძლიერი ფუნქციები არ არის საჭირო. ზოგიერთი მეთოდი შეიძლება არ იმუშაოს ძველ ბრაუზერებში, როგორიცაა Netscape 4-ის ადრეული გამოშვებები.

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

ჭეშმარიტად დაბრუნება

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

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

ფუნქცია myob() ( ფუნქცია cantBeSeen() ( alert(secretValue);

) var secretValue = "";

this.method1 = ფუნქცია () ( secretValue = " სიურპრიზები არ არის";!}

this.method2 = cantBeSeen;

) var oneOb = new myob();

oneOb.method1();

//აფრთხილებს "არ არის მოულოდნელი" oneOb.method2();

//აფრთხილებს "სიურპრიზების გარეშე".

ბრძანების შაბლონი

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

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

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

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

1. JavaScript-ის ოპტიმიზებული GoF შაბლონები.
2. JavaScript დიზაინის თანამედროვე ნიმუშები.
3. Model-View Design Patterns.
4. jQuery დიზაინის შაბლონები.
5. JavaScript იდიომების არქიტექტურული ნიმუშები.
6. აპლიკაციების მაგალითები (MVC, SPA და ა.შ.)

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

ამ სტატიაში მსურს რაც შეიძლება სრულად და თანმიმდევრულად ვისაუბრო იმაზე, თუ რა არის ობიექტი JavaScript-ში, რა არის მისი შესაძლებლობები, რა ურთიერთობები შეიძლება აშენდეს ობიექტებს შორის და რა „მშობლიური“ მემკვიდრეობის მეთოდები მოჰყვება აქედან, როგორ მოქმედებს ეს ყველაფერი. შესრულება და საერთოდ რა უნდა გააკეთოს ამ ყველაფერთან :)

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

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

ობიექტები JavaScript-ში

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

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

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

ასე რომ, JavaScript-ში არის 6 ძირითადი ტიპებიმონაცემები არის განუსაზღვრელი (მნიშვნელობის არარსებობის მითითებით), ნულოვანი, ლოგიკური (ბულის), სტრიქონი (სტრიქონი), ნომერი (რიცხვი) და ობიექტი (ობიექტი).
უფრო მეტიც, პირველი 5 არის პრიმიტიულიმონაცემთა ტიპები, მაგრამ Object არა. გარდა ამისა, პირობითად შეგვიძლია მივიჩნიოთ, რომ Object ტიპს აქვს „ქვეტიპები“: მასივი (Array), ფუნქცია (Function), რეგულარული გამოხატულება (RegExp) და სხვა.
ეს გარკვეულწილად გამარტივებული აღწერაა, მაგრამ პრაქტიკაში, როგორც წესი, საკმარისია.

გარდა ამისა, პრიმიტიული ტიპები String, Number და Boolean გარკვეულწილად დაკავშირებულია ობიექტის არაპრიმიტიულ „ქვეტიპებთან“: String, Number და Boolean, შესაბამისად.
ეს ნიშნავს, რომ სტრიქონი "Hello, world", მაგალითად, შეიძლება შეიქმნას როგორც პრიმიტიული მნიშვნელობა ან როგორც String ობიექტი.
მოკლედ, ეს კეთდება ისე, რომ პროგრამისტმა შეძლოს გამოიყენოს მეთოდები და თვისებები პრიმიტიულ მნიშვნელობებთან მუშაობისას, თითქოს ისინი იყვნენ ობიექტები. ამის შესახებ მეტი შეგიძლიათ წაიკითხოთ ამ სტატიის შესაბამის ნაწილში.

იმუშავეთ ლინკიდან

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

ტესტი = ფუნქცია () (გაფრთხილება ("გამარჯობა!" )) //შექმენით ფუნქცია (alert("Hello!")) (და ფუნქცია, როგორც გვახსოვს, სრულფასოვანი ობიექტია) და ტესტის ცვლადი მასზე მითითებად აქციეთ
ტესტი_ლინკი=ტესტი; //test_link ახლა ასევე ეხება ჩვენს ფუნქციას
ტესტი(); //გამარჯობა!
test_link(); //გამარჯობა!

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

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

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

ტესტი = (პროპ: "რაღაც ტექსტი") //ობიექტის შექმნა prop თვისებით
ტესტი_ლინკი=ტესტი; //შექმენით სხვა ბმული ამ ობიექტთან

Alert(test.prop); //რაღაც ტექსტი

//ობიექტის თვისების შეცვლა
test_link.prop="newtext" ;

Alert(test.prop); //newtext
გაფრთხილება (test_link.prop); //ნიუტექსტი
/*შეიძლება ითქვას, რომ ქონება აქაც და იქაც შეიცვალა - მაგრამ ეს ასე არ არის.
მხოლოდ ერთი ობიექტია. ასე რომ, თვისება მასზე ერთხელ შეიცვალა და ბმულები უბრალოდ აგრძელებენ მიუთითებს, სადაც ისინი მიუთითებენ. */

//დაამატე ახალი თვისება და წაშალე ძველი
test.new_prop="გამარჯობა" ;
წაშლა test.prop;

გაფრთხილება(test_link.prop); // განუსაზღვრელი - ეს თვისება აღარ არსებობს
გაფრთხილება(test_link.new_prop);

//წაშალე ბმული
ტესტის წაშლა;
alert(test.new_prop);
/*ამ დროს სკრიპტი გაუშვებს შეცდომას, რადგან ტესტი აღარ არსებობს და test.new_prop არ არსებობს მით უმეტეს */
გაფრთხილება(test_link.new_prop); //გამარჯობა
/* მაგრამ აქ ყველაფერი რიგზეა, რადგან ჩვენ არ წავშალეთ თავად ობიექტი, არამედ მხოლოდ მისი ბმული. ახლა ჩვენი ობიექტი მითითებულია ერთი ბმულით, test_link */

//ახალი ობიექტის შექმნა
ტესტი=ტესტი_ლინკი; //პირველ რიგში, კვლავ შექმენით ტესტის ბმული
test_link=(პროპექტი: "ზოგიერთი ტექსტი") //და აქ არის ახალი ობიექტი

გაფრთხილება(test_link.prop); //რაღაც ტექსტი
alert(test.prop); //განუსაზღვრელი
/* ახალი ობიექტის შექმნა არღვევს საცნობარო ბმულს და ახლა ტესტი და test_link მიუთითებს სხვადასხვა ობიექტზე.
სინამდვილეში, ეს უდრის test_link-ის წაშლას და ხელახლა შექმნას, მაგრამ მიუთითებს სხვა ობიექტზე */
alert(test.new_prop); //გამარჯობა - ახლა ტესტი შეიცავს ბმულს ჩვენს პირველ ობიექტთან

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

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

პრიმიტიული ღირებულებები

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

obj= ახალი სტრიქონი ("გამარჯობა"); //სტრიქონის შექმნა ობიექტად
მარტივი = "გამარჯობა" ; //პრიმიტიული მნიშვნელობის შექმნა

გაფრთხილება(obj); //გამარჯობა
გაფრთხილება (მარტივი); //გამარჯობა - ჯერჯერობით ყველაფერი პროგნოზირებადია

Alert(obj.length); //6 - String ტიპის ობიექტს აქვს სიგრძე თვისება, რომელიც ინახავს სტრიქონის სიგრძეს
გაფრთხილება (მარტივი.სიგრძე); //6
/* მიუხედავად იმისა, რომ simple არ არის ობიექტი, ჩვენ შეგვიძლია მივიღოთ თვისებების იგივე ნაკრები, როგორც String ტიპის ობიექტი. საკმაოდ მოსახერხებელია */

Obj.prop="text" ;
simple.prop="text" ;

Alert(obj.prop); //ტექსტი - ვინაიდან obj ჩვეულებრივი ობიექტია, შეგვიძლია მას სხვა თვისება მივცეთ მარტივად
alert(simple.prop); // განუსაზღვრელი - მაგრამ მარტივი არ არის ობიექტი და ეს რიცხვი არ გამოგვადგება

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

არ ავურიოთ პრიმიტიული მნიშვნელობების გამოყენება ლიტერალების გამოყენებასთან - მაგალითად, შევქმნით მასივს როგორც "test=new Array()" თუ როგორც "test=", შედეგი მაინც იგივე ობიექტი იქნება. ჩვენ არ მივიღებთ პრიმიტიულ ღირებულებებს.

ობიექტების შექმნა და გამოყენება

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

ტესტი =(
simple_property: "გამარჯობა" ,
ობიექტი_საკუთრება: (
user_1: "პეტია" ,
user_2: "ვასია"
},
ფუნქცია_თვისება: ფუნქცია (მომხმარებელი) (
alert(this .simple_property + ", " + this .object_property);
}
}

Test.function_property("user_1" ); //გამარჯობა, პეტია.

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

ჩვენი ფუნქცია ორჯერ იყენებს ამ საკვანძო სიტყვას, რომელიც არის მაჩვენებელი (ანუ მითითება) იმ ობიექტისთვის, საიდანაც არის ფუნქცია გამოძახებული. ამრიგად, this.simple_property=test.simple_property="გამარჯობა", და this.object_property=test.object_property="Peter".

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

test.function_property("user_1" ); //გამარჯობა, პეტია.

Test2=new Object(); //ახალი ობიექტის შექმნის სხვა ფორმა, მსგავსი test2=()

Test.function_property.call(test2, "user_1" ); //შეცდომა
/* გამოძახების მეთოდი საშუალებას გაძლევთ გამოიძახოთ ფუნქცია სხვა ობიექტის სახელით. ამ შემთხვევაში ჩვენ ვუწოდებთ სატესტო ობიექტის ფუნქციას_საკუთრების მეთოდს და ეს აღარ მიუთითებს ტესტის ობიექტზე, არამედ test2 ობიექტზე. Და ამიტომ მას არ აქვს object_property თვისება, მაშინ როდესაც თქვენ ცდილობთ მიიღოთ this.object_property სკრიპტი გაუშვებს შეცდომას */

//ვცადოთ სიტუაციის გამოსწორება
test2.simple_property="კარგი დღე" ;
test2.object_property=test.object_property; //ამ შემთხვევაში, ჩვენ გამოვიყენებთ ობიექტის მითითებას, რათა არ მოხდეს კოდის დუბლირება

Test.function_property.call(test2, "user_1" ); //დღე მშვიდობისა, პეტია.

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

კონსტრუქტორი

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

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

make_me= ფუნქცია (_name) (
alert ("მე გავუშვი" );
ეს .name=_name;

}

/* მოდით გავარკვიოთ რა ხდება აქ. თარჯიმანი ხედავს ახალ ოპერატორს და ამოწმებს რა არის მისგან მარჯვნივ. იმიტომ რომ make_me არის ფუნქცია და ის შეიძლება გამოვიყენოთ როგორც კონსტრუქტორი, შემდეგ იქმნება ახალი ობიექტი მეხსიერებაში და გაშვებულია make_me ფუნქცია შესასრულებლად და ეს მიუთითებს ზუსტად ამ ახალ ობიექტზე. შემდეგი, ამ ობიექტს ემატება სახელის თვისება, რომელსაც ენიჭება მნიშვნელობა _name არგუმენტიდან და show_name მეთოდი. ასევე (არ ვიცი რომელ მომენტში, მაგრამ არ აქვს მნიშვნელობა) ბავშვის ცვლადი იწყებს მიუთითებს ჩვენს ახალ, ახლად დაბადებულ ობიექტზე */

გაფრთხილება (ბავშვის სახელი); //ვასია
child.show_name(); //ვასია

child2.show_name(); //პეტრე

Child2.show_name=ფუნქცია () (გაფრთხილება( "ჩემს სახელს არ ვიტყვი");} //არ ​​დაგავიწყდეთ, რომ ჩვენ შეგვიძლია შევცვალოთ ჩვენი ობიექტები ნებისმიერ დროს
child2.show_name(); //სახელს არ ვიტყვი

Child.show_name(); //ვასია - ბავშვები არანაირად არ ახდენენ ერთმანეთზე გავლენას

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

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

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

Პროტოტიპი

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

make_me= ფუნქცია (_name) (
alert ("მე გავუშვი" );
ეს .name=_name;
ეს .show_name=ფუნქცია () (გაფრთხილება (this .name);)
}
/*
ფუნქციის საკვანძო სიტყვის დანახვისას, თარჯიმანი ამოწმებს კოდს მის მარჯვნივ და ა.შ. ყველაფერი წესრიგშია - ის ქმნის ახალ ობიექტს მეხსიერებაში, რაც ასევე ჩვენი ფუნქციაა. შემდეგ ავტომატურად (პროგრამის ჩარევის გარეშე) ამ ფუნქციისთვის იქმნება პროტოტიპის თვისება, რომელიც ეხება ცარიელ ობიექტს. თუ ამას ხელით გავაკეთებდით, გამოიყურებოდა make_me.prototype=new Object();

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

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

//ობიექტი - მართლაც, ობიექტი
alert(typeof make_me.prototype.constructor); //ფუნქცია არის ჩვენი ფუნქცია
alert(make_me.prototype.constructor === make_me); //მართალია

//ახალი მეთოდის დამატება make_me ფუნქციის პროტოტიპში

ბავშვი=ახალი მაკიაჟი_მე("ვასია"); //გავაშვებინე
/* ახლა, წინა მაგალითში აღწერილი ყველაფრის გარდა, ბავშვის ობიექტში იქმნება დამატებითი დამალული თვისება [], რომელიც მიუთითებს იმავე ობიექტზე, როგორც make_me.prototype. იმიტომ რომ საკუთრება იმალება, ჩვენ არ შეგვიძლია მისი ღირებულების ნახვა და შეცვლა - თუმცა, ის მნიშვნელოვან როლს ასრულებს შემდგომ მუშაობაში */

გაფრთხილება (ბავშვის სახელი); //ვასია
child.show_name(); //ვასია

Child.set_name ("კოლია" );
/* პირველი, თარჯიმანი ეძებს set_name მეთოდს ბავშვის ობიექტში. ვინაიდან ის იქ არ არის, ის აგრძელებს ძიებას ბავშვში.[ თვისება, პოულობს იქ და აწარმოებს მას. */
child.show_name(); //კოლია - ახლა ვასიას კოლია ჰქვია :)

Make_me.prototype.show_name2=ფუნქცია () (გაფრთხილება ("გამარჯობა, " + ეს .სახელი;) //იმიტომ პროტოტიპი ჩვეულებრივი ობიექტია, ჩვენ ასევე შეგვიძლია შევცვალოთ ის ფრენისას

Child2=new make_me("Petya" );
child2.show_name2(); //გამარჯობა, პეტია
child.show_name2(); //გამარჯობა, კოლია - პროტოტიპში ცვლილებები გავლენას ახდენს არა მხოლოდ ახლად შექმნილ ობიექტებზე, არამედ ყველა ძველზე.

Child2.show_name2=ფუნქცია () (გაფრთხილება( "ჩემს სახელს არ ვიტყვი");} //ჩვენ მაინც შეგვიძლია შევცვალოთ თავად ობიექტი და ახალი show_name2 მეთოდი ამ ობიექტში (და მხოლოდ მასში), როგორც იყო, „გადაწერს“ ძველ მეთოდს პროტოტიპიდან.
child2.show_name2(); //სახელს არ ვიტყვი - იმიტომ რომ... ჩვენ ახლა გვაქვს ჩვენი საკუთარი მეთოდი show_name2, შემდეგ მას უწოდებენ და პროტოტიპში ძიება არ ხდება

Child.show_name2(); //გამარჯობა, კოლია - აქ ისევ ისეა ყველაფერი

Make_me.prototype=(პროპ.: "გამარჯობა") //მოდით, ისევ ვცადოთ პროტოტიპის ხელახლა შექმნა

Alert(child.prop); //განუსაზღვრელი
child.show_name2(); //გამარჯობა კოლია
/* თუ გახსოვთ რა არის მითითებით მუშაობა, მაშინ ყველაფერი გასაგებია. პროტოტიპის ხელახლა შექმნა არღვევს კავშირს და ახლა ბავშვის და child2 ობიექტების [] თვისება მიუთითებს ერთ ობიექტზე (რომელიც ადრე იყო make_me ფუნქციის პროტოტიპი), ხოლო make_me.prototype თვისება მიუთითებს სხვა ობიექტზე, რომელიც არის ახალი. make_me ფუნქციის პროტოტიპი */

Child3=new make_me("Oleg" );
alert(child3.prop); //გამარჯობა - როგორც მოსალოდნელი იყო

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

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

make_me= ფუნქცია (_name) (
alert ("მე გავუშვი" );
ეს .name=_name;
ეს .show_name=ფუნქცია () (გაფრთხილება (this .name);)
}

Make_me.prototype.set_name=ფუნქცია (_name) (ეს .name=_name;)
ბავშვი=ახალი მაკიაჟი_მე("ვასია" );

Alert(typeof make_me.prototype); //ობიექტი - ფუნქციას აქვს პროტოტიპის თვისება
alert(ბავშვის ტიპი.პროტოტიპი); // განუსაზღვრელი - შექმნილ ობიექტს არ გააჩნია პროტოტიპის თვისება
alert(child.constructor.prototype === make_me.prototype); //true - მაგრამ ობიექტს აქვს კონსტრუქტორის თვისება, რომელიც მიუთითებს კონსტრუქტორის ფუნქციაზე make_me, რომელსაც, თავის მხრივ, აქვს პროტოტიპის თვისება.

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

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

მემკვიდრეობა

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

ჩიტი = ფუნქცია()() //ეს არის ჩიტის კონსტრუქტორი
bird.prototype.cry=function ()(alert("ტირილი!");) //ჩიტს შეუძლია ყვირილი
bird.prototype.fly=function ()(alert ("მე ვფრინავ!");) //და ფრენა

იხვი = ფუნქცია () ()
იხვი.პროტოტიპი=ახალი ჩიტი();
duck.prototype.cry=function ()(გაფრთხილება ("Quack-quack!" ;) //იხვი სხვანაირად ყვირის
იხვი.პროტოტიპი.კონსტრუქტორი=იხვი; //Forcibly დააყენეთ prototype.constructor თვისება duck, რადგან წინააღმდეგ შემთხვევაში, ეს ეხება ფრინველს

ბილი = ახალი იხვი(); //ბილი ჩვენი იხვია
billy.fly(); //Მე დავფრინავ! - ბილს შეუძლია ფრენა, რადგან ის ჩიტია.
billy.cry(); //ვაკ ქუაკი! - ბილი ყვირის, რადგან ის იხვია.

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

ვარსკვლავი ამოცანა

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

make_me= ფუნქცია()()
ბავშვი=new make_me();
alert(child.toString()); //გამოსვლები

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

პირველ ხაზზე ვქმნით ახალ ფუნქციას და ცვლადს, სახელად make_me, რომელიც მიუთითებს ამ ფუნქციაზე. ეს ქმნის ფუნქციის პროტოტიპს, make_me.prototype, რომელიც შეიცავს კონსტრუქტორის თვისებას, რომელიც მიუთითებს make_me-ზე.
მაგრამ ეს ყველაფერი არ არის :)
იმიტომ რომ make_me ფუნქციაც ობიექტია, შემდეგ მას, თავის მხრივ, ჰყავს მამა და დედა, ე.ი. დიზაინერი და პროტოტიპი. მისი კონსტრუქტორი არის Function() ენის მშობლიური ფუნქცია, ხოლო მისი პროტოტიპი არის ობიექტი, რომელიც შეიცავს მეთოდებს call, application და ა.შ. - სწორედ ამ პროტოტიპის წყალობით შეგვიძლია ამ მეთოდების გამოყენება ნებისმიერ ფუნქციაში. ამრიგად, make_me ფუნქციას აქვს [] თვისება, რომელიც მიუთითებს Function.prototype-ზე.

თავის მხრივ, ფუნქციის კონსტრუქტორის პროტოტიპი ასევე არის ობიექტი, რომლის კონსტრუქტორი არის (სიურპრიზი!) ობიექტი (ანუ ფუნქცია.პროტოტიპი.[].კონსტრუქტორი===ობიექტი), ხოლო პროტოტიპი არის ობიექტი, რომელიც შეიცავს სტანდარტულ თვისებებს. და ობიექტის მეთოდები, როგორიცაა toString, hasOwnProperty და სხვა (სხვა სიტყვებით - Function.prototype.[]["hasOwnProperty"] - ეს არის ზუსტად ის მეთოდი, რომელიც შეგვიძლია გამოვიყენოთ ყველა წარმოებულ ობიექტში - და ეს არის საკუთარი მეთოდი. ამ ობიექტის და არა მემკვიდრეობითი). ამ საინტერესო გზით ჩვენ აღმოვაჩენთ, რომ ყველა სახის ობიექტი მომდინარეობს ობიექტიდან.

შეგვიძლია კიდევ გავაგრძელოთ? თურმე არა. Object.prototype შეიცავს ობიექტის ძირითად თვისებებს სწორედ იმიტომ, რომ მას არ გააჩნია საკუთარი პროტოტიპი. ობიექტი.პროტოტიპი.[]=null; ამ დროს ჩერდება მოგზაურობა პროტოტიპის ჯაჭვში ქონების ან მეთოდის ძიებაში.

კიდევ ერთი საინტერესო ფაქტი არის ის, რომ ობიექტის კონსტრუქტორი არის ფუნქცია. იმათ. ობიექტი.[].კონსტრუქტორი===ფუნქცია.
არის კიდევ ერთი წრიული მითითება - Object-ის კონსტრუქტორი არის Function, ხოლო Function.prototype-ის კონსტრუქტორი არის Object.

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

ისე, მესამე სტრიქონში ჩვენ ვხედავთ, თუ როგორ მიდის თარჯიმანი ჯაჭვზე, ბავშვიდან ბავშვამდე.[] (aka make_me.prototype), შემდეგ ბავშვზე.[].[] (aka Object.prototype), და უკვე პოულობს იქ. toString მეთოდი, რომელიც იწყებს შესრულებას.

მინარევები

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

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

//ეს არის ადამიანის კონსტრუქტორი
კაცი = ფუნქცია () (
this .live=function ()(alert("მე ცოცხალი ვარ" ;) //ადამიანმა იცის როგორ იცხოვროს
this .walk=function ()(alert("მე დავდივარ" ;) //კაცს შეუძლია სიარული
}

//ეს არის პოეტის კონსტრუქტორი
პოეტი=ფუნქცია ()(
ეს .kill=ფუნქცია ()(გაფრთხილება( "პოეტმა მოკლა კაცი");} //პოეტს შეუძლია ადამიანის მოკვლა
this .live=function () (გაფრთხილება ("მე მკვდარი ვარ" ;) //ამისგან ადამიანი მოკვდება
}

ვლადიმირ=ახალი კაცი(); //ვლადიმირი კაცია
vladimir.live(); //მე ვცხოვრობ - ის ცოცხალია
vladimir.walk(); //მივდივარ - ის დადის

პოეტი.ზარი(ვლადიმერ); //შეასრულეთ პოეტის კონსტრუქტორი ვლადიმირის ობიექტისთვის
vladimir.kill(); //პოეტმა მოკლა კაცი
vladimir.live(); //Მკვდარი ვარ

//ახლა ფოკუსირება
კაცი.ზარი(ვლადიმერ);
vladimir.live(); //Მე ვცხოვრობ

* ეს საწყისი კოდი მონიშნული იყო Source Code Highlighter-ით.

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

განახლება: დახურვები და კერძო საკუთრებები

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

რა ვუყოთ ახლა ამ ყველაფერს

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

უფრო მეტიც, ფასის საკითხი საკმაოდ არატრივიალურია, განსაკუთრებით თუ ვსაუბრობთ Internet Explorer 6 და 7 ბრაუზერის ვერსიების განვითარებაზე.
1. მეხსიერება - აქ ყველაფერი მარტივია. ყველა ბრაუზერში, პროტოტიპებზე მემკვიდრეობა გაცილებით ნაკლებ მეხსიერებას იკავებს, ვიდრე კონსტრუქტორების საშუალებით მეთოდების შექმნისას. უფრო მეტიც, რაც მეტი მეთოდი და თვისება გვაქვს, მით უფრო დიდია განსხვავება. თუმცა, უნდა გვახსოვდეს, რომ თუ ჩვენ არ გვაქვს ათასი იდენტური ობიექტი, მაგრამ მხოლოდ ერთი, მაშინ მეხსიერების მოხმარება ნებისმიერ შემთხვევაში იქნება მცირე, რადგან აქ გასათვალისწინებელია სხვა ფაქტორებიც.
2. პროცესორის დრო - აქ ძირითადი დახვეწილობა დაკავშირებულია კონკრეტულად Microsoft-ის ბრაუზერებთან.
ერთის მხრივ, ობიექტები, სადაც მეთოდები და თვისებები იქმნება კონსტრუქტორის მეშვეობით, შეიძლება შეიქმნას ბევრჯერ (ზოგიერთ შემთხვევაში ათობით და ასჯერ) უფრო ნელა, ვიდრე პროტოტიპის საშუალებით. რაც მეტი მეთოდია, მით უფრო ნელია. ასე რომ, თუ თქვენი IE იყინება რამდენიმე წამით სკრიპტის ინიციალიზაციის დროს, ამ მიმართულებით გათხრა არსებობს.

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

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

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

ტეგები: ტეგების დამატება

მოგესალმებით ყველას, ვინც კითხულობს ამ პუბლიკაციას. დღეს მინდა გაგაცნობთ ენის ძირითად ხელსაწყოს - JavaScript ობიექტების. შეგახსენებთ, რომ js არის კროს ბრაუზერი და მუშაობს ყველა ოპერაციულ სისტემაზე (windows, mac os და ა.შ.). ობიექტზე ორიენტირებული პროგრამირების ენებისგან განსხვავებით, js-ში ობიექტების დანერგვა მნიშვნელოვნად განსხვავდება ინსტანციების გამოყენების ჩვეულებრივი ფუნქციონალებისგან და ვარიაციებისგან, მაგალითად, C#-ში.

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

რა არის ობიექტი JavaScript-ში და რა შესაძლებლობები აქვს მას?

js-ში ობიექტები არის მარტივი ასოციაციური მასივები (მათ ასევე უწოდებენ ჰეშებს).

რა არის ასოციაციური მასივი?

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

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

1 2 3 4 5

var avto = ( დასახელება: "BMW 116i", ფერი: "შავი", ფასი: 588000 );

var avto = ( დასახელება: "BMW 116i", ფერი: "შავი", ფასი: 588000 );

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

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

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

var auto = (); ან var auto = new Object();

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

ყველაფერი თვისებების შესახებ

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

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

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

პირველი გზა.

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

avto.name = „BMW 116i“

მაგრამ ამ მეთოდით თქვენ დაამატებთ კიდევ ერთ ელემენტს არსებულ გასაღებს:

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

მეორე გზა.

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

avto[„სახელი“] = „BMW 116i“

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

avto["მანქანის სახელი"] = "BMW 116i"

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

var auto = (); avto.name = "BMW_116i"; avto.ფასი = 588000; var key = "ფასი"; // მანქანის ფასი მოითხოვა alert(avto);

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

წაშალე ავტო.ფასი;

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

შემდეგ, გაფრთხილების მეორედ გამოძახებისას, დიალოგური ფანჯარა გამოჩნდება "გაუზუსტებელი".

რამდენიმე სიტყვა კომპაქტურობის შესახებ

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

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

მოდით გავიაროთ ჩვენი თვისებები

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

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

js-ში ის თავისი გარეგნობით მარყუჟს წააგავს foreach C# ენიდან. შეამოწმეთ ზოგადი დიზაინი:

for (var obj ობიექტში) ( // ძიების შესრულება)

სადაც obj პასუხისმგებელია ჩამოთვლილი გასაღებების სახელზე,

ობიექტი - მათი ღირებულებებისთვის.

ახლა კი აქ არის კონკრეტული მაგალითი თქვენთვის.

1 2 3 4 5 6 7 8

var avto = ( დასახელება: "BMW 116i", ფერი: "შავი", ფასი: 588000 ); for (var obj ობიექტში) ( alert(obj + ":" + ობიექტი) )

var avto = ( დასახელება: "BMW 116i", ფერი: "შავი", ფასი: 588000 ); for (var obj ობიექტში) ( alert(obj + ":" + ობიექტი) )

დროა გაეცნოთ მეთოდებს

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

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

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

აქ მოცემულია ამ მექანიზმის განხორციელება:

var avto =() avto.name = “BMV” avto.year = 1999 avto.drive = function(k) ( alert(“მანქანამ გაიარა”+n+“კმ.”)) avto.drive(300) avto. წამყვანი (450)

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

JS-საც აქვს კონსტრუქტორები?

Დიახ სერ! ამ ენაზე ყველაფერი, რაც იყენებს საკვანძო სიტყვას " ახალი", ავტომატურად ხდება კონსტრუქტორი. ასე რომ, ზემოთ თქვენ ნახეთ ცარიელი ობიექტის დეკლარაცია სახით: avto = ახალი ობიექტი ();. ეს არის კონსტრუქტორი.

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

var bob = ახალი ობიექტი();

bob.name = "ბობ სმიტი";

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

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

ფუნქცია Auto (სახელი, ფასი) (

ეს.სახელი = სახელი;

ეს.ფასი = ფასი;

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

var car1 = new Avto("BMW", 650000);

var car2 = ახალი Avto ("Audi", 520000);

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

მემკვიდრეობის მახასიათებლები JavaScript-ში

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

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

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

მოდით გადავიდეთ მაგალითზე.

ფუნქცია Transport (სახელი) ( this.name = name this.canDrive = true ) var transport = ახალი ტრანსპორტი ("avto") // შეიქმნა სატრანსპორტო ობიექტის ფუნქცია Bike (სახელი) ( this.name = name ) Bike.prototype = transport / / მიუთითეთ, რომ ამ კლასის ყველა ახალი ობიექტი გამოიყენებს სატრანსპორტო bike1 = new Bike ("for_sport") bike2 = new Bike ("for_child") console.log(bike1.name) console.log(bike2.name) console .log (bike1.canDrive)

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

Ნახვამდის!

პატივისცემით, რომან ჩუეშოვი

წაიკითხეთ: 97 ჯერ