സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പുതിയ പ്രവർത്തനങ്ങൾ. 1 സെ പ്രോഗ്രാമിംഗിൽ സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പുതിയ പ്രവർത്തനങ്ങൾ

ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിസ്ഥാന കഴിവുകളിൽ സാധാരണയായി നമ്പറുകളും സ്ട്രിംഗുകളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ഉൾപ്പെടുന്നു. സാധാരണയായി ഈ സവിശേഷതകൾ കമ്പൈലർ കോഡിലേക്ക് ഹാർഡ്-കോഡ് ചെയ്തിരിക്കുന്നു (അല്ലെങ്കിൽ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ "ബേസ്" ക്ലാസുകൾ നടപ്പിലാക്കുന്നു).

1C-യിൽ, സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനുള്ള കഴിവ് പ്ലാറ്റ്ഫോമിൽ തന്നെ പ്രോഗ്രാം ചെയ്തിട്ടുണ്ട്. ബിൽറ്റ്-ഇൻ 1C ഭാഷയിലെ പ്രോഗ്രാമുകളിൽ 1C സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിൻ്റെ സവിശേഷതകൾ ഇന്ന് നമ്മൾ നോക്കും.

ലൈൻ മൂല്യം 1C

1. നമുക്ക് ഏറ്റവും ലളിതമായതിൽ നിന്ന് ആരംഭിക്കാം. ഒരു വേരിയബിൾ സൃഷ്‌ടിക്കുകയും അതിന് ഒരു സ്ഥിരമായ സ്ട്രിംഗ് മൂല്യം നൽകുകയും ചെയ്യുന്നത് 1C-ൽ ഇതുപോലെ കാണപ്പെടുന്നു:

വേരിയബിൾ = "ഹലോ, വേൾഡ്!";

സ്ഥിരമായ 1C സ്ട്രിംഗ് മൂല്യത്തിൽ നിങ്ങൾക്ക് ഒരു ഉദ്ധരണി പ്രതീകം വ്യക്തമാക്കണമെങ്കിൽ, നിങ്ങൾ അത് ഇരട്ടിയാക്കേണ്ടതുണ്ട് ""

വേരിയബിൾ = "ഹലോ, വേൾഡ്"!;

2. ലൈൻ ബ്രേക്ക് 1C ഒരേസമയം രണ്ട് തരത്തിൽ വ്യക്തമാക്കാം. ആദ്യത്തേത് | എന്ന ചിഹ്നം ഉപയോഗിക്കുന്നു

വേരിയബിൾ = "ഹലോ,
| ലോകം! ";

രണ്ടാമത്തേത് സിംബൽസ് സിസ്റ്റം എൻയുമറേഷൻ ഉപയോഗിക്കുന്നു. 1C ലൈൻ ബ്രേക്കുകളും TAB പോലുള്ള മറ്റ് നോൺ-പ്രിൻ്റിംഗ് പ്രതീകങ്ങളും ചേർക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

വേരിയബിൾ = "ഹലോ" + ചിഹ്നങ്ങൾ.PS + "സമാധാനം!";

3. 1C-യിലെ കോൺഫിഗറേഷനുകൾ ഒരു ഭാഷയ്ക്ക് (റഷ്യൻ, ഇംഗ്ലീഷ് അല്ലെങ്കിൽ മറ്റൊന്ന്) മാത്രമല്ല - ഒരേസമയം നിരവധി ഭാഷകൾക്കായി വികസിപ്പിക്കാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ, നിലവിൽ ഉപയോഗിക്കുന്ന ഭാഷ 1C വിൻഡോയുടെ ചുവടെ തിരഞ്ഞെടുത്തിരിക്കുന്നു.

ഭാഷകളുടെ ലിസ്റ്റ് പൊതു/ഭാഷാ ശാഖയിലെ കോൺഫിഗറേഷൻ വിൻഡോയിൽ സ്ഥിതിചെയ്യുന്നു. ഓരോ ഭാഷയ്ക്കും ഒരു ചെറിയ ഐഡൻ്റിഫയർ ഉണ്ട് ruഅല്ലെങ്കിൽ എൻജിനീയർ.

അത്തരമൊരു കോൺഫിഗറേഷൻ പ്രോഗ്രാം ചെയ്യുമ്പോൾ, 1C ലൈനുകളും ബഹുഭാഷാ ആകാം എന്ന് വ്യക്തമാണ്. ഇത് ചെയ്യുന്നതിന്, വ്യക്തമാക്കുന്നതിലൂടെ അത്തരമൊരു 1C ലൈൻ സൃഷ്ടിക്കാൻ കഴിയും; ഭാഷാ ഐഡൻ്റിഫയർ വഴിയുള്ള ഓപ്ഷനുകൾ:

വേരിയബിൾ = "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 ഉണ്ടാകും
പ്രതീകം 1-ൽ ആരംഭിച്ച് 1C-ൽ ഒരു ഉപസ്‌ട്രിംഗിനായി തിരയുക.
വേരിയബിൾ = Strength("Music"); //6 ഉണ്ടാകും
1C ലൈനിലെ പ്രതീകങ്ങളുടെ എണ്ണം നൽകുന്നു.
1C വിൻഡോയുടെ ചുവടെയുള്ള സന്ദേശ വിൻഡോയിൽ ("ഹലോ") റിപ്പോർട്ട് ചെയ്യുക
മുന്നറിയിപ്പ് ("ഹലോ") //പോപ്പ്അപ്പ് ഡയലോഗ്
സ്റ്റാറ്റസ്("ഹലോ") //താഴെ ഇടതുവശത്തുള്ള സ്റ്റാറ്റസ് ഡിസ്പ്ലേ ലൈനിൽ
.

വസ്‌തുക്കളെ ലൈൻ 1 സിയിലേക്ക് കൊണ്ടുവരുന്നു

നിങ്ങൾക്കറിയാവുന്നതുപോലെ, നിലവിൽ ഘടനാപരമായ വിവരങ്ങൾ കൈമാറുന്നതിനുള്ള ഏറ്റവും ജനപ്രിയ ഫോർമാറ്റ് XML ആണ്. MS Office Word, Excel എന്നിവയുടെ ഏറ്റവും പുതിയ പതിപ്പ് പോലും ഈ ഫോർമാറ്റിൽ ഫയലുകൾ സംരക്ഷിക്കുന്നു (docx, xlsx എന്നിവ യഥാക്രമം, വിപുലീകരണം zip ആക്കി മാറ്റുക, ഒരു ആർക്കൈവറിൽ തുറക്കുക).

ഡാറ്റാ എക്സ്ചേഞ്ചിനായുള്ള 1C പ്ലാറ്റ്ഫോം നിരവധി ഓപ്ഷനുകൾ നൽകുന്നു, അതിൽ പ്രധാനം XML ആണ്.

1. ചുരുക്കെഴുത്ത് () അല്ലെങ്കിൽ സ്ട്രിംഗ് () ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നതാണ് ഏറ്റവും ലളിതമായ രീതി. അഭ്യർത്ഥന ബോഡിയിൽ നിങ്ങൾക്ക് REPRESENTATION() ഫംഗ്ഷൻ ഉപയോഗിക്കാം. അവരുടെ പ്രവർത്തനത്തിൻ്റെ ഫലം ഒന്നുതന്നെയാണ് - അവ ഉപയോക്താവിനായി ഏതെങ്കിലും 1C ഒബ്‌ജക്റ്റിൻ്റെ ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യം സൃഷ്ടിക്കുന്നു.

