Այս բաժնում մենք կծանոթանանք 1C լեզվի տվյալների նոր տեսակի հետ, որը կոչվում է ListValues.
Արժեքների ցանկզանգված է, բայց մեծ հնարավորություններով։ Եվ եթե այո, ապա այն նաև տվյալների հավաքածու է, և դուք կարող եք դրա մեջ տեղադրել թվերի հավաքածու.
// ստեղծել է արժեքների ցանկ
List.Add(23);
Մինչ այժմ ամեն ինչ շատ նման է զանգվածի, այնպես չէ՞: Բայց անցնենք առաջ։ Այժմ օգտագործողին այս թվերը ցուցադրելու համար մենք գրում ենք.
// շրջանցել ցանկի յուրաքանչյուր տարրի միջով For Every Element From List Loop Report (Element.Value);
// ցուցադրել EndCycle տարրի արժեքը;
Եվ ահա առաջին տարբերությունը. Կանոնավոր զանգվածի տարրերը հենց թվերն են: Եվ մուտք դեպի տարրի ընթացիկ արժեքը Ցուցակմենք օգտագործում ենք տարբերակը Իմաստը, օգտագործելով կոնստրուկցիան Տարր. Իմաստը.
Դիտարկենք մի քանի լրացուցիչ հնարավորություններ Արժեքներ.
Կարող է տեսակավորել
Օրինակ, մենք հեշտությամբ կարող ենք տեսակավորել արժեքների ցանկը: Ցանկը կարող է դա անել ինքնին.
List.SortByValue (SortDirection.Age); Սովորական զանգվածի դեպքում մենք պետք է իրականացնեինք տեսակավորման ալգորիթմներից մեկը (օրինակ՝ «փուչիկը»)։
Կարող է որոնել
Արժեքների ցանկը կարող է ինքնուրույն որոնել իր տարրերը: Ենթադրենք, մենք ուզում ենք պարզել, թե արդյոք օգտագործողի կողմից մուտքագրված համարը առկա է մեր ցուցակում.
Մուտքագրեք համարը (համարը); // մուտքագրել է թիվ FoundElement = List օգտվողից: FindByValue (համար);
Եթե FoundItem = Undefined, ապա OpenValue ("Number " + Number + " չի գտնվել ցանկում!"); Հակառակ դեպքում
OpenValue("Number " + Number + " առկա է ցանկում: Ահա այն." + FoundElement.Value);
վերջԵթե; ListValues
Աջակցում է տեղադրմանը և ջնջմանը
Արժեքների ցանկը, ինչպես զանգվածը, աջակցում է տարրերի տեղադրմանը և հեռացմանը.
Ցուցակ. Ներդիր (0, 1000);
// ցանկի հենց սկզբում տեղադրեք հազարը List.Delete(O); // և անմիջապես հեռացրեք այն ցուցակից: Տեղադրել(List.Quantity(), 13);
// ցանկի վերջում տեղադրեք 13 Հաշվետվություն (List[List.Quantity() - 1]);
// ցուցադրել ցանկի վերջին տարրը (13)
Աջակցում է քառակուսի փակագծերին
Ինչպես արդեն հասկացաք, ցուցակի տարրերի համարակալումը նույնպես սկսվում է զրոյից, և մենք կարող ենք մուտք գործել ցանկացած տարր իր ինդեքսով՝ օգտագործելով քառակուսի փակագծերը.
Հաշվետվություն (List.Value); // ցուցադրել ցանկի երկրորդ տարրը Այսպիսով, մենք կարող ենք անցնել ցանկի բոլոր տարրերը այսպես.
A = 0-ի համար ըստ List.Quantity() - 1 Loop Report(List[A].Value);
End Cycle;
Կարող է ստեղծել իր կրկնօրինակը
Արժեքների ցանկն ունի ընդամենը մի հիանալի հատկություն՝ այն կարող է ստեղծել իր կրկնօրինակը.
ListCopy = List.Copy();
// պատրաստել է ցուցակի պատճենը // այժմ մենք կարող ենք ապահով կերպով փոխել Ցուցակի պատճենը // մինչդեռ բնօրինակ ցուցակը չի փոխի Ցուցակի պատճենը: Արժեք = 123456;
Կարող է վերածվել զանգվածի
Եվ վերջապես, ցանկացած պահի կարող եք հեշտությամբ լցնել ցանկի բոլոր տարրերը զանգվածի մեջ.
ArrayNumbers = Ցուցակ: UnloadValues ();
// նետվել է զանգվածի մեջ
A = 0-ի համար ըստ ArrayNumber.Quantity() - 1 ցիկլ
Հաշվետվություն (ArrayNumbers[A]); // կարիք չկա նշելու // տարբերակ Արժեք
End Cycle;
Այս միավորի նյութը կիրառելու և համախմբելու համար խորհուրդ է տրվում կատարել հետևյալ առաջադրանքը.
Անհրաժեշտ է օգտատիրոջից մուտքագրել 5 թիվ, գտնել դրանցից ամենամեծն ու ամենափոքրը և ցուցադրել օգտատիրոջը։ Լուծումը պետք է օգտագործի արժեքների ցանկ:
Լուծում
Ցուցակ = New ValueList;
// ստեղծեց արժեքների ցանկ A = 1-ից 5 ցիկլի համարը = 0;
Մուտքագրեք համարը (համարը); // մուտքագրեք թիվ օգտվողի ցանկից:Ավելացնել(համար); // և ավելացրեք այն EndCycle ցանկում; // և այլն 5 անգամ
// տեսակավորել թվերի ցանկը
Ցուցակ. Տեսակավորել ըստ արժեքի (SortDirection.Age);
// տեսակավորումից հետո ցուցակի առաջին տարրը // ամենափոքր տարրն է, իսկ վերջինը՝ ամենամեծ OpenValue("Smallest element" + List +
", իսկ ամենամեծը " + List[List.Quantity() - 1]);
Ամբողջական շարահյուսություն (սեղմեք ընդլայնելու համար)
ListValues
Նկարագրություն:
Արժեքների ցանկը տվյալների բազայում չպահված օբյեկտ է, որը թույլ է տալիս կառուցել արժեքների դինամիկ հավաքածուներ ինտերֆեյսի խնդիրների լուծման համար և շահարկել դրանք (ավելացնել, խմբագրել, ջնջել տարրեր, տեսակավորել): Այն կարող է լրացվել ցանկացած տեսակի արժեքներով, այսինքն. Մեկ ցուցակում պահվող արժեքների տեսակները կարող են տարբեր լինել: Այս օբյեկտի օգտագործման օրինակներից մեկը բարդ ալգորիթմի միջոցով ստեղծված հնարավոր փաստաթղթերի ցանկից կոնկրետ փաստաթղթի ընտրության կազմակերպումն է:
Հավաքածուի իրեր. ValueListElement
Հնարավոր է, որ օբյեկտը օպերատորի միջոցով շրջանցի հավաքածուն Յուրաքանչյուրի համար... From... Cycle. Անցումը ընտրում է հավաքածուի տարրերը:
Հնարավոր է մուտք գործել հավաքածուի տարր՝ օգտագործելով [...] օպերատորը: Տարրի ինդեքսը փոխանցվում է որպես արգումենտ ( համարակալումը 0-ից).
Հատկություններ:
Մեթոդներ:
Դիզայներներ.
| &OnClient ընթացակարգի կատարման կոդ (հրաման) /// Ինչպես ստեղծել արժեքների ցուցակ 1s 8.3, 8.2-ումՑուցակ = New ValueList; /// Ինչպես ավելացնել տարր 1s 8.3, 8.2 արժեքների ցանկում // ավելացնել մեթոդի պարամետրեր.// - իմաստ // - կատարում // - նշան (պարտադիր) // - նկար (պարտադիր)Ցուցակ. Ավելացնել (1980, // տարրի արժեքը «Վասյայի ծննդյան տարին».// կատարումը); Ցուցակ. Ավելացնել (1985,) ; «Յուլիայի ծննդյան տարին»// արժեքները կարող են լինել տարբեր տեսակի Ցուցակ. Ավելացնել(«Պոլինա», «Երեխայի անուն»); /// Ինչպես տեղադրել տարր 1s 8.3, 8.2 արժեքների ցանկում // ներդիր թիվ 2 դիրքում (տարրերը համարակալված են 0-ից սկսած) // տարր 2010 արժեքով և ներկայացուցչությամբ// «Տարին, երբ ծնվեց նրանց համատեղ դուստրը» Ցուցակ. Ներդիր (2, 2010 թ.,) ; «Տարին, երբ ծնվեց նրանց համատեղ դուստրը»./// Ինչպես շրջանցել արժեքների ցանկի տարրերը 1s 8.3, 8.2-ում Ցուցակի հանգույցից յուրաքանչյուր տարրի համար (Element. Representation + ": " + String(Element. Value) ) ; Վերջնական ցիկլ;/// Ինչպես մաքրել արժեքների ցանկը 1s 8.3, 8.2 Ցուցակ. Մաքրել (); Ցուցակ. Ավելացնել («երկուշաբթի»); Ցուցակ. Ավելացնել («Երեքշաբթի»); Ցուցակ. Ավելացնել («Չորեքշաբթի»); /// Ինչպես պարզել արժեքների ցանկի տարրերի քանակը, ինչպես նաև /// ստացեք ցուցակի տարրը իր ինդեքսով 1s 8.3, 8.2-ում// զրոյից համարակալում Համար Index = 0 Ըստ Ցուցակ. Քանակ () - 1 ցիկլի հաշվետվություն (Ցուցակ[Ինդեքս]) ; Վերջնական ցիկլ;/// Ինչպես գտնել ցուցակի տարրը ըստ արժեքի 1s 8.3, 8.2-ում ValueTuesday = Ցուցակ: FindByValue («Երեքշաբթի»);/// Ինչպես պարզել տարրի ինդեքսը ցուցակում 1s 8.3, 8.2-ում Հաշվետվություն(Ցուցակ. Ինդեքս(ValueTuesday) ) ; // 1, քանի որ համարակալումը սկսվում է զրոյից /// Ինչպես տեսակավորել ցուցակն ըստ իր արժեքների 1s 8.3, 8.2// էր՝ երկուշաբթի, երեքշաբթի, չորեքշաբթի Ցուցակ. SortByValue (SortDirection.Descending) ; // դարձավ՝ չորեքշաբթի, երկուշաբթի, երեքշաբթի /// Ինչպես հեռացնել տարրը արժեքների ցանկից 1s 8.3, 8.2-ում // հեռացնել առաջին տարրը // պարամետր՝ ցուցակի տարր// կամ տարրի ինդեքս // Դուք կարող եք անել այս ցանկը: Ջնջել(Ցուցակ[ 0 ]) ; // կամ այդպես // List.Delete(0); /// Ինչպես տեղափոխել արժեքների ցանկի տարրը 1s 8.3, 8.2-ում // զրոյական տարրը մեկ դիրքով առաջ տեղափոխեք// էր՝ երկուշաբթի երեքշաբթի Ցուցակ. Տեղափոխել (0, 1); // դարձավ՝ երեքշաբթի երկուշաբթի/// Ինչպես պատրաստել ցուցակի պատճենը 1s 8-ում ListCopy = Ցուցակ. Պատճենել(); Գույներ = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել («Կապույտ»); ArrayColors = Գույներ: UnloadValues() ; /// Ինչպես բեռնել ցուցակի արժեքները զանգվածից 1s 8.3, 8.2-ումԳույներ. LoadValues (ArrayColors) ; Ընթացակարգի ավարտը /// Ինչպես կատարել արժեքի անմոդելի ընտրություն ցուցակից /// արժեքները 1-ում 8.3, 8.2&Հաճախորդի ընթացակարգի մասին Ինչպես կատարել Non-ModalValueSelection(Command) Colors = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել («Կապույտ»); // ընթացակարգը AfterSelectingElement-ը սահմանվում է հենց ներքևում AlertAfterElementSelection = Նոր նկարագրությունAlerts( «AfterElementSelection», ThisObject ) ; Գույներ. ShowElementSelection( NotificationAfterElementSelection, «Ընտրիր քո նախընտրած գույնը») ; Ընթացակարգի ավարտ & Հաճախորդի ընթացակարգը տարրի ընտրությունից հետո (տարր, պարամետրեր) Արտահանել Եթե տարրը<>Undefined then Report(Element.Value) ; Վերջ Եթե ; Ընթացակարգի ավարտը /// Ինչպես կատարել արժեքների անմոդայիկ նշումներ ցուցակից /// արժեքները 1-ում 8.3, 8.2&Հաճախորդի ընթացակարգի մասին Ինչպես կատարել արժեքների ոչ մոդալ նշում (հրաման) Գույներ = Արժեքների նոր ցուցակ; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել («Կապույտ»); // ընթացակարգը AfterMarkingElements-ը սահմանվում է հենց ներքևում AlertAfterMarkingItems = Նոր նկարագրությունAlerts( «Նյութերի նշումից հետո», ThisObject ) ; Գույներ. ShowTagItems (AlertAfterTagItems, «Ընտրիր քո նախընտրած գույները») ; Գույներ. FillNotes (Ճշմարիտ); Ընթացակարգի ավարտ & Հաճախորդի ընթացակարգի մասին տարրերը նշելուց հետո (տարրեր, պարամետրեր) Արտահանել Եթե տարրերը<>Undefined then For Every Color From Elements Cycle If Color: Նշել, ապա հաշվետվություն (Color.Value) ; Վերջ Եթե ; Վերջնական ցիկլ; Վերջ Եթե ; Ընթացակարգի ավարտը /// Ինչպես կատարել արժեքի մոդալ ընտրություն 1s 8.3, 8.2 ցուցակից&Հաճախորդի ընթացակարգի մասին Ինչպես կատարել ModalValueSelection(Command) Colors = New ValueList; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել («Կապույտ»); ԸնտրեքԳույն = Գույներ: Ընտրել տարր ( «Ընտրիր քո նախընտրած գույնը») ; Եթե ԸնտրեքԳույնը<>Չսահմանված Հետո հաշվետվություն (SelectColor.Value) ; Վերջ Եթե ; Ընթացակարգի ավարտը /// Ինչպես մոդալ կերպով նշել արժեքները ցուցակից /// արժեքները 1-ում 8.3, 8.2&Հաճախորդի ընթացակարգի մասին Ինչպես կատարել արժեքների մոդալ նշան (հրաման) Գույներ = Արժեքների նոր ցուցակ; Գույներ. Ավելացնել («Կարմիր»); Գույներ. Ավելացնել («Կանաչ»); Գույներ. Ավելացնել («Կապույտ»); Եթե Գույներ. MarkItems ( «Ընտրիր քո նախընտրած գույները») Այնուհետև յուրաքանչյուր գույնի համար Գունային ցիկլից Եթե գույնը: Նշել, ապա հաշվետվություն (Color.Value) ; Վերջ Եթե ; Վերջնական ցիկլ; Վերջ Եթե ; // ահա թե ինչպես կարելի է միանգամից բոլոր նշանները դնել // ցանկը որոշակի արժեքովԳույներ. FillNotes (Ճշմարիտ); Ընթացակարգի ավարտը /// Ներբեռնեք և գործարկեք այս օրինակները ձեր համակարգչում |
Ինչի՞ մասին է այս հոդվածը։
Այս հոդվածը շարունակում է «1C-ի զարգացման առաջին քայլերը» հոդվածաշարը: Այն ներառում է ունիվերսալ հավաքածուների հետ աշխատելու սկզբունքները: Հոդվածը կարդալուց հետո դուք կսովորեք.
- Որո՞նք են ունիվերսալ հավաքածուները, և երբ և ինչ դեպքերում դրանք պետք է օգտագործվեն:
- Ի՞նչ ընդհանուր բան ունեն բոլոր ունիվերսալ հավաքածուները: Ի՞նչ տեխնիկա կարող եք օգտագործել բոլորի հետ աշխատելու համար:
- Ի՞նչ է զանգվածը, ինչպե՞ս և երբ օգտագործել այն: Ի՞նչ մեթոդներ ունի նա։
- Ինչու՞ օգտագործել կառուցվածքը: Ինչպե՞ս է այն տարբերվում զանգվածից:
- Ե՞րբ պետք է օգտագործեք արժեքների ցանկը: Ինչպե՞ս ցուցադրել այն ձևաթղթում:
- Համապատասխանություն – ինչ է դա և երբ օգտագործել այն: Որո՞նք են կառուցվածքի առավելությունները:
- Ինչի՞ համար է օգտագործվում արժեքային աղյուսակը: Ինչպե՞ս նկարագրել դրա կառուցվածքը: Ինչպե՞ս ավելացնել/հեռացնել տողերը: Ինչպե՞ս ցուցադրել այն ձևաթղթում:
- Արժեքների ծառ - ինչի՞ համար է այն օգտագործվում: Ինչպե՞ս լրացնել և ցուցադրել ձևը: Ինչպե՞ս աշխատել դրա հետ:
Կիրառելիություն
Հոդվածում քննարկվում է ընթացիկ հրատարակության 1C:Enterprise 8.3 հարթակը:
Ինչպես աշխատել ունիվերսալ հավաքածուների հետ 1C-ում
Արժեքների հավաքածուն կոնտեյներ է, որը սովորաբար կարող է պարունակել ցանկացած քանակությամբ տարրեր: Այնուամենայնիվ, հաճախ տվյալների տեսակի վերաբերյալ խիստ սահմանափակումներ չկան:
Դուք կարող եք արժեքներ ավելացնել ընդհանուր հավաքածուին: Հավաքածուի բոլոր արժեքները կարող են անցնել: Այս հավաքածուները հիմնականում օգտագործվում են ալգորիթմներում որոշակի մշակման համար: Նրանք. Սրանք մի քանի դինամիկ կառուցվածքներ են, որոնք գոյություն ունեն ալգորիթմի գործողության ընթացքում:
Կարևոր է հասկանալ, որ հավաքածուները չեն պահվում տվյալների բազայում (խոսքը Value Store տվյալների տեսակի մասին չէ, որը կարող է պահել գրեթե ցանկացած տեսակի տվյալ):
Կան ունիվերսալ հավաքածուների տարբեր տեսակներ՝ Array, Structure, Match, Fixed Array, Value Table, Table Part եւ այլն։ Բայց բոլոր հավաքածուներն ունեն նման վարքագիծ։
Հավաքածու կարող է ստեղծվել ֆունկցիայի գործողության արդյունքում (ֆունկցիան որպես արժեք վերադարձնում է ունիվերսալ հավաքածու)։
Դուք կարող եք ձեռքով ձեռք բերել նոր հավաքածու՝ զանգահարելով կոնստրուկտորին և ստեղծելով դասի օրինակ:
Օրինակ: OurArray = Նոր զանգված;
Շատ ընդհանուր հավաքածուների կոնստրուկտորները պարամետրացված են:
Այսպիսով, կոնստրուկտորում համար Դուք կարող եք նշել անդամների թիվը համապատասխան չափերում: Նրանք. դուք կարող եք անմիջապես հայտարարել բազմաչափ .
Կոնստրուկտորի համապատասխան նկարագրությունը շարահյուսական օգնականում է։
Այսպիսով, օգտագործելով կոնստրուկտորի պարամետրերը, դուք կարող եք անմիջապես սահմանել տվյալ օբյեկտի ցանկալի վարքագիծը:
Բայց պարամետրերը կամընտիր են, մշակողը չի կարող դրանք սահմանել և հետագայում սահմանել զանգվածի վարքագիծը, ինչպես նա հարմար է գտնում:
Գրեթե ցանկացած ունիվերսալ հավաքածու կարող է ստեղծվել կոնստրուկտորի միջոցով (բացառություն են կազմում աղյուսակի մասերը, որոնք գործում են որպես կոնֆիգուրացիայի օբյեկտներ):
Համընդհանուր հավաքածուների համար կան ընդհանուր հասկացություններ, ինչպիսիք են ինդեքսը և թիվը: Հավաքածուի յուրաքանչյուր տարր ունի ինդեքս: Այս դեպքում ցուցանիշը սկսվում է զրոյից։
Տարր մուտք գործելու համար OurArray, դրա համար կարող եք օգտագործել ինդեքսային հասանելիություն, ինդեքսը նշված է քառակուսի փակագծերում։
Օրինակ, OurArray. Խնդրում ենք նկատի ունենալ, որ այս դեպքում համակարգը վերադարձնում է Array տարրը 3 ինդեքսով, և հերթականությամբ սա զանգվածի չորրորդ տարրն է:
Որոշ հավաքածուների համար կա նաև տողի համար հասկացությունը: Տողի համարը սկսվում է մեկով: Օրինակ, աղյուսակային մասի համար կա այնպիսի հատկություն, ինչպիսին է տողի համարը: Կարևոր է նկատի ունենալ, որ եթե մենք գիտենք տողի համարը և ցանկանում ենք մուտք գործել դրան ըստ ինդեքսների, ապա որպես ինդեքս պետք է օգտագործենք տողի համարից մեկով փոքր արժեք:
Գծի համար հասկացությունը գոյություն չունի ոչ բոլոր հավաքածուներում, այլ հիմնականում այն հավաքածուներում, որոնք կարող են ցուցադրվել օգտատիրոջ միջերեսում:
Բոլոր հավաքածուներում օգտագործվում է հավաքածուի տարրերի անցում: Շրջանցումը հնարավոր է երկու եղանակով. ցիկլ ForԵվ ցիկլ յուրաքանչյուրի համար.
Ընդհանուր ժողովածուների մեծ մասի համար կիրառվող մեթոդներն են՝ Count, Index, Add, Insert, Delete և Find:
Count-ը ֆունկցիա է, որը վերադարձնում է հավաքածուի տարրերի քանակը: Այն կարող է օգտագործվել ցիկլից առաջ Համար, ինչպես ցույց է տրված նկարում:
Index մեթոդը գոյություն չունի բոլոր հավաքածուների համար, այլ միայն նրանց համար, որոնց տարրերը կարող են հղում կատարել: Օրինակ է Արժեքների աղյուսակ.
Արժեքների աղյուսակ– սա տողերի հատուկ հավաքածու է, որը կարող է պարունակել տարբեր տեսակի արժեքներով տարբեր սյունակներ:
Յուրաքանչյուր տող ներկայացնում է անկախ կազմավորում: Դուք կարող եք ստանալ դրա հղումը այս տողի միջոցով, կարող եք մուտք գործել այս տողի սյունակների արժեքները:
Index մեթոդը թույլ է տալիս որոշել, թե որ ինդեքսն է համապատասխանում տվյալ տողին (այսինքն՝ աղյուսակում տողի ընթացիկ դիրքը): Ինդեքսի արժեքները սկսվում են զրոյից:
Գրեթե ցանկացած ունիվերսալ հավաքածու ունի տվյալ հավաքածուին նոր արժեքներ ավելացնելու մեթոդներ: Նկարը ցույց է տալիս, թե ինչպես լրացնել զանգվածը 0-ից 10 արժեքներով երկու եղանակով:
Զանգվածին տարր ավելացնելու համար մենք կարող ենք օգտագործել մեթոդը Ավելացնել, փակագծերում նշեք ավելացվող արժեքը: Այս դեպքում արժեքը կավելացվի ցանկի վերջում, այսինքն. Վերջին դիրքի շնորհիվ զանգվածը անընդհատ կավելանա։
Մեկ այլ մեթոդ, որը թույլ է տալիս արժեքներ ավելացնել հավաքածուին, դա է Տեղադրեք. Դա տարբերվում է մեթոդից Ավելացնելդրանով դուք կարող եք նշել, թե որտեղ տեղադրվի ավելացված տարրը:
Շարահյուսություն: Տեղադրեք (,)
Առաջին պարամետրը նշում է այն ինդեքսը, որի մեջ կտեղադրվի նոր արժեքը: Նրանք. Օրինակ, մենք կարող ենք նշել, որ յուրաքանչյուր արժեք պետք է տեղադրվի ցանկի սկզբում (երկրորդ մեթոդը վերը նշված նկարում):
Հավաքածուից տարրեր հեռացնելու համար օգտագործեք մեթոդը Ջնջել. Ջնջել մեթոդը ցուցիչով նշում է, թե որ տարրը կջնջենք։
Շարահյուսություն: Ջնջել ()
Օգտագործման օրինակ. OurArray.Delete(5);
Հարկ է նշել, որ այն հավաքածուների համար, որտեղ տողերը ներկայացնում են անկախ էություն (օրինակ՝ համար Արժեքների աղյուսակներ), մենք կարող ենք նաև օգտագործել ինդեքսը ստանալու մեթոդը՝ հետագայում այս տողը ջնջելու համար։
Գրեթե բոլոր հավաքածուները ունեն արժեքի որոնման մեթոդ. Գտեք. Արժեքը, որը մենք ցանկանում ենք գտնել, փոխանցվում է մեթոդին: Որոշ հավաքածուներ թույլ են տալիս սահմանել որոշ սահմանափակումներ:
Օրինակ՝ մեջ Արժեքների աղյուսակկարող եք նշել այն տողերն ու սյունակները, որոնցում ցանկանում եք որոնել:
Եթե արժեքը գտնվի, այս մեթոդը վերադարձնում է ինդեքսը կամ նշված տողը: Եթե արժեքը չի գտնվել, վերադարձվում է տիպի արժեքը Չսահմանված. Զանգվածի հետ կապված՝ վերադառնում է Ցուցանիշ, կամ արժեք Չսահմանված.
Օգտագործման օրինակ. OurVariable = OurArray.Find(8);
Ունիվերսալ հավաքածուները կարող են շատ արագ մաքրվել, այսինքն. հեռացնել բացարձակապես բոլոր տարրերը. Այդ նպատակով օգտագործվում է մեթոդը Մաքրել (), որը հեռացնում է զանգվածի տարրերը, տողերը Արժեքների աղյուսակներ, կամ այլ հավաքածուների տվյալներ։
Լրացուցիչ մեթոդներ Array-ի համար
Մեթոդ BBorder ()վերադարձնում է տարրերի թիվը հանած մեկ: Նրանք. եթե մենք օգտագործում ենք հանգույց Համար, ապա Քանակ մեթոդի փոխարեն կարող ենք անմիջապես օգտագործել մեթոդը Սահման ().
Մասնավորապես, QuantityInArray փոփոխականը կարող է տարբեր կերպ սահմանվել.
QuantityInArray = OurArray.InBorder();
Այնուհետև, ցիկլը նկարագրելիս չպետք է հանել այս փոփոխականից:
Set մեթոդը թույլ է տալիս արժեք վերագրել Array տարրին ըստ ինդեքսի:
Շարահյուսություն: Տեղադրել (,)
Օրինակ: OurArray.Set(2,8);
Այլընտրանքային տարբերակ. OurArray = 8;
Դուք կարող եք օգտագործել մեթոդը Array-ի համար Ստացեք, ինդեքսի վրա արժեք կարդալու համար՝ առանց քառակուսի փակագծերի օգտագործման։
Շարահյուսություն: Ստանալ ()
Օրինակ: OurVariable = OurArray.Get(2);
Այլընտրանքային տարբերակ. OurVariable = OurArray;
Ունիվերսալ հավաքածուի կառուցվածք
Կառուցվածքը, ինչպես զանգվածը, կարող է ունենալ անսահմանափակ թվով տարրեր, սակայն տարրի բովանդակությունը տարբերվում է զանգվածից։
Կառուցվածքը հավաքածու է, որի յուրաքանչյուր արժեք բաղկացած է զույգից։ Զույգի առաջին տարրը կոչվում է Բանալի. Զույգի երկրորդ տարրն է Իմաստը.
Բանալիխիստ տողային տվյալների տեսակ է, որը նկարագրում է արժեքը: Օրինակ, Դեպի բանալին«Կոդը» կարող է համապատասխանել 113 արժեքին; Դեպի բանալին«Անուն» նշանակում է «Վասյա»: Արժեքն ինքնին ենթակա չէ տվյալների տեսակի սահմանափակման:
Կառուցվածքը շատ հարմար է օգտագործել, եթե ցանկանում ենք ստեղծել պարամետրերի որոշակի ցանկ։ Եթե սա Կառուցվածքկանչեց Մեր Կառուցվածքը, ապա դրա երկու արժեքներին կանդրադառնանք հետևյալ կերպ. OurStructure.Code և OurStructure.Name:
Այս տեսակի մուտքը շատ ավելի հարմար է, քան եթե մենք սահմանեինք զանգվածի բոլոր պարամետրերը և մուտք գործեինք դրանք ըստ ինդեքսների:
Կառուցվածքը ծրագրի կոդը դարձնում է ընթեռնելի (հասկանալի): Structure-ն օգտագործվում է բավականին հաճախ, շատ ավելի հաճախ, քան Array-ը:
Այն օգտագործվում է որոշ պարամետրեր նկարագրելու համար, որոնցից հաճախ բավականին մեծ թիվ են լինում բոլոր ալգորիթմներում։
Բացի այդ, Structure-ն օգտագործվում է, եթե ընթացակարգը և ֆունկցիան պարունակում են մեծ թվով անցած պարամետրեր:
Այնուհետև շատ ավելի հարմար է բոլոր պարամետրերը գրել Structure-ում և փոխանցել այն: Նրանք. ընթացակարգերի և գործառույթների պարամետրերը «փաթեթավորված» են:
Առանձին-առանձին պետք է նշել, որ ինչպես ԲանալիԲացարձակապես որևէ տող չի կարող հայտնվել Կառուցվածքում: Կիրառվում են որոշակի սահմանափակումներ։
Բանալիպետք է հանդես գա որպես նույնացուցիչ: Սա նշանակում է, որ ներս Կլյուչեչպետք է բացատներ չլինեն և այն չի կարող սկսվել թվով:
Ընդունելի սկիզբ Բանալիտառով կամ ընդգծումով։ Այսպիսով, Բանալիպետք է բավարարի նույնացուցիչներ ստեղծելու պահանջները:
Եկեք նկատենք, թե ինչպես է կառուցվածքը տարբերվում զանգվածից: Կառուցվածքում կա մեթոդ Տեղադրեք, Array-ում տեղադրելու երկու եղանակ կա. Տեղադրեք(որոշակի պաշտոնի) և Ավելացնել(մինչև ցուցակի վերջը): Զանգվածում բոլոր տարրերը դասավորված են:
Կառուցվածքը մի տեսակ անկարգությունների հավաքածու է։ Ահա թե ինչու կա կառուցվածքի ներդիրի մեթոդ:
Արժեքը տեղադրվում է ոչ թե կոնկրետ դիրքում, այլ նշված հավաքածուի մեջ: Կառուցվածքը չի կարող մուտք գործել ինդեքսով, ինչպես մյուս ընդհանուր հավաքածուները:
Կառուցվածքի տարրերը հասանելի են միայն բանալի անունով: Այնուամենայնիվ, For Every օղակը նույնպես աշխատում է Structure-ի համար, բայց դուք չպետք է ապավինեք Structure տարրերի հերթականությանը:
Կառուցվածքը ստեղծվում է այնպես, ինչպես մյուս ընդհանուր հավաքածուները՝ օգտագործելով Նոր կոնստրուկտորը՝ նշելով տվյալների տեսակը Structure:
Ինչպես զանգվածը, Կառուցվածքի կոնստրուկտորը կարող է ունենալ պարամետրեր: Նրանք. կարելի է նկարագրել կառուցվածքի բովանդակությունը՝ օգտագործելով կոնստրուկտոր:
Ի տարբերություն զանգվածի, որտեղ դուք կարող եք պարզապես նշել տարրերի քանակը բոլոր չափումների համար, Structure-ում դուք կարող եք նշել հենց բովանդակությունը:
Օրինակ: OurStructure = New Structure («Կոդ, անուն», 133, «Վասյա»);
Ստորակետներով բաժանված՝ սկզբում նշված են բանալիների անունները, իսկ հետո, համապատասխանաբար, նույն հաջորդականությամբ՝ պարամետրերի արժեքները:
Կառուցվածքին նոր արժեք ավելացնելու մեթոդ կա Տեղադրեք, որը տեղադրում է նոր զույգ (Բանալին և արժեք):
Օրինակ: OurStructure.Insert(“FamilyMembers”,3);
Կառուցվածքը բնութագրվում է մեկ այլ մեթոդով, որը բավականին հաճախ օգտագործվում է. Սա է մեթոդը Սեփականություն.
Օգտագործելով այս մեթոդը, դուք կարող եք հասկանալ, թե արդյոք այս Կառուցվածքում կա տարր, որի բանալին ունի այս կամ այն անվանումը:
Եթե այդպիսի տարր գոյություն ունի, համակարգը կվերադարձնի True արժեքը, հակառակ դեպքում՝ False:
Օրինակ՝ արտահայտությունը OurStructure.Property («Ընտանիքի անդամներ»)հավասար կլինի True արժեքին: Այս մեթոդը բավականին հաճախ օգտագործվում է կառուցվածքը վերլուծելիս:
Ինչպես ցանկացած ունիվերսալ հավաքածուի դեպքում, ինդեքսով հնարավոր է մուտք գործել Կառուցվածքի հատկությունները: Բայց Structure-ի ինդեքսը լարային արժեք է:
Օրինակ: Հաշվետվություն (Մեր կառուցվածքը[«Ընտանիքի անդամներ»]);
Այնուամենայնիվ, չպետք է մոռանալ, որ Structure-ը օբյեկտների չդասավորված հավաքածու է, այդ իսկ պատճառով 0, 1, 2 ինդեքսով մուտք գործելն անընդունելի է:
Ընդհանուր հավաքածու Արժեքների ցանկ
ListValuesցանկացած տվյալների տիպի տարրերի գծային ցանկ է:
Յուրաքանչյուր տարր բաղկացած է մի քանի արժեքներից: Սխեմատիկորեն արժեքների ցանկը կարող է ներկայացվել որպես չորս սյունակներով ցուցակ:
Առաջին սյունակ - նշագծել. Այն ունի բուլյան տվյալների տեսակ և թույլ է տալիս օգտվողին ստուգել կամ հեռացնել վանդակները:
Մյուս սյունակը նկար է, որը կարող է ինչ-որ կերպ տեսողականորեն ներկայացնել այս տարրը, այսինքն. համապատասխանեցնել այս տողը նկարի հետ:
Երրորդ սյունակը ինքնին պահված արժեքն է, այսինքն. սա ցանկացած տեսակի տվյալ է, և այն կարող է տարբեր լինել տարբեր տողերում:
Չորրորդ սյունակը ներկայացումն է, այսինքն. սա տվյալ արժեքի լարային նկարագրության մի տեսակ է: Տեսարանը կցուցադրվի օգտվողին, երբ նա դիտի այս տարրը: Այս դեպքում, եթե ներկայացումը նշված չէ, համակարգը կփորձի ստանալ այս դիրքում պարունակվող տարրի ներկայացումները:
ListValues– սա այն օբյեկտն է, որի հետ օգտատերը կարող է տեսողականորեն աշխատել: Նրանք. ListValuesկարող է ցուցադրվել ձևի վրա:
Օգտագործողը կարող է դրա հետ կատարել որոշ գործողություններ: Բացի այդ, ListValuesկարելի է եզրակացնել ինքնուրույն՝ օգտագործելով մեթոդները, այսինքն. ցուցադրել էկրանին ալգորիթմի որոշ ճյուղում (բացառությամբ սերվերի կոդի), որպեսզի օգտագործողը ընտրի որոշ տող կամ ստուգի որոշ վանդակներ:
Մենք կգտնենք ListValuesսիտաքսի օգնականում։ Կոնստրուկտոր ListValuesպարամետրացված չէ (դուք չեք կարող սահմանել լռելյայն արժեքներ):
Կան մեթոդներ, ինչպիսիք են.
- Տեղադրել(,) ;
- Ավելացնել (,);
- Քանակ ();
- Ինդեքս ().
Կան նաև հատուկ մեթոդներ, օրինակ. UnloadValues (). Սա ստեղծում է զանգված, որի մեջ պատճենվում է արժեքների ցանկը: Օրինակ:
Տարրերի զանգված = PriceTypes.OutloadValues();
Կա նաև հակադարձ մեթոդ.
ListPriceTypes.LoadValues(ArrayItems);
Կան որոնման մեթոդներ.
FindByValue(); FindByIdentifier():
Կա պատճենման մեթոդ.
ListCopy = PriceTypeList.Copy();
Այս մեթոդը նախատեսված է կրկնօրինակում ինչ-որ փոփոխության ենթարկելու համար:
Կան մեթոդներ.
SortByValue();
SortByView ().
Մեթոդներ Ընտրել տարր (,)Եվ MarkItems ()կանչեք մոդալ երկխոսության տուփ, որը դադարեցնում է ալգորիթմի կատարումը, մինչև օգտագործողը փակի պատուհանը:
Այս մեթոդները կոնֆիգուրացիայի հատկություններում օգտագործելու համար Մոդալի օգտագործման եղանակըպետք է սահմանվի Օգտագործեք.
Կառավարվող հավելվածի մոդուլից կանչված կոդի օրինակ՝
Ցուցադրել այս կոդը օգտագործողի ռեժիմում (մոդալ երկխոսություն):
Ստորև ListValuesօգտագործվում է որպես հասանելի տվյալների տեսակ ձևի ատրիբուտների համար: Մենք մշակման ձևի համար ստեղծում ենք նոր հատկանիշ և սահմանում դրա տեսակը ListValuesև ցուցադրել այն ձևաթղթում:
Նոր թիմի ստեղծում Գրանցվել Նվերներ, փոխանցեք այն ձևաթղթին և դրա համար սահմանեք գործողությունների մշակող։
Օգտվողի ռեժիմում, երբ սեղմում եք «Լրացրեք նվերներ» կոճակը մշակման ձևում, կհայտնվի լրացված ցուցակը:
Ցանկության դեպքում ցանկը կարելի է խմբագրել. որոշ տարրեր կարելի է ավելացնել, որոշները հեռացնել:
Բազմակողմանի հավաքածուի համապատասխանություն
Այս հավաքածուն շատ նման է Կառուցվածք. Ճիշտ այնպես, ինչպես Structure-ը, Matching-ը ներկայացնում է արժեքների հավաքածուներ, որոնք բաղկացած են բանալիից և հենց արժեքից:
Հիմնական տարբերությունն այն է, որ տվյալների ցանկացած տեսակ կարող է նշվել որպես բանալի, ինչպես նաև արժեք: Հաշվի առնելով այս հատկանիշը՝ անհրաժեշտ է մուտք գործել համընկնումի արժեք՝ ըստ ինդեքսի, հիմնական արժեքը նշվում է որպես ինդեքսի արժեք:
Բանալին կարող է լինել այլ տվյալների տեսակ, քան տողը: Համապատասխանության հետ աշխատելու հատկությունները և մեթոդները գրեթե նույնն են, ինչ Structure-ին:
Համապատասխանության կոնստրուկտորը, ի տարբերություն Structure-ի, չի պարունակում պարամետրեր նշելու հնարավորություն:
Օգտագործման օրինակ.
Նամակագրությունը հարմար է օգտագործել, երբ անհրաժեշտ է միացնել ցանկացած երկու կառուցվածք: Օրինակ, աղյուսակային հատվածի յուրաքանչյուր տող պետք է համընկնի արժեքների աղյուսակի տողի հետ:
Այս դեպքում աղյուսակի հատվածի տողը օգտագործվում է որպես Match բանալի և նշվում է համապատասխան արժեքը:
Հավաքածուի մեջ տարրեր ներդնելիս Մեթոդից բացի Համապատասխանեցրեք Տեղադրել (,)Արժեքը տեղադրելու մեկ այլ եղանակ է սովորական հանձնարարական օպերատորի օգտագործումը:
Օրինակ: OurMatch = NewMatch;
Համապատասխանում = 999;
Նրանք. եթե որևէ տարր չկա հավաքածուում, ապա այն կավելացվի հանձնարարության օպերատորի միջոցով, իսկ եթե առկա է, այն կթարմացվի:
Սա ի տարբերություն Structure-ի:
Համընդհանուր հավաքածուի արժեքների աղյուսակ
Արժեքների աղյուսակաղյուսակ է կամայական թվով տողերով և կամայական թվով սյունակներով: Խաչմերուկը կարող է պահել ցանկացած տվյալների տիպի արժեքներ: Անհրաժեշտության դեպքում, սյունակները կարող են մուտքագրվել, այսինքն, դուք կարող եք որոշել, թե որ սյունակում ինչ տեսակի տվյալներ են պահվում:
Դուք կարող եք սյունակները թողնել անտիպ, այնուհետև տարբեր տեսակի արժեքները կարող են պահվել մեկ սյունակում՝ տարբեր տողերում:
Տարբերություններ Արժեքների աղյուսակներերկչափ զանգվածից.
- սա այն օբյեկտն է, որի հետ օգտագործողը կարող է աշխատել (արժեքների աղյուսակը կարող է ցուցադրվել էկրանին, օգտագործողը կարող է լրացնել այն, և մուտքագրված տվյալները կարող են այնուհետև կարդալ);
- արագ որոնման համար ինդեքսների կառուցում;
- կլոնավորում, մի ամբողջ սյունակ լրացնելով որոշակի արժեքով, բեռնաթափելով բոլոր սյունակները զանգվածի մեջ:
Արժեքների աղյուսակօգտագործվում է որպես տեղեկատվության պահպանման մի տեսակ բուֆեր: Արժեքների աղյուսակվերադարձվում և ընդունվում է որպես պարամետր բազմաթիվ համակարգի մեթոդներով: Հնարավոր է հարցում կառուցել արժեքների աղյուսակի դեմ:
Այսպիսով, Արժեքների աղյուսակբաղկացած է մի շարք տողերից և մի շարք սյուներից: Երկու տողերը և սյունակները հավաքածուներ են:
Նրանք. հավաքածուի ներսում Արժեքների աղյուսակկա ևս երկու հավաքածու։ Եկեք դիմենք շարահյուսության օգնականին և գտնենք Արժեքների աղյուսակ.
Աջակցվող տվյալների տեսակները՝ ինքն իրեն Արժեքների աղյուսակ, որը բաղկացած է լարերից։ Յուրաքանչյուր տող ներկայացված է տվյալների տեսակով RowTableValues, որն ունի իր սեփական հատկությունները և իր մեթոդները: Հասանելի է Աղյուսակի սյունակների արժեքների հավաքածուունի նաև որոշակի հատկություններ.
Կարևոր կետ! Ընթացակարգը, որը ստեղծում է Արժեքների աղյուսակ, պետք է կազմի &OnServer-ը:
Նախքան սկսեք աշխատել Արժեքների աղյուսակ, դուք պետք է որոշեք, թե ինչ սյունակներ է այն պարունակելու (այսինքն՝ ստեղծել դրանք): Շարահյուսություն:
Ավելացնել (,)
(ըստ ցանկության)
Տեսակը՝ լարային:
(ըստ ցանկության)
Տեսակ՝ Նկարագրություն Տեսակներ
(ըստ ցանկության)
Տեսակը՝ լարային:
(ըստ ցանկության)
Տեսակ՝ համար։
Օրինակ:
Այս ընթացակարգը կանչելու համար մենք կօգտագործենք հրամանը.
Նկարագրության մեջ Արժեքների աղյուսակներհավաքածուի տարրերը ճշգրիտ են RowsTableValues.
Ի տարբերություն սյունակների, որոնք բաղկացած են միայն հատկություններից (Անուն, Տեսակ, Վերնագիր, Լայնություն), in RowTableValuesԿան և՛ հատկություններ (մուտք՝ ըստ սյունակի անունով), և՛ մեթոդներ (կարող եք ստանալ և սահմանել արժեք, աշխատել սեփականատերերի հետ):
Աղյուսակում նոր տող ավելացնելու համար անհրաժեշտ է օգտագործել նաև մեթոդը Ավելացնել (), կամ Տեղադրել (). Երկրորդ դեպքում դուք պետք է նշեք, թե որ դիրքում պետք է տեղադրվի պահանջվող գիծը։
Սյունակին արժեք նշանակելու համար մենք օգտագործում ենք կետ՝ սյունակի անվանումը կամ ինդեքսը մուտք գործելու համար (օգտագործելով քառակուսի փակագծեր):
Լրացնելու համար Արժեքների աղյուսակներՀետևյալ մեթոդները կարող են օգտագործվել.
Մաքրել ()– հեռացնել բոլոր տողերը Արժեքների աղյուսակներ.
FillValues (,)- թույլ է տալիս լրացնել բոլոր սյունակները կամ ընտրված սյունակները մեկ արժեքով:
LoadColumn(,)– բեռնում է սյունակ զանգվածից:
UnloadColumn()– բեռնաթափում է սյունակը զանգվածի մեջ:
Վերջին երկու մեթոդները հարմար են օգտագործել, երբ անհրաժեշտ է սյունակ տեղափոխել մի արժեքային աղյուսակից մյուսը:
Պատճենել (,)– թույլ է տալիս ստեղծել նորը գոյություն ունեցող աղյուսակի հիման վրա Արժեքների աղյուսակ, և ոչ բոլոր տողերն ու բոլոր սյունակները, այլ միայն դրանցից մի քանիսը: Վերադարձի արժեք - Արժեքների աղյուսակ.
Դուք կարող եք պատճենել կառուցվածքը Արժեքների աղյուսակներ. Դրա համար կա համապատասխան մեթոդ CopyColumns (). Մենք կստանանք դատարկ մեկը Արժեքների աղյուսակպահանջվող կառուցվածքով։
IN Արժեքների աղյուսակկա մեթոդ Ընդհանուր (). Դուք կարող եք նշել այն սյունակը, որտեղ ցանկանում եք գումարել թվային արժեքները: Աղյուսակում նախկինում ցուցադրված կոդի հետ կապված կարող եք հաշվարկել արժեքը. TK.Total («Գումար»).
IN Արժեքների աղյուսակմեթոդով հնարավոր է խմբավորել (փլուզել) թվային արժեքները որոշակի սյունակների նույնական արժեքներով Ծալել (,).
Աղյուսակում նախկինում ցուցադրված կոդի հետ կապված կարող եք հաշվարկել արժեքը. TK.Collapse («Շաբաթվա օր», «Գումար»):
Արժեքների աղյուսակկարող է ցուցադրվել օգտատիրոջ էկրանին, որպեսզի կարողանաք դրա հետ ցանկացած գործողություններ կատարել: Բայց ի տարբերություն ListValuesԴուք չեք կարող պարզապես էկրանին սեղան կանչել ծրագրի կոդից:
Ցուցադրել Արժեքների աղյուսակէկրանին ստեղծեք ձևի հատկանիշ և դրան նշանակեք տվյալների տեսակ Արժեքների աղյուսակ.
Դրանից հետո ստացված աղյուսակը պետք է ցուցադրվի ձևաթղթում:
Նախկինում կազմված ալգորիթմի վերջում գտնվող ձևի մոդուլում (Արժեքների աղյուսակի ստեղծման ընթացակարգում) պետք է ավելացնեք.
ValueInFormData (TK, Աղյուսակ);
Ունիվերսալ հավաքածու Արժեքների ծառ
ունիվերսալ հավաքածու, որը շատ նման է Արժեքների աղյուսակ. Աղյուսակից տարբերությունն այն է, որ ծառի տողերը կարող են ենթարկվել միմյանց, այսինքն. կարող է ձևավորվել ինչ-որ հիերարխիա։
Սա կարող է արտացոլվել նաև էկրանին: Արժեքի ծառը բացահայտորեն բաղկացած է տողերի հավաքածուից և սյունակների հավաքածուից: Ծառի մեջ կա երկու հատկություն՝ տողեր և սյունակներ:
Քանի որ տողերը կարող են ենթակա լինել միմյանց, յուրաքանչյուր տող կարող է ունենալ Ծնող, ինչպես նաև նրա ենթակա տողեր:
Եկեք ստեղծենք համապատասխան Tree հրամանը և դրա մշակման կարգը։
Եկեք ստեղծենք որոնցում կա մեկ մայր և երկու ստորադաս տող:
Եկեք ստեղծենք ձևի ատրիբուտները ԴերԶն(տվյալների տեսակը – Արժեքի ծառ):
Այս հատկանիշի համար մենք կստեղծենք տարի և ամիս սյունակներ:
Տեղափոխեք համապատասխան տարրը ԴերԶնձևի վրա։
Վերջում Գործընթացներ TreeOnServer()հավելենք.
ValueInFormData (TreeZn, DerZn);
Եկեք ստուգենք, թե ինչ է տեղի ունեցել օգտագործողի ռեժիմում:
Օգտագործելով կոճակ Ավելացնելկարող եք նոր տողեր ավելացնել: Նրանք կարող են նաև հիերարխիա ձևավորել։
Արժեքի ծառի բոլոր տարրերը հատելու համար մեզ անհրաժեշտ կլինի օգտագործել ռեկուրսիա, այսինքն. կարգը ինքն իրենից կանչելով. Օրինակ, արժեքների ծառի մշակումը կարող է այսպիսի տեսք ունենալ.
Սրանով ավարտվում է մեր առաջին ծանոթությունը ունիվերսալ հավաքածուների հետ։
Հաջորդ հոդվածում մենք կանդրադառնանք, թե ինչ կարևոր մեխանիզմ կարող է օգտագործել ծրագրավորողը ծրագրի կոդից գրացուցակի տարր մուտքը պարզեցնելու համար:
