DOUG LLOYD: ამ ვიდეო, გვინდოდა მოვუწოდებთ ცალკე ყურადღებას
ძალიან კონკრეტული ელემენტის JavaScript
რომ თქვენ შეიძლება მოსახერხებელი როდესაც თქვენ დაწყებული
მუშაობა მანიპულირების ვებ გვერდები და შეცვლის შინაარსი თქვენი ვებ გვერდი
on the fly.
და ეს ცნება დოკუმენტის ობიექტური მოდელის.
ასე რომ, როგორც ჩვენ ვნახეთ ჩვენი ვიდეო JavaScript, ობიექტების ძალიან მოქნილი.
>> და ისინი შეიძლება შეიცავდეს სხვადასხვა სფეროში.
მიუხედავად იმისა, რომ ჩვენ არ წასვლას ბევრი დეტალურად, იმ სფეროებში და თვისებები,
რომ ჩვენ, ალბათ, უფრო სათანადოდ მოვუწოდებთ მათ
კონტექსტში ობიექტი, მაშინაც კი, იმ თვისებებს შეიძლება იყოს სხვა ობიექტები.
და შიგნით იმ ობიექტების შეიძლება სხვა ობიექტები.
>> თქვენ ეს ძალიან დიდი ობიექტი ბევრი სხვა ობიექტები
შიგნით, რომელიც ერთგვარი ქმნის ეს იდეა დიდი ხე.
ახლა, დოკუმენტი ობიექტი არის განსაკუთრებული ობიექტი JavaScript
რომელიც ორგანიზებას თქვენი ვებ გვერდი მზადების ამ სახის ქოლგა
ობიექტი.
ასე რომ, შიგნით დოკუმენტი ობიექტის ობიექტები წარდგენის
ხელმძღვანელი და სხეულის თქვენს ვებ გვერდზე.
>> Inside იმ სხვა ობიექტების და ა.შ., და ა.შ.,
სანამ თქვენი ვებ გვერდი აქვს ორგანიზებული იყო ამ დიდი ობიექტი.
რა არის თავდაყირა აქ, არა?
კარგად ვიცით, თუ როგორ უნდა იმუშაოს ობიექტების JavaScript.
>> ასე რომ, თუ ჩვენ გვაქვს ობიექტი, რომელიც ეხება მთელი ჩვენი ვებ-გვერდი, რომელიც
ნიშნავს დარეკვით სწორი მეთოდები მანიპულირება, რომ ობიექტი
ან შეცვლის გარკვეული მისი თვისებები, ჩვენ
შეგიძლიათ შეცვალოთ ელემენტები ჩვენი გვერდი პროგრამულად
გამოყენებით JavaScript ნაცვლად, რომელმაც კოდექსის რამ, ვთქვათ, HTML.
ასე რომ, აქ მაგალითია ძალიან მარტივი ვებ გვერდი, არა?
ეს მივიღე HTML tags, ხელმძღვანელი.
>> შიგნით არის სახელწოდება, Hello World.
მაშინ მე ორგანო.
შიგნით რომ, მე მაქვს სამი სხვადასხვა რამ.
მაქვს h2 header tag, პუნქტის, და ბმული.
ეს არის ძალიან მარტივი ვებ-გვერდზე.
>> ისე, რა შეიძლება დოკუმენტი წინააღმდეგი ამ ჰგავს?
ისე, ეს პატარა საშინელი იქნებ პირველი.
მაგრამ ეს ნამდვილად დიდი ხე.
და ძალიან root ეს არის დოკუმენტი.
>> Inside დოკუმენტის სხვა ობიექტის გულისხმობდა HTML ჩემს გვერდზე.
და HTML ჩემი გვერდი არის ყველა ამ.
და შემდეგ შიგნით HTML ობიექტი, მაქვს ხელმძღვანელი ობიექტი,
რომელიც ეხება ყველაფერი.
>> და შიგნით არსებობს, მაქვს სათაური ობიექტი.
და შიგნით არსებობს, მაქვს კიდევ ერთი წინააღმდეგი, რომ უბრალოდ მიესალმები მსოფლიოში.
მე შეიძლება ჩემი სხეული წარმოდგენილია მოსწონს ეს.
>> ჩემს სხეულში, მაქვს h2 ობიექტი და p ობიექტი პუნქტის
და ობიექტი ბმულს.
ასე რომ, ეს მთელი იერარქია შეიძლება წარმოდგენილი იყოს როგორც დიდი ხე
უამრავი პატარა პატარა რამ გამოდის იგი.
ახლა, რა თქმა უნდა, როდესაც ჩვენ პროგრამირება, ჩვენ
არ ვფიქრობ, რამ, როგორიცაა დიდი ხე.
ჩვენ გვინდა, რომ ფაქტობრივი კოდი დაკავშირებული რამ.
>> და საბედნიეროდ, ჩვენ შეგვიძლია გამოიყენოთ ჩვენი დეველოპერი ინსტრუმენტები
რეალურად შევხედოთ ამ ვებ დოკუმენტი ობიექტი.
და მოდით გავაკეთოთ, რომ.
ასე რომ, მე გახსნეს ბრაუზერის tab.
>> და მე გახსნეს შემქმნელი ინსტრუმენტები.
და ჩემი ვიდეო JavaScript, მე აღინიშნა, რომ კონსოლი არ არის
მხოლოდ რაღაც ადგილას, სადაც ჩვენ ბეჭდვა ინფორმაციით,
ეს ასევე არის ადგილი, სადაც ჩვენ შეყვანის ინფორმაცია.
ამ კონტექსტში, რა მე ვაპირებ ვთქვა,
მინდა დავუბრუნდეთ დოკუმენტის ობიექტების,
ასე, რომ შეიძლება დაიწყოს აქვს შევხედოთ მას.
ასე როგორ შეიძლება ამის გაკეთება?
ისე, თუ მინდა ორგანიზება ნამდვილად ლამაზად,
მე ვაპირებ ვთქვა console.dir, D-I-R. ახლა, მე console.log უბრალოდ ბეჭდვითი
რაღაც ძალიან მარტივია.
მაგრამ თუ მე მინდა, რომ ამ ღონისძიების იერარქიულად, როგორც ობიექტი,
მინდა, რომ ეს ერთგვარი სტრუქტურა ისევე როგორც სტრუქტურის.
>> ამიტომ, მე მინდა console.dir დოკუმენტი.
მე ვაპირებ დააჭიროთ.
და ამის ქვემოთ, ახლა, და მე მიუახლოვდით აქ,
მაქვს ამ საპასუხო დოკუმენტი პატარა ისარს იგი.
ახლა, როდესაც მე გახსნა arrow, იქ იქნება ბევრი პერსონალი.
>> მაგრამ ჩვენ ვაპირებთ იგნორირება ბევრი ეს და მხოლოდ სახის აქცენტი
წლის ყველაზე მნიშვნელოვანი ნაწილი, ამიტომ ჩვენ შეიძლება დაიწყოს ნავიგაცია ამ დოკუმენტს.
არსებობს კიდევ ბევრი DOM ვიდრე უბრალოდ მშობელი კვანძების და ბავშვის კვანძების.
არსებობს უამრავი დამხმარე პერსონალი.
>> ამიტომ, მე ვაპირებ გახსნა ამ მდე.
და იქ მთელი ბევრი პერსონალი, რომ pops up.
მაგრამ ყველა მე აინტერესებს არის სწორედ აქ, ბავშვის კვანძების.
მოდით გახსნა რომ.
>> შიგნით არსებობს ვხედავ რაღაც ნაცნობი, HTML.
ასე რომ შიგნით ჩვენი დოკუმენტი ერთ დონეზე ქვემოთ, HTML.
გავხსნა რომ.
რა არის ჩვენ ველოდებით?
>> თუ გავიხსენებთ ჩვენი სქემა, რა უნდა იპოვოს შიგნით HTML?
რა ორი კვანძების ქვემოთ ხე?
მოდით გავარკვიოთ.
ჩვენ გახსენით HTML.
ჩვენ დაცემას მისი შვილი კვანძების.
>> Pop, რომ ღია.
არსებობს ხელმძღვანელი და სხეულის.
ჩვენ შეიძლება გაიხსნას ხელმძღვანელი.
ტურიზმი მისი ბავშვის კვანძების.
ისე, არსებობს ტიტული.
>> და ჩვენ ვერ გაგრძელდება და მოსწონს ეს სამუდამოდ.
ჩვენ შეგვეძლო ამის გაკეთება ორგანოს ისევე.
მაგრამ არის საშუალება, რომ შევხედოთ დოკუმენტის ორგანიზებული როგორც დიდი ობიექტი.
და თუ ჩვენ გადავხედავთ დიდი ობიექტი, რომელიც გამოიყურება ბევრი
როგორიცაა კოდი, რაც იმას ნიშნავს, რომ ჩვენ შეგვიძლია დავიწყოთ მანიპულირება ამ დიდი ობიექტი
კოდს შეცვლის, რა არის ჩვენი ნახვა გამოიყურება და იგრძნობა.
>> ასე რომ, საკმაოდ ძლიერი ინსტრუმენტი ჩვენ ჩვენს ხელთ არის.
ასე რომ, როგორც ჩვენ ვნახეთ, რომ დოკუმენტის ობიექტი თავად
და ყველა ობიექტების შიგნით აქვს თვისებები და მეთოდები, უბრალოდ
ისევე როგორც ნებისმიერი სხვა ობიექტი, რომელიც ჩვენ მუშაობს JavaScript.
მაგრამ ჩვენ შეგვიძლია გამოვიყენოთ იმ თვისებებს და იყენებენ იმ მეთოდებს, რათა ერთგვარი საბურღი ქვემოთ
დიდი დოკუმენტი და მიიღეთ ქვედა და ქვედა და ქვედა,
finer და finer მარცვალი დეტალურად, სანამ ჩვენ
მისაღებად ძალიან კონკრეტული ნაწილი ჩვენი ვებ გვერდზე, რომ ჩვენ გვინდა, რომ შეიცვალოს.
>> ხოლო როდესაც ჩვენ განახლება თვისებები დოკუმენტის ობიექტი და მოვუწოდებთ მათ, მეთოდები,
რამ შეიძლება მოხდეს ჩვენს ვებ-გვერდზე.
და ჩვენ არ გვჭირდება რაიმე გამაგრილებელი აქვს იმ ცვლილებები ძალაში.
>> და ეს საკმაოდ მაგარი უნარი აქვს, როდესაც ჩვენ ვმუშაობთ კოდი.
რა არის ზოგიერთი თვისებები რომლებიც ნაწილი დოკუმენტი ობიექტი?
ისე, ალბათ, დაინახა რამდენიმე მათგანი მართლაც სწრაფად
როგორც ჩვენ zipping მეშვეობით გიგანტური დოკუმენტი
ობიექტის ჩვენ ვნახეთ ბრაუზერში.
>> მაგრამ რამდენიმე ამ თვისებები შეიძლება იყოს რამ, როგორიცაა შიდა HTML.
და თქვენ შეიძლება გავიხსენოთ me გამოყენებით ამ JavaScript, ვიდეო
ძალიან ბოლოს, როდესაც მე ლაპარაკი იყო მოვლენები.
რა იყო ეს შიდა HTML?
ისე, ეს მხოლოდ ის, რაც არის შორის tags.
>> ასე რომ, შიდა HTML, მაგალითად, სათაური
tag, თუ ჩვენ ინახება აპირებს რომ მაგალითად მომენტში წინ,
იქნებოდა მიესალმები მსოფლიოში.
ეს იყო სათაურით ჩვენი გვერდი.
სხვა თვისებები მოიცავს კვანძის სახელი, რომელიც
არის სახელწოდება HTML ელემენტს, როგორიცაა ტიტული.
ID, რომელიც ID ატრიბუტი HTML- ის ელემენტი.
>> შეგახსენებთ, რომ ჩვენ შეგვიძლია სპეციალურად მიუთითებს კონკრეტული ელემენტები ჩვენი HTML
პირადობის ატრიბუტი, რაც, როგორც წესი, მოდის მოსახერხებელი კონტექსტში CSS,
კონკრეტულად.
მშობელი კვანძი, რომელიც არის მინიშნება რა არის უბრალოდ ზემოთ ჩემთვის DOM.
და ბავშვის კვანძების, რომელიც არის მინიშნება რა არის ქვემოთ ჩემთვის.
და ჩვენ ვნახეთ ბევრი, რომ უბრალოდ გადახედეთ.
ბავშვის კვანძების, რომ, თუ როგორ მივიღეთ ქვედა და ქვედა შევიდა ხე.
>> ატრიბუტები, რომ უბრალოდ მასივი ატრიბუტები HTML ელემენტს.
ასე მაგალითად ატრიბუტები შეიძლება იქნება თუ თქვენ გაქვთ იმიჯი აქვს,
ეს ჩვეულებრივ აქვს წყარო ატრიბუტი, იქნებ სიმაღლე და სიგანე ატრიბუტი.
და ასე რომ მხოლოდ მასივი ყველა ატრიბუტები უკავშირდება
რომ ელემენტი.
>> სტილი არის კიდევ ერთი, რომ ამჯამად წარმოადგენს CSS
სტილის კონკრეტული ელემენტს.
მოგვიანებით ამ ვიდეო, ჩვენ კონკრეტულად
ბერკეტი სტილი, რომ რამდენიმე ცვლილებები ჩვენი ნახვა.
ასე რომ, ეს არის გარკვეული თვისებები.
>> და არსებობს ასევე ზოგიერთი მეთოდები, რომ ჩვენ შეგვიძლია
გამოიყენოთ უფრო სწრაფად იქნებ იზოლირება ელემენტები დოკუმენტი ობიექტი.
ალბათ, ყველაზე მრავალმხრივი ამ ყოფნის getElementById.
ასე რომ, შეიძლება ითქვას, რაღაც, რადგან გვახსოვდეს, რომ ეს მეთოდი დოკუმენტი
ობიექტი, document.getElementById.
>> და შიგნით იმ ფრჩხილებში, განსაზღვროს HTML- ის ელემენტი კონკრეტული ID
მიეწერა, რომ მე ადრე მითითებული, და მე მაშინვე
წავიდეთ უფლება, რომ ელემენტს საერთო ვებგვერდზე.
ასე რომ, მე არ მაქვს, იქნებ საბურღი ქვემოთ მეშვეობით თითოეული ფენა.
მე შემიძლია მხოლოდ ამ მეთოდის გამოყენება მიაგნეს, ერთგვარი მოსწონს სითბოს ეძებს რაკეტა,
არა?
ეს მხოლოდ მიდის და აღმოაჩენს ზუსტად ის, რაც ეძებს.
>> GetElementsByTagName არის ძალიან მსგავსი სულისკვეთება.
შესაძლოა, ეს იქნება ყველა იმ თამამი tags ან ყველა p tags
და მომეცი მასივი ყველაფერი რომ მე ვერ მუშაობენ.
appendChild დასძენს რაღაც ერთ დონეზე ქვემოთ ხე.
>> ასე რომ, მე შეგიძლიათ მთელი ახალი ელემენტის ერთ დონეზე დაბალია.
ან შემიძლია ამოიღონ ელემენტს, რომ ერთ დონეზე დაბალია, ასევე, თუ მინდა,
წაშლა რაღაც ჩემი ვებ-გვერდზე.
ახლა, სწრაფი კოდირების შენიშვნა და სწრაფი თავის ტკივილი გადარჩენის შენიშვნა, იმედია.
>> getElementById-- დ არის ამას.
მე ვერ გეტყვით რამდენჯერ მაქვს მეორადი getElementById და მთავრული
დ არსებობს.
იმის გამო, რომ ეს მართლაც გავრცელებული.
თუ ჩვენ წერენ სიტყვა ID, რომ ეს როგორც წესი, კაპიტალის კაპიტალი დ
ჩემი კოდი უბრალოდ არ მუშაობს.
და მე ვერ გაერკვნენ, თუ რატომ.
ეს არის ნამდვილად, ნამდვილად, ნამდვილად საერთო bug რომ ყველას აკეთებს,
მაშინაც კი, ექსპერტები, რომლებსაც აქვთ ამით სამუდამოდ.
ასე რომ, უბრალოდ უნდა იცოდეს, getElementById, რომ დ არის ამას.
და იმედია, რომ ზოგავს რამდენიმე წუთის მინიმუმ გულისტკივილს.
>> ასე რომ, რა ყველა ამ გვითხრათ?
ჩვენ გვყავს ამ მეთოდების გამოყენებით.
ჩვენ გვაქვს ეს თვისებები.
ახლა კი, თუ ჩვენ დავიწყებთ დოკუმენტი, დოკუმენტი.
რაც არ უნდა, ჩვენ შეგვიძლია ახლა მიიღოს ნებისმიერი ერთი ნაჭერი ჩვენს ვებ გვერდზე
ჩვენ გვინდა, რომ გამოყენებით JavaScript მხოლოდ მოუწოდებდა ამ მეთოდების
და ოპერაციული თვისებები რომ ჩვენ სხვადასხვა ადგილებში.
>> ეს შეიძლება მიიღოს სიტყვიერი, ეს document.getElementByID,
იქნებ აქვს ხანგრძლივი tag სახელი, იქნებ თქვენ უფრო ზარები მოგვიანებით.
რამ შეიძლება კიდევ ცოტა wordy.
და როგორც პროგრამისტები, თქვენ ალბათ მინახავს ბევრი ამ ვიდეო,
ჩვენ არ მოგვწონს სიტყვიერი რამ.
>> ჩვენ გვსურს, რომ იყოს ვერ გააკეთებს რამ სწრაფად.
ასე რომ, ჩვენ მინდა უფრო მოკლე გზა ვთქვა რაღაც.
ასე რომ, ეს ერთგვარი მივყავართ ცნება რაღაც მოუწოდა jQuery.
ახლა jQuery არ არის JavaScript.
ეს არ არის ნაწილი JavaScript.
>> ეს არის ბიბლიოთეკა, რომელიც დაიწერა ზოგიერთი JavaScript პროგრამისტების
დაახლოებით 10 წლის წინ.
და მისი მიზანია გაამარტივოს ეს რა არის მოუწოდა კლიენტის მხარეს სკრიფტინგის, რომელიც
ძირითადად რა ჩვენ მხოლოდ ვსაუბრობთ DOM მანიპულაცია.
ასე რომ, თუ მინდოდა ცვლილებები ფონის ფერი ჩემი ვებ გვერდი, შესაძლოა,
კონკრეტული განყოფ.
>> აქ, მე როგორც ჩანს მიღების ElementById colorDiv.
და მე მინდა, რომ მითითებული მისი ფონის ფერი.
თუ მე უბრალოდ გამოყენებით სუფთა JavaScript გამოყენებით დოკუმენტის ობიექტური მოდელის,
რომ არის ბევრი რამ, არა? document.getElementByID
colorDiv.style.backgroundColor = მწვანე.
>> ავე.
ეს იყო ბევრი ვთქვა.
ეს არის ბევრი ტიპის, ძალიან.
ასე რომ, jQuery, ჩვენ შეგვიძლია, შესაძლოა ითქვას, ეს ცოტა უფრო მოკლედ.
სავაჭრო off, რომ ეს შესაძლოა, ცოტა ცოტა მეტი cryptic უეცრად,
არა?
>> ყოველ შემთხვევაში, ხანგრძლივი ცოტა მეტი განმარტებითი როგორც, რასაც ჩვენ ვაკეთებთ.
ეს დოლარის ნიშანი, ფრჩხილებში, ერთი გაცემა, hash, colorDiv, არა?
რას ნიშნავს ეს?
ისე, რომ, ძირითადად, მხოლოდ document.getElementByID colorDiv.
>> მაგრამ ეს ამ სახის სტენოგრამის გზა ამის გაკეთება გამოყენებით jQuery.
მოდით, უბრალოდ შევხედოთ ახლა დროს რამდენიმე სხვადასხვა გზა
რომ მე შეიძლება რეალურად გამოიყენოს ეს დოკუმენტი ობიექტი
მოდელი მანიპულირება ცალი ჩემი საიტი.
კერძოდ, ჩვენ ვაპირებთ უნდა მუშაობა მანიპულირების
ფერი კონკრეტული Div, colorDiv, ვებ გვერდზე.
მოდით შევხედოთ, რომ.
ყველა უფლება.
ასე რომ, მე გვერდზე.
ეს ე.წ. test.html როდესაც თქვენ ჩამოტვირთვა თუ გსურთ Tinker ერთად ეს.
და მაქვს რამოდენიმე ღილაკები ამ გვერდზე.
და მე ვამბობ, ინდივიდუალური ფუნქციებით ფონის ფერი, იისფერი, მწვანე,
ნარინჯისფერი, წითელი, ლურჯი, ერთი ფუნქცია ფონის ფერი, ღონისძიება დამმუშავებლის
ფონის ფერი, და გამოყენებით jQuery.
რა ვარ მე ლაპარაკი როდესაც მე ამით?
ასე რომ, ჩვენ ვნახეთ ღილაკები.
ახლა, მოდით შევხედოთ ზოგიერთი კოდის აქ.
ჩვენ დავიწყებთ test.html.
ასე რომ, ინდივიდუალური ფუნქციებით ფონზე ფერი არის ის, რაც მე აკრეფილი აქ.
ნება მომეცით გადახვევა ცოტა.
>> თქვენ შეამჩნევთ, რომ მე არ არის განსაზღვრული ამ ღილაკებიდან
რომ ვთქვათ, როდესაც ამ ღილაკზე დააწკაპუნებთ, მოვუწოდებთ ფუნქცია ჩართოთ purple.
როდესაც ამ ღილაკზე დაჭერით, უფრო სწორად, მოვუწოდებთ ფუნქცია ჩართოთ მწვანე,
იქცეს ფორთოხალი, გახდეს წითელი, აქციოს ლურჯი.
ალბათ, ხვდებით, რომ ეს ალბათ არ არის საუკეთესო დიზაინის
გრძნობა, არა?
>> კარგი იქნება, თუ შეიძლება აქვს უფრო ზოგადი მიდგომა.
ისე, პირველ რიგში, ჩვენ შევხედოთ რა იმ ხუთ ფუნქციები
document.getElementByID colorDiv.style.background = purple,
მწვანე, ნარინჯისფერი, წითელი, და ლურჯი, შესაბამისად.
ასე რომ, არ არის განსაკუთრებით საუკეთესო დიზაინის.
>> შემდეგი კომპლექტი ღილაკები მე არ არის მე დაწერილი
ერთი ფუნქცია მოუწოდა შეიცვალოს ფერი, რომელიც, როგორც ჩანს,
ადასტურებს სიმებიანი როგორც მისი არგუმენტი.
ასე რომ, ეს ცოტა უკეთესი.
Purple, მწვანე, ნარინჯისფერი, წითელი, ლურჯი არის არგუმენტი.
ამიტომ მე დაწერილი უფრო ზოგადი შემთხვევაში JavaScript ფუნქცია,
რომელიც შეიძლება ასე გამოიყურება.
მე გადადის.
ეს ფუნქცია ცვლილება ფერი ველოდებით არგუმენტი ეწოდება ფერი.
და მე ვამბობ მითითებული ფონის ფერი ფერი.
ასე რომ, აქ წარმოადგენს რა მაქვს აქ.
ასე რომ, ცოტა უკეთესი.
>> მაგრამ მე შეიძლება შეძლებს უკეთესად რომ.
თუ ვეშვებით შევხედოთ ღონისძიებაზე დამმუშავებლის სიტუაცია,
ახლა ყველა ეს ზარები გამოიყურება იგივე.
თუ გავიხსენებთ ჩვენი დისკუსია გამომტანების,
მე შეუძლია მიიღოს ინფორმაცია, რომელიც ამ ღილაკებიდან დააწკაპებთ და გამოვიყენოთ რომ.
>> ასე რომ, event.JavaScript, მე წერილობითი ცვლილება ფერი ღონისძიება, რომელიც
გათვლით, რომელიც ღილაკს იყო დაწკაპავთ.
სწორედ გამოიწვევს ობიექტი ონლაინ.
და მერე აქ, მართლა wordy.
მაგრამ, რასაც მე ვაკეთებ არის მე შექმნის ფონზე
ფერი triggerObject inner.HTML.
ეს არის ტექსტი შორის ღილაკს tags.
>> და მერე აშკარად აქვს შექმნას იგი ამას.
და ეს როგორ შემიძლია გარდაქმნას მთელი სიმებიანი ამას in JavaScript გამოყენება
ეს მეთოდი ამას.
იმის გამო, რომ, როდესაც მე მითითებული ფერი, როგორც მე ვცდილობ აქ,
ფერი უნდა იყოს ყველა ამას.
>> მაგრამ ღილაკს, რომელიც მე მქონდა, თუ ავიღებთ სხვა სახე,
შეამჩნია, რომ ტექსტში არ არის დაწერილია დედაქალაქი P მეწამული.
და მაშინ ძალიან ბოლოში აქ, მე, როგორც ჩანს,
ცდილობენ და ამის გაკეთება გამოყენებით jQuery ასევე.
და ამ შემთხვევაში, მე არ ვარ რეალურად მოუწოდებდა ფუნქცია ყველა.
მე უბრალოდ განაცხადა კლასი, რომ მე ვარ გამოყენებით ამ ღილაკს არის JQ ღილაკს.
ეს არის ის.
>> ასე რომ, როგორ jQuery ვიცი, რასაც მე ვაკეთებ?
ისე, ეს არის ერთ-ერთი უპირატესობა სლეში ნაკლოვანებები jQuery.
მას შეუძლია ნება მიბოძეთ გავაკეთოთ რამ ძალიან მოკლედ, მაგრამ იქნებ არ
როგორც ინტუიციურად.
იქნებ ეს სხვა სამი, რათა უფრო მეტი გრძნობა, რასაც მე ვაკეთებ.
აქ, თუმცა, რა ხდება?
>> როგორც ჩანს, შექმნა ანონიმური ფუნქცია
რომ ტვირთის როდესაც ჩემი დოკუმენტი მზად არის, ასე document.ready,
ზოგიერთი ფუნქცია მოხდება.
ძირითადად, როდის არის დოკუმენტი მზად არის?
ეს მაშინ, როდესაც ჩემი გვერდი დატვირთული.
>> ასე რომ, როგორც კი ჩემი გვერდი დატვირთული, შემდეგი ფუნქცია ყოველთვის მზად არის.
იგი აცხადებს, რომ იმ შემთხვევაში, თუ ობიექტი ტიპის jQButton, ან თუ კლასის jQButton უკვე დააწკაპებთ,
შეასრულოს ეს ფუნქცია.
ასე რომ, აქ არის ორი ანონიმური ფუნქციები, ერთ განისაზღვრა შიგნით სხვა.
>> ასე რომ, ჩემი მთელი კონტექსტში აქ ჯერჯერობით ჩემი გვერდი
როდესაც ეს ტვირთავს ის მოუწოდებს ამ ფუნქციას.
და ამ ფუნქციას ელოდება ამისთვის ღილაკს უნდა დააწკაპებთ.
და როდესაც ღილაკი დაწკაპავთ, JQ ღილაკს კონკრეტულად დააწკაპებთ,
ის მოუწოდებს ამ სხვა ფუნქცია, რომელიც აპირებს
მითითებული ფონზე ფერი colorDiv იყოს
რასაც ტექსტი შორის tags.
>> ეს არის ცნება რომელიც ღილაკს იყო დაწკაპავთ.
მაგრამ სხვაგვარად, ეს არის ერთგვარი იქცევა მსგავსი ღონისძიება.
ეს მხოლოდ ანალოგიურად მე რომ გამოხატოს ეს jQuery.
ისევ და ისევ, ეს, ალბათ, ბევრი უფრო დაშინებას.
ეს არ არის, როგორც ნათელი, როგორც რაღაც event.js,
რომელიც შესაძლოა ცოტა მეტი verbose, მაგრამ ცოტა ნაკლები
დაშინებას.
>> მაგრამ თუ ჩვენ პოპ უკან ჩემს ბრაუზერში ფანჯარა, თუ დავიწყებ clicking-- კარგად,
რომ შეიცვალა ვარდისფერი.
ეს არის მწვანე გამოყენებით string მეთოდს.
ეს არის ფორთოხალი გამოყენებით ღონისძიება დამმუშავებლის.
>> ეს არის წითელი გამოყენებით jQuery, არა?
ისინი ყველა იქცევიან ზუსტად.
ისინი უბრალოდ ამის გამოყენებით სხვადასხვა უახლოვდება პრობლემის მოგვარება.
არსებობს კიდევ ბევრი jQuery მაშინ ჩვენ, რა თქმა უნდა
ვაპირებ ვისაუბრო ამ ვიდეო.
მაგრამ თუ გვინდა, რომ უფრო მეტი, თქვენ შეგიძლიათ წასვლა jQuery სახის დოკუმენტაცია
და ვისწავლოთ საკმაოდ ცოტა მეტი ეს ძალიან მოქნილი ბიბლიოთეკა, რომელიც
დიდი აკეთებს კლიენტის მხარეს სკრიპტირების, როგორიცაა რას ვაკეთებდით
მანიპულირება სახე და ვგრძნობთ ჩვენს ვებ გვერდზე
ერთად დოკუმენტის ობიექტური მოდელი.
მე Doug Lloyd.
ეს არის CS50.