autoexpect - ക്ലൗഡിൽ ഓൺലൈനായി

പട്ടിക:

NAME

autoexpect - ഒരു സെഷൻ കാണുന്നതിൽ നിന്ന് പ്രതീക്ഷിക്കുന്ന സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുക

സിനോപ്സിസ്

സ്വയം പ്രതീക്ഷിക്കുക [ വാദിക്കുന്നു ] [ പ്രോഗ്രാം ആർഗ്സ്... ]

ആമുഖം

autoexpect നിങ്ങൾ മറ്റൊരു പ്രോഗ്രാമുമായി ഇടപഴകുന്നത് നിരീക്ഷിക്കുകയും ഒരു Expect സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുകയും ചെയ്യുന്നു
നിങ്ങളുടെ ഇടപെടലുകൾ പുനർനിർമ്മിക്കുന്നു. നേർരേഖയിലുള്ള സ്‌ക്രിപ്റ്റുകൾക്ക്, autoexpect ഗണ്യമായ സമയം ലാഭിക്കുന്നു
കൈകൊണ്ട് സ്ക്രിപ്റ്റുകൾ എഴുതുന്നു. നിങ്ങൾ ഒരു Expect Expert ആണെങ്കിലും, നിങ്ങൾ അത് കണ്ടെത്തും
ഇടപെടലുകളുടെ കൂടുതൽ ബുദ്ധിശൂന്യമായ ഭാഗങ്ങൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിന് ഓട്ടോ എക്‌സ്‌പെക്‌റ്റ് ഉപയോഗിക്കാൻ സൗകര്യപ്രദമാണ്. അത്
സ്വയമേവ പ്രതീക്ഷിക്കുന്ന സ്‌ക്രിപ്‌റ്റുകളുടെ ഹുങ്കുകൾ കട്ട്/ഒട്ടിക്കുന്നത് അവയിൽ നിന്ന് എഴുതുന്നതിനേക്കാൾ വളരെ എളുപ്പമാണ്
സ്ക്രാച്ച്. നിങ്ങൾ ഒരു തുടക്കക്കാരനാണെങ്കിൽ, ഒന്നും പഠിക്കാതെ രക്ഷപ്പെടാൻ നിങ്ങൾക്ക് കഴിഞ്ഞേക്കും
ഓട്ടോഎക്‌സ്‌പെക്‌ട് എങ്ങനെ വിളിക്കാം എന്നതിനേക്കാൾ പ്രതീക്ഷിക്കുന്നതിനെ കുറിച്ച് കൂടുതൽ.

ഓട്ടോ എക്‌സ്‌പെക്‌ട് ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം ആർഗ്യുമെന്റുകളില്ലാതെ കമാൻഡ് ലൈനിൽ നിന്ന് വിളിക്കുക എന്നതാണ്.
ഉദാഹരണത്തിന്:

% യാന്ത്രിക പ്രതീക്ഷ

ഡിഫോൾട്ടായി, autoexpect നിങ്ങൾക്കായി ഒരു ഷെൽ ഉണ്ടാക്കുന്നു. ഒരു പ്രോഗ്രാമിന്റെ പേരും ആർഗ്യുമെന്റുകളും നൽകി,
autoexpect ആ പ്രോഗ്രാമിന് രൂപം നൽകുന്നു. ഉദാഹരണത്തിന്:

% autoexpect ftp ftp.cme.nist.gov

നിങ്ങളുടെ സ്പോൺഡ് പ്രോഗ്രാം പ്രവർത്തിച്ചുകഴിഞ്ഞാൽ, സാധാരണ രീതിയിൽ ഇടപെടുക. നിങ്ങൾ ഷെല്ലിൽ നിന്ന് പുറത്തുകടക്കുമ്പോൾ
(അല്ലെങ്കിൽ നിങ്ങൾ വ്യക്തമാക്കിയ പ്രോഗ്രാം), autoexpect നിങ്ങൾക്കായി ഒരു പുതിയ സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കും. സ്വതവേ,
autoexpect "script.exp" എന്നതിലേക്ക് പുതിയ സ്ക്രിപ്റ്റ് എഴുതുന്നു. -f ഫ്ലാഗ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് അസാധുവാക്കാനാകും
തുടർന്ന് ഒരു പുതിയ സ്ക്രിപ്റ്റ് നാമം.

ഇനിപ്പറയുന്ന ഉദാഹരണം "ftp ftp.cme.nist.gov" പ്രവർത്തിപ്പിക്കുകയും തത്ഫലമായുണ്ടാകുന്ന Expect സ്ക്രിപ്റ്റ് സംഭരിക്കുകയും ചെയ്യുന്നു
"nist" എന്ന ഫയലിൽ.

% autoexpect -f nist ftp ftp.cme.nist.gov

