დავბრუნდით ვინსტონების შემქმნელ პროგრამაში,
მაგრამ მე დავამატე ახალი ობიექტი - ჰოპერი, რადგან ჰოპერი
თავს გამოტოვებულად გრძნობდა. მას ვინსტონის მსგავსად განვმარტავ,
ვიწყებ კონსტრუქციული ფუნქციით და იგივე თვისებებით, დახატვით,
ლაპარაკით და კიდევ დავამატე ფუნქცია "ვაშა" რადგან ჰოპერები სიხარულს გამოხატავენ.
ფუნქციის ბოლოში შევქმენი ორი ახალი ჰოპერის ობიექტი: პატარა ჰოპერი და დიდი ჰოპერი.
დავხატე ისინი, ერთზე გამოვიძახე "ლაპარაკი", მეორეზე - "ვაშა".
ძალიან კარგი.
ახლა, ამ კოდს თუ დაუკვირდებით,
შესაძლოა საინტერესო რამ შენიშნოთ.
ჰოპერის კოდი ძალიან ჰგავს ვინსტონისას. დაუკვირდით კონსტრუქტორს, ზუსტად იგივეა.
ლაპარაკის ფუნქციაც ზუსტად შეესაბამება ვინსტონის ლაპარაკის ფუნქციას,
ასევე, ორივეს აქვს დახატვის ფუნქცია.
ესეიგი ამ ორ ობიექტს ბევრი საერთო აქვს,
ეს იმიტომ, რომ ჰოპერი და ვინსტონი ძალიან მსგავსი ობიექტის ტიპებია.
თუ დაუფიქრდებით, ნამდვილ სამყაროში,
კომპიუტერს გარეთ ობიექტების უმეტესობას სხვა ობიექტებთან რაღაც საერთო აქვს.
მაგალითად, ცხოველთა სამეფო.
ყველა ცხოველი მსგავსია, მაგრამ ისინი სხვადასხვა ტიპისანი არიან,
როგორც ადამიანები. ადამიანებსაც აქვთ ეს მსგავსებები,
მაგრამ მათ თავიანთი უნიკალური თვისებებიც გააჩნიათ.
ესეიგი ცხოველი ობიექტის ტიპია, რომლისგან ადამიანის ობიექტის ტიპი თვისებებს იძენს.
ნულიდან დაწყება არ გვიწევს, ცხოველების არსებულ თვისებებს ჩვენსას ვუმტებთ.
ყველა ცხოველი უშვებს ხმას,
ადამიანებს კი ენაც აქვთ.
ეს ობიექტის მემკვიდრეობითობა პროგრამირებაშიც ძალიან გამოსადეგია.
Javascript შეგვიძლია მემკვიდრეობის ჯაჭვი შევქმნათ.
უნდა მოვიფიქროთ რა არის საერთო ობიექტის ტიპებს შორის
და მოვიფიქროთ კარგი სახელი,
რადგან უნდა შევქმნათ ახალი ობიექტის ტიპი,
რომელიც წარმოადგენს საფუძველ ობიექტს,
ამიტომ დავარქვათ "არსებები".
ორივე არსებაა.
ესეიგი ვამბობთ var არსება უდრის. ახლა გვჭირდება კონსტრუქტორი ფუნქცია.
მოდი უბრალოდ ჰოპერის მოვიპაროთ, რაც იგივე ვინსტონისაა.
კარგი.
ახლა, ვნახოთ...
ახლა გვინდა...
ახლა რისი გაკეთება გვინდა?
ალბათ, ჯობს ფუნქცია "ლაპარაკი" დავამატოთ.
"ლაპარაკი" ფუნქციისთვის ისევ ჰოპერს მოვპაროთ. ჯერ არსების პროტოტიპს მოვარგებთ.
ძალიან კარგი.
ახლა გვაქვს არსების ობიექტის ტიპი.
საჭიროა ჰოპერს ვუთხრათ რომ ის "არსების" საფიძველში უნდა იყოს.
დავწეროთ Hopper.prototype = object.create
creature.prototype
Javascript-ს ჰოპერის ფუნქციონალურობას ეს ხაზი "არსების" პროტოტიპზე დააფუძნებინებს.
ესეიგი ჰოპერის ფუნქციის მოძებნისას ჯერ ნახავს ჰოპერის პროტოტიპს,
თუ აქ ვერ იპოვის, შემდეგ მოძებნის არსების პროტოტიპში.
ამას ეწოდება პროტოტიპის ჯაჭვი.
ამის გაკეთების შემდეგ შეგვიძლია ჰოპერის ლაპარაკის ფუნქციის წაშლა,
რადგან ის უკვე არსებას გააჩნია,
რომელიც პროტოტიპის ჯაჭვში ზემოთაა.
მზად ხართ?
იმუშავა!
მუშაობს, რადგან პოულობს არსების პროტოტიპში.
ახლა ვინსტონის წაშლაც ვცადოთ.
წერია რომ ობიექტს არ აქვს ლაპარაკის მეთოდი.
რატომ? იმიტომ რომ გვაქვს ვინსტონის კონსტრუქტორი,
დახატვა, ლაპარაკი კი მოვაშორეთ.
დაგვავიწყდა რომ ვინსტონის პროტოტიპი არსების პროტოტიპზე დაგვეფუძნებინა.
ეს ხაზიც აუცილებელია.
Winston.prototype=object.create
creature.prototype.
ესეც ასე!
დაუკვირდით იმას, რომ
ეს ხაზი კონსტრუქტორი ფუნქციის შემდეგაა, მაგრამ ნებისმიერი სხვა რამის დამატებამდე.
სწორედ ამისი გაკეთებაა საჭირო.
ამით ვამბობთ თუ რაზე იქნება საწყისი პროტოტიპი დაფუძნებული.
პროტოტიპს კიდევ რაღაცებს ვამატებთ,
რადგან შესაძლოა რამე უნიკალური იყოს ვინსტონში, ან ჰოპერში,
რაც ზოგადად არსებებს არ ახასიათებთ.
ანუ მათი განმარტვა დაშვებულია.
თუ დავუკვირდებით, გარკვეული კოდი ისევ მეორდება.
კონსტრუქტორი კოდი.
ეს სამჯერაა დაწერილი.
შეგვიძლია უბრალოდ წაშლა?
ვცადოთ.
როგორც ჩანს არ იმუშავა.
ჰოპერი მარცხენა ზედა კუთხეშია, თითქოს ყველაფერი დაავიწყდა.
Javascript არ თვლის რომ იგივე კონსტრუქტორი გინდა, რადგან პროტოტიპი მასზე დააფუძნე.
საშუალებას გაძლევს შენ თვითონ განსაზღვრო კონსტრუქტორი ამ ობიექტებისთვის.
ასევე, იძლევა მარტივ გზას კონსტრუქტორის ობიექტიდან გამოძახებისთვის.
ასე მოვიქცეთ:
დავწეროთ creature.callthis,nickname,age,x,y
ეს ასეთ რამეს აკეთებს (იმუშავა!),
იძახებს არსების ფუნქციას და კონსტრუქტორ ფუნქციას.
იძახებს ფუნქციას და ეუბნება რომ გამოიძახოს კონსტრუქტორი ფუნქცია,
თითქოს ის ობიექტი ჰოპერიდან იყოს ამ არგუმენტებით გამოძახებული.
ეს ის არგუმენტებია, რითაც ვიძახებთ ჰოპერს.
საბოლოოდ ეს კოდი შესრულდება, თითქოს აქ ეწერა.
ჩვენც სწორედ ეს გვინდა. იმუშავა.
შეგვიძლია ეს ხაზიც ვინსტონის კონსტრუქტორში გადავაკოპიროთ.
მუშაობს! ძალიან კარგი!
საერთო თვისებები და ფუნქციები ამ ერთ ობიექტის ტიპში მოვაქციეთ
და შევქმენით ამ საბაზისო ობიექტზე დაფუძნებული ორი ობიექტის ტიპი.
ისინი გარკვეულ ფუნქციებს იღებენ, ზოგს კი თვითონ ამატებენ.
ეს ძალიან მოსახერხებელია, რადგან საზიარო ფუნქციების შეცვლა ერთ ადგილას შეიძლება.
ასაკის შეცვლა რომ გვინდოდეს, მივუწერდით "წლის".
ახლა ყველას "წლის" აქვს მიწერილი ასაკთან.
შეგვიძლია "ლაპარაკი" ფუნქცია "woo" ფუნქციით შევცვალოთ..
რადგან უკვე იხილეთ როგორ იქმნება ობიექტის ტიპები და როგორ მუშაობს მემკვიდრეობითობა,
მოიფიქრეთ როგორ გამოდგება ეს თამაშების, ნახატების, ანიმაციებისთვის და ა.შ.
მაგალითად, შეიძლება გქონდეს თამაში და ბევრი ტიპის პერსონაჟი,
ყველას შეეძლოს სირბილი მაგრამ მოლოდ ზოგს - ახტომა.
ეს მშვენიერი ადგილია ობიექტის ტიპებისა და მემკვიდრეობითობისთვის.
ალბათ თქვენ კიდევ უამრავი გამოყენების მოფიქრებას შეძლებთ.