Ubuntu Online, Fedora Online, Windows online emulator അല്ലെങ്കിൽ MAC OS ഓൺലൈൻ എമുലേറ്റർ എന്നിങ്ങനെയുള്ള ഞങ്ങളുടെ ഒന്നിലധികം സൗജന്യ ഓൺലൈൻ വർക്ക്‌സ്റ്റേഷനുകളിലൊന്ന് ഉപയോഗിച്ച് OnWorks സൗജന്യ ഹോസ്റ്റിംഗ് ദാതാവിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന perlfaq8 കമാൻഡ് ഇതാണ്.
പട്ടിക:
NAME
perlfaq8 - സിസ്റ്റം ഇടപെടൽ
പതിപ്പ്
പതിപ്പ് 5.021009
വിവരണം
Perl FAQ-ന്റെ ഈ വിഭാഗം ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഇന്ററാക്ഷൻ ഉൾപ്പെടുന്ന ചോദ്യങ്ങൾ ഉൾക്കൊള്ളുന്നു.
വിഷയങ്ങളിൽ ഇന്റർപ്രോസസ് കമ്മ്യൂണിക്കേഷൻ (IPC), ഉപയോക്തൃ-ഇന്റർഫേസിന്റെ നിയന്ത്രണം എന്നിവ ഉൾപ്പെടുന്നു
(കീബോർഡ്, സ്ക്രീൻ, പോയിന്റിംഗ് ഉപകരണങ്ങൾ), കൂടാതെ ഡാറ്റയുമായി ബന്ധമില്ലാത്ത മറ്റെന്തെങ്കിലും
കൃത്രിമത്വം.
നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിലേക്ക് perl പോർട്ട് സംബന്ധിച്ച പതിവ് ചോദ്യങ്ങളും ഡോക്യുമെന്റേഷനും വായിക്കുക (ഉദാ.
perlvms, perlplan9, ...). വ്യതിയാനങ്ങളെക്കുറിച്ചുള്ള കൂടുതൽ വിശദമായ വിവരങ്ങൾ ഇവയിൽ അടങ്ങിയിരിക്കണം
നിങ്ങളുടെ പേരിന്റെ.
എങ്ങനെ do I കണ്ടെത്തുക പുറത്ത് ഏത് ഓപ്പറേറ്റിങ് സിസ്റ്റം ഞാൻ പ്രവർത്തിക്കുന്ന കീഴിൽ?
$^O വേരിയബിളിൽ (നിങ്ങൾ "ഇംഗ്ലീഷ്" ഉപയോഗിക്കുകയാണെങ്കിൽ $OSNAME) എന്നതിന്റെ പേരിന്റെ ഒരു സൂചന അടങ്ങിയിരിക്കുന്നു
നിങ്ങളുടെ perl ബൈനറി നിർമ്മിച്ച ഓപ്പറേറ്റിംഗ് സിസ്റ്റം (അതിന്റെ റിലീസ് നമ്പർ അല്ല).
എങ്ങനെ വരുക എക്സിക്() ഇല്ല തിരിച്ചുവരണോ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
നിങ്ങളുടെ പ്രക്രിയയെ മറ്റൊരു കമാൻഡാക്കി മാറ്റുക എന്നതാണ് "exec" ഫംഗ്‌ഷന്റെ ജോലി
മടങ്ങുക. നിങ്ങൾ ചെയ്യേണ്ടത് അങ്ങനെയല്ലെങ്കിൽ, "exec" ഉപയോഗിക്കരുത്. :)
നിങ്ങൾക്ക് ഒരു എക്‌സ്‌റ്റേണൽ കമാൻഡ് പ്രവർത്തിപ്പിക്കാനും നിങ്ങളുടെ പേൾ പ്രോസസ്സ് തുടരാനും ആഗ്രഹിക്കുന്നുവെങ്കിൽ, എ നോക്കുക
പൈപ്പ് "ഓപ്പൺ", "ഫോർക്ക്", അല്ലെങ്കിൽ "സിസ്റ്റം".
എങ്ങനെ do I do ഫാൻസി സ്റ്റഫ് കൂടെ The കീബോർഡ്/സ്ക്രീൻ/മൗസ്?
കീബോർഡുകൾ, സ്‌ക്രീനുകൾ, പോയിന്റിംഗ് ഉപകരണങ്ങൾ ("എലികൾ") എന്നിവ നിങ്ങൾ എങ്ങനെയാണ് ആക്സസ്/നിയന്ത്രിക്കുന്നത് എന്നത് സിസ്റ്റം-
ആശ്രിത. ഇനിപ്പറയുന്ന മൊഡ്യൂളുകൾ പരീക്ഷിക്കുക:
കീബോര്ഡ്
കാലാവധി::ക്യാപ് സ്റ്റാൻഡേർഡ് പെർൾ വിതരണം
കാലാവധി::ReadKey CPAN
കാലാവധി::ReadLine::Gnu CPAN
കാലാവധി::ReadLine::Perl CPAN
കാലാവധി::സ്ക്രീൻ CPAN
സ്ക്രീൻ
കാലാവധി::ക്യാപ് സ്റ്റാൻഡേർഡ് പെർൾ വിതരണം
CPAN-നെ ശപിക്കുന്നു
കാലാവധി::ANSIColor CPAN
ചുണ്ടെലി
Tk CPAN
Wx CPAN
Gtk2 CPAN
Qt4 kdebindings4 പാക്കേജ്
ഈ പ്രത്യേക കേസുകളിൽ ചിലത് ഈ വിഭാഗത്തിലെ മറ്റ് ഉത്തരങ്ങളിൽ ഉദാഹരണങ്ങളായി കാണിച്ചിരിക്കുന്നു
perlfaq.
എങ്ങനെ do I അച്ചടിക്കുക എന്തെങ്കിലും പുറത്ത് in നിറം?
പൊതുവേ, നിങ്ങൾ അങ്ങനെ ചെയ്യുന്നില്ല, കാരണം സ്വീകർത്താവിന് ഒരു വർണ്ണ ബോധമുണ്ടോ എന്ന് നിങ്ങൾക്കറിയില്ല
ഡിസ്പ്ലേ ഉപകരണം. അവർക്ക് നിറം മനസ്സിലാക്കാൻ കഴിയുന്ന ഒരു ANSI ടെർമിനൽ ഉണ്ടെന്ന് നിങ്ങൾക്കറിയാമെങ്കിൽ, നിങ്ങൾ
CPAN-ൽ നിന്ന് ടേം::ANSIColor മൊഡ്യൂൾ ഉപയോഗിക്കാം:
ടേം::ANSIColor ഉപയോഗിക്കുക;
പ്രിന്റ് നിറം("ചുവപ്പ്"), "നിർത്തുക!\n", നിറം("പുനഃസജ്ജമാക്കുക");
പ്രിന്റ് നിറം("പച്ച"), "പോകൂ!\n", നിറം("പുനഃസജ്ജമാക്കുക");
അല്ലെങ്കിൽ ഇതുപോലെ:
ടേം ഉപയോഗിക്കുക::ANSIColor qw(:കോൺസ്റ്റന്റുകൾ);
പ്രിന്റ് RED, "നിർത്തുക!\n", റീസെറ്റ്;
പച്ച, "പോകൂ!\n", റീസെറ്റ് ചെയ്യുക;
എങ്ങനെ do I വായിക്കുക വെറും ഒന്ന് കീ കൂടാതെ കാത്തിരിക്കുന്നു വേണ്ടി a മടക്കം താക്കോൽ?
ഇൻപുട്ട് ബഫറിംഗ് നിയന്ത്രിക്കുന്നത് ശ്രദ്ധേയമായ ഒരു സിസ്റ്റം-ആശ്രിത കാര്യമാണ്. പല സിസ്റ്റങ്ങളിലും, നിങ്ങൾ
ഉപയോഗിക്കാൻ കഴിയും stty perlfunc-ൽ "getc" ൽ കാണിച്ചിരിക്കുന്നതുപോലെ കമാൻഡ്, എന്നാൽ നിങ്ങൾ കാണുന്നത് പോലെ, അതാണ്
നിങ്ങളെ ഇതിനകം തന്നെ പോർട്ടബിലിറ്റി സ്നാഗുകളിൽ എത്തിക്കുന്നു.
തുറക്കുക(TTY, "+
സിസ്റ്റം "stty cbreak /dev/tty 2>&1";
$കീ = getc(TTY); # ഒരുപക്ഷേ ഇത് പ്രവർത്തിക്കുന്നു
# അല്ലെങ്കിൽ വേറെ
sysread(TTY, $കീ, 1); # ഒരുപക്ഷെ ഇത് ചെയ്യും
സിസ്റ്റം "stty -cbreak /dev/tty 2>&1";
CPAN-ൽ നിന്നുള്ള നിബന്ധന ::ReadKey മൊഡ്യൂൾ കൂടുതൽ ഉപയോഗിക്കാവുന്ന എളുപ്പമുള്ള ഇന്റർഫേസ് വാഗ്ദാനം ചെയ്യുന്നു
ഷെൽ ഔട്ട് ചെയ്യുന്നതിനേക്കാൾ കാര്യക്ഷമമാണ് stty ഓരോ കീയ്ക്കും. പരിമിതമായ പിന്തുണ പോലും ഇതിൽ ഉൾപ്പെടുന്നു
വിൻഡോസ്.
ടേം ഉപയോഗിക്കുക ::ReadKey;
റീഡ്മോഡ് ('cbreak');
$കീ = റീഡ്കീ(0);
റീഡ്മോഡ് ('സാധാരണ');
എന്നിരുന്നാലും, കോഡ് ഉപയോഗിക്കുന്നതിന് നിങ്ങൾക്ക് ഒരു പ്രവർത്തിക്കുന്ന സി കംപൈലർ ഉണ്ടായിരിക്കുകയും അത് ഉപയോഗിക്കുകയും വേണം
ഒരു CPAN മൊഡ്യൂൾ നിർമ്മിക്കുകയും ഇൻസ്റ്റാൾ ചെയ്യുകയും ചെയ്യുക. സാധാരണ POSIX മൊഡ്യൂൾ ഉപയോഗിച്ചുള്ള ഒരു പരിഹാരം ഇതാ
ഇതിനകം തന്നെ നിങ്ങളുടെ സിസ്റ്റത്തിലുണ്ട് (നിങ്ങളുടെ സിസ്റ്റം POSIX-നെ പിന്തുണയ്ക്കുന്നുവെന്ന് കരുതുക).
HotKey ഉപയോഗിക്കുക;
$കീ = റെഡികീ();
ഇവിടെ "HotKey" മൊഡ്യൂൾ ഉണ്ട്, അത് കൃത്രിമമായി കൈകാര്യം ചെയ്യാനുള്ള അൽപ്പം ദുരൂഹമായ കോളുകൾ മറയ്ക്കുന്നു
POSIX ടെർമിയോസ് ഘടനകൾ.
# HotKey.pm
പാക്കേജ് HotKey;
കർശനമായി ഉപയോഗിക്കുക;
മുന്നറിയിപ്പുകൾ ഉപയോഗിക്കുക;
രക്ഷാകർതൃ 'കയറ്റുമതി' ഉപയോഗിക്കുക;
ഞങ്ങളുടെ @EXPORT = qw(cbreak cooked readkey);
POSIX qw(:termios_h) ഉപയോഗിക്കുക;
എന്റെ ($term, $oterm, $echo, $noecho, $fd_stdin);
$fd_stdin = fileno(STDIN);
$ടേം = POSIX:: Termios->പുതിയ();
$term->getattr($fd_stdin);
$oterm = $term->getflag();
$echo = ECHO | ECHOK | ICANON;
$noecho = $oterm & ~$echo;
സബ് ബ്രേക്ക് {
$term->setflag($noecho); # ശരി, അതിനാൽ എനിക്കും പ്രതിധ്വനി ആവശ്യമില്ല
$term->setcc(VTIME, 1);
$term->setattr($fd_stdin, TCSANOW);
}
ഉപ പാകം {
$term->setflag($oterm);
$term->setcc(VTIME, 0);
$term->setattr($fd_stdin, TCSANOW);
}
സബ് റെഡികീ {
എന്റെ $കീ = '';
cbreak();
sysread(STDIN, $കീ, 1);
പാകം ചെയ്ത ();
തിരികെ $കീ;
}
അവസാനിപ്പിക്കുക { പാകംചെയ്തത്()}
1;
എങ്ങനെ do I ചെക്ക് എന്ന് ഇൻപുട്ട് is തയ്യാറാണ് on The കീബോർഡ്?
നോൺബ്ലോക്കിംഗ് മോഡിൽ ടേം::ReadKey ഉപയോഗിച്ച് ഒരു കീ വായിക്കുക എന്നതാണ് ഇതിനുള്ള എളുപ്പവഴി
CPAN-ൽ നിന്നുള്ള മൊഡ്യൂൾ, തടയരുതെന്ന് സൂചിപ്പിക്കുന്നതിന് -1 ന്റെ ആർഗ്യുമെന്റ് പാസാക്കുന്നു:
ടേം ഉപയോഗിക്കുക ::ReadKey;
റീഡ്മോഡ് ('cbreak');
എങ്കിൽ (നിർവചിച്ചിരിക്കുന്നത് (എന്റെ $char = ReadKey(-1)) ) {
# ഇൻപുട്ട് കാത്തിരിക്കുന്നു, അത് $char ആയിരുന്നു
} else {
# ഇൻപുട്ടൊന്നും കാത്തുനിന്നില്ല
}
റീഡ്മോഡ് ('സാധാരണ'); # സാധാരണ tty ക്രമീകരണങ്ങൾ പുനഃസ്ഥാപിക്കുക
എങ്ങനെ do I വ്യക്തമാക്കുക The സ്ക്രീൻ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
സ്ക്രീൻ ക്ലിയർ ചെയ്യാൻ, ടെർമിനലിനോട് പറയുന്ന പ്രത്യേക സീക്വൻസ് പ്രിന്റ് ചെയ്താൽ മതി
സ്ക്രീൻ ക്ലിയർ ചെയ്യാൻ. നിങ്ങൾക്ക് ആ ക്രമം ലഭിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് ക്ലിയർ ചെയ്യേണ്ട സമയത്ത് അത് ഔട്ട്പുട്ട് ചെയ്യുക
സ്ക്രീൻ.
പ്രത്യേക ക്രമം ലഭിക്കുന്നതിന് നിങ്ങൾക്ക് ടേം ::ANSISസ്ക്രീൻ മൊഡ്യൂൾ ഉപയോഗിക്കാം. "cls" ഇറക്കുമതി ചെയ്യുക
ഫംഗ്‌ഷൻ (അല്ലെങ്കിൽ ": സ്ക്രീൻ" ടാഗ്):
ടേം ഉപയോഗിക്കുക::ANSIScreen qw(cls);
എന്റെ $clear_screen = cls();
$clear_screen പ്രിന്റ് ചെയ്യുക;
ടേം::ക്യാപ് മൊഡ്യൂളിന് നിങ്ങൾക്ക് കുറഞ്ഞവ കൈകാര്യം ചെയ്യണമെങ്കിൽ പ്രത്യേക ശ്രേണിയും ലഭിക്കും.
ടെർമിനൽ നിയന്ത്രണത്തിന്റെ ലെവൽ വിശദാംശങ്ങൾ. "Tputs" രീതി തന്നിരിക്കുന്നതിനായുള്ള സ്ട്രിംഗ് നൽകുന്നു
കഴിവ്:
ടേം ഉപയോഗിക്കുക ::തൊപ്പി;
എന്റെ $ടെർമിനൽ = ടേം::Cap->Tgetent( {OSPEED => 9600 } );
എന്റെ $clear_string = $terminal->Tputs('cl');
$clear_screen പ്രിന്റ് ചെയ്യുക;
വിൻഡോസിൽ, നിങ്ങൾക്ക് Win32 :: കൺസോൾ മൊഡ്യൂൾ ഉപയോഗിക്കാം. ഔട്ട്പുട്ടിനായി ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിച്ച ശേഷം
നിങ്ങൾ ബാധിക്കാൻ ആഗ്രഹിക്കുന്ന ഫയൽ ഹാൻഡിൽ, "Cls" രീതി വിളിക്കുക:
Win32:: കൺസോൾ;
എന്റെ $OUT = Win32:: Console->new(STD_OUTPUT_HANDLE);
എന്റെ $clear_string = $OUT->Cls;
$clear_screen പ്രിന്റ് ചെയ്യുക;
നിങ്ങൾക്ക് ജോലി ചെയ്യുന്ന ഒരു കമാൻഡ്-ലൈൻ പ്രോഗ്രാം ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അതിനെ ബാക്ക്ടിക്കുകളിൽ വിളിക്കാം
അത് ഔട്ട്പുട്ട് ചെയ്യുന്നതെന്തും ക്യാപ്‌ചർ ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് അത് പിന്നീട് ഉപയോഗിക്കാനാകും:
എന്റെ $clear_string = `clear`;
$clear_string പ്രിന്റ് ചെയ്യുക;
എങ്ങനെ do I നേടുക The സ്ക്രീൻ വലുപ്പം?
നിങ്ങൾക്ക് CPAN-ൽ നിന്ന് Term ::ReadKey മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, വീതി ലഭ്യമാക്കാൻ നിങ്ങൾക്കത് ഉപയോഗിക്കാം
അക്ഷരങ്ങളിലും പിക്സലുകളിലും ഉയരം:
ടേം ഉപയോഗിക്കുക ::ReadKey;
എന്റെ ($wchar, $hchar, $wpixels, $hpixels) = GetTerminalSize();
ഇത് അസംസ്‌കൃത "ioctl" നേക്കാൾ കൂടുതൽ പോർട്ടബിൾ ആണ്, പക്ഷേ ചിത്രീകരണമല്ല:
'sys/ioctl.ph' ആവശ്യമാണ്;
നിർവചിച്ചിട്ടില്ലെങ്കിൽ "TIOCGWINSZ ഇല്ല" മരിക്കുക &TIOCGWINSZ;
തുറക്കുക(എന്റെ $tty_fh, "+
ഒഴികെ (ioctl($tty_fh, &TIOCGWINSZ, $winsize='')) {
ഡൈ സ്പ്രിന്റ്ഫ് "$0: ioctl TIOCGWINSZ (%08x: $!)\n", &TIOCGWINSZ;
}
എന്റെ ($row, $col, $xpixel, $ypixel) = അൺപാക്ക്('S4', $winsize);
പ്രിന്റ് "(റോ,കോൾ) = ($റോ,$കോൾ)";
പ്രിന്റ് " (xpixel,ypixel) = ($xpixel,$ypixel)" $xpixel ആണെങ്കിൽ || $ypixel;
"\n" അച്ചടിക്കുക;
എങ്ങനെ do I ചോദിക്കൂ The ഉപയോക്താവ് വേണ്ടി a password?
(ഈ ചോദ്യത്തിന് വെബുമായി യാതൊരു ബന്ധവുമില്ല. അതിനായി മറ്റൊരു പതിവ് ചോദ്യങ്ങൾ കാണുക.)
perlfunc-ലെ "crypt"-ൽ ഇതിന് ഒരു ഉദാഹരണമുണ്ട്). ആദ്യം, നിങ്ങൾ ടെർമിനൽ "ഇല്ല
എക്കോ" മോഡ്, തുടർന്ന് പാസ്വേഡ് സാധാരണ വായിക്കുക. നിങ്ങൾക്ക് ഇത് പഴയ ശൈലിയിൽ ചെയ്യാം
"ioctl()" പ്രവർത്തനം, POSIX ടെർമിനൽ നിയന്ത്രണം (POSIX അല്ലെങ്കിൽ അതിന്റെ ഡോക്യുമെന്റേഷൻ ഒട്ടകം കാണുക
ബുക്ക്), അല്ലെങ്കിൽ ഒരു കോൾ stty വ്യത്യസ്ത അളവിലുള്ള പോർട്ടബിലിറ്റി ഉള്ള പ്രോഗ്രാം.
CPAN-ൽ നിന്നുള്ള ടേം::ReadKey മൊഡ്യൂൾ ഉപയോഗിച്ച് മിക്ക സിസ്റ്റങ്ങളിലും നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും, അതായത്
ഉപയോഗിക്കാൻ എളുപ്പവും സിദ്ധാന്തത്തിൽ കൂടുതൽ പോർട്ടബിൾ.
ടേം ഉപയോഗിക്കുക ::ReadKey;
റീഡ്മോഡ് ('noecho');
എന്റെ $പാസ്വേഡ് = റീഡ്‌ലൈൻ(0);
എങ്ങനെ do I വായിക്കുക ഒപ്പം എഴുതുക The സീരിയൽ പോർട്ട്?
ഇത് നിങ്ങളുടെ പ്രോഗ്രാം ഏത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിലാണ് പ്രവർത്തിക്കുന്നത് എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. യുണിക്സിന്റെ കാര്യത്തിൽ,
" എന്നതിലെ ഫയലുകളിലൂടെ സീരിയൽ പോർട്ടുകൾ ആക്സസ് ചെയ്യാൻ കഴിയും/ dev"; മറ്റ് സിസ്റ്റങ്ങളിൽ, ഉപകരണം
പേരുകൾ തീർച്ചയായും വ്യത്യസ്തമായിരിക്കും. എല്ലാ ഉപകരണ ഇടപെടലിനും പൊതുവായ നിരവധി പ്രശ്ന മേഖലകൾ
ഇനിപ്പറയുന്നവ:
ലോക്ക് ഫയലുകൾ
ഒന്നിലധികം ആക്സസ് നിയന്ത്രിക്കാൻ നിങ്ങളുടെ സിസ്റ്റം ലോക്ക് ഫയലുകൾ ഉപയോഗിച്ചേക്കാം. നിങ്ങൾ പിന്തുടരുന്നത് ഉറപ്പാക്കുക
ശരിയായ പ്രോട്ടോക്കോൾ. ഒന്നിലധികം പ്രക്രിയകളുടെ വായനയിൽ നിന്ന് പ്രവചനാതീതമായ പെരുമാറ്റം ഉണ്ടാകാം
ഒരു ഉപകരണത്തിൽ നിന്ന്.
ഓപ്പൺ മോഡ്
ഉപകരണത്തിൽ റീഡ് ആൻഡ് റൈറ്റ് ഓപ്പറേഷനുകൾ ഉപയോഗിക്കാൻ നിങ്ങൾ പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ തുറക്കേണ്ടി വരും
ഇത് അപ്‌ഡേറ്റിനായി (വിശദാംശങ്ങൾക്ക് perlfunc-ലെ "ഓപ്പൺ" കാണുക). ഇത് കൂടാതെ തുറക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം
"sysopen()", "O_RDWR|O_NDELAY|O_NOCTTY" എന്നിവ ഉപയോഗിച്ച് തടയാനുള്ള സാധ്യത
Fcntl മൊഡ്യൂൾ (സാധാരണ പേൾ വിതരണത്തിന്റെ ഭാഗം). perlfunc-ൽ "sysopen" കാണുക
ഈ സമീപനത്തെക്കുറിച്ച് കൂടുതലറിയാൻ.
വരിയുടെ അവസാനം
ചില ഉപകരണങ്ങൾ ഓരോ വരിയുടെയും അവസാനം "\n" എന്നതിലുപരി "\r" പ്രതീക്ഷിക്കുന്നു. ഇൻ
perl, "\r", "\n" എന്നിവയുടെ ചില പോർട്ടുകൾ അവയുടെ സാധാരണ (Unix) ASCII മൂല്യങ്ങളിൽ നിന്ന് വ്യത്യസ്തമാണ്
"\015", "\012" എന്നിവയുടെ. നിങ്ങൾക്ക് ആവശ്യമുള്ള സംഖ്യാ മൂല്യങ്ങൾ നേരിട്ട് നൽകേണ്ടി വന്നേക്കാം
ഒക്ടൽ ("\015"), ഹെക്സ് ("0x0D"), അല്ലെങ്കിൽ ഒരു നിയന്ത്രണ-പ്രതീക സ്പെസിഫിക്കേഷനായി ("\cM").
DEV "atv1\012" പ്രിന്റ് ചെയ്യുക; # തെറ്റാണ്, ചില ഉപകരണങ്ങൾക്ക്
DEV "atv1\015" പ്രിന്റ് ചെയ്യുക; # ശരിയാണ്, ചില ഉപകരണങ്ങൾക്ക്
സാധാരണ ടെക്‌സ്‌റ്റ് ഫയലുകളിൽ "\n" ട്രിക്ക് ചെയ്യുമെങ്കിലും, ഇപ്പോഴും ഏകീകൃതമായിട്ടില്ല
Unix, DOS/Win, Macintosh എന്നിവയ്ക്കിടയിൽ പോർട്ടബിൾ ആയ ഒരു ലൈൻ അവസാനിപ്പിക്കുന്നതിനുള്ള സ്കീം,
അവസാനിപ്പിക്കുക ഒഴികെ എല്ലാം "\015\012" എന്നതിൽ വരി അവസാനിക്കുന്നു, കൂടാതെ നിങ്ങൾക്ക് ആവശ്യമില്ലാത്തത് നീക്കം ചെയ്യുക
ഔട്ട്പുട്ട്. ഇത് പ്രത്യേകിച്ച് സോക്കറ്റ് I/O, ഓട്ടോഫ്ലഷിംഗ് എന്നിവയ്ക്ക് ബാധകമാണ്, അടുത്തതായി ചർച്ചചെയ്യുന്നു.
ഫ്ലഷിംഗ് ഔട്ട്പുട്ട്
നിങ്ങൾ അവയെ "പ്രിന്റ്()" ചെയ്യുമ്പോൾ നിങ്ങളുടെ ഉപകരണത്തിലേക്ക് പ്രതീകങ്ങൾ ലഭിക്കുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ അത് ചെയ്യണം
ആ ഫയൽ ഹാൻഡിൽ ഓട്ടോഫ്ലഷ് ചെയ്യുക. നിങ്ങൾക്ക് "select()" ഉം $|ഉം ഉപയോഗിക്കാം നിയന്ത്രിക്കാനുള്ള വേരിയബിൾ
ഓട്ടോഫ്ലഷിംഗ് (perlvar-ൽ "$|" കാണുക, perlfunc-ൽ "തിരഞ്ഞെടുക്കുക", അല്ലെങ്കിൽ perlfaq5, "എങ്ങനെ ചെയ്യാം"
ഒരു ഔട്ട്പുട്ട് ഫയൽഹാൻഡിൽ ഫ്ലഷ്/അൺബഫർ ചെയ്യണോ? എന്തുകൊണ്ടാണ് ഞാൻ ഇത് ചെയ്യേണ്ടത്?"):
എന്റെ $old_handle = തിരഞ്ഞെടുക്കുക($dev_fh);
$| = 1;
തിരഞ്ഞെടുക്കുക($old_handle);
ഒരു താൽക്കാലിക വേരിയബിളില്ലാതെ ഇത് ചെയ്യുന്ന കോഡും നിങ്ങൾ കാണും
തിരഞ്ഞെടുക്കുക((select($deb_handle), $| = 1)[0]);
അല്ലെങ്കിൽ നിങ്ങളാണെന്ന കാരണത്താൽ ആയിരക്കണക്കിന് വരി കോഡ് വലിച്ചിടുന്നതിൽ നിങ്ങൾക്ക് പ്രശ്‌നമില്ലെങ്കിൽ
അല്പം $| വേരിയബിൾ:
IO::ഹാൻഡിൽ ഉപയോഗിക്കുക;
$dev_fh->ഓട്ടോഫ്ലഷ്(1);
മുമ്പത്തെ ഇനത്തിൽ സൂചിപ്പിച്ചതുപോലെ, സോക്കറ്റ് I/O ഉപയോഗിക്കുമ്പോൾ ഇത് ഇപ്പോഴും പ്രവർത്തിക്കില്ല
Unix-നും Macintosh-നും ഇടയിൽ. അതിൽ നിങ്ങളുടെ ലൈൻ ടെർമിനേറ്ററുകൾ ഹാർഡ് കോഡ് ചെയ്യേണ്ടതുണ്ട്
കേസ്.
നോൺ-ബ്ലോക്കിംഗ് ഇൻപുട്ട്
നിങ്ങൾ ഒരു തടയൽ "വായന()" അല്ലെങ്കിൽ "sysread()" ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾ അതിനായി ക്രമീകരിക്കേണ്ടതുണ്ട്.
സമയപരിധി നൽകുന്നതിനുള്ള അലാറം ഹാൻഡ്‌ലർ (perlfunc-ലെ "അലാറം" കാണുക). നിങ്ങൾക്ക് അല്ലാത്ത ഒന്ന് ഉണ്ടെങ്കിൽ
തുറക്കുന്നത് തടയുന്നു, നിങ്ങൾക്ക് ഒരു നോൺ-ബ്ലോക്ക് റീഡ് ഉണ്ടായിരിക്കും, അതിനർത്ഥം നിങ്ങൾ ഉപയോഗിക്കേണ്ടി വന്നേക്കാം എന്നാണ്
ആ ഉപകരണത്തിൽ I/O തയ്യാറാണോ എന്ന് നിർണ്ണയിക്കാൻ ഒരു 4-arg "select()" ("select" കാണുക"
പെർഫങ്ക്.
തന്റെ കോളർ-ഐഡി ബോക്സിൽ നിന്ന് വായിക്കാൻ ശ്രമിക്കുമ്പോൾ, കുപ്രസിദ്ധനായ ജാമി സാവിൻസ്കി
"<[ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു]>", പല്ലുകൾ കടിച്ചുകീറി, "സിസ്റെഡ്", "സിസോപ്പൻ" എന്നിവയുമായി വഴക്കിട്ടതിന് ശേഷം,
POSIX-ന്റെ "tcgetattr" ബിസിനസ്സും രാത്രിയിൽ കുതിച്ചുയരുന്ന മറ്റ് വിവിധ ഫംഗ്ഷനുകളും,
ഒടുവിൽ ഇതുമായി വന്നു:
ഉപ open_modem {
IPC ഉപയോഗിക്കുക ::Open2;
എന്റെ $stty = `/ ബിൻ / സ്റ്റ്ടി -g`;
open2( \*MODEM_IN, \*MODEM_OUT, "cu -l$modem_device -s2400 2>&1");
# സ്റ്റാർട്ടിംഗ് ക്യൂ ഹോസുകൾ /dev/tty യുടെ stty ക്രമീകരണങ്ങൾ ഉള്ളപ്പോൾ പോലും
# പൈപ്പിൽ തുറന്നു...
സിസ്റ്റം ("/ ബിൻ / സ്റ്റ്ടി $stty");
$_ = ;
ചോമ്പ്;
എങ്കിൽ (!m/^കണക്‌റ്റ്/) {
പ്രിന്റ് STDERR "$0: `കണക്‌റ്റഡ്'\n" എന്നതിനുപകരം `$_' എന്ന് അച്ചടിച്ചു;
}
}
എങ്ങനെ do I ഡീകോഡ് ചെയ്യുക എൻക്രിപ്റ്റ് പാസ്വേഡ് ഫയലുകൾ?
സമർപ്പിത ഹാർഡ്‌വെയറിനായി നിങ്ങൾ ധാരാളം പണം ചിലവഴിക്കുന്നു, പക്ഷേ ഇത് നിങ്ങൾക്ക് ലഭിക്കും
കുറിച്ച് സംസാരിച്ചു.
ഗുരുതരമായി, അവ Unix പാസ്വേഡ് ഫയലുകളാണെങ്കിൽ നിങ്ങൾക്ക് കഴിയില്ല --Unix പാസ്വേഡ് സിസ്റ്റം ഉപയോഗിക്കുന്നു
വൺ-വേ എൻക്രിപ്ഷൻ. ഇത് എൻക്രിപ്ഷനേക്കാൾ ഹാഷിംഗ് പോലെയാണ്. നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയുന്ന ഏറ്റവും മികച്ചത് പരിശോധിക്കുന്നതാണ്
അതേ സ്ട്രിംഗിൽ മറ്റെന്തെങ്കിലും ഹാഷുകൾ ഉണ്ടോ എന്ന്. നിങ്ങൾക്ക് ഒരു ഹാഷ് തിരികെ അതിലേക്ക് മാറ്റാൻ കഴിയില്ല
യഥാർത്ഥ സ്ട്രിംഗ്. ക്രാക്ക് പോലുള്ള പ്രോഗ്രാമുകൾ നിർബന്ധമായും (ബുദ്ധിപരമായി) ഊഹിക്കാൻ ശ്രമിക്കും
പാസ്‌വേഡുകൾ, എന്നാൽ പെട്ടെന്നുള്ള വിജയം ഉറപ്പ് നൽകരുത് (കഴിവില്ല).
ഉപയോക്താക്കൾ മോശം പാസ്‌വേഡുകൾ തിരഞ്ഞെടുക്കുന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് ആശങ്കയുണ്ടെങ്കിൽ, എപ്പോഴാണെന്ന് നിങ്ങൾ മുൻകൂട്ടി പരിശോധിക്കണം
അവർ അവരുടെ പാസ്വേഡ് മാറ്റാൻ ശ്രമിക്കുന്നു (പരിഷ്‌ക്കരിച്ചുകൊണ്ട് പാസ്സ്വേർഡ്(1), ഉദാഹരണത്തിന്).
എങ്ങനെ do I തുടക്കം a പ്രക്രിയ in The പശ്ചാത്തലം?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
പശ്ചാത്തലത്തിൽ കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരൊറ്റ മാർഗവുമില്ല, അതിനാൽ നിങ്ങൾ അതിനായി കാത്തിരിക്കേണ്ടതില്ല
നിങ്ങളുടെ പ്രോഗ്രാം മറ്റ് ജോലികളിലേക്ക് നീങ്ങുന്നതിന് മുമ്പ് പൂർത്തിയാക്കുക. പ്രോസസ്സ് മാനേജ്മെന്റ് നിങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു
പ്രത്യേക ഓപ്പറേറ്റിംഗ് സിസ്റ്റം, കൂടാതെ പല സാങ്കേതിക വിദ്യകളും പെർലിപ്‌സിയിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.
IPC::Open2 അല്ലെങ്കിൽ IPC::Open3, IPC::Run, ഉൾപ്പെടെ നിരവധി CPAN മൊഡ്യൂളുകൾക്ക് സഹായിക്കാൻ കഴിഞ്ഞേക്കും.
സമാന്തര:: ജോലികൾ, സമാന്തര:: ഫോർക്ക് മാനേജർ, POE, പ്രോ:: പശ്ചാത്തലം, ഒപ്പം Win32:: പ്രക്രിയ. അവിടെ
നിങ്ങൾ ഉപയോഗിച്ചേക്കാവുന്ന മറ്റ് നിരവധി മൊഡ്യൂളുകളാണ്, അതിനാൽ മറ്റ് ഓപ്ഷനുകൾക്കായി ആ നെയിംസ്പേസുകളും പരിശോധിക്കുക.
നിങ്ങൾ ഒരു Unix-പോലുള്ള സിസ്റ്റത്തിലാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരു സിസ്റ്റം കോൾ ഉപയോഗിച്ച് രക്ഷപ്പെടാൻ കഴിഞ്ഞേക്കും
കമാൻഡിന്റെ അവസാനം നിങ്ങൾ ഒരു "&" ഇട്ടു:
സിസ്റ്റം ("cmd &")
perlfunc-ൽ വിവരിച്ചിരിക്കുന്നതുപോലെ നിങ്ങൾക്ക് "ഫോർക്ക്" ഉപയോഗിക്കാനും ശ്രമിക്കാവുന്നതാണ് (ഇത് തന്നെയാണെങ്കിലും
പല മൊഡ്യൂളുകളും നിങ്ങൾക്കായി ചെയ്യും).
STDIN, STDOUT, STDERR എന്നിവ പങ്കിട്ടു
പ്രധാന പ്രക്രിയയും പശ്ചാത്തലമുള്ളവയും ("കുട്ടി" പ്രക്രിയ) ഒരേപോലെ പങ്കിടുന്നു
STDIN, STDOUT, STDERR ഫയൽഹാൻഡിലുകൾ. ഇരുവരും ഒരേസമയം അവ ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, വിചിത്രം
കാര്യങ്ങൾ സംഭവിക്കാം. കുട്ടിക്ക് വേണ്ടി ഇവ അടയ്ക്കുകയോ വീണ്ടും തുറക്കുകയോ ചെയ്യാം. നിങ്ങൾക്ക് കിട്ടാം
ഇതിന് ചുറ്റും ഒരു പൈപ്പ് "തുറക്കുക" (perlfunc-ൽ "തുറക്കുക" കാണുക) എന്നാൽ ചില സിസ്റ്റങ്ങളിൽ ഇത്
കുട്ടിയുടെ പ്രക്രിയയ്ക്ക് മാതാപിതാക്കളെ മറികടക്കാൻ കഴിയില്ല എന്നാണ്.
സിഗ്നലുകൾ
നിങ്ങൾ SIGCHLD സിഗ്നൽ പിടിക്കേണ്ടതുണ്ട്, ഒരുപക്ഷേ SIGPIPE-ഉം. SIGCHLD അയച്ചു
പശ്ചാത്തലത്തിലുള്ള പ്രക്രിയ പൂർത്തിയാകുമ്പോൾ. നിങ്ങൾ ഒരു ഫയൽ ഹാൻഡിലിലേക്ക് എഴുതുമ്പോൾ SIGPIPE അയയ്ക്കുന്നു
ആരുടെ ചൈൽഡ് പ്രോസസ്സ് അവസാനിച്ചു (ട്രാപ്പ് ചെയ്യപ്പെടാത്ത SIGPIPE നിങ്ങളുടെ പ്രോഗ്രാമിന് കാരണമാകും
നിശബ്ദമായി മരിക്കുക). ഇത് "സിസ്റ്റം("cmd&")" എന്നതിലെ ഒരു പ്രശ്നമല്ല.
തങ്ങള്
ചൈൽഡ് പ്രോസസ്സ് പൂർത്തിയാകുമ്പോൾ അത് "കൊയ്യാൻ" നിങ്ങൾ തയ്യാറായിരിക്കണം.
$SIG{CHLD} = ഉപ {കാത്തിരിക്കുക};
$SIG{CHLD} = 'അവഗണിക്കുക';
നിങ്ങൾക്ക് ഒരു ഇരട്ട ഫോർക്ക് ഉപയോഗിക്കാം. നിങ്ങളുടെ ആദ്യ കുട്ടിക്കായി നിങ്ങൾ ഉടൻ തന്നെ "കാത്തിരിക്കുക()", ഒപ്പം
നിങ്ങളുടെ പേരക്കുട്ടി പുറത്തുകടന്നാൽ init ഡെമൺ "കാത്തിരിക്കും()".
അല്ലാതെ ($pid = ഫോർക്ക്) {
അല്ലാതെ (നാൽക്കവല) {
exec "നിങ്ങൾ ശരിക്കും എന്താണ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നത്";
ഡൈ "എക്സിക്യൂട്ടീവ് പരാജയപ്പെട്ടു!";
}
പുറത്തുകടക്കുക 0;
}
വെയ്റ്റ്പിഡ് ($pid, 0);
ഇത് ചെയ്യുന്നതിന് കോഡിന്റെ മറ്റ് ഉദാഹരണങ്ങൾക്കായി perlipc-ലെ "സിഗ്നലുകൾ" കാണുക. സോമ്പികൾ ഒരു അല്ല
"സിസ്റ്റം("പ്രോഗ് &")" പ്രശ്നം.
എങ്ങനെ do I കെണി നിയന്ത്രണം പ്രതീകങ്ങൾ/സിഗ്നലുകൾ?
നിങ്ങൾ യഥാർത്ഥത്തിൽ ഒരു നിയന്ത്രണ പ്രതീകത്തെ "ട്രാപ്പ്" ചെയ്യില്ല. പകരം, ആ പ്രതീകം ഒരു സിഗ്നൽ സൃഷ്ടിക്കുന്നു
നിങ്ങളുടെ ടെർമിനലിന്റെ നിലവിൽ ഫോർഗ്രൗണ്ടഡ് പ്രോസസ് ഗ്രൂപ്പിലേക്ക് അയയ്‌ക്കുന്നത്, അത് നിങ്ങൾ ട്രാപ്പ് ചെയ്യുന്നു
നിങ്ങളുടെ പ്രക്രിയയിൽ. പെർലിപ്‌സിയിലെ "സിഗ്നലുകൾ" എന്നതിലും സെക്ഷനിലും സിഗ്നലുകൾ രേഖപ്പെടുത്തുന്നു
ഒട്ടകത്തിലെ "സിഗ്നലുകൾ".
നിങ്ങൾ സിഗ്നൽ കൈകാര്യം ചെയ്യാൻ ആഗ്രഹിക്കുന്ന ഫംഗ്‌ഷനുകളായി %SIG ഹാഷിന്റെ മൂല്യങ്ങൾ സജ്ജമാക്കാൻ കഴിയും.
perl സിഗ്നൽ പിടിച്ചതിന് ശേഷം, അതേ പേരിലുള്ള ഒരു കീക്കായി %SIG-ൽ നോക്കുന്നു
സിഗ്നൽ, തുടർന്ന് ആ കീയുടെ സബ്റൂട്ടീൻ മൂല്യത്തെ വിളിക്കുന്നു.
# ഒരു അജ്ഞാത സബ്റൂട്ടീനായി
$SIG{INT} = ഉപ {syswrite(STDERR, "ouch\n", 5 )};
# അല്ലെങ്കിൽ ഒരു ഫംഗ്‌ഷനിലേക്കുള്ള റഫറൻസ്
$SIG{INT} = \&ouch;
# അല്ലെങ്കിൽ ഫംഗ്‌ഷന്റെ പേര് ഒരു സ്ട്രിംഗായി
$SIG{INT} = "ouch";
5.8-ന് മുമ്പുള്ള പേൾ പതിപ്പുകൾ അതിന്റെ സി സോഴ്സ് കോഡ് സിഗ്നൽ ഹാൻഡ്‌ലറുകളിൽ ഉണ്ടായിരുന്നു
നിങ്ങൾ %SIG-ൽ സജ്ജീകരിച്ചിട്ടുള്ള ഒരു പേൾ ഫംഗ്‌ഷൻ സിഗ്നൽ ചെയ്യുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യാം. ഇത് ചട്ടങ്ങൾ ലംഘിച്ചു
ആ ലെവലിൽ സിഗ്നൽ കൈകാര്യം ചെയ്യുന്നത് perl ഡംപ് കോർ ഉണ്ടാക്കുന്നു. പതിപ്പ് 5.8.0 മുതൽ, perl
%SIG നോക്കുന്നു ശേഷം പിടിക്കപ്പെടുമ്പോൾ സിഗ്നൽ പിടിക്കപ്പെട്ടിരിക്കുന്നു.
ഈ ഉത്തരത്തിന്റെ മുൻ പതിപ്പുകൾ തെറ്റായിരുന്നു.
എങ്ങനെ do I പരിഷ്ക്കരിക്കുക The നിഴൽ പാസ്വേഡ് ഫയല് on a യൂണിക്സ് സിസ്റ്റം?
perl ശരിയായി ഇൻസ്റ്റാൾ ചെയ്യുകയും നിങ്ങളുടെ ഷാഡോ ലൈബ്രറി ശരിയായി എഴുതുകയും ചെയ്തിട്ടുണ്ടെങ്കിൽ,
perlfunc-ൽ വിവരിച്ചിരിക്കുന്ന "getpw*()" ഫംഗ്ഷനുകൾ സൈദ്ധാന്തികമായി (വായന-മാത്രം) ആക്സസ് നൽകണം
ഷാഡോ പാസ്വേഡ് ഫയലിലെ എൻട്രികൾ. ഫയൽ മാറ്റാൻ, ഒരു പുതിയ ഷാഡോ പാസ്വേഡ് ഫയൽ ഉണ്ടാക്കുക
(സിസ്റ്റം മുതൽ സിസ്റ്റം വരെ ഫോർമാറ്റ് വ്യത്യാസപ്പെടുന്നു--കാണുക പാസ്സ്വേർഡ്(1) പ്രത്യേകതകൾക്കായി) ഉപയോഗവും pwd_mkdb(8)
ഇത് ഇൻസ്റ്റാൾ ചെയ്യാൻ (കാണുക pwd_mkdb(8) കൂടുതൽ വിവരങ്ങൾക്ക്).
എങ്ങനെ do I ഗണം The കാലം ഒപ്പം തീയതി?
മതിയായ അനുമതികൾക്ക് കീഴിലാണ് നിങ്ങൾ പ്രവർത്തിക്കുന്നതെന്ന് കരുതുക, നിങ്ങൾക്ക് ഇത് സജ്ജീകരിക്കാനാകും
പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ സിസ്റ്റം-വൈഡ് തീയതിയും സമയവും തീയതി(1) പ്രോഗ്രാം. (സമയം നിശ്ചയിക്കാൻ വഴിയില്ല
ഓരോ പ്രോസസ്സ് അടിസ്ഥാനത്തിലും തീയതിയും.) ഈ സംവിധാനം Unix, MS-DOS, Windows, കൂടാതെ
NT; VMS തത്തുല്യമായത് "സമയം സജ്ജമാക്കുക" ആണ്.
എന്നിരുന്നാലും, നിങ്ങൾ ചെയ്യേണ്ടത് നിങ്ങളുടെ സമയ മേഖല മാറ്റുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഒരുപക്ഷേ അതിൽ നിന്ന് രക്ഷപ്പെടാം
ഒരു പരിസ്ഥിതി വേരിയബിൾ ക്രമീകരിക്കുന്നു:
$ENV{TZ} = "MST7MDT"; # Unixish
$ENV{'SYS$TIMEZONE_DIFFERENTIAL'}="-5" # vms
സിസ്റ്റം('trn', 'comp.lang.perl.misc');
എങ്ങനെ കഴിയും I ഉറക്കം() or അലാറം() വേണ്ടി കീഴെ a രണ്ടാമത്തേത്?
"സ്ലീപ്പ്()" ഫംഗ്‌ഷൻ നൽകുന്ന 1 സെക്കൻഡിനേക്കാൾ മികച്ച ഗ്രാനുലാരിറ്റി നിങ്ങൾക്ക് വേണമെങ്കിൽ,
perlfunc-ൽ "select" എന്നതിൽ രേഖപ്പെടുത്തിയിരിക്കുന്ന പോലെ "select()" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം. ശ്രമിക്കുക
സമയം:: HiRes ഉം BSD ഉം:: Itimer മൊഡ്യൂളുകൾ (CPAN-ൽ നിന്ന് ലഭ്യമാണ്, കൂടാതെ Perl-ൽ നിന്ന് ആരംഭിക്കുന്നു
5.8 സമയം ::HiRes സ്റ്റാൻഡേർഡ് ഡിസ്ട്രിബ്യൂഷന്റെ ഭാഗമാണ്).
എങ്ങനെ കഴിയും I അളക്കുക കാലം കീഴെ a രണ്ടാമത്തേത്?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
സമയം::HiRes മൊഡ്യൂൾ (Perl 5.8-ലെ സ്റ്റാൻഡേർഡ് വിതരണത്തിന്റെ ഭാഗം) സമയം അളക്കുന്നു
"gettimeofday()" സിസ്റ്റം കോളിനൊപ്പം, അത് മുതൽ മൈക്രോസെക്കൻഡിൽ സമയം നൽകുന്നു
യുഗം. നിങ്ങൾക്ക് സമയം::പഴയ Perls-ന് HiRes ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ നിങ്ങൾ ഒരു Unixish സിസ്റ്റത്തിലാണെങ്കിൽ,
നിങ്ങൾക്ക് വിളിക്കാൻ കഴിഞ്ഞേക്കും കിട്ടുന്ന സമയം(2) നേരിട്ട്. perlfunc-ൽ "syscal" കാണുക.
എങ്ങനെ കഴിയും I do an atexit() or setjmp()/longjmp()? (ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യുന്നു)
"atexit()" അനുകരിക്കാൻ നിങ്ങൾക്ക് "END" ബ്ലോക്ക് ഉപയോഗിക്കാം. ഓരോ പാക്കേജിന്റെയും "END" ബ്ലോക്കിനെ വിളിക്കുന്നു
പ്രോഗ്രാം അല്ലെങ്കിൽ ത്രെഡ് അവസാനിക്കുമ്പോൾ. "END" എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് perlmod manpage കാണുക
ബ്ലോക്കുകൾ.
ഉദാഹരണത്തിന്, നിങ്ങളുടെ ഫിൽട്ടർ പ്രോഗ്രാമിന് അത് പൂർത്തിയാക്കാൻ കഴിഞ്ഞെന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം
ഡിസ്ക് പൂരിപ്പിക്കാതെ ഔട്ട്പുട്ട്:
അവസാനിക്കുന്നു {
അടയ്ക്കുക(STDOUT) || മരിക്കുക "stdout ക്ലോസ് പരാജയപ്പെട്ടു: $!";
}
ട്രാപ്പ് ചെയ്യപ്പെടാത്ത സിഗ്നലുകൾ പ്രോഗ്രാമിനെ നശിപ്പിക്കുമ്പോൾ "END" ബ്ലോക്ക് വിളിക്കപ്പെടുന്നില്ല, നിങ്ങളാണെങ്കിൽ
നിങ്ങൾ ഉപയോഗിക്കേണ്ട "END" ബ്ലോക്കുകൾ ഉപയോഗിക്കുക
sigtrap qw (ഡൈ നോർമൽ-സിഗ്നലുകൾ) ഉപയോഗിക്കുക;
പേളിന്റെ എക്‌സ്‌പ്‌ഷൻ-ഹാൻഡ്‌ലിംഗ് മെക്കാനിസം അതിന്റെ "eval()" ഓപ്പറേറ്ററാണ്. നിങ്ങൾക്ക് "eval()" ആയി ഉപയോഗിക്കാം
"setjmp", "die()" എന്നിവ "longjmp" ആയി. ഇതിന്റെ വിശദാംശങ്ങൾക്ക്, സിഗ്നലുകളെക്കുറിച്ചുള്ള വിഭാഗം കാണുക,
പ്രത്യേകിച്ച് perlipc-ലെ "സിഗ്നലുകൾ" എന്നതിലെ "ഫ്ലോക്ക്()" തടയുന്നതിനുള്ള സമയപരിധി
"സിഗ്നലുകൾ" എന്ന വിഭാഗത്തിൽ പ്രോഗ്രാമിംഗ് പേൾ.
ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യലാണ് നിങ്ങൾക്ക് താൽപ്പര്യമെങ്കിൽ, നിരവധി CPAN മൊഡ്യൂളുകളിൽ ഒന്ന് ഉപയോഗിക്കുക
Try ::Tiny പോലുള്ള ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുക.
നിങ്ങൾക്ക് "atexit()" വാക്യഘടനയും (ഒരു "rmexit()" ഉം വേണമെങ്കിൽ, "AtExit" മൊഡ്യൂൾ പരീക്ഷിക്കുക
CPAN-ൽ നിന്ന് ലഭ്യമാണ്.
എന്തുകൊണ്ട് ഇല്ല my സോക്കറ്റുകൾ പ്രോഗ്രാം വേല കീഴെ സിസ്റ്റം V (സോളാരിസ്)? എന്ത് ചെയ്യുന്നവൻ The പിശക് സന്ദേശം
"പ്രോട്ടോക്കോൾ അല്ല പിന്തുണച്ചു" അർത്ഥമാക്കുന്നത്?
ചില Sys-V അടിസ്ഥാനമാക്കിയുള്ള സിസ്റ്റങ്ങൾ, പ്രത്യേകിച്ച് സോളാരിസ് 2.X, സാധാരണ സോക്കറ്റുകളിൽ ചിലത് പുനർ നിർവചിച്ചു.
സ്ഥിരാങ്കങ്ങൾ. എല്ലാ വാസ്തുവിദ്യകളിലും ഇവ സ്ഥിരമായതിനാൽ, അവ പലപ്പോഴും കഠിനമായവയായിരുന്നു
perl കോഡിലേക്ക്. ഇത് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശരിയായ മാർഗ്ഗം, ശരിയായത് ലഭിക്കാൻ "സോക്കറ്റ് ഉപയോഗിക്കുക" എന്നതാണ്
മൂല്യങ്ങൾ.
SunOS ഉം Solaris ഉം ബൈനറി അനുയോജ്യമാണെങ്കിലും, ഈ മൂല്യങ്ങൾ വ്യത്യസ്തമാണ്.
ചിത്രം പോകൂ.
എങ്ങനെ കഴിയും I വിളി my സിസ്റ്റത്തിന്റെ അതുല്യമായ C ഫംഗ്ഷനുകളും നിന്ന് പേർൾ?
മിക്ക കേസുകളിലും, നിങ്ങൾ അത് ചെയ്യാൻ ഒരു ബാഹ്യ മൊഡ്യൂൾ എഴുതുന്നു - "എനിക്ക് എവിടെ പഠിക്കാനാകും" എന്നതിനുള്ള ഉത്തരം കാണുക
സിയെ പേളുമായി ബന്ധിപ്പിക്കുന്നതിനെക്കുറിച്ച്? [h2xs, xsubpp]". എന്നിരുന്നാലും, ഫംഗ്‌ഷൻ ഒരു സിസ്റ്റം കോളാണെങ്കിൽ,
നിങ്ങളുടെ സിസ്റ്റം "syscall()" പിന്തുണയ്ക്കുന്നു, നിങ്ങൾക്ക് "syscall" ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം (രേഖപ്പെടുത്തിയിരിക്കുന്നു
പെർഫങ്ക്).
നിങ്ങളുടെ വിതരണത്തോടൊപ്പം വന്ന മൊഡ്യൂളുകളും CPAN-ഉം പരിശോധിക്കാൻ ഓർക്കുക--മറ്റൊരാൾ
ഇത് ചെയ്യുന്നതിന് ഇതിനകം ഒരു മൊഡ്യൂൾ എഴുതിയിട്ടുണ്ടാകാം. വിൻഡോസിൽ, Win32::API പരീക്ഷിക്കുക. Macs-ൽ, ശ്രമിക്കുക
മാക്::കാർബൺ. ഒരു മൊഡ്യൂളിനും C ഫംഗ്‌ഷനിലേക്ക് ഒരു ഇന്റർഫേസ് ഇല്ലെങ്കിൽ, നിങ്ങൾക്ക് ഒരു ബിറ്റ് C ഇൻലൈൻ ചെയ്യാം
ഇൻലൈൻ::C ഉള്ള നിങ്ങളുടെ പേൾ ഉറവിടം.
എവിടെ do I നേടുക The ഉൾപ്പെടുന്നു ഫയലുകൾ ലേക്ക് do ioctl() or syscal()?
ചരിത്രപരമായി, ഇവ സാധാരണ perl-ന്റെ ഭാഗമായ h2ph ടൂൾ വഴി ജനറേറ്റ് ചെയ്യപ്പെടും
വിതരണ. ഈ പ്രോഗ്രാം പരിവർത്തനം ചെയ്യുന്നു സിപിപി(1) ഫയലുകളിലേക്കുള്ള സി ഹെഡ്ഡർ ഫയലുകളിലെ നിർദ്ദേശങ്ങൾ
നിങ്ങൾക്ക് ആർഗ്യുമെന്റായി ഉപയോഗിക്കാവുന്ന "SYS_getitimer()" പോലുള്ള സബ്റൂട്ടീൻ നിർവചനങ്ങൾ അടങ്ങിയിരിക്കുന്നു
നിങ്ങളുടെ പ്രവർത്തനങ്ങളിലേക്ക്. ഇത് പൂർണ്ണമായി പ്രവർത്തിക്കുന്നില്ല, പക്ഷേ ഇത് സാധാരണയായി മിക്ക ജോലികളും ചെയ്യുന്നു.
പോലുള്ള ലളിതമായ ഫയലുകൾ errno.h, syscal.h, ഒപ്പം socket.h നന്നായിരിക്കുന്നു, പക്ഷേ കഠിനമായവ ഇഷ്ടപ്പെടുന്നു
ioctl.h മിക്കവാറും എപ്പോഴും കൈകൊണ്ട് എഡിറ്റ് ചെയ്യേണ്ടതുണ്ട്. *.ph ഫയലുകൾ എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം എന്നത് ഇതാ:
1. സൂപ്പർ യൂസർ ആകുക
2. സിഡി / usr / ഉൾപ്പെടുത്തുക
3. h2ph *.h */*.h
നിങ്ങളുടെ സിസ്റ്റം ഡൈനാമിക് ലോഡിംഗ് പിന്തുണയ്‌ക്കുന്നുവെങ്കിൽ, പോർട്ടബിലിറ്റിയും സാനിറ്റിയും ഉള്ള കാരണങ്ങളാൽ
ഒരുപക്ഷേ h2xs ഉപയോഗിക്കേണ്ടി വരും (സാധാരണ perl വിതരണത്തിന്റെ ഭാഗവും). ഈ ഉപകരണം
C തലക്കെട്ട് ഫയലുകളെ Perl എക്സ്റ്റൻഷനുകളാക്കി മാറ്റുന്നു. എങ്ങനെ തുടങ്ങാം എന്നറിയാൻ perlxstut കാണുക
h2xs.
നിങ്ങളുടെ സിസ്റ്റം ഡൈനാമിക് ലോഡിംഗ് പിന്തുണയ്ക്കുന്നില്ലെങ്കിൽ, നിങ്ങൾ ഇപ്പോഴും h2xs ഉപയോഗിക്കേണ്ടി വരും. കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് perlxstut, ExtUtils:: MakeMaker (ചുരുക്കത്തിൽ, ഉപയോഗിക്കുക ഉണ്ടാക്കുക മുത്ത്
ഒരു സമതലത്തിനു പകരം ഉണ്ടാക്കുക ഒരു പുതിയ സ്റ്റാറ്റിക് എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് perl പുനർനിർമ്മിക്കാൻ).
എന്തുകൊണ്ട് do setuid മുത്ത് സ്ക്രിപ്റ്റുകൾ പരാതിപ്പെടുക കുറിച്ച് കെർണൽ പ്രശ്നങ്ങൾ?
ചില ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾക്ക് കേർണലിൽ ബഗുകൾ ഉണ്ട്, അത് സെറ്റ്യൂഡ് സ്ക്രിപ്റ്റുകൾ അന്തർലീനമാക്കുന്നു
അരക്ഷിതാവസ്ഥ. അത്തരത്തിൽ പ്രവർത്തിക്കുന്നതിന് Perl നിങ്ങൾക്ക് നിരവധി ഓപ്ഷനുകൾ (perlsec-ൽ വിവരിച്ചിരിക്കുന്നു) നൽകുന്നു
സിസ്റ്റങ്ങൾ.
എങ്ങനെ കഴിയും I തുറക്കുക a പൈപ്പ് രണ്ടും ലേക്ക് ഒപ്പം നിന്ന് a കമാൻഡ്?
IPC ::Open2 മൊഡ്യൂൾ (സാധാരണ പേൾ വിതരണത്തിന്റെ ഭാഗം) ഉപയോഗിക്കാൻ എളുപ്പമുള്ള ഒരു സമീപനമാണ്
ജോലി ചെയ്യാൻ ആന്തരികമായി "പൈപ്പ്()", "ഫോർക്ക്()", "എക്‌സെക്()" എന്നിവ ഉപയോഗിക്കുന്നു. വായിക്കുന്നത് ഉറപ്പാക്കുക
എന്നിരുന്നാലും അതിന്റെ ഡോക്യുമെന്റേഷനിലെ ഡെഡ്‌ലോക്ക് മുന്നറിയിപ്പുകൾ (IPC::Open2 കാണുക). "ബൈഡയറക്ഷണൽ" കാണുക
പെർലിപ്‌സിയിൽ മറ്റൊരു പ്രക്രിയയുമായുള്ള ആശയവിനിമയവും "ബൈഡയറക്ഷണൽ കമ്മ്യൂണിക്കേഷനുമായി
സ്വയം" perlipc-ൽ
നിങ്ങൾക്ക് IPC ::Open3 മൊഡ്യൂളും ഉപയോഗിക്കാം (സാധാരണ പേൾ വിതരണത്തിന്റെ ഭാഗം), എന്നാൽ ആയിരിക്കുക
IPC::Open2-ൽ നിന്ന് വ്യത്യസ്തമായ വാദഗതികൾ ഇതിന് ഉണ്ടെന്ന് മുന്നറിയിപ്പ് നൽകി (IPC::Open3 കാണുക).
എന്തുകൊണ്ട് കഴിയില്ല I നേടുക The ഔട്ട്പുട്ട് of a കമാൻഡ് കൂടെ സിസ്റ്റം()?
"സിസ്റ്റം()", ബാക്ക്ടിക്കുകൾ (``) എന്നിവയുടെ ഉദ്ദേശ്യം നിങ്ങൾ ആശയക്കുഴപ്പത്തിലാക്കുകയാണ്. "system()" ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു
എക്സിറ്റ് സ്റ്റാറ്റസ് വിവരങ്ങൾ നൽകുന്നു (16 ബിറ്റ് മൂല്യമായി: കുറഞ്ഞ 7 ബിറ്റുകൾ സിഗ്നൽ ആണ്
പ്രോസസ് ഡൈഡ്, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, ഉയർന്ന 8 ബിറ്റുകൾ യഥാർത്ഥ എക്സിറ്റ് മൂല്യമാണ്). ബാക്ക്ടിക്കുകൾ (``)
ഒരു കമാൻഡ് പ്രവർത്തിപ്പിച്ച് അത് STDOUT-ലേക്ക് അയച്ചത് തിരികെ നൽകുക.
എന്റെ $exit_status = സിസ്റ്റം("മെയിൽ-ഉപയോക്താക്കൾ");
എന്റെ $output_string = `ls`;
എങ്ങനെ കഴിയും I പിടിച്ചെടുക്കുക എസ്.ടി.ഡി.ആർ.ആർ നിന്ന് an പുറമേയുള്ള കമാൻഡ്?
ബാഹ്യ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മൂന്ന് അടിസ്ഥാന മാർഗങ്ങളുണ്ട്:
സിസ്റ്റം $ cmd; # സിസ്റ്റം() ഉപയോഗിക്കുന്നു
എന്റെ $ ഔട്ട്പുട്ട് = `$cmd`; # ബാക്ക്ടിക്കുകൾ ഉപയോഗിക്കുന്നു (``)
തുറക്കുക (എന്റെ $pipe_fh, "$cmd |"); # ഉപയോഗിക്കുന്നത് ഓപ്പൺ()
"സിസ്റ്റം()" ഉപയോഗിച്ച്, STDOUT ഉം STDERR ഉം സ്ക്രിപ്റ്റിന്റെ STDOUT പോലെ തന്നെ പോകും.
STDERR, "system()" കമാൻഡ് അവയെ റീഡയറക്‌ട് ചെയ്യുന്നില്ലെങ്കിൽ. ബാക്ക്‌ടിക്കുകളും "ഓപ്പൺ()" റീഡും മാത്രം
നിങ്ങളുടെ കമാൻഡിന്റെ STDOUT.
നിങ്ങൾക്ക് IPC ::Open3-ൽ നിന്ന് "open3()" ഫംഗ്‌ഷൻ ഉപയോഗിക്കാനും കഴിയും. ബെഞ്ചമിൻ ഗോൾഡ്ബെർഗ് ചിലത് നൽകുന്നു
മാതൃകാ കോഡ്:
ഒരു പ്രോഗ്രാമിന്റെ STDOUT ക്യാപ്‌ചർ ചെയ്യാൻ, എന്നാൽ അതിന്റെ STDERR ഉപേക്ഷിക്കുക:
IPC ഉപയോഗിക്കുക ::Open3;
ഫയൽ ഉപയോഗിക്കുക::സ്പെക്ക്;
എന്റെ $ഇൻ = '';
തുറക്കുക (NULL, ">", ഫയൽ:: Spec->devnull);
എന്റെ $pid = open3($in, \*PH, ">&NULL", "cmd");
സമയത്ത് ( ) {}
വെയ്റ്റ്പിഡ് ($pid, 0);
ഒരു പ്രോഗ്രാമിന്റെ STDERR ക്യാപ്‌ചർ ചെയ്യാൻ, എന്നാൽ അതിന്റെ STDOUT ഉപേക്ഷിക്കുക:
IPC ഉപയോഗിക്കുക ::Open3;
ഫയൽ ഉപയോഗിക്കുക::സ്പെക്ക്;
എന്റെ $ഇൻ = '';
തുറക്കുക (NULL, ">", ഫയൽ:: Spec->devnull);
എന്റെ $pid = open3($in, ">&NULL", \*PH, "cmd");
സമയത്ത് ( ) {}
വെയ്റ്റ്പിഡ് ($pid, 0);
ഒരു പ്രോഗ്രാമിന്റെ STDERR ക്യാപ്‌ചർ ചെയ്യാനും അതിന്റെ STDOUT നമ്മുടെ സ്വന്തം STDERR-ലേക്ക് പോകാനും അനുവദിക്കുക:
IPC ഉപയോഗിക്കുക ::Open3;
എന്റെ $ഇൻ = '';
എന്റെ $pid = open3($in, ">&STDERR", \*PH, "cmd");
സമയത്ത് ( ) {}
വെയ്റ്റ്പിഡ് ($pid, 0);
ഒരു കമാൻഡിന്റെ STDOUT ഉം STDERR ഉം വെവ്വേറെ വായിക്കാൻ, നിങ്ങൾക്ക് അവയെ ടെമ്പിലേക്ക് റീഡയറക്‌ട് ചെയ്യാം
ഫയലുകൾ, കമാൻഡ് പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുക, തുടർന്ന് താൽക്കാലിക ഫയലുകൾ വായിക്കുക:
IPC ഉപയോഗിക്കുക ::Open3;
IO :: ഫയൽ ഉപയോഗിക്കുക;
എന്റെ $ഇൻ = '';
പ്രാദേശിക *കാറ്റ്ചൗട്ട് = IO::File->new_tmpfile;
ലോക്കൽ *CATCHERR = IO::File->new_tmpfile;
എന്റെ $pid = open3($in, ">&CATCHOUT", ">&CATCHERR", "cmd");
വെയ്റ്റ്പിഡ് ($pid, 0);
\*കാറ്റ്ചൗട്ട്, \*ക്യാച്ചർ എന്നിവയ്‌ക്കായി $_, 0, 0 തിരയുക;
സമയത്ത് ( ) {}
സമയത്ത് ( ) {}
എന്നാൽ യഥാർത്ഥത്തിൽ അതിന്റെ ആവശ്യമില്ല രണ്ടും ടെംഫയലുകളാകാൻ... ഇനിപ്പറയുന്നവ അതുപോലെ പ്രവർത്തിക്കണം
നന്നായി, തടസ്സമില്ലാതെ:
IPC ഉപയോഗിക്കുക ::Open3;
എന്റെ $ഇൻ = '';
IO :: ഫയൽ ഉപയോഗിക്കുക;
ലോക്കൽ *CATCHERR = IO::File->new_tmpfile;
എന്റെ $pid = open3($in, \*CATCHOUT, ">&CATCHERR", "cmd");
സമയത്ത് ( ) {}
വെയ്റ്റ്പിഡ് ($pid, 0);
CATCHERR, 0, 0 തിരയുക;
സമയത്ത് ( ) {}
പ്രോഗ്രാമിന്റെ stdout ഉടനടി പ്രോസസ്സ് ചെയ്യാൻ തുടങ്ങുന്നതിനാൽ, ഇത് വേഗത്തിലും ആയിരിക്കും,
പ്രോഗ്രാം പൂർത്തിയാകാൻ കാത്തിരിക്കുന്നതിനുപകരം.
ഇവയിലേതെങ്കിലും ഉപയോഗിച്ച്, കോളിന് മുമ്പ് നിങ്ങൾക്ക് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ മാറ്റാനാകും:
തുറക്കുക (STDOUT, ">ലോഗ് ഫയൽ");
സിസ്റ്റം ("ls");
അല്ലെങ്കിൽ നിങ്ങൾക്ക് Bourne shell ഫയൽ-ഡിസ്ക്രിപ്റ്റർ റീഡയറക്ഷൻ ഉപയോഗിക്കാം:
$ output = `$cmd 2>some_file`;
തുറക്കുക (PIPE, "cmd 2>some_file |");
STDERR-നെ STDOUT-ന്റെ തനിപ്പകർപ്പാക്കാൻ നിങ്ങൾക്ക് ഫയൽ-ഡിസ്ക്രിപ്റ്റർ റീഡയറക്ഷൻ ഉപയോഗിക്കാം:
$ output = `$cmd 2>&1`;
തുറക്കുക (PIPE, "cmd 2>&1 |");
നിങ്ങൾ ശ്രദ്ധിക്കുക ഒന്നും കഴിയില്ല നിങ്ങളുടെ പേൾ പ്രോഗ്രാമിൽ STDOUT-ന്റെ ഡ്യൂപ്പ് ആകാൻ STDERR തുറക്കുക
റീഡയറക്ഷൻ ചെയ്യാൻ ഷെല്ലിനെ വിളിക്കുന്നത് ഒഴിവാക്കുക. ഇത് പ്രവർത്തിക്കുന്നില്ല:
തുറക്കുക (STDERR, ">&STDOUT");
$alloutput = `cmd args`; # stderr ഇപ്പോഴും രക്ഷപ്പെടുന്നു
"ഓപ്പൺ()" STDERR-നെ ആ സമയത്ത് STDOUT പോകുന്നിടത്തേക്ക് കൊണ്ടുപോകുന്നതിനാൽ ഇത് പരാജയപ്പെടുന്നു.
"തുറന്ന()". ബാക്ക്ടിക്കുകൾ STDOUT-നെ ഒരു സ്ട്രിംഗിലേക്ക് മാറ്റുന്നു, എന്നാൽ STDERR മാറ്റരുത്
(ഇത് ഇപ്പോഴും പഴയ STDOUT-ലേക്ക് പോകുന്നു).
നിങ്ങൾ ശ്രദ്ധിക്കുക ആവശമാകുന്നു ബോൺ ഷെൽ ഉപയോഗിക്കുക (sh(1)) ബാക്ക്ടിക്കുകളിലെ റീഡയറക്ഷൻ വാക്യഘടന, അല്ല csh(1)!
പേളിന്റെ "സിസ്റ്റം()", ബാക്ക്ടിക്ക്, പൈപ്പ് എന്നിവ തുറക്കുന്നത് എന്തിനാണ് ബോൺ ഷെൽ ഉപയോഗിക്കുന്നത് എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾ
ലെ versus/csh.whynot "നിങ്ങൾ എപ്പോഴെങ്കിലും അറിയാൻ ആഗ്രഹിച്ചതിലും കൂടുതൽ" എന്ന ശേഖരത്തിലെ ലേഖനം
ഇൻhttp://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz> ഒരു കമാൻഡിന്റെ STDERR ക്യാപ്‌ചർ ചെയ്യാൻ ഒപ്പം
ഒരുമിച്ച് STDOUT:
$ output = `cmd 2>&1`; # ഒന്നുകിൽ ബാക്ക്ടിക്കുകൾക്കൊപ്പം
$pid = ഓപ്പൺ(PH, "cmd 2>&1 |"); # അല്ലെങ്കിൽ തുറന്ന പൈപ്പ് ഉപയോഗിച്ച്
സമയത്ത് ( ) { } # കൂടാതെ ഒരു വായന
ഒരു കമാൻഡിന്റെ STDOUT ക്യാപ്‌ചർ ചെയ്യാൻ, എന്നാൽ അതിന്റെ STDERR ഉപേക്ഷിക്കുക:
$ output = `cmd 2>/dev/null`; # ഒന്നുകിൽ ബാക്ക്ടിക്കുകൾക്കൊപ്പം
$pid = ഓപ്പൺ(PH, "cmd 2>/dev/null |"); # അല്ലെങ്കിൽ തുറന്ന പൈപ്പ് ഉപയോഗിച്ച്
സമയത്ത് ( ) { } # കൂടാതെ ഒരു വായന
ഒരു കമാൻഡിന്റെ STDERR ക്യാപ്‌ചർ ചെയ്യാൻ, എന്നാൽ അതിന്റെ STDOUT ഉപേക്ഷിക്കുക:
$ output = `cmd 2>&1 1>/dev/null`; # ഒന്നുകിൽ ബാക്ക്ടിക്കുകൾക്കൊപ്പം
$pid = ഓപ്പൺ(PH, "cmd 2>&1 1>/dev/null |"); # അല്ലെങ്കിൽ തുറന്ന പൈപ്പ് ഉപയോഗിച്ച്
സമയത്ത് ( ) { } # കൂടാതെ ഒരു വായന
STDERR ക്യാപ്‌ചർ ചെയ്യുന്നതിനായി ഒരു കമാൻഡിന്റെ STDOUT ഉം STDERR ഉം കൈമാറാൻ
STDOUT ഞങ്ങളുടെ പഴയ STDERR-ൽ നിന്ന് പുറത്തുവരുന്നു:
$ output = `cmd 3>&1 1>&2 2>&3 3>&-`; # ഒന്നുകിൽ ബാക്ക്ടിക്കുകൾക്കൊപ്പം
$pid = ഓപ്പൺ(PH, "cmd 3>&1 1>&2 2>&3 3>&-|");# അല്ലെങ്കിൽ തുറന്ന പൈപ്പ് ഉപയോഗിച്ച്
സമയത്ത് ( ) { } # കൂടാതെ ഒരു വായന
ഒരു കമാൻഡിന്റെ STDOUT ഉം STDERR ഉം വെവ്വേറെ വായിക്കാൻ, അവയെ റീഡയറക്‌ട് ചെയ്യുന്നത് എളുപ്പമാണ്
ഫയലുകളിലേക്ക് വെവ്വേറെ, തുടർന്ന് പ്രോഗ്രാം പൂർത്തിയാകുമ്പോൾ ആ ഫയലുകളിൽ നിന്ന് വായിക്കുക:
സിസ്റ്റം("പ്രോഗ്രാം args 1>program.stdout 2>program.stderr");
ഈ എല്ലാ ഉദാഹരണങ്ങളിലും ഓർഡർ പ്രധാനമാണ്. ഷെൽ ഫയൽ പ്രോസസ്സ് ചെയ്യുന്നതിനാലാണിത്
ഡിസ്ക്രിപ്റ്റർ റീഡയറക്‌ടുകൾ കർശനമായി ഇടത്തുനിന്ന് വലത്തോട്ട് ക്രമത്തിൽ.
സിസ്റ്റം("prog args 1>tmpfile 2>&1");
സിസ്റ്റം("പ്രോഗ് ആർഗ്സ് 2>&1 1>tmpfile");
ആദ്യ കമാൻഡ് സ്റ്റാൻഡേർഡ് ഔട്ട്, സ്റ്റാൻഡേർഡ് പിശക് എന്നിവ താൽക്കാലിക ഫയലിലേക്ക് അയയ്ക്കുന്നു. ദി
രണ്ടാമത്തെ കമാൻഡ് അവിടെ പഴയ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് മാത്രമേ അയയ്ക്കൂ, പഴയ സ്റ്റാൻഡേർഡ് പിശക് കാണിക്കുന്നു
പഴയ നിലവാരത്തിൽ.
എന്തുകൊണ്ട് ഇല്ല തുറക്കുക () മടക്കം an പിശക് എപ്പോൾ a പൈപ്പ് തുറക്കുക പരാജയപ്പെടുമോ?
പൈപ്പ് ചെയ്ത "ഓപ്പൺ()" എന്നതിലേക്കുള്ള രണ്ടാമത്തെ ആർഗ്യുമെന്റിൽ ഷെൽ മെറ്റാക്യാരാക്‌ടറുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, perl "fork()"s,
തുടർന്ന് "exec()"sa shell metacharacters ഡീകോഡ് ചെയ്യാനും ഒടുവിൽ ആവശ്യമുള്ളത് പ്രവർത്തിപ്പിക്കാനും
പ്രോഗ്രാം. പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, ഷെല്ലിനാണ് സന്ദേശം ലഭിക്കുന്നത്, പേളിന് അല്ല.
നിങ്ങളുടെ പേൾ പ്രോഗ്രാമിന് കണ്ടെത്താൻ കഴിയുന്നത് ഷെൽ തന്നെ വിജയകരമാണോ എന്ന് മാത്രമാണ്
തുടങ്ങി. നിങ്ങൾക്ക് ഇപ്പോഴും ഷെല്ലിന്റെ STDERR ക്യാപ്‌ചർ ചെയ്യാനും പിശക് സന്ദേശങ്ങൾ ഉണ്ടോയെന്ന് പരിശോധിക്കാനും കഴിയും. കാണുക
"എനിക്ക് എങ്ങനെ ഒരു ബാഹ്യ കമാൻഡിൽ നിന്ന് STDERR ക്യാപ്‌ചർ ചെയ്യാം?" ഈ പ്രമാണത്തിൽ മറ്റെവിടെയെങ്കിലും ഉപയോഗിക്കുക, അല്ലെങ്കിൽ ഉപയോഗിക്കുക
IPC::Open3 മൊഡ്യൂൾ.
"ഓപ്പൺ()" എന്ന ആർഗ്യുമെന്റിൽ ഷെൽ മെറ്റാക്യാരക്റ്ററുകൾ ഇല്ലെങ്കിൽ, പേൾ കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു
ഷെൽ ഉപയോഗിക്കാതെ നേരിട്ട്, കമാൻഡ് ആരംഭിച്ചോ എന്ന് കൃത്യമായി റിപ്പോർട്ട് ചെയ്യാം.
എന്താണ് തെറ്റ് കൂടെ ഉപയോഗിച്ച് ബാക്ക്ടിക്കുകൾ in a ശൂന്യം സന്ദർഭം?
കൃത്യമായി പറഞ്ഞാൽ ഒന്നുമില്ല. ശൈലീപരമായി പറഞ്ഞാൽ, ഇത് എഴുതാനുള്ള നല്ല മാർഗമല്ല
പരിപാലിക്കാവുന്ന കോഡ്. ബാഹ്യ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് പേളിന് നിരവധി ഓപ്പറേറ്റർമാരുണ്ട്. ബാക്ക്ടിക്കുകളാണ്
ഒന്ന്; നിങ്ങളുടെ പ്രോഗ്രാമിലെ ഉപയോഗത്തിനായി അവർ കമാൻഡിൽ നിന്ന് ഔട്ട്പുട്ട് ശേഖരിക്കുന്നു. സംവിധാനം"
പ്രവർത്തനം മറ്റൊന്നാണ്; ഇത് ചെയ്യുന്നില്ല.
നിങ്ങളുടെ പ്രോഗ്രാമിൽ ബാക്ക്ടിക്കുകൾ എഴുതുന്നത് നിങ്ങളുടെ കോഡിന്റെ വായനക്കാർക്ക് വ്യക്തമായ സന്ദേശം അയയ്ക്കുന്നു
കമാൻഡിന്റെ ഔട്ട്പുട്ട് ശേഖരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. അല്ലാത്ത ഒരു വ്യക്തമായ സന്ദേശം അയക്കുന്നതെന്തിന്
ശരിയാണോ?
ഈ വരി പരിഗണിക്കുക:
`cat /etc/termcap`;
നിങ്ങൾ $ പരിശോധിക്കാൻ മറന്നോ? പ്രോഗ്രാം ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്നറിയാൻ. നിങ്ങൾ എഴുതിയാലും
`cat /etc/termcap` പ്രിന്റ് ചെയ്യുക;
ഈ കോഡ് എഴുതാം, ഒരുപക്ഷേ ഇങ്ങനെ എഴുതണം
സിസ്റ്റം("cat /etc/termcap") == 0
അല്ലെങ്കിൽ മരിക്കുക "കാറ്റ് പ്രോഗ്രാം പരാജയപ്പെട്ടു!";
ഇത് വരെ കാത്തിരിക്കുന്നതിനുപകരം, ജനറേറ്റുചെയ്യുമ്പോൾ cat കമാൻഡിന്റെ ഔട്ട്‌പുട്ടിനെ പ്രതിധ്വനിപ്പിക്കും
അത് പ്രിന്റ് ചെയ്യാനുള്ള പ്രോഗ്രാം പൂർത്തിയായി. ഇത് റിട്ടേൺ മൂല്യവും പരിശോധിക്കുന്നു.
"സിസ്റ്റം" ഷെൽ വൈൽഡ്കാർഡ് പ്രോസസ്സിംഗ് എടുക്കുമോ എന്നതിന്റെ നേരിട്ടുള്ള നിയന്ത്രണവും നൽകുന്നു
സ്ഥലം, എന്നാൽ ബാക്ക്ടിക്കുകൾ ചെയ്യരുത്.
എങ്ങനെ കഴിയും I വിളി ബാക്ക്ടിക്കുകൾ കൂടാതെ ഷെൽ പ്രോസസ്സിംഗ്?
ഇത് അൽപ്പം ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്. നിങ്ങൾക്ക് കമാൻഡ് ഇതുപോലെ എഴുതാൻ കഴിയില്ല:
@ok = `grep @opts '$search_string' @filenames`;
Perl 5.8.0 പോലെ, നിങ്ങൾക്ക് ഒന്നിലധികം ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് "ഓപ്പൺ()" ഉപയോഗിക്കാം. ലിസ്റ്റ് ഫോമുകൾ പോലെ
"സിസ്റ്റം()", "എക്‌സെക്()" എന്നിവയിൽ, ഷെൽ രക്ഷപ്പെടലുകളൊന്നും സംഭവിക്കുന്നില്ല.
തുറക്കുക(GREP, "-|", 'grep', @opts, $search_string, @filenames );
chomp(@ok = );
GREP അടയ്ക്കുക;
നിങ്ങൾക്ക് ഇവ ചെയ്യാനാകും:
എന്റെ @ശരി = ();
(ഓപ്പൺ(GREP, "-|")) {
സമയത്ത് ( ) {
ചോമ്പ്;
പുഷ് (@ശരി, $_);
}
GREP അടയ്ക്കുക;
} else {
exec 'grep', @opts, $search_string, @filenames;
}
"സിസ്റ്റം()" പോലെ, നിങ്ങൾ ഒരു ലിസ്റ്റ് "എക്‌സെക്()" ചെയ്യുമ്പോൾ ഷെൽ രക്ഷപ്പെടില്ല. കൂടുതൽ
പെർലിപ്‌സിയിലെ "സേഫ് പൈപ്പ് ഓപ്പൺസ്" എന്നതിൽ ഇതിന്റെ ഉദാഹരണങ്ങൾ കാണാം.
നിങ്ങൾ വിൻഡോസ് ഉപയോഗിക്കുകയാണെങ്കിൽ, ഈ വിഷമിപ്പിക്കുന്ന പ്രശ്നത്തിന് ഒരു പരിഹാരവും സാധ്യമല്ല എന്നത് ശ്രദ്ധിക്കുക. പോലും
പേൾ "ഫോർക്ക്()" അനുകരിക്കുന്നുവെങ്കിലും, നിങ്ങൾ ഇപ്പോഴും കുടുങ്ങിപ്പോകും, കാരണം വിൻഡോസിന് ഒരു
argc/argv-ശൈലി API.
എന്തുകൊണ്ട് കഴിയില്ല my സ്ക്രിപ്റ്റ് വായിക്കുക നിന്ന് STDIN ശേഷം I കൊടുത്തു it EOF (^ഡി on Unix, ^Z on MS-DOS)?
perlio എന്നതിനുപകരം stdio ഉപയോഗിക്കുന്നതിനായി നിങ്ങളുടെ perl കംപൈൽ ചെയ്താൽ മാത്രമേ ഇത് സംഭവിക്കൂ, അതായത്
സ്ഥിരസ്ഥിതി. നിങ്ങൾ മായ്‌ക്കേണ്ട ചില (ഒരുപക്ഷേ എല്ലാം?) stdios പിശകുകളും eof ഫ്ലാഗുകളും സജ്ജമാക്കി. ദി
നിങ്ങൾക്ക് ഉപയോഗിക്കാനാകുന്ന "clearrr()" POSIX മൊഡ്യൂൾ നിർവ്വചിക്കുന്നു. അതാണ് സാങ്കേതികമായി ശരിയായ വഴി
ചെയ്യു. വിശ്വസനീയമല്ലാത്ത ചില പരിഹാരങ്ങൾ ഇതാ:
1. സെക്‌പോയിന്ററിന് ചുറ്റും നിൽക്കാൻ ശ്രമിക്കുക, ഇതുപോലെ അവിടെ പോകുക:
എന്റെ $എവിടെ = പറയൂ($log_fh);
അന്വേഷിക്കുക ($log_fh, $where, 0);
2. അത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ഫയലിന്റെ മറ്റൊരു ഭാഗത്തേക്ക് തിരഞ്ഞ് വീണ്ടും ശ്രമിക്കുക.
3. അത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ഫയലിന്റെ മറ്റൊരു ഭാഗം തിരയാൻ ശ്രമിക്കുക, എന്തെങ്കിലും വായിക്കുക,
പിന്നെ തിരികെ അന്വേഷിക്കുന്നു.
4. അത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, നിങ്ങളുടെ stdio പാക്കേജ് ഉപേക്ഷിച്ച് sysread ഉപയോഗിക്കുക.
എങ്ങനെ കഴിയും I മാറ്റുക my ഷെൽ സ്ക്രിപ്റ്റ് ലേക്ക് പേൾ?
പേൾ പഠിച്ച് അത് മാറ്റിയെഴുതുക. ഗുരുതരമായി, ലളിതമായ കൺവെർട്ടർ ഒന്നുമില്ല. ഉള്ള കാര്യങ്ങൾ
ഷെല്ലിൽ ചെയ്യാൻ വിചിത്രമായത് പേളിൽ ചെയ്യാൻ എളുപ്പമാണ്, ഈ വിചിത്രത തന്നെയാണ്
ഒരു shell->perl കൺവെർട്ടർ എഴുതുന്നത് അസാധ്യമാക്കുക. അത് മാറ്റിയെഴുതുന്നതിലൂടെ, നിങ്ങൾ ചിന്തിക്കും
നിങ്ങൾ ശരിക്കും എന്താണ് ചെയ്യാൻ ശ്രമിക്കുന്നത് എന്നതിനെക്കുറിച്ച്, ഷെല്ലിന്റെ പൈപ്പ്ലൈനിൽ നിന്ന് രക്ഷപ്പെടുമെന്ന് പ്രതീക്ഷിക്കുന്നു
ഡാറ്റ സ്ട്രീം മാതൃക, ചില കാര്യങ്ങൾക്ക് സൗകര്യപ്രദമാണെങ്കിലും, പല അപര്യാപ്തതകൾക്കും കാരണമാകുന്നു.
Can I ഉപയോഗം മുത്ത് ലേക്ക് ഓടുക a Telnet or FTP സെഷൻ?
Net::FTP, TCP::Client, Net::Telnet മൊഡ്യൂളുകൾ പരീക്ഷിക്കുക (CPAN-ൽ നിന്ന് ലഭ്യമാണ്).
<http://www.cpan.org/scripts/netstuff/telnet.emul.shar> അനുകരിക്കുന്നതിനും സഹായിക്കും
ടെൽനെറ്റ് പ്രോട്ടോക്കോൾ, പക്ഷേ നെറ്റ് :: ടെൽനെറ്റ് ഉപയോഗിക്കാൻ വളരെ എളുപ്പമാണ്.
നിങ്ങൾ ചെയ്യേണ്ടത് ടെൽനെറ്റ് ആണെന്ന് നടിക്കുക മാത്രമാണ്, എന്നാൽ പ്രാരംഭ ടെൽനെറ്റ് ആവശ്യമില്ല
ഹാൻ‌ഡ്‌ഷിംഗ്, തുടർന്ന് സ്റ്റാൻഡേർഡ് ഡ്യുവൽ-പ്രോസസ് സമീപനം മതിയാകും:
IO::സോക്കറ്റ് ഉപയോഗിക്കുക; 5.004-ൽ # പുതിയത്
എന്റെ $ഹാൻഡിൽ = IO::Socket::INET->പുതിയ('www.perl.com:80')
അല്ലെങ്കിൽ മരിക്കുക "www.perl.com $-ലെ പോർട്ട് 80-ലേക്ക് ബന്ധിപ്പിക്കാൻ കഴിയില്ല!";
$handle->ഓട്ടോഫ്ലഷ്(1);
എങ്കിൽ (ഫോർക്ക്()) { # XXX: undef എന്നാൽ പരാജയം എന്നാണ് അർത്ഥമാക്കുന്നത്
തിരഞ്ഞെടുക്കുക ($ ഹാൻഡിൽ);
പ്രിന്റ് ചെയ്യുമ്പോൾ ; # stdin മുതൽ സോക്കറ്റ് വരെ എല്ലാം
} else {
പ്രിന്റ് ചെയ്യുമ്പോൾ <$ഹാൻഡിൽ>; # സോക്കറ്റ് മുതൽ stdout വരെ എല്ലാം
}
$ ഹാൻഡിൽ അടയ്ക്കുക;
പുറത്ത്;
എങ്ങനെ കഴിയും I എഴുതുക പ്രതീക്ഷിക്കുന്നു in പേർൾ?
പണ്ട് ഒരു ലൈബ്രറി ഉണ്ടായിരുന്നു chat2.pl (സാധാരണ പേളിന്റെ ഭാഗം
വിതരണം), ഇത് ഒരിക്കലും പൂർത്തിയായിട്ടില്ല. എവിടെയെങ്കിലും കണ്ടാൽ, ചെയ്യരുത് ഉപയോഗം it.
ഈ ദിവസങ്ങളിൽ, CPAN-ൽ നിന്ന് ലഭ്യമായ എക്‌സ്‌പെക്റ്റ് മൊഡ്യൂൾ നോക്കുക എന്നതാണ് നിങ്ങളുടെ ഏറ്റവും മികച്ച പന്തയം
CPAN, IO::Pty, IO::Stty എന്നിവയിൽ നിന്ന് മറ്റ് രണ്ട് മൊഡ്യൂളുകൾ ആവശ്യമാണ്.
Is അവിടെ a വഴി ലേക്ക് മറയ്ക്കുക perl ന്റെ കമാൻഡ് വര നിന്ന് പ്രോഗ്രാമുകൾ അത്തരം as "ps"?
സുരക്ഷാ കാരണങ്ങളാലാണ് നിങ്ങൾ ഇത് ചെയ്യുന്നതെങ്കിൽ (ആളുകൾ കാണാതിരിക്കാൻ
പാസ്‌വേഡുകൾ, ഉദാഹരണത്തിന്) അപ്പോൾ നിങ്ങൾ നിങ്ങളുടെ പ്രോഗ്രാം മാറ്റിയെഴുതണം, അങ്ങനെ നിർണായക വിവരങ്ങൾ
ഒരിക്കലും ഒരു വാദമായി നൽകിയിട്ടില്ല. ആർഗ്യുമെന്റുകൾ മറയ്ക്കുന്നത് നിങ്ങളുടെ പ്രോഗ്രാമിനെ പൂർണ്ണമാക്കില്ല
സുരക്ഷിത.
ദൃശ്യമാകുന്ന കമാൻഡ് ലൈൻ യഥാർത്ഥത്തിൽ മാറ്റുന്നതിന്, നിങ്ങൾക്ക് $0 എന്ന വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യാം
perlvar ൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്. എന്നിരുന്നാലും, എല്ലാ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും ഇത് പ്രവർത്തിക്കില്ല. ഡെമൺ പ്രോഗ്രാമുകൾ
അയയ്ക്കുന്ന മെയിൽ പോലെ, അവരുടെ അവസ്ഥ അവിടെ സ്ഥാപിക്കുക:
$0 = "ഓർക്കസ് [കണക്ഷനുകൾ സ്വീകരിക്കുന്നു]";
I {മാറി ഡയറക്ടറി, തിരുത്തപ്പെട്ടത് my പരിസ്ഥിതി} in a മുത്ത് സ്ക്രിപ്റ്റ്. എങ്ങനെ വരുക The മാറ്റം
അപ്രത്യക്ഷമായി എപ്പോൾ I പുറത്തുകടന്നു The സ്ക്രിപ്റ്റ്? എങ്ങനെ do I നേടുക my മാറ്റങ്ങൾ ലേക്ക് be ദൃശ്യമാണോ?
യൂണിക്സ്
കർശനമായ അർത്ഥത്തിൽ, അത് ചെയ്യാൻ കഴിയില്ല - സ്ക്രിപ്റ്റ് മറ്റൊരു പ്രക്രിയയായി നടപ്പിലാക്കുന്നു
ഷെല്ലിൽ നിന്ന് അത് ആരംഭിച്ചു. ഒരു പ്രക്രിയയിലെ മാറ്റങ്ങൾ അതിൽ പ്രതിഫലിക്കുന്നില്ല
രക്ഷിതാവ്--മാറ്റത്തിന് ശേഷം സൃഷ്ടിക്കപ്പെട്ട ഏതെങ്കിലും കുട്ടികളിൽ മാത്രം. ഷെൽ മാജിക് ഉണ്ട്
നിങ്ങളുടെ ഷെല്ലിലെ സ്ക്രിപ്റ്റിന്റെ ഔട്ട്പുട്ട് "eval()" വഴി ഇത് വ്യാജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു; പരിശോധിക്കുക
വിശദാംശങ്ങൾക്ക് comp.unix.questions FAQ.
എങ്ങനെ do I അടയ്ക്കുക a പ്രക്രിയയുടെ ഫയൽ ഹാൻഡിൽ കൂടാതെ കാത്തിരിക്കുന്നു വേണ്ടി it ലേക്ക് പൂർണ്ണമായോ?
നിങ്ങളുടെ സിസ്റ്റം അത്തരം കാര്യങ്ങളെ പിന്തുണയ്ക്കുന്നുവെന്ന് കരുതുക, പ്രോസസ്സിലേക്ക് ഉചിതമായ ഒരു സിഗ്നൽ അയയ്ക്കുക
(പെർഫങ്കിലെ "കൊല്ലുക" കാണുക). ആദ്യം ഒരു TERM സിഗ്നൽ അയയ്ക്കുക, അൽപ്പം കാത്തിരിക്കുക, ഒപ്പം
അത് അവസാനിപ്പിക്കാൻ ഒരു KILL സിഗ്നൽ അയയ്ക്കുക.
എങ്ങനെ do I ഫോർക്ക് a ഡെമൻ പ്രക്രിയ?
ഡെമൺ പ്രോസസ്സ് എന്നതുകൊണ്ട് നിങ്ങൾ ഉദ്ദേശിക്കുന്നത് വേർപെടുത്തിയ (അതിന്റെ tty യിൽ നിന്ന് വേർപെടുത്തപ്പെട്ട) ഒന്നാണെങ്കിൽ,
മിക്ക Unixish സിസ്റ്റങ്ങളിലും താഴെ പറയുന്ന പ്രക്രിയ പ്രവർത്തിക്കുന്നതായി റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നു. Unix അല്ലാത്ത ഉപയോക്താക്കൾ പരിശോധിക്കേണ്ടതാണ്
അവരുടെ Your_OS:: മറ്റ് പരിഹാരങ്ങൾക്കായുള്ള പ്രോസസ് മൊഡ്യൂൾ.
· /dev/tty തുറന്ന് അതിൽ TIOCNOTTY ioctl ഉപയോഗിക്കുക. കാണുക tty(1) വിശദാംശങ്ങൾക്ക്. അല്ലെങ്കിൽ നല്ലത്
എന്നിരുന്നാലും, നിങ്ങൾക്ക് "POSIX::setsid()" ഫംഗ്‌ഷൻ ഉപയോഗിക്കാം, അതിനാൽ നിങ്ങൾ വിഷമിക്കേണ്ടതില്ല
പ്രക്രിയ ഗ്രൂപ്പുകൾ.
/ എന്നതിലേക്ക് ഡയറക്ടറി മാറ്റുക
· STDIN, STDOUT, STDERR എന്നിവ വീണ്ടും തുറക്കുക, അങ്ങനെ അവ പഴയ tty-യുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.
· ഇതുപോലെ സ്വയം പശ്ചാത്തലം:
ഫോർക്ക് && എക്സിറ്റ്;
CPAN-ൽ നിന്ന് ലഭ്യമായ Proc::Demon മൊഡ്യൂൾ, ഈ പ്രവർത്തനങ്ങൾ ചെയ്യുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷൻ നൽകുന്നു
നിനക്കായ്.
എങ്ങനെ do I കണ്ടെത്തുക പുറത്ത് if ഞാൻ പ്രവർത്തിക്കുന്ന സംവേദനാത്മകമായി or അല്ലേ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
ഇത് ഉത്തരം നൽകാൻ പ്രയാസമുള്ള ചോദ്യമാണ്, ഏറ്റവും മികച്ച ഉത്തരം ഒരു ഊഹം മാത്രമാണ്.
നിങ്ങൾക്ക് ശരിക്കും എന്താണ് അറിയേണ്ടത്? നിങ്ങളുടെ ഫയൽ ഹാൻഡിലുകളിൽ ഒന്ന് ആണോ എന്ന് അറിയണമെങ്കിൽ
ഒരു ടെർമിനലുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു, നിങ്ങൾക്ക് "-t" ഫയൽ ടെസ്റ്റ് പരീക്ഷിക്കാം:
if(-t STDOUT ) {
"ഞാൻ ഒരു ടെർമിനലുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു!\n";
}
എന്നിരുന്നാലും, നിങ്ങൾ പ്രതീക്ഷിക്കുകയാണെങ്കിൽ നിങ്ങൾക്ക് ഭാഗ്യമില്ലായിരിക്കാം, അതിനർത്ഥം ഒരു യഥാർത്ഥ വ്യക്തി ഉണ്ടെന്നാണ്
മറ്റേ വശം. പ്രതീക്ഷിക്കുന്ന മൊഡ്യൂൾ ഉപയോഗിച്ച്, മറ്റൊരു പ്രോഗ്രാമിന് ഒരു വ്യക്തിയായി നടിക്കാൻ കഴിയും. ദി
ട്യൂറിംഗ് ടെസ്റ്റ് പാസാകുന്നതിന് അടുത്ത് പോലും പ്രോഗ്രാം എത്തിയേക്കാം.
IO::ഇന്ററാക്ടീവ് മൊഡ്യൂൾ നിങ്ങൾക്ക് ഉത്തരം നൽകാൻ കഴിയുന്നതിന്റെ പരമാവധി ചെയ്യുന്നു. അതിന്റെ
"is_interactive" ഫംഗ്‌ഷൻ ഒരു ഔട്ട്പുട്ട് ഫയൽഹാൻഡിൽ നൽകുന്നു; ആ ഫയൽ ഹാൻഡിൽ സ്റ്റാൻഡേർഡിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു
സെഷൻ ഇന്ററാക്ടീവ് ആണെന്ന് മൊഡ്യൂൾ കരുതുന്നുവെങ്കിൽ ഔട്ട്പുട്ട്. അല്ലെങ്കിൽ, ഫയൽഹാൻഡിൽ a
ഔട്ട്പുട്ട് നിരസിക്കുന്ന null ഹാൻഡിൽ:
IO:: ഇന്ററാക്ടീവ് ഉപയോഗിക്കുക;
പ്രിന്റ് { is_interactive } "ഞാൻ സാധാരണ ഔട്ട്പുട്ടിലേക്ക് പോയേക്കാം!\n";
ഒരു യഥാർത്ഥ വ്യക്തി നിങ്ങളുടെ നിർദ്ദേശങ്ങൾക്ക് ഉത്തരം നൽകുന്നുവെന്നോ നിങ്ങളുടെ വാക്കുകൾ വായിക്കുന്നുണ്ടെന്നോ ഇത് ഇപ്പോഴും ഉറപ്പുനൽകുന്നില്ല
.ട്ട്‌പുട്ട്.
നിങ്ങളുടെ വിതരണത്തിനായുള്ള ഓട്ടോമേറ്റഡ് ടെസ്റ്റിംഗ് എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് അറിയണമെങ്കിൽ, നിങ്ങൾക്ക് പരിശോധിക്കാം
പരിസ്ഥിതി. ഉദാഹരണത്തിന്, CPAN ടെസ്റ്ററുകൾ, "AUTOMATED_TESTING" എന്നതിന്റെ മൂല്യം സജ്ജമാക്കി:
ഒഴികെ ($ENV{AUTOMATED_TESTING} ) {
പ്രിന്റ് "ഹലോ ഇന്ററാക്ടീവ് ടെസ്റ്റർ!\n";
}
എങ്ങനെ do I ടൈം ഔട്ട് a പതുക്കെ സംഭവം?
"അലാറം()" ഫംഗ്‌ഷൻ ഉപയോഗിക്കുക, ഒരുപക്ഷേ ഒരു സിഗ്നൽ ഹാൻഡ്‌ലറുമായി സംയോജിച്ച്, ഡോക്യുമെന്റ് ചെയ്തതുപോലെ
perlipc-ലെ "സിഗ്നലുകൾ" എന്നതിലും ഒട്ടകത്തിലെ "സിഗ്നലുകൾ" എന്ന വിഭാഗത്തിലും. പകരം നിങ്ങൾക്ക് ഉപയോഗിക്കാം
കൂടുതൽ വഴക്കമുള്ള Sys::AlarmCall മൊഡ്യൂൾ CPAN-ൽ ലഭ്യമാണ്.
വിൻഡോസിന്റെ എല്ലാ പതിപ്പുകളിലും "അലാറം()" ഫംഗ്‌ഷൻ നടപ്പിലാക്കിയിട്ടില്ല. പരിശോധിക്കുക
നിങ്ങളുടെ Perl-ന്റെ നിർദ്ദിഷ്ട പതിപ്പിനുള്ള ഡോക്യുമെന്റേഷൻ.
എങ്ങനെ do I ഗണം സിപിയു പരിധികൾ?
(ഷോ സംഭാവന ചെയ്തത്)
CPAN-ൽ നിന്നുള്ള BSD ::റിസോഴ്സ് മൊഡ്യൂൾ ഉപയോഗിക്കുക. ഒരു ഉദാഹരണം എന്ന നിലക്ക്:
BSD ഉപയോഗിക്കുക :: റിസോഴ്സ്;
setrlimit(RLIMIT_CPU,10,20) അല്ലെങ്കിൽ ഡൈ $!;
ഇത് സോഫ്റ്റ്, ഹാർഡ് പരിധികൾ യഥാക്രമം 10, 20 സെക്കൻഡായി സജ്ജമാക്കുന്നു. 10 സെക്കൻഡിനു ശേഷം
CPU-ൽ പ്രവർത്തിക്കാൻ ചിലവഴിക്കുന്ന സമയം ("മതിൽ" സമയമല്ല), പ്രക്രിയ ഒരു സിഗ്നൽ അയയ്‌ക്കും
(ചില സിസ്റ്റങ്ങളിൽ XCPU) അത് കുടുങ്ങിയില്ലെങ്കിൽ, പ്രക്രിയ അവസാനിപ്പിക്കാൻ ഇടയാക്കും. എങ്കിൽ
സിഗ്നൽ കുടുങ്ങി, പിന്നീട് 10 സെക്കൻഡ് കൂടി (ആകെ 20 സെക്കൻഡ്) പ്രക്രിയ ആയിരിക്കും
ട്രാപ്പ് ചെയ്യാനാവാത്ത സിഗ്നൽ ഉപയോഗിച്ച് കൊന്നു.
ഗുരുതരമായ വിശദാംശങ്ങൾക്കായി BSD ::റിസോഴ്‌സും നിങ്ങളുടെ സിസ്റ്റം ഡോക്യുമെന്റേഷനും കാണുക.
എങ്ങനെ do I ഒഴിവാക്കുക ജയിംസ് on a യൂണിക്സ് സിസ്റ്റം?
ഒരു SIGCHLD ലഭിക്കുമ്പോൾ "കാത്തിരിക്കുക()" എന്ന് വിളിക്കാൻ perlipc-ലെ "സിഗ്നലുകൾ" എന്നതിൽ നിന്നുള്ള റീപ്പർ കോഡ് ഉപയോഗിക്കുക,
അല്ലെങ്കിൽ "ഞാൻ എങ്ങനെ ഒരു പ്രക്രിയ ആരംഭിക്കും" എന്നതിൽ വിവരിച്ചിരിക്കുന്ന ഡബിൾ ഫോർക്ക് ടെക്നിക് ഉപയോഗിക്കുക
പശ്ചാത്തലം?" perlfaq8-ൽ.
എങ്ങനെ do I ഉപയോഗം an SQL ഡാറ്റാബേസ്?
മിക്ക ഡാറ്റാബേസ് സെർവറുകൾക്കും തരങ്ങൾക്കും DBI മൊഡ്യൂൾ ഒരു അമൂർത്ത ഇന്റർഫേസ് നൽകുന്നു,
Oracle, DB2, Sybase, mysql, Postgresql, ODBC, ഫ്ലാറ്റ് ഫയലുകൾ എന്നിവയുൾപ്പെടെ. DBI മൊഡ്യൂൾ
ഒരു ഡാറ്റാബേസ് ഡ്രൈവർ അല്ലെങ്കിൽ DBD വഴി ഓരോ ഡാറ്റാബേസ് തരവും ആക്സസ് ചെയ്യുന്നു. നിങ്ങൾക്ക് ഒരു പൂർണ്ണമായ ലിസ്റ്റ് കാണാൻ കഴിയും
CPAN-ൽ ലഭ്യമായ ഡ്രൈവറുകൾ:http://www.cpan.org/modules/by-module/DBD/> നിങ്ങൾക്ക് വായിക്കാം
ഡിബിഐയെക്കുറിച്ച് കൂടുതൽhttp://dbi.perl.org/>.
മറ്റ് മൊഡ്യൂളുകൾ കൂടുതൽ നിർദ്ദിഷ്ട ആക്സസ് നൽകുന്നു: Win32::ODBC, Alzabo, "iodbc" എന്നിവയും മറ്റുള്ളവയും കണ്ടെത്തി
CPAN തിരയലിൽ:http://search.cpan.org/>.
എങ്ങനെ do I ഉണ്ടാക്കുക a സിസ്റ്റം() പുറത്ത് on കൺട്രോൾ-സി?
നിങ്ങൾക്ക് കഴിയില്ല. നിങ്ങൾ "സിസ്റ്റം()" കോൾ അനുകരിക്കേണ്ടതുണ്ട് (സാമ്പിൾ കോഡിനായി perlipc കാണുക) തുടർന്ന്
INT സിഗ്നലിനായി ഒരു സിഗ്നൽ ഹാൻഡ്‌ലർ ഉണ്ടായിരിക്കണം, അത് സബ്പ്രോസസിലേക്ക് സിഗ്നൽ കൈമാറുന്നു. അഥവാ
നിങ്ങൾക്കത് പരിശോധിക്കാം:
$rc = സിസ്റ്റം ($cmd);
എങ്കിൽ ($rc & 127) { മരിക്കുക "സിഗ്നൽ മരണം"}
എങ്ങനെ do I തുറക്കുക a ഫയല് കൂടാതെ തടയുന്നു?
നോൺ-ബ്ലോക്കിംഗ് റീഡുകളെ പിന്തുണയ്ക്കുന്ന ഒരു സിസ്റ്റം ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് ഭാഗ്യമുണ്ടെങ്കിൽ (മിക്ക യൂണിക്സിഷ്
സിസ്റ്റങ്ങൾ ചെയ്യുന്നു), നിങ്ങൾ "Fcntl" ൽ നിന്ന് "O_NDELAY" അല്ലെങ്കിൽ "O_NONBLOCK" ഫ്ലാഗ് ഉപയോഗിക്കേണ്ടതുണ്ട്.
"sysopen()" എന്നതിനൊപ്പം മൊഡ്യൂൾ:
Fcntl ഉപയോഗിക്കുക;
sysopen(എന്റെ $fh, "/foo/somefile", O_WRONLY|O_NDELAY|O_CREAT, 0644)
അല്ലെങ്കിൽ മരിക്കുക "/foo/somefile തുറക്കാൻ കഴിയില്ല: $!":
എങ്ങനെ do I പറയൂ The വ്യത്യാസം തമ്മിലുള്ള പിശകുകൾ നിന്ന് The ഷെൽ ഒപ്പം പേൾ?
(ഉത്തരം നൽകിയത് ബ്രയാൻ ഡി ഫോയ്)
നിങ്ങൾ ഒരു Perl സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, മറ്റെന്തെങ്കിലും നിങ്ങൾക്കായി സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നു, അതും
മറ്റെന്തെങ്കിലും പിശക് സന്ദേശങ്ങൾ പുറപ്പെടുവിച്ചേക്കാം. സ്ക്രിപ്റ്റ് അതിന്റേതായ മുന്നറിയിപ്പുകളും പിശകുകളും പുറപ്പെടുവിച്ചേക്കാം
സന്ദേശങ്ങൾ. മിക്കപ്പോഴും, ആരാണ് എന്താണ് പറഞ്ഞതെന്ന് നിങ്ങൾക്ക് പറയാൻ കഴിയില്ല.
നിങ്ങൾക്ക് perl പ്രവർത്തിപ്പിക്കുന്ന കാര്യം ശരിയാക്കാൻ കഴിയില്ല, പക്ഷേ perl എങ്ങനെ ഔട്ട്പുട്ട് ചെയ്യുന്നു എന്നത് നിങ്ങൾക്ക് മാറ്റാനാകും
ഒരു ഇഷ്‌ടാനുസൃത മുന്നറിയിപ്പും ഡൈ ഫംഗ്ഷനുകളും നിർവചിച്ചുകൊണ്ട് മുന്നറിയിപ്പുകൾ.
ഈ സ്ക്രിപ്റ്റ് പരിഗണിക്കുക, നിങ്ങൾ പെട്ടെന്ന് ശ്രദ്ധിക്കാത്ത ഒരു പിശക് ഉണ്ട്.
#!/usr/locl/bin/perl
"ഹലോ വേൾഡ്\n" പ്രിന്റ് ചെയ്യുക;
ഞാൻ ഇത് എന്റെ ഷെല്ലിൽ നിന്ന് പ്രവർത്തിപ്പിക്കുമ്പോൾ എനിക്ക് ഒരു പിശക് ലഭിക്കുന്നു (ഇത് ബാഷ് ആയിരിക്കും). അത് നോക്കാം
perl മറന്നതുപോലെ, അതിന് ഒരു "print()" ഫംഗ്‌ഷൻ ഉണ്ട്, പക്ഷേ എന്റെ shebang ലൈൻ perl-ലേക്കുള്ള പാതയല്ല,
അതിനാൽ ഷെൽ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നു, എനിക്ക് പിശക് ലഭിച്ചു.
$./ടെസ്റ്റ്
./ടെസ്റ്റ്: ലൈൻ 3: പ്രിന്റ്: കമാൻഡ് കണ്ടെത്തിയില്ല
പെട്ടെന്നുള്ളതും വൃത്തികെട്ടതുമായ ഒരു പരിഹാരത്തിൽ കുറച്ച് കോഡ് ഉൾപ്പെടുന്നു, എന്നാൽ ഇത് നിങ്ങൾക്ക് ആവശ്യമായി വന്നേക്കാം
പ്രശ്നം കണ്ടുപിടിക്കുക.
#!/usr/bin/perl -w
ആരംഭിക്കുന്നു {
$SIG{__WARN__} = ഉപ{ പ്രിന്റ് STDERR "Perl: ", @_; };
$SIG{__DIE__} = ഉപ{ പ്രിന്റ് STDERR "Perl: ", @_; പുറത്തുകടക്കുക 1};
}
$a = 1 + undef;
$x / 0;
__അവസാനിക്കുന്നു__
മുന്നിൽ "Perl" എന്നതോടുകൂടിയാണ് perl സന്ദേശം വരുന്നത്. "BEGIN" ബ്ലോക്ക് കംപൈൽ സമയത്ത് പ്രവർത്തിക്കുന്നു
അതിനാൽ എല്ലാ കംപൈലേഷൻ പിശകുകൾക്കും മുന്നറിയിപ്പുകൾക്കും "Perl:" പ്രിഫിക്സും ലഭിക്കും.
പേൾ: ./ടെസ്റ്റ് ലൈൻ 9-ൽ അസാധുവായ സന്ദർഭത്തിൽ വിഭജനത്തിന്റെ (/) ഉപയോഗശൂന്യമായ ഉപയോഗം.
പേൾ: "main::a" എന്ന പേര് ഒരിക്കൽ മാത്രം ഉപയോഗിച്ചു: ./test line 8-ൽ അക്ഷരത്തെറ്റ് സാധ്യമാണ്.
പേൾ: "main::x" എന്ന പേര് ഒരിക്കൽ മാത്രം ഉപയോഗിച്ചു: ./test line 9-ൽ അക്ഷരത്തെറ്റ് സാധ്യമാണ്.
പേൾ: ./ടെസ്റ്റ് ലൈൻ 8-ൽ (+) കൂടാതെ ആരംഭിക്കാത്ത മൂല്യത്തിന്റെ ഉപയോഗം.
പേൾ: ./ടെസ്റ്റ് ലൈൻ 9-ലെ ഡിവിഷനിൽ (/) ആരംഭിക്കാത്ത മൂല്യത്തിന്റെ ഉപയോഗം.
പേൾ: ./ടെസ്റ്റ് ലൈൻ 9-ൽ പൂജ്യം കൊണ്ട് നിയമവിരുദ്ധമായ വിഭജനം.
പേൾ: -e ലൈൻ 3-ൽ പൂജ്യം കൊണ്ട് നിയമവിരുദ്ധ വിഭജനം.
"Perl:" ഞാൻ കാണുന്നില്ലെങ്കിൽ, അത് perl-ൽ നിന്നുള്ളതല്ല.
നിങ്ങൾക്ക് എല്ലാ perl പിശകുകളും അറിയാൻ കഴിയും, ചില ആളുകൾ ഉണ്ടെങ്കിലും
അവയെല്ലാം അറിയാം, ഒരുപക്ഷേ നിങ്ങൾക്കറിയില്ല. എന്നിരുന്നാലും, അവയെല്ലാം perldiag manpage-ൽ ഉണ്ടായിരിക്കണം.
നിങ്ങൾ അവിടെ പിശക് കണ്ടെത്തിയില്ലെങ്കിൽ, അത് ഒരു പേൾ പിശക് ആയിരിക്കില്ല.
എല്ലാ സന്ദേശങ്ങളും നോക്കുന്നത് എളുപ്പമുള്ള വഴിയല്ല, അതിനാൽ നിങ്ങൾക്കായി ഇത് ചെയ്യാൻ perl-നെ അനുവദിക്കുക. ഉപയോഗിക്കുക
diagnostics pragma, perl-ന്റെ സാധാരണ സന്ദേശങ്ങളെ വിഷയത്തെക്കുറിച്ചുള്ള ദൈർഘ്യമേറിയ ചർച്ചകളാക്കി മാറ്റുന്നു.
ഡയഗ്നോസ്റ്റിക്സ് ഉപയോഗിക്കുക;
വിപുലീകരിച്ച ചർച്ചയുടെ ഒന്നോ രണ്ടോ ഖണ്ഡികകൾ നിങ്ങൾക്ക് ലഭിച്ചില്ലെങ്കിൽ, അത് perl-ന്റേതായിരിക്കില്ല
സന്ദേശം.
എങ്ങനെ do I ഇൻസ്റ്റാൾ ചെയ്യുക a മൊഡ്യൂൾ നിന്ന് CPAN?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
CPAN എന്ന് പേരുള്ള ഒരു മൊഡ്യൂൾ "cpan" ഉപയോഗിച്ച് നിങ്ങൾക്കായി ചെയ്യുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം.
പേളിനൊപ്പം വരുന്ന കമാൻഡ്. ഇൻസ്റ്റാൾ ചെയ്യാനുള്ള മൊഡ്യൂളുകളുടെ ഒരു ലിസ്റ്റ് നിങ്ങൾക്ക് നൽകാം:
$ cpan IO::Interactive Getopt::എന്തായാലും
നിങ്ങൾ "CPANPLUS" ആണ് തിരഞ്ഞെടുക്കുന്നതെങ്കിൽ, ഇത് വളരെ എളുപ്പമാണ്:
$ cpanp i IO::Interactive Getopt::എന്തായാലും
നിലവിലെ ഡയറക്‌ടറിയിൽ നിന്ന് ഒരു വിതരണം ഇൻസ്റ്റാൾ ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് "CPAN.pm" എന്ന് പറയാവുന്നതാണ്.
ഇൻസ്റ്റാൾ ചെയ്യാൻ "." (ഫുൾ സ്റ്റോപ്പ്):
$ cpan .
നിങ്ങൾക്ക് മറ്റെന്താണ് ചെയ്യാൻ കഴിയുക എന്നറിയാൻ ആ കമാൻഡുകൾക്ക് വേണ്ടിയുള്ള ഡോക്യുമെന്റേഷൻ കാണുക.
എല്ലാ ഡിപൻഡൻസികളും പരിഹരിച്ച് സ്വയം ഒരു വിതരണം ഇൻസ്റ്റാൾ ചെയ്യാൻ ശ്രമിക്കണമെങ്കിൽ
നിങ്ങളുടേത്, സാധ്യമായ രണ്ട് നിർമ്മാണ പാതകളിൽ ഒന്ന് നിങ്ങൾ പിന്തുടരുന്നു.
ഉപയോഗിക്കുന്ന വിതരണങ്ങൾക്കായി Makefile.PL:
$ perl Makefile.PL
$ ടെസ്റ്റ് ഇൻസ്റ്റാൾ ചെയ്യുക
ഉപയോഗിക്കുന്ന വിതരണങ്ങൾക്കായി ബിൽഡ്.പി.എൽ:
$ perl Build.PL
$./ബിൽഡ് ടെസ്റ്റ്
$ ./ബിൽഡ് ഇൻസ്റ്റാൾ ചെയ്യുക
ചില വിതരണങ്ങൾക്ക് ലൈബ്രറികളിലേക്കോ മറ്റ് മൂന്നാം കക്ഷി കോഡുകളിലേക്കോ അവയുടെ നിർമ്മാണത്തിലേക്കോ ലിങ്ക് ചെയ്യേണ്ടി വന്നേക്കാം
കൂടാതെ ഇൻസ്റ്റലേഷൻ ക്രമങ്ങൾ കൂടുതൽ സങ്കീർണ്ണമായേക്കാം. ഏതെങ്കിലും പരിശോധിക്കുക വായിക്കുക or INSTALL ഫയലുകൾ
നിങ്ങൾ കണ്ടെത്തും.
എന്താണ് The വ്യത്യാസം തമ്മിലുള്ള ആവശ്യമുണ്ട് ഒപ്പം ഉപയോഗിക്കണോ?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
റൺ-ടൈമിൽ പേൾ "ആവശ്യമുണ്ട്" എന്ന പ്രസ്താവന പ്രവർത്തിപ്പിക്കുന്നു. Perl ഒരിക്കൽ ഫയൽ ലോഡ് ചെയ്യുകയും കംപൈൽ ചെയ്യുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു,
അത് മറ്റൊന്നും ചെയ്യുന്നില്ല. "ഉപയോഗം" എന്ന പ്രസ്താവന "ആവശ്യമുള്ളത്" എന്നതിന് സമാനമാണ്
കംപൈൽ-ടൈം, എന്നാൽ ലോഡ് ചെയ്ത പാക്കേജിനുള്ള "ഇറക്കുമതി" രീതിയെ പേൾ വിളിക്കുന്നു. ഇവ രണ്ടും
സമാനമാണ്:
MODULE qw (ഇറക്കുമതി ലിസ്റ്റ്) ഉപയോഗിക്കുക;
ആരംഭിക്കുന്നു {
മൊഡ്യൂൾ ആവശ്യമാണ്;
മൊഡ്യൂൾ->ഇറക്കുമതി(ഇറക്കുമതി ലിസ്റ്റ്);
}
എന്നിരുന്നാലും, വ്യക്തമായ, ശൂന്യമായ ഇറക്കുമതി ലിസ്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് "ഇറക്കുമതി" അടിച്ചമർത്താനാകും. രണ്ടും
കംപൈൽ സമയത്ത് ഇവ ഇപ്പോഴും സംഭവിക്കുന്നു:
മൊഡ്യൂൾ ഉപയോഗിക്കുക ();
ആരംഭിക്കുന്നു {
മൊഡ്യൂൾ ആവശ്യമാണ്;
}
"ഉപയോഗം" എന്നത് "ഇറക്കുമതി" രീതിയെ വിളിക്കുന്നതിനാൽ, "MODULE" എന്നതിന്റെ യഥാർത്ഥ മൂല്യം ഒരു ആയിരിക്കണം
നഗ്നവാക്കുകൾ. അതായത്, "ഉപയോഗം" എന്നതിന് പേരിനനുസരിച്ച് ഫയലുകൾ ലോഡുചെയ്യാൻ കഴിയില്ല, എന്നിരുന്നാലും "ആവശ്യത്തിന്" ഇനിപ്പറയുന്നവ ചെയ്യാനാകും:
"$ENV{HOME}/lib/Foo.pm" ആവശ്യമാണ്; # @INC തിരയുന്നില്ല!
കൂടുതൽ വിവരങ്ങൾക്ക് perlfunc-ലെ "ഉപയോഗം" എന്നതിനായുള്ള എൻട്രി കാണുക.
എങ്ങനെ do I സൂക്ഷിക്കുക my സ്വന്തം മൊഡ്യൂൾ/ലൈബ്രറി ഡയറക്ടറി?
നിങ്ങൾ മൊഡ്യൂളുകൾ നിർമ്മിക്കുമ്പോൾ, മൊഡ്യൂളുകൾ എവിടെ ഇൻസ്റ്റാൾ ചെയ്യണമെന്ന് Perl-നോട് പറയുക.
നിങ്ങളുടെ സ്വന്തം ഉപയോഗത്തിനായി മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യണമെങ്കിൽ, ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം ലോക്കൽ::lib,
നിങ്ങൾക്ക് CPAN-ൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യാം. ഇത് നിങ്ങൾക്കായി വിവിധ ഇൻസ്റ്റലേഷൻ ക്രമീകരണങ്ങൾ സജ്ജമാക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നു
നിങ്ങളുടെ പ്രോഗ്രാമുകളിലെ അതേ ക്രമീകരണങ്ങൾ.
നിങ്ങൾക്ക് കൂടുതൽ വഴക്കം വേണമെങ്കിൽ, നിങ്ങളുടെ CPAN ക്ലയന്റ് നിങ്ങൾക്ക് പ്രത്യേകമായി ക്രമീകരിക്കേണ്ടതുണ്ട്
സാഹചര്യം.
"Makefile.PL"-അടിസ്ഥാന വിതരണങ്ങൾക്കായി, സൃഷ്ടിക്കുമ്പോൾ INSTALL_BASE ഓപ്ഷൻ ഉപയോഗിക്കുക
മേക്ക് ഫയലുകൾ:
perl Makefile.PL INSTALL_BASE=/mydir/perl
നിങ്ങൾക്ക് ഇത് നിങ്ങളുടെ "CPAN.pm" കോൺഫിഗറേഷനിൽ സജ്ജീകരിക്കാൻ കഴിയും, അങ്ങനെ മൊഡ്യൂളുകൾ നിങ്ങളുടേതിൽ സ്വയമേവ ഇൻസ്റ്റാൾ ചെയ്യുന്നു
നിങ്ങൾ CPAN.pm ഷെൽ ഉപയോഗിക്കുമ്പോൾ സ്വകാര്യ ലൈബ്രറി ഡയറക്ടറി:
% cpan
cpan> o conf makepl_arg INSTALL_BASE=/mydir/perl
cpan> o conf കമ്മിറ്റ്
"Build.PL"-അടിസ്ഥാന വിതരണങ്ങൾക്കായി, --install_base ഓപ്ഷൻ ഉപയോഗിക്കുക:
perl Build.PL --install_base /mydir/perl
ഈ ഓപ്‌ഷനും സ്വയമേവ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾക്ക് "CPAN.pm" കോൺഫിഗർ ചെയ്യാം:
% cpan
cpan> o conf mbuild_arg "--install_base /mydir/perl"
cpan> o conf കമ്മിറ്റ്
നിങ്ങളുടെ മൊഡ്യൂളുകൾ ഉൾപ്പെടുത്താൻ INSTALL_BASE ഈ ഉപകരണങ്ങളോട് പറയുന്നു /mydir/perl/lib/perl5. "എങ്ങനെ ചെയ്യാം
റൺടൈമിൽ എന്റെ ഉൾപ്പെടുത്തൽ പാതയിലേക്ക് (@INC) ഞാൻ ഒരു ഡയറക്ടറി ചേർക്കുന്നു?" നിങ്ങളുടെ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്കായി
പുതുതായി ഇൻസ്റ്റാൾ ചെയ്ത മൊഡ്യൂളുകൾ.
PREFIX-ൽ നിന്ന് വ്യത്യസ്തമായി പ്രവർത്തിക്കുന്നതിനാൽ, INSTALL_BASE-ൽ ഒരു മുന്നറിയിപ്പ് ഉണ്ട്.
ExtUtils::MakeMaker ന്റെ പഴയ പതിപ്പുകൾ വാദിക്കുന്ന LIB ക്രമീകരണങ്ങളും. INSTALL_BASE ചെയ്യുന്നു
Perl-ന്റെ ഒന്നിലധികം പതിപ്പുകൾക്കോ വ്യത്യസ്ത ആർക്കിടെക്ചറുകൾക്കോ വേണ്ടി മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനെ പിന്തുണയ്ക്കുന്നില്ല
ഒരേ ഡയറക്‌ടറിക്ക് കീഴിൽ. നിങ്ങൾക്ക് അത് ശരിക്കും വേണോ എന്ന് നിങ്ങൾ പരിഗണിക്കണം, നിങ്ങൾ അങ്ങനെ ചെയ്യുകയാണെങ്കിൽ,
പഴയ PREFIX, LIB ക്രമീകരണങ്ങൾ ഉപയോഗിക്കുക. കൂടുതൽ വിവരങ്ങൾക്ക് ExtUtils:: Makemaker ഡോക്യുമെന്റേഷൻ കാണുക
വിശദാംശങ്ങൾ.
എങ്ങനെ do I ചേർക്കുക The ഡയറക്ടറി my പ്രോഗ്രാം ജീവിതത്തിൽ in ലേക്ക് The മൊഡ്യൂൾ/ലൈബ്രറി തിരയൽ പാത?
(ബ്രയാൻ ഡി ഫോയ് സംഭാവന ചെയ്തത്)
നിങ്ങൾക്ക് ഇതിനകം തന്നെ ഡയറക്ടറി അറിയാമെങ്കിൽ, മറ്റേതിന് വേണ്ടിയും നിങ്ങൾക്ക് അത് @INC-ലേക്ക് ചേർക്കാം
ഡയറക്ടറി. നിങ്ങൾ ഒരുപക്ഷേ കംപൈൽ സമയത്ത് നിങ്ങൾക്ക് ഡയറക്ടറി അറിയാമെങ്കിൽ:
ലിബ് $ ഡയറക്ടറി ഉപയോഗിക്കുക;
ഈ ടാസ്ക്കിലെ തന്ത്രം ഡയറക്ടറി കണ്ടെത്തുക എന്നതാണ്. നിങ്ങളുടെ സ്ക്രിപ്റ്റ് മറ്റെന്തെങ്കിലും ചെയ്യുന്നതിനുമുമ്പ്
("chdir" പോലുള്ളവ), "Cwd" മൊഡ്യൂൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് നിലവിലെ വർക്കിംഗ് ഡയറക്ടറി ലഭിക്കും,
പേളിനൊപ്പം വരുന്നത്:
ആരംഭിക്കുന്നു {
Cwd ഉപയോഗിക്കുക;
ഞങ്ങളുടെ $ഡയറക്ടറി = cwd;
}
ലിബ് $ ഡയറക്ടറി ഉപയോഗിക്കുക;
സ്ക്രിപ്റ്റ് നാമമുള്ള $0 മൂല്യം ഉപയോഗിച്ച് നിങ്ങൾക്ക് സമാനമായ ഒരു കാര്യം ചെയ്യാൻ കഴിയും. അതായിരിക്കാം
ഒരു ആപേക്ഷിക പാത പിടിക്കുക, എന്നാൽ "rel2abs"-ന് അതിനെ ഒരു കേവല പാതയാക്കി മാറ്റാൻ കഴിയും. ഒരിക്കൽ നിങ്ങൾക്ക്
ആരംഭിക്കുന്നു {
ഫയൽ ഉപയോഗിക്കുക:: സ്പെക്:: ഫംഗ്ഷനുകൾ qw(rel2abs);
ഫയൽ ഉപയോഗിക്കുക::Basename qw(dirname);
എന്റെ $പാത്ത് = rel2abs( $0 );
ഞങ്ങളുടെ $ഡയറക്ടറി = dirname($path );
}
ലിബ് $ ഡയറക്ടറി ഉപയോഗിക്കുക;
Perl-നൊപ്പം വരുന്ന FindBin മൊഡ്യൂൾ പ്രവർത്തിച്ചേക്കാം. ഇത് ഡയറക്ടറി കണ്ടെത്തുന്നു
നിലവിൽ പ്രവർത്തിക്കുന്ന സ്ക്രിപ്റ്റ് $Bin-ൽ ഇടുന്നു, അത് നിങ്ങൾക്ക് നിർമ്മിക്കാൻ ഉപയോഗിക്കാം
വലത് ലൈബ്രറി പാത:
FindBin qw($Bin) ഉപയോഗിക്കുക;
സമാനമായ കാര്യങ്ങൾ ചെയ്യാൻ നിങ്ങൾക്ക് ലോക്കൽ ::lib ഉപയോഗിക്കാനും കഴിയും. ഉപയോഗിച്ച് മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക
ലോക്കൽ::lib ന്റെ ക്രമീകരണങ്ങൾ തുടർന്ന് നിങ്ങളുടെ പ്രോഗ്രാമിലെ മൊഡ്യൂൾ ഉപയോഗിക്കുക:
ലോക്കൽ ഉപയോഗിക്കുക ::lib; # ഇവിടെ ഒരു പ്രാദേശിക ലിബ് സജ്ജീകരിക്കുന്നു ~/perl5
കൂടുതൽ വിവരങ്ങൾക്ക് ലോക്കൽ::lib ഡോക്യുമെന്റേഷൻ കാണുക.
എങ്ങനെ do I ചേർക്കുക a ഡയറക്ടറി ലേക്ക് my ഉൾപ്പെടുന്നു പാത (@INC) at റൺടൈം?
പരിസ്ഥിതി ഉൾപ്പെടെ, നിങ്ങളുടെ ഉൾപ്പെടുത്തിയ പാത പരിഷ്കരിക്കുന്നതിനുള്ള നിർദ്ദേശിത മാർഗങ്ങൾ ഇതാ
വേരിയബിളുകൾ, റൺ-ടൈം സ്വിച്ചുകൾ, ഇൻ-കോഡ് പ്രസ്താവനകൾ:
"PERLLIB" എൻവയോൺമെന്റ് വേരിയബിൾ
$ കയറ്റുമതി PERLLIB=/path/to/my/dir
$ perl program.pl
"PERL5LIB" എൻവയോൺമെന്റ് വേരിയബിൾ
$ കയറ്റുമതി PERL5LIB=/path/to/my/dir
$ perl program.pl
"perl -Idir" കമാൻഡ് ലൈൻ ഫ്ലാഗ്
$ perl -I/path/to/my/dir program.pl
"ലിബ്" പ്രാഗ്മ:
ലിബ് "$ENV{HOME}/myown_perllib" ഉപയോഗിക്കുക;
ലോക്കൽ::lib മൊഡ്യൂൾ:
ലോക്കൽ ഉപയോഗിക്കുക ::lib;
ലോക്കൽ ഉപയോഗിക്കുക ::lib "~/myown_perllib";
യന്ത്രത്തെ ആശ്രയിക്കുന്ന ആർക്കിടെക്ചറുകളെ കുറിച്ച് അറിയാവുന്നതിനാൽ അവസാനത്തേത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.
"lib.pm" പ്രാഗ്മാറ്റിക് മൊഡ്യൂൾ ആദ്യം ഉൾപ്പെടുത്തിയത് പേളിന്റെ 5.002 പതിപ്പിലാണ്.
എവിടെ ആകുന്നു മൊഡ്യൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടോ?
മൊഡ്യൂളുകൾ ഓരോ കേസിന്റെ അടിസ്ഥാനത്തിലാണ് ഇൻസ്റ്റാൾ ചെയ്യുന്നത് (ഇതിൽ വിവരിച്ചിരിക്കുന്ന രീതികൾ നൽകിയത് പോലെ
മുമ്പത്തെ വിഭാഗം), കൂടാതെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിലും. ഈ പാതകളെല്ലാം @INC-ൽ സംഭരിച്ചിരിക്കുന്നു,
വൺ-ലൈനർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പ്രദർശിപ്പിക്കാൻ കഴിയുന്നവ
perl -e 'print join("\n",@INC,"")'
കമാൻഡിൽ നിന്നുള്ള ഔട്ട്പുട്ടിന്റെ അവസാനം അതേ വിവരങ്ങൾ പ്രദർശിപ്പിക്കും
perl -V
ഒരു മൊഡ്യൂളിന്റെ സോഴ്സ് കോഡ് എവിടെയാണെന്ന് കണ്ടെത്താൻ, ഉപയോഗിക്കുക
perldoc -l എൻകോഡ്
മൊഡ്യൂളിലേക്കുള്ള പാത പ്രദർശിപ്പിക്കുന്നതിന്. ചില സന്ദർഭങ്ങളിൽ (ഉദാഹരണത്തിന്, "AutoLoader" മൊഡ്യൂൾ),
ഈ കമാൻഡ് ഒരു പ്രത്യേക "pod" ഫയലിലേക്കുള്ള പാത കാണിക്കും; മൊഡ്യൂൾ തന്നെ ആയിരിക്കണം
ഒരു 'pm' ഫയൽ എക്സ്റ്റൻഷനോടുകൂടിയ അതേ ഡയറക്ടറി.
എന്ത് is socket.ph ഒപ്പം എവിടെ do I നേടുക ഇത്?
സിസ്റ്റം നെറ്റ്‌വർക്കിംഗ് കോൺസ്റ്റന്റുകളുടെ മൂല്യങ്ങൾ നിർവചിക്കുന്ന ഒരു Perl 4 ശൈലിയിലുള്ള ഫയലാണിത്. ചിലപ്പോൾ അത്
Perl ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ h2ph ഉപയോഗിച്ചാണ് നിർമ്മിച്ചത്, എന്നാൽ മറ്റ് സമയങ്ങളിൽ അത് അങ്ങനെയല്ല. ആധുനിക പരിപാടികൾ വേണം
ഉപയോഗിക്കുക "സോക്കറ്റ് ഉപയോഗിക്കുക;" പകരം.
AUTHOR ഒപ്പം പകർപ്പവകാശ
പകർപ്പവകാശം (സി) 1997-2010 ടോം ക്രിസ്റ്റ്യൻസെൻ, നഥാൻ ടോർക്കിംഗ്ടൺ, മറ്റ് രചയിതാക്കൾ എന്നിവരും സൂചിപ്പിച്ചു.
എല്ലാ അവകാശങ്ങളും നിക്ഷിപ്തം.
ഈ ഡോക്യുമെന്റേഷൻ സൗജന്യമാണ്; അതേ നിബന്ധനകൾക്ക് കീഴിൽ നിങ്ങൾക്ക് ഇത് പുനർവിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ പരിഷ്ക്കരിക്കാനും കഴിയും
പേർൾ തന്നെ.
അതിന്റെ വിതരണം പരിഗണിക്കാതെ തന്നെ, ഈ ഫയലിലെ എല്ലാ കോഡ് ഉദാഹരണങ്ങളും ഇതിനാൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു
പൊതുസഞ്ചയം. നിങ്ങളുടെ സ്വന്തം പ്രോഗ്രാമുകളിൽ ഈ കോഡ് ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും പ്രോത്സാഹിപ്പിക്കുകയും ചെയ്യുന്നു
വിനോദത്തിനോ ലാഭത്തിനോ വേണ്ടി. ക്രെഡിറ്റ് നൽകുന്ന കോഡിലെ ലളിതമായ ഒരു അഭിപ്രായം ഇതായിരിക്കും
മര്യാദയുള്ള എന്നാൽ ആവശ്യമില്ല.
onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് perlfaq8 ഓൺലൈനായി ഉപയോഗിക്കുക