ഓട്ടോഎക്‌സ്‌പെക്‌റ്റ് പ്രവർത്തനക്ഷമമായ സ്‌ക്രിപ്‌റ്റിന് ഗ്യാരണ്ടി നൽകുന്നില്ലെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്
ചില കാര്യങ്ങളെക്കുറിച്ച് അത് ഊഹിക്കേണ്ടതുണ്ട് - ഇടയ്ക്കിടെ അത് തെറ്റായി ഊഹിക്കുന്നു.
എന്നിരുന്നാലും, ഈ പ്രശ്നങ്ങൾ തിരിച്ചറിയാനും പരിഹരിക്കാനും സാധാരണയായി വളരെ എളുപ്പമാണ്. സാധാരണ പ്രശ്നങ്ങൾ
ആകുന്നു:

· സമയത്തിന്റെ. അതിശയകരമാംവിധം ധാരാളം പ്രോഗ്രാമുകൾ (rn, ksh, zsh, telnet മുതലായവ)
ഉപകരണങ്ങളും (ഉദാ, മോഡമുകൾ) "വളരെ വേഗത്തിൽ" വരുന്ന കീസ്ട്രോക്കുകൾ അവഗണിക്കുക
ആവശ്യപ്പെടുന്നു. നിങ്ങളുടെ പുതിയ സ്‌ക്രിപ്റ്റ് ഒരിടത്ത് ഹാംഗ് അപ്പ് ചെയ്‌തതായി കണ്ടാൽ, ഒരു ചേർക്കാൻ ശ്രമിക്കുക
മുമ്പത്തെ അയക്കുന്നതിന് തൊട്ടുമുമ്പ് ചെറിയ ഉറക്കം.

വേരിയബിളിനെ അസാധുവാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് ഈ സ്വഭാവം ഉടനീളം നിർബന്ധിക്കാം
"force_conservative" ജനറേറ്റ് ചെയ്ത സ്ക്രിപ്റ്റിന്റെ തുടക്കത്തിന് സമീപം. ഈ
"യാഥാസ്ഥിതിക" മോഡ് സ്വയമേവ സ്വയമേവ താൽക്കാലികമായി നിർത്തുന്നു (പത്തിലൊന്ന്
ഒരു സെക്കൻഡ്) ഓരോ പ്രതീകവും അയയ്ക്കുന്നതിന് മുമ്പ്. എനിക്കറിയാവുന്ന എല്ലാ പ്രോഗ്രാമുകളും ഇത് ശാന്തമാക്കുന്നു
ന്റെ.

നിങ്ങൾക്ക് പെട്ടെന്ന് ഉറപ്പുനൽകണമെങ്കിൽ ഈ യാഥാസ്ഥിതിക മോഡ് ഉപയോഗപ്രദമാണ്
പ്രശ്‌നം സമയബന്ധിതമാണെന്ന് (അല്ലെങ്കിൽ എത്ര വേഗത്തിലാണെന്ന് നിങ്ങൾ ശരിക്കും ശ്രദ്ധിക്കുന്നില്ലെങ്കിൽ
സ്ക്രിപ്റ്റ് പ്രവർത്തിക്കുന്നു). സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുന്നതിന് മുമ്പ് ഇതേ മോഡ് നിർബന്ധിതമാക്കാം
-c ഫ്ലാഗ് ഉപയോഗിക്കുന്നു.

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

ഇനിപ്പറയുന്ന ഉദാഹരണം യാഥാസ്ഥിതിക മോഡിൽ യാന്ത്രിക പ്രതീക്ഷ ആരംഭിക്കുന്നു.

autoexpect -സി

കൺസർവേറ്റീവ് മോഡ് ടോഗിൾ ചെയ്യുന്നതിനുള്ള ഒരു കീ -C ഫ്ലാഗ് നിർവ്വചിക്കുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണം
ടോഗിൾ ആയി ^L ഉപയോഗിച്ച് autoexpect (യാഥാസ്ഥിതികമല്ലാത്ത മോഡിൽ) ആരംഭിക്കുന്നു. (അതല്ല
^L അക്ഷരാർത്ഥത്തിൽ നൽകിയിട്ടുണ്ട് - അതായത്, ഒരു യഥാർത്ഥ നിയന്ത്രണം-L നൽകുക).

autoexpect -C ^L

ഇനിപ്പറയുന്ന ഉദാഹരണം യാഥാസ്ഥിതിക മോഡിൽ ^L ആയി സ്വയമേവ പ്രതീക്ഷിക്കുന്നത് ആരംഭിക്കുന്നു
ടോഗിൾ ചെയ്യുക.

autoexpect -c -C ^L

