1-ի արժեքների ցուցակը ընթացիկ արժեք
Այս բաժնում մենք կծանոթանանք 1C լեզվի տվյալների նոր տեսակի հետ, որը կոչվում է ValueList.
Արժեքների ցանկզանգված է, բայց հետ մեծ հնարավորություններ. Եվ եթե այո, ապա այն նաև տվյալների հավաքածու է, և դուք կարող եք դրա մեջ տեղադրել թվերի հավաքածու.
// ստեղծել է արժեքների ցանկ
List.Add(23);
Մինչ այժմ ամեն ինչ շատ նման է զանգվածին, այնպես չէ՞։ Բայց անցնենք առաջ։ Այժմ այս թվերն օգտագործողին ցուցադրելու համար մենք գրում ենք.
// Շրջել ցանկի յուրաքանչյուր տարրի միջով For Every Element From List Loop Report (Item.Value);
// ցուցադրել EndCycle տարրի արժեքը;
Եվ ահա առաջին տարբերությունը. Սովորական զանգվածի տարրերը հենց թվերն են։ Եվ մուտք դեպի տարրի ընթացիկ արժեքը Ցուցակմենք ստանում ենք տարբերակով Իմաստը, օգտագործելով կոնստրուկցիան Տարր. Իմաստը.
Դիտարկենք մի քանի լրացուցիչ առանձնահատկություններ Արժեքներ.
Կարող է տեսակավորել
Օրինակ, մենք հեշտությամբ կարող ենք տեսակավորել արժեքների ցանկը: Ցուցակը կարող է դա անել ինքնուրույն.
List.SortByValue (SortingDirection.Asc); Սովորական զանգվածի դեպքում մենք պետք է իրականացնեինք տեսակավորման ալգորիթմներից մեկը (օրինակ՝ «փուչիկը»)։
Կարող է որոնել
Արժեքների ցանկը կարող է փնտրել իր սեփական տարրերը: Ենթադրենք, մենք ուզում ենք պարզել, թե արդյոք օգտագործողի մուտքագրած համարը մեր ցանկում է.
Մուտքագրեք համարը (համարը); // մուտքագրել է թիվ FoundItem = List օգտվողից: FindByValue (համար);
Եթե FoundItem = Undefined, ապա OpenValue ("Number" + Number + " չի գտնվել ցանկում!"); Հակառակ դեպքում
OpenValue("Number " + Number + " ցանկում է: Ահա այն." + FoundItem.Value);
EndIf; Արժեքների ցանկ
Աջակցում է տեղադրմանը և ջնջմանը
Արժեքների ցանկը, ինչպես զանգվածը, աջակցում է տարրերի տեղադրմանը և հեռացմանը.
Ցուցակ. Ներդիր (0, 1000);
// ցանկի հենց սկզբում տեղադրեք հազարը List.Delete(O); // և անմիջապես հեռացրեք այն ցուցակից: Տեղադրել(List.Quantity(), 13);
// տեղադրեք 13-ը ցուցակի վերջում Report(List[List.Count() - 1]);
// ցուցադրել ցանկի վերջին տարրը (13)
Աջակցում է քառակուսի փակագծերին
Ինչպես արդեն հասկացաք, ցուցակի տարրերի համարակալումը նույնպես սկսվում է զրոյից, և մենք կարող ենք ցանկացած տարրի ինդեքսով անդրադառնալ՝ օգտագործելով քառակուսի փակագծերը.
Տեղեկացնել (List.Value); // դուրս բերեց ցուցակի երկրորդ տարրը Այսպիսով, մենք կարող ենք անցնել ցուցակի բոլոր տարրերին այսպես.
A = 0-ի համար ըստ List.Quantity() - 1 Loop Report(List[A].Value);
End Cycle;
Կարողանում է ստեղծել պատճեն
Արժեքների ցանկը պարզապես հիանալի հնարավորություն ունի՝ այն կարող է ստեղծել իր սեփական պատճենը.
ListCopy = List.Copy();
// պատրաստել է ցուցակի պատճենը // այժմ մենք կարող ենք ապահով կերպով փոխել Ցուցակի պատճենը // մինչդեռ բնօրինակ ցուցակը չի փոխի Ցուցակի պատճենը: Արժեք = 123456;
Կարող է վերածվել զանգվածի
Եվ վերջապես, ցանկացած պահի կարող եք հեշտությամբ բեռնաթափել ցանկի բոլոր տարրերը զանգվածի մեջ.
ArrayNumbers = Ցուցակ: UnloadValues ();
// բեռնաթափվել է զանգվածի մեջ
A = 0-ի համար ArrayNumbers.Quantity() - 1 հանգույց
Հաշվետվություն (ArrayNumbers[A]); // կարիք չկա նշելու // տարբերակ Արժեք
End Cycle;
Այս միավորի նյութը մշակելու և համախմբելու համար խորհուրդ է տրվում կատարել հետևյալ առաջադրանքը.
Անհրաժեշտ է օգտատիրոջից մուտքագրել 5 թիվ, գտնել դրանցից ամենամեծն ու ամենափոքրը և ցուցադրել օգտատիրոջը։ Լուծումը պետք է օգտագործի արժեքների ցանկ:
Լուծում
Ցուցակ = Արժեքների նոր ցուցակ;
// ստեղծեց արժեքների ցանկ՝ A = 1-ի համար 5 հանգույցի համար = 0;
Մուտքագրեք համարը (համարը); // մուտքագրեք թիվ օգտվողի ցանկից:Ավելացնել(համար); // և ավելացրեք այն EndCycle ցուցակին; // և այսպես 5 անգամ
// տեսակավորել թվերի ցանկը
Ցուցակ. Դասավորել ըստ արժեքի (Տեսակավորման ուղղություն. Asc);
// տեսակավորումից հետո ցուցակի առաջին տարրը // ամենափոքր տարրն է, իսկ վերջին տարրը՝ ամենամեծ OpenValue("The ամենափոքր տարրը" + Ցուցակ +
", իսկ ամենամեծը " + List[List.Count() - 1]);
Ամբողջական շարահյուսություն (սեղմեք ընդլայնելու համար)
Արժեքների ցանկ
Նկարագրություն:
Արժեքների ցանկը տվյալների բազայում չպահված օբյեկտ է, որը թույլ է տալիս կառուցել արժեքների դինամիկ հավաքածուներ ինտերֆեյսի խնդիրների լուծման համար և շահարկել դրանք (ավելացնել, խմբագրել, ջնջել տարրեր, տեսակավորել): Այն կարող է լրացվել ցանկացած տեսակի արժեքներով, այսինքն. մեկ ցուցակում պահվող արժեքների տեսակները կարող են տարբեր լինել: Այս օբյեկտի օգտագործման օրինակներից մեկը բարդ ալգորիթմի միջոցով ստեղծված հնարավոր փաստաթղթերի ցանկից կոնկրետ փաստաթղթի ընտրության կազմակերպումն է:
Հավաքածուի տարրեր. ItemListValues
Օպերատորի միջոցով հնարավոր է անցնել հավաքածուն օբյեկտի համար Յուրաքանչյուր ... Սկսած ... Ցիկլի. Անցումը ընտրում է հավաքածուի տարրերը:
Հնարավոր է մուտք գործել հավաքածուի տարր՝ օգտագործելով [...] օպերատորը: Տարրի ինդեքսը փոխանցվում է որպես արգումենտ ( համարակալումը 0-ից).
Հատկություններ:
Մեթոդներ:
Կոնստրուկտորներ.
| &OnClient ընթացակարգի կատարման կոդը (հրաման) /// Ինչպես ստեղծել արժեքների ցուցակ 1s 8.3, 8.2-ումՑուցակ = Արժեքների նոր ցուցակ; /// Ինչպես ավելացնել տարր 1s 8.3, 8.2 արժեքների ցանկում // ավելացնել մեթոդի պարամետրեր.// - իմաստ // - կատարում // - նշան (ըստ ցանկության) // - նկար (պարտադիր)Ցուցակ. Ավելացնել (1980 թ. // տարրի արժեքը «Վասյայի ծննդյան տարին»// կատարումը); Ցուցակ. Ավելացնել (1985, «Յուլիայի ծննդյան օրը») ; // արժեքները կարող են լինել տարբեր տեսակիՑուցակ. Ավելացնել(«Պոլինա», «Երեխայի անուն»); /// Ինչպես տեղադրել տարր 1s 8.3, 8.2 արժեքների ցանկում // տեղադրեք թիվ 2 դիրքում (տարրերը համարակալված են 0-ից) // տարր 2010 արժեքով և ներկայացուցչությամբ // «Իրենց համատեղ դստեր ծննդյան տարեթիվը»Ցուցակ. Paste (2, 2010 թ., «Իրենց համատեղ դստեր ծննդյան տարեթիվը».) ; /// Ինչպես շրջանցել արժեքների ցանկի տարրերը 1s 8.3, 8.2-ումՑուցակի հանգույց զեկույցից յուրաքանչյուր տարրի համար( Element. View + ": " + String(Element. Value) ) ; Վերջնական ցիկլ; /// Ինչպես մաքրել արժեքների ցանկը 1s 8.3, 8.2Ցուցակ. Մաքրել (); Ցուցակ. Ավելացնել («երկուշաբթի»); Ցուցակ. Ավելացնել («Երեքշաբթի»); Ցուցակ. Ավելացնել («Չորեքշաբթի»); /// Ինչպես պարզել արժեքների ցանկի տարրերի քանակը և նաև /// ստացեք ցանկի տարրը իր ինդեքսով 1s 8.3, 8.2-ում // համարակալում զրոյիցՀամար Index = 0 Ըստ Ցուցակ. Քանակ() - 1 Loop Report(List[Index]) ; Վերջնական ցիկլ; /// Ինչպես գտնել ցուցակի տարրը ըստ արժեքի 1s 8.3, 8.2-ում ValueTuesday = Ցուցակ: FindByValue («Երեքշաբթի»); /// Ինչպես պարզել ցանկի տարրի ինդեքսը 1s 8.3, 8.2-ումՀաշվետվություն(Ցուցակ. ինդեքս(ValueTuesday) ) ; // 1, քանի որ համարակալումը զրոյից է /// Ինչպես տեսակավորել ցուցակը ըստ արժեքների 1s 8.3, 8.2 // էր՝ երկուշաբթի, երեքշաբթի, չորեքշաբթիՑուցակ. SortByValue (SortingDirection. Descending) ; // դարձավ՝ չորեքշաբթի, երկուշաբթի, երեքշաբթի /// Ինչպես հեռացնել տարրը արժեքների ցանկից 1s 8.3, 8.2-ում // հեռացնել առաջին տարրը // պարամետր՝ ցուցակի տարր // կամ տարրի ինդեքս// Դուք կարող եք անել այս ցանկը: Ջնջել(Ցուցակ[ 0 ] ) ; // կամ այդպես // List.Delete(0); /// Ինչպես տեղափոխել արժեքների ցանկի տարրը 1s 8.3, 8.2-ում // զրոյական տարրը տեղափոխել մեկ դիրք առաջ // էր՝ երկուշաբթի երեքշաբթիՑուցակ. Տեղափոխել (0, 1); // դարձավ՝ երեքշաբթի երկուշաբթի /// Ինչպես պատրաստել ցուցակի պատճենը 1s 8-ում ListCopy = Ցուցակ. Պատճենել(); Գույներ = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել ("Կապույտ"); /// Ինչպես բեռնաթափել ցուցակի արժեքները զանգվածի մեջ 1s 8.3, 8.2-ում ArrayColors = Գույներ: UnloadValues() ; /// Ինչպես բեռնել ցուցակի արժեքները զանգվածից 1s 8.3, 8.2-ումԳույներ. LoadValues (ArrayColors) ; Ավարտի ընթացակարգը /// Ինչպես կատարել արժեքի անմոդելի ընտրություն ցուցակից /// արժեքները 1-ում 8.3, 8.2&OnClient կարգը Ինչպես կատարելModalSelectValue(Command) Colors = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել ("Կապույտ"); // ընթացակարգը AfterItemSelect-ը սահմանվում է հենց ներքևում AlertAfterItemSelection = Նոր ծանուցման նկարագրություն ( «AfterElementSelection», ThisObject ) ; Գույներ. ShowItemChoice (AlertAfterItemChoice, «Ընտրիր քո նախընտրած գույնը») ; EndProcedure &AtClient Procedure AfterElementSelection (տարր, պարամետրեր) Export If Element<>Չսահմանված Հետո հաշվետվություն (Նյութ. Արժեք) ; Վերջ Եթե ; Ավարտի ընթացակարգը /// Ինչպես կատարել արժեքների ոչ մոդալ նշան ցուցակից /// արժեքները 1-ում 8.3, 8.2&OnClient կարգը Ինչպես կատարելModalValueMark(Command) Colors = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել ("Կապույտ"); // ընթացակարգը AfterMarkingItems-ը սահմանվում է հենց ներքևում AlertAfterMarkItems = Նոր նախազգուշացման նկարագրություն ( «Նյութերի նշումից հետո», ThisObject ) ; Գույներ. ShowItemMark(ԾանուցումՆյութից հետո, «Ընտրիր քո նախընտրած գույները») ; Գույներ. FillRemarks (Ճշմարիտ); Endprocedure &OnClient Procedure AfterMarkingElements(Elements, Parameters) Export If Elements<>Undefined then For Every Color From Elements Loop If Color: Դրոշակ, Հետո զեկուցել (Գույն. Արժեք) ; Վերջ Եթե ; Վերջնական ցիկլ; Վերջ Եթե ; Ավարտի ընթացակարգը /// Ինչպես կատարել արժեքի մոդալ ընտրություն 1s 8.3, 8.2 ցուցակից&Հաճախորդի ընթացակարգում Ինչպես կատարել ModalSelectValue(Command) Colors = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել ("Կապույտ"); ԸնտրեքԳույն = Գույներ: Ընտրել տարր ( «Ընտրիր քո նախընտրած գույնը») ; Եթե ChoseColor-ը<>Չսահմանված Հետո հաշվետվություն (SelectColor. Value) ; Վերջ Եթե ; Ավարտի ընթացակարգը /// Ինչպես կատարել արժեքների մոդալ նշան ցուցակից /// արժեքները 1-ում 8.3, 8.2&OnClient կարգը Ինչպես կատարելModalValueMark(Command) Colors = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել ("Կապույտ"); Եթե գույները. Նշել իրերը ( «Ընտրիր քո նախընտրած գույները») Այնուհետև Գույնի ցիկլի յուրաքանչյուր գույնի համար Եթե գույնը: Դրոշակ, Հետո զեկուցել (Գույն. Արժեք) ; Վերջ Եթե ; Վերջնական ցիկլ; Վերջ Եթե ; // և այսպես կարող ես միանգամից բոլոր նշանները դնել // ցանկը որոշակի արժեքովԳույներ. FillRemarks (Ճիշտ) ; Ավարտի ընթացակարգը /// Ներբեռնեք և գործարկեք այս օրինակները համակարգչով |
Ինչի մասին է այս հոդվածը
Այս հոդվածը շարունակում է «1C-ի զարգացման առաջին քայլերը» հոդվածաշարը։ Այն քննարկում է ընդհանուր հավաքածուների հետ աշխատելու սկզբունքները: Հոդվածը կարդալուց հետո դուք կսովորեք.
- Որո՞նք են ընդհանուր հավաքածուները, ե՞րբ և ի՞նչ դեպքերում դրանք պետք է օգտագործվեն:
- Ի՞նչ ընդհանուր բան ունեն բոլոր ունիվերսալ հավաքածուները: Ի՞նչ տեխնիկա կարող է օգտագործվել դրանց բոլորի հետ աշխատելու համար:
- Ի՞նչ է զանգվածը, ինչպե՞ս և երբ օգտագործել այն: Ի՞նչ մեթոդներ ունի նա։
- Ինչու՞ օգտագործել կառուցվածքը: Ինչպե՞ս է այն տարբերվում զանգվածից:
- Ե՞րբ օգտագործել արժեքների ցանկը: Ինչպե՞ս ցուցադրել այն ձևաթղթում:
- Համապատասխանություն - ինչ է դա և երբ օգտագործել այն: Որո՞նք են կառուցվածքի առավելությունները:
- Ինչի համար է օգտագործվում արժեքների աղյուսակը: Ինչպե՞ս նկարագրել դրա կառուցվածքը: Ինչպե՞ս ավելացնել/հեռացնել տողերը: Ինչպե՞ս այն բերել ձևի:
- Արժեքի ծառ - ինչի՞ համար է այն օգտագործվում: Ինչպե՞ս լրացնել և ցուցադրել ձևը: Ինչպե՞ս աշխատել նրա հետ:
Կիրառելիություն
Հոդվածում քննարկվում է ընթացիկ հրատարակության 1C:Enterprise 8.3 հարթակը:
Ինչպես աշխատել ունիվերսալ հավաքածուների հետ 1C-ում
Արժեքների հավաքածուն մի տեսակ կոնտեյներ է, որը սովորաբար կարող է պարունակել ցանկացած քանակությամբ տարրեր: Միևնույն ժամանակ, տվյալների տեսակի վերաբերյալ հաճախ խիստ սահմանափակումներ չկան:
Դուք կարող եք արժեքներ ավելացնել ընդհանուր հավաքածուին: Հավաքածուի բոլոր արժեքները կարող են անցնել: Այս հավաքածուները հիմնականում օգտագործվում են ալգորիթմներում ինչ-որ մշակման համար։ Նրանք. սրանք որոշ դինամիկ կառույցներ են, որոնք գոյություն ունեն ալգորիթմի տևողության համար:
Կարևոր է հասկանալ, որ հավաքածուները չեն պահվում տվյալների բազայում (խոսքը Value Store տվյալների տիպի մասին չէ, որը կարող է պահել գրեթե ցանկացած տվյալների տեսակ):
Գոյություն ունենալ տարբեր տեսակներընդհանուր հավաքածուներ՝ զանգված, կառուցվածք, քարտեզագրում, ֆիքսված զանգված, արժեքների աղյուսակ, աղյուսակային մասև այլն: Բայց բոլոր հավաքածուներն ունեն նման վարքագիծ։
Հավաքածու կարող է ստեղծվել ինչ-որ ֆունկցիայի արդյունքում (ֆունկցիան վերադարձնում է ընդհանուր հավաքածուն որպես արժեք):
Դուք կարող եք ձեռքով ստանալ նոր հավաքածուն՝ զանգահարելով կոնստրուկտորին և ստեղծելով դասի օրինակ:
Օրինակ: OurArray = Նոր զանգված;
Շատ ընդհանուր հավաքածուների կոնստրուկտորները պարամետրացված են:
Այսպիսով, կոնստրուկտորում համար դուք կարող եք նշել տարրերի քանակը համապատասխան չափսերում: Նրանք. դուք կարող եք անմիջապես հայտարարել բազմաչափ .
Կոնստրուկտորի համապատասխան նկարագրությունը շարահյուսության օգնականում է։
Այսպիսով, օգտագործելով կոնստրուկտորի պարամետրերը, դուք կարող եք անմիջապես սահմանել այս օբյեկտի ցանկալի վարքը:
Բայց պարամետրերը կամընտիր են, մշակողը չի կարող դրանք սահմանել և հետագայում որոշել Array-ի վարքագիծը, ինչպես նա հարմար է գտնում:
Գրեթե ցանկացած ընդհանուր հավաքածու կարող է ստեղծվել կոնստրուկտորի միջոցով (բացառությամբ սեղանի մասերի, որոնք գործում են որպես կոնֆիգուրացիայի օբյեկտներ):
Ընդհանուր հավաքածուների համար կան այնպիսի ընդհանուր հասկացություններ, ինչպիսիք են ինդեքսը և թիվը: Հավաքածուի յուրաքանչյուր տարր ունի ինդեքս: Ցուցանիշը սկսվում է զրոյից։
Տարր մուտք գործելու համար OurArray, կարող եք օգտագործել ինդեքսային հասանելիությունը, դրա համար ինդեքսը նշված է քառակուսի փակագծերում։
Օրինակ, OurArray. Նկատի ունեցեք, որ այս դեպքում համակարգը վերադարձնում է զանգվածի տարրը 3 ինդեքսով, և ըստ հերթականության, սա զանգվածի չորրորդ տարրն է:
Որոշ հավաքածուների համար կա նաև շարքի համար հասկացությունը: Տողի համարը սկսվում է մեկով: Օրինակ, աղյուսակային հատվածի համար կա այնպիսի հատկություն, ինչպիսին է տողի համարը: Կարևոր է հիշել, որ եթե մենք գիտենք տողի համարը և ցանկանում ենք հղում կատարել ինդեքսին, ապա միավորի արժեքը պետք է օգտագործվի որպես ինդեքս: քիչ թիվտողեր.
Գծի համար հասկացությունը գոյություն չունի բոլոր հավաքածուների համար, բայց հիմնականում նրանց համար, որոնք կարող են ցուցադրվել օգտագործողի միջերեսում:
Բոլոր հավաքածուների համար օգտագործվում է հավաքածուի տարրերի անցում: Շրջանցումը հնարավոր է երկու եղանակով. ցիկլ Forև ցիկլ յուրաքանչյուրի համար.
Ընդհանուր հավաքածուների մեծ մասի համար կիրառվում են հետևյալ մեթոդները՝ Հաշվել, Ցուցանիշ, Ավելացնել, Տեղադրել, Ջնջել և Գտնել:
Count-ը ֆունկցիա է, որը վերադարձնում է հավաքածուի տարրերի քանակը: Այն կարող է օգտագործվել հանգույցից առաջ Համար, ինչպես ցույց է տրված նկարում:
Index մեթոդը գոյություն չունի բոլոր հավաքածուների համար, այլ միայն նրանց համար, որոնց տարրերը կարող են հղում կատարել: Օրինակ է Արժեքների աղյուսակ.
Արժեքների աղյուսակտողերի հատուկ հավաքածու է, տողերը կարող են պարունակել տարբեր սյունակներ տարբեր տեսակներարժեքներ։
Յուրաքանչյուր տող անկախ սուբյեկտ է: Դուք կարող եք ստանալ դրա հղումը, այս տողի միջոցով կարող եք մուտք գործել այս տողի սյունակների արժեքները:
Index մեթոդը թույլ է տալիս որոշել, թե որ ինդեքսն է համապատասխանում տվյալ տողին (այսինքն՝ աղյուսակում տողի ընթացիկ դիրքը): Ինդեքսի արժեքները սկսվում են զրոյից:
Այս հավաքածուին նոր արժեքներ ավելացնելու մեթոդներ գոյություն ունեն գրեթե ցանկացած ընդհանուր հավաքածուում: Նկարը ցույց է տալիս, թե ինչպես լրացնել զանգվածը 0-ից 10 արժեքներով երկու եղանակով:
Զանգվածին տարր ավելացնելու համար մենք կարող ենք օգտագործել մեթոդը Ավելացնել, փակագծերում նշեք ավելացված արժեքը։ Այս դեպքում արժեքը կավելացվի ցանկի վերջում, այսինքն. Վերջին դիրքի պատճառով զանգվածը անընդհատ կավելանա։
Մեկ այլ մեթոդ, որը թույլ է տալիս արժեքներ ավելացնել հավաքածուին, մեթոդն է Տեղադրեք. Այն տարբերվում է մեթոդից Ավելացնելորպեսզի կարողանաք նշել, թե որտեղ տեղադրվի ավելացված տարրը:
Շարահյուսություն: Տեղադրեք (,)
Առաջին պարամետրը նշում է այն ինդեքսը, որի մեջ կտեղադրվի նոր արժեքը: Նրանք. մենք, օրինակ, կարող ենք նշել, որ յուրաքանչյուր արժեք պետք է տեղադրվի ցուցակի սկզբում (երկրորդ եղանակը վերևի նկարում):
Մեթոդն օգտագործվում է հավաքածուից տարրերը հեռացնելու համար: Ջնջել. Ջնջել մեթոդում ինդեքսով նշվում է, թե որ տարրը կջնջենք։
Շարահյուսություն: Ջնջել ()
Օգտագործման օրինակ. OurArray.Delete(5);
Հարկ է նշել, որ այն հավաքածուների համար, որտեղ տողերը ներկայացնում են անկախ էություն (օրինակ՝ համար Սեղանի արժեքներ), կարող ենք օգտագործել նաև ստանալ ինդեքս մեթոդը՝ հետագայում տվյալ տողը հեռացնելու համար։
Գրեթե բոլոր հավաքածուները ունեն արժեք գտնելու մեթոդ. Գտեք. Մեթոդին փոխանցվում է այն արժեքը, որը մենք ցանկանում ենք գտնել: Որոշ հավաքածուներում կարող եք ցանկացած սահմանափակում դնել:
Օրինակ՝ մեջ Արժեքների աղյուսակկարող եք նշել այն տողերը, այն սյունակները, որոնցում ցանկանում եք որոնել:
Եթե արժեքը գտնվի, ապա այս մեթոդը վերադարձնում է ինդեքսը կամ կոնկրետ տողը: Եթե արժեք չի գտնվել, վերադարձվում է տեսակի արժեք: Չսահմանված. Երբ կիրառվում է զանգվածի վրա, վերադառնում է Ցուցանիշ, կամ արժեքը Չսահմանված.
Օգտագործման օրինակ. OurVariable = OurArray.Find(8);
Ընդհանուր հավաքածուները կարող են շատ արագ մաքրվել, այսինքն. հեռացնել բացարձակապես բոլոր տարրերը. Դրա համար օգտագործվում է մեթոդը պարզ (), որը հեռացնում է զանգվածի տարրերը, տողերը Սեղանի արժեքներ, կամ այլ հավաքածուների տվյալներ։
Լրացուցիչ մեթոդներ զանգվածի համար
Մեթոդ Bboundary ()վերադարձնում է տարրերի թիվը հանած մեկ: Նրանք. եթե մենք օգտագործում ենք հանգույց Համար, ապա Քանակ մեթոդի փոխարեն կարող ենք անմիջապես օգտագործել մեթոդը Սահմանը().
Մասնավորապես, NumberInArray փոփոխականը կարող էր տարբեր կերպ սահմանվել.
NumberInArray = OurArray.InBorder();
Այնուհետև, ցիկլը նկարագրելիս չպետք է հանել այս փոփոխականից:
Set մեթոդը թույլ է տալիս արժեք վերագրել Array տարրին ըստ ինդեքսի:
Շարահյուսություն: Տեղադրել (,)
Օրինակ: OurArray.Set(2,8);
Այլընտրանքային տարբերակ. OurArray = 8;
Դուք կարող եք օգտագործել մեթոդը Array-ի համար Ստացեք, արժեքն ինդեքսում կարդալու համար՝ առանց քառակուսի փակագծերի օգտագործման։
Շարահյուսություն: Ստանալ ()
Օրինակ: OurVariable = OurArray.Get(2);
Այլընտրանքային տարբերակ. OurVariable = OurArray;
Ունիվերսալ հավաքածուի կառուցվածք
Կառուցվածքը, ինչպես զանգվածը, կարող է ունենալ անսահմանափակ թվով տարրեր, սակայն տարրի բովանդակությունը տարբերվում է զանգվածից։
Կառուցվածքը հավաքածու է, որի յուրաքանչյուր արժեք բաղկացած է զույգից։ Զույգի առաջին տարրը կոչվում է Բանալի. Զույգի երկրորդ տարրն է Իմաստը.
Բանալիխիստ տողային տվյալների տեսակ է, որը նկարագրում է արժեքը: Օրինակ, բանալի«Կոդը» կարող է համապատասխանել 113 արժեքին; բանալի«Անուն» նշանակում է «Վասյա»: Ինքն արժեքի վրա տվյալների տիպի սահմանափակում չկա:
Կառուցվածքը շատ հարմար է օգտագործել, եթե ցանկանում ենք ստեղծել պարամետրերի ցանկ։ Եթե սա Կառուցվածքկանչեց Մեր Կառուցվածքը, ապա դրա երկու արժեքներին կանդրադառնանք հետևյալ կերպ. OurStructure.Code և OurStructure.Name:
Նման բողոքարկումը շատ ավելի հարմար է, քան եթե մենք սահմանեինք զանգվածի բոլոր պարամետրերը և մուտք գործեինք դրանք ըստ ինդեքսների:
Կառուցվածքը ծրագրային կոդը դարձնում է ընթեռնելի (հասկանալի): Կառուցվածքն օգտագործվում է բավականին հաճախ, շատ ավելի հաճախ, քան Array-ը։
Այն օգտագործվում է որոշ պարամետրեր նկարագրելու համար, որոնք հաճախ բավականին մեծ են բոլոր ալգորիթմներում։
Բացի այդ, Structure-ն օգտագործվում է, եթե ընթացակարգը և ֆունկցիան պարունակում են մեծ թվով անցած պարամետրեր:
Այնուհետև շատ ավելի հարմար է բոլոր պարամետրերը գրել Structure-ում և փոխանցել այն: Նրանք. կա ընթացակարգերի և գործառույթների պարամետրերի «փաթեթավորում»:
Առանձին-առանձին պետք է նշել, որ ինչպես բանալիԿառուցվածքում բացարձակապես որևէ տող չի կարող հայտնվել: Կիրառվում են որոշակի սահմանափակումներ։
Բանալիպետք է հանդես գա որպես նույնացուցիչ: Սա նշանակում է, որ ներս բանալիչպետք է բացատներ չլինեն և այն չի կարող սկսվել թվով:
Թույլատրելի մեկնարկ բանալիտառով կամ ընդգծումով։ Այս կերպ, Բանալիպետք է բավարարի նույնացուցիչներ ստեղծելու պահանջները:
Եկեք նկատենք, թե ինչպես է կառուցվածքը տարբերվում զանգվածից: Կառուցվածքն ունի մեթոդ Տեղադրեք, Array-ն ունի տեղադրման երկու եղանակ. Տեղադրեք(որոշակի պաշտոնի) և Ավելացնել(ցուցակի վերջում): Զանգվածում բոլոր տարրերը դասավորված են:
Կառուցվածքը մի տեսակ չկարգավորված հավաքածու է: Այդ իսկ պատճառով Struct-ի համար կա միայն ներդիրի մեթոդ:
Արժեքը տեղադրվում է ոչ թե կոնկրետ դիրքում, այլ նշված հավաքածուի մեջ: Կառուցվածքը չի կարող հղում կատարել ինդեքսով, ինչպես մյուս ընդհանուր հավաքածուները:
Կառուցվածքի տարրերը հիշատակվում են միայն Բանալի անունով: Այնուամենայնիվ, For each of loop-ը նույնպես աշխատում է Structure-ի համար, բայց դուք չպետք է ապավինեք Structure-ի տարրերի հերթականությանը:
Կառուցվածքը ստեղծվում է այնպես, ինչպես մյուս ընդհանուր հավաքածուները՝ օգտագործելով Նոր կոնստրուկտորը՝ նշելով Structure-ի տվյալների տեսակը:
Ինչպես զանգվածը, այնպես էլ Struct-ի կոնստրուկտորը կարող է ունենալ պարամետրեր։ Նրանք. հնարավոր է նկարագրել հենց Կառուցվածքի բովանդակությունը՝ օգտագործելով կոնստրուկտոր:
Ի տարբերություն զանգվածի, որտեղ դուք կարող եք պարզապես նշել տարրերի քանակը բոլոր չափումների համար, Structure-ում հնարավոր է ինքնուրույն սահմանել բովանդակությունը:
Օրինակ: OurStructure = New Structure ("Code, Name", 133, "Vasya");
Նախ ստեղներով բաժանված են ստեղների անունները, այնուհետև, համապատասխանաբար, նույն հաջորդականությամբ՝ պարամետրերի արժեքները:
Կառուցվածքին նոր արժեք ավելացնելու համար կա մեթոդ Տեղադրեք, որը տեղադրում է նոր զույգ (Բանալին և արժեք):
Օրինակ: OurStructure.Insert("Ընտանիքի անդամներ",3);
Կառուցվածքը բնութագրվում է մեկ այլ մեթոդով, որը բավականին հաճախ օգտագործվում է. Սա է մեթոդը Սեփականություն.
Օգտագործելով այս մեթոդը, դուք կարող եք հասկանալ, թե կա արդյոք այս Կառուցվածքում այնպիսի տարր, որի համար բանալին ունի այս և այն անուն:
Եթե այդպիսի տարր կա, համակարգը կվերադարձնի True, հակառակ դեպքում՝ False:
Օրինակ՝ արտահայտությունը OurStructure.Property («Ընտանիքի անդամներ»)հավասար կլինի True-ին: Այս մեթոդը բավականին հաճախ օգտագործվում է Կառուցվածքի վերլուծության ժամանակ:
Ինչ վերաբերում է ցանկացած ունիվերսալ հավաքածուի, ապա թույլատրվում է մուտք գործել Կառուցվածքի հատկությունները ըստ ինդեքսների: Բայց Structure-ի ինդեքսը լարային արժեք է:
Օրինակ: Հաշվետվություն (Մեր կառուցվածքը[«Ընտանիքի անդամներ»]);
Այնուամենայնիվ, չպետք է մոռանալ, որ Structure-ը օբյեկտների պատվիրված հավաքածու չէ, այդ իսկ պատճառով մուտքը 0, 1, 2 ինդեքսներով անընդունելի է:
Արժեքների ընդհանուր հավաքածուի ցուցակ
Արժեքների ցանկցանկացած տվյալների տիպի տարրերի գծային ցանկ է:
Յուրաքանչյուր տարր բաղկացած է մի քանի արժեքներից: Սխեմատիկորեն արժեքների ցանկը կարող է ներկայացվել որպես չորս սյունակներով ցուցակ:
Առաջին սյունակ - նշագծել. Այն ունի բուլյան տվյալների տեսակ և թույլ է տալիս օգտվողին կամ ստուգել վանդակները կամ հեռացնել դրանք:
Մյուս սյունակը նկար է, որը կարող է ինչ-որ կերպ տեսողականորեն պատկերել տրված տարր, այսինքն. համապատասխանեցնել այս տողը ցանկացած նկարի հետ:
Երրորդ սյունակը ինքնին պահված արժեքն է, այսինքն. սա ցանկացած տվյալների տեսակ է, և այն կարող է տարբեր լինել տարբեր տողերում:
Չորրորդ սյունակը տեսարանն է, այսինքն. սա լարային նկարագրություն է տրված արժեք. Տեսարանը կցուցադրվի օգտվողին, երբ նա դիտի այս տարրը: Այս դեպքում, եթե դիտումը կարգավորված չէ, համակարգը կփորձի դիտումներ ստանալ այս դիրքում պարունակվող տարրի համար:
Արժեքների ցանկ- սա այն օբյեկտն է, որի հետ օգտագործողը կարող է տեսողականորեն աշխատել: Նրանք. Արժեքների ցանկկարող է ցուցադրվել ձևի վրա:
Օգտագործողը կարող է դրա հետ կատարել որոշ գործողություններ: Բացի այդ, Արժեքների ցանկկարելի է եզրակացնել ինքնուրույն՝ օգտագործելով մեթոդները, այսինքն. ցուցադրել էկրանին ալգորիթմի ինչ-որ ճյուղում (բացառությամբ սերվերի կոդի), որպեսզի օգտատերը ընտրի ինչ-որ տող կամ որոշ նշագրեր դնի:
Եկեք գտնենք Արժեքների ցանկ sitax-ում օգնական. Կոնստրուկտոր Արժեքների ցանկպարամետրացված չէ (կանխադրված արժեքներ չեն կարող սահմանվել):
Կան մեթոդներ, ինչպիսիք են.
- Տեղադրել(,) ;
- Ավելացնել (,);
- Քանակ ();
- Ինդեքս ().
Կան նաև հատուկ մեթոդներ, օրինակ. UnloadValues (). Սա ստեղծում է զանգված, որի մեջ պատճենվում է արժեքների ցանկը: Օրինակ:
ArrayElements = ListPriceTypes.UnloadValues();
Կա նաև հակադարձ մեթոդ.
PriceTypeList.LoadValues (ElementsArray);
Կան որոնման մեթոդներ.
FindByValue(); FindByIdentifier():
Կա պատճենման մեթոդ.
CopyList = ListPriceTypes.Copy();
Այս մեթոդը նախատեսված է կրկնօրինակով ինչ-որ փոփոխություն կատարելու համար:
Կան մեթոդներ.
SortByValue();
SortByView ().
Մեթոդներ Ընտրել տարր (,)և MarkItems ()զանգահարեք մոդալ երկխոսության տուփ, որը դադարեցնում է ալգորիթմի կատարումը, մինչև օգտագործողը փակի այս պատուհանը:
Այս մեթոդները կոնֆիգուրացիայի հատկություններում օգտագործելու համար Մոդալների օգտագործման ռեժիմպետք է սահմանվի Օգտագործեք.
Կառավարվող հավելվածի մոդուլից կանչված կոդի օրինակ՝
Ցուցադրել այս կոդը օգտագործողի ռեժիմում (մոդալ երկխոսության տուփ):
Ստորև Արժեքների ցանկօգտագործվում է որպես ձևի հատկանիշի տվյալների հասանելի տեսակ: Ստեղծեք մշակման ձևի համար նոր հենարաններ, սահմանեք դրա տեսակը Արժեքների ցանկև ցուցադրել այն ձևաթղթում:
Մենք նոր թիմ ենք ստեղծում Խանութ Նվերներ, փոխանցեք այն ձևաթղթին և դրա համար սահմանեք գործողությունների մշակող։
Օգտվողի ռեժիմում, երբ սեղմում եք «Լրացրեք նվերներ» կոճակը մշակման ձևում, կհայտնվի լրացված ցուցակը:
Ցանկության դեպքում ցանկը կարելի է խմբագրել՝ ավելացնել որոշ տարրեր, հեռացնել մի քանիսը:
Համընդհանուր հավաքածուի համապատասխանություն
Այս հավաքածուն շատ նման է Կառուցվածք. Ճիշտ այնպես, ինչպես Struct-ը, Match-ը արժեքների մի շարք է, որը բաղկացած է բանալիից և հենց արժեքից:
Հիմնական տարբերությունն այն է, որ տվյալների ցանկացած տեսակ կարող է նշվել որպես բանալի, ինչպես նաև արժեք: Հաշվի առնելով այս հատկանիշը, անհրաժեշտ է մուտք գործել համընկնումի արժեքը ըստ ինդեքսի, հիմնական արժեքը նշվում է որպես ինդեքսի արժեք:
Բանալին կարող է լինել այլ տվյալների տեսակ, քան տող: Matching-ի հետ աշխատելու հատկությունները և մեթոդները գրեթե նույնն են, ինչ Structure-ում:
Match Constructor-ը, ի տարբերություն Struct-ի, չի պարունակում պարամետրեր նշելու հնարավորություն:
Օգտագործման օրինակ.
Նամակագրությունը օգտակար է, երբ անհրաժեշտ է կապել ցանկացած երկու կառույց: Օրինակ, աղյուսակային մասի յուրաքանչյուր տող պետք է համընկնի արժեքների աղյուսակի տողի հետ:
Այս դեպքում աղյուսակային հատվածի տողը օգտագործվում է որպես Matching ստեղն և նշվում է համապատասխան արժեքը:
Մեթոդից բացի Match հավաքածուի մեջ տարրեր ներդնելիս Տեղադրել (,)Արժեքը տեղադրելու ևս մեկ տարբերակ կա, դա սովորական նշանակման օպերատորի օգտագործումն է:
Օրինակ: OurMatch = Նոր համընկնում;
Համապատասխանում = 999;
Նրանք. եթե տարրը չկար հավաքածուում, ապա այն կավելացվի հանձնարարականի օպերատորի միջոցով, իսկ առկայության դեպքում այն կթարմացվի:
Սա տարբերվում է Structure-ից:
Ընդհանուր հավաքածուի արժեքների աղյուսակ
Արժեքների աղյուսակաղյուսակ է կամայական թվով տողերով և կամայական թվով սյունակներով: Խաչմերուկը կարող է պահել ցանկացած տվյալների տիպի արժեքներ: Անհրաժեշտության դեպքում սյունակները կարող են մուտքագրվել, այսինքն՝ որոշել, թե որ սյունակում է պահվում տվյալների որ տեսակը:
Դուք կարող եք սյունակները թողնել անտիպ, այնուհետև նույն սյունակը տարբեր տողերում կարող է պահել տարբեր տեսակի արժեքներ:
Տարբերություններ Սեղանի արժեքներ 2D զանգվածից.
- սա օբյեկտ է, որի հետ օգտագործողը կարող է աշխատել (արժեքների աղյուսակը կարող է ցուցադրվել էկրանին, օգտագործողը կարող է լրացնել այն, ապագայում մուտքագրված տվյալները կարող են կարդալ);
- արագ որոնման ինդեքսների կառուցում;
- կլոնավորում, ամբողջ սյունակը լրացնելով որոշակի արժեքով, բեռնաթափելով բոլոր սյունակները զանգվածի մեջ:
Արժեքների աղյուսակօգտագործվում է որպես տեղեկատվության պահպանման մի տեսակ բուֆեր: Արժեքների աղյուսակվերադարձվում և ընդունվում է որպես պարամետր համակարգի բազմաթիվ մեթոդներով: Հնարավոր է ստեղծել հարցում արժեքների աղյուսակում:
Այսպիսով, Արժեքների աղյուսակբաղկացած է մի շարք տողերից և մի շարք սյուներից: Երկու տողերը և սյունակները հավաքածուներ են:
Նրանք. հավաքածուի ներսում Արժեքների աղյուսակկա ևս երկու հավաքածու։ Եկեք դիմենք շարահյուսության օգնականին և գտնենք Արժեքների աղյուսակ.
Աջակցվող տվյալների տեսակները՝ ինքն իրեն Արժեքների աղյուսակ, որը բաղկացած է լարերից։ Յուրաքանչյուր տող ներկայացված է տվյալների տեսակով RowTableValues, որն ունի իր սեփական հատկություններն ու մեթոդները։ Հասանելի է CollectionColumns TableValuesունի նաև որոշակի հատկություններ.
Կարևոր կետ! Գործընթացը, որը առաջացնում է Արժեքների աղյուսակ, պետք է կազմի & OnServer.
Նախքան սկսեք աշխատել Արժեքների աղյուսակ, դուք պետք է որոշեք, թե որ սյունակներն այն կպարունակի (այսինքն՝ ստեղծեք դրանք): Շարահյուսություն:
Ավելացնել (,)
(ըստ ցանկության)
Տեսակը՝ լարային:
(ըստ ցանկության)
Տեսակ. Նկարագրություն Տեսակներ
(ըստ ցանկության)
Տեսակը՝ լարային:
(ըստ ցանկության)
Տեսակ՝ համար։
Օրինակ:
Այս ընթացակարգը կանչելու համար մենք կօգտագործենք հրամանը.
Նկարագրության մեջ Սեղանի արժեքներքանի որ հավաքածուի տարրերը հենց RowsTableValues.
Ի տարբերություն սյունակների, որոնք բաղկացած են միայն հատկություններից (Անուն, տեսակ, վերնագիր, լայնություն), in RowTableValuesկան և՛ հատկություններ (հղում ըստ սյունակի անունով), և՛ մեթոդներ (կարող եք ստանալ և սահմանել արժեք, աշխատել սեփականատերերի հետ):
Աղյուսակում նոր տող ավելացնելու համար անհրաժեշտ է օգտագործել նաև մեթոդը Ավելացնել (), կամ Տեղադրել (). Երկրորդ դեպքում դուք պետք է նշեք, թե որ դիրքում պետք է տեղադրվի պահանջվող տողը։
Սյունակին արժեք նշանակելու համար մենք այն նշում ենք սյունակի անունով կամ ինդեքսով (օգտագործելով քառակուսի փակագծեր), որոնք բաժանված են կետով:
Լրացնելու համար Սեղանի արժեքներկարող են օգտագործվել հետևյալ մեթոդները.
պարզ ()- հեռացնել բոլոր տողերը Սեղանի արժեքներ.
FillValues (,)- թույլ է տալիս լրացնել բոլոր սյունակները կամ ընտրված սյունակները մեկ արժեքով:
LoadColumn(,)– բեռնում է սյունակ զանգվածից:
UnloadColumn()– բեռնաթափում է սյունակը զանգվածի մեջ:
Վերջին երկու մեթոդները օգտակար են, երբ անհրաժեշտ է սյունակ տեղափոխել արժեքների մի աղյուսակից մյուսը:
Պատճենել (,)- թույլ է տալիս ստեղծել նոր աղյուսակ՝ հիմնվելով գոյություն ունեցող աղյուսակի վրա Արժեքների աղյուսակ, միաժամանակ նշելով ոչ բոլոր տողերն ու սյունակները, այլ դրանցից միայն մի քանիսը: Վերադարձի արժեք - Արժեքների աղյուսակ.
Դուք կարող եք պատճենել կառուցվածքը Սեղանի արժեքներ. Դրա համար կա համապատասխան մեթոդ. CopyColumns (). Մենք դատարկ կստանանք Արժեքների աղյուսակցանկալի կառուցվածքով։
AT Արժեքների աղյուսակկա մեթոդ ընդհանուր (). Դուք կարող եք նշել այն սյունակը, որտեղ ցանկանում եք գումարել թվային արժեքները: Ինչ վերաբերում է աղյուսակում նախկինում ցուցադրված ծածկագրին, կարող եք հաշվարկել արժեքը. TK.Total («Գումար»).
AT Արժեքների աղյուսակմեթոդով հնարավոր է խմբավորել (փլուզել) թվային արժեքները որոշակի սյունակների նույն արժեքներով Ծալել (,).
Ինչ վերաբերում է աղյուսակում նախկինում ցուցադրված ծածկագրին, կարող եք հաշվարկել արժեքը. TK.Collapse («Շաբաթվա օր», «Գումար»):
Արժեքների աղյուսակկարող է ցուցադրվել օգտատիրոջ էկրանին, որպեսզի կարողանաք դրա հետ ցանկացած գործողություն կատարել: Բայց ի տարբերություն Արժեքների ցանկ-ից ծրագրի կոդըդուք չեք կարող պարզապես զանգահարել էկրանի սեղանին:
Ցուցադրել Արժեքների աղյուսակէկրանին ստեղծեք ձևի հատկանիշ և դրան նշանակեք տվյալների տեսակ Արժեքների աղյուսակ.
Դրանից հետո ստացված աղյուսակը պետք է ցուցադրվի ձևաթղթում:
Ձևի մոդուլում, նախկինում կազմված ալգորիթմի վերջում (Արժեքների աղյուսակ ստեղծելու ընթացակարգում) ավելացրեք.
ValueVFormData (TK, Աղյուսակ);
Ընդհանուր արժեքների հավաքածուի ծառ
բազմակողմանի հավաքածու, որը շատ նման է Արժեքների աղյուսակ. Աղյուսակից տարբերությունն այն է, որ ծառի տողերը կարող են ենթարկվել միմյանց, այսինքն. կարող է ձևավորվել ինչ-որ հիերարխիա:
Այն կարող է ցուցադրվել նաև էկրանին: Արժեքի ծառը բացահայտորեն բաղկացած է տողերի հավաքածուից և սյունակների հավաքածուից: Ծառի մեջ կա երկու հատկություն՝ տողեր և սյունակներ:
Քանի որ տողերը կարող են ենթարկվել միմյանց, ապա յուրաքանչյուր տողի համար կարելի է նշել Ծնող, ինչպես նաև դրան ենթակա տողեր:
Եկեք ստեղծենք համապատասխան Tree հրամանը և դրա մշակման ընթացակարգը:
Եկեք ստեղծենք որոնցում կա մեկ մայր և երկու ստորադաս տող:
Ստեղծեք ձևի հատկանիշ ԴերԶն(տվյալների տեսակը - Արժեքների ծառ):
Այս հատկանիշի համար մենք կստեղծենք տարի և ամիս սյունակներ:
Տեղափոխեք համապատասխան տարրը ԴերԶնձևին։
Վերջում Գործընթացներ TreeOnServer()ավելացնել:
ValueVFormData (TreeZn, DerZn);
Եկեք ստուգենք, թե ինչ է տեղի ունեցել օգտագործողի ռեժիմում:
Կոճակով Ավելացնելկարող եք նոր տողեր ավելացնել: Նրանք կարող են նաև հիերարխիա ձևավորել։
Արժեքի ծառի բոլոր տարրերի վրա կրկնելու համար մենք պետք է օգտագործենք ռեկուրսիա, այսինքն. ինքն իրենից ընթացակարգ կանչելը. Օրինակ, արժեքների ծառի մշակումը կարող է այսպիսի տեսք ունենալ.
Սա ավարտում է մեր առաջին ծանոթությունը ունիվերսալ հավաքածուներին:
Հաջորդ հոդվածում մենք կանդրադառնանք, թե ինչ կարևոր մեխանիզմ կարող է օգտագործել ծրագրավորողը ծրագրի կոդից բառարանի տարր մուտք գործելը պարզեցնելու համար:
