1c მნიშვნელობების ცხრილის შექმნა. რა მეთოდები არსებობს და როგორ მოვიძიოთ რამდენიმე მნიშვნელობა ერთდროულად

გამოქვეყნებულია 2011 წლის 21 სექტემბერს

მნიშვნელობების ცხრილი 1C - ნაწილი 3. მეტამონაცემები. მნიშვნელობების ცხრილის სვეტების ციკლი

ამ სტატიაში მე გეტყვით, თუ როგორ უნდა იმუშაოთ "უცნობი" სტრუქტურის მნიშვნელობების ცხრილთან, როგორ გაიმეოროთ მნიშვნელობების ცხრილის სვეტები, როგორ ამოიღოთ მონაცემები სვეტებიდან და რიგებიდან სვეტების სახელების გამოყენების გარეშე. (ეს სტატია ეკუთვნის 1C სტატიების სერიას ნულიდან; 1C-ის პროგრამირება ნულიდან; 1C მნიშვნელობების ცხრილი)

მასალის ასახსნელად და ჩვენი კოდის მაგალითების „ლაივ რეჟიმში“ გაშვება გვჭირდება 1C მნიშვნელობების ტესტის ცხრილი. ჩვენი ზოგიერთი მაგალითი ამოიღებს მონაცემებს მნიშვნელობების ცხრილიდან, ასე რომ, ჩვენ გავაკეთებთ ცხრილს სამი სვეტით "გვარი", "სახელი", "შუა სახელი" და შევიყვანთ მასში მცირე რაოდენობით მონაცემებს - 3-მდე. რიგები :)

მოდით შევქმნათ 1C მნიშვნელობების სატესტო ცხრილი და შეავსოთ იგი:

MyTZ = New ValueTable; // შექმენით მნიშვნელობების ახალი ცხრილი, რომელიც ინახება ცვლადში "MyTZ" MyTZ.Columns.Add("გვარი"); // შექმენით სვეტი "გვარი" MyTZ.Columns.Add("Name"); // შექმენით სვეტი "Name" MyTZ.Columns.Add("Patronymic"); // შექმენით სვეტი "შუა სახელი" // დაამატეთ პირველი რიგი ჩვენს მნიშვნელობების ცხრილში NewLine = MyTZ.Add(); NewString.LastName = "ჩაპაევი"; NewLine.Name = "ვასილი"; NewString.Middle name = "Ivanovich"; // დაამატეთ მეორე ხაზი NewLine = MyTZ.Add(); NewString.LastName = "ძერჟინსკი"; NewRow.Name = "ფელიქსი"; NewString.Middle name = "Edmundovich"; // დაამატეთ მესამე ხაზი NewLine = MyTZ.Add(); NewLine.LastName = "კოტოვსკი"; NewLine.Name = "გრიგორი"; NewString.Middle name = "Ivanovich";

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

კოდის პირველი ნიმუში არის 1C მნიშვნელობის ცხრილის სვეტების ჩამოთვლა, როგორც კოლექცია.

// TK-ის ყველა სვეტის სახელების ჩვენება For Every Column From MyTZ.Columns Cycle Report ("სვეტის სახელი: " + Column.Name); საბოლოო ციკლი;

ჩვენი ციკლი აჩვენებს ყველა სვეტის სახელს 1C შეტყობინების ფანჯარაში:

სვეტის სახელი: გვარი სვეტის სახელი: სახელი სვეტის სახელი: შუა სახელი

ჩვენ ვხედავთ, რომ სვეტების მეშვეობით გამეორებისთვის გამოიყენება სპეციალური კოლექციის გამეორების ციკლი, მწკრივის გამეორების ციკლის მსგავსი (წინა სტატიაში). MyTZ.სვეტები- ეს არის 1C მნიშვნელობის ცხრილის სვეტების კოლექცია "MyTZ". კოლექცია შეიცავს ამ ტიპის ობიექტებს "ღირებულებების ცხრილის სვეტი"ამ ტიპის თითოეული ობიექტი არის მნიშვნელობების ცხრილის სვეტი და შეიცავს თვისებებს და მეთოდებს. ამ თვისებებზე და მეთოდებზე წვდომით ჩვენ ვიღებთ საჭირო ინფორმაციას ერთი სვეტის შესახებ ან ვასრულებთ სხვა მოქმედებებს.

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

თქვენი ყურადღება მინდა გავამახვილო სერიალის სათაურზე: „ყველასთვის სვეტი MyTZ.Column Cycle-დან" ცვლადი სახელით "სვეტი"ჩვენს მიერ გამოგონილი. არ არის აუცილებელი იგივე სახელის გამოყენება. შეგიძლიათ ამ ცვლადს უწოდოთ ყველაფერი, რაც მოგწონთ, მაგალითად "MyCurrentColumn"მაშინ ზემოთ მოყვანილი მაგალითი ასე გამოიყურება:

