1c արժեքների աղյուսակի ստեղծում: Ինչ մեթոդներ կան և ինչպես որոնել մի քանի արժեքներ միաժամանակ

Հրատարակվել է 2011 թվականի սեպտեմբերի 21-ին

Արժեքների աղյուսակ 1C – մաս 3. Մետատվյալներ. Անցում արժեքների աղյուսակի սյունակների միջով

Այս հոդվածում ես ձեզ կասեմ, թե ինչպես աշխատել «անհայտ» կառուցվածքի արժեքների աղյուսակի հետ, ինչպես կրկնել արժեքների աղյուսակի սյունակների միջով, ինչպես հանել տվյալները սյուներից և տողերից՝ առանց սյունակների անունների օգտագործման: (Այս հոդվածը պատկանում է 1C հոդվածների շարքին զրոյից; 1C ծրագրավորում զրոյից; 1C արժեքների աղյուսակ)

Նյութը բացատրելու և մեր կոդի օրինակները «կենդանի» գործարկելու համար մեզ անհրաժեշտ են մի քանիսը 1C արժեքների փորձարկման աղյուսակ. Մեր օրինակներից մի քանիսը տվյալներ կհանեն արժեքների աղյուսակից, այնպես որ մենք կկազմենք աղյուսակ երեք սյունակով՝ «Ազգանուն», «Անուն», «Միջին անուն» և մուտքագրում ենք փոքր քանակությամբ տվյալներ՝ մինչև 3: շարքեր :)

Այսպիսով, եկեք ստեղծենք 1C արժեքների թեստային աղյուսակ և լրացնենք այն.

MyTZ = New ValueTable; // ստեղծել արժեքների նոր աղյուսակ, որը պահվում է «MyTZ» փոփոխականում MyTZ.Columns.Add(«Ազգանուն»); // ստեղծել «Ազգանուն» սյունակը MyTK.Columns.Add("Name"); // ստեղծել «Անուն» սյունակը MyTZ.Columns.Add(«Patronymic»); // ստեղծել «Միջին անուն» սյունակը // ավելացնել առաջին տողը մեր արժեքների աղյուսակում NewLine = MyTZ.Add(); NewString.LastName = "Chapaev"; NewLine.Name = «Վասիլի»; NewString.Middle name = «Ivanovich»; // ավելացնել երկրորդ տողը NewLine = MyTZ.Add(); NewString.LastName = «Ձերժինսկի»; NewRow.Name = «Ֆելիքս»; NewString.Middle name = «Էդմունդովիչ»; // ավելացնել երրորդ տողը NewLine = MyTZ.Add(); NewLine.LastName = «Կոտովսկի»; NewLine.Name = «Գրիգոր»; NewString.Middle name = «Ivanovich»;

Մեր թեստային աղյուսակը բաղկացած է երեք սյունակից՝ Անուն, Ազգանուն, Հայրանուն; և ունի երեք լրացված տող քաղաքացիական պատերազմի հերոսների անուններով:

Կոդի առաջին նմուշը թվարկում է 1C արժեքային աղյուսակի սյունակները որպես հավաքածու:

// ցուցադրել TK-ի բոլոր սյունակների անունները For Every Column From MyTZ.Columns Cycle Report ("Column name: " + Column.Name); End Cycle;

Մեր ցիկլը կցուցադրի բոլոր սյունակների անունները 1C հաղորդագրության պատուհանում.

Սյունակի անունը. Ազգանուն Սյունակի անունը. Անունը Սյունակի անունը. Միջին անուն

Մենք տեսնում ենք, որ սյունակների միջոցով կրկնելու համար օգտագործվում է հավաքածուի կրկնման հատուկ ցիկլ, որը նման է տողերի կրկնման ցիկլին (նախորդ հոդվածում): MyTZ.Columns- սա 1C արժեքների աղյուսակի սյունակների հավաքածու է «MyTZ». Հավաքածուն պարունակում է տիպի առարկաներ «Արժեքների աղյուսակի սյունակ»Այս տեսակի յուրաքանչյուր օբյեկտ արժեքների աղյուսակի սյունակ է և պարունակում է հատկություններ և մեթոդներ: Մուտք գործելով այս հատկությունները և մեթոդները, մենք ստանում ենք անհրաժեշտ տեղեկատվություն մեկ սյունակի մասին կամ կատարում ենք որոշ այլ գործողություններ դրա հետ:

Օրինակ՝ սեփականություն մուտք գործելը "Անուն" (Սյունակ.Անուն) ստանում ենք ընթացիկ սյունակի անվանումը։

Ցանկանում եմ ձեր ուշադրությունը հրավիրել սերիալի վերնագրի վրա՝ «Բոլորի համար Սյունակ From MyTZ.Column Cycle» Փոփոխական անունով «Սյունակ»մեր կողմից հորինված. Պարտադիր չէ օգտագործել նույն անունը։ Դուք կարող եք անվանել այս փոփոխականը, ինչպես ցանկանում եք, օրինակ «Իմ ընթացիկ սյունակը»Այնուհետև վերը նշված օրինակը կունենա հետևյալ տեսքը.

// Ցուցադրել TK-ի բոլոր սյունակների անունները For Every MyCurrentColumn MyTK.Columns Cycle Report-ից ("Column name: " + MyCurrentColumn.Name); End Cycle;

Երբ 1C կատարման ենթահամակարգը հանդիպում է այս տիպի ցիկլի, ցիկլի յուրաքանչյուր անցումով այն վերագրում է մեր հավաքածուի մեկ տարր նշված անունով փոփոխականին, այս դեպքում՝ հավաքածուի մեկ տարրարժեքի աղյուսակի սյունակներ MyTZ.ColumnsԵվ հետո մենք մուտք ենք գործում ընթացիկ սյունակը պարունակող փոփոխականը և օգտագործում հատկությունը "Անուն".

Ես առաջարկում եմ սյունակի անվան կողքին ցուցադրել սյունակների հավաքածուի յուրաքանչյուր սյունակի թիվը.

// Ցուցադրել արժեքների աղյուսակի բոլոր սյունակների համարը և անունները «Յուրաքանչյուր սյունակի համար» MyTZ.Columns ցիկլի սյունակի համարը = MyTZ.Columns.Index(Column); // ստանալ սյունակի համարը ColumnName = Column.Name; // ստանալ սյունակի անվանումը Հաշվետվություն ("Սյունակի համարը:" + Սյունակի համարը + " Սյունակի անվանումը. " + Սյունակի անունը); End Cycle;

Հետևյալ տեքստը կցուցադրվի 1C հաղորդագրության պատուհանում.

Սյունակի համարը:0 Սյունակի անունը. Ազգանունը Սյունակի համարը.1 Սյունակի անվանումը. Անունը Սյունակի համարը.2 Սյունակի անունը. Միջին անուն.

Խնդրում ենք նկատի ունենալ, որ 1C արժեքների աղյուսակի սյունակները համարակալված են զրոյից սկսած, ինչպես արժեքների աղյուսակի տողերը:

1C արժեքի աղյուսակում սյունակների քանակը

Արժեքների աղյուսակում սյունակների քանակը պարզելու համար մենք օգտագործում ենք «Count()» մեթոդը սյունակների հավաքածուի վրա։

Սյունակների քանակը = MyTZ.Columns.Quantity(); Հաշվետվություն (Սյունակների քանակը);

