പവർഷെൽ ഉപയോഗിച്ച് 7-9 ഗ്രേഡുകളിലെ സ്കൂൾ കുട്ടികൾക്കുള്ള ലളിതമായ ടെലിഗ്രാം ബോട്ടിനുള്ള ടെംപ്ലേറ്റ്

ഒരു സുഹൃത്തുമായുള്ള സംഭാഷണത്തിനിടയിൽ, അവരുടെ സ്കൂളിലെ 8-10 ഗ്രേഡുകളിലെ കുട്ടികളെ പ്രോഗ്രാമിംഗ് പഠിപ്പിക്കുന്നില്ലെന്ന് ഞാൻ പെട്ടെന്ന് മനസ്സിലാക്കി. വേഡ്, എക്സൽ, എല്ലാം. എക്സലിനായി ലോഗോയില്ല, പാസ്കൽ പോലുമില്ല, വിബിഎ പോലുമില്ല.

ഞാൻ വളരെ ആശ്ചര്യപ്പെട്ടു, ഇന്റർനെറ്റ് തുറന്ന് വായിക്കാൻ തുടങ്ങി -
ഒരു സ്പെഷ്യലൈസ്ഡ് സ്കൂളിന്റെ ചുമതലകളിലൊന്ന് അതിന്റെ വികസനത്തിലും ജീവിതരീതിയിലും വിവര സമൂഹത്തിന്റെ വ്യവസ്ഥകൾ പാലിക്കുന്ന ഒരു പുതിയ തലമുറയുടെ വിദ്യാഭ്യാസം പ്രോത്സാഹിപ്പിക്കുക എന്നതാണ്.
പാസ്കൽ പ്രോഗ്രാമിംഗ് ഭാഷയുടെ അടിസ്ഥാന ഘടനകളെക്കുറിച്ചുള്ള അറിവ് പ്രായോഗികമായി ഏകീകരിക്കാൻ ഈ കോഴ്സ് വിദ്യാർത്ഥികളെ അനുവദിക്കും. (2017 ലെ ചില ജിംനേഷ്യത്തിന്റെ പ്രോഗ്രാമിൽ നിന്ന്)

അവസാനം, ഞാൻ കുറച്ച് മണിക്കൂർ ചിലവഴിക്കാനും "സ്കൂൾ കുട്ടികൾക്കായി ഒരു ലളിതമായ ബോട്ട് എങ്ങനെ സൃഷ്ടിക്കാം" എന്നതിന്റെ ഒരു ഉദാഹരണം വരയ്ക്കാനും തീരുമാനിച്ചു.

പവർഷെല്ലിൽ മറ്റൊരു ലളിതമായ ബോട്ട് എങ്ങനെ എഴുതാമെന്നും വെബ്‌ഹുക്ക്, വൈറ്റ് ഐപികൾ, ഡെഡിക്കേറ്റഡ് സെർവറുകൾ, ക്ലൗഡിൽ വിന്യസിച്ചിരിക്കുന്ന വെർച്വൽ മെഷീനുകൾ എന്നിവയില്ലാതെ എങ്ങനെ പ്രവർത്തിക്കാമെന്നും കട്ടിന് ചുവടെയുണ്ട് - സാധാരണ വിൻഡോസ് ഉള്ള ഒരു സാധാരണ ഹോം പിസിയിൽ.

TLDR: വ്യാകരണപരവും വസ്തുതാപരവുമായ പിശകുകൾ, വായിക്കാൻ ഒന്നുമില്ല, നർമ്മവുമില്ല, ചിത്രവുമില്ലാത്ത മറ്റൊരു വിരസമായ ലേഖനം.

ലേഖനത്തിൽ പുതിയതായി ഒന്നുമില്ല, മുമ്പ് എഴുതിയ മിക്കവാറും എല്ലാം ഹബ്രെയിൽ ഉണ്ട്, ഉദാഹരണത്തിന് ലേഖനങ്ങളിൽ നിർദ്ദേശങ്ങൾ: ടെലിഗ്രാമിൽ ബോട്ടുകൾ എങ്ങനെ സൃഷ്ടിക്കാം и സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർക്കുള്ള ടെലിഗ്രാം ബോട്ട്.
മാത്രമല്ല, ഓരോ തവണയും വിദ്യാഭ്യാസ സാഹിത്യത്തെ പരാമർശിക്കാതിരിക്കാൻ ലേഖനം ബോധപൂർവം അനാവശ്യമാണ്. Gang 4, PowerShell Deep Dives അല്ലെങ്കിൽ AWS നന്നായി ആർക്കിടെക്റ്റഡ് ഫ്രെയിംവർക്കിന്റെ 5 തൂണുകൾ എന്നിവയെക്കുറിച്ച് പരാമർശങ്ങളൊന്നുമില്ല.

ഒരു മുഖവുരയ്ക്ക് പകരം, നിങ്ങൾക്ക് ഒഴിവാക്കാം

ഒഴിവാക്കാൻ മടിക്കേണ്ടതില്ല2006-ൽ, അന്നത്തെ വിൻഡോസ് എക്സ്പി, വിസ്റ്റ, സെർവർ 1.0 എന്നിവയ്ക്കായി പവർഷെൽ 2003 മൈക്രോസോഫ്റ്റ് പുറത്തിറക്കി. ചില വഴികളിൽ, ഇത് cmdbat സ്ക്രിപ്റ്റുകൾ, vb സ്ക്രിപ്റ്റുകൾ, വിൻഡോസ് സ്ക്രിപ്റ്റ് ഹോസ്റ്റ്, JScript എന്നിവയെ മാറ്റിസ്ഥാപിച്ചു.

ലൂപ്പുകൾ, ക്ലാസുകൾ, ഫംഗ്‌ഷനുകൾ, MS GUI കോളുകൾ എന്നിവ ഉണ്ടായിരുന്നിട്ടും, ഇപ്പോഴും ഉപയോഗിച്ചിരുന്ന ഡെൽഫി (അല്ലെങ്കിൽ പഴയത്) എന്നതിനുപകരം, ലോഗോ ഓപ്ഷനുകൾക്ക് ശേഷമുള്ള അടുത്ത ഘട്ടമായി പവർഷെല്ലിനെ മാത്രമേ കണക്കാക്കാൻ കഴിയൂ. Git സംയോജനം അങ്ങനെ പോകുന്നു.

പവർഷെൽ താരതമ്യേന അപൂർവമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ; പവർഷെൽ കോർ, വിഎംവെയർ വിസ്ഫിയർ പവർസിഎൽഐ, അസൂർ പവർഷെൽ, എംഎസ് എക്സ്ചേഞ്ച്, ഡിസൈർഡ് സ്റ്റേറ്റ് കോൺഫിഗറേഷൻ എന്നിവയുടെ രൂപത്തിൽ മാത്രമേ നിങ്ങൾക്ക് ഇത് നേരിടാൻ കഴിയൂ. പവർഷെൽ വെബ് ആക്സസ് കൂടാതെ ഒരു ഡസനോളം അപൂർവ്വമായി ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകളും പ്രവർത്തനങ്ങളും. ഒരുപക്ഷേ, മോചനത്തോടെ അദ്ദേഹത്തിന് രണ്ടാമത്തെ കാറ്റ് ലഭിച്ചേക്കാം WSL2, എന്നാൽ അത് കൃത്യമായി അല്ല.

പവർഷെല്ലിന് മൂന്ന് വലിയ ഗുണങ്ങളുണ്ട്:

1. ഇത് താരതമ്യേന ലളിതമാണ്, അതിനെക്കുറിച്ച് ധാരാളം സാഹിത്യങ്ങളും ഉദാഹരണങ്ങളും ഉണ്ട്, റഷ്യൻ ഭാഷയിൽ പോലും, ഉദാഹരണത്തിന്, ഫോറെച്ചിനെക്കുറിച്ചുള്ള ഒരു ലേഖനം - പുസ്തകത്തിൽ നിന്ന് ആഴത്തിൽ പവർഷെൽ - വ്യത്യാസത്തെക്കുറിച്ച് () കൂടാതെ {}
2. അവൻ എഡിറ്ററുടെ കൂടെ പോകുന്നു ISE, വിൻഡോസിനൊപ്പം ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഒരുതരം ഡീബഗ്ഗർ പോലും അവിടെയുണ്ട്.
3. അതിൽ നിന്ന് വിളിക്കാൻ എളുപ്പമാണ് ഒരു ഗ്രാഫിക്കൽ ഇന്റർഫേസ് നിർമ്മിക്കുന്നതിനുള്ള ഘടകങ്ങൾ.

0. തയ്യാറാക്കൽ.

ഞങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

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

ലേഖനങ്ങൾ തുറന്ന് വായിച്ചു - നിർദ്ദേശങ്ങൾ: ടെലിഗ്രാമിൽ ബോട്ടുകൾ എങ്ങനെ സൃഷ്ടിക്കാം и സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർക്കുള്ള ടെലിഗ്രാം ബോട്ട്

1. നമുക്ക് മറ്റൊരു ടെസ്റ്റ് ബോട്ട് ഉണ്ടാക്കാം.

എല്ലാവർക്കും ഇത് ഇതിനകം അറിയാവുന്നതും ഇതിനകം സംഭവിച്ചതുമായതിനാൽ, നിങ്ങൾക്ക് ഇത് ഒഴിവാക്കാനും കഴിയുംമുകളിലെ ലേഖനത്തിൽ പറഞ്ഞിരിക്കുന്നതുപോലെ - ഒന്നാമതായി, ടെലിഗ്രാമിനുള്ള ഒരു ബോട്ട് - ഇത് ഇപ്പോഴും നിങ്ങളുടെ ഭാഗത്ത് പ്രവർത്തിക്കുന്ന ഒരു ആപ്ലിക്കേഷനാണ്, കൂടാതെ ടെലിഗ്രാം ബോട്ട് API-ലേക്ക് അഭ്യർത്ഥനകൾ നടത്തുന്നു. കൂടാതെ, API വ്യക്തമാണ് - പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് ബോട്ട് ഒരു നിർദ്ദിഷ്ട URL ആക്സസ് ചെയ്യുന്നു, കൂടാതെ ഒരു JSON ഒബ്ജക്റ്റ് ഉപയോഗിച്ച് ടെലിഗ്രാം പ്രതികരിക്കുന്നു.

ബന്ധപ്പെട്ട പ്രശ്നങ്ങൾ: ഏതെങ്കിലും അജ്ഞാതമായ രീതിയിൽ നിങ്ങൾ ഒരു JSON ഒബ്‌ജക്റ്റിൽ നിന്ന് കുറച്ച് കോഡ് എടുത്ത് എങ്ങനെയെങ്കിലും അത് നിർവ്വഹണത്തിനായി അയച്ചാൽ (ഉദ്ദേശത്തോടെയല്ല), കോഡ് നിങ്ങൾക്കായി എക്സിക്യൂട്ട് ചെയ്യും.

സൃഷ്‌ടിക്കൽ പ്രക്രിയ മുകളിലെ രണ്ട് ലേഖനങ്ങളിൽ വിവരിച്ചിരിക്കുന്നു, പക്ഷേ ഞാൻ ആവർത്തിക്കുന്നു: ഒരു ടെലിഗ്രാമിൽ ഞങ്ങൾ കോൺടാക്റ്റുകൾ തുറക്കുന്നു, @botfather-നെ തിരയുക, അവനോട് പറയുക /newbot, ഒരു ബോട്ട് Botfortest12344321 സൃഷ്ടിക്കുക, അതിനെ Mynext1234bot എന്ന് വിളിക്കുക, കൂടാതെ ഒരു അദ്വിതീയ കീ ഉപയോഗിച്ച് ഒരു സന്ദേശം സ്വീകരിക്കുക. ഫോം 1234544311:AbcDefNNNNNNNNNNNNNN

താക്കോൽ ശ്രദ്ധിക്കുക, അത് വിട്ടുകൊടുക്കരുത്!

അപ്പോൾ നിങ്ങൾക്ക് ബോട്ട് ക്രമീകരിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ഇത് ഗ്രൂപ്പുകളിലേക്ക് ചേർക്കുന്നത് നിരോധിക്കുക, എന്നാൽ ആദ്യ ഘട്ടങ്ങളിൽ ഇത് ആവശ്യമില്ല.

നമുക്ക് ബോട്ട്ഫാദറിനോട് “/mybot” എന്ന് ചോദിക്കാം, ഞങ്ങൾക്ക് എന്തെങ്കിലും ഇഷ്ടപ്പെട്ടില്ലെങ്കിൽ ക്രമീകരണങ്ങൾ ക്രമീകരിക്കാം.

നമുക്ക് കോൺടാക്റ്റുകൾ വീണ്ടും തുറക്കാം, അവിടെ @Botfortest12344321 കണ്ടെത്താം (@ ഉപയോഗിച്ച് തിരയൽ ആരംഭിക്കേണ്ടത് നിർബന്ധമാണ്), "ആരംഭിക്കുക" ക്ലിക്ക് ചെയ്ത് "/Glory to the robots" എന്ന ബോട്ടിലേക്ക് എഴുതുക. / ചിഹ്നം ആവശ്യമാണ്, ഉദ്ധരണികൾ ആവശ്യമില്ല.
ബോട്ട്, തീർച്ചയായും, ഒന്നിനും ഉത്തരം നൽകില്ല.

ബോട്ട് സൃഷ്ടിച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിച്ച് അത് തുറക്കാം.

api.telegram.org/bot1234544311:AbcDefNNNNNNNNNNNNN/getMe
ഇവിടെ 1234544311:AbcDefNNNNNNNNNNNNNN എന്നത് മുമ്പ് ലഭിച്ച കീയാണ്,
എന്ന പോലെ ഒരു ലൈൻ നേടുക
{"ശരി":ശരി,"ഫലം":{""}}

നമുക്ക് ആദ്യത്തെ രഹസ്യ വാക്യം (ടോക്കൺ) ഉണ്ട്. ഇപ്പോൾ നമുക്ക് രണ്ടാമത്തെ രഹസ്യ നമ്പർ കണ്ടെത്തേണ്ടതുണ്ട് - ബോട്ടുമായുള്ള ചാറ്റിന്റെ ഐഡി. ഓരോ ചാറ്റ്, ഗ്രൂപ്പ് മുതലായവയും വ്യക്തിഗതമാണ് കൂടാതെ അതിന്റേതായ നമ്പറുമുണ്ട് (ചിലപ്പോൾ മൈനസോടെ - ഓപ്പൺ ഗ്രൂപ്പുകൾക്ക്). ഈ നമ്പർ കണ്ടെത്തുന്നതിന്, ഞങ്ങൾ ബ്രൗസറിൽ അഭ്യർത്ഥിക്കേണ്ടതുണ്ട് (വാസ്തവത്തിൽ, ബ്രൗസറിൽ ഇത് ആവശ്യമില്ല, എന്നാൽ കൂടുതൽ നന്നായി മനസ്സിലാക്കാൻ നിങ്ങൾക്ക് ഇത് ആരംഭിക്കാം) വിലാസം (ഇവിടെ 1234544311:NNNNNNNNNN നിങ്ങളുടെ ടോക്കൺ ആണ്

https://api.telegram.org/bot1234544311:NNNNNNNNN/getUpdates

പോലെ ഒരു പ്രതികരണം നേടുക

{"ok":true,"result":[{"update_id":...,... സല്ലാപം":{"id":123456789

ഞങ്ങൾക്ക് chat_id ആവശ്യമാണ്.

നമുക്ക് ചാറ്റിലേക്ക് സ്വമേധയാ എഴുതാനാകുമോ എന്ന് പരിശോധിക്കാം: ബ്രൗസറിൽ നിന്ന് വിലാസത്തിലേക്ക് വിളിക്കുക

https://api.telegram.org/botваштокен/sendMessage?chat_id=123456789&text="Life is directed motion"

നിങ്ങളുടെ ചാറ്റിൽ ഒരു ബോട്ടിൽ നിന്ന് നിങ്ങൾക്ക് ഒരു സന്ദേശം ലഭിക്കുകയാണെങ്കിൽ, ശരി, നിങ്ങൾ അടുത്ത ഘട്ടത്തിലേക്ക് പോകുക.

ഈ രീതിയിൽ (ബ്രൗസർ വഴി) നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ലിങ്ക് ജനറേഷനിൽ പ്രശ്‌നങ്ങളുണ്ടോ, അല്ലെങ്കിൽ എന്തെങ്കിലും എവിടെയെങ്കിലും മറച്ചിട്ട് പ്രവർത്തിക്കുന്നില്ലേ എന്ന് പരിശോധിക്കാം.

വായന തുടരുന്നതിന് മുമ്പ് നിങ്ങൾ അറിയേണ്ടത്

ടെലിഗ്രാമിന് നിരവധി തരം ഗ്രൂപ്പ് ചാറ്റുകൾ ഉണ്ട് (തുറന്നതും അടച്ചതും). ഈ ചാറ്റുകൾക്ക്, ചില ഫംഗ്‌ഷനുകൾ (ഉദാഹരണത്തിന്, ഐഡി) വ്യത്യസ്തമാണ്, ഇത് ചിലപ്പോൾ ചില പ്രശ്‌നങ്ങൾ ഉണ്ടാക്കുന്നു.

ഇത് 2019 അവസാനമാണെന്ന് നമുക്ക് അനുമാനിക്കാം, നമ്മുടെ കാലത്തെ നായകൻ പോലും, അറിയപ്പെടുന്ന മാൻ-ഓർക്കസ്ട്ര (അഡ്മിനിസ്‌ട്രേറ്റർ, വക്കീൽ, ഇൻഫർമേഷൻ സെക്യൂരിറ്റി സ്പെഷ്യലിസ്റ്റ്, പ്രോഗ്രാമർ, പ്രായോഗികമായി MVP) Evgeniy V. $i വേരിയബിളിനെ ഒരു ശ്രേണിയിൽ നിന്ന് വേർതിരിക്കുന്നു, ലൂപ്പുകളിൽ വൈദഗ്ദ്ധ്യം നേടിയിട്ടുണ്ട്, അടുത്ത രണ്ട് വർഷത്തിനുള്ളിൽ ചോക്കലേറ്റ് മാസ്റ്റർ ചെയ്യും നോക്കുക, തുടർന്ന് PowerShell ഉപയോഗിച്ച് സമാന്തര പ്രോസസ്സിംഗ് и ഓരോ വസ്തുവിനും സമാന്തരമായി അതു വരും.

1. ഞങ്ങളുടെ ബോട്ട് എന്തുചെയ്യുമെന്ന് ഞങ്ങൾ ചിന്തിക്കുന്നു

എനിക്ക് ആശയങ്ങളൊന്നുമില്ല, എനിക്ക് ചിന്തിക്കേണ്ടി വന്നു. ഞാൻ ഇതിനകം ഒരു ബോട്ട്-നോട്ട്ബുക്ക് എഴുതിയിട്ടുണ്ട്. "എവിടെയെങ്കിലും എന്തെങ്കിലും അയയ്ക്കുന്ന" ബോട്ട് നിർമ്മിക്കാൻ ഞാൻ ആഗ്രഹിച്ചില്ല. Azure-ലേക്ക് കണക്റ്റുചെയ്യാൻ നിങ്ങൾക്ക് ഒരു ക്രെഡിറ്റ് കാർഡ് ആവശ്യമാണ്, എന്നാൽ വിദ്യാർത്ഥിക്ക് അത് എവിടെ നിന്ന് ലഭിക്കും? എല്ലാം അത്ര മോശമല്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്: പ്രധാന മേഘങ്ങൾ സൗജന്യമായി ചില പരീക്ഷണ കാലയളവ് നൽകുന്നു (എന്നാൽ നിങ്ങൾക്ക് ഇപ്പോഴും ഒരു ക്രെഡിറ്റ് കാർഡ് നമ്പർ ആവശ്യമാണ് - അതിൽ നിന്ന് ഒരു ഡോളർ ഡെബിറ്റ് ചെയ്യപ്പെടുമെന്ന് തോന്നുന്നു. എങ്കിൽ ഞാൻ ഓർക്കുന്നില്ല അത് പിന്നീട് തിരിച്ചയച്ചു.)

AI ML ഇല്ലാതെ ഒരു ബോട്ട്-പാവം-കവി-നെയ്ത്തുകാരൻ ഉണ്ടാക്കുന്നത് അത്ര രസകരമല്ല.

നിഘണ്ടുവിൽ നിന്നുള്ള ഇംഗ്ലീഷ് വാക്കുകൾ എന്നെ ഓർമ്മിപ്പിക്കുന്ന (അല്ലെങ്കിൽ എന്നെയല്ല) ഒരു ബോട്ട് നിർമ്മിക്കാൻ ഞാൻ തീരുമാനിച്ചു.
ഡാറ്റാബേസുമായി ഇടപഴകുന്നത് ഒഴിവാക്കാൻ, നിഘണ്ടു ഒരു ടെക്സ്റ്റ് ഫയലിൽ സൂക്ഷിക്കുകയും സ്വമേധയാ അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യും.
ഈ സാഹചര്യത്തിൽ, ജോലിയുടെ അടിസ്ഥാനകാര്യങ്ങൾ കാണിക്കുക എന്നതാണ് ചുമതല, കുറഞ്ഞത് ഭാഗികമായി പൂർത്തിയായ ഉൽപ്പന്നം ഉണ്ടാക്കരുത്.

2. ആദ്യമായി എന്ത്, എങ്ങനെ പരീക്ഷിക്കുന്നു

നമുക്ക് C:poshtranslate എന്ന ഫോൾഡർ ഉണ്ടാക്കാം
ആദ്യം, നമുക്ക് ഏതുതരം പവർഷെൽ ഉണ്ടെന്ന് നോക്കാം, നമുക്ക് സ്റ്റാർട്ട്-റൺ വഴി ISE സമാരംഭിക്കാം
പവർഷെൽ
അല്ലെങ്കിൽ ഇൻസ്റ്റാൾ ചെയ്ത പ്രോഗ്രാമുകളിൽ Powershell ISE കണ്ടെത്തുക.
സമാരംഭിച്ചതിന് ശേഷം, സാധാരണ പരിചിതമായ "ചില തരത്തിലുള്ള എഡിറ്റർ" തുറക്കും; ടെക്സ്റ്റ് ഫീൽഡ് ഇല്ലെങ്കിൽ, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും "ഫയൽ - പുതിയത് സൃഷ്ടിക്കുക" ക്ലിക്ക് ചെയ്യാം.

നമുക്ക് പവർഷെല്ലിന്റെ പതിപ്പ് നോക്കാം - ടെക്സ്റ്റ് ഫീൽഡിൽ എഴുതുക:

get-host 

കൂടാതെ F5 അമർത്തുക.

പവർഷെൽ സംരക്ഷിക്കാൻ ഓഫർ ചെയ്യും - "നിങ്ങൾ പ്രവർത്തിപ്പിക്കാൻ പോകുന്ന സ്‌ക്രിപ്റ്റ് സംരക്ഷിക്കപ്പെടും.", ഞങ്ങൾ സമ്മതിക്കുകയും പവർഷെല്ലിൽ നിന്ന് ഫയൽ സംരക്ഷിക്കുകയും C: poshtranslate myfirstbotBT100.

സമാരംഭിച്ചതിന് ശേഷം, താഴെയുള്ള ടെക്സ്റ്റ് വിൻഡോയിൽ നമുക്ക് ഒരു ഡാറ്റ പട്ടിക ലഭിക്കും:

Name             : Windows PowerShell ISE Host
Version          : 5.1.(и так далее)

എനിക്ക് 5.1 എന്തെങ്കിലും ഉണ്ട്, അത് മതി. നിങ്ങൾക്ക് പഴയ വിൻഡോസ് 7/8 ആണെങ്കിൽ വലിയ കാര്യമൊന്നുമില്ല - എന്നിരുന്നാലും പവർഷെൽ പതിപ്പ് 5-ലേക്ക് അപ്‌ഡേറ്റ് ചെയ്യേണ്ടതുണ്ട് - ഉദാ. നിർദ്ദേശങ്ങൾ.

താഴെയുള്ള കമാൻഡ് ലൈനിൽ Get-Date എന്ന് ടൈപ്പ് ചെയ്യുക, എന്റർ അമർത്തുക, സമയം നോക്കുക, കമാൻഡ് ഉപയോഗിച്ച് റൂട്ട് ഫോൾഡറിലേക്ക് പോകുക
cd
കൂടാതെ cls കമാൻഡ് ഉപയോഗിച്ച് സ്‌ക്രീൻ മായ്‌ക്കുക (ഇല്ല, നിങ്ങൾ rm ഉപയോഗിക്കേണ്ടതില്ല)

ഇപ്പോൾ നമുക്ക് എന്താണ് പ്രവർത്തിക്കുന്നത്, എങ്ങനെയെന്ന് പരിശോധിക്കാം - നമുക്ക് കോഡ് പോലുമല്ല, രണ്ട് വരികൾ എഴുതാം, അവർ എന്താണ് ചെയ്യുന്നതെന്ന് മനസിലാക്കാൻ ശ്രമിക്കുക. # ചിഹ്നം ഉപയോഗിച്ച് ഗെറ്റ്-ഹോസ്‌റ്റ് ഉപയോഗിച്ച് ലൈൻ കമന്റ് ചെയ്‌ത് കുറച്ച് ചേർക്കുക.

# Пример шаблона бота 
# get-host
<# это пример многострочного комментария #>
$TimeNow = Get-Date
$TimeNow

(ഹബ്രെയിലെ കോഡ് ഫോർമാറ്റിംഗ് ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റിൽ രണ്ട് ഡസൻ ഓപ്ഷനുകൾ ഉണ്ട് എന്നതാണ് രസകരമായ കാര്യം - എന്നാൽ പവർഷെൽ അവിടെ ഇല്ല. ഡോസ് ഉണ്ട്. പെർൾ ഉണ്ട്.)

GUI-ൽ നിന്ന് F5 അല്ലെങ്കിൽ ">" അമർത്തി കോഡ് പ്രവർത്തിപ്പിക്കാം.

ഞങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ലഭിക്കുന്നു:

Saturday, December 8, 2019 21:00:50 PM (или что-то типа)

ഇനി നമുക്ക് ഈ രണ്ട് വരികളും രസകരമായ ചില പോയിന്റുകളും നോക്കാം, അതിനാൽ ഭാവിയിൽ ഇതിലേക്ക് മടങ്ങിവരില്ല.

പാസ്കലിൽ നിന്ന് വ്യത്യസ്തമായി (മാത്രമല്ല), ഒരു വേരിയബിളിന് ഏത് തരം നൽകണമെന്ന് പവർഷെൽ തന്നെ നിർണ്ണയിക്കുന്നു; ഇതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ ലേഖനത്തിൽ എഴുതിയിരിക്കുന്നു പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ ടൈപ്പ് ചെയ്യുന്നതിനുള്ള വിദ്യാഭ്യാസ പരിപാടി
അതിനാൽ, ഒരു $TimeNow വേരിയബിൾ സൃഷ്‌ടിച്ച് അതിന് നിലവിലെ തീയതിയുടെയും സമയത്തിന്റെയും (Get-Date) മൂല്യം നൽകുന്നതിലൂടെ, ഏത് തരത്തിലുള്ള ഡാറ്റയാണ് അവിടെ ഉണ്ടായിരിക്കുകയെന്നതിനെക്കുറിച്ച് ഞങ്ങൾ വളരെയധികം വിഷമിക്കേണ്ടതില്ല.

ശരിയാണ്, ഈ അജ്ഞത പിന്നീട് വേദനിപ്പിച്ചേക്കാം, പക്ഷേ അത് പിന്നീടുള്ളതാണ്. വാചകത്തിൽ ചുവടെ ഒരു ഉദാഹരണം ഉണ്ടാകും.
നമുക്ക് എന്താണ് കിട്ടിയതെന്ന് നോക്കാം. നമുക്ക് എക്സിക്യൂട്ട് ചെയ്യാം (കമാൻഡ് ലൈനിൽ)

$TimeNow | Get-member

മനസ്സിലാക്കാൻ കഴിയാത്ത വാചകത്തിന്റെ ഒരു പേജ് നേടുക

മനസ്സിലാക്കാൻ കഴിയാത്ത വാചക നമ്പർ 1 ന്റെ ഉദാഹരണം

PS C:> $TimeNow | Get-member
   TypeName: System.DateTime
Name                 MemberType     Definition                                                                                                                                       
----                 ----------     ----------                                                                                                                                       
Add                  <b>Method         </b>datetime Add(timespan value)  
..
DisplayHint          NoteProperty   DisplayHintType DisplayHint=DateTime                                                                                                             
Date                 <b>Property       </b>datetime Date {get;}                                                                                                                             
Year                 Property       int Year {get;}   
..                                                                                                                               
DateTime             ScriptProperty System.Object DateTime {get=if ((& { Set-StrictMode -Version 1; $this.DisplayHint }) -ieq  "Date")...                                         

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ടൈപ്പ് നെയിം എന്ന തരത്തിലുള്ള ഒരു വേരിയബിൾ: System.DateTime ഒരു കൂട്ടം രീതികളും (ഈ വേരിയബിൾ ഒബ്‌ജക്റ്റ് ഉപയോഗിച്ച് നമുക്ക് എന്തുചെയ്യാൻ കഴിയും എന്ന അർത്ഥത്തിൽ) ഗുണങ്ങളും ഉപയോഗിച്ച് സൃഷ്‌ടിച്ചിരിക്കുന്നു.

വിളിക്കാം $TimeNow.DayOfYear - വർഷത്തിലെ ദിവസത്തിന്റെ എണ്ണം നമുക്ക് ലഭിക്കും.
വിളിക്കാം $TimeNow.DayOfYear | Get-Member - നമുക്ക് ലഭിക്കും TypeName: System.Int32 ഒരു കൂട്ടം രീതികളും.
വിളിക്കാം $TimeNow.ToUniversalTime() - കൂടാതെ UTC-യിൽ സമയം നേടുക

ഡീബഗ്ഗർ

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

3. ടെലിഗ്രാം ബോട്ടുമായുള്ള ഇടപെടൽ മനസ്സിലാക്കൽ

തീർച്ചയായും, ബോട്ടുമായുള്ള ഇടപെടൽ, എല്ലാ ഗെറ്റ്‌പുഷുകളും മറ്റും ഉപയോഗിച്ച് ഇതിലും കൂടുതൽ സാഹിത്യങ്ങൾ എഴുതിയിട്ടുണ്ട്, പക്ഷേ സിദ്ധാന്തത്തിന്റെ പ്രശ്നം ഐച്ഛികമായി പരിഗണിക്കാം.

ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് ആവശ്യമാണ്:

• കത്തിടപാടുകളിൽ എന്തെങ്കിലും അയയ്ക്കാൻ പഠിക്കുക
• കത്തിടപാടുകളിൽ നിന്ന് എന്തെങ്കിലും നേടാൻ പഠിക്കുക

3.1 കത്തിടപാടുകളിൽ എന്തെങ്കിലും അയയ്ക്കാനും അതിൽ നിന്ന് സ്വീകരിക്കാനും പഠിക്കുന്നു

ഒരു ചെറിയ കോഡ് - ഭാഗം 3

Write-output "This is part 3"
$MyToken = "1234544311:AbcDefNNNNNNNNNNNNN"
$MyChatID = "123456789"
$MyProxy = "http://1.2.3.4:5678" 

$TimeNow = Get-Date
$TimeNow.ToUniversalTime()
$ScriptDir = Split-Path $script:MyInvocation.MyCommand.Path
$BotVersion = "BT102"

$MyText01 = "Life is directed motion - " + $TimeNow

$URL4SEND = "https://api.telegram.org/bot$MyToken/sendMessage?chat_id=$MyChatID&text=$MyText01"

Invoke-WebRequest -Uri $URL4SEND

കൂടാതെ റഷ്യൻ ഫെഡറേഷനിൽ ഈ ഘട്ടത്തിൽ ഞങ്ങൾക്ക് പിശക് ലഭിക്കുന്നു റിമോട്ട് സെർവറിലേക്ക് കണക്റ്റുചെയ്യാൻ കഴിയുന്നില്ല.

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

പ്രവർത്തനക്ഷമമായ ഒരു പ്രോക്സി കണ്ടെത്തുന്നതിനുള്ള ചുമതല വളരെ ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല - പ്രസിദ്ധീകരിച്ച മിക്ക http പ്രോക്സികളും പ്രവർത്തിക്കുന്നു. അഞ്ചാമത്തേത് എനിക്ക് വേണ്ടി പ്രവർത്തിച്ചതായി ഞാൻ കരുതുന്നു.

പ്രോക്സി ഉപയോഗിക്കുന്ന വാക്യഘടന:

Invoke-WebRequest -Uri $URL4SEND -Proxy $MyProxy

ഒരു ബോട്ടുമായുള്ള നിങ്ങളുടെ ചാറ്റിൽ നിങ്ങൾക്ക് ഒരു സന്ദേശം ലഭിക്കുകയാണെങ്കിൽ, എല്ലാം ശരിയാണ്, നിങ്ങൾക്ക് മുന്നോട്ട് പോകാം. ഇല്ലെങ്കിൽ, ഡീബഗ്ഗിംഗ് തുടരുക.

നിങ്ങളുടെ $URL4SEND സ്ട്രിംഗ് എന്തായി മാറുന്നുവെന്ന് നിങ്ങൾക്ക് കാണാനും ബ്രൗസറിൽ ഇത് അഭ്യർത്ഥിക്കാൻ ശ്രമിക്കാനും കഴിയും:

$URL4SEND2 = '"'+$URL4SEND+'"'
start chrome $URL4SEND2 

3.2 ചാറ്റിൽ "എന്തെങ്കിലും" എങ്ങനെ എഴുതാമെന്ന് ഞങ്ങൾ പഠിച്ചു, ഇപ്പോൾ അത് വായിക്കാൻ ശ്രമിക്കാം

ഇനി 4 വരികൾ കൂടി ചേർത്ത് അകത്ത് എന്താണെന്ന് നോക്കാം | അംഗമാകുക

$URLGET = "https://api.telegram.org/bot$MyToken/getUpdates"
$MyMessageGet = Invoke-WebRequest -Uri $URLGET -Method Get -Proxy $MyProxy
Write-Host "Get-Member"
$MyMessageGet | Get-Member

ഏറ്റവും രസകരമായ കാര്യം ഞങ്ങൾക്ക് നൽകിയിരിക്കുന്നു

Content           Property   string Content {get;}  
ParsedHtml        Property   mshtml.IHTMLDocument2 ParsedHtml {get;}                                    
RawContent        Property   string RawContent {get;set;}

അവയിൽ എന്താണ് ഉള്ളതെന്ന് നോക്കാം:

Write-Host "ParsedHtml"
$MyMessageGet.ParsedHtml # тут интересное
Write-Host "RawContent"
$MyMessageGet.RawContent # и тут интересное, но еще к тому же и читаемое. 
Write-Host "Content"
$MyMessageGet.Content

എല്ലാം നിങ്ങൾക്കായി പ്രവർത്തിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് ഇതുപോലുള്ള ഒരു നീണ്ട ലൈൻ ലഭിക്കും:

{"ok":true,"result":[{"update_id":12345678,
"message":{"message_id":3,"from":{"id"

ഭാഗ്യവശാൽ, സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്ററിനായുള്ള ടെലിഗ്രാം ബോട്ടിൽ മുമ്പ് പ്രസിദ്ധീകരിച്ച ലേഖനത്തിൽ ഈ വരി (അതെ, $MyMessageGet.RawContent | പ്രകാരം ഗെറ്റ്-മെമ്പർ എന്നത് System.String ആണ്), ഇതിനകം ഡിസ്അസംബ്ലിംഗ് ചെയ്തിട്ടുണ്ട്.

4. നിങ്ങൾക്ക് ലഭിക്കുന്നത് പ്രോസസ്സ് ചെയ്യുക (എന്തെങ്കിലും എങ്ങനെ അയയ്ക്കണമെന്ന് ഞങ്ങൾക്കറിയാം)

ഇതിനകം എഴുതിയതുപോലെ ഇവിടെ, ഏറ്റവും ആവശ്യമായ കാര്യങ്ങൾ ഉള്ളടക്കത്തിലാണ്. നമുക്ക് അത് സൂക്ഷ്മമായി പരിശോധിക്കാം.

ആദ്യം, ഞങ്ങൾ വെബ് ഇന്റർഫേസിൽ നിന്നോ ഫോണിൽ നിന്നോ ബോട്ടിലേക്ക് കുറച്ച് വാക്യങ്ങൾ കൂടി എഴുതും

/message1
/message2
/message3

കൂടാതെ $URLGET വേരിയബിളിൽ രൂപപ്പെടുത്തിയ വിലാസം ബ്രൗസറിലൂടെ നോക്കുക.

ഇതുപോലുള്ള ഒന്ന് ഞങ്ങൾ കാണും:

{"ok":true,"result":[{"update_id":NNNNNNN,
"message":{"message_id":10, .. "text":"/message1"
"message":{"message_id":11, .. "text":"/message2 
"message":{"message_id":12, .. "text":"/message3 

അത് എന്താണ്? എൻഡ്-ടു-എൻഡ് സന്ദേശ ഐഡന്റിഫയർ, ചാറ്റ് ഐഡന്റിഫയർ, അയയ്‌ക്കൽ ഐഡന്റിഫയർ എന്നിവയും മറ്റ് നിരവധി വിവരങ്ങളും അടങ്ങുന്ന ഒബ്‌ജക്‌റ്റുകളുടെ അറേകളിൽ നിന്നുള്ള ചില സങ്കീർണ്ണമായ ഒബ്‌ജക്റ്റുകൾ.

എന്നിരുന്നാലും, "ഇത് ഏതുതരം വസ്തുവാണ്" എന്ന് കണ്ടുപിടിക്കേണ്ട ആവശ്യമില്ല - ജോലിയുടെ ഒരു ഭാഗം ഇതിനകം ഞങ്ങൾക്കായി ചെയ്തു. ഉള്ളിൽ എന്താണെന്ന് നോക്കാം:

ലഭിച്ച സന്ദേശങ്ങൾ അല്ലെങ്കിൽ ഭാഗം 4 വായിക്കുന്നു

Write-Host "This is part 4" <# конечно эта строка нам не нужна в итоговом тексте, но по ней удобно искать. #> 

$Content4Pars01 = ConvertFrom-Json $MyMessageGet.Content
$Content4Pars01 | Get-Member
$Content4Pars01.result
$Content4Pars01.result[0]
$Content4Pars01.result[0] | Get-Member
$Content4Pars01.result[0].update_id
$Content4Pars01.result[0].message
$Content4Pars01.result[0].message.text
$Content4Pars01.result[1].message.text
$Content4Pars01.result[2].message.text

5. ഇപ്പോൾ നമ്മൾ എന്താണ് ചെയ്യേണ്ടത്?

തത്ഫലമായുണ്ടാകുന്ന ഫയൽ myfirstbotBT105 എന്ന പേരിൽ സംരക്ഷിക്കാം അല്ലെങ്കിൽ നിങ്ങൾക്ക് ഏറ്റവും ഇഷ്ടമുള്ളതെന്തും, ശീർഷകം മാറ്റി ഇതിനകം എഴുതിയ എല്ലാ കോഡുകളും കമന്റ് ചെയ്യുക

<#start comment 105 end comment 105#>

ഇപ്പോൾ നമുക്ക് നിഘണ്ടു എവിടെ നിന്ന് ലഭിക്കും (നന്നായി, എവിടെ - ഒരു ഫയലിലെ ഡിസ്കിൽ) അത് എങ്ങനെയായിരിക്കുമെന്ന് തീരുമാനിക്കേണ്ടതുണ്ട്.

തീർച്ചയായും, നിങ്ങൾക്ക് സ്ക്രിപ്റ്റിന്റെ വാചകത്തിൽ തന്നെ ഒരു വലിയ നിഘണ്ടു എഴുതാൻ കഴിയും, എന്നാൽ ഇത് പൂർണ്ണമായും പോയിന്റിന് അപ്പുറത്താണ്.
അതുകൊണ്ട് പവർഷെല്ലിന് സാധാരണയായി പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് നോക്കാം.
പൊതുവേ, ഏത് ഫയലുമായി പ്രവർത്തിക്കണമെന്ന് അവൻ ശ്രദ്ധിക്കുന്നില്ല, അത് ഞങ്ങൾക്ക് പ്രശ്നമല്ല.
ഞങ്ങൾക്ക് ഒരു ചോയിസ് ഉണ്ട്: txt (നിങ്ങൾക്ക് കഴിയും, പക്ഷേ എന്തുകൊണ്ട്), csv, xml.
നമുക്ക് എല്ലാവരെയും കാണാൻ കഴിയുമോ?എല്ലാവരേയും നോക്കാം.
നമുക്ക് MyVocabClassExample1 എന്ന ക്ലാസും $MyVocabExample1 എന്ന വേരിയബിളും സൃഷ്ടിക്കാം
$ ഇല്ലാതെയാണ് ക്ലാസ് എഴുതിയിരിക്കുന്നതെന്ന് ഞാൻ ശ്രദ്ധിക്കുന്നു

ചില കോഡ് #5

write-host "This is part 5"
class MyVocabClassExample1 {
    [string]$Original  # слово
    [string]$Transcript
    [string]$Translate
    [string]$Example
    [int]$VocWordID # очень интересный момент. Использование int с его ограничениями может порой приводить к диким последствиям, для примера - недавний случай с SSD HPE. Изначально я не стал добавлять этот элемент, потом все же дописал и закомментировал.
    }

$MyVocabExample1 = [MyVocabClassExample1]::new()
$MyVocabExample1.Original = "Apple"
$MyVocabExample1.Transcript = "[ ˈapəl ]"
$MyVocabExample1.Translate = "Яблоко"
$MyVocabExample1.Example = "An apple is a sweet, edible fruit produced by an apple tree (Malus domestica)"
# $MyVocabExample1.$VocWordID = 1

$MyVocabExample2 = [MyVocabClassExample1]::new()
$MyVocabExample2.Original = "Pear"
$MyVocabExample2.Transcript = "[ pe(ə)r ]"
$MyVocabExample2.Translate = "Груша"
$MyVocabExample2.Example = "The pear (/ˈpɛər/) tree and shrub are a species of genus Pyrus"
# $MyVocabExample1.$VocWordID = 2

ഉപയോഗിച്ച് ഇത് ഫയലുകളിലേക്ക് എഴുതാൻ ശ്രമിക്കാം സാമ്പിൾ.

ചില കോഡ് #5.1

Write-Host $ScriptDir # надеюсь $ScriptDir вы не закомментировали 
$MyFilenameExample01 = $ScriptDir + "Example01.txt"
$MyFilenameExample02 = $ScriptDir + "Example02.txt"
Write-Host $MyFilenameExample01
Out-File  -FilePath $MyFilenameExample01 -InputObject $MyVocabExample1

Out-File  -FilePath $MyFilenameExample01 -InputObject -Append $MyVocabExample2
notepad $MyFilenameExample01

- കൂടാതെ Out-File -FilePath $MyFilenameExample01 -InputObject -Append $MyVocabExample2 എന്ന വരിയിൽ ഞങ്ങൾക്ക് ഒരു പിശക് ലഭിക്കും.

അവൻ ചേർക്കാൻ ആഗ്രഹിക്കുന്നില്ല, അയ്യോ, എന്തൊരു നാണക്കേട്.

$MyVocabExample3AsArray = @($MyVocabExample1,$MyVocabExample2)
Out-File  -FilePath $MyFilenameExample02 -InputObject $MyVocabExample3AsArray
notepad $MyFilenameExample02

എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം. മികച്ച ടെക്‌സ്‌റ്റ് കാഴ്‌ച - എന്നാൽ അത് എങ്ങനെ തിരികെ കയറ്റുമതി ചെയ്യാം? കോമകൾ പോലെയുള്ള ഏതെങ്കിലും തരത്തിലുള്ള ടെക്സ്റ്റ് സെപ്പറേറ്ററുകൾ ഞാൻ അവതരിപ്പിക്കണോ?

അവസാനം നിങ്ങൾക്ക് ഒരു “കോമയാൽ വേർതിരിച്ച മൂല്യങ്ങൾ (CSV) ഫയൽ A ലഭിക്കും സ്റ്റോപ്പ് വെയിറ്റ്.
#

$MyFilenameExample03 = $ScriptDir + "Example03.csv"
$MyFilenameExample04 = $ScriptDir + "Example04.csv"
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample1 
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample2 -Append 
Export-Csv  -Path $MyFilenameExample04 -InputObject $MyVocabExample3AsArray 

കാണാൻ എളുപ്പമുള്ളത് പോലെ, MS-നെ അതിന്റെ ലോജിക് കൊണ്ട് പ്രത്യേകം വേർതിരിക്കുന്നില്ല; സമാനമായ നടപടിക്രമത്തിനായി, ഒരു കേസിൽ -FilePath ഉപയോഗിക്കുന്നു, മറ്റൊന്നിൽ -Path.

കൂടാതെ, മൂന്നാമത്തെ ഫയലിൽ റഷ്യൻ ഭാഷ അപ്രത്യക്ഷമായി, നാലാമത്തെ ഫയലിൽ അത് മാറി ... നന്നായി, എന്തോ സംഭവിച്ചു. #TYPE System.Object[] 00
# “എണ്ണം”,”നീളം”,”നീണ്ട നീളം”,”റാങ്ക്”,”SyncRoot”,”വായിക്കാൻ മാത്രം”,”ഇസ് ഫിക്സഡ് സൈസ്”,”ഇസ് സിൻക്രണൈസ്ഡ്”
#
നമുക്ക് ഇത് കുറച്ച് തിരുത്തിയെഴുതാം:

Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample1 -Encoding Unicode
Export-Csv  -Path $MyFilenameExample03 -InputObject $MyVocabExample2 -Append -Encoding Unicode
notepad $MyFilenameExample03
notepad $MyFilenameExample04

ഇത് സഹായിച്ചതായി തോന്നുന്നു, പക്ഷേ എനിക്ക് ഇപ്പോഴും ഫോർമാറ്റ് ഇഷ്ടമല്ല.

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

ശരിയാണ്, ഇതുവരെ എഴുതാൻ ഒന്നുമില്ല, എന്നാൽ ലോഗുകൾ എങ്ങനെ തിരിക്കാം എന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് ചിന്തിക്കാം.
ഇപ്പോൾ നമുക്ക് xml പരീക്ഷിക്കാം.

ചില xml

$MyFilenameExample05 = $ScriptDir + "Example05.xml"
$MyFilenameExample06 = $ScriptDir + "Example06.xml"
Export-Clixml  -Path $MyFilenameExample05 -InputObject $MyVocabExample1 
Export-Clixml  -Path $MyFilenameExample05 -InputObject $MyVocabExample2 -Append -Encoding Unicode
Export-Clixml  -Path $MyFilenameExample06 -InputObject $MyVocabExample3AsArray
notepad $MyFilenameExample05
notepad $MyFilenameExample06

xml-ലേക്ക് എക്‌സ്‌പോർട്ടുചെയ്യുന്നതിന് നിരവധി ഗുണങ്ങളുണ്ട് - വായനാക്ഷമത, മുഴുവൻ ഒബ്‌ജക്റ്റിന്റെയും കയറ്റുമതി, കൂടാതെ ഒരു അപ്‌പെൻഡ് ചെയ്യേണ്ടതില്ല.

നമുക്ക് ശ്രമിക്കാം xml ഫയൽ വായിക്കുക.

xml-ൽ നിന്നുള്ള ഒരു ചെറിയ വായന

$MyFilenameExample06 = $ScriptDir + "Example06.xml"
$MyVocabExample4AsArray = Import-Clixml -Path $MyFilenameExample06
# $MyVocabExample4AsArray 
# $MyVocabExample4AsArray[0]
# и немного о совершенно неочевидных нюансах. Powershell время от времени ведет себя не так, как вроде бы как бы стоило бы ожидать бы.
# например у меня эти два вывода отличаются
# Write-Output $MyVocabExample4AsArray 
# write-host $MyVocabExample4AsArray 

നമുക്ക് ടാസ്ക്കിലേക്ക് മടങ്ങാം. ഞങ്ങൾ ഒരു ടെസ്റ്റ് ഫയൽ എഴുതി, അത് വായിക്കുക, സ്റ്റോറേജ് ഫോർമാറ്റ് വ്യക്തമാണ്, ആവശ്യമെങ്കിൽ, വരികൾ ചേർക്കാനും ഇല്ലാതാക്കാനും നിങ്ങൾക്ക് ഒരു പ്രത്യേക ചെറിയ ഫയൽ എഡിറ്റർ എഴുതാം.

ഒരു ചെറിയ പരിശീലന ബോട്ട് ഉണ്ടാക്കുക എന്നതായിരുന്നു ചുമതല എന്ന് ഞാൻ നിങ്ങളെ ഓർമ്മിപ്പിക്കട്ടെ.

വർക്ക് ഫോർമാറ്റ്: ഞാൻ ബോട്ടിലേക്ക് "ഉദാഹരണം" കമാൻഡ് അയയ്ക്കുന്നു, ബോട്ട് എനിക്ക് ക്രമരഹിതമായി തിരഞ്ഞെടുത്ത വാക്കും ട്രാൻസ്ക്രിപ്ഷനും അയയ്ക്കുന്നു, കൂടാതെ 10 സെക്കൻഡുകൾക്ക് ശേഷം എനിക്ക് ഒരു വിവർത്തനവും അഭിപ്രായവും അയയ്ക്കുന്നു. കമാൻഡുകൾ എങ്ങനെ വായിക്കണമെന്ന് ഞങ്ങൾക്കറിയാം, പ്രോക്സികൾ എങ്ങനെ സ്വയമേവ തിരഞ്ഞെടുത്ത് പരിശോധിക്കാമെന്നും സന്ദേശ കൗണ്ടറുകൾ വിസ്മൃതിയിലേക്ക് പുനഃസജ്ജമാക്കാമെന്നും പഠിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.

മുമ്പ് കമന്റ് ചെയ്തതെല്ലാം അനാവശ്യമെന്ന് കമന്റ് ചെയ്യാം, ഇപ്പോൾ ആവശ്യമില്ലാത്ത ഉദാഹരണങ്ങൾ txt, csv എന്നിവ ഉപയോഗിച്ച് കമന്റ് ചെയ്യാം, കൂടാതെ ഫയൽ B106 പതിപ്പായി സേവ് ചെയ്യാം.

ഓ, അതെ. നമുക്ക് വീണ്ടും ബോട്ടിലേക്ക് എന്തെങ്കിലും അയയ്ക്കാം.

6. ഫംഗ്ഷനുകളിൽ നിന്നും മറ്റും ഡിസ്പാച്ച് ചെയ്യുക

റിസപ്ഷൻ പ്രോസസ്സ് ചെയ്യുന്നതിനുമുമ്പ്, ഒരു ടെസ്റ്റ് സന്ദേശം അല്ലാതെ "കുറഞ്ഞത് എന്തെങ്കിലും" അയയ്ക്കുന്നതിനുള്ള ഒരു ഫംഗ്ഷൻ നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്.

തീർച്ചയായും, ഉദാഹരണത്തിൽ ഞങ്ങൾക്ക് ഒരു അയയ്‌ക്കലും ഒരു പ്രോസസ്സിംഗും മാത്രമേ ഉണ്ടാകൂ, എന്നാൽ ഒരേ കാര്യം നിരവധി തവണ ചെയ്യേണ്ടതുണ്ടെങ്കിൽ എന്തുചെയ്യും?

ഒരു ഫംഗ്ഷൻ എഴുതുന്നത് എളുപ്പമാണ്. അതിനാൽ, ഞങ്ങൾക്ക് $MyVocabExample4AsArray എന്ന ടൈപ്പ് ഒബ്‌ജക്റ്റിന്റെ ഒരു വേരിയബിൾ ഉണ്ട്, ഫയലിൽ നിന്ന് വായിച്ചു, രണ്ട് ഘടകങ്ങളുടെ ഒരു അറേയുടെ രൂപത്തിൽ.
നമുക്ക് വായിക്കാൻ പോകാം.

അതേ സമയം, ഞങ്ങൾ ക്ലോക്ക് കൈകാര്യം ചെയ്യും; ഞങ്ങൾക്ക് ഇത് പിന്നീട് ആവശ്യമാണ് (വാസ്തവത്തിൽ, ഈ ഉദാഹരണത്തിൽ ഞങ്ങൾക്ക് ഇത് ആവശ്യമില്ല :)

ചില കോഡ് #6.1

Write-Output "This is Part 6"
$Timezone = (Get-TimeZone)
IF($Timezone.SupportsDaylightSavingTime -eq $True){
    $TimeAdjust =  ($Timezone.BaseUtcOffset.TotalSeconds + 3600) } # приведенное время
    ELSE{$TimeAdjust = ($Timezone.BaseUtcOffset.TotalSeconds) 
    }
    
function MyFirstFunction($SomeExampleForFunction1){
$TimeNow = Get-Date
$TimeNow.ToUniversalTime()
# $MyText02 = $TimeNow + " " + $SomeExampleForFunction1 # и вот тут мы получим ошибку
$MyText02 = $SomeExampleForFunction1 + " " + $TimeNow # а тут не получим, кто догадается почему - тот молодец.

$URL4SendFromFunction = "https://api.telegram.org/bot$MyToken/sendMessage?chat_id=$MyChatID&text=$MyText02"
Invoke-WebRequest -Uri $URL4SendFromFunction -Proxy $MyProxy
}

നിങ്ങൾക്ക് എളുപ്പത്തിൽ കാണാനാകുന്നതുപോലെ, ഫംഗ്ഷൻ മുമ്പ് ഹാർഡ്-കോഡ് ചെയ്ത $MyToken, $MyChatID എന്നിവയെ വിളിക്കുന്നു.

ഇത് ചെയ്യേണ്ട ആവശ്യമില്ല, ഓരോ ബോട്ടിനും $MyToken ഒന്നാണെങ്കിൽ, ചാറ്റിന് അനുസരിച്ച് $MyChatID മാറും.

എന്നിരുന്നാലും, ഇതൊരു ഉദാഹരണമായതിനാൽ, ഞങ്ങൾ ഇത് ഇപ്പോൾ അവഗണിക്കും.

$MyVocabExample4AsArray ഒരു അറേ അല്ലാത്തതിനാൽ, ഒന്നിനോട് വളരെ സാമ്യമുണ്ടെങ്കിലും, നിങ്ങൾക്ക് അത് എടുക്കാൻ കഴിയില്ല അതിന്റെ ദൈർഘ്യം അഭ്യർത്ഥിക്കുക.

ഒരിക്കൽ കൂടി നമുക്ക് ചെയ്യാൻ പറ്റാത്തത് ചെയ്യേണ്ടിവരും - കോഡ് അനുസരിച്ചല്ല പാരച്യൂട്ട് - എടുത്ത് എണ്ണുക

ചില കോഡ് #6.2

$MaxRandomExample = 0 
foreach ($Obj in $MyVocabExample4AsArray) {
$MaxRandomExample ++
}
Write-Output $MaxRandomExample
$RandomExample = Get-Random -Minimum 0 -Maximum ($MaxRandomExample)
$TextForExample1 = $MyVocabExample4AsArray[$RandomExample].Original
# MyFirstFunction($TextForExample1)
# или в одну строку
# MyFirstFunction($MyVocabExample4AsArray[Get-Random -Minimum 0 -Maximum ($MaxRandomExample -1)].Example)
# Угадайте сами, какой пример легче читается посторонними людьми.

വികലമായ രസകരമായ സവിശേഷത. നമുക്ക് 0 അല്ലെങ്കിൽ 1 ലഭിക്കണമെന്ന് പറയുക (അറേയിൽ രണ്ട് ഘടകങ്ങൾ മാത്രമേ ഉള്ളൂ). അതിരുകൾ 0..1 ക്രമീകരിക്കുമ്പോൾ, നമുക്ക് "1" ലഭിക്കുമോ?
ഇല്ല - ഞങ്ങൾക്ക് അത് ലഭിക്കില്ല, ഞങ്ങൾക്ക് ഒരു പ്രത്യേക ഉദാഹരണമുണ്ട് ഉദാഹരണം 2: 0 നും 99 നും ഇടയിൽ ഒരു ക്രമരഹിത പൂർണ്ണസംഖ്യ നേടുക - റാൻഡം - പരമാവധി 100
അതിനാൽ, 0..1 ന്, പരമാവധി മൂലക നമ്പർ = 0 ഉപയോഗിച്ച് 2..1 വലുപ്പം സജ്ജീകരിക്കേണ്ടതുണ്ട്.

7. ഇൻകമിംഗ് സന്ദേശങ്ങളുടെ പ്രോസസ്സിംഗും പരമാവധി ക്യൂ ദൈർഘ്യവും

നമ്മൾ നേരത്തെ എവിടെ നിർത്തി? ഞങ്ങൾക്ക് $MyMessageGet എന്ന വേരിയബിൾ ലഭിച്ചു
അതിൽ നിന്ന് ലഭിച്ച $Content4Pars01, Content4Pars01.result അറേയുടെ ഘടകങ്ങളിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്

$Content4Pars01.result[0].update_id
$Content4Pars01.result[0].message
$Content4Pars01.result[0].message.text

നമുക്ക് ബോട്ട് /message10, /message11, /message12, /word വീണ്ടും /word, /hello എന്നിവ അയയ്ക്കാം.
നമുക്ക് എന്താണ് ലഭിച്ചതെന്ന് നോക്കാം:

$Content4Pars01.result[0].message.text
$Content4Pars01.result[2].message.text

ലഭിച്ച എല്ലാ കാര്യങ്ങളും പരിശോധിച്ച് സന്ദേശം / വാക്ക് ആണെങ്കിൽ ഒരു പ്രതികരണം അയയ്ക്കാം
നിർമ്മാണത്തിന്റെ കാര്യം, if-elseif എന്ന് ചിലർ വിശേഷിപ്പിക്കുന്നതിനെ പവർഷെല്ലിൽ വിളിക്കുന്നു സ്വിച്ച് വഴി. അതേ സമയം, താഴെയുള്ള കോഡ് -വൈൽഡ്കാർഡ് കീ ഉപയോഗിക്കുന്നു, അത് പൂർണ്ണമായും അനാവശ്യവും ദോഷകരവുമാണ്.

ചില കോഡ് #7.1

Write-Output "This is part 7"
Foreach ($Result in $Content4Pars01.result) # Да, можно сделать быстрее 
 { 
    switch -wildcard ($Result.message.text) 
            {
            "/word" {MyFirstFunction($TextForExample1)}
            }
}

നമുക്ക് സ്ക്രിപ്റ്റ് ഒന്ന് രണ്ട് തവണ പ്രവർത്തിപ്പിക്കാം. ഓരോ നിർവ്വഹണ ശ്രമത്തിനും ഒരേ വാക്ക് രണ്ട് തവണ ലഭിക്കും, പ്രത്യേകിച്ചും ക്രമരഹിതമായി നടപ്പിലാക്കുന്നതിൽ ഞങ്ങൾ തെറ്റ് വരുത്തിയാൽ.

എന്നാൽ നിർത്തുക. ഞങ്ങൾ വീണ്ടും / വാക്ക് അയച്ചില്ല, എന്തുകൊണ്ടാണ് സന്ദേശം വീണ്ടും പ്രോസസ്സ് ചെയ്യുന്നത്?

ബോട്ടിലേക്ക് സന്ദേശങ്ങൾ അയക്കുന്നതിനുള്ള ക്യൂവിന് പരിമിതമായ ദൈർഘ്യമുണ്ട് (100 അല്ലെങ്കിൽ 200 സന്ദേശങ്ങൾ, ഞാൻ കരുതുന്നു) അത് സ്വമേധയാ മായ്‌ക്കേണ്ടതാണ്.

ഇത് തീർച്ചയായും ഡോക്യുമെന്റേഷനിൽ വിവരിച്ചിരിക്കുന്നു, പക്ഷേ നിങ്ങൾ അത് വായിക്കണം!

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾക്ക് ?chat_id പാരാമീറ്റർ ആവശ്യമാണ്, കൂടാതെ &ടൈമൗട്ട്, &ലിമിറ്റ്, &parse_mode=HTML, &disable_web_page_preview=true എന്നിവ ഇതുവരെ ആവശ്യമില്ല.

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

നമുക്ക് നോക്കാം:

$Content4Pars01.result[0].update_id
$Content4Pars01.result[1].update_id 
$Content4Pars01.result | select -last 1
($Content4Pars01.result | select -last 1).update_id

അതെ, ഞങ്ങൾ അത് പുനഃസജ്ജമാക്കുകയും ഫംഗ്ഷൻ അല്പം മാറ്റിയെഴുതുകയും ചെയ്യും. ഞങ്ങൾക്ക് രണ്ട് ഓപ്ഷനുകളുണ്ട് - മുഴുവൻ സന്ദേശവും ഫംഗ്‌ഷനിലേക്ക് അയച്ച് അത് പൂർണ്ണമായും ഫംഗ്‌ഷനിൽ പ്രോസസ്സ് ചെയ്യുക, അല്ലെങ്കിൽ സന്ദേശ ഐഡി മാത്രം നൽകി അത് പുനഃസജ്ജമാക്കുക. ഉദാഹരണത്തിന്, രണ്ടാമത്തേത് കൂടുതൽ ലളിതമായി തോന്നുന്നു.

മുമ്പ്, ഞങ്ങളുടെ "എല്ലാ സന്ദേശങ്ങളും" അന്വേഷണ സ്ട്രിംഗ് ഇതുപോലെയായിരുന്നു

$URLGET = "https://api.telegram.org/bot$MyToken/getUpdates"

അത് പോലെ കാണുകയും ചെയ്യും

$LastMessageId = ($Content4Pars01.result | select -last 1).update_id
$URLGET1 = "https://api.telegram.org/bot$mytoken/getUpdates?offset=$LastMessageId&limit=100" 
$MyMessageGet = Invoke-WebRequest -Uri $URLGET1 -Method Get -Proxy $MyProxy 

ആദ്യം എല്ലാ സന്ദേശങ്ങളും സ്വീകരിക്കാനും അവ പ്രോസസ്സ് ചെയ്യാനും നിങ്ങളെ ആരും വിലക്കുന്നില്ല, വിജയകരമായ പ്രോസസ്സിംഗ് അഭ്യർത്ഥനയ്ക്ക് ശേഷം മാത്രമേ സ്ഥിരീകരിക്കാത്തത് -> സ്ഥിരീകരിച്ചു.

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

കോഡിന്റെ രണ്ട് വരികൾ കൂടി

$LastMessageId = ($Content4Pars01.result | select -last 1).update_id  #ошибку в этом месте предполагается исправить самостоятельно. 
$URLGET1 = "https://api.telegram.org/bot$mytoken/getUpdates?offset=$LastMessageId&limit=100" 
Invoke-WebRequest -Uri $URLGET1 -Method Get -Proxy $MyProxy

8. ഒരു നിഗമനത്തിന് പകരം

അടിസ്ഥാന പ്രവർത്തനങ്ങൾ - സന്ദേശങ്ങൾ വായിക്കുക, ക്യൂ പുനഃക്രമീകരിക്കുക, ഫയലിൽ നിന്ന് വായിക്കുക, ഫയലിലേക്ക് എഴുതുക എന്നിവ പൂർത്തിയാക്കി കാണിക്കുന്നു.

ഇനി നാല് കാര്യങ്ങൾ മാത്രമേ ചെയ്യാനുള്ളൂ:

• ചാറ്റിലെ ഒരു അഭ്യർത്ഥനയ്ക്ക് ശരിയായ ഉത്തരം അയയ്ക്കുന്നു
• ബോട്ട് ചേർത്ത ഏതെങ്കിലും ചാറ്റിന് ഒരു പ്രതികരണം അയയ്ക്കുന്നു
• ഒരു ലൂപ്പിൽ കോഡ് നടപ്പിലാക്കുന്നു
• വിൻഡോസ് ഷെഡ്യൂളറിൽ നിന്ന് ഒരു ബോട്ട് സമാരംഭിക്കുന്നു.

ഈ ടാസ്‌ക്കുകളെല്ലാം ലളിതമാണ്, ഇതുപോലുള്ള പാരാമീറ്ററുകളെക്കുറിച്ചുള്ള ഡോക്യുമെന്റേഷൻ വായിച്ചുകൊണ്ട് എളുപ്പത്തിൽ പൂർത്തിയാക്കാൻ കഴിയും
സെറ്റ്-എക്സിക്യൂഷൻ പോളിസി അനിയന്ത്രിതവും -എക്സിക്യൂഷൻ പോളിസി ബൈപാസും
രൂപത്തിന്റെ ചക്രം

$TimeToSleep = 3 # опрос каждые 3 секунды
$TimeToWork = 10 # минут
$HowManyTimes = $TimeToWork*60/$TimeToSleep # счетчик для цикла
$MainCounter = 0
for ($MainCounter=0; $MainCounter -le $HowManyTimes) {
sleep $TimeToSleep
$MainCounter ++

വായിച്ച എല്ലാവർക്കും നന്ദി.

അവലംബം: www.habr.com