ഡിഫോൾട്ടായി ഒരു ഡയറക്ടറിക്ക്, ഇതായിരിക്കും അതിൻ്റെ പേര്. ഒരു പ്രമാണത്തിന് - പ്രമാണത്തിൻ്റെ പേര്, നമ്പർ, തീയതി.

2. ഏത് 1C ഒബ്ജക്റ്റും (നിയന്ത്രണങ്ങളോടെ) XML ആയും തിരിച്ചും പരിവർത്തനം ചെയ്യാവുന്നതാണ്. പരിവർത്തന പ്രക്രിയയെ സീരിയലൈസേഷൻ എന്ന് വിളിക്കുന്നു.

StringViewXml = XMLString(മൂല്യം); //1C മൂല്യത്തിൽ നിന്ന് XML നേടുക
Value1C = XMLValue(Type("DirectoryLink.Nomenclature"),TypeStringXml); //XML സ്ട്രിംഗിൽ നിന്ന് 1C മൂല്യം നേടുക, സ്വീകരിക്കേണ്ട 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. ഇൻപുട്ട് ഫീൽഡിൻ്റെ കഴിവുകൾ വിപുലീകരിക്കാൻ കഴിയും (ഇൻപുട്ട് ഫീൽഡിൻ്റെ സവിശേഷതകൾ കാണുക, അതിൽ വലത്-ക്ലിക്കുചെയ്യുക, കൂടുതൽ വിശദാംശങ്ങൾ):

ചെക്ക്ബോക്സ് മൾട്ടിലൈൻ എഡിറ്റിംഗ് മോഡ്
വിപുലമായ എഡിറ്റിംഗ് ചെക്ക്ബോക്സ് (മുമ്പത്തെ ചെക്ക്ബോക്സ് ചെക്ക് ചെയ്തിട്ടുണ്ടെങ്കിൽ ലഭ്യമാണ്)
ചെക്ക്ബോക്സ് പാസ്വേഡ് മോഡ് (കാണുക).

4. ഇൻപുട്ട് ഫീൽഡിൻ്റെ എല്ലാ കഴിവുകളും നിങ്ങൾക്ക് പര്യാപ്തമല്ലെങ്കിൽ, ഒരു ബിൽറ്റ്-ഇൻ എഡിറ്റർ ഉണ്ട്. ഇത് ഫോമിലേക്ക് ചേർക്കുന്നതിന്, നിങ്ങൾ ഫോം/ഇൻസേർട്ട് കൺട്രോൾ മെനുവിലേക്ക് ഒരു ടെക്സ്റ്റ് ഡോക്യുമെൻ്റ് ഫീൽഡ് ചേർക്കേണ്ടതുണ്ട്. അതിൻ്റെ പ്രോപ്പർട്ടികളിൽ നിങ്ങൾക്ക് അതിൻ്റെ പ്രവർത്തന മോഡ് വ്യക്തമാക്കാൻ കഴിയും - എക്സ്റ്റൻഷൻ പ്രോപ്പർട്ടി.

ഒരു ടെക്സ്റ്റ് ഡോക്യുമെൻ്റ് ഫീൽഡ് ഡാറ്റയുമായി നേരിട്ട് ബന്ധപ്പെടുത്താൻ കഴിയില്ല. ഫോമിൻ്റെ OnOpen() ഇവൻ്റ് ഹാൻഡ്‌ലറിൽ ഒരു ഫംഗ്ഷൻ എഴുതേണ്ടത് ആവശ്യമാണ് (കാണുക):

Form Elements.ElementNameTextDocumentField.SetText(ValueString); //ഇവിടെ ValueString എന്നത് ആട്രിബ്യൂട്ടിൽ നിന്ന് ലഭിച്ച വാചകമാണ്

സേവ് ഹാൻഡ്‌ലറിൽ - ഉദാഹരണത്തിന്, സേവ് ബട്ടണിൽ - ഒരു സേവ് ചേർക്കുക:

ValueString = FormElements.ElementNameTextDocumentField.GetText(); //മൂല്യം നമ്മൾ സംരക്ഷിക്കുന്ന ആട്രിബ്യൂട്ടാണ് ഇവിടെയുള്ള വരി

5. 1C പതിപ്പ് 8.2.11-ൽ, നിയന്ത്രിത ഫോമുകളിൽ, ഒരു 1C ലൈൻ പ്രതിനിധീകരിക്കുന്നതിന് ഒരു പുതിയ ഓപ്ഷൻ പ്രത്യക്ഷപ്പെട്ടു - ഫോർമാറ്റ് ചെയ്ത ഡോക്യുമെൻ്റ് ഫീൽഡ്.

ഒരു ടെക്സ്റ്റ് ഡോക്യുമെൻ്റിൻ്റെ ഫീൽഡിന് സമാനമായി, അത് തുറക്കുമ്പോൾ നിങ്ങൾ അത് സജ്ജീകരിക്കുകയും പ്രോഗ്രാം ഉപയോഗിച്ച് സ്വയം സംരക്ഷിക്കുമ്പോൾ അത് എഴുതുകയും വേണം.

1C ഒബ്‌ജക്‌റ്റിൽ ഞങ്ങൾ സൃഷ്‌ടിക്കുന്ന ഫോം (ഡയറക്‌ടറി, ഡോക്യുമെൻ്റ്, പ്രോസസ്സിംഗ് മുതലായവ) - മൂല്യ സംഭരണ തരം ഉപയോഗിച്ച് ഒരു ആട്രിബ്യൂട്ട് ചേർക്കുക
OnReadOnServer() ഫംഗ്‌ഷനിൽ ഞങ്ങൾ ആട്രിബ്യൂട്ടിൽ നിന്നുള്ള വാചകം സജ്ജമാക്കുന്നു
//ഇവിടെ ആട്രിബ്യൂട്ട് എന്നത് 1C ഒബ്‌ജക്റ്റിൻ്റെ അധിക ആട്രിബ്യൂട്ട് ആണ്
//ഇവിടെ FormattedDocument എന്നത് എഡിറ്റ് ചെയ്യുന്നതിനുള്ള ഫോമിലെ ഫീൽഡിൻ്റെ പേരാണ്
&ഓൺസെർവർ

FormattedDocument = CurrentObject.Attributes.Get();
നടപടിക്രമത്തിൻ്റെ അവസാനം
BeforeWritingOnServer() ഫംഗ്‌ഷനിലോ ബട്ടൺ ഉപയോഗിച്ചോ, ഞങ്ങൾ ഫീൽഡിൽ നിന്ന് ടെക്‌സ്‌റ്റ് എഴുതും
&ഓൺസെർവർ
ഓൺസെർവർ (കറൻ്റ് ഒബ്ജക്റ്റ്) വായിക്കുമ്പോൾ നടപടിക്രമം
CurrentObject.Props = NewValueStorage(FormattedDocument);
നടപടിക്രമത്തിൻ്റെ അവസാനം

1C അന്വേഷണങ്ങളിൽ സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിന് കുറച്ച് മെക്കാനിസങ്ങളുണ്ട്. ആദ്യം, വരികൾ ചേർക്കാം. രണ്ടാമതായി, നിങ്ങൾക്ക് ഒരു സ്ട്രിംഗിൽ നിന്ന് ഒരു സബ്സ്ട്രിംഗ് എടുക്കാം. മൂന്നാമതായി, പാറ്റേൺ ഉൾപ്പെടെയുള്ള സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യാം. ചരടുകൾ ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയുന്നത് അത്രയേയുള്ളൂ.

സ്ട്രിംഗ് കൂട്ടിച്ചേർക്കൽ