// TK-ის ყველა სვეტის სახელების ჩვენება For Every MyCurrentColumn MyTK.Columns Cycle Report ("სვეტის სახელი: " + MyCurrentColumn.Name); საბოლოო ციკლი;

როდესაც 1C შესრულების ქვესისტემა ხვდება ამ ტიპის ციკლს, ციკლის ყოველი გავლისას იგი ანიჭებს ცვლადს მითითებული სახელით ჩვენი კოლექციიდან ერთ ელემენტს, ამ შემთხვევაში - ერთი კოლექციის ელემენტიღირებულების ცხრილის სვეტები MyTZ.სვეტებიშემდეგ ჩვენ შევდივართ ცვლადზე, რომელიც შეიცავს მიმდინარე სვეტს და ვიყენებთ თვისებას "სახელი".

მე ვთავაზობ, რომ სვეტის სახელის გვერდით გამოჩნდეს თითოეული სვეტის ნომერი სვეტების კრებულში:

// აჩვენე მნიშვნელობების ცხრილის ყველა სვეტის ნომერი და სახელები ყოველი სვეტისთვის MyTZ.Columns Cycle ColumnNumber = MyTZ.Columns.Index(Column); // მიიღეთ სვეტის ნომერი ColumnName = Column.Name; // მიიღეთ სვეტის სახელი Report("სვეტის ნომერი:" + სვეტის ნომერი + " სვეტის სახელი: " + სვეტის სახელი); საბოლოო ციკლი;

შემდეგი ტექსტი გამოჩნდება 1C შეტყობინების ფანჯარაში:

სვეტის ნომერი:0 სვეტის სახელი: გვარი სვეტის ნომერი:1 სვეტის სახელი: სახელი სვეტის ნომერი:2 სვეტის სახელი: შუა სახელი

გთხოვთ გაითვალისწინოთ, რომ 1C მნიშვნელობების ცხრილის სვეტები დანომრილია ნულიდან, ისევე როგორც მნიშვნელობების ცხრილის რიგები.

სვეტების რაოდენობა 1C მნიშვნელობის ცხრილში

მნიშვნელობების ცხრილში სვეტების რაოდენობის გასარკვევად ვიყენებთ მეთოდს "Count()" სვეტების კოლექციაზე.

სვეტების რაოდენობა = MyTZ.Columns.Quantity(); ანგარიში (სვეტების რაოდენობა);

ეკრანზე გამოჩნდება ნომერი "3". მართლაც, ჩვენს ცხრილს აქვს სამი სვეტი: "გვარი", "სახელი", "პატრონიმი"

სვეტის ობიექტის მიღება მისი რიცხვით (ინდექსი) და სვეტების ჩამოთვლა სვეტების ინდექსის გამოყენებით

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

ანგარიშისთვის = 0 By MyTZ.Columns.Quantity() - 1 ციკლი CurrentColumn = MyTZ.Columns[Act]; ანგარიში (CurrentColumn.Name); საბოლოო ციკლი;

ეკრანზე მივიღებთ შემდეგს

Სრული სახელი

ვფიქრობ, ეს მაგალითი ნათელი იყო. ჩვენ მივმართეთ მეთოდს რაოდენობა ()სვეტების კოლექციები" 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". ჩვენ ვაჩვენეთ ეს მნიშვნელობა ეკრანზე და ის წარმოადგენს სტრიქონს „ჩაპაევი“.

მოდით ცოტა გავართულოთ ჩვენი მაგალითი:

FirstLine = MyTK; // მიიღეთ პირველი სტრიქონი (ნულიდან დანომრილი) Report (FirstLine); // ცხრილის პირველ რიგში პირველი სვეტის მნიშვნელობის ჩვენება Report(FirstRow); // ცხრილის პირველ რიგში მეორე სვეტის მნიშვნელობის ჩვენება Report(FirstRow); // ცხრილის პირველ რიგში მესამე სვეტის მნიშვნელობის ჩვენება

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

ჩაპაევი ვასილი ივანოვიჩი

ახლა მე ასევე შევცვლი ამ მაგალითს ისე, რომ ჩვენ შეგვიძლია გავაკეთოთ ცვლადის გარეშე "Პირველი ხაზი"

ანგარიში (MyTZ); // ცხრილის პირველ რიგში პირველი სვეტის მნიშვნელობის ჩვენება Report(MyTZ); // ცხრილის პირველ რიგში მეორე სვეტის მნიშვნელობის ჩვენება Report(MyTZ); // ცხრილის პირველ რიგში მესამე სვეტის მნიშვნელობის ჩვენება

