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

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

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

Var mylist \u003d document.getelementbyid ("MyList"), კონტეინერი \u003d document.getelementbyid ("C"); Container.appendchild (mylist);

საბოლოო DOM გამოიყურება ასე:

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

მე ასევე შემიძლია მთლიანად ამოიღო ბავშვის ელემენტი DOM- ისგან Removechild (). ასე რომ, ჩვენი სია წაშლილია წინა მაგალითიდან:

Var mylist \u003d document.getelementbyid ("MyList"), კონტეინერი \u003d document.getelementbyid ("C"); კონტეინერი (მილისტი);

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

Var myoldchild \u003d document.body.removechild (mylist); document.pody.appendchild (myoldchild);

ეს არის მეთოდი childnode.remove (), შედარებით ცოტა ხნის წინ დაემატა სპეციფიკაცია:

Var mylist \u003d document.getelementbyid ("MyList"); mylist.remove ();

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

შვილობილი კომპანიების შეცვლა

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

მაგალითი ტექსტი.

Var mypar \u003d document.getelementbyid ("par"), mydiv \u003d document.createelement ("div"); Mydiv.classname \u003d "მაგალითი"; Mydiv.createtextnode ("ახალი ელემენტის ტექსტი")); document.body.replacechild (mydiv, mypar);

როგორც ხედავთ, replacechild () მეთოდი იღებს ორ არგუმენტს: ახალი ელემენტი და ძველი ელემენტი შეცვალა.

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

მაგალითი 1.

მაგალითი ტექსტი 2.

მაგალითი ტექსტი 3.

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

Var mypelementbyid ("PAR1"), mypar3 \u003d document.getelementbyid ("PAR3"); document.body.replacechild (mypar1, mypar3);

ახლა გენერირებული DOM ასე გამოიყურება:

მაგალითი ტექსტი 2.

მაგალითი 1.

სპეციფიკური ბავშვის ელემენტების შერჩევა

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

FirsteLmildChild- ის თვისებები და LastElemildChild- ის თვისებები ზუსტად იმას ნიშნავს, რა შეიძლება იყოს მათი სახელით: აირჩიეთ პირველი და ბოლო ქალიშვილის ელემენტები. დავუბრუნდეთ ჩვენს მარკირებას:

• მაგალითი ერთი.
• მაგალითი ორი.
• მაგალითი სამი
• მაგალითი ოთხი.
• მაგალითი ხუთი.
• მაგალითი ექვსი.

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

Var mylist \u003d document.getelementbyid ("MyList"); Console.log (mylist.firstelementchild.innerhtml); // "მაგალითი ერთი" console.log (mylist.lastelementchild.innerhtml); // "მაგალითი ექვსი"

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

Var mylist \u003d document.getelementbyid ("MyList"); Console.log (mylist.firstelelementchild.NexteLementsibling.innerhtml); // "მაგალითი ორი" console.log (mylist.lastelementchild.previouslemesibling.innerhtml); // "მაგალითი ხუთი"

ასევე არსებობს პირველი თვისებები Fastchild, LAPTHILDLING, ANDERSIBLING, და NEXTSIBLING, მაგრამ ისინი ითვალისწინებენ ყველა სახის კვანძების, და არა მხოლოდ ელემენტები. როგორც წესი, თვისებები, რომლებიც ითვალისწინებენ მხოლოდ კვანძების ელემენტებს, სასარგებლოა, ვიდრე ყველა კვანძს.

შინაარსის შინაარსი

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

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

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

Var mylist \u003d document.getelementbyid ("mylist"), container \u003d document.getelementby ("C"), mypar \u003d document.getelementbyid ("PAR"); კონტეინერი (Mypar, MyList);

HTML- ის შედეგად, პუნქტი სიის წინ იქნება და ეს არის სხვა გზა.

როგორც ჩანაცვლება (), ჩასმა () იღებს ორ არგუმენტს: ელემენტი დაემატება და ელემენტს, რომლის წინაც ჩვენ გვინდა ჩასვათ იგი.

ეს მეთოდი მარტივია. შევეცადოთ ახლა უფრო ძლიერი ჩასმა მეთოდი: insertadjacenthtml () მეთოდი.