ഒരു അന്വേഷണത്തിൽ വരികൾ ചേർക്കുന്നതിന്, "+" പ്രവർത്തനം ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് പരിമിതമായ ദൈർഘ്യമുള്ള സ്ട്രിംഗുകൾ മാത്രമേ ചേർക്കാൻ കഴിയൂ.

"പേര്: " + കൌണ്ടർപാർട്ടികൾ എന്ന പേരിൽ കോളം 1 എന്ന പേര് തിരഞ്ഞെടുക്കുക

സബ്സ്ട്രിംഗ് ഫംഗ്ഷൻ

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

ഒബ്ജക്റ്റ് മോഡലിൽ നിന്നുള്ള പരിസ്ഥിതി() ഫംഗ്ഷൻ്റെ ഒരു അനലോഗ്. സബ്‌സ്ട്രിംഗ്() ഫംഗ്‌ഷൻ സ്ട്രിംഗ് ഡാറ്റയിൽ പ്രയോഗിക്കുകയും ഒരു ശകലം തിരഞ്ഞെടുക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യാം <Строки> , പ്രതീക നമ്പറിൽ തുടങ്ങുന്നു <НачальнаяПозиция> (ഒരു വരിയിലെ പ്രതീകങ്ങൾ 1 മുതൽ അക്കമിട്ടിരിക്കുന്നു) നീളവും <Длина> കഥാപാത്രങ്ങൾ. ഫംഗ്‌ഷൻ കണക്കുകൂട്ടലിൻ്റെ ഫലത്തിന് വേരിയബിൾ-ലെങ്ത് സ്‌ട്രിംഗ് തരമുണ്ട്, എങ്കിൽ ദൈർഘ്യം പരിധിയില്ലാത്തതായി കണക്കാക്കും <Строка> പരിധിയില്ലാത്ത നീളവും പരാമീറ്ററും ഉണ്ട് <Длина> സ്ഥിരമായോ 1024-നേക്കാൾ വലുതോ അല്ല.

സ്ട്രിംഗിൻ്റെ ദൈർഘ്യം രണ്ടാമത്തെ പാരാമീറ്ററിൽ വ്യക്തമാക്കിയതിനേക്കാൾ കുറവാണെങ്കിൽ, ഫംഗ്ഷൻ ഒരു ശൂന്യമായ സ്ട്രിംഗ് തിരികെ നൽകും.

ശ്രദ്ധ!അൺലിമിറ്റഡ് ദൈർഘ്യമുള്ള സ്‌ട്രിംഗുകളെ പരിമിത ദൈർഘ്യമുള്ള സ്‌ട്രിംഗുകളായി പരിവർത്തനം ചെയ്യാൻ SUBSTRING() ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നത് ശുപാർശ ചെയ്യുന്നില്ല. പകരം, കാസ്റ്റ് ഓപ്പറേറ്റർ EXPRESS() ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

പ്രവർത്തനം സമാനമാണ്

ഒരു സ്ട്രിംഗ് ആട്രിബ്യൂട്ട് ചില മാനദണ്ഡങ്ങൾ പാലിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കണമെങ്കിൽ, ഞങ്ങൾ അത് താരതമ്യം ചെയ്യുന്നു:

കൌണ്ടർപാർട്ടികളുടെ പേര് = "ഗാസ്പ്രോം" എന്ന ഡയറക്ടറിയിൽ നിന്ന് പേര് AS തിരഞ്ഞെടുക്കുക.

എന്നാൽ നിങ്ങൾക്ക് കൂടുതൽ സൂക്ഷ്മമായ താരതമ്യം വേണമെങ്കിൽ എന്തുചെയ്യും? സമത്വമോ അസമത്വമോ മാത്രമല്ല, ഒരു പ്രത്യേക പാറ്റേണുമായുള്ള സാമ്യം? ഇതിന് തന്നെയാണ് സമാനമായ ഫംഗ്‌ഷൻ സൃഷ്‌ടിച്ചത്.

ലൈക്ക് - ഒരു പാറ്റേണുമായി സാമ്യമുള്ള ഒരു സ്ട്രിംഗ് പരിശോധിക്കുന്നതിനുള്ള ഓപ്പറേറ്റർ. SQL-ൽ LIKE എന്നതിൻ്റെ അനലോഗ്.

വലത് വശത്ത് വ്യക്തമാക്കിയ പാറ്റേൺ സ്‌ട്രിംഗുമായി അതിൻ്റെ ഇടതുവശത്ത് വ്യക്തമാക്കിയിട്ടുള്ള എക്‌സ്‌പ്രഷൻ്റെ മൂല്യം താരതമ്യം ചെയ്യാൻ സമാനമായ ഓപ്പറേറ്റർ നിങ്ങളെ അനുവദിക്കുന്നു. എക്സ്പ്രഷൻ്റെ മൂല്യം ടൈപ്പ് സ്ട്രിംഗ് ആയിരിക്കണം. പദപ്രയോഗത്തിൻ്റെ മൂല്യം പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ, ഓപ്പറേറ്ററുടെ ഫലം ശരിയായിരിക്കും, അല്ലാത്തപക്ഷം അത് തെറ്റായിരിക്കും.

പാറ്റേൺ സ്‌ട്രിംഗിലെ ഇനിപ്പറയുന്ന പ്രതീകങ്ങൾ സേവന പ്രതീകങ്ങളാണ് കൂടാതെ സ്‌ട്രിംഗ് പ്രതീകത്തിൽ നിന്ന് വ്യത്യസ്തമായ അർത്ഥവുമുണ്ട്:

% (ശതമാനം): ഏതെങ്കിലും അനിയന്ത്രിതമായ പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കുന്ന ഒരു ശ്രേണി;
_ (അണ്ടർസ്കോർ): ഒരു ഏകപക്ഷീയമായ പ്രതീകം;
[…] (സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ ഒന്നോ അതിലധികമോ പ്രതീകങ്ങൾ): ചതുര ബ്രാക്കറ്റിനുള്ളിൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്ന ഏതെങ്കിലും ഒരു പ്രതീകം. എണ്ണത്തിൽ ശ്രേണികൾ അടങ്ങിയിരിക്കാം, ഉദാഹരണത്തിന് a-z, അതായത് ശ്രേണിയുടെ അറ്റങ്ങൾ ഉൾപ്പെടെ ശ്രേണിയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു അനിയന്ത്രിതമായ പ്രതീകം;
[^...] (സ്ക്വയർ ബ്രാക്കറ്റിൽ ഒരു നിഷേധചിഹ്നം തുടർന്ന് ഒന്നോ അതിലധികമോ പ്രതീകങ്ങൾ): നിഷേധചിഹ്നത്തെ തുടർന്ന് ലിസ്റ്റ് ചെയ്തിരിക്കുന്നവ ഒഴികെയുള്ള ഏതെങ്കിലും ഒരു പ്രതീകം.

മറ്റേതെങ്കിലും ചിഹ്നം സ്വയം അർത്ഥമാക്കുന്നു, അധിക ലോഡൊന്നും വഹിക്കുന്നില്ല. ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന പ്രതീകങ്ങളിലൊന്ന് സ്വയം എഴുതണമെങ്കിൽ, അതിന് മുമ്പായി എഴുതണം<Спецсимвол>. ഞാൻ തന്നെ<Спецсимвол>(അനുയോജ്യമായ ഏതെങ്കിലും പ്രതീകം) സ്പെഷ്യൽ ക്യാരക്ടർ കീവേഡിന് ശേഷം അതേ പ്രസ്താവനയിൽ നിർവചിച്ചിരിക്കുന്നു.