იგივე იქნება ეკრანზე

ჩაპაევი ვასილი ივანოვიჩი

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

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

RowCounter-ისთვის = 0 By MyTZ.Quantity() - 1 Loop // ციკლი სტრიქონებში ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 ციკლი // ჩადგმული ციკლი სვეტებში // მიიღეთ უჯრედის მნიშვნელობა (მიმდინარე მწკრივიდან და მიმდინარე სვეტები) CellValue = MyTK[RowCounter][ColumnCounter]; // მწკრივის ნომრის, სვეტის ნომრის და უჯრედის მნიშვნელობის ჩვენება Report("Row No" + Row Count + "Column No" + Column Count + " = " + CellValue); საბოლოო ციკლი; საბოლოო ციკლი;

ეკრანზე გამოჩნდება შემდეგი:

ხაზი No. 0 სვეტი No. 0 = ჩაპაევის ხაზი No. 0 სვეტი No. 1 = ვასილი ხაზი No. 0 სვეტი No. 2 = ივანოვიჩის ხაზი No. 1 სვეტი No. 0 = ძერჟინსკის ხაზი No. 1 სვეტი No1 = ფელიქსი ხაზი No1 სვეტი No2 = ედმუნდოვიჩი ხაზი No2 სვეტი No0 = კოტოვსკის ხაზი No2 სვეტი No1 = გრიგორი ხაზი No2 სვეტი No2 = ივანოვიჩი

ორი ციკლის გამოყენებით, რომელთაგან ერთი მეორეშია ჩასმული, ჩვენ ვაჩვენეთ ყველა სვეტის მნიშვნელობები 1C მნიშვნელობების ცხრილის ყველა სტრიქონიდან. ამ შემთხვევაში, ჩვენ არ ვიყენებდით სვეტების სახელებს, მაგრამ ვწვდით სვეტებსა და რიგებს მათი ინდექსებით. მეტი გაგებისთვის, ყურადღება მიაქციეთ მაგალითში მოცემულ კომენტარებს.

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

LineCounter-ისთვის = 0 By MyTZ.Quantity() - 1 ციკლი // ციკლი სტრიქონების მეშვეობით ანგარიში (" ======= ხაზის ნომერი. " + LineCounter + " ======="); მოხსენება (" "); // ხაზის მიწოდება (ცარიელი მწკრივის ჩასმა) For ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 ციკლი // ჩადგმული ციკლი სვეტების მეშვეობით // მიიღეთ უჯრედის მნიშვნელობა (მიმდინარე მწკრივიდან და მიმდინარე სვეტიდან) CellValue = MyTZ [RowCounter][ ColumnCounter]; // მიიღეთ სვეტის სახელი ColumnName = MyTZ.Columns[ColumnCounter].Name; // სვეტის სახელის და უჯრედის მნიშვნელობის ჩვენება Report(ColumnName + ": " + CellValue); საბოლოო ციკლი; მოხსენება (" "); // ხაზის მიწოდება (ცარიელი ხაზის ჩასმა) EndCycle;

ახლა, ჩვენს ეკრანზე, ინფორმაცია უფრო წარმომადგენლობითი ჩანდა:

ხაზი No 0 ======= გვარი: ჩაპაევი სახელი: ვასილი პატრონიმი: ივანოვიჩი ======= ხაზი No1 ======= გვარი: ძერჟინსკი სახელი: ფელიქს პატრონიმი: ედმუნდოვიჩი ===== == ხაზი No2 ======= გვარი: კოტოვსკი სახელი: გრიგორი პატრონიმი: ივანოვიჩი

დიახ, კინაღამ დამავიწყდა. ზედიზედ ორი [...][...] ოპერატორის გამოყენებისას, სვეტის ინდექსის ნაცვლად შეგვიძლია გადავცეთ ამ სვეტის სახელი: ValueTable[RowIndex][ColumnName]

ყურადღება მიაქციეთ ისრით მონიშნულ ხაზს ". ამ სტრიქონში მიმდინარე სვეტის ინდექსის ნაცვლად კვადრატულ ფრჩხილებში არგუმენტს გადავცემთ მიმდინარე სვეტის სახელს [...] შედეგი იგივე იქნება.

და ახლა, ბოლო რამ ამ სტატიაში.

ყველა მონაცემის სწორად მოპოვება 1C მნიშვნელობის ცხრილიდან მარყუჟების გამოყენებით რიგებისა და სვეტების კოლექციის მეშვეობით

