Jquery- ում տվյալների մեթոդը մեզ հնարավորություն է տալիս կամայական տվյալներ կապել ցանկացած փաստաթղթի կամ JavaScript օբյեկտի հետ, ինչը թույլ է տալիս կատարել ձեր ծածկագիրը ավելի կարճ եւ ընթեռնելի: JQuery 1.4.3- ի վարկածից սկսած հնարավոր դարձավ օգտագործել այս մեթոդը javaScript օբյեկտներ, ինչպես նաեւ հետեւում են այս տվյալների փոփոխություններին:
Հիմունքներ
Սկսենք այն փաստը, որ դուք կարող եք անվանել տվյալների եղանակը jQuery- ի համար, ինչպես նաեւ ուղղակիորեն օգտագործել $ .data () գործառույթը:
// մեթոդի օգտագործումը. $ ("# Mydiv"): Տվյալներ («Հիմնական», «պատահական նշանակում»); // գործառույթ ուղղակիորեն օգտագործելով. $ .Data ($ ("# Mydiv"): Ստացեք (0), «ստեղն», «կամայական իմաստ»).
Տվյալների գործառույթը ցածր մակարդակի իրականացում է, որն իրականում օգտագործվում է մեթոդը զանգահարելիս: JQuery Object մեթոդը շատ ավելի հարմար է, այն նաեւ թույլ է տալիս ինքներդ ձեզ ներառել որպես զանգերի շղթա:
Նաեւ նշեք, որ դուք պետք է DOM տարրը փոխանցեք որպես $ .data գործառույթի առաջին պարամետրը, եւ ոչ թե JQuery օբյեկտը:
Օբեկտի մեթոդը պահանջում է երկու պարամետր `բանալին եւ արժեքը: Հիմնականը լարային հաստատունն է, եւ արժեքը տվյալների ցանկացած կառույց է, ներառյալ զանգվածների եւ օբյեկտների գործառույթները: Կա այլընտրանքային շարահյուս, որում օբյեկտը կարող է փոխանցվել որպես մեկ պարամետր:
// Դուք կարող եք տեղափոխել օբյեկտը, $ ("# Mydiv"): Տվյալներ ((«Անուն». «Սթիվի», «Տարիքը»)); // նույնը, $ («# Mydiv»): Տվյալներ («անուն», «Սթիվի»): Տվյալներ («Տարիքը», 21);
Այժմ, եթե անհրաժեշտ է պահպանել տվյալները, կարող եք զանգահարել տվյալների գործառույթը `այն փոխանցելով որպես պարամետր:
Var thevalue \u003d $ ("# Mydiv"): Տվյալներ («Տարիքը»); // 21.
Այս տվյալների հասանելիությունը բաց է սցենարի մեջ գտնվող ցանկացած վայրում: Դուք կստանաք պահպանված տվյալներ, քանի դեռ կա տվյալ ընտրողի համաձայն ձեռք բերված տարր:
Var thevalue \u003d $ ("Div: First"): Տվյալներ («Անուն»); // stevie $ ("Div: First"): Կտտացրեք (գործառույթ () (ազդանշան (սա) .data («Տարիքը»));
JQuery 1.4.3- ն ունի նաեւ HTML5 տվյալներ, որոնք պահվում են ատրիբուտներում: Սա նշանակում է, որ եթե ունեք որեւէ տարր, հայտարարվել է հետեւյալ կերպ.
Այս դեպքում դուք կարող եք տվյալներ ստանալ տվյալների-ներքին-ID- ի հատկանիշից `զանգահարելով $ (« # IMG1 »մեթոդ: Տվյալներ (« Ներքին ID »), որն, անկասկած, հարմար է« Այաքսի »հարցումների համար:
JavaScript օբյեկտների տվյալների եղանակը օգտագործելով
Կարող եք զարմացած լինել, բայց տվյալների եղանակը կարող է օգտագործվել նաեւ սովորական JavaScript օբյեկտների համար: Այս ֆունկցիոնալությունը պաշտոնապես հայտնվեց JQuery 1.4.3-ում:
Var myobj \u003d (); $ (Myobj) .Դատա («քաղաք», «Springfield»);
Տրված օրինակը իրականում ստեղծում է քաղաքային սեփականություն տվյալ օբյեկտի համար: Ինչու չգրել myobj.city \u003d «Springfield» - ը պարզապես: Եվ տարբերությունն այն է, որ տվյալների մեթոդը ավելացնում է մի քանի օգտակար իրադարձություններ, որոնք պարզեցնում են աշխատանքը այս օբյեկտի հետ: Օրինակ:
Var progressebar \u003d (); $ (ProgressBar) .Բինդ («Setdata», գործառույթ (E, բանալին, արժեքը) (անջատիչ (բանալին) (գործ). $ ("# Առաջընթաց»): Լայնություն (արժեք + "" ") Տեքստը (արժեքը +"% »); ընդմիջում;« Գույն ». $ (" # Առաջընթաց "): CSS (« # առաջընթաց ») .TOGGLECLASS («Ակտիվ», արժեք); ընդմիջում;))); $ (ProgressBar) .Դատա («Միացված», ճշմարիտ) .Դատա («տոկոս», 21). Data («Գույն»); Console.log (ProgressBar.Enabled);
Տրված օրինակով մենք օգտագործում ենք տվյալների եղանակը `ստեղծելու ամենապարզ API- ն, որի միջոցով մենք կարող ենք թարմացնել կետը:
Կան եւս երկու իրադարձություն, որոնք կարող են օգտագործվել JavaScript օբյեկտի համար.
- getdata - Trigggers նախքան տվյալները կարդալը: Դուք կարող եք օգտագործել այն `ստացված տվյալները կանխելու համար: Օրինակ, արժեքը վերահաշվարկելու համար:
- Փոխվել է, որ տվյալները տեղադրվում կամ փոփոխվում են: Այս միջոցառումը օգտագործվում է JQuery Datalink Plugin- ում: Դրանով դուք կարող եք ձեւի տվյալները կապել JavaScript օբյեկտի հետ եւ աշխատել ձեւի դաշտերի հետ, ինչպես օբյեկտի հատկություններով:
Կուլիսների ետեւում
jQuery- ը ստեղծում է դատարկ առարկա (հետաքրքրասեր, այն կոչվում է $ .cache), որը բոլոր արժեքների պահեստն է, օգտագործելով տվյալների մեթոդը: DOM- ի յուրաքանչյուր տարր, որն օգտագործվում է տվյալների մեթոդով, նշանակվում է եզակի նույնացուցիչ, որն այնուհետեւ $. Cache օբյեկտի տվյալները մուտք գործելու բանալին է:
jQuery- ը ոչ միայն այս պահոցում օգտագործողի տվյալներն են, ներքին տվյալները, իրադարձությունների պահուստները, որոնք դուք կախված եք կենդանի (), պարտադիր () եւ պատվիրակ () գործառույթներից: Կենտրոնական պահեստի օգտագործումը jQuery- ն ավելի հուսալի է դարձնում:
Եզրակացություն
Տվյալների մեթոդը JQuery բազմաթիվ առանձնահատկություններից միայն մեկն է, ինչը հեշտացնում է վեբ մշակողների կյանքը: Գրադարանի այլ առանձնահատկությունների հետ կապված, այն լրացնում է այն ամուր հիմքը, որի համար մենք կարող ենք ապավինել:
Դասը կքննարկի JavaScript օբյեկտների թեման: Դա կլինի օգտվողի օբյեկտների մասին. JavaScript- ում օբյեկտի ստեղծում, աշխատեք հատկությունների եւ օբյեկտի մեթոդների, ինչպես նաեւ JavaScript- ի նախատիպերի հետ: Հակիրճ ուրվագծեք աշխատանքը օբյեկտների հետ Գտնվելու վայր, Նավարկող, Էկրան
Առաջադրանք Կայքի կայք - Ստանալով գործնական հմտությունների օգտագործողներ, լեզվի հետ աշխատելու համար: Լաբորատոր աշխատանքներ JavaScript- ի միջոցով նկարագրված է որպես դրանց բարդությունը բարձրացնում եւ աջակցվում է տեսողական լուծումներով, թույլ կտա հեշտությամբ ընկալել ուսումնասիրված նյութը եւ սովորել, թե ինչպես ստեղծել «կենդանի», դինամիկ վեբ էջեր:
JavaScript- ում կան մի քանի տեսակի օբյեկտներ.
- Ներկառուցված առարկաներ
- Զննարկչի օբյեկտներ
- Առարկաները, որոնք ծրագրավորողը ստեղծում է ինքնուրույն (սովորույթ)
Ներկառուցված առարկաները կանխորոշված \u200b\u200bառարկաներ են, որոնց մեծ մասը արդեն դիտարկվել է նախորդ դասերում:
JavaScript- ի զննարկչի առարկաները կքննարկվեն հետագա դասերում:
Եվ հիմա հանդիպելու ժամանակը javaScript- ում հարմարվողական առարկաներ.
- Օբեկտ (առարկաներ)
- Համարը (համարների վերամշակում)
- Լարային (շարքի վերամշակում)
- Array (զանգվածներ)
- Մաթեմատիկա (մաթեմատիկական բանաձեւեր, գործառույթներ եւ հաստատուններ)
- Ամսաթիվ (աշխատել ամսաթվերի եւ ժամանակի հետ)
- Regexp.
- Գլոբալ (դրա անսահմանությունը, նան, անորոշ) հատկությունները
- Գործառույթ:
JavaScript- ի ստեղծման օբյեկտներ
Օբեկտներ ստեղծելու 2 եղանակ կա.
- Օգտագործելով օբյեկտի սկզբնականացուցիչ (կամ օբյեկտ-հավաքածուների ստեղծում)
- Օգտագործելով օբյեկտի դիզայներ ()
- Հավաքածուներ ստեղծելով
var_ object_name \u003d նոր օբյեկտ (); Փաթեթի անվանումը: Ծրագրաշար \u003d արժեք; // կետի նոտացիա_name_Name [«Գույքը»] \u003d արժեք; // հիմնված նոտացիա
Կարեւոր է. Հատկանշական է, որ անհնար է գործիչ օգտագործել որպես արժեք, MyOBG.ROST \u003d 2 // Հնարավոր չէ: myobg.rost \u003d "2" // կարող ես
Օրինակ: Ստեղծեք MyBrowser օբյեկտը անվանման հատկություններով ) եւ տարբերակը (արժեքը " 9.0 »)
✍ Լուծում 1:
var mybrowser \u003d նոր օբյեկտ (); MyBrowser.Name \u003d "Microsoft Internet Explorer."; MyBrowser [" Version "] \u003d" 9.0 ";
Օրինակ: Ստեղծեք երկու հավաքածու օբյեկտ (մեքենա եւ մոտո) գույնի եւ ապրանքանիշի հատկություններով: Display ուցադրել գույքի արժեքը Գույն Օբյեկտի մոտ Ավտոմեքենա եւ հատկությունները ապրանքանիշը. Օբյեկտի մոտ moto..
✍ լուծում.
| Var car \u003d նոր օբյեկտ (); car.color \u003d "սպիտակ"; Car.maxsepeed \u003d 220; car.brand \u003d "Nissan"; Document.write ("Machine Color:" Car.Color); Var moto \u003d (Գույն, "Կապույտ", Ձիաուժ `130, Ապրանքանիշը:" Yamaha "); Document.write ( «Մոտոցիկլետ արտադրող» + Moto.brand); |
var car \u003d նոր օբյեկտ (); car.color \u003d "սպիտակ"; Car.maxsepeed \u003d 220; car.brand \u003d "Nissan"; Document.write ("Machine Color:" Car.Color); Var moto \u003d (Գույն, "Կապույտ", Ձիաուժ `130, Ապրանքանիշը:" Yamaha "); Document.write ("Motorcycle Արտադրող," + Moto.brand);
Ցիկլը «յուրաքանչյուրի համար», JavaScript- ում օբյեկտների հետ աշխատելիս
Այս դիզայնի մասին մի փոքր արդեն ասել է:
The javaScript- ի ցիկլով նախատեսված է, որը նախատեսված է զանգվածային, հավաքածուների եւ առարկաների միջոցով անցնել:
Դիտարկենք, որ օգտագործելու օրինակ.
| 1 2 3 4 5 6 7 8 | var mybrowser \u003d նոր օբյեկտ (); MyBrowser.Name \u003d "Microsoft Internet Explorer"; MyBrowser ["Version"] \u003d "9.0"; Համար (var a MyBrowser) (Alert (A); // շրջում է MyBrowser օբյեկտի հատկությունները: Գրեք անունը, տարբերակը Alert (MyBrowser [a]); // տալիս է հատկությունների արժեքները } |
var mybrowser \u003d նոր օբյեկտ (); MyBrowser.Name \u003d "Microsoft Internet Explorer"; MyBrowser ["Version"] \u003d "9.0"; For (Alert (A); // մաքրում է MyBrowser օբյեկտի հատկությունները: Անուն, տարբերակի ազդանշան (MyBrowser [A]); // թողարկված գույքի արժեքներ)
Շինարարների դասերի ստեղծումն իրականացվում է երկու փուլով.
- Նախ ստեղծում է դաս, օգտագործելով դիզայներ:
- Այնուհետեւ ստեղծվում է նոր կոնստրուկտորային օբյեկտ:
Դիզայներ օգտագործող օբյեկտների դասի ստեղծում (դասերի դիզայներների ստեղծում).
function_Name_Blass_Name (SV-B1, SV-CO2) (սա .SV-B1 \u003d արժեք; սա SB-C2 \u003d արժեք;)
Օբյեկտի դասի հիման վրա նոր օբյեկտի ստեղծում.
var_ object_name \u003d new_name_name ("Value_SV-VA1", "Value_SV2");
var name_name \u003d new_name_name (); Անունը_ անունը: MSB-B1 \u003d "Value_SV-VA1"; _name_name.cv-in2 \u003d "Value_SV-VA2";
Դիզայների դասի անվանումը սովորական է գրել մայրաքաղաքից:
Դիտարկենք.
Օրինակ: Օբեկտների դասի համար շինարարի ստեղծում եւ այս դասի հիման վրա օբյեկտ ստեղծելը. Ստեղծեք MyBrowser օբյեկտ `անվանման հատկություններով: «Microsoft Internet Explorer») եւ տարբերակը (արժեքը " 9.0 »)
Բաց որոշում
| 1 2 3 4 5 6 7 8 | Ֆունկցիայի զննարկիչ (անուն, տարբերակ) (սա .Name \u003d անուն; սա .version \u003d տարբերակ;) var mybrowser \u003d "9.0"); «Microsoft Internet Explorer»); Alert (MyBrowser.Name); Alert (MyBrowser.Version); |
Գործառույթի զննարկիչ (անուն, տարբերակ) (այս .Name \u003d անուն; սա. Version \u003d տարբերակ;) var mybrowser \u003d նոր զննարկիչ ("9.0"); Alert (MyBrowser.Name); Alert (MyBrowser.Version);
Այսպիսով, համեմատեք եւս մեկ անգամ օբյեկտներ ստեղծելու առաջին եղանակով.
// հավաքածուի օբյեկտ Var MyBrowser \u003d (Անուն `Microsoft Internet Explorer", տարբերակ, "7.0"); Alert (MyBrowser.Name); Alert (MyBrowser.Version); // Հաջորդ գիծն անընդունելի է: Var mybrowser1 \u003d New MyBrowser ("Mozillafirefox", "3.5"); // Ճիշտ չէ! !!
Կարեւոր է. Օբեկտի հավաքածուի ստեղծման դեպքում դուք չեք կարող ստեղծել էքսպենտ դաս, քանի որ սա դաս չէ
JS 6_1 Առաջադրանք: Ստեղծեք օբյեկտի աշխատող, որը պարունակում է տեղեկատվություն որոշ ֆիրմայի աշխատակիցների մասին, ինչպիսիք են անունը, վարչությունը, հեռախոսը, աշխատավարձը (օգտագործեք դիզայներների գործառույթը եւ դրա հիմնաբառը): Ստեղծեք օբյեկտի օրինակ
JavaScript- ում օբյեկտի հատկությունների մուտք
Փաթեթի անվանումը: Որակի անվանումը
| 1 2 | Agent007.miya \u003d "պարտատոմս"; Alert (Agent007. |
agent007.miya \u003d "պարտատոմս"; Alert (Agent007.
Որն է լռելյայն գույքը
Դիզայներների գործառույթը թույլ է տալիս մուտքագրել կանխադրված օբյեկտի օբյեկտ: Այս հատկությունները կլինեն օբյեկտի յուրաքանչյուր օրինակ
| 1 2 3 4 5 6 7 8 9 10 | Գործառույթի ուսանող (անուն, հեռախոս) (սա .Name \u003d անուն; սա .Phone \u003d "22-22-22"; // Լռելյայն գույքը: ) Վար Իվանով \u003d նոր ուսանող («Իվան», «33-33-33»); Alert (Ivanov.Name); // թողարկվել է «Իվան» ահազանգը (Ivanov.phone); // թողարկվելու է «22-22-22» Ivanov.Phone \u003d "33-33-33"; // փոխել լռելյայն SV-in- ը Alert (Ivanov.phone); // կտա «33-33-33» |
Գործառույթի ուսանող (անուն, հեռախոս) (այս .Name \u003d անուն; սա. Shonephon \u003d "22-22-22"; // լռելյայն) ; Alert (Ivanov.Name); // թողարկվել է «Իվան» ահազանգը (Ivanov.phone); // թողարկվելու է «22-22-22» Ivanov.Phone \u003d "33-33-33"; // Մենք փոխում ենք լռելյայն ազդանշանը (ivanov.phone); // կտա «33-33-33»
Հատկություններ ավելացնելը օբյեկտների դասին
Գույքի արժեքը կարող է ավելացվել.
- օբյեկտի հատուկ օրինակ;
- Ամբողջ դասի օբյեկտը
Ավելացնելով հատկություններ բետոնի (օրինակ) օբյեկտ.
Փաթեթի անվանումը: Որակի անվանումը \u003d արժեք
ivanov.biology \u003d "Գերազանց";
Կարեւոր է. Օրինակ, գույքը սահմանվում է որոշակի օբյեկտի, եւ ոչ թե օբյեկտի դասի համար:
Ավելացնելով հատկություններ Դասարին Օբեկտներ.
nameklass.prototype. Որակի անվանումը \u003d արժեք
Student.prototype.biology \u003d "գերազանց";
Կարեւոր է. Օրինակ, գույքը (լռելյայն) սահմանված է օբյեկտի դասի համար: Դա արվում է նախատիպի միջոցով. Նախատիպ- Կառույցը սահմանող օբյեկտ
| 1 2 | Student.prototype.email \u003d " [Email պաշտպանված]"; ահազանգ (Ivanov.Email); // ԿՏԱՇՏ ՀԱՐՈՒՄ » [Email պաշտպանված]" |
Student.prototype.email \u003d " [Email պաշտպանված]"; ահազանգ (Ivanov.Email); // թողարկված" [Email պաշտպանված]"
Օրինակ: Արժեքներով օբյեկտի բոլոր հատկությունների արտադրանքի օրինակ
| 1 2 3 4 5 6 7 8 9 | VAR Summertour \u003d (Թուրքիա. 2000, Իսպանիա: 3000, Եգիպտոս, 1000); Var տարբերակ; For (Option in ամառում) (ՓԱՍՏԱԹՂԹԵՐ (Ընտրանք + ".« Ամփոփում [տարբերակ] + » " ) ; } |
vAR Summertour \u003d (Թուրքիա. 2000, Իսպանիա: 3000, Եգիպտոս, 1000); Var տարբերակ; Որովհետեւ (Option in ամառվա մեջ) (ՓԱՍՏԱԹՂԹԵՐ (Ընտրանք + ".« + Ամառ + »
");
}
JavaScript Prototypes (ներածություն)
Դիտարկենք, թե ինչպես են JavaScript- ի դասերը կառուցվում նախատիպերի վրա
Օրինակ: Ստեղծեք օբյեկտի դասի մեքենա (մեքենա) երեք հատկություններով. Անուն (անուն), մոդել (մոդել), գույն (գույն): Ստեղծեք դասի օրինակ հատուկ հատկություններով: Ապա ստեղծված օրինակով Ավելացնել Դասարին Սեփականատիրոջ գույքը (սեփականատերը) `հատուկ լռելյայն իմաստով ( Իվանով): Display ուցադրել ստեղծված դեպքի հատկությունների բոլոր արժեքները
| Գործառույթի մեքենա (անուն, մոդել, գույն) ( / * Ավտոմեքենաների օբյեկտի դիզայներ * / Սա. Անուն \u003d անուն; Սա .Model \u003d մոդել; սա .color \u003d գույն; ) Var mycar \u003d նոր մեքենա; mycar.name \u003d "mers"; Mycar.model \u003d "600"; Mycar.color \u003d "Green"; Car.prototype .Owner \u003d "Իվանով"; / * Ավելացնել նոր սեփականություն * / Alert (MyCar.Name + "" "+ Mycar Modelel +" "" + MyCar.Color + "" +, MyCar.Owner); |
Գործառույթի մեքենա (անուն, մոդել, գույն) (/ * դիզայներական օբյեկտի մեքենա * / այս .Name \u003d անուն; այս model \u003d մոդել;) var mycar \u003d Նոր մեքենա; mycar.name \u003d "mers"; Mycar.model \u003d "600"; Mycar.color \u003d "Green"; Car.prototype.owner \u003d "Իվանով"; / * Ավելացնել նոր գույքը * / ահազանգ (MyCar.Name + "" "+ MyCar.Color +" "+ MyCar.Owner);
JS 6_2 Առաջադրանք: JS 6_1- ը աշխատողի օբյեկտի կողմից ստեղծված աշխատողի ECCAST- ի միջոցով սահմանելու համար ավելացնել նոր գույքի հասցե օբյեկտի դասին
Օբեկտների JavaScript մեթոդներ
Օբյեկտի մեթոդի ստեղծում
Օրինակ: Ավելացնել զննարկչի օբյեկտի կոնստրուկտորային մեթոդի մասին, որը պատկեր կներկայացնի այս օբյեկտի հատկությունների վերաբերյալ զննարկչի էկրանին:
- Օբեկտների մեթոդները ստեղծվում են գործառույթի հիման վրա եւ ավելացվում են դասի կոնստրուկտորին
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | Funnation Showbrowser () (փաստաթուղթ. «Դիտորդ (« Դիտորդ »(« Դիտորդ ». + Սա +» »« + սա. «Անուն \u003d անուն, սա: \u003d showbrowser;) var mybrowser \u003d New Browser ("Microsoft Internet Explorer", 8.0); myBrowser.about brebrowser (); |
funnation Showbrowser () (փաստաթուղթ. Վիրավոր («Դիտորդ». «+ Սա.« + Այս .version);) գործառույթի զննարկիչ; սա. Aboutsion \u003d \u003d showbrowser;) var mybrowser \u003d New Browser ("Microsoft Internet Explorer", 8.0); myBrowser.about brebrowser ();
Ֆունկցիայի զննարկիչ (անուն, տարբերակ) (այս. Անուն \u003d անուն; սա. Version; սա. Aboutbrowser \u003d գործառույթ);)) var mybrowser \u003d Նոր զննարկիչ («Microsoft Internet Explorer», 8.0); myBrowser.about brebrowser ();
JS 6_3 Առաջադրանք: Ստեղծեք օբյեկտների դաս (շրջայց) տուրիստական \u200b\u200bընկերության աշխատանքի համար `ուղեւորության արժեքը հաշվարկելու եղանակով. Մարդու քանակը * Օրերի քանակը * Երկրի սակագինը, Ստեղծեք Թուրքիայի օբյեկտի օրինակ, հատկություններով: Display ուցադրել էկրանին օբյեկտի բոլոր հատկությունները: Օբեկտների մեթոդի հաշվարկը գործառույթի հիման վրա ստեղծում է գործառույթ:
Ներկառուցված օբյեկտների JavaScript- ի նախատիպերը (նախատիպը)
Ներկառուցված օբյեկտների հատկություններ եւ մեթոդներ ավելացնելը (նախատիպ)
JavaScript.- նախատիպերի հիման վրա OOP լեզու (օբյեկտի վրա հիմնված ծրագրավորում):
Նախատիպ - Կառույցը սահմանող օբյեկտ
Դիտարկենք նախատիպերի հետ աշխատանքը օրինակով.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | / * Նախատիպի փոփոխություն * / // Ներկառուցված օբյեկտի մեջ լռելյայն գույքը ավելացնելը Լարային .Prototype .Color \u003d "սեւ"; // մեթոդի ավելացում (փոփոխություն) ներկառուցված օբյեկտի մեջ Լարային .prototype .Write \u003d stringwrite; Գործառույթի լարային () (փաստաթուղթ: "); ՓԱՍՏԱԹՂԹԵՐ (սա .tostring ()); փաստաթուղթ:) ; } // Օգտագործեք փոփոխված դասը Var s \u003d նոր լար («լարային է»); s.color \u003d "կարմիր"; s.write (); |
/ * Փոխեք նախատիպը * / // Լռելյայն գույքը ներկառուցված լարով ավելացնելով: Prototype.color \u003d "սեւ" օբյեկտ; // մեթոդի ավելացում (փոփոխություն) ներկառուցված լարային ցանցին: prototype.write օբյեկտ \u003d լարային այո; Գործառույթի լարային () (փաստաթուղթ: "); ՓԱՍՏԱԹՂԹԵՐ .ԳԻՏԵՍ (ԱՅՍՊՐՈՒՄ (). ՓԱՍՏԱԹՂԹԵՐ. ՓԱՍՏԱԹՂԹԵՐ ("«);) // Օգտագործեք փոփոխված դասի VAR S \u003d նոր լարը (« լարային »է); s.color \u003d" կարմիր "; s.write ();
Կարեւոր է. Մաթեմատիկայի օբյեկտը չի կարող ավելացնել հատկություններ եւ մեթոդներ
JS 6_4 Առաջադրանք: Առաջադրանքը կատարելու համար լրացրեք ծրագրի կոդը. Ներկառուցված լարային դասի ավելացրեք PrintME () մեթոդը, որը ցուցադրում է բառը «Հորայ»: Որպես վերնագիր (պիտակը H ...), որը նշված է օգտագործողի օգտագործողի կողմից ():
Վերնագրի մակարդակը (1, 2 ... 6) կարող է ավելացվել որպես լարային դասի հատկություններ:
Հիշեցնենք, թե ինչպես է HTML- ի նման HTML- ի նման լինել:
Կոչում
Ամբողջական ծածկագիր.
| 1 2 3 4 5 6 7 8 | Լարային .prototype .Uroven \u003d "1"; ... գործառույթ Printzagolovok () (... ...) var s \u003d նոր ...; ... |
String.prototype.uroven \u003d "1"; ... գործառույթ Printzagolovok () (... ...) var s \u003d նոր ...; ...
Ամփոփում. Համեմատեք JavaScript- ում օգտագործողի օբյեկտների օգտագործման եւս երկու տարբերակ.
- Հավաքածուներ ստեղծելով
- Շինարարների դասերի ստեղծում
- Գնալ դեպի գլխավոր էջ
- ...
- ...
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | var mybook \u003d նոր օբյեկտ (); Mybook.title \u003d "(! Lang: գիրք)"
;
myBook.price
=
"200"
;
alert(myBook[
"title"
]
)
;
!} // 1-ին տարբերակ ավելացնել գույքին Alert (MeBook.Price); // 2-րդ տարբերակ ավելացնել հատկություններին Ֆունկցիան mybookshow () (For I- ում MyBook- ում) (ՓԱՍՏԱԹՂԹԵՐ. ՓԱՍՏԱԹՂԹԵՐ (I + ". + MyBook [i]» " ) ; // մեծ գույք )) Mybook.show \u003d mybookshow; MyBook.Show (); |
var mybook \u003d նոր օբյեկտ (); Mybook.title \u003d "(! Lang: գիրք)";
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 \u003d mybookshow; mybook.show ();
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | Գործառույթ MyBook (վերնագիր, գին) ( // Հատկությունների սահմանում Սա .title \u003d վերնագիր; Սա .PRICE \u003d գինը; // մեթոդի սահմանում Սա .Սոուն \u003d շոու; Ֆունկցիայի ցուցադրություն () (փաստաթուղթ: վերնագիր («Վերնագիր.» + Սա .title); փաստաթուղթ: Գրատ ("Գին); Գիրք); Գիրք :Show (); |
Գործառույթ MyBook (վերնագիր, գին) (/ այս հատկությունների սահմանում) .title \u003d վերնագիր; սա. Գինը; // Definition ("վերնագիր." Վերնագիր) + Սա. Վերնագիր); փաստաթուղթ: Գրատ ("Գին." + սա. Գրքույկ \u003d "գիրք"); Գիրք: sheow;\u003e Գնալ դեպի գլխավոր էջ</ Ա\u003e. <li\u003e ... </ Li\u003e <li\u003e ... </ Li\u003e
* Բարդ. ընտրացանկի իրերի քանակը, նրանց անունները եւ url Պետք է օգտվողը պահանջել
Հուշում:show ուցադրման () շարքերում ցուցադրելու համար օգտագործեք փաստաթուղթը:
JavaScript- ի գտնվելու վայրը, Նավիգատոր, Էկրանի օբյեկտներ
JavaScript Navigator
Մտածեք նավարկողի օբյեկտը JavaScript- ում օգտագործելով.
Օրինակ: Գրեք մի առանձնահատկություն, որը ցուցադրում է.
- Զննարկչի անուն
- Զննարկչի լեզու
- ՕՀ անուն
- Ներառված են բլիթներ
- Օգտվողը միացված է ինտերնետին
- Էկրանի լուծում
- Գույնի խորություն
- Ներբեռնված էջի հասցեն
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | Var տարբերակ; // Նավիգատորի օբյեկտի բոլոր հատկությունների արդյունքը For (Ընտրանք Navigator- ում) (ՓԱՍՏԱԹՂԹԵՐ (Ընտրանք + ".« + Նավիգատոր [տարբերակ] + » " ) ; } // նավարկողի օբյեկտի հատուկ հատկությունների գործառույթը Գործառույթի օգտագործողներ () (փաստաթուղթ: " Զննարկչի անուն. " + Navigator.useragent + " "); ՓԱՍՏԱԹՂԹԵՐ .ԳՈՐԾԱՐԱՐ (« Զննարկչի լեզու. «+ Նավիգատոր. "); ՓԱՍՏԱԹՂԹԵՐ .ԳԻՐ (« ՕՀ ԱՆՎԱՆՈՒՄ. «+ Նավիգատոր.Կ. +» "); փաստաթուղթ: «Արդյոք բլիթները ներառված են." + Նավիգատոր. CookieNabled + » "); փաստաթուղթ: «Ինտերնետը միացված է.« + Navigator.nline + » «);) Օգտագործողներ (); |
var տարբերակ; // Նավիգատորի բոլոր հատկությունների եզրակացությունը օբյեկտի համար (տարբերակ NAVIGATOR- ում) (փաստաթուղթ:
«);) // Navigator գործառույթի հատուկ հատկությունների գործառույթը Օգտագործողի կողմից () (Փաստաթուղթ:
Զննարկչի անուն. «+ Navigator.useragent +»
"); ՓԱՍՏԱԹՂԹԵՐ .ԳՈՐԾԱՐԱՐ (« Զննարկչի լեզու. «+ Նավիգատոր.
"); ՓԱՍՏԱԹՂԹԵՐ .ԳԻՐ (« ՕՀ ԱՆՎԱՆՈՒՄ. «+ Նավիգատոր.Կ. +»
"); Փաստաթուղթ.« Ներառված են բլիթները. «+ Navigator.cookieNabled +»
"); Փաստաթուղթ: Գրատ (« Ինտերնետը միացված է. «+ Նավիգատոր .Nline +»
«);) Օգտագործողներ ();
JavaScript օբյեկտի էկրան
Մտածեք օգտագործել էկրանի օբյեկտը JavaScript- ում, օրինակ.
Գործառույթի օգտագործողներ () (ՓԱՍՏԱԹՂԹԵՐ .ԳԻՏՈՒՄ ("Բանաձեւ." Screen.width + "X" Screen.Height + "
"); ՓԱՍՏԱԹՂԹԵՐ (« Գույնի խորություն. + Էկրան.Կոլեցեպտ + »X" Screen.Height + "
«);) Օգտագործողներ ();
JavaScript Տեղադրության օբյեկտ
Մտածեք, օգտագործելով javaScript- ում գտնվելու վայրի օբյեկտը.
| 1 2 3 4 | Գործառույթի օգտագործողներ () (փաստաթուղթ: "Վերբեռնված էջի հասցեն." + Գտնվելու մասին. Հեֆ + » «);) Օգտագործողներ (); |
Գործառույթի օգտագործողներ () (ՓԱՍՏԱԹՂԹԵՐ) ("Հասցե ներբեռնված էջ." + Տեղ. HRREF + "
«);) Օգտագործողներ ();
Եզրակացություններ.
- Նոր բանալի բառով արտահայտություններ օգտագործելով, կարող եք ստեղծել օբյեկտների օրինակներ, այսինքն, նրանց հատուկ մարմնացումները:
- Ավելին, JavaScript- ի նախատիպի գույքի շնորհիվ դուք հնարավորություն ունեք ավելացնել օգտվողի նոր հատկություններ եւ մեթոդներ, որոնք հորինել են օգտագործողի կողմից եւ բացակայում են ներկառուցված օբյեկտների աղբյուրը:
- Օբեկտների ստեղծումը կարող է օգտագործվել տվյալների շտեմարան ստեղծելու համար:
Այս գլխում.
JavaScript- ում կան մի շարք կանխորոշված \u200b\u200bառարկաներ, որոնք կարող են օգտագործվել գրություններ գրելիս: Դրանք ներառում են այնպիսի առարկաներ, ինչպիսիք են զանգվածը, Boolean- ը, ամսաթիվը, գործառույթը, մաթեմատիկան, համարը, ռեգեքսը եւ լարը, ինչպես նաեւ պարզունակ օբյեկտի օբյեկտը: Մեջ Վաղ տարբերակներ Դրա մեջ ներառված էր նաեւ փաստաթղթի լեզուն (պատուհան, փաստաթուղթ), բայց այժմ դրանք բացառվում են միջուկից: javaScript լեզուԵվ դիմեք փաստաթղթի օբյեկտի մոդելի (DOM) օբյեկտի մոդելի սահմանմանը, որը կքննարկվի ավելի ուշ: Այնուամենայնիվ, այս օբյեկտների (փաստաթղթի եւ պատուհանի) որոշ հատկություններ մեզ արդեն ծանոթ են:
Այնուամենայնիվ, ներկառուցված JavaScript- ի օբյեկտներին Ժամանակակից հայեցակարգ, Բոլոր ներկառուցված առարկաները, բացառությամբ մաթեմատիկայի եւ ամսաթվի, ունեն այնպիսի հատկություններ, ինչպիսիք են շինարարը եւ նախատիպը: Դրանք օգտագործվում են առկա օբյեկտների նոր հատկություններ ավելացնելու համար եւ նկարագրված են գործառույթի օբյեկտի համատեքստում:
Օբյեկտի օբյեկտ
JavaScript լեզվական բոլոր առարկաները օբյեկտի օբյեկտի ժառանգներն են: Հետեւաբար, այս օբյեկտի բոլոր հատկությունները եւ մեթոդները մատչելի են նաեւ JavaScript- ի ցանկացած այլ օբյեկտից:
Օբեկտը սահմանվում է ընդամենը 2 հատկություն `շինարար եւ նախատիպ: Կառուցողական գույքը որոշում է այն գործառույթը, որը ստեղծում է օբյեկտի նախատիպը. Դա ամբողջ գործառույթի ամբողջ գործառույթն է, եւ ոչ միայն նրա անունը: Այլ կերպ ասած, մենք համարում ենք տարբերակը, երբ որոշ փորձարկման օբյեկտ է սահմանված եւ ստեղծվում է այս TMP օբյեկտի օրինակ.
Ֆունկցիայի թեստ (տարբերակ) (սա .version \u003d տարբերակ;) TMP \u003d նոր թեստ (1);
Նման դեպքում, օգտագործելով շինարարության գույքը, կարող եք տեսնել թեստային օբյեկտի աղբյուրի կոդը (Նկար 4.6).
Alert (TMP.Constructor);
ՆկՂ 4.6.
Այս գույքի համար, սակայն, կա մեկ սահման. Այն չի կարող ցուցադրել ներկառուցված JavaScript լեզվով օբյեկտների ծածկագիրը. Նման դեպքերում ելքային տեղեկատվությունը սահմանափակվում է նախատիպի գործառույթի եւ տողի անունով:
Ինչ վերաբերում է նախատիպի գույքին, ապա այն թույլ է տալիս մուտք գործել ընթացիկ օբյեկտի նախատիպի գործառույթ: Այս գույքի օգտագործումը հնարավորություն է տալիս փոխել օբյեկտի նախատիպի բնութագրերը: Օրինակ, թեստային տիպի օբյեկտի համար կարող եք ավելացնել նոր գույք, օգտագործելով նախատիպի գույքը.
Test.prototype.com \u003d "Նոր գույքի մեկնաբանություն";
Այժմ տիպի թեստի բոլոր օբյեկտները, ներառյալ արդեն ստեղծված TMP- ի իրադարձությունը, կունենան մեկնաբանությունների գույք, ինչը հեշտ է համոզվել, որ նման ստուգման կիրառումը.
Alert (TMP.com);
Ավելին, ներկառուցված JavaScript- ի օբյեկտները նույնպես թույլատրվում են թարմացնել: Օրինակ, եթե մենք պետք է ավելացնենք զանգվածին նման գույք, որպես նկարագրություն, ապա կարող եք դա անել (իհարկե, միայն ներկայիս սցենարի շրջանակներում), նկատի ունենալով զանգվածի օբյեկտի նախատիպը եւ ավելացնելը Գույքը դրան.
Array.prototype.description \u003d "";
Ինչ վերաբերում է մեթոդներին, ապա դրանցից ավելին կան օբյեկտի օբյեկտի համար, նույնքան 5 կտոր: Սա Tosource, Tosstring, Watch, Unwuatp եւ Valuef, նրանց Կարճ նկարագրություն Գտնվում է Աղյուսակ 4.10-ում:
Tostring- ը եւ արժեքի մեթոդները կիրառելի են գրեթե բոլոր ներկառուցված JavaScript օբյեկտների համար, եւ, որպես կանոն, թարգմանչի կողմից ինքնաբերաբար կոչվում է, երբ անհրաժեշտ է վերափոխվել: Ինչ վերաբերում է Tosource- ի մեթոդին, ապա, փաստորեն, պարզապես աշխատանքներ է կատարում շինարարական գույքի համար:
Netscape 4 զննարկիչում ներկայացված մնացած ժամացույցի եւ եզրակացության մնացած մեթոդները (այժմ աջակցվում են Mozilla), նախագծված են դեբեռնելու սցենարների համար: Քանի որ այս հրապարակման շրջանակներում սահմանափախտակների ծրագրերի հարցը չի դիտարկվում, ապա իմաստ չունի նկարագրել այս մեթոդները: Բայց հենց այն դեպքում, երբ դուք կարող եք նկատի ունենալ, որ ծովային կապիկում (բայց ոչ Firefox զննարկիչում) կա սցենարի կարգաբերում - JavaScript- ի կարգաբխրում:
Օբյեկտի զանգված:
Զանգվածային փոփոխականները պարունակում են արժեքների պատվիրված հավաքածուներ, մեկ փոփոխականի տեսքով ներկայացված հարմարության համար: Մենք արդեն մեկից մեկից ավելի զանգվածներ ունենք (հիշեք գոնե փաստարկի զանգվածներ), այժմ ժամանակն է գործ ունենալ իրենց բոլոր հատկություններով եւ կիրառման խճճվածություններով:
Ի տարբերություն ծրագրավորման այլ լեզուների, JavaScript- ը չունի այս տեսակի տվյալներ, որպես զանգված: Բայց այս սահմանափակումը պայմանավորված է նրանով, որ հնարավոր է օգտագործել կանխորոշված \u200b\u200bզանգվածային առարկա `զանգված: Օբյեկտ-զանգված ստեղծելու համար կարող եք օգտագործել հետեւյալ շարահյուսական ընտրանքներից մեկը.
Namemassiva \u003d Նոր զանգված (տարր 1, Element2, ... Element) Namemassiva \u003d Նոր զանգված (ոսպնյակ)
Առաջին դեպքում նշվում են զանգվածի բոլոր բաղադրիչները, երկրորդում `պարզապես ցույց է տալիս տարրերի քանակը: Զրուցչելու ժամանակ թույլատրվում է նաեւ օգտագործել գրականություն.
Համակարգիչներ \u003d [«ԱՀ», «Mac», «արեւ»];
Արժեքների տարրերը արժեքներով լրացնելու համար, ինչպես ընդհանուր առմամբ, տարրերը լրացնելու համար կարող է օգտագործվել տարրերի ցուցանիշը: Հիշեք, որ զանգվածի տարրերի ցուցանիշը սկսվում է զրոյից.
Var գույներ \u003d նոր զանգված (3); Գույներ \u003d "կարմիր"; Գույներ \u003d «Կապույտ»; Գույներ \u003d "Green";
Շատ հաճախ, հարմար է օգտագործել զանգվածը ուղղակիորեն լրացնելու հնարավորությունը, երբ գովազդի կողմից տրամադրված լեզվի կողմից գովազդի միջոցով:
Var գույներ \u003d նոր զանգված («կարմիր», «կապույտ», «կանաչ»);
Զանգի երկարությունը պարզելու համար (տարրերի քանակը, որոնցից բաղկացած է զանգվածը), օգտագործեք երկարության գույքը.
Var numpolors \u003d գույներ. Երկարություն;
Բացի երկարության հատկություններից, JavaScript- ը նաեւ տրամադրում է մի շարք այլ հատկություններ եւ մեթոդներ `զանգվածների հետ աշխատելու համար: Մասնավորապես, զանգվածի օբյեկտի հատկությունները, բացի երկարությունից, ներառում են համընդհանուր բոլոր կոնստրուկտորների եւ նախատիպային օբյեկտների համար, ինչպես նաեւ նպատակ ուներ օգտագործել զանգվածների եւ մուտքային հատկությունների կանոնավոր արտահայտություններով զանգվածներ:
Ինչ վերաբերում է մեթոդներին, ապա ստանդարտ Tosource- ի, Tostring- ի եւ արժեքի, զանգվածների համար օժտված են Աղյուսակ 4.11-ում նշված տասը հատկություններով:
| Մեթոդ | Նկարագրություն |
|---|---|
| Կոնդաթ | Համատեղում է երկու զանգված եւ վերադառնում է նոր |
| Միացեք: | Միավորում է զանգվածի բոլոր տարրերը մեկ տողով |
| Փոփ | Հեռացնում է Վերջին տարրը զանգվածից եւ վերադարձնում այն |
| Հրել | Զանգվածի ավարտին ավելացնում է մեկ կամ մի քանի տարրեր եւ այն վերադարձնում է նոր երկարություն: |
| Հակադիր | Զանգվածի տարրերը տեղափոխում է այնպես, որ առաջինը դառնա վերջինը, եւ հակառակը |
| shift. | Հեռացնում է զանգվածի առաջին տարրը եւ վերադարձնում այն |
| Կտոր. | Հեռացնում է զանգվածի տարրերի մի մասը եւ վերադառնում է նոր զանգված |
| Բծավորել | Ավելացնել եւ (կամ) հեռացնում է տարրը զանգվածից |
| Տեսակավորել. | Տեսարժան վայրերի այբուբենի տարրերը |
| Անխուսափելի: | Զանգվածի սկզբում ավելացնում է մեկ կամ մի քանի տարր, եւ վերադառնում է զանգվածի նոր երկարություն (MSIE 5.5 եւ 6-ում այս մեթոդը ոչինչ չի վերադարձնում) |
Հաշվի առեք որոշ մեթոդներ ավելի մանրամասն: Այսպիսով, օգտագործելով Concat մեթոդը, կարող եք համատեղել 2 զանգված մեկում.
Var a \u003d նոր զանգված ("A1", "A2"); VAR B \u003d Նոր զանգված ("B1", "B2"); var ab \u003d a.concat (B);
Այստեղ AB փոփոխականը կդառնա զանգված, որը պարունակում է երկու սոսնձված զանգվածների բոլոր 4 տարրերը: Եթե \u200b\u200bայժմ այս զանգվածին դիմելու համար միացման մեթոդը, ապա արդյունքը կլինի տող, որը պարունակում է ստորակետով նշված այս զանգվածի բոլոր տարրերը:
Str \u003d ab.join (); // ստանալ Str \u003d "A1, A2, B1, B2"
Ինչ վերաբերում է փոփ մեթոդին, ապա այն կիրառելով նույն զանգվածին, մենք պատասխան կստանանք «B2» - ում, եւ զանգվածը կկտրվի երեք առաջին արժեքների: Եվ հերթափոխի մեթոդը, ընդհակառակը, վերադարձնում է առաջին տարրը (մեր դեպքում `« Ա 1 ») եւ նույնն է անում զանգվածի հետ, որ մնացած տարրերը առաջ են շարժվում:
Ավելի լավ հասկանալու համար, թե ինչպես են այս եւ այլ մեթոդներ աշխատում զանգվածների հետ, մենք դիմում ենք 4.3 ցուցակագրում նշված հաջորդ օրինակին:
Listing 4.3. Աշխատելով զանգվածների հետ
Նույն օրինակը կարելի է դիտել Array.html ֆայլում, դուք կարող եք դիտարկել զննարկիչում իր աշխատանքի բոլոր արդյունքները (տես Նկար 4.7):
ՆկՂ 4.7. Splice մեթոդի կիրառման արդյունքը. Վերադառնալ զանգված եւ փոփոխություն
Չափերը կարող են լինել նաեւ բազմաչափ, այսինքն: Զանգվածի տարրը կարող է լինել մեկ այլ զանգված: Այս դեպքում զանգվածային տարրին դիմելու համար օգտագործվում է հետեւյալ շարահյուսությունը.
Array2D \u003d "Element 0,0" array2d \u003d "Element 0.1" ... Array2D [n] [n] \u003d "Element n, n"
Երկկողմանի զանգվածը լրացնելու եւ դուրս բերելու օրինակ կարելի է գտնել Array.html ֆայլում, կա նաեւ ինտերակտիվ օրինակ `զանգվածի գրեթե բոլոր մեթոդների համար:
Օբյեկտի բուլայն:
Օբյեկտի բուլյան - կճեպի տվյալների տիպի նույն անունի տեսակը: Օբյեկտի տիպի բուլայն որոշելու համար օգտագործվում է հետեւյալ շարահյուսությունը.
Boleanobj \u003d Նոր Boolean (արժեք)
Այստեղ արժեքը նախաստորագրվող արտահայտություն է, որը, անհրաժեշտության դեպքում, կտրվի իրական կամ կեղծ: Եթե \u200b\u200bնշեք այդ արժեքը, որքան 0, զրոյական, կեղծ, նան, անորոշ կամ դատարկ տող, ապա օբյեկտի տիպի բուլանի նախաստորագրման արդյունքը կեղծ կլինի, եւ ցանկացած այլ արժեքի դեպքում `ճշմարիտ:
Մի շփոթեք ճշմարիտ եւ կեղծ պարզունակ տրամաբանության արժեքները ճշմարիտ տվյալների ճշգրիտ տեսակների եւ բուլյան օբյեկտի կեղծ օբյեկտների հետ: Օրինակ, եթե դուք հայտարարում եք փոփոխական x- ի մասին եւ նշանակեք Boolean օբյեկտի արժեքը, նախաստորագրվել է կեղծ արժեքի միջոցով, այն դեռ կլինի ճշմարտության արժեքը (ճշմարիտ).
X \u003d նոր բուլյան (կեղծ); // համեմատել, եթե (x) մենք իրականություն ենք ստանում
Միեւնույն ժամանակ, եթե դուք պարզապես նշանակեք կեղծի պարզունակ տվյալների տիպի փոփոխական, ապա այն կստանա այն.
X \u003d կեղծ; // համեմատել, եթե (x) մենք կեղծվում ենք
Ինչ վերաբերում է այս օբյեկտի օգտագործմանը, գործնականում այն \u200b\u200bկարող է օգտագործվել որպես գործառույթ, բուլյանների ցանկացած այլ տեսակների արժեքները փոխարկելու համար.
A \u003d 100; x \u003d բուլյան (ա); // x- ը ճշմարիտ կստանա, եթե (x) (...)
Բայց, փաստորեն, դժվար թե դա անեք, քանի որ անհրաժեշտության դեպքում նման փոխարկումներ են կատարվում JavaScript թարգմանչի կողմից ինքնաբերաբար, հնարավոր կլինի անհապաղ գրել «Եթե (ա) ...», եւ պահանջվում է վերափոխում Այս դեպքում ամեն դեպքում կկատարվի:
Օբյեկտի ամսաթիվը:
JavaScript Language- ի ամսաթվերի հետ աշխատելու համար այն չի տրամադրվում հատուկ տեսակի տվյալների, սակայն զանգվածների դեպքում, կա հատուկ տվյալների օբյեկտ: Ամսաթվի ամսաթիվը ստեղծելու համար կարող եք օգտագործել հետեւյալ եղանակներից որեւէ մեկը.
Նոր ամսաթիվ () Նոր ամսաթիվ (Millisecond) Նոր ամսաթիվ («Date_V_VID_STAKK»)
Առաջին դեպքում, ամսաթվի օբյեկտը ստեղծվում է ընթացիկ ժամանակով, երկրորդում, պետք է նշվի 1970 թվականի հունվարի 1-ից անցած միլիշ վայրկյանների քանակը: Եթե \u200b\u200bամսաթիվը նշված է տողի տեսքով, ապա այն պետք է լինի «Փետրվար, 2005» -ի տեսակը: Թույլատրվում է նաեւ ամսաթիվը սահմանել տարին, ամիս, օրը եւ այլն:
Նոր ամսաթիվ (տարի, ամիս, օր [, ժամ, րոպե, երկրորդ, Millisecond])
Իհարկե, այս դեպքում կարելի է խուսափել վայրկյանների եւ միլիարդ վայրկյանների ճշգրտումից, մանավանդ, քանի որ միլիլեկտրոնները նույնիսկ չեն աջակցվում զննարկիչների հին տարբերակներով: Բացի այդ, JavaScript- ում 1.3-րդ վարկածի, ամսաթվերը ավելի վաղ չեն ապահովվում 1970 թվականի հունվարի 1-ին: Ինչ վերաբերում է արժեքների ձեւաչափին, որը ցույց է տալիս գիծը, ապա տարին ցանկացած 4-նիշանոց է (եթե նշում եք երկնիշ, ապա այն կավելացնի 1900-ից 11-ը) (Դեկտեմբեր), իսկ օրը `0-ից 31-ը: Ըստ այդմ, ժամանակի արժեքները նույնպես սահմանափակ են. Ժամերներով այն կլինի մի ընդհանուր 0-ից 23-ը, 0-ից մինչեւ 59-ը` 0-ից 59-ից 0-ից 999. Որպես օբյեկտի տեսակի արժեքը նշեք 2005 թվականի մայիսի 9-ին, դուք պետք է գրեք.
Varyday \u003d Նոր ամսաթիվ (2005, 5, 9);
Եվ եթե Ձեզ անհրաժեշտ է ստանալ ընթացիկ ամսաթիվը եւ ժամանակային արժեքը, ապա ընդհանրապես պարամետրեր չեն պահանջվում.
Var հիմա \u003d նոր ամսաթիվ ();
Սկսած JavaScript 1.3-ից, ամսաթվերի շարքը կարող է տեղակայվել 01/01/1970-ից առաջ եւ հետո 100 միլիոն օրվա ընթացքում (ընդհանուր առմամբ, այն գրեթե 550 հազար տարի է): Նույն վարկածով պահանջը միշտ հայտնվեց, որ մեկ տարի նշվում է քառանիշ ձեւաչափով, որպեսզի խուսափեն դարերի փոփոխության հետ կապված սխալներից:
Ամսաթվի օբյեկտի հետ աշխատելու համար կան 2 հատկություն `շինարար եւ նախատիպ, ինչպես նաեւ շատ մեթոդներ, որոնք թույլ են տալիս կարեւորել ամսաթվի ցանկալի մասը (տարին, ամիսը կամ այլ ձեւաչափով) Եվ այլն Բոլորը նշված են Աղյուսակ 4.12-ում:
| Մեթոդը եւ դրա շարահյուսությունը | Նկարագրություն |
|---|---|
| gredate () | Վերադարձնում է մեկ ամսվա օրը տեղական ժամանակով |
| getday () | Տեղական ժամանակ վերադառնում է շաբաթվա օրը |
| getRaideeare () | Վերադարձնում է տարին տեղական ժամանակով |
| Գեթուրներ () | Տեղական ժամանակում վերադարձնում է ներկայիս ժամանակը (ժամացույցը) |
| getmilliseconds () | Ներկայիս ժամանակը (Millisecond) վերադարձնում է տեղական ժամանակով |
| getminutes () | Տեղական ժամանակում վերադարձնում է ներկայիս ժամանակը (րոպեները) |
| getmonth () | Տեղական ժամանակում վերադարձնում է ներկայիս ժամանակը (ամիսը) |
| Ստանում է () | Տեղական ժամանակում վերադարձնում է ներկայիս ժամանակը (վայրկյանները) |
| Ստացեք ժամանակ () | Տեղական ժամանակում վերադարձնում է ներկայիս ժամանակը |
| gettimezoneoffset () | Տեղական ժամանակում վերադարձնում է ժամանակի տեղաշարժը Գրինվիչի ժամանակին |
| getutcdate () | Ամսվա օրը վերադարձնում է համընդհանուր ժամանակ |
| gETUTCDAY () | Շաբաթվա օրը վերադարձնում է համընդհանուր ժամանակ |
| getutciftear () | Վերադարձնում է մեկ տարի համընդհանուր ժամանակ |
| getutchours () | Վերադարձնում է ընթացիկ ժամանակը (ժամացույցը) համընդհանուր ժամանակում |
| getutcmilliseconds () | Վերադարձնում է ընթացիկ ժամանակը (MillIseconds) համընդհանուր ժամանակում |
| getutcminutes () | Վերադարձնում է ընթացիկ ժամանակը (րոպեները) համընդհանուր ժամանակում |
| getutconth () | Վերադարձնում է ընթացիկ ժամանակը (ամիս) համընդհանուր ժամանակում |
| getutcseconds () | Վերադարձնում է ընթացիկ ժամանակը (վայրկյանները) համընդհանուր ժամանակում |
| getyear () | Հնացած: Տարին վերադարձնում է մի կարճ (երկշիշ) ձեւաչափով համընդհանուր ժամանակում |
| parse (line_dates) | Վերադարձնում է 1970-ի հունվարի 1-ից անցած միլիշ վայրկյանների քանակը տեղական ժամանակում պարամետրում նշված արժեքին |
| setdate (օր) | Մեկ ամսվա օրը սահմանում է տեղական ժամանակով |
| Սահմանափակում (տարի) | Տեղում է տարին տեղական ժամանակով |
| sethours (ժամացույց) | Տեղում է ժամանակը (ժամացույցը) տեղական ժամանակով |
| setmilliseconds (Milliseconds) | Տեղում է ժամանակը (Millisecond) տեղական ժամանակում |
| setminutes (րոպեներ) | Տեղում է ժամանակը (րոպեները) տեղական ժամանակում |
| setmonth (ամիս) | Տեղում է ժամանակը (ամիս) տեղական ժամանակով |
| setseconds (վայրկյան) | Տեղում է ժամանակը (վայրկյան) տեղական ժամանակում |
| Պայմանագիր (միլիարդ վայրկյան) | Տեղական ժամանակում տեղադրվում է միլամեկդներում ժամանակին |
| setutcdate (օր) | Ամսվա օրը սահմանում է համընդհանուր ժամանակ |
| Կստեղծված (տարի) | Տարին սահմանում է համընդհանուր ժամանակ |
| setutchours (ժամացույց) | Ժամանակը (ժամացույցը) սահմանում է համընդհանուր ժամանակ |
| Setutcmilliseconds (Milliseconds) | Համընդհանուր ժամանակ է սահմանում ժամանակը (Millisecond) |
| setutcminutes (րոպեներ) | Համընդհանուր ժամանակում սահմանում է ժամանակը (րոպեները) |
| setutconth (ամիս) | Համընդհանուր ժամանակում սահմանում է ժամանակը (ամիսը) |
| setucseconds (վայրկյան) | Համընդհանուր ժամանակում սահմանում է ժամանակը (վայրկյան) |
| syyyeAn (տարի) | Հնացած: Տարին սահմանում է տեղական ժամանակով, որպես տարվա արժեք, եկեք ասենք երկնիշ ձեւաչափ |
| togmtstring () | Հնացած: Կրոնտերը ամսաթիվը `Գրինվիչի ժամանակին համապատասխանող տողի |
| Տոլոկալեստ () | Վերադարձնում է ամսաթիվը եւ ժամանակը տեղական համակարգի կայանքների ձեւաչափին համապատասխան տողի տեսքով |
| Տոլոկալեդատինգ () | Վերադարձնում է ամսաթիվը տեղական համակարգի կայանքների ձեւաչափին համապատասխան տողի տեսքով |
| tolocaletimestring () | Վերադարձնում է ժամանակը տեղական համակարգի կայանքների ձեւաչափին համապատասխան տողի տեսքով |
| tosource () | Վերադարձնում է բառը բառացի տեսանկյունից |
| tostring () | Վերադարձնում է ամսաթվի օբյեկտը գծի տեսքում |
| tutcstring () | Կրոնտերը ամսաթիվը տողի մեջ համընդհանուր ժամանակին համապատասխան ձեւաչափով |
| UTC (պարամետրեր) | Վերադարձնում է 1970-ի հունվարի 1-ից անցած միլիշ վայրկյանների քանակը, համընդհանուր ժամանակ: Քանի որ պարամետրերը նշում են մեկ տարի, ամիս եւ օր, ինչպես նաեւ (ըստ ցանկության) - ժամեր, րոպեներ, վայրկյաններ եւ միլիշ վայրկյաններ |
| Արժեք () | Վերադարձնում է ամսաթիվը պրիմիտիվ արժեքի տեսքով |
Չնայած մեթոդների այսպիսի առատությանը, բավարար է ամսաթվի օբյեկտի հետ աշխատելը. Դուք պետք է միայն հասկանաք մեթոդի անունների սկզբունքը.
- «Սահմանելուց» սկսած մեթոդները նախագծված են ամսաթվերի ամսաթիվը եւ ժամը սահմանելու համար.
- «Ստացեք» -ից սկսած մեթոդները նախագծված են ամսաթիվը, ժամանակը կամ դրանց մասերը `ամսաթվից օբյեկտներից.
- «Մինչ» սկսած մեթոդները `ամսաթիվը եւ ժամանակը (կամ նրանց մասերը) վերադարձնելու համար լարային արժեքների տեսքով.
- «UTC» պարունակող մեթոդները տարբերվում են միայն այն փաստից, որ նրանք աշխատում են համընդհանուր ժամանակի ձեւաչափով (I.E.- ն ցուցադրում է ժամանակին ըստ Գրինվիչի):
Այսպիսով, այն մնում է միայն ձեռք բերելու կամ անվանելու ամսաթվի կամ ժամանակի անհրաժեշտ մասը `ստանալու կամ տեղադրելու համար Ցանկալի պարամետրանհրաժեշտության դեպքում, օգտագործելով UTC: Դե, երբ պահանջվում է արդյունքը ստանալ «մարդկային» ձեւով, օգտագործել մեթոդներ: Պետք է հիշեք նաեւ, որ միայն լիարժեք ձեւաչափի գործառույթները միշտ պետք է օգտագործվեն տարվա հետ աշխատելու համար (այսինքն, GetRourear կամ GeteRcultirear):
JavaScript- ում ամսաթվի լարային տեսքը ունի հետեւյալ ձեւաչափը.
Կրկնակի ամսվա համար Թվի տարին ժամացույց. Րոպե. Վայրկյան GMT ± օֆսեթ
Տեսողականորեն տեսնելու ամսաթվերի դիտումը եւ միեւնույն ժամանակ եւ հաշվի առեք, թե ինչպես է այն աշխատում, ինչպես պետք է, հաշվի առեք, թե ինչ են նրանք բոլորը ավարտվում: Միեւնույն ժամանակ, առաջին բանը, որ կարող է մտքի գալ գործառույթի աշխատանքը դիտելու համար `տեքստի արտադրանքի օգտագործումը փաստաթղթում.
Document.writeln (dateobject.tostring ()); Document.writeln (DateBject.Togmtting ()); // եւ այլն
Բայց, փաստորեն, քանի որ շատ գործառույթներ կան, լավ կլինի լավ գրել, որ գործողությունը կատարվել է.
Document.writeln ("DateBject.Tostring ()" DateBject.Tostring ());
Եվ հիմա մենք կմտածենք այն մասին, թե քանի տող ենք ուզում այդպիսի եղանակով դուրս գալ: Նույնիսկ հաշվի առեք «Պատճենել եւ տեղադրել» մեթոդի հնարավորությունները, որոնք աջակցում են բոլորին Տեքստի խմբագիրներՍա չի ապահովագրվի նման սխալները.
Document.Writeln ("DateBject.Tolocalestring ()" + DateBject.Tostring ());
Բայց, ինչպես ասվում է IBM նշանաբանով, մարդիկ պետք է մտածեն, եւ ավտոմեքենաները աշխատեն: Այսպիսով, մենք կարծում ենք, թե ինչպես կատարել համակարգչային աշխատանքը, միեւնույն ժամանակ, ինքներդ ձեզ թալանելով կոդի լրացուցիչ բայթ ներմուծելու անհրաժեշտությունից, որի համար մենք դիմում ենք ցուցակագրմանը 4.4:
Listing ուցակ 4.4. Տարբեր տեսակի ամսաթվերի եւ գնահատման գործառույթի արդյունք
Առաջին հերթին, այն սահմանում է տպագրության առանձնահատկությունը, որն, ըստ էության, ցուցադրում է ամսաթիվը մեկ ձեւով կամ մեկ այլ ձեւով: Փոխարենը, դա ցուցադրում է մեր դեպքում, բայց սկզբունքորեն կարող է որեւէ բան արտադրանքի. Հիմնական բանը այն է, որ այն փաստարկը, որն այն դարձնում է JavaScript կոդի բեկորով: Միեւնույն ժամանակ, ծածկագիրը ցուցադրվում է ինչպես հետեւյալն է (այսինքն, շարքի փոփոխականը տպվում է բնօրինակ ձեւով), եւ այնուհետեւ ցուցադրվում է կատարման արդյունքը: Արդյունքում, այս գործառույթը մեկ անգամ գրելով, ապագայում, ապագայում, ամբողջ փաստաթղթի ընթացքում կապվեք այն, թալանելով իրեն գրեթե նույն տեքստը երկու անգամ մուտքագրելու անհրաժեշտությունից:
Արդյունքների գործառույթից հետո տիպի ամսաթվի օբյեկտի ստեղծում, որը նշանակվում է 2005, 3 ամիս (Ապրիլ, որովհետեւ հունվար - զրո), 1 համար, 30 վայրկյան: Հաջորդը, փաստաթուղթը բացվում է, եւ տպագրության գործառույթը ամսաթվի օբյեկտի 6 տարբեր մեթոդների համար հաջորդաբար կոչվում է: Այս սցենարի արդյունքը կլինի 6 տող, որոնք պարունակում են զույգ արժեքներ մեթոդից եւ դրա գործողության արդյունքի արդյունքը (Նկար 4.8):
ՆկՂ 4.8. Նույն ամսաթվի դուրսբերումը տարբեր մեթոդներով
Հարկ է նշել, որ TOSOURCE մեթոդը, որը ցուցադրում է ծրագրի ներքին ներկայացման ամսաթիվը, աջակցվում է միայն Mozilla-Browsers- ի կողմից: Բացի այդ, մնացած բոլոր մեթոդներով ամսաթվերի ելքի ձեւաչափը նույնպես կարող է փոքր տարբեր լինել տարբեր զննարկիչներում: Կարող եք նման օրինակ ներբեռնել դիտման տարբեր ծրագրերի եւ ինքնուրույն տեսնել, թե ինչ են տրված (File Date.html):
Օբեկտի գործառույթ
Նախանշված գործառույթի օբյեկտը որոշում է JavaScript- ի ծածկագիրը, որը պետք է իրականացվի որպես գործառույթ: Գործառույթի օբյեկտը հայտարարելու համար օգտագործում է հետեւյալ շարահյուսությունը.
Անունի գործառույթ \u003d Նոր գործառույթ ([Argument1, Argument2, ... փաստարկ], Blufunction)
Այս դեպքում ցանկացած փոփոխականի անվանումը կարող է օգտագործվել որպես գործառույթի անուն կամ առկա օբյեկտի ունեցվածքը: Հնարավոր է նաեւ նշել օբյեկտի տիպի գործառույթը որպես արժեք օբյեկտի միջոցառման ձեռնարկի համար: Ենթադրենք, եթե մենք ուզում ենք կատարել ձեր սեփական իրադարձության բեռնաթափման տիպը «Ամբողջ ներբեռնման փաստաթուղթ» (փաստաթուղթ.Բեռնատար), մենք կարող ենք այսպես գրել.
Document.onload \u003d Նոր գործառույթ ([Argument1, ... փաստարկ], Bodyfunction);
Այս դեպքում փաստարկներն են գործառույթներին փոխանցվող պարամետրերը, բայց գործառույթի մարմինը իրական կոդն է, որը պետք է լրացվի այս օբյեկտի գործառույթին մուտք ունենալիս: Օրինակ, դուք կարող եք գրել մի օբյեկտի այս տարբերակը, որը կօգտագործվի քառակուսի մեջ մի շարք կառուցելու համար.
Var shoksobj \u003d նոր գործառույթ ("X", "Return X * X");
Այստեղ Squarobj- ը փոփոխականի անունն է, X- ը ստացված փաստարկն է, եւ «Վերադարձ X * x» - ը գործառույթի մարմինն է: Ուշադրություն դարձրեք այն փաստին, որ ոչ միայն մարմնի գործառույթը, այլեւ այն փաստարկները կցված են մեջբերումներով, ինչպես նաեւ այն օբյեկտի տեսակը, ինչպես սովորական է javaScript- ը, գրված է մեծատառով (գործառույթ):
Այս մեթոդով ստեղծված փոփոխականների օգտագործումը նման է ցանկացած այլ տեսակի փոփոխականների օգտագործման:
Var a \u003d 5 + shoteobj (2); // ստանալ 9:
Փաստորեն, օբյեկտի տիպի օբյեկտը միշտ կարող է ներկայացվել որպես պայմանական գործառույթ `հայտարարված Հիմնաբառեր Գործառույթ: Այսպիսով, երկրորդ աստիճանի նույն մոնտաժը կարելի է բնութագրել հետեւյալ կերպ.
Function Squarefunc (x) (վերադարձեք x * x;)
Ըստ այդմ եւ օգտագործեք այս մեթոդով հայտարարված գործառույթը (այս դեպքում, դա գործառույթն է «մաքուր» ձեւի, եւ ոչ թե ընթացակարգի մեջ):
Var a \u003d 5 + squarefunc (2); // ստացեք նաեւ 9
Այսպիսով, փոփոխական արժեքի առաջադրումը որպես գործառույթի օբյեկտի գործառույթ, որն օգտագործում է գործառույթի նման հայտարարությունը որպես այդպիսին: Բայց միեւնույն ժամանակ, այս մոտեցումները նույնպես ունեն տարբերություն. Եթե screadobj- ը փոփոխական է, որի արժեքը հղում է գործառույթի օբյեկտի օգտագործմամբ ստեղծված օբյեկտի վրա: Ըստ այդմ, ծրագիրը իրականացնելիս նրանք նույնպես այլ կերպ են վարվում. Օբեկտի տիպի համար թարգմանչի գործառույթը, երբ փոփոխական ընկնում է (մեր դեպքում `Squareobj), իսկ սովորական մեթոդով հայտարարված գործառույթների համար Կոդը գնահատվում է միայն առաջին հատվածում: Այս տարբերությունը կարող է լինել ոչ առեւտրային դեպքում, եթե գործառույթը կատարում է միանգամյա գործ, սակայն գործառույթի օբյեկտի հիման վրա փոփոխականների օգտագործումը զգալիորեն նվազեցնում է ծրագրի իրականացումը: Հետեւաբար, գործնականում օբյեկտի օբյեկտների օգտագործումը հազվադեպ է, բայց, այնուամենայնիվ, երբեմն դրանք կարող են հարմար լինել, օրինակ, այլ առարկաների մեթոդներ ավելացնել:
Գործառույթի օբյեկտը ունի ստանդարտ կոնստրուկտոր եւ նախատիպային հատկություններ JavaScript- ի համար, ինչպես նաեւ մի շարք սեփական.
Փաստարկներ. Արգենտինական գործառույթների պարամետրերին համապատասխան զանգված, համապատասխանում է մարմնի գործառույթին: Argument.Caller (հնացած) - ցույց է տալիս այն գործառույթի անվանումը, որից տեղի են ունեցել օբյեկտի բողոքարկումներ. Արգենտներ. Երկարություն - ցույց է տալիս գործառույթի պարամետրերի քանակը: Երկարություն - ցույց է տալիս գործառույթով ակնկալվող փաստարկների քանակը (եւ ոչ թե դրանց ժամանման միջոցով ստացված քանակի համար, ինչպես նաեւ վիճակի դեպքում).
Ուշադրություն
Բոլոր փաստարկների հատկությունները կարող են տեսանելի լինել միայն «ներսից» գործառույթից, եւ սկսած JavaScript- ից 1.4, փաստարկներն այլեւս գործառույթի օբյեկտի սեփականություն չեն: Փաստորեն, գործառույթի երկարության համար մնում է ընդամենը 1 սեփական ունեցվածքը:
Բացի հատկություններից, գործառույթի օբյեկտը ունի մի քանի մեթոդներ: Այսպիսով, կիրառման եղանակը թույլ է տալիս կիրառել մեկ առարկայի մեթոդը մյուսին, իսկ զանգի մեթոդը զանգում է մեկ այլ օբյեկտի մեթոդը `ներկայիս մեկի համատեքստում: Դժբախտաբար, այս մեթոդների իրականացումը գործնականում հստակորեն շատ է թողնում ցանկալի: Այսպիսով, մնում է միայն նշել JavaScript մեթոդների չափանիշը, որը, ինչպես նաեւ գործառնական օբյեկտը, ինչպես նաեւ մատչելի է:
Օբյեկտի մաթեմատիկա:
Մաթեմատիկան ներկառուցված JavaScript լեզվական օբյեկտն է, որն ունի հիմնական մաթեմատիկական կայունություններ եւ գործառույթներ, որպես մեթոդներ եւ հատկություններ: Օրինակ, մաթեմատիկական օբյեկտի PI գույքը պարունակում է PI (π) համարի արժեքը, որը կազմում է մոտավորապես 3,1416, իսկ մեղքի մեթոդը վերադարձնում է նշված համարի սինուսը:
Ի լրումն π թվից, մաթեմատիկական օբյեկտը ունի հետեւյալ հատկությունները.
- 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)
Քանի որ մաթեմատիկական օբյեկտի բոլոր հատկությունները կանխորոշված \u200b\u200bհաստատուններ են, այնուհետեւ ստեղծեք մաթեմատիկայի այլ առարկաներ ոչ միայն պարտադիր չէ, այլեւ անընդունելի է, օրինակ, դրանք նույն կերպ մուտք գործելու համար, օրինակ,
Var circle երկարություն \u003d տրամագիծ * math.pi;
Բացի հատկություններից, հիմնական մաթեմատիկական գործառույթներին համապատասխան մեթոդներ են սահմանվում նաեւ մաթեմատիկական օբյեկտի համար: Բոլորը նշված են Աղյուսակ 4.13-ում:
| Մեթոդը եւ դրա շարահյուսությունը | Նկարագրություն |
|---|---|
| aBS (համարը) | Վերադարձնում է փաստարկի բացարձակ արժեքը |
| atan2 (y, x) | Վերադարձնում է մի շարք սահմաններում: Մինչեւ X առանցքի եւ կետի (X, Y) միջեւ անկյուն (ռադիաներով) ներկայացնելը: Նկատի ունեցեք, որ առաջին փաստարկը Y- կոորդինատ է |
| exp (համարը) | Վերադարձնում է նշված չափով (էքսպոնենցիալ լոգարիթմ) |
| cEIL (համարը), հատակը (համարը) | Վերադարձնում է մի արժեք, որը ամենամոտ մեծ (առթիվ) կամ ավելի փոքր է (հատակ) ամբողջ թիվ |
| mIN (Number1, Number2), Max (Number1, Number2) | Վերադարձեք ավելի փոքր (րոպե) կամ ավելի մեծ (առավելագույն) թվով երկու համեմատված փաստարկների |
| sIN (համարը), COS (համարը), TAN (համարը), ASIN (համարը), ACOS (համարը), Աթան (համարը) | Վերադարձեք ստանդարտ տրիգոնոմետրիկ գործառույթների կատարման արդյունքը - Sinus, Coine, Tangent, Arcsinus, Arcsinus եւ Arctangent |
| pOW (հիմք, ցուցիչ) | Հիմքը վերադարձնում է ցուցահանդեսին |
| Պատահական () | 0-ից 1-ից վերադարձնում է կեղծ պատահական համարը |
| Կլոր (համարը) | Վերադարձնում է արժեքը, կլորացված մոտակա ամբողջը |
| sQRT (համարը) | Վերադարձնում է համարի քառակուսի արմատը |
Ինչպես գույքի դեպքում `մաթեմատիկայի օբյեկտի մեթոդները օգտագործելու համար, դուք պետք է ուղղակիորեն դիմեք ինքնուրույն օբյեկտին, եւ ոչ թե դրա պատճենների վրա: Օրինակ, մենք գրում ենք մի գործառույթ, որը կվերադարձնի տրամագիծը շրջապատի իրենց տարածքի հիման վրա.
Գործառույթ Circlediam (հրապարակ) (շառավղ \u003d մաթեմատիկա.sqrt (քառակուսի / մաթեմատիկա);)
Օգտվելով դրանից գործնականում, կարող եք դիմել արագ եւ ազդանշանային մեթոդների օգնության.
Var sq \u003d հուշում ("Մուտք գործեք", 1); Var di \u003d circlediam (sq); Alert ("Circle տրամագիծը." + DI);
Մաթեմատիկայի օբյեկտի այս եւ այլ մեթոդների աշխատանքը կարելի է դիտել Math.html ֆայլում:
Միավորների օբյեկտ
Համարի օբյեկտը պարզ թվային տեսակների օբյեկտի ներկայացուցչություն է: Այն ունի հատուկ հատկություններ թվային կայունության համար, ինչպիսիք են «առավելագույն թիվը», «ոչ համարը» եւ «անսահմանությունը»: Նոր օբյեկտի տիպի համար ստեղծելու համար օգտագործեք հետեւյալ շարահյուսությունը.
Նոր համարը
Գործնականում, թվերի օբյեկտի օգտագործումը առավել հաճախ կրճատվում է իր կայունությունները օգտագործելու համար, վավերացման եւ սխալների հետեւման փաստարկները ստուգելիս: Օրինակ, ստուգելու համար, թե արդյոք արժեքը փոփոխական է, թե ոչ, այս մեթոդը կարող է օգտագործվել.
Եթե \u200b\u200b(x! \u003d Number.nan);
Այս դեպքում պայմանը ճիշտ կլինի, եթե փոփոխական x- ը պարունակում է մի շարք, քանի որ այն համեմատվում է հատուկ արժեքի հետ `NAN« Ոչ համար »: Նանից բացի, կարող են օգտագործվել այլ հատուկ արժեքներ. Բոլորն էլ համարի օբյեկտի հատկություններն են.
- Max_value - առավելագույն հնարավոր համար
- Min_Value - Նվազագույն հնարավոր համար
- Nan - ոչ մի թիվ (ոչ մի թիվ)
- Բացասական_infinity - «Բացասական անսահմանություն», արտահոսքի դեպքում վերադարձված հատուկ արժեք
- Dead_infinity - «Դրական անսահմանություն», արտահոսքի դեպքում վերադարձվել է հատուկ արժեք
Այս բոլոր հատկությունները կայուն են, այնպես որ դրանք օգտագործելու համար անհրաժեշտ չէ նոր օբյեկտի տիպի համարը: Բացի հետեւյալ հատկություններից, թիվը սահմանում է նաեւ շինարարության եւ նախատիպի նույն ստանդարտ հատկությունները
Բացի հատկություններից, համարի օբյեկտը, իհարկե, ունի մեթոդներ: Ի լրումն Ստանդարտ մեթոդներ Tosource, Tosstring and Valuef, JavaScript 1.5-ում Կան 3 նոր համար `TOEXPONELIEAL, TOFIXED եւ TOPREQUENT: Դրանք բոլորը նպատակ ունեն շարունակել շարքերը տողերի վրա, ձեւաչափի հիման վրա: Այսպիսով, ToExponential մեթոդը մի շարք վերածում է ցուցիչի տեսքով մի շարք, Tofixed մեթոդը մի շարք պարունակում է մի շարք կիսապաշտպանիչ քանակով, կախված այս մեթոդներից մեկը, կախված այս մեթոդներից մեկը նիշերի համարը եւ ընտրված քանակը:
Մենք ավելի մանրամասն ուսումնասիրում ենք այս մեթոդներով, որոնց համար մենք համարում ենք նրանց շարահյուսությունը.
Մեթոդ ([համարը))
Ակնհայտ է, որ բոլոր մեթոդների համար նշանների քանակը ցույց է տալիս կիսագնդի քանակը, բայց եթե լռելյայն տոֆիքսե մեթոդի համար (այսինքն, եթե ոչինչ չի նշվում), ապա արդյունահանման համար անհրաժեշտ նիշերի համար համարի ամբողջությամբ: Այս բոլոր մեթոդների աշխատանքի եւ տարբերությունների հետ ավելի լավ գործ ունենալու համար դրանք համարեք 4.5 ցուցակագրման օրինակով.
Listing ուցակ 4.5. Texponential, Tofixed եւ ToPrecible մեթոդներ
Այստեղ մենք կրկին (ինչպես 4.4 ցուցակագրում) առաջին հերթին օգտվել է արտահայտության հետ գործառույթից, այնուհետեւ դրա մեկնաբանության արդյունքը, միայն այս դեպքում, տպագրություններ: Հետեւյալը պետք է լինի այն փոփոխականի անվանումը, որի վրա կկատարվեն հաշվարկները: Այս դեպքում մենք դա հայտարարեցինք որպես տիպի համարի օբյեկտ, չնայած, ըստ էության, հնարավոր կլինի սահմանափակել փոփոխականի պարզ հայտարարագրին (x \u003d 12.45678): Վերջապես, փաստաթուղթը բացվում է ձայնագրման համար, եւ այն առաջին հերթին ցուցադրում է փոփոխական x արժեքը, առանց որեւէ հստակ վերափոխումների (բայց մենք արդեն գիտենք, որ այստեղ օգտագործվում են ժամանակի բոլոր երեք մեթոդները Թվերի նշանները, այնուհետեւ `պարամետրերով 2-րդ եւ 4. Այս սցենարի արդյունքը կլինի 10 տող պարունակող զույգեր« Expression: 49):
ՆկՂ 4.9.
Եզրափակելով, որ մեկ անգամ եւս հիշում է, որ այս մեթոդները հայտնվել են միայն JavaScript- ում 1.5-ում եւ, համապատասխանաբար, Netscape 4-ում չեն աշխատում 4.0-ում: Միեւնույն ժամանակ, դրանք ապահովում են ավելի ճկուն հնարավորություններ համարները ձեւավորելու համար, քան մաթեմատիկայի օբյեկտի կլոր () մեթոդը:
2011-08-01 // Հարցեր ունեք, առաջարկներ, մեկնաբանություններ: Դու կարող ես
Շատ առաջ, XHTML / HTML4- ի ընթացքում մշակողները ունեին ընդամենը մի քանի առանձնահատկություններ, որոնք նրանք կարող էին օգտագործել, որպեսզի պահեն Դոմի հետ կամայական տվյալները: Դուք կարող եք հորինել ձեր սեփական ատրիբուտները, բայց ռիսկային է. Ձեր ծածկագիրը վավեր չի լինի, զննարկիչները կարող են անտեսել ձեր տվյալները, եւ այն կարող է խնդիրներ առաջացնել ստանդարտ HTML հատկանիշների հետ:
Հետեւաբար, մշակողների մեծամասնությունը կապված էր դասի կամ վերագրման հատկանիշների հետ, քանի որ դրանք լրացուցիչ տողեր պահելու միակ ողջամիտ միջոցն էին: Օրինակ, ենթադրենք, որ մենք ստեղծում ենք widget, Twitter- ում ժամանակավոր հաղորդագրության գծի նման հաղորդագրություններ ցուցադրելու համար: Իդեալում, JavaScript- ը պետք է կարողանա կազմաձեւել առանց ծածկագիրը վերաշարադրելու անհրաժեշտության, այնպես որ մենք սահմանում ենք օգտվողի ID- ն դասի հատկանիշում, օրինակ.
Մեր JavaScript Code- ը ID- ով տարր է կփնտրի msglist., Օգտագործելով սցենարը, մենք կփնտրենք դասեր, սկսած Օգտագործող_Եվ «Բոբը» մեր դեպքում կլինի օգտվողի ID- ն, եւ մենք կցուցադրենք այս օգտագործողի բոլոր հաղորդագրությունները:
Եկեք ասենք, որ մենք կցանկանայինք նաեւ սահմանել հաղորդագրությունների առավելագույն քանակը եւ բաց թողնել հաղորդագրությունները վեց ամսվա ընթացքում (180 օր).
Մեր հատկանիշը Դասավորել Այն շատ արագ բարձրանում է. Ավելի հեշտ է թույլ տալ սխալ, եւ javaScript- ի տողերի վերլուծությունը ավելի բարդ է դառնում:
HTML5 տվյալների հատկանիշներ
Բարեբախտաբար, HTML5- ում ներդրվեց մաքսային ատրիբուտներ օգտագործելու ունակությունը: Նախածանցով կարող եք օգտագործել ցանկացած անուն ցածր գրանցամատյանում Տվյալներ, օրինակ,
Պատվերով տվյալների հատկանիշներ.
- Այս տողերը դրանց մեջ են, դուք կարող եք պահպանել ցանկացած տեղեկատվություն, որը կարող է ներկայացվել կամ կոդավորված լինել որպես լար, ինչպիսին է JSON- ը: Տեսակները պետք է բերվեն JavaScript- ի միջոցով
- պետք է օգտագործվի այն դեպքերում, երբ չկա համապատասխան HTML5 տարրեր կամ հատկանիշներ
- Դիմեք միայն էջին: Ի տարբերություն միկրոֆրոֆրացիների, դրանք պետք է անտեսվեն Արտաքին համակարգերՏիպ Որոնիչ եւ որոնել ռոբոտներ
JavaScript- ի վերամշակման օրինակ. GetatTribute եւ setatstribute
Բոլոր զննարկիչները թույլ են տալիս ստանալ եւ փոխել տվյալների հատկանիշները `օգտագործելով GetAtTribute եւ setattribute մեթոդներ.
Var msglist \u003d document.getelementbyid ("msglist"); var show \u003d msglist.getattribute («Տվյալների ցուցակ-չափ»); msglist.Setttribute ("Տվյալների ցուցակ-չափս", + ow ույց տալ + 3);
Այն աշխատում է, բայց պետք է օգտագործվի միայն հին զննարկիչների հետ համատեղելիությունը պահպանելու համար:
Օրինակ # 2 Վերամշակում JavaScript. Տվյալների () մեթոդ JQuery Library
Սկսած JQuery 1.4.3 տվյալների () Մեթոդի գործընթացները HTML5 տվյալների հատկանիշներ: Անհրաժեշտ չէ հստակ հստակեցնել նախածանցը ՏվյալներԱյսպիսով, այդպիսի ծածկագիրը կաշխատի.
Var msglist \u003d $ ("# msglist"); var Show \u003d msglist.data ("List-Size"); msglist.data ("List-Size", Show + 3);
Բայց եղեք, որ հնարավոր է, հիշեք, որ jQuery- ը փորձում է նման հատկանիշների արժեքները վերափոխել մաքրող տեսակներին (բուլյան արժեքներ, համարներ, առարկաներ կամ զրոյական) եւ ազդել DOM- ին: Ի տարբերություն setattribute., Մեթոդ Տվյալներ () ֆիզիկապես չի փոխարինի ատրիբուտը Տվյալների ցուցակ-չափ - Եթե ստուգում եք դրա արժեքը jQuery- ից, այն դեռ կմնա հավասար 5-ի:
JavaScript- ի վերամշակման օրինակ. API տվյալների հավաքածուների հետ աշխատելու համար
Եվ, վերջապես, մենք ունենք API, HTML5 տվյալների հավաքածուների հետ աշխատելու, որը վերադարձնում է DomStringMAP օբյեկտը: Պետք է հիշել, որ տվյալների հատկանիշները ցուցադրվում են օբյեկտում, առանց նախածանցների ՏվյալներԱնուններից հանվում են հիպենայի նշանները, եւ անուններն իրենք վերածվում են ուղտի, օրինակ.
| Հատկանիշ անուն | Անունը տվյալների հավաքածու API- ում |
| Տվյալների օգտագործող: | Օգտվող |
| Տվյալների առավելագույնը: | Առավելագույնը: |
| Տվյալների ցուցակ-չափ | Ցուցակագրում է: |
Մեր նոր կոդը.
Var msglist \u003d document.getelementbyid ("msglist"); var show \u003d msglist.dataset.listies; MSGLIST.DATASET.Listsize \u003d + Ցույց + 3;
Այս API- ն աջակցում է բոլոր ժամանակակից զննարկիչները, բայց ոչ IE10- ը եւ ներքեւում: Նման զննարկիչների համար կա աշխատանքներ, բայց, հավանաբար, ավելի գործնական է jQuery- ի օգտագործումը, եթե գրում եք հին զննարկիչների համար:
Աշխատելիս: ամսաթիվը եւ ժամանակը JavaScript- ում Օգտագործված Օբյեկտի ամսաթիվը:, Կարծում եմ, որ անհրաժեշտ չէ բացատրել, թե որքան հաճախ պետք է աշխատել ամսաթվի եւ ժամի հետ: Եվ այս հոդվածում դուք կսովորեք, թե ինչպես դա անել JavaScript..
Եկեք սկսենք ավանդույթով, դիզայներների հետ Օբյեկտի ամսաթիվը, Նրանցից չորսն են: Առաջին շինարարը առանց պարամետրերի, եւ այն վերադառնում է ներկայիս ժամն ու ամսաթիվը.
Var Date \u003d Նոր ամսաթիվ ();
document.write (ամսաթիվը);
Արդյունքում, այս ոգով ինչ-որ բան կտեսնեք »: Հոկտեմբեր 14 2010 11:42:06 GMT + 0400".
Երկրորդ դիզայներ Օբյեկտի ամսաթիվը - Սա շինարար է `մեկ պարամետրով: Այս պարամետրը պարունակում է անցյալում միլամետրերի քանակը 01.01.1970 (Դարաշրջանի ծագումը Unix): Օրինակ, այսպես.
Var Date \u003d Նոր ամսաթիվ (135253235);
document.write (ամսաթիվը);
Արդյունքում, կտեսնեք հետեւյալը. " Fri Jan 02 1970 16:34:13 GMT + 0300".
Հետեւյալ կոնստրուկտորը թույլ է տալիս ստեղծել Օբյեկտի ամսաթիվը: Հետեւյալ պարամետրերի ճշգրտմամբ. Տարի, ամիս եւ համարներ.
Var Date \u003d Նոր ամսաթիվ (2010, 0, 12);
document.write (ամսաթիվը);
Արդյունք. Երեքշաբթի 12 2010 00:00:00 GMT + 0300«Նաեւ նկատեք դա 0 Օ Ամիսը հունվար է, եւ 11-րդ - Սա դեկտեմբերն է:
Եւ վերջին դիզայներ Ամսաթիվ դասը JavaScript- ում Թույլ է տալիս ստեղծել Օբյեկտի ամսաթիվը: Ամսաթվի եւ ժամի բոլոր պարամետրերով. Տարեթիվ, ամիս, քանակ, ժամ, րոպե եւ վայրկյան:
Var Date \u003d Նոր ամսաթիվ (2010, 0, 12, 23, 45, 12);
document.write (ամսաթիվը);
Ստացվում է սա »: Երեքշաբթի 12 23:45:11 GMT + 0300«Դա ամեն ինչ է javaScript- ում ամսաթվի օբյեկտի դիզայներներՄենք տրամադրեցինք մշակողներին:
U- ի հատուկ հատկություններ: դասի ամսաթիվը: Ոչ, այնպես որ մենք անմիջապես գնում ենք մեթոդների: Եկեք անմիջապես սկսենք այն մեթոդների խմբից, որ աշխատանքը լիովին հավասար է, բայց նրանցից յուրաքանչյուրը վերադարձնում է իր ամսաթիվը եւ ժամանակի տարրը.
Var Date \u003d Նոր ամսաթիվ ();
document.Write («Տարեթիվ -» + Date.GetItyear () + "
");
document.write («Ամիս -» + ամսաթիվ. Egetmonth () + "
");
document.write ("Համար -" + ամսաթիվ.
");
document.write («Շաբաթվա օր -» + Date.GeDday () + "
");
document.write («ժամ -» + ամսաթիվ .Գեթուրներ () + "
");
document.write («Minute -» + ամսաթիվ. Getminutes () + "
");
document.Write («Secund -» + Date.Getseconds () + "
");
document.write ("Milliseconda -" + Date.GetMilliseconds () + "
");
ՓԱՍՏԱԹՈՒՂԹ. Գրատ («Միլլիսեկտրոնների քանակը անցավ 01/01/1970 -" + ամսաթիվ. Geletime () + "
");
Այս սցենարը վարելը, դուք անմիջապես հասկանում եք, որ այս մեթոդներից յուրաքանչյուրը անում է: Միակ բանը, որ ես ուզում եմ նշել, այն է, որ շաբաթվա օրերի քանակը նույնպես սկսվում է զրո, Եւ կիրակին ունի ցուցանիշ 0 , եւ շաբաթ օրը - 6 .
Նման մեթոդներ կան, բայց ցույց են տալիս Գրինվիչի ամսաթիվը եւ ժամանակը, Եկեք այդպիսի կոդ գրենք.
Var Date \u003d Նոր ամսաթիվ ();
document.Write («Տարեթիվ -» + Date.GetutCultirear () + "
");
document.Write («ամիս -» + Date.getCmonth () + "
");
document.write ("Համար -" + Date.GetutCDate () + "
");
document.write («Շաբաթվա օր -» + Date.GetutCDay () + "
");
document.write («ժամ -» + Date.Getutchours () + "
");
document.write («Minute -» + Date.GetutCMinutes () + "
");
document.Write («Secund -» + Date.GetutCSeconds () + "
");
document.write ("Millisecond -" + Date.GetutCMilliseconds () + "
");
Այս սցենարը վարելը, դուք կսովորեք ընթացիկ Ամսաթիվ եւ ժամ Գրինվիչում.
Հակառակ մեթոդներ ստանալ () մեթոդներ են Սահմանել (), Եթե \u200b\u200bառաջինը վերադարձավ որոշակի արժեքներ, վերջիններս, ընդհակառակը, նրանք փոխում են դրանք: Իրականում, այս սցենարը ես չէի կարող տալ, բայց որպեսզի հարցեր չլինեն, եկեք անենք դա.
Var Date \u003d Նոր ամսաթիվ ();
date.SetItyear (1990);
date.Setmonth (11);
date.Setdate (15);
Ամսաթիվ. Մեթուրներ (9);
date.Setminutes (20);
Ամսաթիվ .Setseconds (0);
date.SetMilliseconds (10);
document.write (ամսաթիվը);
Հուսով եմ, որ դուք նկատեցիք, որ մեթոդը Սեթդիա () գոյություն չունի. Սա հուշում է, որ շաբաթվա օրը ընտրվում է `կախված տարին, ամիս եւ համարներից:
Գրինվիչի համար կան նաեւ նմանատիպ մեթոդներ: Միայն նախածանցն է ավելացվում UTC.Օրինակ, ամիսը փոխելու համար օգտագործվում է մեթոդ setutconth ().
Եվ վերջին մեթոդը պայմանագիր (), Վերցնում է որպես պարամետր, որոնք անցել են միլամետրերի քանակը 01.01.1970 :
Date.SetTime (39293012);
document.write (ամսաթիվը);
Արդյունքում, կտեսնեք սա. Հինգշաբթի 01 1970 13:54:53 GMT + 0300".
Դա բոլոր դիզայներներն ու մեթոդներն են Ամսաթիվ օբյեկտ JavaScript- ում.
