ნაწილი 1. მეთოდები (26).

1.1. ძირითადი მეთოდები (10). დამოუკიდებელი, აგებულია საკუთარ მარტივ ალგორითმებზე.

Page_Add() (მარჯვნივ-მარცხნივ დამატება მითითებული სიმბოლოებით).

Page_Inverse () (ინვერსია - სიმბოლოები მარჯვნიდან მარცხნივ).

Page_Codes() (სიმბოლოების კოდები ""-ის მეშვეობით და მასივი კოდებით)

Page_Characters() (კოდების სტრიქონი გამოყოფილი ""-ით ან მასივიდან კოდებით)

Page_ReplaceSymbols() (ზოგიერთი სიმბოლო სხვებით ჩანაცვლება).

String_FromArray() (სტრიქონი გამყოფით გამოყოფილი ფრაგმენტების მასივიდან)

Page_FindIn() (მოძებნეთ ქვესტრიქონი (მარჯვნივ) მითითებული მოვლენის ნომრით).

Page_FindGr() (მოძებნეთ სიმბოლოთა ჯგუფი, რომელიც შედის მითითებულ სიმბოლოთა ნაკრებში)

Page_FindNumber() (მოძებნეთ რიცხვი, მათ შორის მარჯვნივ მითითებული შემთხვევის ნომრით)

Page_Interpret() (მაივში, დადგენილი სინტაქსის მიხედვით)

1.2. წარმოებული მეთოდები (12). სინამდვილეში, ეს არის ოთხი განზოგადებული ალგორითმის მეთოდის გამოყენება (იხ. ნაწილი 2)

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

Page_Find() (მოძებნეთ ქვესტრიქონი (მათ შორის, რეგისტრირებული და მარჯვნივ) მითითებული მოვლენის ნომრით).

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

Str_Piece() (სტრიქონის ნაჭერი დელიმიტერის მითითებულ მოვლენებს შორის (მარცხნივ ან მარჯვნივ)).

Page_ReplacePiece() (ანაცვლებს "ნაწილს" წყაროს სტრიქონში მითითებული სტრიქონით).

Page_ВArray() (გამყოფის მითითებულ მოვლენებს შორის (მათ შორის მარჯვნივ და ქეისის გარეშე).

Page_TransferBySyllables() (დაყოფილია ქვესტრიქონებად "Hardly", დეფისით).

Page_TransferByWords() (დაყოფილია ქვესტრიქონებად „რბილად“)

Page_Cut() ("გაჭრა" მითითებული სიგრძის ქვესტრიქონებად)

Str_Shorten() (შეცვალეთ "შემოკლებული" სიმბოლოების მარცხენა ჯგუფი "შემცვლელი სტრიქონით"

Page_Abbreviation() (შეცვალეთ "შემცირებული" სიმბოლოების მარჯვენა ჯგუფი "ჩანაცვლების სტრიქონით"

Str_ShortenS() (შეცვალეთ „შემოკლებული“ სიმბოლოების ჯგუფის შუაში „შემცვლელი სტრიქონი“

Page_Extend (გაფართოება მითითებულ სიგრძემდე მითითებული სიმბოლოების რაოდენობის გაზრდით)

1.3. დეტალური მეთოდები (3). ხაზის "განკვეთა" მაგიდაზე გადატანით დეტალური ინფორმაციით.

Page_vTableIn() (ცხრილში ჩადგმული დელიმიტერების სისტემის მიხედვით).

Page_vTableGr (მაგიდაზე მრავალ დონის ფილტრის მიხედვით).

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

ნაწილი 2. განზოგადებული მეთოდები-ალგორიმები (3).

Page_Occurrence() (მეთოდები "Find" და "Replace").

Page_Fragments() (მეთოდები "Piece", "ReplacePiece", "InArray", "inTableIn").

Page_Abcr() (მეთოდები "AbcrL", "AbcrP", "AbcrS", "Expand".

Page_Split() (მეთოდები "გადაადგილება სილაბებით", "გადაადგილება სიტყვებით", "გაჭრა").

ნაწილი 3. უნივერსალური ფუნქცია.

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

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

ფუნქციები შვიდი პარამეტრით ("დემო" აგებულია ამ ფუნქციაზე):

გვერდი_(მეთოდები, ქვემეთოდები, შეყვანა, პარამი1, პარამი2, სიგრძე_ნომერი_პოზიცია, დამატებითი გამომავალი)

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

- "მეთოდები" - რამდენიმე "კომბინირებული" და (ან) ერთი "ექსკლუზიური" მეთოდი

(ერთ სიმბოლოს კოდები ან სახელები, შესაძლებელია ","-ის საშუალებით)

- "ქვემეთოდები" - რამდენიმე "კომბინირებული" და (ან) "ექსკლუზიური" ვარიანტი

„ექსკლუზიური“ მეთოდი (ერთსიმბოლოიანი კოდები ან სახელები);

- „შეყვანა“ - სტრიქონი, ან მასივი ან მნიშვნელობების ცხრილი;

- "Param1" - საძიებო სტრიქონი, ჩანაცვლებები, გამყოფები, ფილტრები;

- "Param2" - ჩანაცვლების სტრიქონი ან სიმბოლოები;

- „სიგრძე_ნომერი_პოზიცია“ - რიცხვი, რიცხვები გამყოფის ან მასივის მეშვეობით რიცხვებით;

- „დამატებითი გამომავალი“ - რიცხვი ან სტრიქონი ან მასივი ან მნიშვნელობების ცხრილი;

ქვემეთოდების სახელები და/ან ერთსიმბოლოიანი კოდები, აგრეთვე ნომრები

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

რომელიმე ქვემოთ ჩამოთვლილი დელიმიტერებიდან: ” :;”.

ნაწილი 4. რამდენიმე მაგალითი.

There areNumbersInLine=(Str_FindNumber(InLine)<>Განუსაზღვრელი);

ხაზში არის ნომრები = (String_FindGr(Inline,"+0123456789")>0);

არის ლათინური = (Str_FindGr(InStr, Str_Interpret("lL"))>0);

არის მითითებული ნიშნები = (Str_NfindGr(VxStr, "+to rogYu.0p9")>0);

IsNotPrinted=(Str_FindGr(InxStr, Line_Interpret("-l-L-r-R-P-Z-C"))>0);

ნაწილი 5. დასკვნა.

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

გამოყენებული იყო ჩაშენებული ფუნქციები: Left(), Right(), Middle(), StrLength()

- (პოზიციონირება და ხაზის ნაწილის მიღება უნდა იყოს „სწრაფი“).

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

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

ხაზის მნიშვნელობა 1C

1. დავიწყოთ უმარტივესით. ცვლადის შექმნა და მისთვის მუდმივი სტრიქონის მნიშვნელობის მინიჭება ასე გამოიყურება 1C-ში:

ცვლადი = "გამარჯობა, სამყარო!";

თუ თქვენ გჭირდებათ ციტატის სიმბოლოს მითითება მუდმივი 1C სტრიქონის მნიშვნელობაში, მაშინ უნდა გააორმაგოთ იგი ""

ცვლადი = "გამარჯობა, სამყარო"!;

2. ხაზის გაწყვეტა 1C შეიძლება დაზუსტდეს ერთდროულად ორი გზით. პირველი იყენებს სიმბოლოს |

ცვლადი = "გამარჯობა,
| სამყარო! ";

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

ცვლადი = "გამარჯობა" + სიმბოლოები. PS + "მშვიდობა!";

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

ენების სია განთავსებულია კონფიგურაციის ფანჯარაში General/Languages ​​ფილიალში. თითოეულ ენას აქვს მოკლე იდენტიფიკატორი, როგორიცაა ruან ინჟ.

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

Variable = "ru=""გამარჯობა, მსოფლიო! ""; en=""გამარჯობა, მსოფლიო! """;

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

//სწორია ორენოვანი კონფიგურაციისთვის
ანგარიში (NStr(ცვლადი));

საყრდენები ხაზის ტიპის 1C

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

თუ მიუთითებთ ატრიბუტის ტიპს - ხაზი 1C, მაშინ დამატებით უნდა მიუთითოთ პარამეტრები.

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

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

მუშაობა 1C სტრიქონებთან

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

• AbbrLP ("წარმოუდგენელი, მაგრამ მართალია!")
  შლის დამატებით სივრცეებს ​​1C ხაზიდან. ასევე შეიძლება გამოყენებულ იქნას ნებისმიერი ტიპის 1C სტრიქონზე გადასაყვანად (მაგალითად, რიცხვებში).
• ცვლადი = "ვასია" + AbbrLP(" პლუს") + "ოლია"; //იქნება "ვასია პლუს ოლია"
  რამდენიმე 1C სტრიქონის მნიშვნელობის შეჯამების მაგალითი. შედეგი იქნება ერთი ხაზი 1C.
• ცვლადი = Lev("მუსიკა", 2); //იქნება "მუ"
  ცვლადი = საშუალო ("მუსიკა", 2, 2); //იქნება "საფრთხე"
  ცვლადი = უფლებები ("მუსიკა", 2); //იქნება "კა"
  1C სტრიქონიდან ქვესტრიქონის მიღების სხვადასხვა ვარიანტები.
• ცვლადი = Find("მუსიკა", "zy"); //იქნება 3
  მოძებნეთ ქვესტრიქონი 1C სტრიქონში, დაწყებული სიმბოლო 1-ით.
• ცვლადი = StrLength ("მუსიკა"); //იქნება 6
  აბრუნებს სიმბოლოების რაოდენობას 1C ხაზში.
• მოხსენება ("გამარჯობა") //შეტყობინებების ფანჯარაში 1C ფანჯრის ბოლოში
  გაფრთხილება ("გამარჯობა") // ამომხტარი დიალოგი
  სტატუსი ("გამარჯობა") // სტატუსის ჩვენების ხაზში ქვედა მარცხენა მხარეს
  .

ობიექტების მიტანა 1C ხაზამდე

მოგეხსენებათ, სტრუქტურირებული ინფორმაციის გაცვლის ყველაზე პოპულარული ფორმატი ამჟამად არის XML. MS Office Word-ის და Excel-ის უახლესი ვერსიაც კი ინახავს ფაილებს ამ ფორმატში (შესაბამისად, შეცვალეთ გაფართოება zip-ზე, გახსენით არქივში).

მონაცემთა გაცვლის 1C პლატფორმა გთავაზობთ რამდენიმე ვარიანტს, რომელთაგან მთავარი ასევე არის XML.

1. უმარტივესი მეთოდია Abbreviation() ან String() ფუნქციის გამოყენება. თქვენ შეგიძლიათ გამოიყენოთ REPRESENTATION() ფუნქცია მოთხოვნის ორგანოში. მათი მოქმედების შედეგი იგივეა - ისინი ქმნიან მომხმარებლისთვის ნებისმიერი 1C ობიექტის სიმებიანი წარმოდგენას.

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

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

StringViewXml = XMLString(Value); //მიიღეთ XML 1C მნიშვნელობიდან
Value1C = XMLValue(Type("DirectoryLink.Nomenclature"),TypeStringXml); //მიიღეთ 1C მნიშვნელობა XML სტრიქონიდან, უნდა მიუთითოთ 1C ტიპი, რომელიც უნდა მიიღოთ

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

მწკრივი = ValueInRowInt(Value1C); //მიიღეთ სტრიქონი 1C 1C მნიშვნელობიდან
ValueVFile ("C:\MyFile.txt", Value1C); //სხვა ვარიანტი, ჩვენ ვიღებთ ფაილს შენახული სტრიქონით 1C მნიშვნელობიდან
Value1C = ValueFromStringInt(String); //უკან 1C ხაზიდან
Value1C = ValueFile("C:\MyFile.txt"); //უკან ფაილიდან

1C ხაზების რედაქტირება ფორმაზე

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

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

ცვლადი = "";
Row = EnterValue (ცვლადი, "Enter Full Name");

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

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

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

4. თუ შეყვანის ველის ყველა შესაძლებლობა არ არის საკმარისი თქვენთვის, არის ჩაშენებული რედაქტორი. ფორმაში დასამატებლად, თქვენ უნდა დაამატოთ ტექსტური დოკუმენტის ველი Form/Insert Control მენიუში. მის თვისებებში შეგიძლიათ მიუთითოთ მისი მუშაობის რეჟიმი - Extension თვისება.

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

Form Elements.ElementNameTextDocumentField.SetText(StringValue); //აქ ValueString არის ტექსტი მიღებული, მაგალითად, ატრიბუტიდან

და შენახვის დამმუშავებელში - მაგალითად, Save ღილაკში - დაამატეთ შენახვა:

ValueString = FormElements.ElementNameTextDocumentField.GetText(); //Valueხაზი აქ არის ატრიბუტი, სადაც ჩვენ ვინახავთ მნიშვნელობას

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

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

• 1C ობიექტში, რომლის ფორმასაც ვქმნით (ცნობარი, დოკუმენტი, დამუშავება და ა.შ.) - დაამატეთ ატრიბუტი Value Storage ტიპის.
• OnReadOnServer() ფუნქციაში ჩვენ ვაყენებთ ტექსტს ატრიბუტიდან

  //აქ ატრიბუტი არის 1C ობიექტის დამატებული ატრიბუტი
  //აქ FormattedDocument არის რედაქტირებისთვის ფორმის ველის სახელი
  &სერვერზე
  
  FormattedDocument = CurrentObject.Attributes.Get();
  პროცედურის დასასრული
  

• BeforeWritingOnServer() ფუნქციაში ან ღილაკის გამოყენებით ჩვენ დავწერთ ტექსტს ველიდან

  &სერვერზე
  პროცედურა სერვერზე წაკითხვისას (CurrentObject)
  CurrentObject.Props = NewValueStorage(FormattedDocument);
  პროცედურის დასასრული

String ტიპი გვხვდება პროგრამირების ყველა ენაში. ის პრიმიტიულია და 1C-ში არის მასთან მუშაობის მრავალი ფუნქცია. ამ სტატიაში ჩვენ დეტალურად განვიხილავთ 1C 8.3 და 8.2 სტრიქონების ტიპებთან მუშაობის სხვადასხვა გზებს მაგალითების გამოყენებით.

ხაზი

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

String (False) // აბრუნებს "არა"
String(12345) // აბრუნებს "12,345"
სტრიქონი (მიმდინარე თარიღი()) //"07/21/2017 11:55:36″

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

SokrLP, SokrL, SokrP

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

Abbreviation(" Spaces will remove ორივე მხარეს ") // "Spaces on two sides will remove"
Abbreviation(" Spaces on two sides will remove ") // " spaces on the left will remove "
Abbreviation(" Spaces on two sides will remove ") // " spaces on the right will remove"

ლომი, მარჯვენა, საშუალო

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

Lev("String ცვლადი", 4) // აბრუნებს "Str"
Right("String ცვლადი", 7) // აბრუნებს "ცვლადი"
საშუალო ("String variable", 2, 5) // აბრუნებს "troko"

სიძლიერის სიგრძე

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

StrLength("Word") // შესრულების შედეგი იქნება ნომერი 5

იპოვე

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

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

Find("ერთი, ორი, ერთი, ორი, სამი", "ორი") // ფუნქცია დააბრუნებს რიცხვს 6

ცარიელი ხაზი

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

EmptyString("Pupkin Vasily Ivanovich") // ფუნქცია დააბრუნებს მნიშვნელობას False
EmptyString(" ") // ფუნქცია დააბრუნებს მნიშვნელობას True

VReg, NReg, Treg

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

Vreg ("GENERAL DIRECTOR") // დაბრუნების მნიშვნელობა - "CEO DIRECTOR"
NReg ("CEO DIRECTOR") // დაბრუნების მნიშვნელობა - "CEO"
TREG ("CEO DIRECTOR") // დაბრუნების მნიშვნელობა - "გენერალური დირექტორი"

გვერდის ჩანაცვლება

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

StrReplace("წითელი, თეთრი, ყვითელი", ","", ";") // აბრუნებს "წითელს; თეთრი; ყვითელი"

StrNumberLines

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

ქვემოთ მოცემულ მაგალითში ციკლი გაივლის სამ რაუნდს, რადგან LineNumberRow ფუნქცია დააბრუნებს მნიშვნელობას 3:

იყიდება ind = 1 Str სტრიქონების რაოდენობის მიხედვით ("Line1" + Symbols.PS + "Line2" + Symbols.PS + "Line3") ციკლი
<тело цикла>
საბოლოო ციკლი;

StrGetString

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

StrGetString("String1" + Characters.PS + "String2" + Characters.PS + "String3", 2) // დააბრუნეთ "String2"

PageNumberOccurrences

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

StrNumberAttachments("a;b;c;d; ", ";") // ფუნქცია დააბრუნებს რიცხვს 4

სიმბოლო და სიმბოლო კოდი

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

SymbolCode("A") // ფუნქცია დააბრუნებს რიცხვს 1040
CharacterCode(1040) // ფუნქცია დააბრუნებს "A"-ს

საერთო ამოცანები სტრინგებთან მუშაობისას

სტრიქონების შეერთება

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

"სტრიქონი 1″ + "ხაზი 2" //ორი ხაზის დამატების შედეგი იქნება "სტრიქონი 1 ხაზი 2"

ტიპის კონვერტაცია

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

String(1000) // აბრუნებს "1000"

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

StrReplace(String(1000),Characters.NPP,"") // აბრუნებს "1000"

String(Format(1000,"HG=")) // აბრუნებს "1000"

ციტატები სტრიქონში

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

Header = String("Horns and Hooves LLC - ეს ჩვენ ვართ!") // დააბრუნებს "Horns and Hooves LLC - ეს ჩვენ ვართ!"

მრავალხაზოვანი, ხაზის შესვენება

მრავალხაზოვანი ტექსტის შესაქმნელად, უბრალოდ დაამატეთ მას ხაზების წყვეტები (Symbols.PS).

MultilineText = "პირველი ხაზი" + სიმბოლოები. PS + "მეორე ხაზი"

როგორ ამოიღოთ სივრცეები

იმისათვის, რომ წაშალოთ სივრცეები მარჯვნივ ან მარცხნივ, შეგიძლიათ გამოიყენოთ ფუნქცია "ScrAP()" (ასევე "ScrL()" და "ScrP()"):

StringNoSpaces = აბრევიატურა (" ბევრი ასო ") // ფუნქცია დააბრუნებს მნიშვნელობას "ბევრ ასო"

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

StringNoSpaces = StrReplace(String(99999),Characters.NPP,"") // აბრუნებს "99999"

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

StringNoSpaces = StrReplace("გამარჯობა","") // აბრუნებს "გამარჯობა"

სიმების ერთმანეთთან შედარება

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

"Hello" = "hello" // აბრუნებს False
"Hello" = "Hello" // აბრუნებს True
"Hello" = "მშვიდობით" // დაბრუნდება False

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

სიმებიანი დამატება

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

აირჩიეთ "სახელი:"

ქვესტრიქონის ფუნქცია

SUBSTRING(<Строка>, <НачальнаяПозиция>, <Длина>)

Environment() ფუნქციის ანალოგი ობიექტის მოდელიდან. Substring() ფუნქცია შეიძლება გამოყენებულ იქნას სტრიქონების მონაცემებზე და საშუალებას გაძლევთ აირჩიოთ ფრაგმენტი <Строки> სიმბოლოს ნომრით დაწყებული <НачальнаяПозиция> (სტრიქონის სიმბოლოები დანომრილია 1-დან) და სიგრძე <Длина> პერსონაჟები. ფუნქციის გამოთვლის შედეგს აქვს ცვლადი სიგრძის სტრიქონის ტიპი და სიგრძე ჩაითვლება შეუზღუდავად, თუ <Строка> აქვს შეუზღუდავი სიგრძე და პარამეტრი <Длина> არ არის მუდმივი ან 1024-ზე მეტი.

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

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

ფუნქცია მსგავსი

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

SELECT Counterparties დასახელება AS სვეტი 1 FROM Counterparties AS Counterparties.

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

LIKE - ოპერატორი, რომელიც ამოწმებს სტრიქონს ნიმუშთან მსგავსებაზე. LIKE-ის ანალოგი SQL-ში.

SIMILAR ოპერატორი საშუალებას გაძლევთ შეადაროთ მის მარცხნივ მითითებული გამოხატვის მნიშვნელობა მარჯვნივ მითითებულ შაბლონის სტრიქონთან. გამოხატვის მნიშვნელობა უნდა იყოს string ტიპის. თუ გამოხატვის მნიშვნელობა ემთხვევა შაბლონს, ოპერატორის შედეგი იქნება TRUE, წინააღმდეგ შემთხვევაში იქნება FALSE.

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

• % (პროცენტი): თანმიმდევრობა, რომელიც შეიცავს ნებისმიერი რაოდენობის თვითნებურ სიმბოლოებს;
• _ (ხაზგასმით): ერთი თვითნებური სიმბოლო;
• [...] (ერთი ან მეტი სიმბოლო კვადრატულ ფრჩხილებში): ნებისმიერი სიმბოლო, რომელიც ჩამოთვლილია კვადრატულ ფრჩხილებში. ჩამოთვლა შეიძლება შეიცავდეს დიაპაზონებს, მაგალითად a-z, რაც ნიშნავს თვითნებურ სიმბოლოს, რომელიც შედის დიაპაზონში, დიაპაზონის ბოლოების ჩათვლით;
• [^...] (კვადრატულ ფრჩხილებში უარყოფის ნიშანი, რომელსაც მოჰყვება ერთი ან მეტი სიმბოლო): ნებისმიერი ცალკეული სიმბოლო, გარდა იმ სიმბოლოებისა, რომლებიც ჩამოთვლილია უარყოფის ნიშნის შემდეგ.

ნებისმიერი სხვა სიმბოლო ნიშნავს თავის თავს და არ ატარებს რაიმე დამატებით დატვირთვას. თუ ჩამოთვლილი სიმბოლოებიდან ერთ-ერთი უნდა დაიწეროს როგორც თავად, მაშინ მას წინ უნდა უძღოდეს<Спецсимвол>. მე თვითონ<Спецсимвол>(ნებისმიერი შესაფერისი სიმბოლო) განისაზღვრება იმავე განცხადებაში SPECIAL CHARACTER საკვანძო სიტყვის შემდეგ.

განხორციელებული ვერსია 8.3.6.1977.

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

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

ფორმატირების ფუნქცია StrTemplate()

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

StrTemplate (<Шаблон>, <Значение1-Значение10>)

<Шаблон>- ეს არის სტრიქონი, რომელშიც თქვენ უნდა ჩაანაცვლოთ პარამეტრების წარმოდგენები.

<Значение1> , ... <Значение10>- ეს არის პარამეტრები (მაქსიმუმ ათი), რომელთა გამოსახულებები უნდა შეიცვალოს სტრიქონში.

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

მაგალითად, ასეთი ოპერატორის შესრულების შედეგი:

იქნება ხაზი:

მონაცემთა შეცდომა მე-2 სტრიქონზე (საჭიროა თარიღის ტიპი)

სტრიქონებთან მუშაობის ფუნქცია StrCompare()

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

თქვენ შეგიძლიათ იგივე ქმედება ადრე შეასრულოთ Value Comparison ობიექტის გამოყენებით:

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

სტრიქონებთან მუშაობის ფუნქციები StrStartsWith(), StrEndsAt()

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

მაგალითად, ისინი მოსახერხებელია If განაცხადის გამოყენებაში:

სტრიქონებთან მუშაობის ფუნქციები StrDivide(), StrConnect()

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

სტრიქონებთან მუშაობის ფუნქცია StrFind()

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

• ძიება სხვადასხვა მიმართულებით (თავიდან, ბოლოდან);
• ძიება მითითებული პოზიციიდან;
• მოძებნეთ მოვლენა მითითებული ნომრით (მეორე, მესამე და ა.შ.).

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

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