Էկրանի վրա կցուցադրվի «3» թիվը: Իսկապես, մեր աղյուսակն ունի երեք սյունակ՝ «Ազգանուն», «Անուն», «Հայրանուն»

Սյունակի օբյեկտի ստացում իր թվով (ինդեքսով) և սյունակների թվարկում՝ օգտագործելով սյունակի ինդեքսը

Կազմենք արժեքների աղյուսակի բոլոր սյունակներում որոնման ցիկլ՝ օգտագործելով սյունակների ինդեքսները (թվերը): Հիշեք, որ սյունակների համարակալումը սկսվում է զրոյից: Հետևաբար, մենք պետք է «Sch» ցիկլի հաշվիչը զրոյից հասցնենք մի թվի, որը հավասար է սյունակների թվին հանած մեկ:

Հաշվի համար = 0 Ըստ MyTZ.Columns.Quantity() - 1 ցիկլ CurrentColumn = MyTZ.Columns[Act]; Հաշվետվություն (CurrentColumn.Name); End Cycle;

Էկրանի վրա մենք կստանանք հետևյալը

Ամբողջական անուն

Կարծում եմ այս օրինակը պարզ էր. Մենք դիմեցինք մեթոդին Քանակ ()սյունակների հավաքածուներ» MyTZ.Columns.Quantity()«, ստացավ սյունակների թիվը և սկսեց մի հանգույց՝ հաշվիչով զրոնախքան սյունակների թիվը հանած մեկ. Օղակի ներսում մենք ստանում ենք յուրաքանչյուր սյունակ սյունակների հավաքածուից և վերագրում ընթացիկ սյունակի օբյեկտը փոփոխականին Ընթացիկ սյունակՀաջորդը, փոփոխականը Ընթացիկ սյունակմենք մուտք ենք գործում գույք Անունև ցուցադրել այս հատկության արժեքը էկրանին. Հաշվետվություն (CurrentColumn.Name);

Կարևոր է երբեք չշփոթել օբյեկտի հատկությունը և օբյեկտի մեթոդը:

Սեփականությունը որոշակի ստատիկ արժեք է, և դրան մուտք գործելը գրվում է, օրինակ, առանց փակագծերի CurrentColumn.Name. Մեթոդն ըստ էության օբյեկտի պրոցեդուրա կամ ֆունկցիա է, և պրոցեդուրաներին և ֆունկցիաներին կանչերը միշտ գրվում են փակագծերով (նույնիսկ եթե մուտքային պարամետրեր չկան): Օրինակ: MyTZ.Columns.Quantity()

Եթե մենք մուտք գործենք մեթոդ և մոռանանք գրել փակագծերը, 1C թարգմանիչը մեզ սխալի հաղորդագրություն կտա և չի գործարկի կոդը: Քանի որ թարգմանիչը կհամարի, որ մենք մուտք ենք գործում ոչ թե մեթոդ, այլ հատկություն, քանի որ փակագծեր չկան: Բայց այն չի կարողանա գտնել այդ անունով հատկություններ (քանի որ կա միայն այդ անունով մեթոդ) - որը նշված կլինի սխալի հաղորդագրության մեջ:

Ահա թե ինչ կգրի թարգմանիչը, եթե ես մոռանամ փակագծեր դնել մեթոդի կանչի մեջ այդքան սխալ ձևով MyTZ.Columns.Quantity(առանց փակագծերի «Քանակ ()» հետո):

Օբյեկտի դաշտը չի գտնվել (Քանակ)

Այս դեպքում «դաշտը» և «սեփականությունը» պետք է հասկանալ որպես հոմանիշներ կամ 1C մշակողների տերմինաբանության անճշտություն: Նրանք այս երկու բառերն էլ օգտագործում են նույն հայեցակարգին անդրադառնալու համար: Թեև ծրագրավորման այլ լեզուներում այս տերմինները կարող են տարբեր բաներ նշանակել:

Տվյալների ստացում 1C արժեքների աղյուսակից՝ օգտագործելով սյունակների համարները

Սկսելու համար ես ձեզ առաջարկում եմ մեր աղյուսակի առաջին շարքից տվյալներ ստանալու պարզ օրինակ: Խնդրում ենք նկատի ունենալ, որ մենք օգտագործում ենք նախապես լրացված աղյուսակը հոդվածի սկզբից: Մենք հաստատ գիտենք, որ աղյուսակն ունի առաջին տող և առնվազն մեկ սյունակ։ Եթե այս օրինակը կիրառենք դատարկ աղյուսակի վրա, սխալ կառաջանա։ Այսպիսով.

FirstLine = MyTK; // ստացիր առաջին տողը (համարակալված զրոյից) FirstColumnValue = FirstRow; // ստանալ առաջին սյունակի արժեքը (սյունակների համարակալումը նույնպես զրոյից է) Report(Value of the FirstColumn); // ցուցադրել աղյուսակի առաջին շարքի առաջին սյունակի արժեքը

Էկրանը կցուցադրի.

Չապաեւը

Մենք սկզբում ստացանք արժեքների աղյուսակի տողի օբյեկտ՝ մուտք գործելով արժեքների աղյուսակ՝ օգտագործելով [...] օպերատորը: (եթե մոռացել եք, թե ինչպես դա անել, կարող եք դիտել նախորդ հոդվածները) Մենք օպերատորի ներսում փոխանցեցինք «0» փաստարկը: Սա արժեքների աղյուսակի առաջին շարքի ինդեքսն է։ FirstLine = MyTK;

Ավելին, մենք նաև իրավունք ունենք մուտք գործելու լարային օբյեկտ՝ օգտագործելով [...] օպերատորը: Այս օպերատորի ներսում մենք փոխանցեցինք արժեքների աղյուսակի սյունակի համարը, այս դեպքում նաև «0»: Եվ այսպիսով, մենք ստացանք «0» համարով սյունակի արժեքը ընթացիկ աղյուսակի «0» համարով տողի համար։ Մենք ցուցադրեցինք այս արժեքը էկրանին և այն ներկայացնում է «Chapaev» տողը:

Եկեք մի փոքր բարդացնենք մեր օրինակը.

FirstLine = MyTK; // ստանալ առաջին տողը (համարակալված զրոյից) Հաշվետվություն (FirstLine); // ցուցադրել առաջին սյունակի արժեքը աղյուսակի առաջին շարքում Report (FirstRow); // ցուցադրել երկրորդ սյունակի արժեքը աղյուսակի առաջին շարքում Report (FirstRow); // ցուցադրել աղյուսակի առաջին շարքի երրորդ սյունակի արժեքը

Այժմ մենք ցուցադրել ենք արժեքները մեր արժեքային աղյուսակի առաջին տողի բոլոր երեք սյունակներից.

Չապաև Վասիլի Իվանովիչ

Այժմ ես նույնպես կփոփոխեմ այս օրինակը, որպեսզի մենք կարողանանք անել առանց փոփոխականի «Առաջին գիծ»

Հաշվետվություն (MyTZ); // ցուցադրել առաջին սյունակի արժեքը աղյուսակի առաջին շարքում Report (MyTZ); // ցուցադրել երկրորդ սյունակի արժեքը աղյուսակի առաջին շարքում Report (MyTZ); // ցուցադրել աղյուսակի առաջին շարքի երրորդ սյունակի արժեքը