როგორც წესი, როდესაც თქვენ უნდა შეასრულოს ნებისმიერი ქმედება DOM, დეველოპერები იყენებენ jQuery. თუმცა, თითქმის ნებისმიერი DOM მანიპულირება შეიძლება გაკეთდეს Pure JavaScript გამოყენებით მისი DOM API.

განვიხილოთ ეს API უფრო დეტალურად:

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

DOM მოთხოვნები

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

Const Myelement \u003d document.queryselector ("# Foo\u003e div.bar")

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

Myelement.matches ("div.bar") \u003d\u003d\u003d ჭეშმარიტი

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

Const Myelements \u003d document.queryseletorall ("ბარი")

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

Const MychildeleMet \u003d Myelement.Queryselector ("შეყვანა") // // / document.queryselector ("# foo\u003e div.bar შეყვანის შეყვანა")

კითხვა ჩნდება: რატომ გამოიყენოთ სხვა, ნაკლებად მოსახერხებელი მეთოდები, როგორიცაა .GELEMENTSBYTAGNAME ()? არსებობს პატარა პრობლემა - გამომავალი შედეგი .Queryselector () არ არის განახლებული, და როდესაც ჩვენ დავამატებთ ახალ ელემენტს (იხ.), ეს არ შეიცვლება.