പതിപ്പ് 8.3.6.1977-ൽ നടപ്പിലാക്കി.

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്ത ഫംഗ്ഷനുകളുടെ സെറ്റ് ഞങ്ങൾ വിപുലീകരിച്ചു. സ്‌ട്രിംഗ് ഡാറ്റ പാഴ്‌സ് ചെയ്യുന്നതിനുള്ള കൂടുതൽ വിപുലമായ ടൂളുകൾ നിങ്ങൾക്ക് നൽകാനാണ് ഞങ്ങൾ ഇത് ചെയ്തത്. ടെക്സ്റ്റ് വിശകലനത്തിൻ്റെ സാങ്കേതിക ജോലികളിൽ പുതിയ ഫംഗ്ഷനുകൾ സൗകര്യപ്രദവും ഉപയോഗപ്രദവുമായിരിക്കും. ഫോർമാറ്റ് ചെയ്‌ത രൂപത്തിൽ ഡാറ്റ അടങ്ങിയിരിക്കുന്ന വാചകം പാഴ്‌സുചെയ്യുന്നതുമായി ബന്ധപ്പെട്ട ജോലികളിൽ. ഇത് ഉപകരണങ്ങളിൽ നിന്ന് ലഭിച്ച ചില ഫയലുകളുടെ വിശകലനം ആകാം, അല്ലെങ്കിൽ, ഉദാഹരണത്തിന്, ഒരു സാങ്കേതിക രേഖയുടെ വിശകലനം.

മുമ്പ് പുതിയ ഫംഗ്‌ഷനുകൾ ചെയ്യുന്ന എല്ലാ പ്രവർത്തനങ്ങളും നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയും. ബിൽറ്റ്-ഇൻ ഭാഷയിൽ എഴുതിയിരിക്കുന്ന കൂടുതലോ കുറവോ സങ്കീർണ്ണമായ അൽഗോരിതങ്ങൾ ഉപയോഗിക്കുന്നു. അതിനാൽ, പുതിയ പ്രവർത്തനങ്ങൾ നിങ്ങൾക്ക് അടിസ്ഥാനപരമായി പുതിയ കഴിവുകളൊന്നും നൽകുന്നില്ല. എന്നിരുന്നാലും, കോഡിൻ്റെ അളവ് കുറയ്ക്കാനും കോഡ് ലളിതവും കൂടുതൽ മനസ്സിലാക്കാവുന്നതുമാക്കാനും അവർ നിങ്ങളെ അനുവദിക്കുന്നു. കൂടാതെ, പ്രവർത്തനങ്ങളുടെ നിർവ്വഹണം വേഗത്തിലാക്കാൻ അവർ നിങ്ങളെ അനുവദിക്കുന്നു. പ്ലാറ്റ്‌ഫോമിൽ നടപ്പിലാക്കിയ ഫംഗ്‌ഷനുകൾ, തീർച്ചയായും, ഒരു ബിൽറ്റ്-ഇൻ ഭാഷയിൽ എഴുതിയിരിക്കുന്ന സമാനമായ അൽഗോരിതത്തേക്കാൾ വേഗത്തിലാണ് പ്രവർത്തിക്കുന്നത്.

ഫോർമാറ്റിംഗ് ഫംഗ്‌ഷൻ StrTemplate()

ഈ ഫംഗ്ഷൻ പരാമീറ്ററുകളെ ഒരു സ്ട്രിംഗിലേക്ക് മാറ്റിസ്ഥാപിക്കുന്നു. അത്തരമൊരു പരിവർത്തനത്തിൻ്റെ ആവശ്യകത പലപ്പോഴും ഉയർന്നുവരുന്നു, ഉദാഹരണത്തിന്, മുന്നറിയിപ്പ് സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കുമ്പോൾ. ഈ ഫംഗ്‌ഷൻ്റെ വാക്യഘടന ഇപ്രകാരമാണ്:

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

<Шаблон>- പാരാമീറ്റർ പ്രാതിനിധ്യങ്ങൾ മാറ്റിസ്ഥാപിക്കേണ്ട സ്ട്രിംഗ് ഇതാണ്.

<Значение1> , ... <Значение10>- ഇവ പരാമീറ്ററുകളാണ് (പരമാവധി പത്ത്), ഇവയുടെ പ്രാതിനിധ്യങ്ങൾ സ്ട്രിംഗിൽ പകരം വയ്ക്കണം.

നിങ്ങൾ പകരം വയ്ക്കാൻ ആഗ്രഹിക്കുന്ന ടെംപ്ലേറ്റിലെ ഒരു പ്രത്യേക സ്ഥലം സൂചിപ്പിക്കാൻ, നിങ്ങൾ % 1, ... % 10 പോലുള്ള മാർക്കറുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്. ടെംപ്ലേറ്റിൽ ഉൾപ്പെട്ടിരിക്കുന്ന മാർക്കറുകളുടെ എണ്ണവും മൂല്യങ്ങൾ അടങ്ങിയ പാരാമീറ്ററുകളുടെ എണ്ണവും പൊരുത്തപ്പെടണം.

ഉദാഹരണത്തിന്, അത്തരമൊരു ഓപ്പറേറ്റർ നടപ്പിലാക്കുന്നതിൻ്റെ ഫലം:

ഒരു വരി ഉണ്ടാകും:

2 വരിയിലെ ഡാറ്റ പിശക് (തീയതി തരം ആവശ്യമാണ്)

സ്ട്രിംഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനം StrCompare()

ഈ ഫംഗ്‌ഷൻ രണ്ട് സ്ട്രിംഗുകളെ ഒരു കേസ്-ഇൻസെൻസിറ്റീവ് രീതിയിൽ താരതമ്യം ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഇതുപോലെ:

മൂല്യ താരതമ്യ ഒബ്‌ജക്‌റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് മുമ്പ് ഇതേ പ്രവർത്തനം നടത്താം:

എന്നിരുന്നാലും, പുതിയ ഫീച്ചർ ഉപയോഗിക്കുന്നത് എളുപ്പമാണെന്ന് തോന്നുന്നു. കൂടാതെ, ഫംഗ്ഷൻ, മൂല്യ താരതമ്യം ഒബ്ജക്റ്റിൽ നിന്ന് വ്യത്യസ്തമായി, നേർത്ത ക്ലയൻ്റിലും വെബ് ക്ലയൻ്റിലും പ്രവർത്തിക്കുന്നു.

സ്ട്രിംഗ്സ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ StrStartsWith(), StrEndsAt()

ഈ ഫംഗ്‌ഷനുകൾ ഒരു സ്‌ട്രിംഗ് ആരംഭിക്കുന്നത് ഒരു നിർദ്ദിഷ്‌ട സബ്‌സ്‌ട്രിംഗിൽ ആണോ അതോ ഒരു സ്ട്രിംഗ് അവസാനിക്കുന്നത് ഒരു നിർദ്ദിഷ്ട സബ്‌സ്‌ട്രിംഗിൽ ആണോ എന്ന് നിർണ്ണയിക്കുന്നു. ഈ ഫംഗ്ഷനുകൾക്കുള്ള അൽഗോരിതം ഒരു ഉൾച്ചേർത്ത ഭാഷയിൽ നടപ്പിലാക്കുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, എന്നാൽ അവയുടെ സാന്നിധ്യം ക്ലീനറും കൂടുതൽ മനസ്സിലാക്കാവുന്നതുമായ കോഡ് എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു. അവർ വേഗത്തിൽ പ്രവർത്തിക്കുന്നു.