Նույնը կլինի էկրանին

Չապաև Վասիլի Իվանովիչ

Վերևի օրինակում մենք տեսանք, որ որոշակի տողում և արժեքների աղյուսակի որոշակի սյունակում գտնվող արժեք մուտք գործելու համար մենք կարող ենք օգտագործել երկու օպերատորների հաջորդական կանչը [...] այս ձևով. Արժեքների աղյուսակ[Տողերի ինդեքս][Սյունակի ինդեքս]

Այսպիսով, մենք պատրաստ ենք ստեղծել հանգույց և ստանալ բոլոր տողերի և բոլոր սյունակների տվյալները՝ օգտագործելով տողերի և սյունակների ինդեքսները.

RowCounter-ի համար = 0 By MyTZ.Quantity() - 1 Loop // ցիկլով տողերի միջով ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // nested loop սյունակների միջով // ստացեք բջիջի արժեքը (ընթացիկ տողից և ընթացիկ սյունակները) CellValue = MyTK[RowCounter][ColumnCounter]; // ցուցադրել տողի համարը, սյունակի համարը և բջիջի արժեքը Հաշվետվություն ("Տողի համար" + տողերի քանակ + "սյունակ թիվ" + սյունակների քանակ + " = " + CellValue); End Cycle; End Cycle;

Էկրանի վրա կցուցադրվի հետևյալը.

Տող No 0 սյունակ No 0 = Չապաև Գծ No 0 սյունակ No 1 = Վասիլի գիծ No 0 սյուն No 2 = Իվանովիչի տող No 1 սյուն No 0 = Ձերժինսկու գիծ No 1 սյունակ No 1 = Ֆելիքս Տող թիվ 1 սյունակ թիվ 2 = Էդմունդովիչ տող թիվ 2 սյուն թիվ 0 = Կոտովսկի տող թիվ 2 սյուն թիվ 1 = Գրիգորի տող թիվ 2 սյունակ թիվ 2 = Իվանովիչ

Օգտագործելով երկու ցիկլեր, որոնցից մեկը մյուսի մեջ է, մենք ցուցադրեցինք բոլոր սյունակների արժեքները 1C արժեքների աղյուսակի բոլոր տողերից: Այս դեպքում մենք չենք օգտագործել սյունակների անունները, այլ մուտք ենք գործել սյունակներ և տողեր իրենց ինդեքսներով: Ավելի հասկանալու համար ուշադրություն դարձրեք օրինակի ներսում եղած մեկնաբանություններին:

Եզրափակելով, ես առաջարկում եմ մի փոքր փոխել մեր օրինակը, որպեսզի սյունակների համարների փոխարեն էկրանին ցուցադրի նրանց անունները: Եվ բացի այդ, ես կպատրաստեմ ավելի ներկայանալի դիզայն՝ բովանդակությունը էկրանին ցուցադրելու համար։

LineCounter-ի համար = 0 By MyTZ.Quantity() - 1 Loop // շրջադարձ տողերի միջով Հաշվետվություն (" ======= Գծի համար. " + LineCounter + " ========"); Զեկուցել(" "); // տողերի հոսք (տեղադրեք դատարկ տող) ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // nested loop սյունակների միջով // ստացեք բջիջի արժեքը (ընթացիկ տողից և ընթացիկ սյունակից) CellValue = MyTZ [RowCounter][ ColumnCounter]; // ստանալ սյունակի անունը ColumnName = MyTZ.Columns[ColumnCounter].Name; // ցուցադրել սյունակի անունը և բջիջի արժեքը Report(ColumnName + ": " + CellValue); End Cycle; Զեկուցել(" "); // տողերի հոսք (դատարկ տող մտցնելով) EndCycle;

Այժմ, մեր էկրանին տեղեկատվությունը սկսեց ավելի ներկայացուցչական տեսք ունենալ.

Տող թիվ 0 ======= Ազգանուն՝ Չապաև Անուն՝ Վասիլի Հայրանուն՝ Իվանովիչ ======= Տող թիվ 1 ======= Ազգանուն՝ Ձերժինսկի Անուն՝ Ֆելիքս Հայրանուն. Էդմունդովիչ ===== == Տող թիվ 2 ======= Ազգանուն՝ Կոտովսկի Անուն՝ Գրիգորի Հայրանուն՝ Իվանովիչ

Այո, ես գրեթե մոռացել էի: Երկու [...][...] օպերատորներ անընդմեջ օգտագործելիս մենք կարող ենք սյունակի ինդեքսի փոխարեն փոխանցել այս սյունակի անունը. ValueTable[RowIndex][ColumnName]

LineCounter-ի համար = 0 By MyTZ.Quantity() - 1 Loop // շրջադարձ տողերի միջով Հաշվետվություն (" ======= Գծի համար. " + LineCounter + " ========"); Զեկուցել(" "); // տողերի հոսք (դատարկ տող տեղադրելով) ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // nested loop սյունակների միջով ColumnName = MyTZ.Columns[ColumnCounter].Name; // ստանալ սյունակի nameCell Value = MyTZ[RowCounter][ColumnName]; //

Ուշադրություն դարձրեք սլաքով նշված տողին: Այս տողում ընթացիկ սյունակի ինդեքսի փոխարեն մենք քառակուսի փակագծերում գտնվող փաստարկին փոխանցում ենք ընթացիկ սյունակի անվանումը [...] Արդյունքը կլինի նույնը:

Եվ հիմա, վերջին բանը այս հոդվածում:

1C արժեքների աղյուսակից բոլոր տվյալները ճիշտ ստանալը, օգտագործելով օղակները տողերի հավաքածուի և սյունակների հավաքածուի միջոցով

Յուրաքանչյուր ընթացիկ գծի համար MyTZ Loop-ից // հանգույց տողերի հավաքածուի միջոցով Հաշվետվություն(" ======= Տողի համար. Զեկուցել(" "); Յուրաքանչյուր CurrentColumn-ի համար MyTZ.Columns Loop-ից // nested loop, որը կրկնվում է սյունակների հավաքածուի միջոցով ColumnName = CurrentColumn.Name; // ստանալ սյունակի nameCellValue = CurrentRow[ColumnName]; // ստանալ բջիջի արժեքը BY սյունակի NAME Report(ColumnName + ": " + CellValue); // ցուցադրել սյունակի անունը և բջիջի արժեքը Ցիկլերի ավարտը; Զեկուցել(" "); End Cycle;

Օրինակում օգտագործվել է երկու օղակ: Սյունակների հավաքածուի միջով պտտվող օղակը տեղադրվում է տողերի միջով պտտվելու օղակի ներսում: Եթե դուք աշխատել եք վերը նշված օրինակների միջոցով և կարդացել եք նախորդ հոդվածները, ապա դժվարություն չեք ունենա հասկանալու, թե ինչպես է աշխատում այս օրինակը:

Վերջապես, ես հնարավորինս կնվազեցնեմ մեր վերջին օրինակի կոդի տողերի քանակը՝ վերացնելով միջանկյալ փոփոխականների օգտագործումը։ Մենք կստանանք «արդյունաբերական կոդի» նմուշ, որն օգտագործվում է իրական խնդիրներում։