Const Elements1 \u003d document.queryseletorall ("div") Const Elements2 \u003d document.getelmentsbytagname ("div") Const NEWELEMENT \u003d document.createelement ("div" document.bodyeelement ("div") document.body.appendchild (nealelement) elements1. სიგრძე \u003d\u003d\u003d ELEMENTS2.Length / FALSE

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

როგორ ვიმუშაოთ სიები?

გარდა ამისა, ყველა u.queryseletorall () არსებობს ორი პატარა ნიუანსი. თქვენ არ შეგიძლიათ უბრალოდ მოვუწოდებთ მეთოდებს შედეგებს და ველით, რომ ისინი ვრცელდება თითოეული მათგანი (როგორც თქვენ შეიძლება გამოყენებულ იქნას ამის გაკეთება jQuery). ნებისმიერ შემთხვევაში, აუცილებელია ციკლის ყველა ელემენტის დასალაგებლად. მეორე - დაბრუნებული ობიექტი არის ელემენტების სია, არა მასივი. შესაბამისად, მასების მეთოდები არ იმუშავებს. რა თქმა უნდა, არსებობს სიების მეთოდები, როგორიც არის .თქლის (), მაგრამ სამწუხაროდ, ისინი არ არიან შესაფერისი ყველა შემთხვევაში. ასე რომ უმჯობესია კონვერტირება სიაში შევიდა მასივი:

// array.from () array.from (myelments) .foreach // ან პროტოტიპი მასივი (მდე es6) array.prototype.foreach.call (myelements, dosomethithithecheleachelement) // easier:. )

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

Myelement.children myelement.firstelmentchild myeelement.lastelementchild miseelement.previoulensibling myeelement.nextelementsibling

მას შემდეგ, რაც ელემენტის ინტერფეისი (ელემენტი) მემკვიდრეობით კვანძის ინტერფეისი (კვანძის), ასევე წარმოდგენილია შემდეგი თვისებები:

Myelement.childnodes myeelement.firstchild myeelement.lastchild myelement.previoussibling myelement.nextsibling myelement.parennode Myeelement.Parentelement

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

Myelement.firstild.nodetype \u003d\u003d\u003d 3 // ეს ელემენტი იქნება ტექსტური კვანძის

დასძინა კლასები და ატრიბუტები

ახალი კლასის დამატება ძალიან მარტივია:

Myelement.classlist.add ("foo") myeelement.classlist.remove ("ბარი") myelement.classlist.Toggle ("BAZ")

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

/ / ატრიბუტის ღირებულების ღირებულების მიღება \u003d MyElement.Value // დააყენეთ ატრიბუტი, როგორც MyElement.Value \u003d "Element (! Lang: Foo" // Для установки нескольких свойств используйте.Object.assign() Object.assign(myElement, { value: "foo", id: "bar" }) // Удаление атрибута myElement.value = null !}

თქვენ შეგიძლიათ გამოიყენოთ მეთოდები.გარეშე (), .Setattribute () i.removeattribute (). ისინი დაუყოვნებლივ შეიცვლება ელემენტის HTML ატრიბუტები (განსხვავებით DOM თვისებები), რომელიც გამოიწვევს ბრაუზერის Redrawing (თქვენ შეგიძლიათ ნახოთ ყველა ცვლილება შესწავლა ელემენტის გამოყენებით დეველოპერული ინსტრუმენტები ბრაუზერში). ასეთი perverters არა მხოლოდ საჭიროებს მეტი რესურსები, ვიდრე დაყენების Dom თვისებები, მაგრამ ასევე შეიძლება გამოიწვიოს მოულოდნელი შეცდომები.

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

დამატება CSS-Styles

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

Myelement.style.marginleft \u003d "2EM"

ზოგიერთი კონკრეტული თვისებები შეიძლება გამოყენებულ იქნას გამოყენებით .Style, მაგრამ თუ გსურთ მიიღოთ ღირებულებები გარკვეული კომპიუტერული, უმჯობესია გამოიყენოთ window.getcomputedstyle (). ეს მეთოდი იღებს პუნქტს და დააბრუნებს CSSStyLedeclation, რომელიც შეიცავს სტილს, როგორც თავად ელემენტს და თავის მშობელს:

Window.getcomputedstyle (myeelement) .სტპროპერტივერაუ ("ზღვარი მარცხნივ")

შეცვლა DOM

თქვენ შეგიძლიათ გადაადგილება ნივთები:

// დამატება Element1 როგორც ბოლო ელემენტის Element2 Element1.Appendchild (Element2) // Insert Element2 როგორც ბავშვის ელემენტის Element1 Element3 Element1.inSertbefore (Element2, Element3)

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

// clone const myelemloneclone \u003d myelement.clonenode () myparenelement.appendchild (myelementclone)

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

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

Const Mynewelement \u003d document.CreateElement ("div") Const Mynewtextnode \u003d document.createtextnode ("ზოგიერთი ტექსტი")

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

Myparenelement.removeChild (Myeelement)

თქვენ შეგიძლიათ დაუკავშირდეთ და არაპირდაპირ:

Myelement.parentnode.removeChild (Myeelement)

მეთოდები ელემენტებისათვის

თითოეულ ელემენტს აქვს თვისებები, როგორიცაა .innerhtml i.textContent, მათ შეიცავს HTML კოდი და, შესაბამისად, ტექსტი თავად. ქვემოთ მოყვანილი მაგალითია ელემენტის შინაარსი:

// შეცვლა HTML myelement.innerhtml \u003d `

სინამდვილეში, HTML- ის ცვლილება ცუდი იდეაა, რადგან ადრე მოხდა ყველა ცვლილება, ხოლო თარიღის დამლაგებლები გადატვირთულია. უმჯობესია გამოიყენოთ ეს მეთოდი მხოლოდ HTML- ის სრულიად ჩამოშორებით და სერვერის ასლის შეცვლას. Ამგვარად:

Const Link \u003d Document.CreateElement ("A") კონსტრუქცია ტექსტი \u003d document.createtextnode ("გავაგრძელოთ კითხვა ...") Const Hr \u003d document.CreateElement ("HR") Link.href \u003d "foo.html" link.appendchild ( ტექსტი) myelement.appendchild (ლინკები) myeelement.appendchild (HR)

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

Const Fragment \u003d document.createdocumentfragment (fragment.appendchild (ტექსტი) fragment.appendchild (hr) myelement.appendchild (ფრაგმენტი)

ღონისძიების ჰოლანდიელები

ერთი მარტივი handlers:

Myelement.onclick \u003d ფუნქცია onclick (event) (console.log (event.type + "გაათავისუფლეს"))

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

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

Myelement.addeventlistener ("Click", ფუნქცია (console.log))) myelement.addeventlistener ("Click", ფუნქცია (მოვლენა) (Console.Log (Event.Type + "კვლავ გაათავისუფლეს")))

Event.Target ქონების დასძენს ელემენტს, რომლისთვისაც ღონისძიება დაფიქსირდა.

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

/ ქონების `ფორმები` - მასივი, რომელიც შეიცავს ყველა ფორმას Const MyForm \u003d Document.Forms Const MyInputelments \u003d MyForm.Queryselectorlall (" შეყვანის ") array.from (myinputelments) .foreach (el \u003d\u003e (el.addeventlistener (" ცვლილება " , ფუნქცია (ღონისძიება) (console.log (event.target.value)))))

ნაგულისხმევი პრევენცია

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

Myform.addeventlistener ("წარდგენა", ფუნქცია (Const Name \u003d this.Queryselector ("# სახელი") IF (NAME.VALUE \u003d\u003d\u003d "(! LANG: DONALD DUCK") { alert("You gotta be kidding!") event.preventDefault() } }) !}