თითოეული CurrentLine From MyTZ Loop // ციკლი სტრიქონების კრებულის მეშვეობით Report(" ======= ხაზის ნომერი. " + MyTZ.Index(CurrentLine) + " ======="); მოხსენება (" "); თითოეული CurrentColumn-ისთვის MyTZ.Columns Loop-ისთვის // წყობილი ციკლი, რომელიც იმეორებს სვეტების კრებულს ColumnName = CurrentColumn.Name; // მიიღეთ სვეტის სახელიCellValue = CurrentRow[ColumnName]; // მიიღეთ უჯრედის მნიშვნელობა სვეტის სახელის მიხედვით (ColumnName + ": " + CellValue); // აჩვენე სვეტის სახელი და უჯრედის მნიშვნელობა End of Cycle; მოხსენება (" "); საბოლოო ციკლი;

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

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

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

თითოეული CurrentLine From MyTZ Cycle // iterate over rows Report(" ======= ხაზის ნომერი. " + MyTZ.Index(CurrentLine) + " =======" + Symbols.PS); თითოეული CurrentColumn From MyTZ.Columns Loop // გამეორება სვეტებზე Report(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); საბოლოო ციკლი; მოხსენება (" "); საბოლოო ციკლი;

ეკრანზე გამომავალი არ შეცვლილა, ის იგივე რჩება, როგორც წინა მაგალითში:

2 კვირიანი კურსი

"პროგრამირება 1C-ში დამწყებთათვის"

კურსი გაიგზავნება ელექტრონული ფოსტით. გახდი პროგრამისტი ნაბიჯ-ნაბიჯ ამოცანების შესრულებით.

მონაწილეობის მისაღებად საჭიროა მხოლოდ კომპიუტერი და ინტერნეტი

უფასო წვდომა კურსზე:

Sp-force-hide ( display: none;).sp-form ( ჩვენება: ბლოკი; ფონი: #eff2f4; padding: 5px; სიგანე: 270px; მაქსიმალური სიგანე: 100%; საზღვრის-რადიუსი: 0px; -moz-საზღვრები -რადიუსი: 0 პიქსელი; -ვებკიტი-საზღვრის რადიუსი: 0 პიქს; შრიფტი-ოჯახი: 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; padding-მარცხნივ: 8.75px; padding-მარჯვნივ: 8.75px; საზღვარი -radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; სიმაღლე: 35px; სიგანე: 100%;).sp-form .sp-field label ( ფერი: #444444; font- ზომა: 13 პიქსელი; შრიფტის სტილი: ნორმალური; შრიფტის წონა: თამამი;) ფონის ფერი: #f4394c; ფერი: #ffffff; სიგანე: 100%; შრიფტის წონა: 700; შრიფტის სტილი: ნორმალური; font-family: Arial, "Helvetica Neue", sans-serif; ყუთი-ჩრდილი: არცერთი; -moz-box-shadow: არცერთი; -webkit-box-shadow: არცერთი; ფონი: ხაზოვანი-გრადიენტი (ზემოდან, #e30d22, #f77380);).sp-form .sp-button-container (ტექსტის გასწორება: ცენტრში; სიგანე: ავტომატური;)

(ეს სტატია ეკუთვნის 1C სტატიების სერიას ნულიდან; 1C-ის პროგრამირება ნულიდან; 1C მნიშვნელობების ცხრილი)

ვირტუალური მონაცემთა შენახვის სტრუქტურა ცხრილის სახით - ეს არის ის, რაც არის

მნიშვნელობების ცხრილი არ არის 1C მონაცემთა ბაზის მუდმივი ობიექტი და არ არის შენახული გაშვების სესიებს შორის.

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

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

მოდით შევქმნათ ღირებულებების ცხრილი და შევავსოთ იგი რაღაცით. უნდა გვახსოვდეს, რომ 1C მნიშვნელობების ცხრილი შეიძლება შეიქმნას არა მხოლოდ ხელით, ოპერატორის დარეკვით

NewValueTable;

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

მაშინვე მარტივ მაგალითს მოგიყვან.

// MyTZ = New ValueTable; // შექმენით მნიშვნელობების ახალი ცხრილი, რომელიც ინახება ცვლადში "MyTZ" MyTZ. Სვეტები. დამატება("გვარი"); // შექმენით სვეტი "გვარი" MyTZ. Სვეტები. დამატება ("სახელი"); // შექმენით სვეტი "სახელი".ანგარიში (MyTZ); // MyTZ ცვლადის მნიშვნელობის ჩვენება //

მე შევქმენი ცხრილი 1C მნიშვნელობებით, ორი სვეტით: "გვარი", "სახელი". Პროცედურა ანგარიში (MyTK)გამოჩნდება ცვლადის ტიპი შეტყობინების ფანჯარაში MyTZ: ღირებულებების ცხრილი

ჩვენი ღირებულების ცხრილი ამ დროისთვის ცარიელია. ამას დავუმატოთ ორიოდე სტრიქონი, სახელი და გვარი.

// შეავსეთ მნიშვნელობების ცხრილი // დავამატე პირველი სტრიქონი ჩვენს მნიშვნელობის ცხრილს NewLine = MyTZ. დამატება() ; Ახალი ხაზი. გვარი = "სიდოროვი" ; Ახალი ხაზი. სახელი = "ვასია" ; // დაამატეთ მეორე სტრიქონი ჩვენს მნიშვნელობის ცხრილს NewLine = MyTZ. დამატება() ; Ახალი ხაზი. გვარი = "ივანოვი" ; Ახალი ხაზი. სახელი = "პეტრე" ;

ჩვენ მივიღეთ ასეთი ცხრილი:

საჭიროა გახსოვდეთ: მნიშვნელობების ცხრილში მწკრივების ნომრები იწყება ნულიდან

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

// *** ეკრანზე აჩვენეთ ნულოვანი ხაზის მნიშვნელობები *** (ყოველდღიურ ცხოვრებაში, ჩვეულებრივ, ნივთებს ვთვლით ერთიდან, მაგრამ აქ - ნულიდან) // მიიღეთ ჩვენი ცხრილის ნულოვანი მწკრივი კვადრატულ ფრჩხილებში მწკრივის ინდექსის გამოყენებით OurNullString = MyTZ[ 0] ; // ახლა მთელი ნულოვანი სტრიქონი შეიცავს ცვლადში "OurFirstLine"ანგარიში (OurNullString.LastName) ; // ნულოვანი მწკრივის "გვარი" სვეტის მნიშვნელობის ჩვენებაანგარიში (OurNullString.Name) ; // აჩვენე "Name" სვეტის მნიშვნელობა იმავე ხაზიდან

შედეგად, ეკრანზე გამოჩნდება:

სიდოროვი ვასია

ახლა, ძალიან ჭკვიანური და ლაკონურისთვის, მე გაჩვენებ მაგალითს, რომელიც საშუალებას გაძლევთ შეხვიდეთ სვეტის მნიშვნელობაზე ამა და ასეთ მწკრივში (სვეტის მნიშვნელობა ამ და ასეთ მწკრივში არის მნიშვნელობების ცხრილის უჯრედი არაოფიციალური ტერმინია, მაგრამ მოსახერხებელი). მაგრამ შუალედური ცვლადის გამოყენების გარეშე, როგორიცაა "OurZeroString".

უჯრედების მნიშვნელობების ჩვენება მეორე რიგიდან (არ დაგავიწყდეთ, რომ მწკრივი მეორეა, მაგრამ ამ მწკრივის ინდექსი ერთია, ასე რომ ნუმერაცია იწყება ნულიდან)

და ბოლოს, ამ სტატიის ბოლო წერტილი. მე გაჩვენეთ მნიშვნელობების ცხრილის ერთ მწკრივზე წვდომის მაგალითი ინდექსით (სტრიქონის ნომერი). უჯრედის შიგთავსის წაკითხვის ან მინიჭების უნივერსალური ფორმაა: "MyValueTable[RowNumber].ColumnName"

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

// // გადაატრიალეთ და აჩვენეთ ჩვენი მნიშვნელობების ცხრილის ყველა სტრიქონი// LineNumber-ისთვის = 0 MyTZ-ის მიხედვით. რაოდენობა() - 1 ციკლის ანგარიში (MyTZ[LineNumber] . გვარი) ; // "გვარი" სვეტის მნიშვნელობის ჩვენებაანგარიში (MyTK[LineNumber] . სახელი) ; // აჩვენე "Name" სვეტის მნიშვნელობაბოლო ციკლი ;

ამ მარყუჟის გაშვების შედეგად ეკრანზე გამოჩნდება შემდეგი:

სიდოროვი ვასია ივანოვი პეტია

აქ მე გითხარით 1C მნიშვნელობების ცხრილთან მუშაობის საფუძვლები. ეს ინფორმაცია ეხება 1C 8.0, 8.1, 8.2. საინტერესო დეტალები „1C მნიშვნელობის ცხრილის“ ობიექტის შესახებ ამით არ მთავრდება. ამ ობიექტს აქვს უზარმაზარი შესაძლებლობები მონაცემებით მოსახერხებელი მუშაობისთვის. ამის შესახებ შემდეგ სტატიებში ვისაუბრებ.

დეგტიარევი რომან.

როგორ ვისწავლოთ პროგრამირება 1C-ში ნულიდან?

როგორ ვიმუშაოთ 1C პროგრამისტად და მიიღოთ 150000 რუბლამდე თვეში?

დარეგისტრირდით უფასოდ

2 კვირიანი კურსი

"პროგრამირება 1C-ში დამწყებთათვის"

მონაწილეობის მისაღებად საჭიროა მხოლოდ კომპიუტერი და ინტერნეტი

უფასო წვდომა კურსზე:

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

დავალების მახასიათებლები.

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

Form Elements.TableField.CreateColumns();

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

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

პრობლემის გადაწყვეტა.

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

ფორმაზე ცხრილის შექმნა ხდება მნიშვნელობის ცხრილის, როგორც ატრიბუტის აღწერით:
SelectionTypeArray = ახალი მასივი; SelectionType.Add(Type("Value Table")) მასივი; 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("თარიღი")); DescriptionTypesTime = New 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"));