· പ്രതിധ്വനിക്കുന്നു. നിരവധി പ്രോഗ്രാം എക്കോ പ്രതീകങ്ങൾ. ഉദാഹരണത്തിന്, നിങ്ങൾ "കൂടുതൽ" എന്ന് ടൈപ്പ് ചെയ്താൽ a
ഷെൽ, ഓട്ടോ എക്‌സ്‌പെക്‌റ്റ് യഥാർത്ഥത്തിൽ കാണുന്നത് ഇതാണ്:

നിങ്ങൾ 'm' എന്ന് ടൈപ്പ് ചെയ്തു,
കമ്പ്യൂട്ടർ ടൈപ്പ് ചെയ്ത 'm',
നിങ്ങൾ 'o' എന്ന് ടൈപ്പ് ചെയ്തു,
കമ്പ്യൂട്ടർ ടൈപ്പ് ചെയ്ത 'o',
നിങ്ങൾ 'r' എന്ന് ടൈപ്പ് ചെയ്തു,
കമ്പ്യൂട്ടർ ടൈപ്പ് ചെയ്ത 'r',
...

പ്രോഗ്രാമിനെക്കുറിച്ചുള്ള പ്രത്യേക അറിവില്ലാതെ, നിങ്ങളാണോ എന്ന് അറിയാൻ കഴിയില്ല
ഓരോ പ്രതീകവും അടുത്തത് ടൈപ്പുചെയ്യുന്നതിന് മുമ്പ് പ്രതിധ്വനിക്കുന്നത് കാണാൻ കാത്തിരിക്കുന്നു. സ്വയം പ്രതീക്ഷിക്കുകയാണെങ്കിൽ
പ്രതീകങ്ങൾ പ്രതിധ്വനിക്കുന്നത് കാണുന്നു, അവയെല്ലാം ഒരു ഗ്രൂപ്പായി അയയ്ക്കാൻ കഴിയുമെന്ന് അത് അനുമാനിക്കുന്നു
അവ യഥാർത്ഥത്തിൽ പ്രത്യക്ഷപ്പെട്ട രീതിയിൽ ഇടപെടുന്നതിന് പകരം. ഇത് ഉണ്ടാക്കുന്നു
സ്ക്രിപ്റ്റ് വായിക്കാൻ കൂടുതൽ സുഖകരമാണ്. എന്നിരുന്നാലും, എങ്കിൽ അത് തെറ്റായി കണക്കാക്കാം
ഓരോ കഥാപാത്രവും പ്രതിധ്വനിക്കുന്നത് കാണാൻ നിങ്ങൾ ശരിക്കും കാത്തിരിക്കേണ്ടി വന്നു.

· മാറ്റം. സ്‌ക്രിപ്റ്റിലെ ഇടപെടലിൽ നിന്നുള്ള ഓരോ പ്രതീകവും Autoexpect രേഖപ്പെടുത്തുന്നു.
ഇത് അഭിലഷണീയമാണ്, കാരണം ഇത് നിങ്ങൾക്ക് വിലയിരുത്താനുള്ള കഴിവ് നൽകുന്നു
എന്താണ് പ്രധാനം, പാറ്റേൺ പൊരുത്തം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം.

മറുവശത്ത്, റണ്ണിൽ നിന്ന് റണ്ണിലേക്ക് ഔട്ട്പുട്ട് വ്യത്യാസമുള്ള കമാൻഡുകൾ നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ,
സൃഷ്ടിച്ച സ്ക്രിപ്റ്റുകൾ ശരിയായിരിക്കില്ല. ഉദാഹരണത്തിന്, "തീയതി"
കമാൻഡ് എപ്പോഴും വ്യത്യസ്തമായ ഔട്ട്പുട്ട് ഉണ്ടാക്കുന്നു. അതിനാൽ date കമാൻഡ് while ഉപയോഗിക്കുന്നു
എഡിറ്റിംഗ് ആവശ്യമായ ഒരു സ്ക്രിപ്റ്റ് നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഉറപ്പായ മാർഗമാണ് autoexpect പ്രവർത്തിപ്പിക്കുന്നത്
അത് പ്രവർത്തിക്കാൻ വേണ്ടി.

-p ഫ്ലാഗ് "പ്രോംപ്റ്റ് മോഡിലേക്ക്" സ്വയമേവ പ്രതീക്ഷിക്കുന്നു. ഈ മോഡിൽ, autoexpect ചെയ്യും
പ്രോഗ്രാം ഔട്ട്പുട്ടിന്റെ അവസാന വരി മാത്രം നോക്കുക - ഇത് സാധാരണയായി ആണ്
പ്രോംപ്റ്റ്. ഇത് തീയതി പ്രശ്നം (മുകളിൽ കാണുക) കൂടാതെ മറ്റുള്ളവയും കൈകാര്യം ചെയ്യുന്നു.

ഇനിപ്പറയുന്ന ഉദാഹരണം പ്രോംപ്റ്റ് മോഡിൽ സ്വയം പ്രതീക്ഷിക്കൽ ആരംഭിക്കുന്നു.

autoexpect -p

പ്രോംപ്റ്റ് മോഡ് ടോഗിൾ ചെയ്യുന്നതിനുള്ള ഒരു കീ -P ഫ്ലാഗ് നിർവ്വചിക്കുന്നു. ഇനിപ്പറയുന്ന ഉദാഹരണം ആരംഭിക്കുന്നു
ടോഗിൾ ആയി ^P ഉപയോഗിച്ച് autoexpect (നോൺ-പ്രോംപ്റ്റ് മോഡിൽ). ^P എന്നത് ശ്രദ്ധിക്കുക
അക്ഷരാർത്ഥത്തിൽ നൽകി - അതായത്, ഒരു യഥാർത്ഥ നിയന്ത്രണം-P നൽകുക.

autoexpect -P ^P

ഇനിപ്പറയുന്ന ഉദാഹരണം ടോഗിൾ ആയി ^P ഉപയോഗിച്ച് പ്രോംപ്റ്റ് മോഡിൽ ഓട്ടോ എക്‌സ്‌പെക്റ്റ് ആരംഭിക്കുന്നു.

autoexpect -p -P ^P

മറ്റുള്ളവ ഫ്ലാഗുകൾ

ദി - നിശബ്ദം ഓട്ടോ എക്‌സ്‌പെക്‌റ്റ് സൃഷ്‌ടിച്ച വിവര സന്ദേശങ്ങളെ ഫ്ലാഗ് പ്രവർത്തനരഹിതമാക്കുന്നു.

ദി -Q ഫ്ലാഗ് ഒരു ഉദ്ധരണി പ്രതീകത്തിന് പേരിടുന്നു, അത് സ്വയമേവ പ്രതീക്ഷിക്കുന്ന പ്രതീകങ്ങൾ നൽകുന്നതിന് ഉപയോഗിക്കാം
ടോഗിളുകളായി ഉപയോഗിക്കുന്നതിനാൽ അത് ഉപയോഗിക്കും.

ഇനിപ്പറയുന്ന ഉദാഹരണം, പ്രവേശിക്കുന്നതിനുള്ള ഒരു മാർഗം നൽകുന്നതിന് ഉപയോഗിക്കുന്ന ഉദ്ധരണികളുള്ള നിരവധി ഫ്ലാഗുകൾ കാണിക്കുന്നു
അക്ഷരാർത്ഥത്തിൽ ടോഗിൾ ചെയ്യുന്നു.

autoexpect -P ^P -C ^L -Q ^Q

ശൈലി

എക്‌സ്‌പെക്റ്റ് പ്രോഗ്രാമുകൾക്കായി ഒരു "സ്റ്റൈൽ" ഉണ്ടോ എന്ന് എനിക്കറിയില്ല, പക്ഷേ ഓട്ടോ എക്‌സ്‌പെക്റ്റ് തീർച്ചയായും വേണം
ശൈലിയുടെ ഏതെങ്കിലും മാതൃകയായി ഉയർത്തിപ്പിടിക്കരുത്. ഉദാഹരണത്തിന്, Autoexpect, Expect-ന്റെ സവിശേഷതകൾ ഉപയോഗിക്കുന്നു
കമ്പ്യൂട്ടർ സൃഷ്ടിച്ച സ്ക്രിപ്റ്റിങ്ങിനായി പ്രത്യേകം ഉദ്ദേശിച്ചിട്ടുള്ളവയാണ്. അതുകൊണ്ട് ശ്രമിക്കരുത്
ഓട്ടോ എക്‌സ്‌പെക്‌റ്റ് സൃഷ്‌ടിച്ചതുപോലെ ദൃശ്യമാകുന്ന സ്‌ക്രിപ്റ്റുകൾ വിശ്വസ്തതയോടെ എഴുതുക. ഇതല്ല
ഉപയോഗപ്രദമായ.

മറുവശത്ത്, സ്വയമേവ പ്രതീക്ഷിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ചില മൂല്യവത്തായ കാര്യങ്ങൾ കാണിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾ
ഒരു Tcl സ്ക്രിപ്റ്റിൽ ഉപയോഗിക്കുന്നതിന് ഏതെങ്കിലും സ്ട്രിംഗ് എങ്ങനെ ഉദ്ധരിക്കണമെന്ന് കാണാൻ കഴിയും
ഓട്ടോ എക്‌സ്‌പെക്‌റ്റിലൂടെ സ്ട്രിംഗുകൾ.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഓൺലൈനിൽ ഓട്ടോ എക്‌സ്‌പെക്റ്റ് ഉപയോഗിക്കുക