ՄԱՍ 1. ՄԵԹՈԴՆԵՐ (26).

1.1. Հիմնական մեթոդներ (10). Անկախ, կառուցված իրենց պարզ ալգորիթմների վրա:

Page_Add() (աջից ձախ լրացում նշված նիշերով):

Page_Inverse () (inversion - նիշերը աջից ձախ):

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() (որոնում (ներառյալ մեծատառերի անզգույշ և աջակողմյան), և փոխարինիր սահմանազատող ենթատողերը):

String_Piece() (մի կտոր սահմանազատողի նշված երևույթների միջև (ձախ կամ աջ)):

Page_ReplacePiece() (փոխարինում է աղբյուրի տողի «կտորը» նշված տողով):

Page_ВArray() (անջատիչի նշված երևույթների միջև (ներառյալ աջ կողմում և առանց պատյանների):

Page_TransferBySyllables() (բաժանվում է «Hardly» ենթատողերի՝ գծիկով):

Page_MoveByWords() (բաժանված ենթատողերի «Փափուկ»)

Page_Cut() («Կտրել» նշված երկարությունների ենթատողերի)

Str_Shorten() (փոխարինել «կրճատ» նիշերի ձախ խումբը «փոխարինող տողով»

Page_Abbreviation() (փոխարինել «կրճատված» նիշերի աջ խումբը «փոխարինող տողով»

Str_ShortenS() (փոխարինել «կրճատված» նիշերի խմբի մեջտեղում «փոխարինող տողով»

Page_Extend (ընդլայնում մինչև որոշակի երկարություն՝ ավելացնելով նշված նիշերի քանակը)

1.3. Մանրամասն մեթոդներ (3). Տող «հերձում»՝ մանրամասն տեղեկություններով աղյուսակի փոխանցմամբ։

Page_vTableIn() (աղյուսակի մեջ՝ ըստ nested delimiters համակարգի):

Page_vTableGr (սեղանին ըստ բազմաստիճան ֆիլտրի):

Page_inTableNumbers (աղյուսակում, որոնց միջև կան թվեր և հատվածներ):

ՄԱՍ 2. ԸՆԴՀԱՆՐԱՑՎԱԾ ՄԵԹՈԴՆԵՐ-ԱԼԳՈՐԻՄՆԵՐ (3).

Page_Occurrence() («Գտնել» և «Փոխարինել» մեթոդները):

Page_Fragments() (մեթոդներ «Piece», «ReplacePiece», «InArray», «inTableIn»):

Page_Abcr() (մեթոդներ «AbcrL», «AbcrP», «AbcrS», «Expand»:

Page_Split() (մեթոդներ «Տեղափոխել ըստ վանկերի», «Տեղափոխել ըստ բառերի», «Կտրել»):

ՄԱՍ 3. ՈՒՆԻՎԵՐՍԱԼ ՖՈՒՆԿՑԻԱ.

Սա մի տեսակ պայմանական ծրագրավորման ինտերֆեյս է, որը թույլ է տալիս

միանգամից մի քանի մեթոդ կիրառեք տողի վրա: Իրականացվել է որպես

գործառույթներ յոթ պարամետրով («Դեմո»-ն կառուցված է այս ֆունկցիայի վրա).

Էջ_(Մեթոդներ, ենթամեթոդներ, մուտքագրում, պարամ1, պարամ2, երկարություն_համար_դիրք, լրացուցիչ ելք)

Ընտրանքներ:

- «Մեթոդներ» - մի քանի «համակցված» և (կամ) մեկ «բացառիկ» մեթոդ

(մեկ նիշանի կոդերը կամ անունները, հնարավոր է «,»-ի միջոցով)

- «Ենթամեթոդներ» - մի քանի «համակցված» և (կամ) «բացառիկ» տարբերակներ

«բացառիկ» մեթոդ (մեկ նիշի ծածկագրեր կամ անուններ);

- «Մուտք» - տող, կամ զանգված կամ արժեքների աղյուսակ;

- «Param1» - որոնման տող, փոխարինումներ, բաժանիչներ, զտիչներ;

- «Param2» - փոխարինող տող կամ նիշ;

- «Length_Number_Position» - Թիվ, թվեր բաժանարարի կամ թվերով զանգվածի միջոցով;

- «Լրացուցիչ ելք» - համար կամ տող կամ զանգված կամ արժեքների աղյուսակ;

Ենթամեթոդների անունները և/կամ մեկ նիշանի կոդերը, ինչպես նաև թվերը

(Length_Number_Position) կարող է լինել ցանկացած դեպքում և առանձնացված

Հետևյալ սահմանազատիչներից որևէ մեկը. «:;»:

ՄԱՍ 4. ՈՐՈՇ ՕՐԻՆՆԵՐ.

There areNumbersInLine=(Str_FindNumber(InLine)<>Չսահմանված);

Տողում կան թվեր = (String_FindGr(Inline,"+0123456789")>0);

Կա լատիներեն = (Str_FindGr(InStr, Str_Interpret("lL"))>0);

Կան Specified Signs = (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:

Փոփոխական = «Բարև» + Symbols.PS + «խաղաղություն»;

3. 1C-ի կոնֆիգուրացիաները կարող են մշակվել ոչ միայն մեկ լեզվի համար (ռուսերեն, անգլերեն կամ այլ), այլ միաժամանակ մի քանի լեզուների համար: Այս դեպքում ներկայումս օգտագործվող լեզուն ընտրվում է 1C պատուհանի ներքևում:

Լեզուների ցանկը գտնվում է General/Languages ​​մասնաճյուղի կազմաձևման պատուհանում: Յուրաքանչյուր լեզու ունի կարճ նույնացուցիչ, ինչպիսին է ruկամ eng.

Հասկանալի է, որ նման կոնֆիգուրացիան ծրագրավորելիս 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:
• Փոփոխական = Լև («Երաժշտություն», 2); //կլինի «Մու»
  Փոփոխական = Միջին («Երաժշտություն», 2, 2); //կլինի «սպառնալիք»
  Փոփոխական = իրավունքներ («Երաժշտություն», 2); //կլինի «կա»
  1C տողից ենթատող ստանալու տարբեր տարբերակներ:
• Փոփոխական = Գտնել ("Երաժշտություն", "zy"); //կլինեն 3
  Փնտրեք ենթատող 1C տողում՝ սկսած 1-ին գրանշանից:
• Փոփոխական = StrLength («Երաժշտություն»); //կլինի 6
  Վերադարձնում է նիշերի քանակը 1C տողում:
• Զեկուցել («Բարև») // 1C պատուհանի ներքևում գտնվող հաղորդագրության պատուհանում
  Զգուշացում («Բարև») // բացվող երկխոսություն
  Կարգավիճակ («Բարև») // ներքևի ձախ մասում գտնվող կարգավիճակի ցուցադրման տողում
  .

Օբյեկտները բերելով 1C տողին

Ինչպես գիտեք, ներկայումս կառուցվածքային տեղեկատվության փոխանակման ամենատարածված ձևաչափը XML-ն է։ Նույնիսկ MS Office Word-ի և Excel-ի վերջին տարբերակը պահպանում է ֆայլերը այս ձևաչափով (համապատասխանաբար docx և xlsx, փոխեք ընդլայնումը zip-ի, բացեք արխիվատորում):

Տվյալների փոխանակման 1C հարթակը տրամադրում է մի քանի տարբերակներ, որոնցից հիմնականը նույնպես XML-ն է։

1. Ամենապարզ մեթոդը Abbreviation() կամ String() ֆունկցիան օգտագործելն է։ Հարցման մարմնում կարող եք օգտագործել ՆԵՐԿԱՅԱՑՆՈՒՄ() ֆունկցիան: Նրանց գործողության արդյունքը նույնն է. նրանք օգտվողի համար ստեղծում են ցանկացած 1C օբյեկտի լարային ներկայացում:

Լռելյայն գրացուցակի համար սա կլինի նրա անունը: Փաստաթղթի համար՝ փաստաթղթի անվանումը, համարը և ամսաթիվը:

2. Ցանկացած 1C օբյեկտ (սահմանափակումներով) կարող է փոխարկվել XML-ի և հակառակը։ Փոխակերպման գործընթացը կոչվում է սերիալացում:

StringViewXml = XMLString (Արժեք); //ստացեք 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 ծրագրավորում սովորեցնելիս, կյանքում այն ​​օգտագործվում է շատ ավելի քիչ հաճախ (բայց այն օգտագործվում է):

Փոփոխական = "";
Տող = EnterValue (Փոփոխական, «Մուտքագրեք լրիվ անունը»);

2. 1C օբյեկտի (տեղեկատու/փաստաթուղթ) կամ ձևի մանրամասները (տես) ցուցադրելու համար ամենից հաճախ օգտագործվում է մուտքագրման դաշտ: Սա 1C-ում օգտագործողի համար ամենատարածված գործիքն է խմբագրման դաշտերի հետ աշխատելու համար:

3. Մուտքագրման դաշտի հնարավորությունները կարող են ընդլայնվել (տես մուտքագրման դաշտի հատկությունները, աջ սեղմիր դրա վրա, ավելի մանրամասն).

• Նշավանդակ Բազմագիծ խմբագրման ռեժիմ
• Ընդլայնված խմբագրման վանդակ (հասանելի է, եթե նախորդ վանդակը նշված է)
• Checkbox Գաղտնաբառի ռեժիմ (տես):

4. Եթե մուտքագրման դաշտի բոլոր հնարավորությունները ձեզ չեն բավարարում, ապա կա ներկառուցված խմբագիր։ Այն ձևաթղթին ավելացնելու համար անհրաժեշտ է տեքստային փաստաթղթի դաշտ ավելացնել Form/Insert Control ցանկում: Նրա հատկություններում կարող եք նշել դրա գործառնական ռեժիմը՝ Extension հատկությունը:

Տեքստային փաստաթղթի դաշտը չի կարող ուղղակիորեն կապված լինել տվյալների հետ: Ձևի OnOpen() իրադարձությունների մշակիչում անհրաժեշտ է գրել ֆունկցիա (տես).

Form Elements.ElementNameTextDocumentField.SetText(StringValue); //այստեղ ValueString-ը տեքստն է, որը ստացվել է, օրինակ, հատկանիշից

Իսկ պահպանման կարգավորիչում, օրինակ, Save կոճակում, ավելացրեք պահպանում.

ValueString = FormElements.ElementNameTextDocumentField.GetText(); //ValueԱյս տողը այն հատկանիշն է, որտեղ մենք պահպանում ենք արժեքը

5. 1C 8.2.11 տարբերակում, կառավարվող ձևերով, հայտնվել է նոր տարբերակ 1C տողը ներկայացնելու համար՝ Formatted Document դաշտը։

Տեքստային փաստաթղթի դաշտի նման, դուք պետք է այն կարգավորեք այն բացելիս և գրեք այն, երբ ինքներդ այն պահում եք ծրագրի միջոցով:

• 1C օբյեկտում, որի ձևը մենք ստեղծում ենք (տեղեկատու, փաստաթուղթ, մշակում և այլն) - ավելացրեք ատրիբուտ Value Storage տիպով:
• OnReadOnServer() ֆունկցիայի մեջ մենք սահմանում ենք տեքստը հատկանիշից

  //այստեղ Attribute-ը 1C օբյեկտի ավելացված հատկանիշն է
  //այստեղ FormattedDocument-ը խմբագրման համար նախատեսված ձևի դաշտի անվանումն է
  &Սերվերի վրա
  
  FormattedDocument = CurrentObject.Attributes.Get();
  Ընթացակարգի ավարտը
  

• BeforeWritingOnServer() ֆունկցիայի մեջ կամ կոճակի միջոցով տեքստը կգրենք դաշտից

  &Սերվերի վրա
  Ընթացակարգը Սերվերի վրա կարդալիս (Ընթացիկ Օբյեկտ)
  CurrentObject.Props = NewValueStorage(FormattedDocument);
  Ընթացակարգի ավարտը

String տեսակը հանդիպում է ծրագրավորման բոլոր լեզուներում։ Այն պարզունակ է, և 1C-ում կան բազմաթիվ գործառույթներ դրա հետ աշխատելու համար։ Այս հոդվածում մենք մանրամասն կանդրադառնանք 1C 8.3 և 8.2 լարային տեսակների հետ աշխատելու տարբեր եղանակներին՝ օգտագործելով օրինակներ:

Գիծ

Ցանկացած տիպի փոփոխականը տողի փոխարկելու համար կա «String()» համանուն ֆունկցիա։ Մուտքային պարամետրը կլինի ինքնին փոփոխականը, որի լարային ներկայացումը պետք է ստացվի:

String (False) // վերադարձնում է «Ոչ»
String(12345) // վերադարձնում է «12,345»
String(CurrentDate()) //"07/21/2017 11:55:36"

Հնարավոր է տողի վերածել ոչ միայն պարզունակ տիպերը, այլ նաև մյուսները, օրինակ՝ տեղեկատուների և փաստաթղթերի տարրերը։

SokrLP, SokrL, SokrP

Այս ֆունկցիաների մուտքային պարամետրերը լարային տիպի փոփոխական են: Գործառույթները հեռացնում են աննշան նիշերը (բացատներ, փոխադրումներ և այլն)՝ համապատասխանաբար ձախ և աջ կողմերից, միայն ձախից և միայն աջից։

Հապավում (" Spaces will remove on two sides ") // "Spaces will remove on two sides"
Հապավում («Բացատները երկու կողմերում կհեռացվեն») // «Ձախ բացատները կհեռացվեն»
Հապավում (" Բացատները երկու կողմերում կհեռացվեն") // "Աջ կողմի բացատները կհեռացվեն"

Առյուծ, ճիշտ, միջին

Այս գործառույթները թույլ են տալիս կտրել տողի մի մասը: «Left()» ֆունկցիան կվերադարձնի տողի հատվածը նշված երկարության ձախ կողմից: «Right()» ֆունկցիան նման է, բայց կտրում է աջից: «Avg()» ֆունկցիան թույլ է տալիս նշել այն նիշի թիվը, որից կընտրվի տողը և դրա երկարությունը:

Lev("String variable", 4) // վերադարձնում է "Str"
Right ("String variable", 7) // վերադարձնում է "variable"
Միջին ("String variable", 2, 5) // վերադարձնում է "troko"

Ուժեղություն

Ֆունկցիան որոշում է տողային փոփոխականում պարունակվող նիշերի քանակը:

StrLength («Բառ») // կատարման արդյունքը կլինի 5 թիվը

Գտեք

Ֆունկցիան հնարավորություն է տալիս որոնել տողի մի մասը լարային փոփոխականում։ Վերադարձի արժեքը կլինի մի թիվ, որը ցույց է տալիս հայտնաբերված տողի սկզբի դիրքը։ Եթե ​​համընկնում չի գտնվել, զրո է վերադարձվում:

Խնդրում ենք նկատի ունենալ, որ որոնումը մեծատառերի զգայուն է: Եթե ​​սկզբնական տողում կա որոնման ենթատողի մեկից ավելի երևույթ, ֆունկցիան կվերադարձնի առաջին առաջացման սկիզբը:

Find(«մեկ, երկու, մեկ, երկու, երեք», «երկու») // ֆունկցիան կվերադարձնի 6 թիվը

Դատարկ գիծ

Այս ֆունկցիայի օգտագործումը թույլ է տալիս որոշել, թե արդյոք տողը դատարկ է: Մանր նիշերը, ինչպիսիք են տիեզերքը, կառքի վերադարձը և այլն, հաշվի չեն առնվում:

EmptyString ("Pupkin Vasily Ivanovich") // ֆունկցիան կվերադարձնի False արժեքը
EmptyString(" ") // ֆունկցիան կվերադարձնի True արժեքը

VReg, NReg, Treg

Այս ֆունկցիաները շատ օգտակար են լարային փոփոխականները համեմատելիս և փոխակերպելիս։ «Vreg()»-ը կվերադարձնի սկզբնական տողը մեծատառով, «HPreg()»-ը փոքրատառով, իսկ «Treg()»-ը կձևավորի այն այնպես, որ յուրաքանչյուր առանձին բառի առաջին նիշը գրվի մեծատառով, իսկ բոլոր հաջորդ նիշերը՝ մեծատառով:

Vreg («ԳԼԽԱՎՈՐ ՏՆՕՐԵՆ») // վերադարձի արժեքը - «ԳԼԽԱՎՈՐ ՏՆՕՐԵՆ»
Nreg («Գլխավոր տնօրեն») // վերադարձի արժեքը – «Գլխավոր տնօրեն»
TREG («Գլխավոր տնօրեն») // վերադարձի արժեք – «Գլխավոր տնօրեն»

Էջի փոխարինում

Այս գործառույթը նման է տեքստային խմբագրիչների փոխարինմանը: Այն թույլ է տալիս լարային փոփոխականներում մեկ նիշ կամ նիշերի շարք փոխարինել մյուսով:

StrReplace("կարմիր, սպիտակ, դեղին", ","", ";") // վերադարձնում է "կարմիր; սպիտակ; դեղին»

StrNumberLines

Ֆունկցիան թույլ է տալիս որոշել տեքստային փոփոխականում փոխադրման վերադարձով առանձնացված տողերի քանակը:

Ստորև բերված օրինակի հանգույցը կանցնի երեք փուլով, քանի որ LineNumberRow ֆունկցիան կվերադարձնի 3 արժեքը.

Համար ind = 1 ըստ Str.
<тело цикла>
End Cycle;

StrGetString

Այս ֆունկցիան աշխատում է բազմագիծ տեքստի հետ այնպես, ինչպես նախորդը: Այն թույլ է տալիս տեքստային փոփոխականից ստանալ կոնկրետ տող:

StrGetString ("String1" + Characters.PS + "String2" + Characters.PS + "String3", 2) // վերադարձնել «String2»

Էջերի համարները

Ֆունկցիան հաշվում է որոնման տողում նիշերի կամ ենթատողի հայտնվելու քանակը:

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 - that's us!") // կվերադարձնի "Horns and Hooves LLC - that's us!"

Բազմագիծ, տողերի ընդմիջում

Բազմատող տեքստ ստեղծելու համար պարզապես ավելացրեք տողերի ընդմիջումներ (Symbols.PS):

MultilineText = «Առաջին տող» + նշաններ. PS + «Երկրորդ տող»

Ինչպես հեռացնել բացերը

Աջ կամ ձախ հատվածները հեռացնելու համար կարող եք օգտագործել «ScrAP()» ֆունկցիան (ինչպես նաև «ScrL()» և «ScrP()»):

StringNoSpaces = հապավում ("Շատ տառեր") // ֆունկցիան կվերադարձնի "Շատ տառեր" արժեքը

Եթե ​​թիվը տողի վերածելուց հետո անհրաժեշտ է հեռացնել չընդհատվող բացատները, օգտագործեք հետևյալ կառուցվածքը.

StringNoSpaces = StrReplace(String(99999),Characters.NPP,") // վերադարձնում է «99999»

Ծրագրավորողները նաև հաճախ օգտագործում են հետևյալ կառուցվածքը, որը թույլ է տալիս հեռացնել կամ փոխարինել մեկ այլ գրանշանով տեքստային փոփոխականի բոլոր բացերը.

StringNoSpaces = StrReplace("բարև","") // վերադարձնում է "բարև"

Համեմատելով տողերը միմյանց հետ

Դուք կարող եք համեմատել տերմինները սովորական հավասար նշանի հետ: Համեմատությունը մեծատառերի զգայուն է:

«Hello» = «բարև» // վերադարձնում է False
"Hello" = "Hello" // վերադարձնում է True
«Hello» = «Ցտեսություն» // կվերադարձնի False

1C հարցումներում տողերի հետ աշխատելու մեխանիզմները քիչ են: Նախ, տողերը կարող են ավելացվել: Երկրորդ, դուք կարող եք վերցնել տողից ենթատող: Երրորդ, տողերը կարելի է համեմատել, այդ թվում՝ ըստ օրինաչափության։ Հավանաբար սա այն ամենն է, ինչ կարելի է անել լարերով:

Լարի ավելացում

Հարցման մեջ տողեր ավելացնելու համար օգտագործվում է «+» գործողությունը: Դուք կարող եք ավելացնել միայն սահմանափակ երկարությամբ տողեր:

Ընտրեք «Անուն.

Ենթալարի ֆունկցիա

ԵՆԹԱԴՐՈՒՄ (<Строка>, <НачальнаяПозиция>, <Длина>)

Environment() ֆունկցիայի անալոգը օբյեկտի մոդելից: Substring() ֆունկցիան կարող է կիրառվել լարային տվյալների վրա և թույլ է տալիս ընտրել հատված <Строки> , սկսած նիշի համարից <НачальнаяПозиция> (տողի նիշերը համարակալված են 1-ից սկսած) և երկարությունը <Длина> կերպարներ. Ֆունկցիայի հաշվարկի արդյունքն ունի փոփոխական երկարությամբ տողի տեսակ, և երկարությունը կհամարվի անսահմանափակ, եթե <Строка> ունի անսահմանափակ երկարություն և պարամետր <Длина> հաստատուն չէ կամ 1024-ից մեծ չէ:

Եթե ​​տողի երկարությունը փոքր է, քան նշված է երկրորդ պարամետրում, ապա ֆունկցիան կվերադարձնի դատարկ տող:

Ուշադրություն.Խորհուրդ չի տրվում օգտագործել SUBSTRING() ֆունկցիան՝ անսահմանափակ երկարությամբ տողերը սահմանափակ երկարությամբ տողերի փոխարկելու համար: Փոխարենը, ավելի լավ է օգտագործել Cast օպերատորը EXPRESS():

Գործառույթը նման է

Եթե ​​մենք պետք է համոզվենք, որ լարային հատկանիշը համապատասխանում է որոշակի չափանիշների, մենք համեմատում ենք այն.

ԸՆՏՐԵՔ Կողմնակիցներ. Անվանում AS Սյունակ 1 տեղեկատուից. Կողմնակիցներ ՈՐՊԵՍ Կողմնակիցներ WHERE Կոնտրագենտներ. Անուն = «Գազպրոմ»

Բայց ի՞նչ, եթե ավելի նուրբ համեմատության կարիք ունեք: Ոչ միայն հավասարություն կամ անհավասարություն, այլ նմանություն որոշակի օրինաչափության: Հենց դրա համար է ստեղծվել SIMILAR ֆունկցիան։

LIKE - Օպերատոր, որը ստուգում է տողը օրինաչափության նմանության համար: LIKE-ի անալոգը SQL-ում:

SIMILAR օպերատորը թույլ է տալիս համեմատել դրա ձախ կողմում նշված արտահայտության արժեքը աջ կողմում նշված օրինաչափության տողի հետ: Արտահայտության արժեքը պետք է լինի string տիպի: Եթե ​​արտահայտության արժեքը համապատասխանում է օրինաչափությանը, ապա օպերատորի արդյունքը կլինի TRUE, հակառակ դեպքում՝ FALSE:

Կաղապարի տողի հետևյալ նիշերը սպասարկման նիշեր են և ունեն տողային նիշից տարբեր նշանակություն.

• % (տոկոս). հաջորդականություն, որը պարունակում է ցանկացած թվով կամայական նշաններ.
• _ (ընդգծում). մեկ կամայական նիշ;
• [...] (մեկ կամ մի քանի նիշ քառակուսի փակագծերում). ցանկացած առանձին նիշ, որը նշված է քառակուսի փակագծերում: Թվարկումը կարող է պարունակել միջակայքեր, օրինակ՝ a-z, որը նշանակում է կամայական նիշ, որը ներառված է տիրույթում, ներառյալ տիրույթի ծայրերը.
• [^...] (քառակուսի փակագծերում ժխտման նշան, որին հաջորդում է մեկ կամ մի քանի նիշ). ցանկացած այլ նիշ, բացառությամբ ժխտման նշանին հաջորդող թվարկվածների:

Ցանկացած այլ նշան նշանակում է ինքն իրեն և չի կրում որևէ լրացուցիչ բեռ: Եթե ​​թվարկված նիշերից մեկը պետք է գրվի որպես ինքն իրեն, ապա դրան պետք է նախորդել<Спецсимвол>. ինքս ինձ<Спецсимвол>(ցանկացած հարմար նիշ) սահմանվում է նույն հայտարարության մեջ ՀԱՏՈՒԿ ՆՇԱՆԱՎՈՐ հիմնաբառից հետո:

Իրականացված տարբերակում 8.3.6.1977 թ.

Մենք ընդլայնել ենք լարերի հետ աշխատելու համար նախատեսված գործառույթների շարքը: Մենք դա արեցինք, որպեսզի ձեզ ավելի առաջադեմ գործիքներ տրամադրենք տողերի տվյալների վերլուծության համար: Նոր գործառույթները հարմար և օգտակար կլինեն տեքստի վերլուծության տեխնոլոգիական առաջադրանքներում։ Տեքստի վերլուծության հետ կապված առաջադրանքներում, որոնք պարունակում են տվյալներ ֆորմատավորված ձևով: Սա կարող է լինել սարքավորումներից ստացված որոշ ֆայլերի վերլուծություն կամ, օրինակ, տեխնոլոգիական մատյանի վերլուծություն:

Դուք կարող եք կատարել բոլոր այն գործողությունները, որոնք նախկինում կատարում են նոր գործառույթներ: Ներկառուցված լեզվով գրված քիչ թե շատ բարդ ալգորիթմների օգտագործում: Հետևաբար, նոր գործառույթները ձեզ սկզբունքորեն նոր հնարավորություններ չեն տալիս: Այնուամենայնիվ, դրանք թույլ են տալիս նվազեցնել կոդի քանակը և ծածկագիրը դարձնել ավելի պարզ և հասկանալի: Բացի այդ, նրանք թույլ են տալիս արագացնել գործողությունների կատարումը: Որովհետև հարթակում ներդրված ֆունկցիաները, իհարկե, ավելի արագ են աշխատում, քան ներկառուցված լեզվով գրված նմանատիպ ալգորիթմը։

StrTemplate() ֆորմատավորման ֆունկցիա

Այս ֆունկցիան պարամետրերը փոխարինում է տողի մեջ: Նման փոխակերպման անհրաժեշտությունը հաճախ է առաջանում, օրինակ, նախազգուշական հաղորդագրություններ ցուցադրելիս: Այս ֆունկցիայի շարահյուսությունը հետևյալն է.

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

<Шаблон>- սա այն տողն է, որի մեջ դուք պետք է փոխարինեք պարամետրերի ներկայացումները:

<Значение1> , ... <Значение10>- սրանք պարամետրեր են (առավելագույնը տասը), որոնց ներկայացումները պետք է փոխարինվեն տողի մեջ:

Կաղապարում որոշակի տեղ նշելու համար, որտեղ ցանկանում եք կատարել փոխարինումը, դուք պետք է օգտագործեք նշիչներ, ինչպիսիք են %1, ... %10: Կաղապարում ներգրավված մարկերների քանակը և արժեքներ պարունակող պարամետրերի քանակը պետք է համընկնեն:

Օրինակ, նման օպերատորի կատարման արդյունքը.

կլինի տող.

Տվյալների սխալ 2-րդ տողում (ամսաթվի տեսակը պարտադիր է)

StrCompare() տողերի հետ աշխատելու ֆունկցիա

Այս ֆունկցիան համեմատում է երկու տողեր՝ մեծատառերի անզգայուն եղանակով: Օրինակ, այսպես.

Դուք կարող եք նույն գործողությունը կատարել ավելի վաղ՝ օգտագործելով Value Comparison օբյեկտը.

Այնուամենայնիվ, նոր գործառույթից օգտվելն ավելի հեշտ է թվում: Եվ բացի սրանից, ֆունկցիան, ի տարբերություն Value Comparison օբյեկտի, աշխատում է ինչպես thin client-ում, այնպես էլ վեբ-հաճախորդում։

StrStartsWith(), StrEndsAt() տողերի հետ աշխատելու գործառույթներ

Այս ֆունկցիաները որոշում են՝ արդյոք տողը սկսվում է որոշակի ենթատողով, թե արդյոք տողը ավարտվում է նշված ենթատողով։ Այս գործառույթների ալգորիթմը ներդրված լեզվով իրականացնելը դժվար չէ, սակայն դրանց առկայությունը թույլ է տալիս գրել ավելի մաքուր և հասկանալի կոդ: Եվ նրանք ավելի արագ են աշխատում:

Օրինակ, դրանք հարմար է օգտագործել If դրույթում.

StrDivide(), StrConnect() տողերի հետ աշխատելու գործառույթներ

Այս գործառույթները տողը բաժանում են մասերի, օգտագործելով որոշակի սահմանազատիչ: Կամ հակառակը, նրանք միավորում են մի քանի տող մեկի մեջ, նրանց միջև ներդնելով ընտրված բաժանարարը: Դրանք հարմար են տեղեկամատյաններ և տեխնոլոգիական ամսագրեր ստեղծելու կամ վերլուծելու համար: Օրինակ, դուք կարող եք հեշտությամբ վերլուծել տեխնոլոգիական մատյան մուտքը մասերի, որոնք հարմար են հետագա վերլուծության համար.

StrFind() տողերի հետ աշխատելու ֆունկցիա

Հին Find() ֆունկցիայի փոխարեն մենք ներդրել ենք նոր ֆունկցիա, որն ունի լրացուցիչ հնարավորություններ.

• Որոնել տարբեր ուղղություններով (սկզբից, վերջից);
• Որոնել նշված դիրքից;
• Որոնել նշված թվով երևույթ (երկրորդ, երրորդ և այլն):

Փաստորեն, դա կրկնօրինակում է հին ֆունկցիայի հնարավորությունները: Սա արվում է ավելի հին տարբերակներում կազմված մոդուլների հետ համատեղելիությունը պահպանելու համար: Խորհուրդ է տրվում այլևս չօգտագործել հին Find() ֆունկցիան:

Ստորև բերված է նոր որոնման հնարավորությունների օգտագործման օրինակ: Հակադարձ որոնումը օգտակար է, երբ ձեզ անհրաժեշտ է պաշտոնականացված տողի վերջին մասը, օրինակ՝ ֆայլի ամբողջական անունը URL-ում: Իսկ որոնումը նշված դիրքից օգնում է այն դեպքերում, երբ անհրաժեշտ է փնտրել հայտնի հատվածում, այլ ոչ թե ամբողջ տողում։