საბოლოო ციკლი;
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." + სვეტი.სახელი;
NewElement.Width = 10;

საბოლოო ციკლი;

პირობითი დიზაინი, თუ გვჭირდება, ხელითაც ვწერთ, ბრძანების მენიუ - ხელით. მაგიდის დამჭერები ასევე იწერება ხელით. მაგალითად, „Selection“ ცხრილისთვის მოვლენის დამმუშავებლის დასამატებლად:

Table of SelectionFields.SetAction("Selection","TZNSelection");

ამ მოვლენის დასამუშავებლად დადგენილია ცალკე პროცედურა პროცედურის სახით:

&OnClient
პროცედურა TKNSelection (TK, Selected Row, Field, StandardProcessing)
//მმუშავებლის ბრძანებები EndProcedure

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

&OnClient

ბოლო, რისი დამატებაც მინდოდა არის ის, რომ ყველა ამ ნაბიჯის შემდეგ, დარწმუნდით, რომ დაიმახსოვრეთ მზა ცხრილის გადაცემა ფორმის ატრიბუტზე:

ValueВFormAttributes(ToR, "ScheduleTable");

ეს არის ის, რაც ჩვენ გვაქვს შედეგად:

და აქ არის "Selection" მოვლენის მართვა:

შემდგომი სიტყვა.

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

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

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

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

ამიტომ, 1C-ში მაგიდებთან მუშაობა თვალსაჩინო ადგილს იკავებს.

ცხრილებს 1C-ში ასევე უწოდებენ "ტაბულურ ნაწილებს". მათ აქვთ დირექტორიები, დოკუმენტები და სხვა.

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

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

//ვარიანტი 1 – თანმიმდევრული წვდომა შეკითხვის შედეგებზე

//მიიღე მაგიდა
Select = Query.Run().Select();
// შეკითხვის შედეგის ყველა სტრიქონს თანმიმდევრობით გავდივართ
ხოლო Select.Next() ციკლი
ანგარიში (არჩევა.სახელი);
საბოლოო ციკლი;

//ვარიანტი 2 – ატვირთვა მნიშვნელობათა ცხრილში
Request = New Request("SELECT Name FROM Directory.Nomenclature");
//მიიღე მაგიდა
ცხრილი = Query.Run().Unload().
//შემდეგ ჩვენ ასევე შეგვიძლია გავიმეოროთ ყველა ხაზი
ცხრილის ციკლიდან თითოეული რიგისთვის
ანგარიში (სტრიქონი.სახელი);
საბოლოო ციკლი;
//ან თვითნებური წვდომა სტრიქონებზე
Row = Table.Find("შოველ", "სახელი");

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

ცხრილი ფორმაზე (სქელი კლიენტი)

მომხმარებელი მუშაობს ცხრილთან, როდესაც ის განთავსდება ფორმაზე.

ფორმებთან მუშაობის ძირითადი პრინციპები განვიხილეთ გაკვეთილზე და გაკვეთილზე

მაშ ასე, დავდოთ ცხრილი ფორმაზე. ამისათვის შეგიძლიათ გადაიტანეთ ცხრილი Controls პანელიდან. ანალოგიურად, მენიუდან შეგიძლიათ აირჩიოთ Form/Insert Control.

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

დააჭირეთ ღილაკს "..." მონაცემთა თვისებაში. იმისათვის, რომ ნახოთ ცხრილის ნაწილების სია, თქვენ უნდა გააფართოვოთ Object ფილიალი.

როდესაც აირჩევთ ცხრილის ნაწილს, 1C თავად დაამატებს სვეტებს ფორმაში არსებულ ცხრილში. მომხმარებლის მიერ ასეთ ცხრილში შეყვანილი რიგები ავტომატურად შეინახება საცნობარო წიგნთან/დოკუმენტთან ერთად.

იმავე მონაცემთა თვისებაში შეგიძლიათ შეიყვანოთ თვითნებური სახელი და აირჩიოთ Value Table ტიპის.

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