ഉദാഹരണത്തിന്, If പ്രസ്താവനയിൽ അവ ഉപയോഗിക്കാൻ സൗകര്യപ്രദമാണ്:

സ്ട്രിംഗുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ StrDivide(), StrConnect()

ഈ ഫംഗ്‌ഷനുകൾ ഒരു സ്‌ട്രിംഗിനെ ഒരു നിർദ്ദിഷ്‌ട ഡിലിമിറ്റർ ഉപയോഗിച്ച് ഭാഗങ്ങളായി വിഭജിക്കുന്നു. അല്ലെങ്കിൽ തിരിച്ചും, അവർ നിരവധി വരികൾ ഒന്നായി സംയോജിപ്പിക്കുന്നു, അവയ്ക്കിടയിൽ തിരഞ്ഞെടുത്ത സെപ്പറേറ്റർ തിരുകുന്നു. ലോഗുകളും സാങ്കേതിക ജേണലുകളും സൃഷ്ടിക്കുന്നതിനോ വിശകലനം ചെയ്യുന്നതിനോ അവ സൗകര്യപ്രദമാണ്. ഉദാഹരണത്തിന്, കൂടുതൽ വിശകലനത്തിന് അനുയോജ്യമായ ഭാഗങ്ങളിലേക്ക് നിങ്ങൾക്ക് ഒരു സാങ്കേതിക ലോഗ് എൻട്രി എളുപ്പത്തിൽ പാഴ്‌സ് ചെയ്യാൻ കഴിയും:

സ്ട്രിംഗ്സ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പ്രവർത്തനം StrFind()

പഴയ Find() ഫംഗ്‌ഷനുപകരം, അധിക കഴിവുകളുള്ള ഒരു പുതിയ ഫംഗ്‌ഷൻ ഞങ്ങൾ നടപ്പിലാക്കി:

വ്യത്യസ്ത ദിശകളിൽ തിരയുക (ആരംഭം മുതൽ അവസാനം വരെ);
ഒരു നിർദ്ദിഷ്ട സ്ഥാനത്ത് നിന്ന് തിരയുക;
ഒരു നിർദ്ദിഷ്ട സംഖ്യ (രണ്ടാമത്തെ, മൂന്നാമത്തേത്, മുതലായവ) ഉള്ള ഒരു സംഭവത്തിനായി തിരയുക.

വാസ്തവത്തിൽ, ഇത് പഴയ പ്രവർത്തനത്തിൻ്റെ കഴിവുകളെ തനിപ്പകർപ്പാക്കുന്നു. പഴയ പതിപ്പുകളിൽ സമാഹരിച്ച മൊഡ്യൂളുകളുമായി അനുയോജ്യത നിലനിർത്തുന്നതിനാണ് ഇത് ചെയ്യുന്നത്. പഴയ ഫൈൻഡ്() ഫംഗ്‌ഷൻ ഇനി ഉപയോഗിക്കരുതെന്ന് ശുപാർശ ചെയ്യുന്നു.

പുതിയ തിരയൽ കഴിവുകൾ ഉപയോഗിക്കുന്ന ഒരു ഉദാഹരണം ചുവടെയുണ്ട്. ഒരു URL-ലെ പൂർണ്ണമായ ഫയലിൻ്റെ പേര് പോലെ, ഒരു ഔപചാരിക സ്‌ട്രിംഗിൻ്റെ അവസാന ഭാഗം ആവശ്യമുള്ളപ്പോൾ റിവേഴ്‌സ് തിരയൽ ഉപയോഗപ്രദമാണ്. ഒരു നിർദ്ദിഷ്ട സ്ഥാനത്ത് നിന്ന് തിരയുന്നത് നിങ്ങൾക്ക് അറിയാവുന്ന ഒരു ശകലത്തിൽ തിരയേണ്ട സന്ദർഭങ്ങളിൽ സഹായിക്കുന്നു, അല്ലാതെ മുഴുവൻ വരിയിലും അല്ല.

ഭാഗം 1. രീതികൾ (26).

1.1 അടിസ്ഥാന രീതികൾ (10). സ്വതന്ത്രമായ, സ്വന്തം ലളിതമായ അൽഗോരിതങ്ങളിൽ നിർമ്മിച്ചതാണ്.

Page_Add() (നിർദ്ദിഷ്ട പ്രതീകങ്ങൾക്കൊപ്പം വലത്-ഇടത് കൂട്ടിച്ചേർക്കൽ).

പേജ്_ഇൻവേഴ്സ് () (വിപരീതം - വലത്തുനിന്ന് ഇടത്തോട്ട് പ്രതീകങ്ങൾ).

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() (ഒരു ഹൈഫൻ ഉപയോഗിച്ച് "ഹാർഡ്ലി" എന്ന ഉപ സ്ട്രിംഗുകളായി വിഭജിക്കുക).

Page_MoveByWords() ("സോഫ്റ്റ്ലി" എന്ന ഉപ സ്ട്രിംഗുകളായി വിഭജിക്കുക)

Page_Cut() (നിർദ്ദിഷ്‌ട ദൈർഘ്യത്തിൻ്റെ ഉപസ്‌ട്രിംഗുകളായി “മുറിക്കുക”)

