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

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

მიიღეთ 267 ვიდეო გაკვეთილი 1C-ზე უფასოდ:

პარამეტრები

ამ ობიექტისთვის ამდენი პარამეტრი არ არის:

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

1C 8.3-ში განსაზღვრული ტიპების გამოყენების მაგალითი

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

გამოყენების მაგალითები:

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

და უფრო მეტი.

თუ იწყებთ 1C პროგრამირების სწავლას, გირჩევთ ჩვენს უფასო კურსი(არ დაგავიწყდეს

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

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

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

1C ტიპებთან მუშაობა ხშირად გამოიყენება:

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

ტიპი 1C შეგიძლიათ მიიღოთ:

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

1C ტიპები შეიძლება დაიყოს სამ ტიპად:

• ძირითადი ტიპები 1C
• 1C მონაცემთა ბაზების ტიპები (მინიშნება, ობიექტები)
• ტიპები 1C.

1C ტიპის განსაზღვრა და 1C ტიპების შედარება

შეგიძლიათ გაიგოთ მნიშვნელობის ტიპი 1C ფუნქციის TypeValue (ცვლადი) გამოყენებით.

იმის გასაგებად, თუ რა ტიპის 1C დააბრუნა ამ ფუნქციამ, უნდა მიუთითოთ ჩვენთვის საჭირო ტიპი ("TypeName")

მაგალითად, 1C ტიპის ცვლადის განმარტება (შედარება):
თუ TypeValue(Variable) = Type("TypeName") მაშინ

რა ტიპები უნდა დავწერო TypeName-ად?

ძირითადი ტიპები

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

Მაგალითად:
Znch = 12;
თუ TypeValue(Value) = Type("ნომერი") მაშინ
ElseIf Value = Type("String") შემდეგ
ElseIf Value = Type ("თარიღი") შემდეგ
ElseIf Value = Type("Boolean") შემდეგ
დაასრულე თუ;

მონაცემთა ბაზის ტიპები

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

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

Მაგალითად:
მნიშვნელობა = Directories.Organizations.EmptyLink();
თუ TypeValue(Value) = Type("DirectoryLink.Organizations") მაშინ
სხვაგვარადIf Value = Type("DirectoryObject.Organization") შემდეგ
სხვაგვარადIf TypeValue(Value) = Type("DocumentLink.საქონლის მიღება") შემდეგ
სხვა შემთხვევაშიIf Value = Type("DocumentObject.საქონლის მიღება") მაშინ
დაასრულე თუ;

რეგისტრების წარდგენა შესაძლებელია განსხვავებული ტიპები. რეგისტრის ტიპის სახელი რთულია:
RegisterRegisterTypeAccessType.RegisterName

1C რეგისტრების ტიპები:

• ინფორმაცია
• დანაზოგი
• Აღრიცხვა
• Გაანგარიშება.

რეგისტრში წვდომის რამდენიმე ტიპი არსებობს. ყველაზე ხშირად გამოიყენება:

• SetRecords
• სია
• ნიმუში
• ჩანაწერი
• ჩანაწერის გასაღები.

სულ, მაგალითად:
თუ TypeValue(Value) = Type("InformationRegisterList.RegisterName") მაშინ
სხვაგვარადIf Value = Type("AccumulationRegisterRecordSet.RegisterName") შემდეგ
დაასრულე თუ;

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

ასეთი 1C ტიპები მითითებულია მათი სახელით (ერთი სიტყვით, სივრცეების გარეშე). Მაგალითად:
თუ TypeValue(Value) = Type("Array") მაშინ
ElseIf Value = Type("List of Value") შემდეგ
დაასრულე თუ;

1C საცნობარო ტიპის მნიშვნელობის განსაზღვრა

მონაცემთა ბაზის ყველა ობიექტთან (ცნობარი, დოკუმენტი...) მუშაობა ხორციელდება ბმულების საშუალებით. მაგალითად, თუ გვსურს დოკუმენტში მითითება, მაშინ მისი 1C ტიპი იქნება “DirectoryLink.DirectoryName”.

Მაგალითად:
მნიშვნელობა = Directories.Organizations.EmptyLink();
If Directories.TypeAllLinks().Contains(TypeValue(Value)) მაშინ
//ეს არის საცნობარო წიგნი
ElseIf Documents.TypeAllLinks().Contains(TypeValue(Value)) შემდეგ
//ეს არის დოკუმენტი
დაასრულე თუ;

მოთხოვნისას, 1C ტიპის შემოწმება შესაძლებელია ორი გზით.

პირველი მსგავსია აღწერილის, მაგრამ 1C ტიპის სახელი არ მიუთითებს "ბმულზე" ან "ობიექტზე", ანუ "DirectoryLink.Organizations" ნაცვლად ჩვენ ვწერთ "Directory.Organizations"

Მაგალითად:

ქვითარი ხელმისაწვდომი ტიპები 1C

ბევრ ობიექტს აქვს თვისება.ValueType, რომელიც შეიცავს 1C ტიპების ჩამონათვალს:

• ველი მსუქანი კლიენტის ფორმაზე
  Form Elements.FieldName.ValueType
• ველი ფორმაზე თხელი კლიენტი(გამონაკლისი: სახელწოდებით AvailableTypes)
  Elements.FieldName.AvailableTypes
• ღირებულებების ცხრილის სვეტი, ღირებულებების ხე
• ფორმის დეტალები
• შერჩევის ელემენტი

როგორ იმუშაოთ ველში 1C ტიპის ამ ჩამონათვალთან.ValueType - იხილეთ „ტიპების აღწერა“ განყოფილებაში „1C ენა“.

მუშაობა 1C დეტალების ტიპებთან კონფიგურაციის მეტამონაცემებში

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

ძირითადი მეთოდები:

• 1C ობიექტისთვის გამოიძახეთ Metadata() მეთოდი, რომელიც აბრუნებს კონკრეტული ობიექტის მეტამონაცემებს და შემდეგ იმუშავებს დეტალების ჩამონათვალთან (და ცხრილის განყოფილების დეტალებთან)
  დოკუმენტები.საქონლის მიღება.EmptyLink().Metadata().დეტალები
• გამოიყენეთ გლობალური ცვლადი "მეტამონაცემები", რომელიც აბრუნებს ყველა კონფიგურაციის მეტამონაცემებს და შემდეგ შედით კონკრეტული ობიექტის დეტალებზე
  მეტამონაცემები.დოკუმენტები.საქონლის მიღება.დეტალები

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

როგორ ვიმუშაოთ 1C ტიპების ამ ჩამონათვალთან - იხილეთ "ტიპების აღწერა" განყოფილებაში "1C ენა".

მიუთითეთ 1C ტიპის ფილტრი

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

• მნიშვნელობების სია (. AvailableValues)
• მართული კლიენტის ფორმის ველი (.AvailableTypes)

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

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

ჩვენ ვაგრძელებთ გაცნობას 1C:Enterprise-ის ახალ ფუნქციონალთან, რომელიც დაიწყო სერიის წინა სტატიაში. ამ სტატიაში მასალების შესწავლის შემდეგ თქვენ შეიტყობთ:

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

გამოყენებადობა

სტატიაში განხილულია 1C:Enterprise პლატფორმის ვერსია 8.3.4.437, მაგრამ მისი მასალები ასევე შეიძლება სასარგებლო იყოს მათთვის, ვინც მუშაობს ძველ გამოშვებებზე.

როგორ გავამარტივოთ განვითარება 1C: Enterprise 8.3-ში

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

განსაზღვრული ტიპები

პლატფორმა 8.3, ახალი ობიექტი დაემატა კონფიგურაციის ფილიალს "ზოგადი" - განსაზღვრული ტიპები.

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

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

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

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

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

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

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

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

ზოგიერთი დეტალისთვის არის აკრეფის სტანდარტი კონფიგურაციის ფარგლებში. მაგალითად, ჩვენ განვსაზღვრავთ რაოდენობას, როგორც სიგრძის რიცხვს 15 სიზუსტით 3, და ჯამს, როგორც სიგრძის რიცხვს 15 სიზუსტით 2.

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

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

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

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

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

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

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

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

ცვლილებები აღარ არის მანამდე მიმდინარე ვერსიებიპლატფორმა 8.3.10/8.3.11 არ მუშაობდა განსაზღვრულ ტიპთან.

კონფიგურაციის თვისება „ძირითადი როლები“

პლატფორმა 8.2-ში root კონფიგურაციის ელემენტს ჰქონდა „პირველადი როლი“ თვისება, რომელშიც დეველოპერმა განსაზღვრა როლი, რომელიც გამოიყენებოდა, თუ საინფორმაციო ბაზამომხმარებლები არ შექმნილა.

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

გასადიდებლად დააწკაპუნეთ სურათზე.

Form Client Event Handlers-ის შექმნა

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

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

პლატფორმა 8.3-ში გამოჩნდა დამხმარე კლიენტის ფორმის მოვლენების დამმუშავებლების შესაქმნელად.

გასადიდებლად დააწკაპუნეთ სურათზე.

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

კონფიგურაციის ატვირთვა ფაილებში

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

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

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

კონფიგურაციის ობიექტები აიტვირთება XML ფაილების ნაკრების სახით. მოდულები და ტექსტის განლაგება ინახება როგორც TXT ფაილები. სურათები კონფიგურაციიდან ინახება გამოსახულების ფაილებად (BMP, PNG და ა.შ.). დახმარების ინფორმაცია აიტვირთება HTML ფაილებში.

გასადიდებლად დააწკაპუნეთ სურათზე.

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

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

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

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

"c:\Program Files (x86)\1cv8\8.3.4.437\bin\1cv8.exe" DESIGNER /F "X:\Platform8Demo" /N "Administrator" /DumpConfigToFiles "X:\1"

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

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

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

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

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

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

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

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

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

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

გაითვალისწინეთ, რომ 8.3.7 ვერსიიდან, გამოჩნდა ახალი ატვირთვის ფორმატი, რომელსაც ეწოდება "იერარქიული". ძველი ფორმატი ცნობილი გახდა, როგორც "წრფივი". ფორმატის შერჩევა ხელმისაწვდომია ფაილის ატვირთვის ფანჯარაში:

8.3.11 ვერსიით დაწყებული, "იერარქიული" ფორმატი გახდა ერთადერთი ხელმისაწვდომი შერჩევისთვის ინტერაქტიული ატვირთვის დროს:

თუ იყენებთ ამ ფუნქციას, გირჩევთ:

• პირველ რიგში, გამოიყენეთ "იერარქიული" ატვირთვის ფორმატი;
• მეორეც, გამოიყენეთ პლატფორმა არანაკლებ 8.3.8+ ვერსიით, რადგან მისგან დაწყებული XML ფაილების ჩატვირთვა/ატვირთვის სიჩქარე მნიშვნელოვნად გაიზარდა.

8.3.10 ვერსიაში დაიწყო XML ფაილებში კონფიგურაციის ნაწილობრივი ატვირთვის მხარდაჭერა. შედეგად, შესაძლებელი გახდა კონფიგურაციის ატვირთვის გამოყენება XML-ში Git-თან ერთად.

მონაცემთა ტიპები 1C-ში: Enterprise 8.x

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

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

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

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

Თარიღი. თავად თარიღის გარდა, ამ ტიპის მნიშვნელობები ასევე შეიცავს დროს. დრო ეხება საათებს, წუთებს და წამებს. ინიციალიზაციისთანავე ცვლადი ტიპი"თარიღი" მიენიჭება მნიშვნელობა (თარიღი) "01 იანვარი, 0001 00 საათი 00 წუთი 00 წამი, ეს ზოგჯერ იწვევს გაღიზიანებას, მაგრამ დროთა განმავლობაში თქვენ ეჩვევით მას."

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

Განუსაზღვრელი. ტიპის "გაურკვეველი" მნიშვნელობები გამოიყენება იმ შემთხვევებში, როდესაც თქვენ უნდა მიუთითოთ ცარიელი მნიშვნელობა, რომელიც არ ეკუთვნის სხვა მონაცემთა ტიპს. მაგალითად, თქვენ უნდა გამოაცხადოთ ცვლადი, რომელიც შემდეგ გამოყენებული იქნება სადმე. თქვენ შეგიძლიათ მიანიჭოთ მას ისეთი მნიშვნელობა, როგორიცაა 0 ან “” (ანუ ცარიელი სტრიქონი), მაგრამ ამით ჩვენ დაუყოვნებლივ ვაყენებთ მისთვის შესაბამის ტიპს (რიცხვი ან სტრიქონი). მაგრამ რა მოხდება, თუ რომელიმე ამ ტიპის დაყენებამ შეიძლება ხელი შეუშალოს მოგვიანებით? ასეთ შემთხვევებში, შეგიძლიათ გამოიყენოთ "განუსაზღვრელი" ტიპის მნიშვნელობა. აღსანიშნავია ისიც, რომ ჩაშენებული ენის მრავალი ფუნქცია, წარუმატებლად შესრულების შემთხვევაში, შედეგად აბრუნებს ამ ტიპის მნიშვნელობას. თქვენი ფუნქციების აღწერისას რეკომენდებულია იგივე წესის დაცვა.

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

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

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

ცვლადი1 = 123; //ვინაიდან ჩვენ მივენიჭეთ რიცხვი, ცვლადის ტიპი იქნება "number".
ცვლადი2 = "სტრიქონი"; //აქ მივანიჭეთ სტრიქონი, რაც ნიშნავს, რომ ცვლადის ტიპი იქნება string.

ახლა თქვენ უნდა იყოთ 100% დარწმუნებული, რომ ცვლადი1 არის რიცხვითი. სწორედ აქ გამოდგება "ტიპი" (სასაცილოდ ჟღერს) და ასევე რამდენიმე დამხმარე ფუნქცია. ჯერ-ჯერობით დეტალებს არ შევეხები. უბრალოდ შეხედეთ და შეეცადეთ გაიგოთ ქვემოთ მოცემული მაგალითი:

თუ (TypeValue(Variable1) = Type ("ნომერი")) მაშინ

ანგარიში ("ცვლადი1 არის რიცხვითი!");

წინააღმდეგ შემთხვევაში

ანგარიში ("ცვლადი1 არ არის რიცხვითი:()");

დაასრულე თუ;

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

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

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

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

გამოყენებადობა

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

მონაცემთა პრიმიტიული ტიპები და მათი ზოგიერთი ფუნქცია

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

სიმებიანი მუდმივები

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

Message.Text = "არსებობს ცარიელი მონაცემები";

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

სტრიქონი შეიძლება შედგებოდეს ნებისმიერი სიმბოლოსგან. სიმები შეიძლება იყოს მრავალხაზოვანი. ამ შემთხვევაში, ყოველი ახალი ხაზი უნდა განისაზღვროს ბრჭყალებში. Მაგალითად:

ტექსტი = „შევსებულია არასწორი დეტალები“
„შეუძლებელია დოკუმენტის განთავსება“;

მძიმით იდება მხოლოდ ბოლო ხაზის ბოლოს.

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

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

მოთხოვნა.ტექსტი =
"აირჩიე
| Employees.Name AS Employee,
| თანამშრომლები.დაბადების თარიღი AS DateBirth
|საიდან
| Directory.Employees HOW თანამშრომლები
|სად
| არა თანამშრომლები ეს არის ჯგუფი“;

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

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

ტექსტი = „დეტალები არასწორად არის შევსებული“ + „დოკუმენტის განთავსება შეუძლებელია“;

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

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

ტექსტი = “შეცდომა მოდულში “General module1””;

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

და ბოლოს არის სამი ბრჭყალი: ბოლო ბრჭყალი ხურავს ხაზს, ორი წინა მიუთითებს ბრჭყალზე.

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

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

სინტაქსის ასისტენტში ისინი განყოფილებაში არიან ჩაშენებული ენის ზოგადი აღწერა – ჩაშენებული ფუნქციები – String ტიპის მნიშვნელობებთან მუშაობის ფუნქციები.

ფუნქციების საკმაოდ დიდი რაოდენობაა და ისინი, როგორც წესი, საკმარისია სიმებიანი მუდმივებთან მუშაობისთვის.

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

Ამოცანა:

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

ციფრების თანმიმდევრობა (ერთი ან მეტი), რომელიც გამოყოფილია სხვა სიმბოლოებისგან სივრცეებით, წარმოადგენს დადებით მთელ რიცხვს.

მაგალითად, ხაზი "72 ABC 6AP 31 54f -22" შეიცავს ორ მთელ რიცხვს დადებითი რიცხვები: 72 და 31. ინტერვალის გარდა, სხვა არამნიშვნელოვანი სიმბოლოები (როგორიცაა ჩანართი, კარის დაბრუნება) არ გამოიყენება. ფუნქციამ უნდა დააბრუნოს დადებითი მთელი რიცხვების რაოდენობა.

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

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

დამმუშავებლის შიგნით ჩვენ განვსაზღვრავთ ცვლადს ხაზი, Მაგალითად:

რიგი = „72 ABC 6AP 31 54f -22“;

რაოდენობა = მთელი რიცხვების რაოდენობა (სტრიქონი);

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

Report("სტრიქონი შეიცავს " + ნომერი + " მთელი რიცხვები");

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

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

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

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

Სინტაქსი:

სიმბოლოს კოდი (,)

Პარამეტრები:

(აუცილებელია)

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

დაბრუნების ღირებულება:
გადაცემული სიმბოლოს კოდი. კოდი ბრუნდება Unicode კოდირების მიხედვით.

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

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

მოდით განვსაზღვროთ შესაბამისი ცვლადები და მათი მნიშვნელობები:

Code0 = სიმბოლოს კოდი (“0”);
Code9 = CharacterCode(“9”);

პრობლემის გადასაჭრელად, ჩვენ ვირჩევთ შემდეგ სქემას:

1. თუ ხაზი შეიცავს წამყვან ან უკანა სივრცეებს ​​რაიმე რაოდენობით, მაშინ ჩვენ მოვიშორებთ მათ სპეციალური ფუნქცია. შემდეგ ჩვენ დავინტერესდებით პერსონაჟების ჯგუფებით შიდა სივრცეებს ​​შორის. თუ ჯგუფი შედგება მხოლოდ ციფრებისგან, მაშინ ეს არის მთელი რიცხვი. არსებობს სპეციალური ფუნქცია, რომელიც შეიძლება გამოყენებულ იქნას პირველი სივრცის პოზიციის დასადგენად.
2. მას შემდეგ რაც გექნებათ პირველი სივრცის პოზიცია, შეგიძლიათ გამოიყენოთ სხვა ფუნქცია, რათა მიიღოთ სიმბოლოთა ჯგუფი (ქვესტრიქონი) სივრცის მარცხნივ.
3. გავაანალიზოთ ჯგუფს შემადგენელი პერსონაჟები და დავადგინოთ არის თუ არა ის მთელი რიცხვი. იდენტიფიცირებული მთელი რიცხვები შეჯამდება სპეციალურ ცვლადში.
4. მოდით შევამოკლოთ საწყისი ხაზი სხვა ფუნქციის გამოყენებით ყველა სიმბოლოს არჩევით ახლა სივრცის მარჯვნივ. ეს სივრცე შეიძლება იყოს არა მხოლოდ ერთი, არამედ ზედიზედ სივრცეების მთელი სერია, ამიტომ დარჩენილ ხაზში გამოიყენეთ სპეციალური ფუნქცია, რათა მოიშოროთ ყველა მარცხენა სივრცე (ზედიზედ) და დაბრუნდეთ 2 წერტილში. ჩვენ გავიმეორებთ ნაბიჯები 2 წერტილიდან 4 წერტილამდე, სანამ არ მივაღწევთ მდგომარეობას, რომ არ დარჩეს სივრცეები ხაზში. ამ შემთხვევაში, შემცირებული სტრიქონი იქნება გაანალიზებული სიმბოლოების ბოლო ჯგუფი.

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

AbbrLP
სინტაქსი: AbbrLP()
Პარამეტრები: (აუცილებელია).
ჭრის სივრცეებს ​​(უმნიშვნელო სიმბოლოებს) პირველის მარცხნივ მნიშვნელოვანი სიმბოლოსტრიქონში და გამოჩნდება ხაზის ბოლო მნიშვნელოვანი სიმბოლოს მარჯვნივ.

იპოვე
სინტაქსი: Find(,)
Პარამეტრები: (აუცილებელია), (აუცილებელია).
აბრუნებს ნაპოვნი ქვესტრიქონის პირველი სიმბოლოს პოზიციას.
სტრიქონში სიმბოლოების ნუმერაცია იწყება 1-დან. თუ სტრიქონი არ შეიცავს მითითებულ ქვესტრინგს, მაშინ ჩვენ შემთხვევაში ქვესტრინგად გამოვიყენებთ ინტერვალს (“ ”).

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

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

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

AbbrL
სინტაქსი: აბრევიატურა ()
Პარამეტრები: (აუცილებელია).
წყვეტს სივრცეებს ​​(არამნიშვნელოვანი სიმბოლოები) სტრიქონის პირველი მნიშვნელოვანი სიმბოლოს მარცხნივ. ჩვენ ვიყენებთ ამ ფუნქციას დანარჩენი სტრიქონის მარცხენა მხარეს შესაძლო სივრცეების მოსაშორებლად.

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

რიცხვითი გამონათქვამები

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

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

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

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

ოპერაციები, რომლებიც გამოიყენება ნომრებზე:

• ჩვეულებრივი არითმეტიკული მოქმედებები(-, +, *, /). გამრავლება და გაყოფა უპირატესობას ანიჭებს შეკრებას და გამოკლებას. ფრჩხილებს აქვს უმაღლესი პრიორიტეტი. ასევე არსებობს უნარული ოპერატორები + და -, რომელთა უპირატესობა მოდის ფრჩხილების შემდეგ;
• ოპერაცია „გაყოფის დარჩენილი ნაწილი“ (%). მაგალითად, 12%5=2;
• მათემატიკური ფუნქციები, რომლებიც შეიძლება გამოვიყენოთ რიცხვებისთვის (ტრიგონომეტრიული ფუნქციები, სიძლიერე, კვადრატული ფესვი, დამრგვალება მითითებულ ადგილზე, რიცხვის მთელი ნაწილის არჩევა)

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

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

ლოგიკური მნიშვნელობები

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

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

ლიტერალები ტიპის Date

თარიღის აღწერის ორი გზა არსებობს. ერთ-ერთი მათგანი იყენებს სიტყვასიტყვით. ლიტერალი იწერება ერთ ბრჭყალებში.

ჯერ წელი იწერება, მერე თვე და მერე დღე.

საჭიროების შემთხვევაში, შეგიძლიათ დროც მიუთითოთ, რადგან 1C: Enterprise 8 სისტემაში, ნებისმიერი თარიღი შეიცავს როგორც თარიღს, ასევე დროს. Მაგალითად:

DocumentDate = '20140315121020';

თუ დრო არ არის მითითებული, ის ნაგულისხმევად არის ნულოვანი. თარიღის აღწერილობაში შეგიძლიათ გამოიყენოთ ნებისმიერი გამყოფი. Მაგალითად:

DocumentDate = '2014.03.15';

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

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

1C: Enterprise 8 სისტემაში, ცარიელი თარიღი არის კალენდრის დასაწყისი. ჩაწერის პარამეტრები:

EmptyDate = '00010101';
EmptyDate = თარიღი (1,1,1);

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

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

დამატების ოპერაცია გამოიყენება თარიღისთვის. დამატების ოპერაცია თარიღს ამატებს წამების მითითებულ რაოდენობას.

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

დავალების განცხადებაში, სადაც მრავალი ცვლადი ჯამდება (მაგალითად, ცვლადი = A + B + C), შესაძლებელია მონაცემთა პრიმიტიული ტიპების კონვერტაცია. მონაცემთა ტიპის კონვერტაცია ხორციელდება პირველი მონაცემთა ტიპის მნიშვნელობაზე.

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

ასე რომ, სტრიქონი + ნომერი = სტრიქონი. ზოგჯერ რიცხვი შეიძლება დაემატოს სტრიქონს, თუ სტრიქონიდან შეიძლება ამოღებულ იქნას გარკვეული რიცხვითი მნიშვნელობა (მაგალითად, 123 + "456").

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

True AND 1 = True;
მართალია და 0 = მცდარი.

ნულზე მეტი ნებისმიერი რიცხვი გარდაიქმნება True-ში, 0 გარდაიქმნება მცდარი.

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

ამ შემთხვევაში True გარდაიქმნება 1-ად და False 0-ად.

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

TO ხაზინებისმიერი ტიპის მონაცემთა კონვერტაცია ხდება.

რიცხვის მიღება შესაძლებელია სტრიქონიდან ან ლოგიკურიდან. ლოგიკური კონვერტაცია: True 1-ზე, False 0-მდე.

შეგიძლიათ გადასცეთ სტრიქონი Date-ზე, თუ ის შეიცავს თარიღის მნიშვნელობას. მაგალითად, თარიღი (“20140315”). როგორც უკვე აღვნიშნეთ, შესაძლებელია კონვერტაცია პოზიციის მიხედვით:

Თარიღი(,).

თქვენ შეგიძლიათ გადაიყვანოთ ნომერი და თავად ლოგიკური მნიშვნელობა ლოგინად.

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

მონაცემთა პრიმიტიული ტიპები Number, String, Date და Boolean შეიძლება იმოქმედონ მონაცემთა ბაზის ველებად.

ნულოვანი და განუსაზღვრელი მნიშვნელობები

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

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

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

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

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

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

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

მონაცემთა ტიპი Undefined არის ზოგიერთი ატრიბუტის არა ცარიელი მნიშვნელობა.

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

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

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

მაგალითად, დირექტორიაში ელემენტის ძებნა სახელით, თუ რომელიმე დირექტორიაში არ არის ასეთი ელემენტის სახელი. მეთოდი FindByNameდააბრუნებს მნიშვნელობას Განუსაზღვრელი.

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

თუ არსებობს დოკუმენტების სია და ეს სია ცარიელია (მასში ხაზები არ არის), მაშინ მიმდინარე ხაზი მიიღებს მნიშვნელობას Განუსაზღვრელი.

თუ ინფობაზას აქვს ატრიბუტი კომპოზიციური მონაცემთა ტიპით, მაშინ ამ ატრიბუტის ცარიელი მნიშვნელობა იქნება ტოლი Განუსაზღვრელი.

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

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

მონაცემთა ტიპი ტიპი

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

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

აღსანიშნავია, რომ მონაცემთა ამ ტიპს არ აქვს ლიტერალი. ჩვენ არ შეგვიძლია დავწეროთ NULL ან Undefined, მაგრამ შეგვიძლია მივიღოთ ამ ტიპის მნიშვნელობა ორი ფუნქციის გამოყენებით ტიპიდა TypeValue.

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

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

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

მომავალში ის უნდა შევადაროთ ნებისმიერი ტიპის ინტერესს. Მაგალითად:

თუ TypeValue(Element) = Type (“DirectoryLink.Nomenclature”) მაშინ
ანგარიში ("ეს არის პროდუქტი");
დაასრულე თუ;

დასასრულს, მოდით შევაჯამოთ ყველა დაფარული მასალა.

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

ჩვენ უფრო დეტალურად შევისწავლით ამ ობიექტებს შემდეგ სტატიაში, ასე რომ თვალი ადევნეთ! ;)