აქ არის პატარა ფაქტი დასაწყებად - მარტივი მაგალითებიიმუშავეთ მნიშვნელობების ცხრილთან:

1. შექმენით მნიშვნელობების ცხრილი

ValueTable = New ValueTable;

2. შექმენით მნიშვნელობების ცხრილის სვეტები:

ValueTable.Columns.Add("სახელი");
ValueTable.Columns.Add("გვარი");

3. დაამატეთ ახალი რიგები სვეტების სახელების გამოყენებით:

NewString.Name = "ვასილი";
NewRow.LastName = "Pupkin";

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

FoundString = ValueTable.Find(LookupValue);

5. იპოვეთ პირველი შემთხვევა მნიშვნელობების ცხრილის გარკვეულ სვეტებში

FoundString = ValueTable.Find(LookupValue, "Supplier, Buyer");

6. თუ თქვენ უნდა იპოვოთ ყველა მოვლენა მნიშვნელობების ცხრილში:
ჩვენ ვიყენებთ საძიებო სტრუქტურას.

SearchStructure = Structure("Employee", LookupValue);
ArrayFoundStrings = ValueTable.FindStrings(SearchStructure);

მოდით შევქმნათ საძიებო სტრუქტურა, რომლის თითოეული ელემენტი შეიცავს სვეტის სახელს გასაღების სახით და ამ სვეტში მოძიებულ მნიშვნელობას მნიშვნელობად. Search Structure-ს პარამეტრად გადავცემთ FindStrings() მეთოდს. შედეგად, ჩვენ ვიღებთ ცხრილის რიგებს.
თუ საძიებო სტრუქტურას დავამატებთ სასურველი მნიშვნელობის ძიებას, მაგალითად, ასევე სვეტში Responsible, მაშინ FindRows() მეთოდის გამოყენების შედეგად მივიღებთ ყველა მწკრივს, სადაც თანამშრომელიც და პასუხისმგებელიც სასურველის ტოლია. ღირებულება.

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

თითოეული CurrentRow-ისთვის ValueTable Loop-დან
ანგარიში (CurrentLine.Name);
საბოლოო ციკლი;

იგივე გააკეთე ინდექსების გამოყენებით:

SeniorIndex = ValueTable.Count() - 1;
MF = 0-ისთვის SeniorIndex ციკლისთვის
ანგარიში (ValueTable[Count].Name);
საბოლოო ციკლი;

8. არსებული მნიშვნელობების ცხრილის მწკრივის წაშლა

ValueTable.Delete(RemoveRow);

ინდექსით

ValueTable.Delete(0);

9. მნიშვნელობათა ცხრილის არსებული სვეტის წაშლა

ValueTable.Columns.Delete(RemoveColumn);

ინდექსით

ValueTable.Columns.Delete(0);

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

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

NewRow = ValueTable.Add();
NewRow[ColumnName] = მნიშვნელობა;

11. როგორ შეავსოთ მნიშვნელობების ცხრილის მთელი სვეტი სასურველი მნიშვნელობით?
Fiscal Accounting Flag სვეტი Value Table-ის მნიშვნელობების ცხრილში უნდა იყოს შევსებული მნიშვნელობით False.

ValueTable.FillValue(False, "Fiscal Accounting Flag");

ჩვენ ვიყენებთ FillValues() მეთოდს მნიშვნელობების ცხრილისთვის. პირველი პარამეტრი არის შევსების მნიშვნელობა. მეორე პარამეტრი არის შევსებული სვეტის სახელი.

12. როგორ შეავსოთ მნიშვნელობების ცხრილი "TableRecipient" მნიშვნელობების ცხრილის "SourceTable" მონაცემებით?

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

TableReceiver = TableOriginal.Copy();

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

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

SourceTable-ის თითოეული რიგისთვის SourceTable Loop-დან
FillPropertyValues ​​(NewString, SourceTableString);
ბოლო ციკლი

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

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

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

SimilarColumns = New Array();

თითოეული სვეტისთვის SourceTable.Columns Loop
MatchingColumn = TableReceiver.Columns.Find(Column.Name);

თუ MatchedColumn<>განუსაზღვრელი მაშინ

// სვეტის თვისებების მიღება.
სახელი = სვეტი.სახელი;
ValueType = Column.ValueType;
სათაური = Column.Title;
Width = Column.Width;

// სვეტების ჩანაცვლება დანიშნულების ცხრილში.
Index = TableReceiver.Columns.Index(CoincidentColumn);

TableReceiver.Columns.Delete(Index);
TableReceiver.Columns.Insert(Index, Name, ValueType, Title, Width);

// დაამატეთ შესაბამისი სვეტების შემდეგი სახელი მასივში.
Same-nameColumns.Add(Column.Name);

Დაასრულე თუ;

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

// დაარეგულირეთ წყაროს ცხრილის რიგები.
SourceTable-ის თითოეული რიგისთვის SourceTable Loop-დან

// დაამატეთ ახალი მწკრივი დანიშნულების ცხრილში.
NewString = TableReceiver.Add();

// შეავსეთ მნიშვნელობები შესაბამის უჯრედებში.
თითოეული NameColumns of Same NameColumns მარყუჟი
NewString[ColumnName] = SourceTableString[ColumnName];

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

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

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

13. როგორ დავამატოთ სვეტები მნიშვნელობების ცხრილს "მნიშვნელობების ცხრილი" ტიპის შეზღუდვებით?

სვეტის დამატებისას შეგიძლიათ უბრალოდ მიუთითოთ მისი სახელი და არ შეეხოთ Add() მეთოდის მეორე პარამეტრს. ამ შემთხვევაში, სვეტის მონაცემთა ტიპი თვითნებურია.

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

// დაამატეთ სვეტი ტიპის შეზღუდვების გარეშე.
ValueTable.Columns.Add("ობიექტი");

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

სვეტის დამატება, რომელშიც მითითებულია მონაცემთა ტიპი

// შეზღუდვები სვეტების მონაცემთა ტიპებზე:
// მხოლოდ "კონტრაქტორების" დირექტორიას ელემენტები.
ValueTable.Columns.Add("ანგარიში", New TypeDescription("ReferenceReference.Accounts"));

თუ სვეტის მონაცემების შევსებისთვის დაშვებულ ტიპებს შორის არის სტრიქონი, შეგიძლიათ შეზღუდოთ მისი ბიტის სიღრმე (სიგრძე), მიუთითოთ ცვლადი ან ფიქსირებული სიგრძის გამოყენება. ეს ყველაფერი უზრუნველყოფილია ობიექტის შექმნით StringQualifiers კონსტრუქტორის გამოყენებით. გარდა ამისა, ეს ობიექტი გამოყენებული იქნება TypeDescription კონსტრუქტორის ერთ-ერთ პარამეტრად.

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

// მოამზადეთ და დააწესეთ ლიმიტები String ტიპის მონაცემებისთვის.
სიმებიანი კვალიფიკატორები = ახალი სიმებიანი კვალიფიკატორები (20, ValidLength.Variable);
AllowedTypes = NewTypeDescription("String",StringQualifiers);
ValueTable.Columns.Add("NoteStringShort", ValidTypes);

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

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

// ტიპების ადრე გამოყენებული აღწერილობის გაფართოება.
Number Qualifiers = New Number Qualifiers(10, 2, ValidSign.Non-negative);
DateQualifiers = New DateQualifiers(DateParts.Date);
ExtendedValidTypes = NewTypeDescription(ValidTypes, "Number, Date",NumberQualifiers,DateQualifiers);

ValueTable.Columns.Add("Note", ExtendedAllowedTypes);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ცხრილის ექსპორტი Excel-ში

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

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

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

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

სტატიები ღირებულებების სხვა უნივერსალური კოლექციების შესახებ 1C-ში

ისწავლეთ პროგრამირება 1C-ში ჩემი წიგნიდან "პროგრამა 1C-ში 11 ნაბიჯში"

1. წიგნი დაწერილია გასაგები და მარტივი ენით - დამწყებთათვის.
2. ისწავლეთ 1C არქიტექტურის გაგება;
3. თქვენ დაიწყებთ კოდის წერას 1C ენაზე;
4. დაეუფლოს პროგრამირების ძირითად ტექნიკას;
5. მიღებული ცოდნის კონსოლიდაცია დავალების წიგნის დახმარებით;

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

1. ძალიან ხელმისაწვდომი და გასაგები ენა
2. წიგნი იგზავნება ელ PDF ფორმატში. იხსნება ნებისმიერ მოწყობილობაზე!
3. გაიგეთ მართული 1C აპლიკაციის იდეოლოგია
4. ისწავლეთ მართული აპლიკაციის შემუშავება;
5. ისწავლეთ დიზაინი მართული ფორმები 1C;
6. თქვენ შეძლებთ მართული ფორმების ძირითად და საჭირო ელემენტებთან მუშაობას
7. მართული აპლიკაციის ქვეშ პროგრამირება ნათელი გახდება

პრომო კოდი 15% ფასდაკლებით - 48PVXHeYu

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

შეიძლება გადაიხადოთ ხელით:

Yandex.Money — 410012882996301
ვებ ფული - R955262494655

შემოუერთდი ჩემს ჯგუფებს.

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

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

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

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

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

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

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

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

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

ჩვენი ციკლი აჩვენებს ყველა სვეტის სახელს 1C შეტყობინების ყუთში:

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

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

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

თქვენი ყურადღება მინდა გავამახვილო ციკლის სათაურზე: „თითოეულისთვის სვეტი MyTR.Columns Loop-დან დასახელებულია ცვლადი "სვეტი"ჩვენს მიერ გამოგონილი. არ არის აუცილებელი იგივე სახელის გამოყენება. თქვენ შეგიძლიათ დაასახელოთ ეს ცვლადი რაც გსურთ, მაგალითად "MyCurrentColumn"მაშინ ზემოთ მოყვანილი მაგალითი ასე გამოიყურება:

// ამობეჭდეთ TK-ის ყველა სვეტის სახელები თითოეული MyCurrentColumn-დან MyTK.Columns Notify Loop("სვეტის სახელი: " + MyCurrentColumn.Name); საბოლოო ციკლი;

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

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

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

ტექსტი გამოჩნდება 1C შეტყობინების ყუთში:

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

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

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

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

Number ofColumns = MyTM.Columns.Number(); ანგარიში (სვეტების რაოდენობა);

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

სვეტის ობიექტის მიღება მისი ნომრით (ინდექსი) და სვეტებზე გამეორება სვეტის ინდექსის გამოყენებით

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

SC = 0 By MyTM.Columns.Quantity() - 1 Loop CurrentColumn = MyTM.Columns[SC]; Notify (CurrentColumn.Name); საბოლოო ციკლი;

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

Სრული სახელი

ვფიქრობ, ეს მაგალითი ნათელი იყო. ჩვენ მივმართეთ მეთოდს რაოდენობა ()სვეტების კოლექციები" MyTM.Columns.Quantity()", მიიღო სვეტების რაოდენობა და დაიწყო ციკლი მრიცხველით ნულიადრე სვეტების რაოდენობა მინუს ერთი. მარყუჟის შიგნით ვიღებთ თითოეულ სვეტს სვეტის კოლექციიდან და ვანიჭებთ მიმდინარე სვეტის ობიექტს ცვლადს მიმდინარე სვეტიშემდეგი, ცვლადი მიმდინარე სვეტიჩვენ შევდივართ ქონებაზე სახელიდა აჩვენეთ ამ თვისების მნიშვნელობა ეკრანზე: Notify (CurrentColumn.Name);

მნიშვნელოვანია არასოდეს ავურიოთ ობიექტის თვისება ობიექტის მეთოდთან.

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

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

ეს არის ის, რასაც თარჯიმანი დაწერს, თუ დამავიწყდება ფრჩხილების ჩასმა მეთოდის გამოძახებაში ასეთი არასწორი გზით MyTM.Columns.Quantity("რაოდენობის()" შემდეგ ფრჩხილების გარეშე):

ობიექტის ველი ვერ მოიძებნა (დათვლა)

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

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

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

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

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

ჩაპაევი

ჩვენ პირველად მივიღეთ მნიშვნელობის ცხრილის მწკრივის ობიექტი [...] ოპერატორის გამოყენებით მნიშვნელობის ცხრილზე წვდომით. (თუ დაგავიწყდათ როგორ გააკეთოთ ეს, შეგიძლიათ გადახედოთ წინა სტატიებს) ოპერატორის შიგნით, ჩვენ გადავიტანეთ არგუმენტი "0". ეს არის მნიშვნელობების ცხრილის პირველი რიგის ინდექსი. FirstLine = MyTR;

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

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

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

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

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

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

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

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

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

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

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

RowCount = 0 By MyTM.Quantity() - 1 Loop // ციკლი რიგების მეშვეობით ColumnCount = 0 By MyTM.Columns.Quantity() - 1 ციკლი // ჩადგმული ციკლი სვეტებში // მიიღეთ უჯრედის მნიშვნელობა (მიმდინარე მწკრივიდან და მიმდინარე სვეტები) CellValue = MyTR[RowCount][ColumnCount]; // მწკრივის ნომრის, სვეტის ნომრის და უჯრედის მნიშვნელობის ჩვენება Report("Line #" + RowCount + "Column #" + ColumnCount + " = " + CellValue); საბოლოო ციკლი; საბოლოო ციკლი;

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

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

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

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

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

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

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

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

RowCount = 0 By MyTR.Quantity() - 1 Loop // ციკლი სტრიქონების მეშვეობით Report(" ======= რიგი # " + RowCount + " ======="); მოხსენება (" "); // ხაზის მიწოდება (ცარიელი ხაზის ჩასმა) For ColumnCount = 0 By MyTR.Columns.Quantity() - 1 ციკლი // ჩადგმული ციკლი სვეტების მეშვეობით ColumnName = MyTR.Columns[ColumnCount].Name; // მიიღეთ სვეტის სახელიCellValue = MyTR[RowCount][ColumnName]; //

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

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

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

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

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

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

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

თითოეული CurrentRow From MyTR Loop // loop მეშვეობით ხაზების Report(" ======= Line # " + MyTR.Index(CurrentRow) + " =======" + Symbols.PS); თითოეული CurrentColumn-ისთვის MyTr.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პx; შრიფტი-ოჯახი: 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 (ტექსტის გასწორება: ცენტრში; სიგანე: ავტომატური;)