გახსენით
დახურვა

სადაც გენერირდება მონაცემთა js ობიექტი. როგორ შემიძლია წვდომა და დავამუშავო ჩადგმული ობიექტები, მასივები ან JSON? რა უნდა გავაკეთო, თუ მონაცემთა სტრუქტურის „სიღრმე“ ჩემთვის უცნობია

07.12.2023 -
ანალიტიკა

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

ბრინჯი. 2.1. ობიექტები JavaScript-ში

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

ჩაშენებული ობიექტები

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

აქ * აღნიშნავს ჩაშენებულ ობიექტებს, რომლებიც განსაზღვრულია Microsoft JScript 3.0 ვერსიაში. ეს ვერსია დანერგილია Microsoft Internet Explorer ბრაუზერის 4.0 ვერსიაში.

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

როგორ ვიმუშაოთ ჩაშენებულ ობიექტებთან?

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

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

ჩამონათვალი 2.1. ფაილი თავი2/თარიღი/თარიღი.html

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

აქ JavaScript სკრიპტი ქმნის მონაცემთა ობიექტს ახალი საკვანძო სიტყვის გამოყენებით, რომელიც ნაცნობია ყველა C++ თაყვანისმცემლებისთვის და Date კონსტრუქტორი პარამეტრების გარეშე:

var dt; dt = new Date();

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

შემდეგი ხაზი ქმნის თარიღის ტექსტის სტრიქონს:

szDate = "თარიღი: " + dt.getDate() + "." + dt.getMonth() + "." +dt.getYear();

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

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

document.write(szDate);

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

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

document.write("დრო: " + dt.getHours() + ":" + dt.getMinutes() + ":" + dt.getSeconds());

HTML დოკუმენტის გამოჩენა Microsoft Internet Explorer 4.0 ვერსიის ბრაუზერის ფანჯარაში ნაჩვენებია ნახ. 2.2.

ბრინჯი. 2.2. იხილეთ ადგილობრივი თარიღი და დრო

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

ბრაუზერის ობიექტები

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

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

ბრაუზერის ობიექტების იერარქია

ბრაუზერის ობიექტების იერარქია სქემატურად არის ნაჩვენები ნახ. 2.2.

ბრინჯი. 2.2. ბრაუზერის ობიექტების იერარქია

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

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

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

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

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

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

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

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

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

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

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

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

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

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

კონკრეტული მაგალითი მოვიყვანოთ.

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

ბრინჯი. 2.3. პოსტების შინაარსის ნახვა

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

საჭირო კლასი იქმნება შემდეგნაირად:

ფუნქცია myRecord (სახელი, ოჯახი, ტელეფონი, მისამართი) ( this.name = სახელი; this.family = ოჯახი; this.phone = phone; this.address = მისამართი; this.secure = false; )

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

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

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

როგორ გამოვიყენოთ კონკრეტული კლასი?

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

var rec1; var rec2; rec1 = new myRecord("Ivan", "Ivanov", "000-322-223", "Malaya Bolshaya st., 225, apt. 226"); rec2 = new myRecord("Petr", "Petrov", "001-223-3334", "Bolshaya Malaya st., 552, apt. 662"); rec2.secure = true;

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

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

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

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

ფუნქცია printTableHead() (...) ფუნქცია printTableEnd() (. this.phone = this.secure = false.printTableHead;

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

this.printRecord = printRecord; this.printTableHead = printTableHead; this.printTableEnd = printTableEnd;

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

rec1.printTableHead(); rec1.printRecord(); rec1.printTableEnd(); rec2.printTableHead(); rec2.printRecord(); rec2.printTableEnd();

დავუბრუნდეთ ნახ. 2.3, წარმოგიდგენთ მის სრულ ტექსტს (ჩამონათვალი 2.2).

ჩამონათვალი 2.2. ფაილის თავი 2/NewObject/NewObject.html

ჩანაწერების ნახვა ჩანაწერების ნახვა

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

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

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

var szSec = ""; if(this.secure) szSec = " (უსაფრთხო)"; else szSec = " (არაუსაფრთხო)".fontcolor("წითელი");

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

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

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

შემდეგი, printTableHead მეთოდი აგზავნის განცხადებას HTML დოკუმენტში

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

printTableEnd მეთოდი ბეჭდავს განცხადებას HTML დოკუმენტში

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

ფუნქცია printTableEnd() ( document.write(""); document.write("

"); }

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

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

document.write(" სახელი:" + this.name.italics() + "");

ჩვენ უკვე აღვწერეთ myRecord კლასის განმარტება ზემოთ.

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

აქ ჩვენ ვქმნით ორ ობიექტს rec1 და rec2 myRecord კლასზე დაყრდნობით და შემდეგ rec2 ობიექტის უსაფრთხო თვისებას ვაყენებთ true.

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

ამ თავში:

JavaScript-ს აქვს რამდენიმე წინასწარ განსაზღვრული ობიექტი, რომელიც შეგიძლიათ გამოიყენოთ სკრიპტების დაწერისას. ეს მოიცავს ობიექტებს, როგორიცაა Array, Boolean, Date, Function, Math, Number, RegExp და String, ისევე როგორც პრიმიტიული ობიექტი Object. ენის ადრინდელ ვერსიებში მასში ასევე შედიოდა დოკუმენტის ობიექტები (ფანჯარა, დოკუმენტი), მაგრამ ისინი ახლა გამორიცხულია JavaScript ენის ბირთვიდან და მიეკუთვნება დოკუმენტის ობიექტის მოდელის (DOM) განმარტებას, რომელიც იქნება მოგვიანებით განიხილეს. თუმცა ამ ობიექტების ზოგიერთი თვისება (დოკუმენტი და ფანჯარა) ჩვენთვის უკვე ნაცნობია.

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

ობიექტი

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

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

ფუნქციის ტესტი(ვერსია) ( this.version = version; ) tmp = new test(1);

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

Alert(tmp.constructor);

ბრინჯი. 4.6.

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

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

Test.prototype.comment = "ახალი კომენტარის თვისება";

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

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

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

Array.prototype.description = "";

რაც შეეხება მეთოდებს, მათგან ოდნავ მეტია განსაზღვრული Object ობიექტისთვის - დაახლოებით 5 მათგანი. ეს არის toSource, toString, watch, unwatch და valueOf, მათი მოკლე აღწერა მოცემულია ცხრილში 4.10.

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

საათისა და უყურების დარჩენილი მეთოდები, Netscape 4 ბრაუზერში დანერგილი საკუთრების გაფართოებები (ახლა ასევე მხარდაჭერილია Mozilla-ს მიერ), განკუთვნილია სკრიპტების გამართვისთვის. ვინაიდან პროგრამის გამართვის საკითხი არ განიხილება ამ პუბლიკაციის ფარგლებში, აზრი არ აქვს ამ მეთოდების აღწერას. მაგრამ ყოველ შემთხვევაში, შეგიძლიათ გაითვალისწინოთ, რომ Sea Monkey-ს ​​(მაგრამ არა Firefox ბრაუზერს) აქვს სკრიპტის გამართვა - JavaScript Debugger.

მასივის ობიექტი

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

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

ArrayName = ახალი მასივი (element1, element2, ... elementN) ArrayName = ახალი მასივი (ArrayLength)

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

კომპიუტერები = ["PC", "Mac", "Sun"];

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

Var ფერები = new Array(3); ფერები = "წითელი"; ფერები = "ლურჯი"; ფერები = "მწვანე";

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

Var ფერები = ახალი მასივი ("წითელი", "ლურჯი", "მწვანე");

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

Var NumColors = ფერები.სიგრძე;

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

რაც შეეხება მეთოდებს, სტანდარტული toSource, toString და valueOf გარდა, მასივები აღჭურვილია კიდევ ათეულით, რომლებიც ჩამოთვლილია ცხრილში 4.11.

ცხრილი 4.11. მასივის ობიექტების მეთოდები მეთოდის აღწერა
კონკატაერთიანებს ორ მასივს და აბრუნებს ახალს
შეუერთდიაერთიანებს მასივის ყველა ელემენტს ერთ სტრიქონში
პოპშლის ბოლო ელემენტს მასივიდან და აბრუნებს მას
ბიძგიამატებს ერთ ან მეტ ელემენტს მასივის ბოლოს და აბრუნებს მის ახალ სიგრძეს
საპირისპირომოძრაობს მასივის ელემენტებს ისე, რომ პირველი გახდეს ბოლო და პირიქით
ცვლაშლის მასივის პირველ ელემენტს და აბრუნებს მას
ნაჭერიშლის მასივის ელემენტების ნაწილს და აბრუნებს ახალ მასივს
შერწყმაამატებს და/ან შლის ელემენტს მასივიდან
დალაგებაახარისხებს მასივის ელემენტებს ანბანურად
უცვლელიამატებს ერთ ან მეტ ელემენტს მასივის დასაწყისში და აბრუნებს მასივის ახალ სიგრძეს (MSIE 5.5 და 6-ში ეს მეთოდი არაფერს აბრუნებს)

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

Var a = ახალი მასივი ("A1", "A2"); var b = ახალი მასივი ("B1", "B2"); var ab = a.concat(b);

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

Str = ab.join(); // მიიღეთ str = "A1,A2,B1,B2"

რაც შეეხება pop მეთოდს, თუ მას იმავე მასივზე გამოვიყენებთ, პასუხად მივიღებთ „B2“-ს და მასივი ჩამოიჭრება პირველ სამ მნიშვნელობამდე. მეორეს მხრივ, shift მეთოდი აბრუნებს პირველ ელემენტს (ჩვენს შემთხვევაში, "A1") და იგივეს აკეთებს მასივის შემთხვევაში, ერთადერთი განსხვავება ისაა, რომ დარჩენილი ელემენტები გადაინაცვლებს წინ.

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

ჩამონათვალი 4.3. მასივებით მუშაობა

იგივე მაგალითის ნახვა შესაძლებელია ფაილში array.html, ამავე დროს შეგიძლიათ ნახოთ მისი მუშაობის ყველა შედეგი ბრაუზერში (იხ. სურ. 4.7).

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

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

Array2D="ელემენტი 0,0" Array2D="ელემენტი 0,1" ... Array2D[N][N]="ელემენტი N,N"

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

ლოგიკური ობიექტი

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

BooleanObj = ახალი ლოგიკური (მნიშვნელობა)

აქ მნიშვნელობა არის ინიციალიზაციის გამოხატულება, რომელიც საჭიროების შემთხვევაში გადაიცემა true ან false. თუ თქვენ მიუთითებთ ისეთ მნიშვნელობას, როგორიცაა 0, null, false, NaN, განუსაზღვრელი ან ცარიელი სტრიქონი, ლოგიკური ობიექტის ინიციალიზაციის შედეგი იქნება false, ხოლო ნებისმიერი სხვა მნიშვნელობის შემთხვევაში, შედეგი იქნება true.

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

X = ახალი ლოგიკური (false); // შედარებისას თუ (x) მივიღებთ ჭეშმარიტს

ამავდროულად, თუ თქვენ უბრალოდ მიანიჭებთ პრიმიტიულ მონაცემთა ტიპს false ცვლადს, მაშინ ის მიიღებს ზუსტად ამას:

X = ყალბი; // შედარებისას თუ (x) მივიღებთ მცდარს

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

A = 100; x = ლოგიკური (a); // x გახდება ჭეშმარიტი, თუ (x) (...)

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

თარიღის ობიექტი

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

ახალი თარიღი() ახალი თარიღი (მილიწამები) ახალი თარიღი ("თარიღი_როგორც_სტრიქონი")

პირველ შემთხვევაში, თარიღის ობიექტი იქმნება მიმდინარე დროით, მეორეში კი მითითებული უნდა იყოს 1970 წლის 1 იანვრიდან გასული მილიწამების რაოდენობა. თუ თარიღი მითითებულია როგორც სტრიქონი, მაშინ ის უნდა იყოს „2005 წლის 28 თებერვალი“. ასევე შესაძლებელია თარიღის დაყენება მთელი რიცხვების გამოყენებით წელი, თვე, დღე და ა.შ.:

ახალი თარიღი (წელი, თვე, დღე [, საათი, წუთი, წამი, მილიწამი])

რა თქმა უნდა, ამ შემთხვევაში, თქვენ შეგიძლიათ თავიდან აიცილოთ წამების და მილიწამების მითითება, მით უმეტეს, რომ ბრაუზერების ძველ ვერსიებში მილიწამები არც კი იყო მხარდაჭერილი. გარდა ამისა, 1.3 ვერსიამდე JavaScript არ უჭერს მხარს 1970 წლის 1 იანვრამდე თარიღს. რაც შეეხება მნიშვნელობების ფორმატს, რომელიც მითითებულია ხაზში, წელი არის ნებისმიერი 4-ნიშნა რიცხვი (თუ მიუთითებთ ორნიშნა რიცხვს, მას დაემატება 1900), თვის ნომერი არის 0-დან ( იანვარს) 11-დან (დეკემბრამდე), ხოლო დღე 0-დან 31-მდეა. შესაბამისად, დროის მნიშვნელობებიც შეზღუდულია: საათის განმავლობაში ეს იქნება მთელი რიცხვი 0-დან 23-მდე, წამებისა და წუთებისთვის - 0-დან 59-მდე და მილიწამებისთვის - 0-დან 999-მდე. ასე რომ, როგორც ობიექტის მნიშვნელობა Date ტიპის, მიუთითეთ 2005 წლის 9 მაისი, თქვენ უნდა დაწეროთ:

Var anyday = ახალი თარიღი (2005, 5, 9);

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

Var now = new Date();

JavaScript 1.3-დან მოყოლებული, თარიღის დიაპაზონი შეიძლება იყოს 100 მილიონ დღემდე 01/01/1970-მდე (ეს არის თითქმის 550 ათასი წელი!). ამავე ვერსიაში არსებობდა მოთხოვნა, რომ წელი ყოველთვის ოთხნიშნა ფორმატში მიეთითებინა, რათა თავიდან ავიცილოთ შეცდომები, რომლებიც დაკავშირებულია საუკუნეების ცვლილებასთან.

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

ცხრილი 4.12. თარიღის ობიექტის მეთოდები მეთოდი და მისი სინტაქსის აღწერა
getDate ()აბრუნებს თვის დღეს ადგილობრივი დროით
getDay ()აბრუნებს კვირის დღეს ადგილობრივი დროით
getFullYear ()აბრუნებს წელს ადგილობრივი დროით
getHours ()აბრუნებს მიმდინარე დროს (საათებს) ადგილობრივ დროში
getMilliseconds ()აბრუნებს მიმდინარე დროს (მილიწამებში) ადგილობრივ დროში
getMiutes ()აბრუნებს მიმდინარე დროს (წუთებს) ადგილობრივ დროში
getMonth ()აბრუნებს მიმდინარე დროს (თვეს) ადგილობრივ დროში
getSeconds ()აბრუნებს მიმდინარე დროს (წამებს) ადგილობრივ დროში
getTime ()აბრუნებს მიმდინარე დროს, როგორც რაოდენობას ადგილობრივი დროით
getTimezoneOffset()აბრუნებს დროის ოფსეტურ წუთებში GMT-თან შედარებით ადგილობრივი დროით
getUTCDate()აბრუნებს თვის დღეს უნივერსალურ დროში
getUTCDay ()აბრუნებს კვირის დღეს უნივერსალურ დროში
getUTCFullYear()აბრუნებს წელს უნივერსალურ დროში
getUTCHours()აბრუნებს მიმდინარე დროს (საათებს) უნივერსალურ დროში
getUTCMilliseconds()აბრუნებს მიმდინარე დროს (მილიწამებში) უნივერსალურ დროში
getUTCMinutes ()აბრუნებს მიმდინარე დროს (წუთებს) უნივერსალურ დროში
getUTCMonth()აბრუნებს მიმდინარე დროს (თვეს) უნივერსალურ დროში
getUTCSseconds()აბრუნებს მიმდინარე დროს (წამებს) უნივერსალურ დროში
getYear ()მოძველებულია. აბრუნებს წელს მოკლე (ორნიშნა) უნივერსალური დროის ფორმატით
გარჩევა (თარიღის_სტრიქონი)აბრუნებს 1970 წლის 1 იანვრიდან გასული მილიწამების რაოდენობას პარამეტრში მითითებულ მნიშვნელობამდე, ადგილობრივი დროით
მითითებული თარიღი (დღე)ადგენს თვის დღეს ადგილობრივი დროით
setFullYear (წელი)ადგენს წელიწადს ადგილობრივი დროით
setHours (საათები)ადგენს დროს (საათებს) ადგილობრივი დროით
setMilliseconds (მილიწამები)ადგენს დროს (მილიწამებში) ადგილობრივ დროში
წუთების დაყენება (წუთები)ადგენს დროს (წუთებს) ადგილობრივ დროში
კომპლექტი თვე (თვე)ადგენს დროს (თვეს) ადგილობრივი დროით
setseconds (წამები)ადგენს დროს (წამებს) ადგილობრივ დროში
SetTime (მილიწამები)ადგენს დროს მილიწამებში ადგილობრივი დროით კონკრეტული თარიღისთვის
setUTCDate (დღე)ადგენს თვის დღეს უნივერსალურ დროში
setUTCFullYear (წელი)ადგენს წელიწადს უნივერსალურ დროში
setUTCHours (საათები)ადგენს დროს (საათებს) უნივერსალურ დროში
SetUTCMilliseconds (მილიწამები)ადგენს დროს (მილიწამებში) უნივერსალურ დროში
setUTCწუთები (წუთები)ადგენს დროს (წუთებს) უნივერსალურ დროში
setUTCთვე (თვე)ადგენს დროს (თვეს) უნივერსალურ დროში
setUTCSseconds (წამი)ადგენს დროს (წამებს) უნივერსალურ დროში
კომპლექტი წელი (წელი)მოძველებულია. ადგენს წელიწადს ადგილობრივი დროით, წლის მნიშვნელობისთვის მისაღებია ორნიშნა ფორმატი
toGMTString()მოძველებულია. გარდაქმნის თარიღს GMT დროის შესაბამის სტრიქონში
toLocaleString()აბრუნებს თარიღს და დროს, როგორც სტრიქონი, რომელიც შეესაბამება ადგილობრივი სისტემის პარამეტრებს
toLocaleDateString()აბრუნებს თარიღს, როგორც სტრიქონი, რომელიც შეესაბამება ადგილობრივი სისტემის პარამეტრების ფორმატს
toLocaleTimeString()აბრუნებს დროს ლოკალური სისტემის პარამეტრების მიხედვით ფორმატირებული სტრიქონის სახით
toSource ()აბრუნებს თარიღის ობიექტს პირდაპირი წარმოდგენით
toString ()აბრუნებს თარიღის ობიექტს სიმებიანი წარმოდგენით
toUTCString()გარდაქმნის თარიღს სტრიქონად უნივერსალური დროის ფორმატში
UTC (პარამეტრები)აბრუნებს უნივერსალურ დროში 1970 წლის 1 იანვრიდან გასული მილიწამების რაოდენობას. პარამეტრებში მითითებულია წელი, თვე და დღე, ასევე (სურვილისამებრ) საათები, წუთები, წამები და მილიწამები
ფასეულობა()აბრუნებს თარიღს, როგორც პრიმიტიულ მნიშვნელობას

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

  • "set"-ით დაწყებული მეთოდები არის თარიღის და დროის დაყენება თარიღის ობიექტებში;
  • "get"-ით დაწყებული მეთოდები განკუთვნილია თარიღის ობიექტებიდან თარიღის, დროის ან მათი ნაწილების მისაღებად;
  • მეთოდები, რომლებიც იწყება „to“-ით, აბრუნებს თარიღს და დროს (ან მათ ნაწილებს) სტრიქონების მნიშვნელობებად;
  • "UTC" შემცველი მეთოდები განსხვავდება მსგავსისგან მხოლოდ იმით, რომ ისინი მუშაობენ უნივერსალური დროის ფორმატით (ანუ აჩვენებს გრინვიჩის საშუალო დროს მიმდინარე დროის სარტყელთან შედარებით ოფსეტის გათვალისწინებით).

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

JavaScript-ში თარიღის სიმებიანი წარმოდგენა აქვს შემდეგი ფორმატი:

კვირის დღე თვე თარიღი წელი საათები: წუთები: წამები GMT±Offset

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

Document.writeln(DateObject.toString()); document.writeln(DateObject.toGMTString()); // და ა.შ.

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

Document.writeln("DateObject.toString()" + DateObject.toString());

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

Document.writeln("DateObject.toLocaleString()" + DateObject.toString());

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

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

თარიღის ობიექტის მეთოდები

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

გამომავალი ფუნქციის შემდეგ ხდება Date ტიპის ობიექტის შექმნა, რომელსაც ენიჭება მნიშვნელობა 2005, მე-3 თვე (აპრილი, ვინაიდან იანვარი არის ნული), 1 დღე, 14 საათი, 30 წუთი, 45 წამი. შემდეგ, დოკუმენტი იხსნება ჩასაწერად და printDate ფუნქცია თანმიმდევრულად გამოიძახება Date ობიექტის 6 სხვადასხვა მეთოდისთვის. ამ სკრიპტის შედეგი იქნება 6 სტრიქონი, რომელიც შეიცავს წყვილების მნიშვნელობებს მეთოდიდან და მისი მუშაობის შედეგიდან, გამოყოფილი ორწერტილით (ნახ. 4.8).

ბრინჯი. 4.8. ერთი და იგივე თარიღის გამოტანა სხვადასხვა მეთოდის გამოყენებით

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

ფუნქციის ობიექტი

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

FunctionName = ახალი ფუნქცია ([argument1, argument2, ...argumentN], FunctionBody)

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

Document.onload = new Function([Argument1, ...argumentN], FunctionBody);

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

Var SquareObj = new Function("x", "return x*x");

აქ SquareObj არის ცვლადის სახელი, x არის მიღებული არგუმენტი და “return x*x” არის ფუნქციის სხეული. ყურადღება მიაქციეთ იმ ფაქტს, რომ არა მხოლოდ ფუნქციის ძირითადი ნაწილი, არამედ მის მიერ მიღებული არგუმენტებიც არის ჩასმული ბრჭყალებში და ასევე, რომ ობიექტის ტიპის სახელი, როგორც ეს ჩვეულებრივ JavaScript-შია, იწერება დიდი ასოთი (Function) .

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

Var a = 5 + SquareObj(2); // მიიღეთ 9

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

ფუნქცია SquareFunc(x) (დაბრუნება x*x;)

შესაბამისად, შეგიძლიათ გამოიყენოთ ასეთი მეთოდით გამოცხადებული ფუნქცია (ამ შემთხვევაში, ფუნქცია მისი „სუფთა“ ფორმით და არა პროცედურა), ანალოგიურად:

Var a = 5 + SquareFunc(2); // ჩვენ ასევე ვიღებთ 9-ს

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

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

არგუმენტები – ფუნქციის არგუმენტების პარამეტრების შესაბამისი მასივი.callee – შეესაბამება ფუნქციის სხეულს. arguments.caller (მოძველებული) – მიუთითებს ფუნქციის სახელს, საიდანაც გამოიძახეს ობიექტი; arguments.length – მიუთითებს ფუნქციის პარამეტრების რაოდენობაზე. length – მიუთითებს ფუნქციის მიერ მოსალოდნელი არგუმენტების რაოდენობაზე (და არა მიღებულ რაოდენობას, როგორც ეს არის argument.length-ის შემთხვევაში);

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

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

მათემატიკის ობიექტი

მათემატიკა არის ჩაშენებული JavaScript ობიექტი, რომელსაც აქვს ძირითადი მათემატიკური მუდმივები და ფუნქციები, როგორც მეთოდები და თვისებები. მაგალითად, Math ობიექტის PI თვისება შეიცავს Pi (π) მნიშვნელობას, რომელიც დაახლოებით უდრის 3.1416-ს და sin მეთოდი აბრუნებს მითითებული რიცხვის სინუსს.

გარდა π რიცხვისა, მათემატიკის ობიექტს აქვს შემდეგი თვისებები:

  • E – ბუნებრივი ლოგარითმების საფუძველი (დაახლოებით 2,718)
  • LN10 - ბუნებრივი ლოგარითმი 10 (დაახლოებით 2.302)
  • LN2 - ბუნებრივი ლოგარითმი 2 (დაახლოებით 0,693)
  • LOG10E - ათობითი ლოგარითმი E (დაახლოებით 0,434)
  • LOG2E - ორობითი ლოგარითმი E (დაახლოებით 1.442)
  • SQRT1_2 - კვადრატული ფესვი 0,5 (დაახლოებით 0,707)
  • SQRT2 - კვადრატული ფესვი 2-დან (დაახლოებით 1.414)

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

Var CircleLength = დიამეტრი * Math.PI;

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

ცხრილი 4.13. JavaScript მათემატიკის მეთოდები მეთოდი და მისი სინტაქსის აღწერა
abs (ნომერი)აბრუნებს არგუმენტის აბსოლუტურ მნიშვნელობას
atan2 (y, x)აბრუნებს რიცხვს დიაპაზონში -? მდე?, რომელიც წარმოადგენს კუთხეს (რადიანებში) x-ღერძსა და წერტილს (x,y) შორის. გაითვალისწინეთ, რომ პირველი არგუმენტი არის Y კოორდინატი
exp(ნომერი)აბრუნებს E-ს მითითებულ სიმძლავრეზე (ექსპონენციალური ლოგარითმი)
ჭერი (ნომერი), იატაკი (ნომერი)აბრუნებს მნიშვნელობას, რომელიც არის უახლოესი დიდი (ჭერი) ან უფრო მცირე (სართული) მთელი რიცხვი
მინ(ნომერი1, ნომერი2), მაქს(ნომერი1, ნომერი2)დააბრუნეთ შედარებული ორი არგუმენტის მცირე (წთ) ან უფრო დიდი (მაქს) რიცხვი
sin (რიცხვი), cos (რიცხვი), თან (რიცხვი), ასინი (რიცხვი), აკოს (რიცხვი), ატან (რიცხვი)დააბრუნეთ სტანდარტული ტრიგონომეტრიული ფუნქციების შედეგი - სინუსი, კოსინუსი, ტანგენსი, რკალი, არკოზინი და არქტანგენსი
სიმძლავრე (ბაზა, მაჩვენებელი)აბრუნებს საფუძველს მაჩვენებლის სიძლიერეზე
შემთხვევითი ()აბრუნებს ფსევდო შემთხვევით რიცხვს 0-დან 1-მდე
რაუნდი (რიცხვი)აბრუნებს მრგვალ მნიშვნელობას უახლოეს მთელ რიცხვამდე
sqrt (ნომერი)აბრუნებს რიცხვის კვადრატულ ფესვს

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

ფუნქცია CircleDiam(Square) (Radius = Math.sqrt(Square / Math.PI) ;)

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

Var sq = prompt("Enter area",1); var di = CircleDiam(კვ); alert("წრის დიამეტრი: "+di);

Math ობიექტის ამ და სხვა მეთოდების მოქმედება ჩანს ფაილში math.html.

ნომრის ობიექტი

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

ახალი ნომერი (მნიშვნელობა)

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

თუ (x!=Number.NaN);

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

  • MAX_VALUE - მაქსიმალური შესაძლო რაოდენობა
  • MIN_VALUE - მინიმალური შესაძლო რაოდენობა
  • NaN - არა რიცხვი
  • NEGATIVE_INFINITY – „უარყოფითი უსასრულობა“, სპეციალური მნიშვნელობა დაბრუნდა გადადინების შემთხვევაში
  • POSITIVE_INFINITY – „პოზიტიური უსასრულობა“, სპეციალური მნიშვნელობა დაბრუნდა გადადინების შემთხვევაში

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

თვისებების გარდა, Number ობიექტს, რა თქმა უნდა, აქვს მეთოდებიც. სტანდარტული toSource, toString და valueOf მეთოდების გარდა, JavaScript 1.5-მა შემოიტანა Number ობიექტის 3 ახალი მშობლიური მეთოდი - toExponential, toFixed და toPrecision. ყველა მათგანი შექმნილია რიცხვების სტრიქონებად გადაქცევისთვის ამა თუ იმ ფორმატის საფუძველზე. ამგვარად, toExponential მეთოდი აკონვერტებს რიცხვს სტრიქონად, როგორც რიცხვი მაჩვენებლით, toFixed მეთოდი გარდაქმნის მას რიცხვს, რომელიც შეიცავს რიცხვს ფიქსირებული ათწილადის რიცხვით, ხოლო toPrecision მეთოდი იყენებს ერთ-ერთ ამ მეთოდს, დამოკიდებულია რიცხვი და გამოყოფილი ათობითი ადგილების რაოდენობა.

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

მეთოდი ([სიმბოლოების რაოდენობა])

ცხადია, ყველა მეთოდისთვის, ციფრების რაოდენობა მიუთითებს ათობითი ადგილების რაოდენობაზე, მაგრამ თუ toFixed მეთოდისთვის ნაგულისხმევი მნიშვნელობა (ანუ, თუ არაფერია მითითებული) არის 0, მაშინ toExponential და toPrecision-ისთვის ეს არის ათწილადების საჭირო რაოდენობა. მთელი ნომრის საჩვენებლად. ყველა ამ მეთოდის მოქმედებისა და განსხვავებების უკეთ გასაგებად, მოდით შევხედოთ მათ ჩამონათვალი 4.5-ის მაგალითის გამოყენებით:

ჩამონათვალი 4.5. ექსპონენციალური, ფიქსირებული და ზუსტი მეთოდები

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

აქ ჩვენ კვლავ (როგორც ჩამონათვალში 4.4) გამოვიყენეთ ფუნქცია, რომელიც ბეჭდავს ჯერ გამონათქვამს, შემდეგ კი მისი ინტერპრეტაციის შედეგს, მაგრამ ამ შემთხვევაში დავარქვით printNumber. შემდეგი მოდის ცვლადის ფაქტობრივი დეკლარაცია, რომელზედაც შესრულდება გამოთვლები. ამ შემთხვევაში ჩვენ გამოვაცხადეთ ის, როგორც Number ტიპის ობიექტად, თუმცა, ფაქტობრივად, შეგვეძლო შემოვიფარგლებოდით მარტივი ცვლადის დეკლარაციით (x = 12.45678). საბოლოოდ, დოკუმენტი იხსნება ჩასაწერად და x ცვლადის მნიშვნელობა ჯერ იბეჭდება მასში ყოველგვარი აშკარა კონვერტაციის გარეშე (მაგრამ ჩვენ უკვე ვიცით, რომ სინამდვილეში აქ ავტომატურად გამოიყენება toString() მეთოდი), რის შემდეგაც სამივე განსახილველი მეთოდი იძახიან ჯერ რიცხვითი სიმბოლოების მითითების გარეშე, შემდეგ კი 2 და 4 პარამეტრებით. ამ სკრიპტის შედეგი იქნება 10 სტრიქონი, რომელიც შეიცავს წყვილებს „გამოხატვა: დამუშავების შედეგი“ (ნახ. 4.9).

ბრინჯი. 4.9.

დასასრულს, კიდევ ერთხელ უნდა აღინიშნოს, რომ ეს მეთოდები გამოჩნდა მხოლოდ JavaScript 1.5-ში და, შესაბამისად, არ მუშაობს Netscape 4, MSIE 4/5 და Opera ბრაუზერებში 7.0 ვერსიამდე. ამავდროულად, ისინი უზრუნველყოფენ უფრო მეტ მოქნილობას გამომავალი რიცხვების ფორმატირებისას, ვიდრე, ვთქვათ, მათემატიკის ობიექტის round() მეთოდი.

2011-08-01 // რაიმე შეკითხვა, წინადადება, კომენტარი? Შენ შეგიძლია

ჯერ კიდევ XHTML/HTML4-ის დღეებში, დეველოპერებს ჰქონდათ მხოლოდ რამდენიმე ვარიანტი, რომელთა გამოყენებაც შეეძლოთ DOM-თან დაკავშირებული თვითნებური მონაცემების შესანახად. თქვენ შეგეძლოთ საკუთარი ატრიბუტების გამოგონება, მაგრამ ეს სარისკო იყო - თქვენი კოდი არ იქნებოდა მოქმედი, ბრაუზერებმა შესაძლოა უგულებელყოთ თქვენი მონაცემები და ამან შეიძლება გამოიწვიოს პრობლემები, თუ სახელი ემთხვევა სტანდარტულ HTML ატრიბუტებს.

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

ჩვენი JavaScript კოდი მოძებნის ელემენტს ID msglist-ით. სკრიპტის გამოყენებით ჩვენ მოვიძიებთ user_-ით დაწყებულ კლასებს, ხოლო „bob“ ჩვენს შემთხვევაში იქნება მომხმარებლის ID და ჩვენ გამოვაჩენთ ამ მომხმარებლის ყველა შეტყობინებას.

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

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

HTML5 მონაცემთა ატრიბუტები

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

მორგებული მონაცემთა ატრიბუტები:

  • ეს არის სტრიქონები - მათში შეგიძლიათ შეინახოთ ნებისმიერი ინფორმაცია, რომელიც შეიძლება იყოს წარმოდგენილი ან დაშიფრული, როგორც სტრიქონი, როგორიცაა JSON. ტიპის კასტინგი უნდა განხორციელდეს JavaScript-ის გამოყენებით
  • უნდა იქნას გამოყენებული იმ შემთხვევებში, როდესაც არ არის შესაფერისი HTML5 ელემენტები ან ატრიბუტები
  • მიმართეთ მხოლოდ გვერდს. მიკროფორმატებისგან განსხვავებით, ისინი უნდა იყოს იგნორირებული გარე სისტემების მიერ, როგორიცაა საძიებო სისტემები და მცოცავი
JavaScript დამუშავების მაგალითი #1: getAttribute და setAttribute

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

Var msglist = document.getElementById("msglist"); var show = msglist.getAttribute("data-list-size"); msglist.setAttribute("data-list-size", +show+3);

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

JavaScript-ში დამუშავების მაგალითი No2: jQuery ბიბლიოთეკის data() მეთოდი

როგორც jQuery 1.4.3, data() მეთოდი ამუშავებს HTML5 მონაცემთა ატრიბუტებს. თქვენ არ გჭირდებათ ცალსახად მიუთითოთ მონაცემთა პრეფიქსი, ასე რომ კოდი იმუშავებს:

Var msglist = $("#msglist"); var show = msglist.data("list-size"); msglist.data("list-size", show+3);

თუმცა, გაითვალისწინეთ, რომ jQuery ცდილობს გადაიყვანოს ასეთი ატრიბუტების მნიშვნელობები შესაბამის ტიპებად (ბულიანები, რიცხვები, ობიექტები, მასივები ან null) და გავლენას მოახდენს DOM-ზე. setAttribute-ისგან განსხვავებით, data() მეთოდი ფიზიკურად არ ჩაანაცვლებს data-list-size ატრიბუტს - თუ მის მნიშვნელობას შეამოწმებთ jQuery-ს გარეთ - ის მაინც იქნება 5.

JavaScript დამუშავების მაგალითი No. 3: API მონაცემთა ნაკრებებთან მუშაობისთვის

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

ატრიბუტის სახელი მონაცემთა ნაკრები API სახელი
მონაცემთა მომხმარებელი მომხმარებელი
მონაცემები-მაქსაჟი მაქსიმალური
მონაცემთა სია-ზომა სიის ზომა

ჩვენი ახალი კოდი:

Var msglist = document.getElementById("msglist"); var show = msglist.dataset.listSize; msglist.dataset.listSize = +ჩვენება+3;

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

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

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

Var date = new Date();
დოკუმენტი.ჩაწერა (თარიღი);

შედეგად, თქვენ იხილავთ ასეთ რამეს: "ხუთ ოქტ 14 2010 11:42:06 GMT+0400".

მეორე კონსტრუქტორი Date ობიექტისთვის არის ერთპარამეტრიანი კონსტრუქტორი. ეს პარამეტრი შეიცავს მილიწამების რაოდენობას, რომელიც გავიდა 01/01/1970 წლიდან (უნიქსის ეპოქის დაბადებიდან). მაგალითად, ასე:

Var date = new Date(135253235);
დოკუმენტი.ჩაწერა (თარიღი);

შედეგად, ნახავთ შემდეგს: "პარ იან 02 1970 16:34:13 GMT+0300".

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

Var date = new Date(2010, 0, 12);
დოკუმენტი.ჩაწერა (თარიღი);

შედეგი: "სამ იანვარი 12 2010 00:00:00 GMT+0300". ასევე გაითვალისწინეთ, რომ თვე 0 არის იანვარი, ხოლო 11 თვე არის დეკემბერი.

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

Var date = new Date(2010, 0, 12, 23, 45, 12);
დოკუმენტი.ჩაწერა (თარიღი);

თქვენ მიიღებთ ამ ხაზს: "სამ იან 12 2010 23:45:11 GMT+0300". ეს არის ყველა JavaScript Date ობიექტის კონსტრუქტორი, რომელიც დეველოპერებმა მოგვაწოდეს.

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

Var date = new Date();
document.write("წელი - " + date.getFullYear() + "
");
document.write("თვე - " + date.getMonth() + "
");
document.write("ნომერი - " + date.getDate() + "
");
document.write("კვირის დღე - " + date.getDay() + "
");
document.write("საათი - " + date.getHours() + "
");
document.write("წუთი - " + date.getMinutes() + "
");
document.write("მეორე - " + date.getSeconds() + "
");
document.write("მილიწამი - " + date.getMilliseconds() + "
");
document.write("01/01/1970-დან გასული მილიწამების რაოდენობა - " + date.getTime() + "
");

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

არსებობს მსგავსი მეთოდები, მაგრამ თარიღისა და დროის ჩვენება გრინვიჩის დროით. მოდით დავწეროთ ეს კოდი:

Var date = new Date();
document.write("წელი - " + date.getUTCFullYear() + "
");
document.write("თვე - " + date.getUTCMonth() + "
");
document.write("ნომერი - " + date.getUTCDate() + "
");
document.write("კვირის დღე - " + date.getUTCDay() + "
");
document.write("საათი - " + date.getUTCHours() + "
");
document.write("წუთი - " + date.getUTCMinutes() + "
");
document.write("მეორე - " + date.getUTCSseconds() + "
");
document.write("მილიწამი - " + date.getUTCMilliseconds() + "
");

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

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

Var date = new Date();
თარიღი.setFullYear(1990);
თარიღი.setMonth(11);
თარიღი.setDate(15);
თარიღი.setHours(9);
თარიღი.setMinutes(20);
date.setSeconds(0);
date.setMilliseconds(10);
დოკუმენტი.ჩაწერა (თარიღი);

იმედია შენიშნეთ, რომ setDay() მეთოდი არ არსებობს. ეს ნიშნავს, რომ კვირის დღე შეირჩევა წლის, თვის და თარიღის მიხედვით.

გრინვიჩის მსგავსი მეთოდებიც არსებობს. მხოლოდ UTC პრეფიქსი ემატება, მაგალითად, თვის შესაცვლელად გამოიყენება setUTCMonth() მეთოდი.

და ბოლო მეთოდი არის setTime(). პარამეტრად იღებს მილიწამების რაოდენობას, რომელიც გავიდა 01/01/1970 წლიდან:

Date.setTime(39293012);
დოკუმენტი.ჩაწერა (თარიღი);

შედეგად, თქვენ ნახავთ ამას: "ხუთ იან 01 1970 13:54:53 GMT+0300".

ეს არის ყველა კონსტრუქტორი და მეთოდი Date ობიექტის JavaScript-ში.

გაკვეთილი მოიცავს Javascript ობიექტების თემებს. ჩვენ ვისაუბრებთ მორგებულ ობიექტებზე: ობიექტის შექმნა javaScript-ში, მუშაობა ობიექტის თვისებებთან და მეთოდებთან, ასევე javascript პროტოტიპებთან. მოკლედ აღწერს მდებარეობის, ნავიგატორის, ეკრანის ობიექტებთან მუშაობას


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


JavaScript-ში რამდენიმე ტიპის ობიექტია:

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

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

მომავალ გაკვეთილებში ვისაუბრებთ ბრაუზერის ობიექტებზე javaScript-ში.

ახლა დროა გაეცნოთ პერსონალურ ობიექტებს JavaScript-ში.

  • ობიექტი
  • ნომერი (ნომრის დამუშავება)
  • სტრიქონი (სტრიქონების დამუშავება)
  • მასივი
  • მათემატიკა (მათემატიკური ფორმულები, ფუნქციები და მუდმივები)
  • თარიღი (თარიღებთან და დროებთან მუშაობა)
  • RegExp
  • გლობალური (მისი თვისებები Infinity, NaN, განუსაზღვრელი)
  • ფუნქცია
JavaScript ობიექტის შექმნა

ობიექტების შექმნის 2 გზა არსებობს:

  • ობიექტის ინიციალატორის გამოყენება (ან კოლექციური ობიექტების შექმნა)
  • ობიექტის კონსტრუქტორის გამოყენებით ()
  • კოლექციის ობიექტების შექმნა

    • var object_name = new Object(); object_name.property = მნიშვნელობა;// წერტილის აღნიშვნა ობიექტის_სახელი["თვისება"] = მნიშვნელობა;// ფრჩხილის აღნიშვნა

    მნიშვნელოვანია: აღსანიშნავია, რომ თქვენ არ შეგიძლიათ გამოიყენოთ რიცხვი მნიშვნელობად: myObg.rost = 2 // IMPOSSIBLE! myObg.rost = "2" // შესაძლებელია

    მაგალითი: შექმენით ობიექტი myBrowser თვისებების სახელით (მნიშვნელობა ) და ვერსია (მნიშვნელობა" 9.0 »)


    ✍ გამოსავალი 1:

      var myBrowser = new Object(); myBrowser.name= "Microsoft Internet Explorer"; myBrowser["ვერსია"]= "9.0";

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


    ✍ გამოსავალი:
      var car = new Object(); car.color = "თეთრი" ; car.maxSpeed ​​= 220; car.brand = "Nissan" ; document.write ("მანქანას აქვს ფერი: " + car.color ) ; var moto = ( ფერი: "ლურჯი", ცხენის ძალა: 130, ბრენდი: "Yamaha" ); document.write ("მოტოციკლი დამზადებულია: " + moto.brand ) ;

      var car = new Object(); car.color = "თეთრი"; car.maxSpeed=220; car.brand = "Nissan"; document.write("მანქანას აქვს ფერი: " + car.color); var moto = (ფერი: "ლურჯი", ცხენის ძალა: 130, ბრენდი: "Yamaha"); document.write("მოტოციკლს ჰყავს მწარმოებელი: " + moto.brand);

    "თითოეული" ციკლი Javascript-ში ობიექტებთან მუშაობისას

    ამ დიზაინის შესახებ საკმაოდ ბევრი რამ უკვე ითქვა.
    for in loop javascript-ში შექმნილია მასივების, კოლექციების და ობიექტების მეშვეობით გამეორებისთვის.

    მოდით შევხედოთ გამოყენების მაგალითს:

    1 2 3 4 5 6 7 8 var myBrowser = new Object(); myBrowser.name = "Microsoft Internet Explorer" ; myBrowser[ "ვერსია" ] = "9.0" ; for (var a myBrowser-ში) ( alert(a) ; // იმეორებს myBrowser ობიექტის თვისებებს. დააბრუნებს სახელს, ვერსიას alert(myBrowser[a] ) ; // აბრუნებს თვისების მნიშვნელობებს)

    var myBrowser = new Object(); myBrowser.name= "Microsoft Internet Explorer"; myBrowser["ვერსია"]= "9.0"; for (var a myBrowser-ში) ( alert(a); // იმეორებს myBrowser ობიექტის თვისებებს. დააბრუნებს სახელს, ვერსიას alert(myBrowser[a]); // აბრუნებს თვისების მნიშვნელობებს)

  • კონსტრუქტორის კლასების შექმნა

    • კონსტრუქტორის კლასების შექმნა ხორციელდება ორ ეტაპად:

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

    • ობიექტის კლასის შექმნა კონსტრუქტორის გამოყენებით (კონსტრუქტორის კლასების შექმნა):

    ფუნქცია Object_class_name(sv1, sv2)( this.sv1 = მნიშვნელობა; this.sv2 = მნიშვნელობა; )

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

    var object_name = new class_name("stack_value1","staff_value2");

    var ობიექტის_სახელი =ახალი კლასის_სახელი(); ობიექტის სახელი.stv1="მნიშვნელობა_stv1"; ობიექტის სახელი.stv2="მნიშვნელობა_stv2";

    მიღებულია კონსტრუქტორის კლასის სახელწოდების დაწერა დიდი ასოებით!


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

    მაგალითი: ობიექტების კლასის კონსტრუქტორის შექმნა და ამ კლასზე დაფუძნებული ობიექტის შექმნა: შექმენით ობიექტი myBrowser თვისებების სახელით (მნიშვნელობა "Microsoft Internet Explorer") და ვერსია (მნიშვნელობა" 9.0 »)

    ღია ხსნარი

    1 2 3 4 5 6 7 8 ფუნქცია ბრაუზერი (სახელი, ვერსია) (this .name = name; this .version = version; ) var myBrowser = new Browser("Microsoft Internet Explorer" , "9.0" ); alert(myBrowser.name) ; alert(myBrowser.version);

    ფუნქცია ბრაუზერი (სახელი, ვერსია)( this.name = სახელი; this.version = ვერსია; ) var myBrowser = new Browser("Microsoft Internet Explorer","9.0"); alert (myBrowser.name); alert(myBrowser.version);

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

    // კოლექციის ობიექტი var myBrowser = (სახელი: "Microsoft Internet Explorer", ვერსია: "7.0"); alert (myBrowser.name); alert(myBrowser.version); // შემდეგი სტრიქონი არასწორია! var myBrowser1 = new myBrowser("MozillaFirefox","3.5"); // ᲡᲘᲛᲐᲠᲗᲚᲔᲡ ᲐᲠ ᲨᲔᲔᲡᲐᲑᲐᲛᲔᲑᲐ! !!

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


    js ამოცანა 6_1. შექმენით Employee ობიექტი, რომელიც შეიცავს ინფორმაციას გარკვეული კომპანიის თანამშრომლების შესახებ, როგორიცაა სახელი, დეპარტამენტი, ტელეფონი, ხელფასი (გამოიყენეთ კონსტრუქტორის ფუნქცია და ეს საკვანძო სიტყვა). შექმენით ობიექტის მაგალითი

    ობიექტების თვისებებზე წვდომა Javascript-ში

    ობიექტის_სახელი. საკუთრების სახელი

    1 2 agent007.Name = "ბონდი" ; alert(agent007.Name);

    agent007.Name = "ბონდი"; alert(agent007.Name);

    რა არის ნაგულისხმევი თვისება

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

    1 2 3 4 5 6 7 8 9 10 ფუნქცია Student(სახელი, ტელეფონი) (ეს .სახელი = სახელი; ეს .ტელეფონი = "22-22-22" ; // ნაგულისხმევი თვისება! ) var ivanov = new Student("Ivan" , "33-33-33" ) ; გაფრთხილება (ivanov.name) ; // გამოსცემს "ივან" სიგნალს (ivanov.phone ) ; // გამოჩნდება "22-22-22" ivanov.phone = "33-33-33" ; //შეცვალეთ ნაგულისხმევი თვისებების გაფრთხილება (ivanov.phone); // დააბრუნებს "33-33-33"

    ფუნქცია Student(სახელი, ტელეფონი) ( this.name=name; this.phone="22-22-22"; // ნაგულისხმევი თვისება! ) var ivanov = new Student("Ivan","33-33-33" ) ; გაფრთხილება (ivanov.name); // გამოსცემს "ივან" სიგნალს (ivanov.phone); // გამოჩნდება "22-22-22" ivanov.phone="33-33-33"; //შეცვალოს ნაგულისხმევი თვისებების გაფრთხილება (ivanov.phone); // დააბრუნებს "33-33-33"

    ობიექტების კლასში თვისებების დამატება

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

    • ობიექტის კონკრეტული მაგალითი;
    • ობიექტების მთელი კლასი

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

    ობიექტის_სახელი. ქონების_სახელი = ღირებულება

    ivanov.biology = "შესანიშნავი";

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

    თვისებების დამატება კლასამდეობიექტები:

    კლასი_სახელი.პროტოტიპი. ქონების_სახელი = ღირებულება

    Student.prototype.biology = "შესანიშნავი";

    მნიშვნელოვანია: მაგალითში თვისება (ნაგულისხმევად) დაყენებულია ობიექტების კლასისთვის! ეს კეთდება პროტოტიპის გამოყენებით; პროტოტიპი - ობიექტი, რომელიც განსაზღვრავს სტრუქტურას

    1 2 Student.prototype.email = " [ელფოსტა დაცულია]" ; alert(ivanov.email ) ; // გამოჩნდება " [ელფოსტა დაცულია]"

    Student.prototype.email=" [ელფოსტა დაცულია]"; alert(ivanov.email); // გამოჩნდება " [ელფოსტა დაცულია]"

    მაგალითი: ობიექტის ყველა თვისების ჩვენების მაგალითი მნიშვნელობებით

    1 2 3 4 5 6 7 8 9 var summerTour= (თურქეთი: 2000, ესპანეთი: 3000, ეგვიპტე: 1000); var ვარიანტი; for (Option in summerTour) ( document.write (option + ":" + summerTour[ ვარიანტი] + "
    " ) ; }

    var summerTour=( თურქეთი: 2000, ესპანეთი: 3000, ეგვიპტე: 1000 ); var ვარიანტი; for (option in summerTour)( document.write(option + ":" + summerTour + "
    "); }

    Javascript პროტოტიპები (შესავალი)

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

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

    ფუნქცია Car(სახელი, მოდელი, ფერი) (/* მანქანის ობიექტის კონსტრუქტორი*/ this .name = სახელი; this .model = model; this .color = ფერი; ) var myCar= new Car; myCar.name = "Mers" ; myCar.model = "600" ; myCar.color = "მწვანე" ; Car.prototype .owner = "ივანოვი" ; /* დაამატეთ ახალი თვისება*/ alert(myCar.name + " " + myCar.model + " " + myCar.color + " " + myCar.owner ) ;

    ფუნქცია Car(სახელი, მოდელი, ფერი) ( /* მანქანის ობიექტის კონსტრუქტორი*/ this.name = სახელი; this.model = model; this.color = ფერი; ) var myCar=new Car; myCar.name="Mercedes"; myCar.model="600"; myCar.color="მწვანე"; Car.prototype.owner = "ივანოვი"; /* ახალი თვისების დამატება*/ alert(myCar.name+" "+myCar.model+" "+myCar.color+" "+myCar.owner);

    js ამოცანა 6_2. js 6_1 ამოცანისთვის Employee ობიექტის შექმნილი ინსტანციის მეშვეობით, დაამატეთ ახალი მისამართის თვისება ობიექტის კლასში.

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

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

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

    1 2 3 4 5 6 7 8 9 10 11 12 13 ფუნქცია showBrowser() (document.write("Browser:" + this .name + " " + this .version) ;) ფუნქცია Browser(სახელი, ვერსია) (ეს .სახელი = სახელი; ეს .ვერსია = ვერსია; ეს .ბრაუზერის შესახებ = showBrowser ) var myBrowser= new Browser("Microsoft Internet Explorer" , 8.0 ); myBrowser.aboutBrowser();

    ფუნქცია showBrowser() ( document.write ("ბრაუზერი: " + this.name + " " + this.version); ) ფუნქცია Browser (სახელი, ვერსია) ( this.name = სახელი; this.version = ვერსია; this.aboutBrowser = showBrowser ) var myBrowser=new Browser("Microsoft Internet Explorer",8.0); myBrowser.aboutBrowser();

  • ობიექტის მეთოდები იქმნება ფუნქციის საფუძველზე და ემატება კლასის კონსტრუქტორს

    • ფუნქცია ბრაუზერი(სახელი, ვერსია) ( this.name = სახელი; this.version = ვერსია; this.aboutBrowser = function())( document.write("ბრაუზერი: " + სახელი + " " + ვერსია); ) ) var myBrowser = ახალი ბრაუზერი ("Microsoft Internet Explorer",8.0); myBrowser.aboutBrowser();

    js ამოცანა 6_3. შექმენით ობიექტის კლასი (ტური) ტურისტული კომპანიის ფუნქციონირებისთვის მოგზაურობის ღირებულების გამოთვლის მეთოდით დაფუძნებული: ხალხის რაოდენობა * დღეების რაოდენობა * ქვეყნის ტარიფი. შექმენით turkeyTour ობიექტის მაგალითი ქონების მნიშვნელობებით. აჩვენეთ ყველა ობიექტის თვისება ეკრანზე. შექმენით საანგარიშო ობიექტის მეთოდი ფუნქციის საფუძველზე.

    ჩაშენებული ობიექტების Javascript პროტოტიპები (Prototype).

    თვისებებისა და მეთოდების დამატება ჩაშენებულ ობიექტებზე (პროტოტიპი)

    JavaScript არის პროტოტიპზე დაფუძნებული OOP (ობიექტზე ორიენტირებული პროგრამირების) ენა.
    პროტოტიპი - ობიექტი, რომელიც განსაზღვრავს სტრუქტურას

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

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 /* პროტოტიპის შეცვლა */ // ნაგულისხმევი თვისების დამატება ჩაშენებულ ობიექტზე String .prototype .color = "black" ; // ჩაშენებულ ობიექტში მეთოდის დამატება (შეცვლა) String .prototype .write = stringWrite; ფუნქცია stringWrite() ( document.write ("") ; document.write (this .toString ()) ; document.write ("") ;) // გამოიყენეთ შეცვლილი კლასი var s = new String ("ეს არის სტრიქონი " ) ; s.color = "წითელი" ; s.write();

    /* პროტოტიპის შეცვლა */ // ნაგულისხმევი თვისების დამატება ჩაშენებულ ობიექტზე String.prototype.color = "შავი"; // ჩაშენებულ ობიექტში მეთოდის დამატება (შეცვლა) String.prototype.write = stringWrite; ფუნქცია stringWrite())( document.write(""); document.write(this.toString()); document.write(""); ) // გამოიყენეთ შეცვლილი კლასი var s = new String("ეს არის სტრიქონი"); s.color = "წითელი"; s.write();

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


    js ამოცანა 6_4. დაამატეთ პროგრამის კოდი დავალების შესასრულებლად: დაამატეთ printMe() მეთოდი ჩაშენებულ String კლასში, რომელიც ბეჭდავს სიტყვას. "ჰორეი!"როგორც სათაური (h... tag), მომხმარებლის მიერ განსაზღვრული დონე ().
    სათაურის დონე (1, 2...6) შეიძლება დაემატოს String კლასის თვისებად.
    გავიხსენოთ როგორი უნდა იყოს სათაურის ტეგები HTML-ში:

    სათაური

    შეავსეთ კოდი:

    1 2 3 4 5 6 7 8 სიმებიანი .პროტოტიპი .uroven = "1" ; ... ფუნქცია printZagolovok () ( ... ... ) var s= new ...; ...

    String.prototype.uroven="1"; ... ფუნქცია printZagolovok ()( ... ... ) var s=new ...; ...

    შეჯამება: მოდით, კვლავ შევადაროთ JavaScript-ში მორგებული ობიექტების გამოყენების ორი ვარიანტი:

  • კოლექციის ობიექტების შექმნა
    • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 var myBook= ახალი ობიექტი () ; myBook.title = "book" ; myBook.price = "200" ; alert(myBook[ "title" ] ) ; // 1-й вариант обращения к свойствам alert(meBook.price ) ; // 2-й вариант обращения к свойствам function myBookShow() { for (var i in myBook) { document.write (i+ ": " + myBook[ i] + "!}
    " ) ; // გამეორება თვისებების მეშვეობით ) ) myBook.show = myBookShow; myBook.show () ;

    var myBook=new Object(); myBook.title="book"; myBook.price="200"; alert(myBook["title"]); // 1-й вариант обращения к свойствам alert(meBook.price); // 2-й вариант обращения к свойствам function myBookShow() { for (var i in myBook) { document.write(i+": "+myBook[i]+"!}
    "); // გამეორება თვისებების მეშვეობით ) ) myBook.show=myBookShow; myBook.show();

  • კონსტრუქტორის კლასების შექმნა
    • 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ფუნქცია myBook(სათაური, ფასი) (// თვისებების განსაზღვრა ამ .title = title; this .price = ფასი; // მეთოდის განსაზღვრა this .show = show; function show() (document.write ("სათაური: " + this სათაური ) ; document.write ( "Price: " + this .price ) ) var book = new myBook ("Book" , 200 ); book.show();

    ფუნქცია myBook(title,price)( // თვისებების განსაზღვრა this.title = title; this.price = ფასი; // მეთოდის განსაზღვრა this.show = show; function show() ( document.write("სათაური: " + this სათაური.write("Price:" + this.price var book = new myBook("Book", 200); book.show();> Გადადი მთავარ გვერდზე ... ...

  • Გადადი მთავარ გვერდზე
  • ...
  • ...

    • *კომპლექსი: მენიუს ელემენტების რაოდენობა, მათი სახელები და urlუნდა მოითხოვოს მომხმარებლისგან

    რჩევა: show() მეთოდით ეკრანზე სტრიქონის გამოსაჩენად გამოიყენეთ document.write() მეთოდი

    javaScript მდებარეობა, ნავიგატორი, ეკრანი JavaScript ნავიგატორის ობიექტები

    მოდით შევხედოთ Navigator ობიექტის გამოყენებას JavaScript-ში მაგალითის გამოყენებით:

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

    • ბრაუზერის სახელი
    • ბრაუზერის ენა
    • OS სახელი
    • ჩართულია ქუქიები
    • არის თუ არა მომხმარებელი ინტერნეტთან დაკავშირებული?
    • ეკრანის გარჩევადობა
    • ფერის სიღრმე
    • ჩატვირთული გვერდის მისამართი
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 var ვარიანტი; // ნავიგატორის ობიექტის ყველა თვისების ჩვენება (ვარიანტი ნავიგატორში) ( document.write (ვარიანტი + " : " + ნავიგატორი[ ვარიანტი] + "
    ");

    ბრაუზერის სახელი: "+navigator.userAgent+"
    " ); document.write ("ბრაუზერის ენა: " + navigator.language + "
    " ); document.write("OS სახელი: " + navigator.oscpu + "
    " ); document.write (" ქუქიები ჩართულია: " + navigator.cookieEnabled + "
    " ); document.write ("ინტერნეტი დაკავშირებულია: " + navigator.nLine + "
    ") ;) მომხმარებლის დეტალები() ;

    var ვარიანტი; // აჩვენე ნავიგატორის ობიექტის ყველა თვისება (option in navigator)( document.write(option + " : " + navigator+ "
    "); ) // ფუნქცია ობიექტის ნავიგატორის ფუნქციის კონკრეტული თვისებების მოსაძებნად userDetails ()( document.write("

    ბრაუზერის სახელი: "+navigator.userAgent+"
    "); document.write("ბრაუზერის ენა: " + navigator.language + "
    "); document.write("OS სახელი: " + navigator.oscpu + "
    "); document.write("ჩართულია თუ არა ქუქიები: " + navigator.cookieEnabled + "
    "); document.write("ინტერნეტი დაკავშირებულია: " + navigator.nLine + "
    "); ) მომხმარებლის დეტალები();

    JavaScript ეკრანის ობიექტი

    მოდით შევხედოთ Screen ობიექტის გამოყენებას JavaScript-ში მაგალითის გამოყენებით:

    ფუნქცია userDetails () (document.write ("გარჩევადობა: " + ეკრანი.სიგანე + " x " + ეკრანი. სიმაღლე + "
    "); document.write("ფერების სიღრმე: " + ეკრანი. ფერის სიღრმე + " x " + ეკრანი. სიმაღლე + "
    "); ) მომხმარებლის დეტალები();

    Javascript მდებარეობის ობიექტი

    მოდით შევხედოთ Location ობიექტის გამოყენებას JavaScript-ში მაგალითის გამოყენებით:

    1 2 3 4 ფუნქცია userDetails() ( document.write("ჩატვირთული გვერდის მისამართი: " + location.href + "
    ") ;) მომხმარებლის დეტალები() ;

    ფუნქცია userDetails ()( document.write("ჩატვირთული გვერდის მისამართი: " + location.href + "
    "); ) მომხმარებლის დეტალები();

    დასკვნები:

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