ცხრილზე მაუსის მარჯვენა ღილაკით შეგიძლიათ დაამატოთ სვეტი. სვეტის თვისებებში შეგიძლიათ მიუთითოთ მისი სახელი (1C კოდში მითითებისთვის), ფორმის სვეტის სათაური, ტაბულური ნაწილის ატრიბუტთან კავშირი (ეს უკანასკნელი - თუ არ არის შერჩეული თვითნებური ცხრილი, მაგრამ ცხრილის ნაწილი).

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

ცხრილის სამართავად, თქვენ უნდა აჩვენოთ ბრძანების პანელი ფორმაზე. აირჩიეთ მენიუს პუნქტი Form/Insert Control/Command Bar.

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

ცხრილი ფორმის შესახებ (თხელი/მართული კლიენტი)

მართულ ფორმაზე, ეს მოქმედებები ცოტა განსხვავებულად გამოიყურება. თუ ფორმაზე ცხრილის ნაწილის განთავსება გჭირდებათ, გააფართოვეთ Object ფილიალი და გადაიტანეთ ერთ-ერთი ცხრილის ნაწილი მარცხნივ. Სულ ეს არის!

თუ თქვენ გჭირდებათ მნიშვნელობების ცხრილის განთავსება, დაამატეთ ახალი ფორმის ატრიბუტი და მის თვისებებში მიუთითეთ ტიპი - მნიშვნელობების ცხრილი.

სვეტების დასამატებლად გამოიყენეთ მარჯვენა ღილაკით მენიუ ამ ფორმის ატრიბუტზე, აირჩიეთ ატრიბუტის სვეტის დამატება.

შემდეგ ასევე გადაიტანეთ ცხრილი მარცხნივ.

იმისათვის, რომ ცხრილს ჰქონდეს ბრძანების ზოლი, ცხრილის თვისებებში აირჩიეთ მნიშვნელობები Usage – Command bar position განყოფილებაში.

ცხრილის ატვირთვა Excel-ში

ფორმაზე განთავსებული ნებისმიერი 1C ცხრილი შეიძლება დაიბეჭდოს ან აიტვირთოს Excel-ში.

ამისათვის დააწკაპუნეთ ცხრილის ცარიელ სივრცეზე მარჯვენა ღილაკით და აირჩიეთ სია.

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

Კითხვა სხვადასხვა ტიპის მნიშვნელობების ცხრილის სვეტის შექმნა 1C v8-ში
უპასუხეღირებულებების ცხრილის სვეტის შექმნისას შეგიძლიათ გაიაროთ ტიპების მასივიდა შესაძლოა კონკრეტული ტიპი. ტიპების მასივი გამოიყენება, როდესაც ერთი სვეტისთვის რამდენიმე განსხვავებული ტიპის მითითება გჭირდებათ.

გამოიყენება ტიპების აღსანიშნავად "ზოგადი ობიექტი" - "ტიპების აღწერა". ამიტომ, პირველ რიგში განვმარტავთ, თუ რა არის „ტიპების აღწერა“ („მნიშვნელობის ტიპების აღწერა“).

"ღირებულების ტიპების აღწერა". სისტემაში სხვადასხვა ობიექტების ქონების ღირებულებების მისაღები ტიპების აღსაწერად გამოიყენება სპეციალური ობიექტი "ტიპების აღწერა". ამ ობიექტის გამოყენებით, შეგიძლიათ აღწეროთ მნიშვნელობების მოქმედი ტიპები, რომლებიც შეიძლება მიენიჭოს თვისებებს. პრიმიტიული ტიპების შესაძლო მნიშვნელობების შემდგომი შეზღუდვის მიზნით მოწოდებულია Number, String და Date შესარჩევები. კვალიფიკატორები აღწერენ ისეთ პარამეტრებს, როგორიცაა სტრიქონის ან რიცხვის სიგრძე, თარიღის სწორი ნაწილები და ა.შ.

"ტიპის აღწერა" მეთოდის სინტაქსი