Դա պետք է արվի միայն այն դեպքում, երբ դուք լավ հասկանում եք, թե ինչ եք անում: Եթե կոդը շատ բարդ է, ապա ընդունելի է թողնել միջանկյալ փոփոխականներ՝ ավելի ուշ ձեր սեփական կոդը հասկանալը հեշտացնելու համար։ Նաև ցանկացած ծածկագիր պետք է մեկնաբանվի գոնե նվազագույն չափով, որպեսզի որոշ ժամանակ անց ավելի հեշտ լինի հասկանալ ծրագրի տեքստերը։

MyTZ ցիկլի յուրաքանչյուր ընթացիկ գծի համար // կրկնել տողերի վրա Հաշվետվություն(" ======= Տողի համար. Յուրաքանչյուր CurrentColumn From MyTZ.Columns Loop // կրկնել սյունակների վրա Report(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); End Cycle; Զեկուցել(" "); End Cycle;

Էկրանի վրա ելքը չի փոխվել, այն մնում է նույնը, ինչ նախորդ օրինակում.

2 ՇԱԲԱԹԱԿԱՆ ԴԱՍԸՆԹԱՑ

«ԾՐԱԳՐԱՎՈՐՈՒՄ 1C-ում ՍԿՍՆԱԿՆԵՐԻ ՀԱՄԱՐ»

Դասընթացը կուղարկվի էլեկտրոնային փոստով: Դարձեք ծրագրավորող՝ կատարելով քայլ առ քայլ առաջադրանքները:

Մասնակցության համար անհրաժեշտ է միայն համակարգիչ և ինտերնետ

Դասընթացի անվճար մուտք.

Sp-force-hide (ցուցադրում՝ ոչ մեկը;).sp-form (ցուցադրում՝ բլոկ; ֆոն՝ #eff2f4; լիցք՝ 5px; լայնություն՝ 270px; առավելագույն լայնություն՝ 100%, եզրագծի շառավիղ՝ 0px; -moz-սահման -շառավիղ՝ 0px; -webkit-border-radius՝ 0px; տառատեսակ-ընտանիք՝ Arial, «Helvetica Neue», sans-serif; ֆոնային կրկնություն՝ առանց կրկնելու; ֆոնի դիրքը՝ կենտրոն; ֆոնի չափը՝ ավտոմատ;) .sp-form մուտքագրում ( էկրան՝ inline-block; անթափանցիկություն՝ 1; տեսանելիություն՝ տեսանելի;).sp-form .sp-form-fields-wrapper ( լուսանցք՝ 0 ավտոմատ; լայնություն՝ 260px;).sp-form .sp -form-control (ֆոն՝ #ffffff; եզրագույն՝ #cccccc; եզրագծի ոճ՝ ամուր; եզրագծի լայնություն՝ 1px; տառաչափ՝ 15px; ներդիր՝ ձախ՝ 8,75px; ներդիր՝ աջ՝ 8,75px; եզրագիծ -շառավիղը՝ 4px; -moz-border-radius՝ 4px; -webkit-border-radius՝ 4px; բարձրությունը՝ 35px, լայնությունը՝ 100%;).sp-form .sp-field label (գույնը՝ #444444; տառատեսակ- չափը՝ 13px; տառատեսակի ոճը՝ նորմալ; տառատեսակի քաշը՝ թավ;). ֆոնի գույնը՝ #f4394c, գույնը՝ #ffffff, լայնությունը՝ 100%, տառատեսակի քաշը՝ 700; տառատեսակի ոճը՝ նորմալ; տառատեսակ-ընտանիք՝ Arial, «Helvetica Neue», sans-serif; տուփ-ստվեր՝ ոչ մի; -moz-box-shadow՝ ոչ մեկը; -webkit-box-shadow՝ ոչ մեկը; ֆոն՝ գծային գրադիենտ (վերև, #e30d22, #f77380);

(Այս հոդվածը պատկանում է 1C հոդվածների շարքին զրոյից; 1C ծրագրավորում զրոյից; 1C արժեքների աղյուսակ)

Վիրտուալ տվյալների պահպանման կառուցվածքը աղյուսակային ձևով. ահա թե ինչ է դա

Արժեքների աղյուսակը 1C տվյալների բազայի մշտական օբյեկտ չէ և չի պահպանվում գործարկման նիստերի միջև:

Արժեքների աղյուսակ 1C(TK) ստեղծվում է «թռիչքի վրա»՝ օգտագործելով ծրագրային կոդը, այնուհետև դրա հետ աշխատանքը կատարվում է այնպես, ինչպես 1C ծրագրավորման լեզվի ցանկացած այլ ծրագրի օբյեկտի հետ: Օգտագործելով մեթոդի կանչեր և մուտք գործելով աղյուսակ-օբյեկտի հատկությունները:

Այսինքն՝ ծրագրավորողը հիշողության մեջ աղյուսակ է ստեղծում, լրացնում է տվյալներով, աշխատում է դրանցով, տեսակավորում, խմբավորում, տոտալների հաշվարկ և այլն։ Ստանում է անհրաժեշտ տվյալներ հետագա օգտագործման համար:

Եկեք ստեղծենք արժեքների աղյուսակ և այն լրացնենք ինչ-որ բանով: Պետք է հիշել, որ 1C արժեքների աղյուսակը կարող է ստեղծվել ոչ միայն ձեռքով, զանգահարելով օպերատորին

NewValueTable;

Արժեքների աղյուսակը հաճախ արդյունք է մեթոդի կանչի մեկ այլ օբյեկտի, օրինակ՝ հարցման արդյունքը կարող է թափվել արժեքների աղյուսակի մեջ և այլն:

Անմիջապես մի պարզ օրինակ բերեմ.

// MyTZ = New ValueTable; // ստեղծել արժեքների նոր աղյուսակ, որը պահվում է «MyTZ» փոփոխականում MyTK. Սյունակներ. Ավելացնել ("Ազգանուն"); // ստեղծել «Ազգանուն» սյունակը MyTZ. Սյունակներ. Ավելացնել («Անուն»); // ստեղծել «Անուն» սյունակըՀաշվետվություն (MyTZ); // ցուցադրել MyTZ փոփոխականի արժեքը //

Ես ստեղծեցի 1C արժեքների աղյուսակ՝ երկու սյունակով՝ «Ազգանուն», «Անուն»: Ընթացակարգը Հաշվետվություն (MyTK)հաղորդագրության պատուհանում կցուցադրի փոփոխականի տեսակը MyTZ: Արժեքների աղյուսակ

Մեր արժեքային աղյուսակն առայժմ դատարկ է: Դրան ավելացնենք մի երկու տող՝ անուն-ազգանուններով։

// լրացնել արժեքների աղյուսակը // ավելացրեք առաջին տողը մեր արժեքային աղյուսակում NewLine = MyTZ: Ավելացնել () ; Նոր գիծ. Ազգանուն = «Սիդորով» ; Նոր գիծ. Անուն = «Վասյա» ; // ավելացնել երկրորդ տող մեր արժեքների աղյուսակում NewLine = MyTZ: Ավելացնել () ; Նոր գիծ. Ազգանուն = «Իվանով» ; Նոր գիծ. Անուն = «Պետրոս» ;

Մենք ստացանք այսպիսի աղյուսակ.

Պետք է հիշել. Արժեքների աղյուսակում տողերի համարները սկսվում են զրոյից

Ինչու մեզ նույնիսկ տողերի համարներ են պետք: Եվ որպեսզի մենք կարողանանք մուտք գործել արժեքների աղյուսակի առանձին տող, օրինակ, վերցնենք և ցուցադրենք այս տողը էկրանին։

// *** էկրանին ցուցադրում է զրոյական գծի արժեքները *** (առօրյա կյանքում մենք սովորաբար թվարկում ենք իրերը՝ սկսած մեկից, բայց այստեղ՝ զրոյից) // ստացեք մեր աղյուսակի զրոյական տողը՝ օգտագործելով քառակուսի փակագծերում տողերի ինդեքսը OurNullString = MyTZ[0]; // այժմ ամբողջ զրոյական տողը պարունակվում է «OurFirstLine» փոփոխականումԶեկույց (OurNullString.LastName) ; // ցուցադրել զրոյական տողում պահվող «Ազգանուն» սյունակի արժեքըՀաշվետվություն (OurNullString.Name) ; // ցուցադրել «Անուն» սյունակի արժեքը նույն տողից

Արդյունքում էկրանին կցուցադրվի.

Սիդորով Վասյա

Հիմա, շատ խելացի և հակիրճ լինելու համար, ես ցույց կտամ մի օրինակ, որը թույլ է տալիս մուտք գործել սյունակի արժեքը այս և այն տողում (այս և նման տողում սյունակի արժեքը արժեքների աղյուսակի բջիջն է Ոչ պաշտոնական տերմին, բայց հարմար): Բայց առանց «OurZeroString»-ի նման միջանկյալ փոփոխական օգտագործելու:

Երկրորդ շարքից բջիջների արժեքը ցուցադրելու համար (մի մոռացեք, որ տողը երկրորդն է, բայց այս տողի ինդեքսը մեկն է, ուստի համարակալումը սկսվում է զրոյից)

Վերջապես, այս հոդվածի վերջնական կետը: Ես ձեզ ցույց տվեցի արժեքային աղյուսակի մեկ տող մուտք գործելու օրինակ՝ ըստ ինդեքսի (տողի համարի): Բջիջի բովանդակությունը կարդալու կամ նշանակելու համընդհանուր ձևն է՝ «MyValueTable[RowNumber].ColumnName»:

Այժմ ես ձեզ կտամ արժեքների աղյուսակի բովանդակության ամբողջական թողարկման ցիկլ: Առանց մանրամասն բացատրությունների, որպեսզի կարողանաք նաև ձեր ուղեղները հավաքել :)

// // շրջանցել և ցուցադրել մեր արժեքների աղյուսակի բոլոր տողերը// LineNumber-ի համար = 0 Ըստ MyTK-ի: Քանակ() - 1 ցիկլի հաշվետվություն (MyTZ[LineNumber]. Ազգանուն) ; // ցուցադրել «Ազգանուն» սյունակի արժեքըՀաշվետվություն (MyTK[LineNumber] . Անուն) ; // ցուցադրել «Անուն» սյունակի արժեքըՎերջնական ցիկլ;

Այս օղակը գործարկելու արդյունքում էկրանին կցուցադրվի հետևյալը.

Սիդորով Վասյա Իվանով Պետյա

Այստեղ ես ձեզ ասացի 1C արժեքների աղյուսակի հետ աշխատելու հիմունքները: Այս տեղեկատվությունը վերաբերում է 1C 8.0-ին, 8.1-ին, 8.2-ին: «1C արժեքների աղյուսակ» օբյեկտի վերաբերյալ հետաքրքիր մանրամասները դրանով չեն ավարտվում: Այս օբյեկտն ունի տվյալների հետ հարմար աշխատանքի հսկայական հնարավորություններ։ Այս մասին կխոսեմ հաջորդ հոդվածներում։

Դեգտյարև Ռոման.

Ինչպե՞ս սովորել զրոյից ծրագրավորել 1C-ում:

Ինչպե՞ս աշխատել որպես 1C ծրագրավորող և ամսական վաստակել մինչև 150,000 ռուբլի:

ԳՐԱՆՑՎԵՔ ԱՆՎՃԱՐ

2 ՇԱԲԱԹԱԿԱՆ ԴԱՍԸՆԹԱՑ

«ԾՐԱԳՐԱՎՈՐՈՒՄ 1C-ում ՍԿՍՆԱԿՆԵՐԻ ՀԱՄԱՐ»

Դասընթացը կուղարկվի էլեկտրոնային փոստով: Դարձեք ծրագրավորող՝ կատարելով քայլ առ քայլ առաջադրանքները:

Մասնակցության համար անհրաժեշտ է միայն համակարգիչ և ինտերնետ

Դասընթացի անվճար մուտք.

Ողջույններ infostart-ի բոլոր ընթերցողներին։ Այս հոդվածը նվիրված կլինի ծրագրային կերպով կառավարվող հավելվածի ձևի վրա արժեքների կամայական աղյուսակ ստեղծելու խնդրին:

Առաջադրանքի առանձնահատկությունները.

Յուրաքանչյուր ոք, ով ծրագրավորել է սովորական հավելվածում, հաճախ բախվել է ձևի վրա արժեքների կամայական աղյուսակ ստանալու խնդիր: Արժեքների կամայական աղյուսակը աղյուսակ է, որի սյունակների քանակը և տեսակը նախապես հայտնի չեն: Այսինքն, կարող է լինել 3 սյունակ, կամ գուցե 6, կամ գուցե 8: Սովորական հավելվածում ամեն ինչ պարզ է. կարող եք մշակման ձևի վրա տեղադրել «Արժեքների աղյուսակ» տարրը, այնուհետև փոխանցել ստեղծված արժեքների աղյուսակը: այս տարրին ծրագրային կերպով: Այնուհետև պարզ հրամանով.

Form Elements.TableField.CreateColumns();

ստացեք ձևի վրա արժեքների պատրաստի աղյուսակ: Թվում է, թե դա կարող է ավելի պարզ լինել:

Այս ամենը սովորական հավելվածում էր։ Կառավարվող հավելվածում ամեն ինչ փոխվել է։ Կամայական աղյուսակ ստեղծելն այնքան էլ հեշտ չէ: Այժմ դուք պետք է կամ կոշտորեն պարամետրացնեք արժեքների աղյուսակը ձևի վրա, կամ ստեղծեք այն ծրագրավորված (նկարագրեք, լավ, սա, ըստ էության, ինքնին կառավարվող հավելվածի էությունն է): Սա այն է, ինչ մենք կփորձենք անել. ծրագրային կերպով ստեղծել արժեքների կամայական աղյուսակ վերահսկվող ձևի վրա:

Խնդրի լուծումը.

Առաջին բանը, որ մենք պետք է անենք, այն է, թե ինչպես է աղյուսակը հայտնվել ձևաթղթում: Հիմնական բանն այն է, որ մշակման մեջ ձևի որևէ տարր ստեղծելու կարիք չկա: Մենք այն կստեղծենք ծրագրային կերպով, ինչպես ամբողջ աղյուսակը: Այսինքն՝ աղյուսակը նկարագրվելու և ստեղծվելու է ձևը բացելու կամ կոճակ օգտագործելու պահին՝ կախված նրանից, թե ում է պետք։

Ձևի վրա աղյուսակի ստեղծումը տեղի է ունենում արժեքների աղյուսակի նկարագրության միջոցով՝ որպես հատկանիշ.
SelectionTypeArray = Նոր զանգված; SelectionType.Add-ի զանգված (Type («Արժեքների աղյուսակ»)); ChoiceTypeDescription = New TypeDescription (ChoiceTypeArray); Մանրամասների զանգված = Նոր զանգված; Array of Attributes.Add(New Form Attributes ("Schedule Table", Description of SelectionType, "", "TZN")); Այժմ մենք պետք է ստեղծենք արժեքների ծրագրային աղյուսակ, որը պարունակում է տվյալներ: Եթե արժեքների աղյուսակը ստացվում է հարցումից, ապա ամեն ինչ քիչ թե շատ կարգին է։ Եթե աղյուսակը ստեղծվում է ձեռքով, ապա «Տիպերի նկարագրության» միջոցով կարելի է ստեղծել թվեր կամ ամսաթվեր պարունակող սյունակների նշանակությունը: Բանն այն է, որ արժեքների աղյուսակի սյունակները պետք է ունենան որոշակի տեսակ: Եթե, օրինակ, ակնկալվում է, որ օգտվողը ինտերակտիվ կերպով կլրացնի տվյալ սյունակներում, ապա դուք չեք կարող արժեքների աղյուսակի սյունակ ավելացնել պարզապես անունով, այն պետք է ունենա տեսակ: Հիշեք, սա շատ կարևոր է, քանի որ... Մենք այս տեսակները կտեղափոխենք ձևի սեղանին:
Մենք ստեղծում ենք աղյուսակ, որը պարունակում է մի քանի սյունակներ.
CD = NewDateQualifiers (DateParts.Time); ArrayKD = Նոր զանգված; ArrayCD.Add (Type ("Date")); DescriptionTypesTime = Նոր DescriptionTypes(ArrayCD,CD); TZ = New ValueTable;
TK.Columns.Add("With", DescriptionTypesTime);
TK.Columns.Add("Before", DescriptionTypesTime);
TK.Columns.Add(«Անուն»);
TK.Columns.Add(«Նշում»); // Ամբողջական անուն և նշում - տողեր Հաջորդը, մենք կլցնենք մեր TK ծրագրի աղյուսակը անհրաժեշտ տվյալներով: Մենք ստանում ենք TK աղյուսակ, որը պարունակում է անհրաժեշտ արժեքներ և պատրաստ է փոխանցվել ստեղծված ձևի հատկանիշին: TK-ից յուրաքանչյուր սյունակի համար Սյունակների ցիկլը

Array of Attributes.Add(New Form Attributes(Column.Name, Column.ValueType,"ScheduleTable"));

End Cycle;
ChangeDetails (ArrayDetails);
SelectionFieldsTable = Elements.Add("TZN", Type("FormTable"));
SelectionFieldsTable.DataPath = "ScheduleTable";
SelectionFieldTable.Display = TableDisplay.List;

Սա պարզ համադրություն է, և մեր սեղանը պատրաստ է։

TK-ից յուրաքանչյուր սյունակի համար Սյունակների ցիկլը

NewElement = Elements.Add(Column.Name, Type("FormField"), SelectionFieldTable);
NewElement.View = FormFieldView.InputField;
NewElement.DataPath = «ScheduleTable»: + Column.Name;
NewElement.Width = 10;

End Cycle;

Պայմանական դիզայն, եթե մեզ պետք է, մենք էլ ենք ձեռքով գրում, հրամանի ընտրացանկը՝ ձեռքով։ Սեղանի մշակիչները նույնպես գրված են ձեռքով: Օրինակ՝ «Ընտրություն» աղյուսակի համար իրադարձությունների մշակիչ ավելացնելու համար.

SelectionFields.SetAction ("Ընտրություն","TZNSelection");

Այս իրադարձությունը մշակելու համար սահմանված է առանձին ընթացակարգ՝ ընթացակարգի տեսքով.

&OnClient
Ընթացակարգ TKNSelection (TK, Selected Row, Field, StandardProcessing)
// handler հրամաններ EndProcedure

Նկատի ունեցեք, որ սեղանի մշակիչները կրակում են հաճախորդի վրա և, հետևաբար, պետք է ունենան կոմպիլյատորի ցուցիչի հրաման

&OnClient

Դե, վերջին բանը, որ ես ուզում էի ավելացնել այն է, որ այս բոլոր քայլերից հետո, համոզվեք, որ հիշեք, որ պատրաստի աղյուսակը փոխանցեք ձևի հատկանիշին.

ValueВFormAttributes (ToR, «ScheduleTable»);

Սա այն է, ինչ մենք ունենք արդյունքում.

Եվ ահա «Ընտրություն» միջոցառման ընթացքը.

Հետբառ.

Հուսով եմ, որ հոդվածը կօգնի այն 1C ծրագրավորողներին, ովքեր սկսում են ծրագրային ձևով աղյուսակներ ստեղծել:

Դուք կարող եք ներբեռնել մշակում, որը ծրագրային կերպով ստեղծում է արժեքների աղյուսակ և ցուցադրում այն կառավարելի ձևի վրա՝ մեկնաբանություններով, որոնք կօգնեն ձեզ ստեղծել ձեր սեփական աղյուսակները:

Փողերի և ապրանքների հաշվառման համար բիզնեսում լայնորեն կիրառվում են տարբեր աղյուսակներ։ Գրեթե յուրաքանչյուր փաստաթուղթ աղյուսակ է:

Մեկ աղյուսակում ներկայացված են պահեստից առաքվող ապրանքները: Մեկ այլ աղյուսակում ներկայացված են այդ ապրանքների համար վճարելու պարտավորությունները:

Հետևաբար, 1C-ում աղյուսակների հետ աշխատելը նշանավոր տեղ է զբաղեցնում:

1C-ի աղյուսակները կոչվում են նաև «աղյուսակային մասեր»: Գրացուցակները, փաստաթղթերը և այլք ունեն դրանք:

Հարցումը, երբ կատարվում է, վերադարձնում է աղյուսակ, որը կարելի է մուտք գործել երկու տարբեր եղանակներով:

Առաջին - ավելի արագ - ընտրությունը, դրանից տողեր ստանալը հնարավոր է միայն կարգով: Երկրորդը հարցման արդյունքի վերբեռնումն է արժեքների աղյուսակում և այնուհետև պատահական մուտք դեպի դրան:

//Ընտրանք 1 – հաջորդական մուտք դեպի հարցումների արդյունքներ

//ստացեք սեղանը
Ընտրել = Query.Run().Select();
// մենք հերթականությամբ անցնում ենք հարցման արդյունքի բոլոր տողերը
Մինչ Select.Next() հանգույց
Հաշվետվություն (Ընտրություն. Անուն);
End Cycle;

//Ընտրանք 2 – վերբեռնում արժեքների աղյուսակում
Request = New Request ("SELECT Name FROM Directory.Nomenclature");
//ստացեք սեղանը
Աղյուսակ = Query.Run().Unload():
//հետագայում մենք կարող ենք նաև կրկնել բոլոր տողերի միջով
Աղյուսակի ցիկլի յուրաքանչյուր տողի համար
Հաշվետվություն (String.Name);
End Cycle;
//կամ կամայականորեն մուտք գործել տողեր
Row = Table.Find("Shovel", "Name");

Կարևոր առանձնահատկությունն այն է, որ աղյուսակում, որը ստացվում է հարցման արդյունքից, բոլոր սյունակները խիստ մուտքագրված կլինեն: Սա նշանակում է, որ Անուն դաշտը Անվանակարգի գրացուցակից խնդրելով, դուք կստանաք String տեսակի սյունակ, որի թույլատրելի երկարությունը ոչ ավելի, քան N նիշ:

Աղյուսակ ձևի վրա (հաստ հաճախորդ)

Օգտագործողը աշխատում է սեղանի հետ, երբ այն տեղադրվում է ձևի վրա:

Մենք քննարկել ենք ձևերի հետ աշխատելու հիմնական սկզբունքները դասին և դասընթացին

Այսպիսով, եկեք սեղանը դնենք ձևաթղթի վրա: Դա անելու համար կարող եք աղյուսակը քաշել Controls վահանակից: Նմանապես, ընտրացանկից կարող եք ընտրել Form/Insert Control:

Տվյալները կարող են պահպանվել կոնֆիգուրացիայի մեջ, այնուհետև դուք պետք է ընտրեք կազմաձևման օբյեկտի գոյություն ունեցող (նախկինում ավելացված) աղյուսակային մասը, որի ձևը խմբագրում եք:

Սեղմեք «...» կոճակը Տվյալների հատկության մեջ: Աղյուսակային մասերի ցանկը տեսնելու համար անհրաժեշտ է ընդլայնել Object մասնաճյուղը։

Երբ ընտրում եք աղյուսակային մասը, 1C-ն ինքնին սյունակներ կավելացնի ձևի աղյուսակում: Օգտագործողի կողմից նման աղյուսակում մուտքագրված տողերը ավտոմատ կերպով կպահվեն տեղեկատուի/փաստաթղթի հետ միասին:

Նույն Տվյալների հատկությունում կարող եք մուտքագրել կամայական անուն և ընտրել Արժեքների աղյուսակի տեսակը:

Սա նշանակում է, որ ընտրվել է արժեքների կամայական աղյուսակ: Այն ավտոմատ կերպով չի ավելացնի սյունակներ, ոչ էլ ինքնաբերաբար կպահվի, բայց դուք կարող եք անել այն, ինչ ուզում եք դրա հետ:

Սեղանի վրա աջ սեղմելով կարող եք սյունակ ավելացնել: Սյունակի հատկությունների մեջ կարող եք նշել դրա անունը (1C կոդում հղման համար), ձևի սյունակի վերնագիրը, աղյուսակային մասի հատկանիշի հետ կապը (վերջինս, եթե ոչ կամայական աղյուսակ է ընտրված, այլ աղյուսակային մաս):

Ձևի աղյուսակի հատկություններում կարող եք նշել, թե արդյոք օգտվողը կարող է տողեր ավելացնել/ջնջել: Ավելի առաջադեմ ձև է միայն դիտել վանդակը: Այս հատկությունները հարմար են օգտագործել տեղեկատվության ցուցադրման, բայց ոչ խմբագրման համար նախատեսված աղյուսակների կազմակերպման համար:

Աղյուսակը կառավարելու համար պետք է ձևաթղթի վրա ցուցադրել հրամանի վահանակ: Ընտրեք ցանկի տարրը Ձև / Տեղադրեք վերահսկում / Հրամանի տող:

Հրամանի տողի հատկություններում ընտրեք «Ավտոլրացում» վանդակը, որպեսզի վահանակի կոճակները ինքնաբերաբար հայտնվեն:

Աղյուսակ ձևի վրա (բարակ/կառավարվող հաճախորդ)

Կառավարվող ձևի վրա այս գործողությունները մի փոքր այլ տեսք ունեն: Եթե Ձեզ անհրաժեշտ է ձևաթղթի վրա տեղադրել աղյուսակային մաս, ընդլայնեք Object մասնաճյուղը և քաշեք աղյուսակային մասերից մեկը դեպի ձախ: Այսքանը:

Եթե Ձեզ անհրաժեշտ է արժեքների աղյուսակ տեղադրել, ապա ավելացրեք ձևի նոր հատկանիշ և դրա հատկություններում նշեք տիպը՝ արժեքների աղյուսակ:

Սյունակներ ավելացնելու համար օգտագործեք աջ սեղմման ընտրացանկը այս ձևի հատկանիշի վրա, ընտրեք Ավելացնել հատկանիշ սյունակ:

Այնուհետև քաշեք աղյուսակը դեպի ձախ:

Որպեսզի աղյուսակն ունենա հրամանի տող, աղյուսակի հատկություններում ընտրեք արժեքները Usage – Command bar position բաժնում:

Աղյուսակի վերբեռնում Excel-ում

Ձևաթղթում տեղադրված ցանկացած 1C աղյուսակ կարող է տպվել կամ վերբեռնվել Excel-ում:

Դա անելու համար աջ սեղմեք աղյուսակի դատարկ տարածության վրա և ընտրեք Ցուցակ:

Կառավարվող (բարակ) հաճախորդում նմանատիպ գործողություններ կարող են իրականացվել՝ օգտագործելով ցանկի տարրը Բոլոր գործողությունները/Ցուցադրել ցանկը:

Հարց 1C v8-ում տարբեր տեսակի արժեքների աղյուսակի սյունակի ստեղծում
ՊատասխանելԱրժեքների աղյուսակի սյունակ ստեղծելիս կարող եք անցնել տեսակների զանգված, և գուցե կոնկրետ տեսակ: Տեսակների զանգվածն օգտագործվում է, երբ մեկ սյունակի համար պետք է նշել մի քանի տարբեր տեսակներ:

Օգտագործվում է տեսակները նշելու համար «Ընդհանուր օբյեկտ» - «Տեսակների նկարագրություն». Հետևաբար, նախ կբացատրենք, թե ինչ է իրենից ներկայացնում «Տիպերի նկարագրությունը» («Արժեքի տեսակների նկարագրություն»):

«Արժեքի տեսակների նկարագրություն». Համակարգում տարբեր օբյեկտների գույքային արժեքների ընդունելի տեսակները նկարագրելու համար օգտագործվում է հատուկ օբյեկտ «Տեսակների նկարագրություն». Օգտագործելով այս օբյեկտը, դուք կարող եք նկարագրել արժեքների վավեր տեսակներ, որոնք կարող են վերագրվել հատկություններին: Ավելի սահմանափակելու համար պարզունակ տեսակների հնարավոր արժեքները տրամադրվում են Number, String և Date որակավորումներ. Որակավորիչները նկարագրում են այնպիսի պարամետրեր, ինչպիսիք են տողի կամ թվի երկարությունը, ամսաթվի վավեր մասերը և այլն:

«Տիպի նկարագրություն» մեթոդի շարահյուսություն