Str_Shorten() ("ചുരുക്കമുള്ള" പ്രതീകങ്ങളുടെ ഇടത് ഗ്രൂപ്പിനെ ഒരു "മാറ്റിസ്ഥാപിക്കൽ സ്ട്രിംഗ്" ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക

Page_Abbreviation() ( "കുറച്ച" പ്രതീകങ്ങളുടെ വലത് ഗ്രൂപ്പിന് പകരം "മാറ്റിസ്ഥാപിക്കൽ സ്ട്രിംഗ്"

Str_ShortenS() (“ചുരുക്കിയ” പ്രതീകങ്ങളുടെ ഗ്രൂപ്പിൻ്റെ മധ്യത്തിൽ ഒരു “മാറ്റിസ്ഥാപിക്കൽ സ്ട്രിംഗ്” ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക

Page_Extend (നിർദ്ദിഷ്‌ട പ്രതീകങ്ങളുടെ എണ്ണം വർദ്ധിപ്പിച്ച് ഒരു നിർദ്ദിഷ്ട ദൈർഘ്യത്തിലേക്ക് വികസിപ്പിക്കൽ)

1.3 വിശദമായ രീതികൾ (3). വിശദമായ വിവരങ്ങളുള്ള ഒരു ടേബിളിലേക്ക് ട്രാൻസ്ഫർ ചെയ്യുന്ന ഒരു ലൈൻ "ഡിസെക്റ്റിംഗ്".

Page_vTableIn() (നെസ്റ്റഡ് ഡിലിമിറ്ററുകളുടെ സിസ്റ്റം അനുസരിച്ച് പട്ടികയിലേക്ക്).

Page_vTableGr (ഒരു മൾട്ടി-ലെവൽ ഫിൽട്ടർ അനുസരിച്ച് പട്ടികയിലേക്ക്).

Page_inTableNumbers (അവയ്ക്കിടയിൽ അക്കങ്ങളും ശകലങ്ങളും ഉള്ള ഒരു പട്ടികയിൽ).

ഭാഗം 2. പൊതുവായ രീതികൾ-അൽഗോറിംസ് (3).

Page_Occurrence() (“കണ്ടെത്തുക”, “മാറ്റിസ്ഥാപിക്കുക” എന്നീ രീതികൾ).

Page_Fragments() (രീതികൾ “പീസ്”,”ReplacePiece,”InArray”,”inTableIn”).

Page_Abcr() (രീതികൾ "AbcrL", "AbcrP", "AbcrS", "Expand".

Page_Split() (രീതികൾ "അക്ഷരങ്ങൾ അനുസരിച്ച് നീക്കുക", "വാക്കുകൾ ഉപയോഗിച്ച് നീക്കുക", "മുറിക്കുക").

ഭാഗം 3. യൂണിവേഴ്സൽ ഫംഗ്ഷൻ.

ഇത് അനുവദിക്കുന്ന ഒരു തരം സോപാധിക പ്രോഗ്രാമിംഗ് ഇൻ്റർഫേസാണ്

ഒരു സ്ട്രിംഗിൽ ഒരേസമയം നിരവധി രീതികൾ പ്രയോഗിക്കുക. ആയി നടപ്പിലാക്കി

ഏഴ് പാരാമീറ്ററുകളുള്ള ഫംഗ്‌ഷനുകൾ ("ഡെമോ" ഈ ഫംഗ്ഷനിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്):

പേജ്_(രീതികൾ, ഉപരീതികൾ, ഇൻപുട്ട്, പരം1, പാരം2, നീളം_എണ്ണ_സ്ഥാനം, അധിക ഔട്ട്പുട്ട്)

പരാമീറ്ററുകൾ:

- "രീതികൾ" - നിരവധി "സംയോജിത" കൂടാതെ (അല്ലെങ്കിൽ) ഒരു "എക്‌സ്‌ക്ലൂസീവ്" രീതി

(ഒറ്റ പ്രതീക കോഡുകളോ പേരുകളോ, "," വഴി സാധ്യമാണ്)

- "ഉപരീതികൾ" - നിരവധി "സംയോജിത" കൂടാതെ (അല്ലെങ്കിൽ) "എക്‌സ്‌ക്ലൂസീവ്" ഓപ്ഷനുകൾ

"എക്‌സ്‌ക്ലൂസീവ്" രീതി (ഒറ്റ പ്രതീക കോഡുകൾ അല്ലെങ്കിൽ പേരുകൾ);

- "ഇൻപുട്ട്" - സ്ട്രിംഗ്, അല്ലെങ്കിൽ അറേ അല്ലെങ്കിൽ മൂല്യങ്ങളുടെ പട്ടിക;

- "Param1" - തിരയൽ സ്ട്രിംഗ്, സബ്സ്റ്റിറ്റ്യൂഷനുകൾ, സെപ്പറേറ്ററുകൾ, ഫിൽട്ടറുകൾ;

- "Param2" - പകരം വയ്ക്കൽ സ്ട്രിംഗ് അല്ലെങ്കിൽ പ്രതീകങ്ങൾ;

- “Length_Number_Position” -നമ്പർ, ഒരു സെപ്പറേറ്റർ വഴിയുള്ള സംഖ്യകൾ അല്ലെങ്കിൽ സംഖ്യകളുള്ള ഒരു അറേ;

- "അധിക ഔട്ട്പുട്ട്" - നമ്പർ അല്ലെങ്കിൽ സ്ട്രിംഗ് അല്ലെങ്കിൽ അറേ അല്ലെങ്കിൽ മൂല്യങ്ങളുടെ പട്ടിക;

ഉപരീതികളുടെ പേരുകളും കൂടാതെ/അല്ലെങ്കിൽ ഒറ്റ-ക്ഷര കോഡുകളും അതിലെ അക്കങ്ങളും

(Length_Number_Position) ഏത് സാഹചര്യത്തിലും വേർതിരിക്കാം

ഇനിപ്പറയുന്ന ഏതെങ്കിലും ഡിലിമിറ്ററുകൾ: ”, :;”.

ഭാഗം 4. ചില ഉദാഹരണങ്ങൾ.

അവിടെ നമ്പറുകൾഇൻലൈൻ=(Str_FindNumber(InLine)<>നിർവചിക്കാത്തത്);

വരിയിൽ നമ്പറുകൾ ഉണ്ട് = (String_FindGr(Inline,"+0123456789")>0);

ലാറ്റിൻ ഉണ്ട് = (Str_FindGr(InStr, Str_Interpret("lL"))>0);

നിർദ്ദിഷ്ട അടയാളങ്ങൾ ഉണ്ട് = (Str_NfindGr(VxStr, "+to rogYu.0p9")>0);

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

ഭാഗം 5. ഉപസംഹാരം.

സാധ്യമാകുന്നിടത്ത്, ലൈനിലൂടെ ഒരു പാസ് ഉപയോഗിച്ച് ഞാൻ ചെയ്തു. രണ്ടാമത്തെ പാസ് സാധാരണയായി ശകലങ്ങളിലാണ്. ഞാൻ ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷൻ StrNumberOccurrences() ഉപയോഗിച്ചിട്ടില്ല.

ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്നു: ഇടത്(), വലത്(), മിഡിൽ(), സ്ട്രെലെങ്ത്()

- (ലൈനിൻ്റെ ഭാഗം സ്ഥാപിക്കുന്നതും ലഭിക്കുന്നതും "വേഗത" ആയിരിക്കണം).

എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകളിലും സ്ട്രിംഗ് തരം കാണപ്പെടുന്നു. ഇത് പ്രാകൃതമാണ്, കൂടാതെ 1C-യിൽ ഇത് പ്രവർത്തിക്കുന്നതിന് നിരവധി ഫംഗ്ഷനുകൾ ഉണ്ട്. ഈ ലേഖനത്തിൽ, ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് 1C 8.3, 8.2 എന്നിവയിലെ സ്ട്രിംഗ് തരങ്ങളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള വിവിധ വഴികൾ ഞങ്ങൾ വിശദമായി പരിശോധിക്കും.

ലൈൻ

ഏത് തരത്തിലുള്ള വേരിയബിളും ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിനായി, "സ്ട്രിംഗ്()" എന്ന അതേ പേരിൽ ഒരു ഫംഗ്ഷൻ ഉണ്ട്. ഇൻപുട്ട് പാരാമീറ്റർ വേരിയബിളായിരിക്കും, അതിൻ്റെ സ്ട്രിംഗ് പ്രാതിനിധ്യം ലഭിക്കണം.

സ്ട്രിംഗ്(തെറ്റായ) // "ഇല്ല" എന്ന് നൽകുന്നു
സ്ട്രിംഗ്(12345) // "12,345" നൽകുന്നു
സ്ട്രിംഗ്(നിലവിലെ തീയതി()) //"07/21/2017 11:55:36″

ഒരു സ്ട്രിംഗിലേക്ക് പ്രാകൃത തരങ്ങൾ മാത്രമല്ല, മറ്റുള്ളവയും പരിവർത്തനം ചെയ്യാൻ കഴിയും, ഉദാഹരണത്തിന്, ഡയറക്ടറികളുടെയും പ്രമാണങ്ങളുടെയും ഘടകങ്ങൾ.

SokrLP, SokrL, SokrP

ഈ ഫംഗ്‌ഷനുകളുടെ ഇൻപുട്ട് പാരാമീറ്ററുകൾ സ്ട്രിംഗ് തരത്തിൻ്റെ ഒരു വേരിയബിളാണ്. ഫംഗ്‌ഷനുകൾ അപ്രധാനമായ പ്രതീകങ്ങൾ നീക്കംചെയ്യുന്നു (സ്‌പെയ്‌സുകൾ, ക്യാരേജ് റിട്ടേണുകൾ മുതലായവ): ഇടത്, വലത് വശങ്ങളിൽ നിന്ന്, ഇടത് വശത്ത് നിന്ന് മാത്രം, വലതുവശത്ത് നിന്ന് മാത്രം.

ചുരുക്കെഴുത്ത്("ഇരുവശത്തുമുള്ള സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യപ്പെടും ") // "ഇരുവശത്തും സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യപ്പെടും"
ചുരുക്കെഴുത്ത്("ഇരുവശത്തുമുള്ള സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യപ്പെടും") // "ഇടതുവശത്തുള്ള സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യപ്പെടും"
ചുരുക്കെഴുത്ത്("ഇരുവശങ്ങളിലുമുള്ള സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യപ്പെടും") // "വലതുവശത്തുള്ള സ്‌പെയ്‌സുകൾ നീക്കം ചെയ്യപ്പെടും"

ലിയോ, വലത്, ഇടത്തരം

ഒരു സ്ട്രിംഗിൻ്റെ ഭാഗം ട്രിം ചെയ്യാൻ ഈ പ്രവർത്തനങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു. "ഇടത്()" ഫംഗ്‌ഷൻ ഒരു സ്‌ട്രിംഗിൻ്റെ ഭാഗം അതിൻ്റെ ഇടത് വശത്ത് നിന്ന് നിർദ്ദിഷ്‌ട ദൈർഘ്യത്തിൽ തിരികെ നൽകും. "വലത്()" ഫംഗ്‌ഷൻ സമാനമാണ്, എന്നാൽ വലതുവശത്ത് നിന്ന് വിളവെടുക്കുന്നു. "Avg()" ഫംഗ്ഷൻ, വരി തിരഞ്ഞെടുക്കുന്ന പ്രതീകത്തിൻ്റെ എണ്ണവും അതിൻ്റെ ദൈർഘ്യവും വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ലെവ്("സ്ട്രിംഗ് വേരിയബിൾ", 4) // "Str" തിരികെ നൽകുന്നു
വലത് ("സ്ട്രിംഗ് വേരിയബിൾ", 7) // "വേരിയബിൾ" നൽകുന്നു
മീഡിയം("സ്ട്രിംഗ് വേരിയബിൾ", 2, 5) // "ട്രോക്കോ" നൽകുന്നു

ദൃഢത

ഒരു സ്ട്രിംഗ് വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ എണ്ണം ഫംഗ്ഷൻ നിർണ്ണയിക്കുന്നു.

ദൈർഘ്യം("വാക്ക്") // നിർവ്വഹണത്തിൻ്റെ ഫലം നമ്പർ 5 ആയിരിക്കും

കണ്ടെത്തുക

ഒരു സ്ട്രിംഗ് വേരിയബിളിൽ ഒരു സ്ട്രിംഗിൻ്റെ ഭാഗം തിരയുന്നത് ഫംഗ്ഷൻ സാധ്യമാക്കുന്നു. കണ്ടെത്തിയ സ്ട്രിംഗിൻ്റെ തുടക്കത്തിൻ്റെ സ്ഥാനം കാണിക്കുന്ന ഒരു സംഖ്യയായിരിക്കും റിട്ടേൺ മൂല്യം. പൊരുത്തമൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ, പൂജ്യം തിരികെ നൽകും.

തിരയൽ കേസ് സെൻസിറ്റീവ് ആണെന്നത് ശ്രദ്ധിക്കുക. യഥാർത്ഥ സ്‌ട്രിംഗിൽ സെർച്ച് സബ്‌സ്‌ട്രിംഗിൻ്റെ ഒന്നിലധികം സംഭവങ്ങൾ ഉണ്ടെങ്കിൽ, ഫംഗ്‌ഷൻ ആദ്യ സംഭവത്തിൻ്റെ ആരംഭം തിരികെ നൽകും.

കണ്ടെത്തുക("ഒന്ന്, രണ്ട്, ഒന്ന്, രണ്ട്, മൂന്ന്", "രണ്ട്") // ഫംഗ്‌ഷൻ 6 എന്ന നമ്പർ നൽകും

EmptyString

ഈ ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നത് ഒരു സ്ട്രിംഗ് ശൂന്യമാണോ എന്ന് നിർണ്ണയിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. സ്‌പേസ്, ക്യാരേജ് റിട്ടേൺ, മറ്റുള്ളവ തുടങ്ങിയ ചെറിയ പ്രതീകങ്ങൾ കണക്കിലെടുക്കുന്നില്ല.

EmptyString("Pupkin Vasily Ivanovich") // ഫംഗ്‌ഷൻ മൂല്യം തെറ്റായി നൽകും
EmptyString(" ") // ഫംഗ്‌ഷൻ True എന്ന മൂല്യം നൽകും

VReg, NReg, TReg

സ്ട്രിംഗ് വേരിയബിളുകൾ താരതമ്യം ചെയ്യുമ്പോഴും പരിവർത്തനം ചെയ്യുമ്പോഴും ഈ പ്രവർത്തനങ്ങൾ വളരെ ഉപയോഗപ്രദമാണ്. "Vreg()" യഥാർത്ഥ സ്ട്രിംഗ് വലിയക്ഷരത്തിലും "HPreg()" ചെറിയക്ഷരത്തിലും നൽകും, കൂടാതെ "TReg()" അത് ഫോർമാറ്റ് ചെയ്യും, അങ്ങനെ ഓരോ വ്യക്തിഗത പദത്തിൻ്റെയും ആദ്യ പ്രതീകം വലിയക്ഷരമാക്കുകയും തുടർന്നുള്ള എല്ലാ പ്രതീകങ്ങളും വലിയക്ഷരമാക്കുകയും ചെയ്യും.

VReg("ജനറൽ ഡയറക്ടർ") // റിട്ടേൺ മൂല്യം - "സിഇഒ ഡയറക്ടർ"
NReg(“CEO DIRECTOR”) // റിട്ടേൺ മൂല്യം – “CEO”
TREG(“CEO DIRECTOR”) // റിട്ടേൺ മൂല്യം – “ജനറൽ ഡയറക്ടർ”

പേജ് മാറ്റിസ്ഥാപിക്കുക

ഈ ഫംഗ്‌ഷൻ ടെക്‌സ്‌റ്റ് എഡിറ്ററുകളിൽ മാറ്റിസ്ഥാപിക്കുന്നതിന് സമാനമാണ്. സ്ട്രിംഗ് വേരിയബിളുകളിൽ ഒരു പ്രതീകം അല്ലെങ്കിൽ പ്രതീകങ്ങളുടെ കൂട്ടം മറ്റൊന്ന് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

StrReplace("ചുവപ്പ്, വെള്ള, മഞ്ഞ", ","", ";") // തിരികെ "ചുവപ്പ്; വെള്ള; മഞ്ഞ"

StrNumberLines

ഒരു ടെക്സ്റ്റ് വേരിയബിളിൽ ക്യാരേജ് റിട്ടേണുകൾ കൊണ്ട് വേർതിരിച്ച വരികളുടെ എണ്ണം നിർണ്ണയിക്കാൻ ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ചുവടെയുള്ള ഉദാഹരണത്തിലെ ലൂപ്പ് മൂന്ന് റൗണ്ടുകളിലൂടെ കടന്നുപോകും, കാരണം LineNumberRow ഫംഗ്‌ഷൻ മൂല്യം 3 നൽകുന്നു:

സ്ട്രിംഗുകളുടെ എണ്ണം പ്രകാരം ind = 1 ("Line1" + ചിഹ്നങ്ങൾ.PS + "Line2" + ചിഹ്നങ്ങൾ.PS + "Line3") സൈക്കിൾ
<тело цикла>
എൻഡ് സൈക്കിൾ;

StrGetString

ഈ ഫംഗ്ഷൻ മുമ്പത്തേതിന് സമാനമായി മൾട്ടിലൈൻ ടെക്സ്റ്റുമായി പ്രവർത്തിക്കുന്നു. ഒരു ടെക്സ്റ്റ് വേരിയബിളിൽ നിന്ന് ഒരു പ്രത്യേക സ്ട്രിംഗ് ലഭിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

StrGetString("String1" + പ്രതീകങ്ങൾ.PS + "String2" + പ്രതീകങ്ങൾ.PS + "String3", 2) // "String2" തിരികെ നൽകുക

പേജ് നമ്പർ സംഭവങ്ങൾ

തിരയൽ സ്ട്രിംഗിലെ ഒരു പ്രതീകത്തിൻ്റെയോ സബ്‌സ്‌ട്രിംഗിൻ്റെയോ സംഭവങ്ങളുടെ എണ്ണം ഫംഗ്ഷൻ കണക്കാക്കുന്നു.

StrNumberAttachments("a;b;c;d; ", ";") // ഫംഗ്‌ഷൻ നമ്പർ 4 നൽകും

ചിഹ്നവും ചിഹ്ന കോഡും

യൂണികോഡ് എൻകോഡിംഗിൽ അതിൻ്റെ കോഡ് ഉപയോഗിച്ച് ഒരു പ്രതീകം നേടാനും ഈ കോഡ് പ്രതീകം തന്നെ നിർണ്ണയിക്കാനും ഈ പ്രവർത്തനങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു.

SymbolCode("A") // ഫംഗ്‌ഷൻ 1,040 എന്ന സംഖ്യ നൽകും
ക്യാരക്ടർ കോഡ്(1040) // ഫംഗ്‌ഷൻ "എ" തിരികെ നൽകും

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ സാധാരണ ജോലികൾ

സംയോജിപ്പിക്കുന്ന സ്ട്രിംഗുകൾ

നിരവധി സ്ട്രിംഗുകൾ സംയോജിപ്പിക്കാൻ (കോൺകാറ്റനേഷൻ നടത്താൻ), കൂട്ടിച്ചേർക്കൽ ഓപ്പറേറ്റർ ഉപയോഗിച്ചാൽ മതി.

“ലൈൻ 1″ + “ലൈൻ 2″ //രണ്ട് വരികൾ ചേർക്കുന്നതിൻ്റെ ഫലം “ലൈൻ 1 ലൈൻ 2” ആയിരിക്കും

തരം പരിവർത്തനം

ഒരു തരം ഒരു സ്ട്രിംഗ് ആക്കി മാറ്റുന്നതിന്, ഉദാഹരണത്തിന്, ഒരു ഡയറക്‌ടറി ഘടകത്തിലേക്കുള്ള ലിങ്ക്, ഒരു നമ്പർ മുതലായവ, "String()" ഫംഗ്‌ഷൻ ഉപയോഗിച്ചാൽ മതി. “ScrLP()” പോലുള്ള ഫംഗ്‌ഷനുകൾ വേരിയബിളുകളെ ഒരു സ്‌ട്രിംഗാക്കി മാറ്റും, എന്നാൽ ഉടൻ തന്നെ അപ്രധാനമായ പ്രതീകങ്ങൾ മുറിച്ചുമാറ്റും.

സ്ട്രിംഗ്(1000) // "1,000" നൽകുന്നു

ഒരു സംഖ്യയെ ഒരു സ്‌ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുമ്പോൾ, ആയിരത്തെ വേർതിരിക്കുന്ന ഒരു സ്‌പെയ്‌സ് പ്രോഗ്രാം സ്വയമേവ ചേർത്തുവെന്നത് ശ്രദ്ധിക്കുക. ഇത് ഒഴിവാക്കാൻ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന നിർമ്മാണങ്ങൾ ഉപയോഗിക്കാം:

StrReplace(String(1000),Characters.NPP,"") // "1000" നൽകുന്നു

സ്ട്രിംഗ്(ഫോർമാറ്റ്(1000,"HG=")) // "1000" നൽകുന്നു

ഒരു സ്ട്രിംഗിലെ ഉദ്ധരണികൾ

ഒരു സ്ട്രിംഗ് വേരിയബിളിൽ ഉദ്ധരണി അടയാളങ്ങൾ വ്യക്തമാക്കേണ്ടതിൻ്റെ ആവശ്യകത നിങ്ങൾ പലപ്പോഴും കൈകാര്യം ചെയ്യേണ്ടിവരും. ഇത് കോൺഫിഗറേറ്ററിൽ എഴുതിയ അഭ്യർത്ഥന വാചകം അല്ലെങ്കിൽ ഒരു വേരിയബിൾ ആകാം. ഈ പ്രശ്നം പരിഹരിക്കാൻ, നിങ്ങൾ രണ്ട് ഉദ്ധരണി ചിഹ്നങ്ങൾ സജ്ജമാക്കിയാൽ മതി.

ഹെഡർ = സ്ട്രിംഗ്("കൊമ്പുകളും കുളമ്പുകളും LLC - അത് ഞങ്ങളാണ്!") // "കൊമ്പുകളും കുളമ്പുകളും LLC - അത് ഞങ്ങളാണ്!"

മൾട്ടി-ലൈൻ, ലൈൻ ബ്രേക്ക്

മൾട്ടി-ലൈൻ ടെക്‌സ്‌റ്റ് സൃഷ്‌ടിക്കുന്നതിന്, അതിൽ ലൈൻ ബ്രേക്കുകൾ (Symbols.PS) ചേർക്കുക.

MultilineText = "ആദ്യ വരി" + ചിഹ്നങ്ങൾ.PS + "രണ്ടാം വരി"

ഇടങ്ങൾ എങ്ങനെ നീക്കംചെയ്യാം

വലത്തോട്ടോ ഇടത്തോട്ടോ ഉള്ള സ്‌പെയ്‌സുകൾ നീക്കംചെയ്യുന്നതിന്, നിങ്ങൾക്ക് “ScrAP()” (അതുപോലെ “ScrL()”, “ScrP()” എന്നീ ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം:

StringNoSpaces = ചുരുക്കെഴുത്ത്(" പല അക്ഷരങ്ങൾ ") // ഫംഗ്ഷൻ "നിരവധി അക്ഷരങ്ങൾ" എന്ന മൂല്യം നൽകും

ഒരു സംഖ്യയെ ഒരു സ്‌ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്‌ത ശേഷം, നിങ്ങൾ നോൺ-ബ്രേക്കിംഗ് സ്‌പെയ്‌സ് നീക്കം ചെയ്യണമെങ്കിൽ, ഇനിപ്പറയുന്ന നിർമ്മാണം ഉപയോഗിക്കുക:

StringNoSpaces = StrReplace(String(99999),Characters.NPP,"") // "99999" നൽകുന്നു

പ്രോഗ്രാമർമാർ പലപ്പോഴും ഇനിപ്പറയുന്ന നിർമ്മാണം ഉപയോഗിക്കുന്നു, ഇത് ഒരു ടെക്സ്റ്റ് വേരിയബിളിലെ എല്ലാ ഇടങ്ങളും നീക്കം ചെയ്യാനോ മറ്റൊരു പ്രതീകം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാനോ നിങ്ങളെ അനുവദിക്കുന്നു: