1C 8.3 სტრიქონები ჩაშენებულ ენაში 1c წარმოადგენს პრიმიტიული ტიპის მნიშვნელობებს ხაზი... ღირებულებები ამ ტიპისშეიცავდეს თვითნებური სიგრძის Unicode სტრიქონს. სტრიქონის ტიპის ცვლადები წარმოადგენს ბრჭყალებში ჩასმული სიმბოლოების ერთობლიობას.
მაგალითი 1. შევქმნათ სტრიქონის ცვლადი ტექსტით.
StringVariable = "გამარჯობა სამყარო!";
სტრიქონებთან მუშაობის ფუნქციები 1c 8.3-ში
ვ ამ განყოფილებასმოგეცემათ ძირითადი ფუნქციები, რომლებიც საშუალებას გაძლევთ შეცვალოთ ხაზები 1c-ში, ან გააანალიზოთ მათში არსებული ინფორმაცია.
ქუჩის სიგრძე
სიძლიერის სიგრძე (<Строка>) ... აბრუნებს პარამეტრში გადაცემულ სტრიქონში შემავალი სიმბოლოების რაოდენობას.
მაგალითი 2. დავთვალოთ სიმბოლოების რაოდენობა სტრიქონში "Hello World!"
სტრიქონი = "გამარჯობა სამყარო!"; სიმბოლოების რაოდენობა = StrLength (სტრიქონი); ანგარიში (სიმბოლოების რაოდენობა);
ამ კოდის შესრულების შედეგი იქნება სიმბოლოების რაოდენობის ჩვენება სტრიქონში: 11.
აბრევიატურა
AbbrL (<Строка>)
... წყვეტს უმნიშვნელო სიმბოლოებს სტრიქონის პირველი მნიშვნელოვანი სიმბოლოს მარცხნივ.
მცირე პერსონაჟები:
- სივრცე;
- არამტვრევადი სივრცე;
- ცხრილების შედგენა;
- ვაგონის დაბრუნება;
- ხაზოვანი თარგმანი;
- ფორმის (გვერდის) თარგმანი.
მაგალითი 3. წაშალეთ ყველა სივრცე სტრიქონის მარცხენა მხრიდან "მსოფლიო!" და მიამაგრეთ მასზე სტრიქონი "Hello".
სიმებიანი = შემოკლებული ("მშვიდობა!"); სტრიქონი = "გამარჯობა" + სტრიქონი; ანგარიში (სტრიქონი);
ამ კოდის შესრულების შედეგი იქნება ხაზის გამომავალი "Hello World!"
აბრევიატურა
აბრევიატურა (<Строка>) ... წყვეტს უმნიშვნელო სიმბოლოებს სტრიქონის პირველი მნიშვნელოვანი სიმბოლოს მარჯვნივ.
მაგალითი 4. ფორმა "გამარჯობა" და "მსოფლიო!" ფრაზა "გამარჯობა სამყარო!"
სტრიქონი = შემოკლებული ("გამარჯობა") + "" + შემოკლებული ("მსოფლიო!"); ანგარიში (სტრიქონი);
SokrLP
SocrLP (<Строка>)
... წყვეტს უმნიშვნელო სიმბოლოებს სტრიქონის პირველი მნიშვნელოვანი სიმბოლოს მარჯვნივ და ასევე წყვეტს უმნიშვნელო სიმბოლოებს სტრიქონის პირველი მნიშვნელოვანი სიმბოლოს მარცხნივ. ეს ფუნქციაიგი გამოიყენება უფრო ხშირად, ვიდრე წინა ორი, რადგან ის უფრო მრავალმხრივია.
მაგალითი 5. ამოიღეთ უმნიშვნელო სიმბოლოები მარცხნივ და მარჯვნივ კონტრაგენტის სახელზე.
Counterparty = Directories.Contractors.NaytiPoRequisite ("INN", "0777121211"); CounterpartyObject = Counterparty.GetObject (); CounterpartyObject.Name = SokrLP (CounterpartyObject.Name); CounterpartyObject.Write ();
ლომი
Ლომი(<Строка>, <ЧислоСимволов>)
... იღებს სტრიქონის პირველ სიმბოლოებს, სიმბოლოების რაოდენობა მითითებულია პარამეტრში პერსონაჟების რაოდენობა.
მაგალითი 6. შეუშვით სტრუქტურაში თანამშრომელიშეიცავდეს დასაქმებულის სახელს, გვარს და პატრონიკას. მიიღეთ სტრიქონი გვარით და ინიციალებით.
InitialName = ლომი (Employee.Name, 1); პატრონიმი საწყისი = ლომი (დასაქმებული, პატრონიმი, 1); FullName = Employee.LastName + "" + InitialName + "." + პატრონიმის ინიციალი + ".";
უფლება
მარჯვენა (<Строка>, <ЧислоСимволов>) ... იღებს სტრიქონის ბოლო სიმბოლოებს, სიმბოლოების რაოდენობა მითითებულია პარამეტრში პერსონაჟების რაოდენობა.თუ სიმბოლოების მითითებული რაოდენობა აღემატება სტრიქონის სიგრძეს, მაშინ მთელი სტრიქონი ბრუნდება.
მაგალითი 7. დავუშვათ, რომ სტრიქონის ცვლადის ბოლო შეიცავს თარიღს ფორმატში "yyyymmdd", მიიღეთ სტრიქონი თარიღით და გადააკეთეთ იგი ტიპად. თარიღი.
სტრიქონი = " მიმდინარე თარიღი: 20170910 "; StringDate = მარჯვენა (სტრიქონი, 8); თარიღი = თარიღი (StringDate);
ოთხშაბათი
ოთხშაბათი (<Строка>, <НачальныйНомер>, <ЧислоСимволов>) ... იღებს ქვესტრინგს პარამეტრად გადაცემული სტრიქონიდან ხაზი, დაწყებული სიმბოლოდან, რომლის ნომერიც მითითებულია პარამეტრში საწყისი ნომერიდა სიგრძე გადავიდა პარამეტრზე პერსონაჟების რაოდენობა.ხაზში სიმბოლოების ნუმერაცია იწყება 1-დან. თუ პარამეტრში საწყისი ნომერიმითითებულია მნიშვნელობა, რომელიც არის ნულის ტოლი ან ნაკლები, მაშინ პარამეტრი იღებს მნიშვნელობას 1. თუ პარამეტრი სიმბოლოების რაოდენობაარ არის მითითებული, შემდეგ არჩეულია სიმბოლოები ხაზის ბოლომდე.
მაგალითი 8. დავუშვათ, რომ მეცხრე პოზიციიდან დაწყებული სტრიქონის ცვლადი შეიცავს რეგიონის კოდს, თქვენ უნდა მიიღოთ იგი და ჩაწეროთ ცალკე სტრიქონში.
ხაზი = "რეგიონი: 99 მოსკოვი"; რეგიონი = ოთხ (ხაზი, 9, 2);
ძიება
იპოვე (<Строка>, <ПодстрокаПоиска>, <НаправлениеПоиска>, <НачальнаяПозиция>, <НомерВхождения>) ... ეძებს მითითებულ ქვესტრინგს სტრიქონში, აბრუნებს ნაპოვნი ქვესტრიქონის პირველი სიმბოლოს პოზიციის ნომერს. განვიხილოთ ამ ფუნქციის პარამეტრები:
- ხაზი... წყაროს სტრიქონი;
- ქვესტრიქონი... საძიებელი ქვესტრიქონი;
- ძებნის მიმართულება... განსაზღვრავს მიმართულებას სტრიქონში ქვესტრიქონის მოსაძებნად. შეუძლია მიიღოს მნიშვნელობები:
- ძიების მიმართულება. დასაწყისიდან;
- ძიების მიმართულება.;
- საწყისი პოზიცია... განსაზღვრავს პოზიციას სტრიქონში, საიდანაც იწყება ძიება;
- ჩანაწერების რაოდენობა... განსაზღვრავს საწყის სტრიქონში სასურველი ქვესტრიქონის გაჩენის რაოდენობას.
მაგალითი 9. სტრიქონში "გამარჯობა სამყარო!" განსაზღვრეთ სიმბოლოს ბოლო გაჩენის პოზიცია „და“.
PositionNumber = StrNayti ("Hello World!", "And", DirectionSearch.End); ანგარიში (პოზიციის ნომერი);
ამ კოდის შესრულების შედეგი იქნება სიმბოლო "და" ბოლო გაჩენის ნომრის ჩვენება: 9.
ვრეგ
ბრეგ (<Строка>) ... გარდაქმნის ყველა სიმბოლოს მითითებულ სტრიქონში 1s 8-ში ზევით.
მაგალითი 10. გადააკეთეთ სტრიქონი "hello world!" დიდი ასოებით.
StringBreg = Breg ("გამარჯობა სამყარო!"); ანგარიში (StringVreg);
ამ კოდის შესრულების შედეგი იქნება ხაზის ჩვენება "HELLO WORLD!"
Nreg
HPreg (<Строка>) ... გარდაქმნის მითითებული სტრიქონის ყველა სიმბოლოს 1s 8-ში პატარებად.
მაგალითი 11. გადააკეთეთ სტრიქონი "HELLO WORLD!" მცირე ასოებით.
StringNreg = НReg ("HELLO WORLD!"); ანგარიში (StringVreg);
ამ კოდის შესრულების შედეგი იქნება ხაზის "გამარჯობა სამყარო!"
ტრეგ
ტრეგი (<Строка>) ... აკონვერტებს სტრიქონს შემდეგნაირად: თითოეული სიტყვის პირველი სიმბოლო გარდაიქმნება დიდზე, სიტყვის დარჩენილი სიმბოლოები გარდაიქმნება პატარაზე.
მაგალითი 12. დაწერეთ სიტყვების პირველი ასოები სტრიქონში "hello world!"
StringTreg = Treg ("გამარჯობა სამყარო!"); ანგარიში (StringTreg);
ამ კოდის შესრულების შედეგი იქნება გამომავალი ხაზის ეკრანზე "Hello World!"
სიმბოლო
სიმბოლო (<КодСимвола>) ... იღებს სიმბოლოს მისი Unicod კოდით.
მაგალითი 13. დავუმატოთ მარცხნივ და მარჯვნივ სტრიქონში "Hello World!" სიმბოლო ★
StringWithStars = სიმბოლო ("9733") + "Hello World!" + Symbol ("9733"); ანგარიში (StringWithStars);
ამ კოდის შესრულების შედეგი იქნება ხაზის ჩვენება "★ Hello World! ★"
სიმბოლო კოდი
სიმბოლური კოდი (<Строка>, <НомерСимвола>) ... იღებს უნიკოდის სიმბოლოს კოდს პირველ პარამეტრში მითითებული სტრიქონიდან, რომელიც მდებარეობს მეორე პარამეტრში მითითებულ პოზიციაზე.
მაგალითი 14. გაიგეთ ბოლო სიმბოლოს კოდი "Hello World!"
სტრიქონი = "გამარჯობა სამყარო!"; CharacterCode = CharacterCode (String, StrLength (String)); ანგარიში (SymbolCode);
ამ კოდის შესრულების შედეგი იქნება სიმბოლოს კოდის ჩვენება "!" - 33.
ცარიელი ხაზი
ცარიელი ხაზი (<Строка>) ... ამოწმებს, შეიცავს თუ არა სტრიქონი მხოლოდ უმნიშვნელო სიმბოლოებს, ანუ ცარიელია თუ არა.
მაგალითი 15. შეამოწმეთ არის თუ არა სამი სივრცისგან შემდგარი სტრიქონი ცარიელი.
Empty = EmptyString (""); ანგარიში (ცარიელი);
ამ კოდის შესრულების შედეგი იქნება სიტყვის "დიახ" ჩვენება (ლოგიკური მნიშვნელობის სტრიქონი მართალია).
გვერდის ჩანაცვლება
ჩანაცვლება (<Строка>, <ПодстрокаПоиска>, <ПодстрокаЗамены>) ... პოულობს საძიებო ქვესტრიქონის ყველა შემთხვევას თავდაპირველ სტრიქონში და ანაცვლებს მას შემცვლელი ქვესტრიქონით.
მაგალითი 16. სტრიქონში "Hello World!" სიტყვა „მშვიდობა“ შეცვალოს სიტყვით „მეგობრები“.
String = StrReplace ("Hello World!", "World", "Friends"); ანგარიში (სტრიქონი);
ამ კოდის შესრულების შედეგი იქნება ხაზის ჩვენება "გამარჯობა მეგობრებო!"
StrNumberStrings
ხაზების რაოდენობა (<Строка>) ... ითვლის სტრიქონების რაოდენობას მრავალ სტრიქონიან სტრიქონში. Წასვლა ახალი ხაზი 1s 8-ში გამოიყენება სიმბოლო PS(ხაზის შესანახი სიმბოლო).
მაგალითი 17. განსაზღვრეთ ტექსტის სტრიქონების რაოდენობა:
"Პირველი ხაზი
მეორე ხაზი
მესამე ხაზი"
Number = StrNumberStrings ("პირველი ხაზი" + Symbols.PS + "მეორე ხაზი" + Symbols.PS + "მესამე ხაზი"); ანგარიში (ნომერი);
ამ კოდის შესრულების შედეგი იქნება ტექსტში ხაზების რაოდენობის ჩვენება: 3
StrGetString
StrGetString (<Строка>, <НомерСтроки>) ... იღებს სტრიქონს მრავალსტრიქონიან სტრიქონში მისი რიცხვის მიხედვით. ხაზის ნუმერაცია იწყება 1-დან.
მაგალითი 18. მიიღეთ ბოლო სტრიქონი ტექსტში:
"Პირველი ხაზი
მეორე ხაზი
მესამე ხაზი"
ტექსტი = "პირველი ხაზი" + Symbols.PS + "მეორე ხაზი" + Symbols.PS + "მესამე ხაზი"; LastRow = StrGetString (ტექსტი, StrNumberLines (ტექსტი)); ანგარიში (LastLine);
ამ კოდის შესრულების შედეგი იქნება ხაზის "მესამე ხაზის" ჩვენება.
Str.შემთხვევათა რაოდენობა
Str.შემთხვევათა რაოდენობა (<Строка>, <ПодстрокаПоиска>) ... აბრუნებს სტრიქონში მითითებული ქვესტრინგის შემთხვევების რაოდენობას. ფუნქცია რეგისტრირებულია.
მაგალითი 19. დაადგინეთ რამდენჯერ გამოჩნდება ასო „c“ სტრიქონში „ხაზები 1s 8.3-ში და 8.2-ში“, განურჩევლად მისი რეგისტრისა.
Line = "ხაზები 1s 8.3 და 8.2"; შემთხვევების რაოდენობა = StrNumber of Occurrences (Vreg (სტრიქონი), "S"); ანგარიში (შემთხვევების რაოდენობა);
ამ კოდის შესრულების შედეგი იქნება შემთხვევების რაოდენობის ჩვენება: 2.
გვერდი იწყება
გვერდი იწყება (<Строка>, <СтрокаПоиска>) ... ამოწმებს, იწყება თუ არა პირველ პარამეტრში გადაცემული სტრიქონი მეორე პარამეტრის სტრიქონით.
მაგალითი 20. დაადგინეთ, იწყება თუ არა შერჩეული კონტრაგენტის INN რიცხვი 1-ით. შეუშვით ცვლადი კონტრაპარტიული კონტრაქტორები.
TIN = Counterparty.INN; Starts withUnits = StrStarts with (INN, "1"); If BeginsUnits then // შენი კოდი EndIf;
გვერდი სრულდება
გვერდი მთავრდება (<Строка>, <СтрокаПоиска>) ... ამოწმებს, მთავრდება თუ არა პირველ პარამეტრში გადაცემული სტრიქონი მეორე პარამეტრის სტრიქონით.
მაგალითი 21. დაადგინეთ, მთავრდება თუ არა არჩეული კონტრაგენტის TIN ციფრი 2-ით. შეიტანეთ ცვლადი კონტრაპარტიულიშენახულია დირექტორიას ელემენტის ბმული კონტრაქტორები.
TIN = Counterparty.INN; Ends With Two = Str მთავრდება With (INN, "2"); If Ends WithDouble then // შენი კოდი EndIf;
PageSplit
StrSplit (<Строка>, <Разделитель>, <ВключатьПустые>) ... ყოფს სტრიქონს ნაწილებად განსაზღვრული გამიჯვნის სიმბოლოების გამოყენებით და მიღებულ სტრიქონებს წერს მასივში. პირველი პარამეტრი ინახავს თავდაპირველ სტრიქონს, მეორე შეიცავს სტრიქონს, რომელიც შეიცავს გამყოფს, მესამე აზუსტებს, ჩაწეროს თუ არა ცარიელი სტრიქონები მასივში (ნაგულისხმევად მართალია).
მაგალითი 22. დავუშვათ, გვაქვს სტრიქონი, რომელიც შეიცავს რიცხვებს, რომლებიც გამოყოფილია ";"-ით, მიიღეთ სტრიქონიდან რიცხვების მასივი.
სტრიქონი = "1; 2; 3"; Array = StrSplit (სტრიქონი, ";"); For Rd = 0 By Array.Quantity () - 1 Cycle Attempt Array [Rd] = Number (SqrLP (Array [Rd])); გამონაკლისი მასივი [Сч] = 0; მცდელობების დასასრული მარყუჟის დასასრული;
შესრულების შედეგად მიიღება მასივი 1-დან 3-მდე რიცხვებით.
StrConnect
StrConnect (<Строки>, <Разделитель>) ... გარდაქმნის სტრიქონების მასივს პირველი პარამეტრიდან სტრიქონში, რომელიც შეიცავს მასივის ყველა ელემენტს, გამოყოფილი მეორე პარამეტრში მითითებული დელიმიტერით.
მაგალითი 23. წინა მაგალითის რიცხვების მასივის გამოყენებით მიიღეთ ორიგინალური სტრიქონი.
Rd = 0-ისთვის მასივის მიხედვით. რაოდენობა () - 1 ციკლის მასივი [Rd] = სტრიქონი (მასივი [Rd]); ციკლის დასასრული; String = StrConnect (Array, ";");
TO ძირითადი შესაძლებლობებიპროგრამირების ენას ჩვეულებრივ მოიხსენიებენ, როგორც ციფრებთან და სტრიქონებთან მუშაობას. ჩვეულებრივ, ეს ფუნქციები მყარი კოდირებულია კომპილერის კოდში (ან დანერგილია პროგრამირების ენის "ბაზა" კლასები).
1C-ში, სტრინგებთან მუშაობის შესაძლებლობა დაპროგრამებულია თავად პლატფორმაში. დღეს განვიხილავთ 1C სტრიქონებთან მუშაობის მახასიათებლებს პროგრამებში ჩაშენებულ 1C ენაზე.
1C ხაზის მნიშვნელობა
1. დავიწყოთ უმარტივესით. ცვლადის შექმნა და მისთვის მუდმივი სტრიქონის მნიშვნელობის მინიჭება ასე გამოიყურება 1C-ში:
ცვლადი = "გამარჯობა სამყარო!";
თუ თქვენ გჭირდებათ ციტატის სიმბოლოს მითითება მუდმივი სტრიქონის მნიშვნელობით 1C, მაშინ უნდა გააორმაგოთ იგი ""
ცვლადი = "გამარჯობა", "სამყარო" "!";
2. ხაზის გაწყვეტა 1C შეიძლება განისაზღვროს ერთდროულად ორი გზით. პირველი იყენებს სიმბოლოს |
ცვლადი = "გამარჯობა,
| მშვიდობა! ";
მეორე იყენებს სიმბოლოების სისტემის ჩამოთვლას. ის საშუალებას გაძლევთ დაამატოთ როგორც 1C ხაზის წყვეტები, ასევე სხვა დაუბეჭდავი სიმბოლოები, როგორიცაა TAB.
ცვლადი = "Hello" + Symbols.PS + "world!";
3. 1C-ში კონფიგურაციები შეიძლება განვითარდეს არა მხოლოდ ერთი ენისთვის (რუსული, ინგლისური ან სხვა) - არამედ ერთდროულად რამდენიმე ენისთვის. ამ შემთხვევაში, ამჟამად გამოყენებული ენა არჩეულია 1C ფანჯრის ბოლოში.
ენების სია არის კონფიგურაციის ფანჯარაში General / Languages ფილიალში. თითოეულ ენას აქვს მოკლე იდენტიფიკატორი, როგორიცაა ruან ინჟ.
ნათელია, რომ ასეთი კონფიგურაციის დაპროგრამებისას, 1C ხაზები ასევე შეიძლება იყოს მრავალენოვანი. ამისათვის შესაძლებელია ასეთი 1C ხაზის შექმნა მეშვეობით მითითებით; პარამეტრები ენის იდენტიფიკატორის მიხედვით:
Variable = "ru =" "გამარჯობა, სამყარო!" "; En =" "გამარჯობა, სამყარო!" "";
თუ იყენებთ ამ გზით ჩამოყალიბებულ 1C ხაზს ჩვეულებისამებრ, მაშინ ის იქნება რაც მასში წერია. იმისათვის, რომ სისტემამ გაიყოს ის ორ ვარიანტად და გამოიყენოს სასურველი, თქვენ უნდა გამოიყენოთ HStr () ფუნქცია:
// სწორია ორენოვანი კონფიგურაციებისთვის
ანგარიში (НStr (ცვლადი));
საყრდენები ხაზის ტიპის 1C
რეკვიზიტი არის 1C მითითება / დოკუმენტის ველი. ის განსხვავდება 1C პროგრამის ცვლადისაგან იმით, რომ მისი ტიპი (რიცხვი, 1C სტრიქონი და ა.შ.) ზუსტად არის მითითებული ატრიბუტისთვის. თუ თქვენ გჭირდებათ იმის გაგება, თუ რა არის რეკვიზიტები - უყურეთ გაკვეთილს.
თუ მიუთითებთ ატრიბუტის ტიპს - ხაზი 1C, მაშინ დამატებით უნდა მიუთითოთ პარამეტრები.
1C სტრიქონები არის შეუზღუდავი სიგრძის (მიითითებული, როგორც სიგრძე = 0) და შეზღუდული სიგრძე, რაც მიუთითებს სიმბოლოების ზუსტ რაოდენობაზე. შეუზღუდავი სიგრძის 1C ხაზები ინახება ცალკე SQL ცხრილიამიტომ მათი გამოყენება ნაკლებად პროდუქტიულია, ვიდრე შეზღუდული.
სწორედ ამიტომ, შეუზღუდავი სიგრძის 1C სტრიქონების გამოყენებას აქვს თავისი შეზღუდვები - მათი გამოყენება ყველგან შეუძლებელია. მაგალითად, ის არ შეიძლება გამოყენებულ იქნას როგორც დოკუმენტის ნომერი, დირექტორია კოდი, განზომილება.
1C სტრიქონებთან მუშაობა
1C პლატფორმის რამდენიმე ჩაშენებული ფუნქციაა სტრინგებთან მუშაობისთვის.
- SocrLP ("წარმოუდგენელი, მაგრამ მართალია!")
შლის ხაზი 1C დამატებითი ფართები... ის ასევე შეიძლება გამოყენებულ იქნას ნებისმიერი ტიპის 1C სტრიქონებზე გადასაყვანად (მაგალითად, რიცხვებში). - ცვლადი = "Vasya" + SokrLP ("პლუს") + "Olya"; // იქნება "ვასია პლუს ოლია"
1C სტრიქონის რამდენიმე მნიშვნელობის შეჯამების მაგალითი. შედეგი იქნება ერთი ხაზი 1C. - ცვლადი = ლომი ("მუსიკა", 2); // იქნება "მუ"
ცვლადი = ოთხშაბათი ("მუსიკა", 2, 2); // იქნება "შლ"
ცვლადი = მარჯვენა ("მუსიკა", 2); // იქნება "კა"
1C სტრიქონიდან ქვესტრიქონის მიღების სხვადასხვა ვარიანტები. - ცვლადი = ძებნა ("მუსიკა", "შლ"); // იქნება 3
მოძებნეთ ქვესტრიქონი 1C სტრიქონში, დაწყებული სიმბოლო 1-დან. - ცვლადი = StrLength ("მუსიკა"); // იქნება 6
აბრუნებს სიმბოლოების რაოდენობას 1C სტრიქონში. - მოხსენება ("გამარჯობა") // შეტყობინების ფანჯარაში 1C ფანჯრის ბოლოში
გაფრთხილება ("Hello") // ამომხტარი დიალოგი
მიუთითეთ ("გამარჯობა") // სტატუსის ჩვენების ხაზში ქვედა მარცხენა მხარეს
.
ობიექტების ჩამოსხმა ხაზში 1C
მოგეხსენებათ, სტრუქტურირებული ინფორმაციის გაცვლის ყველაზე პოპულარული ფორმატი ამჟამად არის XML. თუნდაც უახლესი ვერსიაᲥᲐᲚᲑᲐᲢᲝᲜᲘ Office Wordდა Excel ინახავს ფაილებს ამ ფორმატში (docx და xlsx, შესაბამისად, შეცვალეთ გაფართოება zip-ზე, გახსენით არქივში).
მონაცემთა გაცვლის 1C პლატფორმა გთავაზობთ რამდენიმე ვარიანტს, რომელთაგან მთავარი ასევე არის XML.
1. უმარტივესი მეთოდია აბრევიატურის () ან სტრიქონის () ფუნქციის გამოყენება. მოთხოვნის სხეულში შეგიძლიათ გამოიყენოთ რეპრესენტაცია () ფუნქცია. მათი მოქმედების შედეგი იგივეა - ისინი ქმნიან მომხმარებლისთვის ნებისმიერი 1C ობიექტის სიმებიანი წარმოდგენას.
საცნობარო წიგნისთვის, ეს იქნება მისი სახელი ნაგულისხმევად. დოკუმენტისთვის - დოკუმენტის დასახელება, ნომერი და თარიღი.
2. ნებისმიერი 1C ობიექტი (შეზღუდვებით) შეიძლება გადაიზარდოს XML-ში და პირიქით. კონვერტაციის პროცესს სერიალიზაცია ეწოდება.
ViewStringXml = XMLString (მნიშვნელობა); // მიიღეთ XML 1C მნიშვნელობიდან
Value1C = XMLValue (ტიპი ("ReferenceLink.Nomenclature"), ViewStringXml); // მიიღეთ 1C მნიშვნელობა XML სტრიქონიდან, თქვენ უნდა მიუთითოთ 1C ტიპი, რომელიც უნდა მიიღოთ
3. არსებობს 1C პლატფორმის გზა ნებისმიერი 1C ობიექტის სტრინგად გადაქცევისთვის. ის გადავიდა 1C 7.7 ვერსიიდან. ეს ფორმატი არ ესმით სხვა პროგრამებს, მაგრამ ეს ესმით სხვა 1C-ს, რაც აადვილებს მის გამოყენებას 1C ბაზებს შორის გაცვლისთვის.
სტრიქონი = ValueVSStringInter (Value1C); // მიიღეთ ხაზი 1C 1C მნიშვნელობიდან
ValueVFile ("C: \ MyFile.txt", Value1C); // კიდევ ერთი ვარიანტი, ჩვენ ვიღებთ ფაილს შენახული სტრიქონით 1C მნიშვნელობიდან
Value1C = ValueFromStringInternal (String); // უკან 1C ხაზიდან
Value1C = ValueOfFile ("C: \ MyFile.txt"); // ფაილიდან დაბრუნება
1C ხაზების რედაქტირება ფორმაზე
1C პროგრამაში 1C სტრიქონებთან მუშაობის გარდა, რა თქმა უნდა, მსურს მომხმარებელმა შეძლოს მათი რედაქტირება. ამისათვის რამდენიმე შესაძლებლობა არსებობს:
1. უმარტივესი გზაა მოთხოვნაზე 1C ხაზის შეყვანის მოთხოვნა. ეს მეთოდი გამოიყენება 1C პროგრამირების სწავლებისას, რეალურ ცხოვრებაში ის გაცილებით ნაკლებად გამოიყენება (მაგრამ გამოიყენება!).
ცვლადი = "";
String = EnterValue (ცვლადი, "Enter your full name");
2. 1C ობიექტის ატრიბუტის (საცნობარო წიგნი / დოკუმენტი) ან ფორმის ატრიბუტის საჩვენებლად (იხ.), ყველაზე ხშირად გამოიყენება შეყვანის ველი. ეს არის ყველაზე გავრცელებული ინსტრუმენტი 1C-ში მომხმარებლის მუშაობისთვის რედაქტირების ველებთან.
3. შეყვანის ველის შესაძლებლობები შეიძლება გაფართოვდეს (იხ. შეყვანის ველის თვისებები, დააწკაპუნეთ მარჯვენა ღილაკითმასზე უფრო დეტალურად):
- მონიშნეთ მრავალხაზოვანი რედაქტირების რეჟიმი
- მოსანიშნი ველი გაფართოებული რედაქტირება (ხელმისაწვდომია, თუ წინა ჩამრთველი არის მონიშნული)
- მონიშვნის ველი პაროლის რეჟიმი (იხ.).
4. თუ შეყვანის ველის ყველა შესაძლებლობა არ არის საკმარისი, არის ჩაშენებული რედაქტორი. ფორმაში დასამატებლად, თქვენ უნდა დაამატოთ ველი Form / Insert Control მენიუში. ტექსტური დოკუმენტი... მის თვისებებში შეგიძლიათ მიუთითოთ მისი მუშაობის რეჟიმი - Extension თვისება.
ტექსტური დოკუმენტის ველი არ შეიძლება პირდაპირ დაუკავშირდეს მონაცემებს. აუცილებელია ფუნქციის ჩაწერა ფორმის OnOpening () მოვლენის დამმუშავებელში (იხ.):
FormElements.ElementNameTextDocumentField.SetText (ValueString); // აქ ValueString არის ტექსტი, რომელიც მიღებულია, მაგალითად, რეკვიზიტებიდან
და შენახვის დამმუშავებელში - მაგალითად, Save ღილაკში - დაამატეთ შენახვა:
ValueString = FormElements.ElementNameTextDocumentField.GetText (); // ValueThe string აქ არის რეკვიზიტები, სადაც ჩვენ ვინახავთ მნიშვნელობას
5. 1C ვერსიაში 8.2.11, in მართული ფორმებიგამოჩნდა ახალი შესაძლებლობახაზის წარმოდგენა 1C - ფორმატირებული დოკუმენტის ველი.
ტექსტური დოკუმენტის ველის მსგავსად, გახსნისას აუცილებელია დაყენება და პროგრამის გამოყენებით ტექსტის შენახვისას დაწერა.
- 1C ობიექტში, რომლის ფორმასაც ვაკეთებთ (საცნობარო წიგნი, დოკუმენტი, დამუშავება და ა.შ.) - დაამატეთ ატრიბუტი Storage ტიპის
- ReadOnServer () ფუნქციაში დააყენეთ ტექსტი რეკვიზიტებიდან
// აქ Props არის 1C ობიექტის დამატებული თვისება
// here FormattedDocument არის ველის სახელი ფორმაში, რომელიც უნდა შესწორდეს
&სერვერზე
FormattedDocument = CurrentObject.Props.Get ();
პროცედურის დასასრული - ფუნქციაში BeforeWriteOnServer () ან ღილაკით ჩაწერეთ ტექსტი ველიდან
&სერვერზე
ReadingOnServer-ის (CurrentObject) პროცედურა
CurrentObject.Props = NewValueStore (FormattedDocument);
პროცედურის დასასრული
1C შეკითხვებში სტრინგებთან მუშაობის რამდენიმე მექანიზმი არსებობს. პირველ რიგში, ხაზები შეიძლება დაემატოს. მეორეც, შეგიძლიათ აიღოთ ქვესტრიქონი სტრიქონიდან. მესამე, სტრიქონების შედარება შესაძლებელია, მათ შორის ნიმუშის მიხედვით. ეს არის ალბათ ყველაფერი, რაც შეგიძლიათ გააკეთოთ სიმებით.
სიმების შეერთება
მოთხოვნაში სტრიქონების დასამატებლად გამოიყენება "+" ოპერაცია. შესაძლებელია მხოლოდ შეზღუდული სიგრძის ხაზების დაკეცვა.
აირჩიეთ "სახელი:" + კონტრაგენტები. დასახელება, როგორც სვეტი1, დირექტორიადან. კონტრაგენტები, როგორც კონტრაქტორები WHERE კონტრაგენტები. ბმული = & ბმული
ქვესტრიქონის ფუნქცია
სუბსტრატი (<Строка>, <НачальнаяПозиция>, <Длина>)
ფუნქციის Environment () ანალოგი ობიექტის მოდელიდან. Substring () ფუნქცია შეიძლება გამოყენებულ იქნას სტრიქონის ტიპის მონაცემებზე და საშუალებას გაძლევთ აირჩიოთ ფრაგმენტი <Строки> სიმბოლოს ნომრით დაწყებული <НачальнаяПозиция> (სტრიქონში სიმბოლოები დანომრილია 1-დან) და სიგრძე <Длина> პერსონაჟები. ფუნქციის შეფასების შედეგს აქვს ცვლადი სიგრძის სტრიქონის ტიპი და სიგრძე ჩაითვლება შეუზღუდავად, თუ <Строка> აქვს შეუზღუდავი სიგრძე და პარამეტრი <Длина> არ არის მუდმივი ან აღემატება 1024-ს.
თუ სტრიქონის სიგრძე ნაკლებია მეორე პარამეტრში მითითებულზე, მაშინ ფუნქცია დააბრუნებს ცარიელ სტრიქონს.
ყურადღება! SUBSTRING () ფუნქციის გამოყენება შეუზღუდავი სიგრძის სტრიქონების შეზღუდული სიგრძის სტრიქონებში გადასაყვანად არ არის რეკომენდებული. ამის ნაცვლად, უმჯობესია გამოვიყენოთ ჩამოსხმის ოპერაცია, როგორიცაა EXPRESS ().
ფუნქცია Like
თუ ჩვენ უნდა დავრწმუნდეთ, რომ სიმებიანი ატრიბუტი აკმაყოფილებს გარკვეულ კრიტერიუმებს, ჩვენ ვადარებთ მას:
აირჩიეთ კონტრაგენტები. დასახელება AS სვეტი1 დირექტორიადან. კონტრაგენტები, როგორც კონტრაგენტები WHERE კონტრაქტორები. სახელი = "გაზპრომი"
მაგრამ რა მოხდება, თუ უფრო რთული შედარება გინდა? არა მხოლოდ თანასწორობა ან უთანასწორობა, არამედ გარკვეული ნიმუში? სწორედ ამისთვის არის შექმნილი ფუნქცია LIKE.
LIKE - ოპერატორი ნიმუშის მსგავსი სტრიქონის შესამოწმებლად. LIKE-ის ანალოგი SQL-ში.
LIKE ოპერატორი საშუალებას გაძლევთ შეადაროთ მის მარცხნივ მითითებული გამოხატვის მნიშვნელობა მარჯვნივ მითითებულ შაბლონის სტრიქონთან. გამოხატვის მნიშვნელობა უნდა იყოს string ტიპის. თუ გამოხატვის მნიშვნელობა ემთხვევა შაბლონს, ოპერატორი გამოიწვევს TRUE-ს, წინააღმდეგ შემთხვევაში - FALSE.
შაბლონის სტრიქონში შემდეგი სიმბოლოები არის სერვისის სიმბოლოები და აქვთ სტრიქონის სიმბოლოს გარდა სხვა მნიშვნელობა:
- % (პროცენტი): თანმიმდევრობა, რომელიც შეიცავს ნებისმიერი რაოდენობის თვითნებურ სიმბოლოებს;
- _ (ხაზგასმული): ერთი თვითნებური სიმბოლო;
- [...] (ერთი ან მეტი სიმბოლო კვადრატულ ფრჩხილებში): ნებისმიერი სიმბოლო, რომელიც ჩამოთვლილია კვადრატულ ფრჩხილებში. ჩამოთვლა შეიძლება შეიცავდეს დიაპაზონებს, მაგალითად, a-z, რაც ნიშნავს თვითნებურ სიმბოლოს, რომელიც შედის დიაპაზონში, დიაპაზონის ბოლოების ჩათვლით;
- [^…] (კვადრატულ ფრჩხილებში უარყოფის ნიშანი, რომელსაც მოჰყვება ერთი ან მეტი სიმბოლო): ნებისმიერი ცალკეული სიმბოლო, გარდა იმ სიმბოლოებისა, რომლებიც ჩამოთვლილია უარყოფის ნიშნის შემდეგ.
ნებისმიერი სხვა სიმბოლო ნიშნავს თავის თავს და არ ატარებს რაიმე დამატებით მნიშვნელობას. თუ საჭიროა ჩამოთვლილი სიმბოლოებიდან ერთ-ერთი საკუთარი თავის დაწერა, მაშინ მას წინ უნდა უძღოდეს<Спецсимвол>... მე თვითონ<Спецсимвол>(ნებისმიერი შესატყვისი სიმბოლო) განისაზღვრება იმავე განცხადებაში შემდეგ საკვანძო სიტყვასპეციალური სიმბოლო.
"სტრიქონი" ტიპი გვხვდება პროგრამირების ყველა ენაში. ის პრიმიტიულია და 1C-ში არის მასთან მუშაობის მრავალი ფუნქცია. ამ სტატიაში ჩვენ უფრო დეტალურად განვიხილავთ სხვადასხვა გზები 1C 8.3 და 8.2 სტრიქონების ტიპებთან მუშაობა მაგალითებით.
ხაზი
ნებისმიერი ტიპის ცვლადის სტრინგად გადასაყვანად, არსებობს ამავე სახელწოდების ფუნქცია "String ()". შეყვანის პარამეტრი იქნება თავად ცვლადი, რომლის სიმებიანი გამოსახულება უნდა იყოს მიღებული.
სტრიქონი (false) // აბრუნებს "არა"
სტრიქონი (12345) // აბრუნებს "12 345"
სტრიქონი (მიმდინარე თარიღი ()) // 07/21/2017 11:55:36 ″
შესაძლებელია არა მხოლოდ პრიმიტიული ტიპების სტრინგად გადაქცევა, არამედ სხვა, მაგალითად, საცნობარო წიგნების ელემენტები, დოკუმენტები.
SocrLP, SocrL, SocrP
ამ ფუნქციების შეყვანის პარამეტრები არის სტრიქონის ტიპის ცვლადი. ფუნქციები ხსნის უმნიშვნელო სიმბოლოებს (სივრცეები, ვაგონის დაბრუნება და სხვა): მარცხენა და მარჯვენა მხრიდან, მხოლოდ მარცხენა მხრიდან და მხოლოდ მარჯვნიდან, შესაბამისად.
AbbrLP ("სივრცეები ორივე მხარეს წაიშლება") // "სივრცეები ორივე მხარეს წაიშლება"
შემოკლებული ("სივრცეები ორივე მხარეს წაიშლება") // "მარცხნივ სივრცეები წაიშლება"
აბრევიატურა ("სივრცეები ორივე მხარეს წაიშლება") // "მარჯვნივ სივრცეები წაიშლება"
ლომი, მარჯვენა, ოთხშაბათი
ეს ფუნქციები საშუალებას გაძლევთ ამოჭრათ სტრიქონის ნაწილი. "Lion ()" ფუნქცია დააბრუნებს სტრიქონის ნაწილს მითითებული სიგრძის მარცხენა მხრიდან. "მარჯვნივ ()" ფუნქცია იგივეა, მაგრამ ჩამოჭრა კეთდება მარჯვნივ. "Avg ()" ფუნქცია საშუალებას გაძლევთ მიუთითოთ სიმბოლოების რაოდენობა, საიდანაც შეირჩევა სტრიქონი და მისი სიგრძე.
Lion ("String ცვლადი", 4) // აბრუნებს "Stro"
მარჯვენა ("String ცვლადი", 7) // აბრუნებს "ცვლადი"
ოთხ ("String variable", 2, 5) // აბრუნებს "troco"
ქუჩის სიგრძე
ფუნქცია განსაზღვრავს სიმბოლოების რაოდენობას, რომლებიც შეიცავს სიმებიანი ცვლადი.
StrLength ("Word") // შესრულების შედეგი იქნება ნომერი 5
იპოვე
ფუნქცია შესაძლებელს ხდის სტრიქონის ნაწილის ძიებას ნებისმიერ სიმებიანი ცვლადში. დაბრუნებული მნიშვნელობა იქნება რიცხვი, რომელიც აჩვენებს ნაპოვნი სტრიქონის დასაწყისის პოზიციას. თუ შესატყვისი არ არის ნაპოვნი, ნული ბრუნდება.
გთხოვთ გაითვალისწინოთ, რომ ძიებები რეგისტრირებულია. თუ თავდაპირველი სტრიქონი შეიცავს საძიებო ქვესტრიქონის ერთზე მეტ შემთხვევას, ფუნქცია დააბრუნებს პირველი შემთხვევის დასაწყისს.
იპოვეთ ("ერთი, ორი, ერთი, ორი, სამი", "ორი") // ფუნქცია დააბრუნებს რიცხვს 6
ცარიელი ხაზი
ამ ფუნქციის გამოყენება საშუალებას გაძლევთ განსაზღვროთ ცარიელია თუ არა სტრიქონი. იგნორირებულია ისეთი უმნიშვნელო სიმბოლოები, როგორიცაა სივრცე, ვაგონის დაბრუნება და სხვა.
EmptyString ("Pupkin Vasily Ivanovich") // ფუნქცია დააბრუნებს მნიშვნელობას False
EmptyString ("") // ფუნქცია დააბრუნებს True
VReg, NReg, Treg
ეს ფუნქციები ძალიან სასარგებლოა სიმებიანი ცვლადების შედარებისა და კონვერტაციისთვის. Breg () დააბრუნებს თავდაპირველ სტრიქონს დიდი რეგისტრით, HPreg () მცირე რეგისტრით, და TPreg () დააფორმატებს მას ისე, რომ თითოეული ცალკეული სიტყვის პირველი სიმბოლო იქნება მთავრული და ყველა მომდევნო იქნება პატარა.
Vreg ("GENERAL DIRECTOR") // დაბრუნების მნიშვნელობა - "GENERAL DIRECTOR"
НReg ("GENERAL DIRECTOR") // დაბრუნების მნიშვნელობა - "გენერალური დირექტორი"
TREG ("GENERAL DIRECTOR") // დაბრუნების მნიშვნელობა - "გენერალური დირექტორი"
გვერდის ჩანაცვლება
ეს ფუნქცია ჩანაცვლების ანალოგია ტექსტის რედაქტორები... ის საშუალებას გაძლევთ შეცვალოთ ერთი სიმბოლო ან სიმბოლოების ნაკრები მეორით სიმებიანი ცვლადებში.
StrReplace ("წითელი, თეთრი, ყვითელი", ",", ";") // დააბრუნებს "წითელს; თეთრი; ყვითელი"
StrNumberStrings
ფუნქცია საშუალებას გაძლევთ განსაზღვროთ ტექსტურ ცვლადში გამოყოფილი ხაზების რაოდენობა, რომლებიც გამოყოფილია აბრუნებით.
ქვემოთ მოცემულ მაგალითში ციკლი გაივლის სამ წრეს, რადგან RowNumber of Rows ფუნქცია დააბრუნებს მნიშვნელობას 3:
StrNumberStrings-ის ind = 1-ისთვის ("String1" + Symbols.PS + "String2" + Symbols.PS + "String3") ციკლი
<тело цикла>
ციკლის დასასრული;
StrGetString
ეს ფუნქცია მუშაობს მრავალ სტრიქონიანი ტექსტით ისევე, როგორც წინა. ის საშუალებას გაძლევთ მიიღოთ კონკრეტული სტრიქონი ტექსტის ცვლადიდან.
StrGetString ("String1" + Symbols.PS + "String2" + Symbols.PS + "String3", 2) // დააბრუნებს "String2"
Str.შემთხვევათა რაოდენობა
ფუნქცია ითვლის სიმბოლოს ან ქვესტრიქონის გაჩენის რაოდენობას საძიებო სტრიქონში.
დანართების მწკრივი ("a; b; c; d;", ";") // ფუნქცია დააბრუნებს ნომერ 4-ს
სიმბოლო და სიმბოლო კოდი
ეს ფუნქციები საშუალებას გაძლევთ მიიღოთ სიმბოლო მისი Unicode კოდით, ასევე განსაზღვროთ ეს კოდი თავად სიმბოლოთი.
SymbolCode ("A") // ფუნქცია დააბრუნებს ნომერს 1 040
SymbolCode (1040) // ფუნქცია დააბრუნებს "A"
ხშირი დავალებები სტრინგებთან მუშაობისას
შემაერთებელი სიმები
მრავალი სტრიქონის შესაერთებლად (შეერთების შესასრულებლად) საკმარისია დამატებით ოპერატორის გამოყენება.
"ხაზი 1 ″ +" ხაზი 2 ″ // ორი ხაზის დამატების შედეგი იქნება "სტრიქონი 1 ხაზი 2"
ტიპის კონვერტაცია
იმისათვის, რომ ტიპი გადაიყვანოთ სტრიქონად, მაგალითად, ლექსიკონის პუნქტზე მითითება, რიცხვი და ა.შ., საკმარისია გამოიყენოთ "სტრიქონი ()" ფუნქცია. ფუნქციები, როგორიცაა "Abbreviation ()" ასევე გარდაქმნის ცვლადებს სტრიქონად, მაგრამ მაშინვე უმნიშვნელო სიმბოლოების შეკვეცით.
სტრიქონი (1000) // დააბრუნებს "1000"
გთხოვთ გაითვალისწინოთ, რომ რიცხვის სტრიქონად გადაქცევისას პროგრამა ავტომატურად ამატებდა სივრცეს, რომელიც გამოყოფს ათასს. ამის თავიდან ასაცილებლად, შეგიძლიათ გამოიყენოთ შემდეგი კონსტრუქციები:
StrReplace (String (1000), Characters.NPP, "") // დააბრუნებს "1000"
სტრიქონი (ფორმატი (1000, "CHG =")) // დააბრუნებს "1000"
ციტატები სტრიქონში
ხშირად მოგიწევთ გაუმკლავდეთ ციტატების მითითების აუცილებლობას სტრიქონების ცვლადში. ეს შეიძლება იყოს მოთხოვნის ტექსტი დაწერილი კონფიგურატორში, ან უბრალოდ ცვლადი. ამ პრობლემის გადასაჭრელად, თქვენ უბრალოდ უნდა დააყენოთ ორი ციტატა.
სათაური = სტრიქონი ("Horns and Hooves LLC" - ეს ჩვენ ვართ! ") // აბრუნებს" Horns and Hooves LLC - ეს ჩვენ ვართ!"
მრავალი ხაზი, ხაზის შესვენება
მრავალ სტრიქონიანი ტექსტის შესაქმნელად საკმარისია მას ხაზების შეწყვეტის სიმბოლოების (Symbols.PS) დამატება.
MultilineText = "პირველი ხაზი" + Symbols.PS + "მეორე ხაზი"
როგორ ამოიღოთ სივრცეები
იმისათვის, რომ წაშალოთ სივრცეები მარჯვნივ ან მარცხნივ, შეგიძლიათ გამოიყენოთ ფუნქცია "Abreviation ()" (ისევე როგორც "Abreviation ()" და "Abreviation ()"):
StringNoSpaces = AbbreviatedLP ("ბევრი ასო") // ფუნქცია დააბრუნებს მნიშვნელობას "ბევრ ასო"
თუ რიცხვის სტრინგად გადაქცევის შემდეგ, თქვენ უნდა წაშალოთ უწყვეტი სივრცეებიგამოიყენეთ შემდეგი კონსტრუქცია:
StringNoSpaces = StrReplace (String (99999), Characters.NPP, "") // დააბრუნებს "99999"
ასევე, პროგრამისტები ხშირად იყენებენ შემდეგ კონსტრუქციას, რომელიც საშუალებას გაძლევთ წაშალოთ ან შეცვალოთ ტექსტური ცვლადის ყველა სივრცე სხვა სიმბოლოთი:
StringNoSpaces = StrReplace ("მოგესალმებით", "", "") // აბრუნებს "გამარჯობა"
სიმების ერთმანეთთან შედარება
ტერმინები შეიძლება შევადაროთ ჩვეულებრივ ტოლობის ნიშანს. შედარება რეგისტრირებულია.
"Hello" = "hello" // დაბრუნდება False
"Hello" = "Hello" // დაბრუნდება True
"Hello" = "მშვიდობით" // დაბრუნდება False