Նոր նկարագրության տեսակներ (<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
Ընտրանքներ:
<Исходное описание типов> (ըստ ցանկության)
Տեսակ՝ Նկարագրություն Տեսակներ. Տեսակների նախնական նկարագրությունը, որի հիման վրա կկառուցվի նորը.
<Добавляемые типы> (ըստ ցանկության)
Տեսակ՝ զանգված, տող: Տիպի արժեքների զանգված՝ A Type, որը բաղկացած է այն տեսակներից, որոնք կօգտագործվեն օբյեկտում, կամ ստորակետերով բաժանված տեսակների անունները պարունակող տող:
<Вычитаемые типы> (ըստ ցանկության)
Տեսակ՝ զանգված, տող: Տիպի արժեքների զանգված (կամ ստորակետերով բաժանված տիպի անուններ պարունակող տող), որը բաղկացած է այն տեսակներից, որոնք կբացառվեն առաջին պարամետրում նշված նախնական հայտարարագրից:
<Квалификаторы числа> (ըստ ցանկության)
Տեսակ՝ Որակավորման համարներ: Թվերի որակիչներ, որոնք նկարագրում են թվային տիպի վավեր արժեքներ:
<Квалификаторы строки> (ըստ ցանկության)
Տեսակ՝ QualifiersStrings: Տողերի որակիչներ, որոնք նկարագրում են լարային տեսակի վավեր արժեքները:
<Квалификаторы даты> (ըստ ցանկության)
Տեսակ՝ Որակավորման Ամսաթվեր: Ամսաթվի որակիչներ, որոնք նկարագրում են Date տեսակի վավեր արժեքները:
Նկարագրություն:
Ստեղծում է տիպի նկարագրություն՝ հիմնվելով մեկ այլ տեսակի նկարագրության վրա՝ ավելացնելով որոշ տեսակներ և բացառելով մյուսները: Եթե նոր որակավորում չի նշվում, ապա բնօրինակ տիպի հայտարարագրի որակավորումները կպահպանվեն:
«Տիպի նկարագրություն» օբյեկտի օգտագործման օրինակ.

// Ընդլայնել Valid Types-ի նկարագրությունը նոր տեսակներով Array = Նոր զանգված; Զանգված. Ավելացնել (տեսակ ( «Հղում. Մեթոդներ»)); Զանգված. Ավելացնել (Տեսակ («Համար» )); Նշան = ValidSign. Ոչ բացասական; QuNumbers = New QualifiersNumbers(10, 2, Sign); ValidTypes = NewTypeDescription (ValidTypes, Array, KvNumbers);

Այժմ, փաստորեն, աղյուսակում տարբեր տեսակի սյունակների արժեքների ճիշտ ստեղծման օրինակներ:

Ընդհանուր առմամբ, բավական է սյունակների տեսակները սահմանել հետևյալ կերպ.

TK. Սյունակներ. Ավելացնել ( «Տեսակավորող ինդեքս», Նոր ՆկարագրությունՏեսակներ ( «Թիվ» ) ; TK. Սյունակներ. Add("SectionName", New TypeDescription("String") ); TK. Սյունակներ. Add("DataCorr" , New TypeDescription("Date") ); TK. Սյունակներ. Ավելացնել ( «Անվերապահ ջնջում», New TypeDescription («Բուլյան»)); TK. Սյունակներ. Add("Nomenclature" , New TypeDescription() ); TK. Սյունակներ. Ավելացնել ("SectionData", New TypeDescription("Structure")); // «համար» և «տող» սյունակներ ստեղծելու օրինակ՝ պարամետրերի հստակեցմամբ. TK. Սյունակներ. Ավելացնել ( «Տոկոսն ավարտված է», Նոր ՆկարագրությունՏեսակներ ( «Թիվ» , Նոր որակավորումներԹվեր ( 18 , 2 ) ) ; TK. Սյունակներ. Add("SectionName" , NewTypeDescription("String" , , NewStringQualifiers(200, AllowedLength. Variable) ) ; TK. Սյունակներ. Add("DecommissionedDate" , NewTypeDescription("Date" , , , NewDateQualifiers(DateParts.DateTime) ) ;

Այնուամենայնիվ, ավելի ընդհանուր առմամբ, զանգվածը փոխանցվում է որպես սյունակի տեսակ: Զանգվածն օգտագործվում է, երբ մեկ սյունակում պետք է մի քանի տեսակներ վերագրվեն: Այնուհետև կառուցվածքի սահմանումը կլինի մոտավորապես այսպիսին (օրինակներ տրված են տարբեր տեսակի սյունակների համար, երբ տեսակը զանգված է, բայց պարզության համար զանգվածի կազմը տրված է նույն տիպի, որպեսզի չշփոթվի. )

////// տեխնիկական բնութագրերի կառուցվածքի ձևավորում (սյունակների ստեղծում) //// սահմանել փոխարինման որակավորումներ տեխնիկական բնութագրի որակավորման դաշտերում CN = New QualifiersNumbers (18, 9); KS = NewStringQualifiers (200); CD = NewDateQualifiers (DataParts.DateTime) ; //// սահմանել տիպի նկարագրություններ ապագա TK սյունակների համար // Զանգվածը տեսակների սկզբնական նկարագրությունն է, որի հիման վրա կկառուցվի նորը // Խնդրում ենք նկատի ունենալ, որ TK սյունակների համար այս օրինակում սկզբնական տիպի նկարագրությունը զանգված էԶանգված = Նոր զանգված; Զանգված. Add(Type("String") ); TypeDescriptionString = New TypeDescription(Array, , KS) ; Զանգված. Մաքրել (); Զանգված. Ավելացնել(Տեսակ(«Համար») ); TypeDescriptionNumber = New TypeDescription(Array, , , CN) ; Զանգված. Մաքրել (); Զանգված. Ավելացնել (Տեսակ («Ամսաթիվ») ); DescriptionTypesDate = New DescriptionTypes(Array, , , , CD) ; Զանգված. Մաքրել (); Զանգված. Ավելացնել (տեսակ ( «DirectoryLink.Nomenclature»)) ; Տիպ ՆկարագրությունԱնվանակարգ = Նոր տեսակի նկարագրություն (զանգված) ; Զանգված. Մաքրել (); Զանգված. Ավելացնել (տեսակ ( «DirectoryLink.SeriesNomenclature»)) ; TypeDescriptionSeries = New TypeDescription(Array) ; Զանգված. Մաքրել (); Զանգված. Ավելացնել (տեսակ ( «DirectoryLink.Quality»)) ; TypeDescriptionQuality = New TypeDescription(Array) ; Զանգված. Մաքրել (); Զանգված. Add(Type("Boolean") ); TypeDescriptionBoolean = New TypeDescription(Array) ; // իրականում սյունակներ ավելացնելով TK-ին (ստեղծելով ապագա TK-ի կառուցվածքը) TK. Սյունակներ. Ավելացնել(«Անվանակոչ», ՆկարագրությունՏիպերԱնոմենկլատուրա) ; TK. Սյունակներ. Ավելացնել ("Code" , TypeDescriptionString) ; TK. Սյունակներ. Ավելացնել ( «Սերիա նոմենկլատուրա», DescriptionTypesSeries); TK. Սյունակներ. Add("AccountCode" , Type DescriptionString) ; TK. Սյունակներ. Add("ActionDate", TypeDescriptionDate); TK. Սյունակներ. Add("Quality", TypeDescriptionQuality) ; TK. Սյունակներ. Ավելացնել ("NumberUS", DescriptionTypesNumber) ; TK. Սյունակներ. Ավելացնել («Դուրս գրել», TypeDescriptionBoolean); . . . //////// տեխնիկական բնութագրերի կառուցվածքի ձևավորում (սյունակների ստեղծում) ////////////////////////////////////////////////////////

Արժեքների աղյուսակում տող ավելացնելու համար տե՛ս