Method.Stoppropagation () დაეხმარება, თუ თქვენ გაქვთ კონკრეტული ღონისძიება Handler, ფიქსირებული ბავშვის ელემენტის, და მეორე დამმუშავებლის იგივე მოვლენაა მშობლისთვის.

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

• capture: ღონისძიება თან ერთვის ამ ელემენტს, სანამ სხვა პუნქტში ქვემოთ DOM;
• ერთხელ: ღონისძიება შეიძლება მხოლოდ ფიქსირებული იყოს;
• პასიური: event.preventdefault () იგნორირებულია (გამონაკლისი შეცდომის დროს).

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

Myelement.addeventlistener (ტიპი, მსმენელი, ჭეშმარიტი)

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

Myelement.addeventlistener ("ცვლილება", ფუნქციის მსმენელი (მოვლენა) (Console.log (event.Type + "მივიღე" + ეს) ეს) ეს) ეს) ამ)

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

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

Myform.addeventlistener ("ცვლილება", ფუნქცია (ღონისძიება) (Const Target \u003d event.target თუ (Target.Matches ("შეყვანის")) (Console.log (Target.Value)))

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

გაცოცხლება

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

დარეკეთ ფანჯარაში. SettimeOut () მეთოდი სანამ ანიმაცია დასრულდა, არ არის საუკეთესო იდეა, რადგან თქვენი განაცხადის შეიძლება გათიშეთ, განსაკუთრებით მობილური მოწყობილობებისთვის. უმჯობესია გამოიყენოთ window.requestanimationFrame () გადარჩენა ყველა ცვლილება მომდევნო redrawing. იგი იღებს ფუნქციას, როგორც არგუმენტი, რომელიც, თავის მხრივ, იღებს დრო შტამს:

Const Start \u003d window.performance.Now () Const Duration \u003d 2000 window.requestanimationFrame (Const Progress \u003d ახლა - დაწყება myelement.style.opacity \u003d პროგრესი / ხანგრძლივობა თუ (პროგრესი< duration) { window.requestAnimationFrame(fadeIn) } }

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

ჩვენ წერენ თქვენს ბიბლიოთეკას

ის ფაქტი, რომ DOM- ში, რათა შეასრულოს ნებისმიერი ოპერაცია ელემენტებით, ყველა დროის უნდა იყოს დახარისხებული, ეს შეიძლება ჩანდეს ძალიან tedious შედარებით jQuery $ Syntax ("Foo"). CSS ((ფერი: "წითელი")) . მაგრამ რატომ არ წერენ რამდენიმე თქვენი მეთოდები, ამ ამოცანის ხელშეწყობა?

Const $ \u003d ფუნქცია $ (Const Elements \u003d Array.From (Select.QuerySelectorltlall (Selector) დაბრუნება (ელემენტები, HTML (Element \u003d\u003e Element.innerhtml \u003d NEWHTML)) დაბრუნება ეს), CSS (Element \u003d\u003e Object.Astign (Element.Style, Newcss))) დაბრუნება ეს), შესახებ (ღონისძიება, დამლაგებელი, პარამეტრები) (ეს.

წინასწარ.