ახალი აღწერილობის ტიპები (<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
Პარამეტრები:
<Исходное описание типов> (სურვილისამებრ)
ტიპი: აღწერა ტიპები. ტიპების თავდაპირველი აღწერა, რის საფუძველზეც აშენდება ახალი.
<Добавляемые типы> (სურვილისამებრ)
ტიპი: მასივი, სტრიქონი. ტიპის მნიშვნელობების მასივი A Type შედგება ტიპებისგან, რომლებიც გამოყენებული იქნება ობიექტში, ან სტრიქონი, რომელიც შეიცავს მძიმით გამოყოფილი ტიპების სახელებს.
<Вычитаемые типы> (სურვილისამებრ)
ტიპი: მასივი, სტრიქონი. Type მნიშვნელობების მასივი (ან სტრიქონი, რომელიც შეიცავს მძიმით გამოყოფილი ტიპის სახელებს), რომელიც შედგება იმ ტიპებისგან, რომლებიც გამოირიცხება პირველ პარამეტრში მითითებული საწყისი დეკლარაციისგან.
<Квалификаторы числа> (სურვილისამებრ)
ტიპი: QualifiersNumbers. რიცხვების კვალიფიკატორები, რომლებიც აღწერს რიცხვითი ტიპის მოქმედ მნიშვნელობებს.
<Квалификаторы строки> (სურვილისამებრ)
ტიპი: QualifiersStrings. სიმებიანი კვალიფიკატორები, რომლებიც აღწერს სტრიქონის ტიპის მოქმედ მნიშვნელობებს.
<Квалификаторы даты> (სურვილისამებრ)
ტიპი: QualifiersDates. თარიღის კვალიფიკატორები, რომლებიც აღწერს თარიღის ტიპის მოქმედ მნიშვნელობებს.
აღწერა:
ქმნის ტიპის აღწერას სხვა ტიპის აღწერილობის საფუძველზე, ზოგიერთი ტიპის დამატებით და სხვების გამოკლებით. თუ ახალი კვალიფიკატორი არ არის მითითებული, ორიგინალური ტიპის დეკლარაციის კვალიფიკატორები შენარჩუნდება.
"ტიპის აღწერა" ობიექტის გამოყენების მაგალითი:

// გააფართოვეთ Valid Types-ის აღწერა ახალი ტიპებითმასივი = ახალი მასივი; მასივი. დამატება(ტიპი( "საცნობარო ბმული. მეთოდები")); მასივი. Add(Type ("ნომერი" )); ნიშანი = ValidSign. არაუარყოფითი; QuNumbers = New QualifiersNumbers(10, 2, Sign); ValidTypes = NewTypeDescription(ValidTypes, Array, KvNumbers);

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

ზოგადად, საკმარისია სვეტების ტიპების განსაზღვრა შემდეგნაირად:

TK. Სვეტები. დამატება( "დახარისხების ინდექსი", ახალი აღწერაTypes ("ნომერი") ); TK. Სვეტები. Add("SectionName", New TypeDescription("String") ); TK. Სვეტები. Add("DataCorr" , New TypeDescription("თარიღი") ); TK. Სვეტები. დამატება( "უპირობო წაშლა", New TypeDescription("Boolean")); TK. Სვეტები. Add("Nomenclature" , New TypeDescription() ); TK. Სვეტები. Add("SectionData" , New TypeDescription("სტრუქტურა")) ; // სვეტების "ნომრის" და "სტრიქონის" შექმნის მაგალითი პარამეტრების დაზუსტებით: TK. Სვეტები. დამატება( "პროცენტი დასრულებული", New DescriptionTypes ( "Number" , New QualifiersNumbers ( 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) ; მასივი. Clear() ; მასივი. Add(Type ("ნომერი") ); TypeDescriptionNumber = New TypeDescription(Array, , , CN) ; მასივი. Clear() ; მასივი. Add(Type ("თარიღი") ); DescriptionTypesDate = New DescriptionTypes(Array, , , , CD) ; მასივი. Clear() ; მასივი. დამატება(ტიპი( "DirectoryLink.Nomenclature")) ; ტიპი DescriptionNomenclature = New Type Description (Array) ; მასივი. Clear() ; მასივი. დამატება(ტიპი( "DirectoryLink.SeriesNomenclature")) ; TypeDescriptionSeries = New TypeDescription(Array) ; მასივი. Clear() ; მასივი. დამატება(ტიპი( "DirectoryLink.Quality")) ; TypeDescriptionQuality = New TypeDescription(Array) ; მასივი. Clear() ; მასივი. Add(Type("Boolean") ); TypeDescriptionBoolean = New TypeDescription(Array) ; // ფაქტიურად სვეტების დამატება TK-ში (მომავალი TK-ის სტრუქტურის შექმნა) TK. Სვეტები. Add("ნომენკლატურა", აღწერაTypesNomenclature) ; TK. Სვეტები. Add("Code" , TypeDescriptionString) ; TK. Სვეტები. დამატება( "სერიის ნომენკლატურა", DescriptionTypesSeries); TK. Სვეტები. Add("AccountCode" , ტიპი DescriptionString) ; TK. Სვეტები. Add("ActionDate" , TypeDescriptionDate) ; TK. Სვეტები. Add("ხარისხი" , TypeDescriptionQuality) ; TK. Სვეტები. Add("NumberUS", DescriptionTypesNumber) ; TK. Სვეტები. Add("ჩაწერა" , TypeDescriptionBoolean) ; . . . //////// ტექნიკური მახასიათებლების სტრუქტურის ფორმირება (სვეტების შექმნა) ////////////////////////////////////////////////////////

მნიშვნელობების ცხრილში მწკრივის დასამატებლად იხ