රූබි වෙතින් ෂෙල් විධාන අමතන්නේ කෙසේද

රූබි වැඩසටහනක ඇතුළත සිට මම ෂෙල් විධාන අමතන්නේ කෙසේද? මෙම විධානයන්ගෙන් ප්‍රතිදානය නැවත රූබි වෙත ලබා ගන්නේ කෙසේද?

මෙම පැහැදිලි කිරීම පදනම් වී ඇත්තේ මගේ මිතුරෙකුගේ අදහස් දැක්වූ රූබි පිටපතක් මත ය. ඔබට ස්ක්‍රිප්ට් වැඩි දියුණු කිරීමට අවශ්‍ය නම්, එය සබැඳියෙන් යාවත්කාලීන කිරීමට නිදහස් වන්න.

පළමුව, රූබි සහ shell අයැදින විට, එය සාමාන්යයෙන් හඳුන්වන බවයි සටහන් /bin/sh, නෑ බෑෂ්. සමහර /bin/shපද්ධතිවල සියලුම බාෂ් සින්ටැක්ස් සහාය නොදක්වයි .

ෂෙල් ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමට ක්‍රම මෙන්න:

cmd = "echo 'hi'" # Sample string that can be used

1. Kernel#` , පොදුවේ බැක්ටික්ස් ලෙස හැඳින්වේ - `cmd`

   මෙය Bash, PHP සහ Perl ඇතුළු වෙනත් බොහෝ භාෂා වලට සමානය.

   ෂෙල් විධානයෙහි ප්‍රති result ලය (එනම් සම්මත ප්‍රතිදානය) ලබා දෙයි.

   ලියකියවිලි: http://ruby-doc.org/core/Kernel.html#method-i-60

   value = `echo 'hi'`
   value = `#{cmd}`
   

2. බිල්ට් සින්ටැක්ස්, %x( cmd )

   xචරිතය අනුගමනය කිරීම පරිසීමකය වන අතර එය ඕනෑම චරිතයක් විය හැකිය. පරිසීමක එක් චරිතයක් නම් (, [, {, හෝ <, සාහිත්යමය ගැලපෙන වසා පරිසීමකය දක්වා චරිත, පිළිතුරු පැතැලිව පරිසීමකය යුගල ගිණුමක් ගනිමින් කින් සමන්විත වේ. අනෙක් සියලුම පරිසීමකයන් සඳහා, වචනයේ පරිසමාප්ත අර්ථයෙන්ම පරිසීමක අක්‍ෂරයේ ඊළඟ සිදුවීම දක්වා අක්ෂර ඇතුළත් වේ. නූල් අන්තර් #{ ... }මැදිහත්වීමට අවසර ඇත.

   ෂෙල් විධානයෙහි ප්‍රති result ලය (එනම් සම්මත ප්‍රතිදානය) ලබා දෙයි.

   ලියකියවිලි: https://docs.ruby-lang.org/en/master/syntax/literals_rdoc.html#label-Percent+Strings

   value = %x( echo 'hi' )
   value = %x[ #{cmd} ]
   

3. Kernel#system

   දී ඇති විධානය උප කුලකයකින් ක්‍රියාත්මක කරයි.

   ප්රතිලාභ trueවිධානය සොයා හා සාර්ථකව ක්රියාත්මක නම්, falseවෙනත් ආකාරයකින්.

   ලියකියවිලි: http://ruby-doc.org/core/Kernel.html#method-i-system

   wasGood = system( "echo 'hi'" )
   wasGood = system( cmd )
   

4. Kernel#exec

   දී ඇති බාහිර විධානය ක්‍රියාත්මක කිරීමෙන් වත්මන් ක්‍රියාවලිය ප්‍රතිස්ථාපනය කරයි.

   කිසිවක් ලබා නොදේ, වත්මන් ක්‍රියාවලිය ප්‍රතිස්ථාපනය වන අතර කිසි විටෙකත් ඉදිරියට නොයයි.

   ලියකියවිලි: http://ruby-doc.org/core/Kernel.html#method-i-exec

   exec( "echo 'hi'" )
   exec( cmd ) # Note: this will never be reached because of the line above
   

මෙන්න සමහර අමතර උපදෙස් ය: $?, සමාන වන $CHILD_STATUS, ඔබ backticks භාවිතා කරන්නේ නම් පසුගිය පද්ධතියේ තත්ත්වය විධානය ක්රියාත්මක ප්රවේශ, system()හෝ %x{}. එවිට ඔබට exitstatusසහ pidගුණාංග වෙත පිවිසිය හැකිය :

$?.exitstatus

වැඩිදුර කියවීම සඳහා බලන්න:

• http://www.elctech.com/blog/im-in-ur-commandline-executin-ma-commands
• http://blog.jayfields.com/2006/06/ruby-kernel-system-exec-and-x.html
• http://tech.natemurray.com/2007/03/ruby-shell-commands.html

මෙන්න " රූබි හි උපසිරැසියක් දියත් කිරීමේ සෑම ක්‍රමයක්ම භාවිතා කරන්නේ කවදාද " යන්න මත පදනම් වූ ගැලීම් සටහනක් . මෙයද බලන්න, " යෙදුමක් එහි ස්ථායීතාවය ටර්මිනලයක් මිස පයිප්පයක් යැයි සිතීමට උත්සාහ කරන්න ".

මම මෙය කිරීමට කැමති ආකාරය %xවචනානුසාරයෙන් භාවිතා කිරීම වන අතර එමඟින් විධානයක් තුළ උපුටා දැක්වීම් භාවිතා කිරීම පහසු කරයි (සහ කියවිය හැකිය!):

directorylist = %x[find . -name '*test.rb' | sort]

මෙම අවස්ථාවෙහිදී, වත්මන් නාමාවලිය යටතේ ඇති සියලුම පරීක්ෂණ ලිපිගොනු සමඟ ගොනු ලැයිස්තුව ජනනය කරනු ඇත, ඔබට අපේක්ෂිත පරිදි සැකසිය හැක:

directorylist.each do |filename|
  filename.chomp!
  # work with file
end

රූබි හි ෂෙල් ස්ක්‍රිප්ට් ධාවනය කිරීම පිළිබඳ මගේ මතයේ හොඳම ලිපිය මෙන්න: "රූබි තුළ ෂෙල් විධාන ක්‍රියාත්මක කිරීමට ක්‍රම 6 ක් ".

ඔබට අවශ්‍ය වන්නේ ප්‍රතිදානය පමණක් ලබා ගැනීමයි.

මට STDOUT සහ STDERR වැනි වඩා දියුණු දේවල් අවශ්‍ය වූ නිසා මම Open4 මැණික් භාවිතා කළෙමි. එහි විස්තර කර ඇති සියලුම ක්‍රම ඔබ සතුව ඇත.

මගේ ප්‍රියතම එක Open3

  require "open3"

  Open3.popen3('nroff -man') { |stdin, stdout, stderr| ... }

මෙම යාන්ත්‍රණයන් අතර තෝරාගැනීමේදී සිතා බැලිය යුතු කරුණු කිහිපයක් නම්:

1. ඔබට stdout අවශ්‍යද? නැතිනම් ඔබට stderr අවශ්‍යද? නැත්නම් වෙන්ව සිටිනවාද?
2. ඔබේ ප්‍රතිදානය කොතරම් විශාලද? සම්පූර්ණ ප්‍රති result ලය මතකයේ රඳවා ගැනීමට ඔබට අවශ්‍යද?
3. උප ක්‍රියාවලිය තවමත් ක්‍රියාත්මක වන අතරතුර ඔබේ ප්‍රතිදානය සමහරක් කියවීමට ඔබට අවශ්‍යද?
4. ඔබට ප්‍රති result ල කේත අවශ්‍යද?
5. ක්‍රියාවලිය නියෝජනය කරන සහ ඉල්ලුමට අනුව එය විනාශ කිරීමට ඔබට ඉඩ දෙන රූබි වස්තුවක් ඔබට අවශ්‍යද?

ඔබට සරල බැක්ටික්ස් (``) system(), සහ IO.popenපූර්ණ ලෙස Kernel.fork/ Kernel.execසමග IO.pipeසහ ඕනෑම දෙයක් අවශ්‍ය විය හැකිය IO.select.

උප ක්‍රියාවලියක් ක්‍රියාත්මක කිරීමට වැඩි කාලයක් ගත වුවහොත් ඔබට කල් ඉකුත්වීම මිශ්‍රණයට විසි කිරීමට අවශ්‍ය විය හැකිය.

අවාසනාවට, එය බොහෝ දුරට රඳා පවතී .

තවත් එක් විකල්පයක්:

ඔබ විට:

• stderr මෙන්ම stdout ද අවශ්‍යයි
• Open3 / Open4 භාවිතා කළ නොහැක / භාවිතා කළ නොහැක (ඔවුන් මගේ මැක් මත නෙට්බීන්ස් හි ව්‍යතිරේකයන් විසි කරයි, ඒ මන්දැයි නොදැන)

ඔබට ෂෙල් යළි හරවා යැවීම භාවිතා කළ හැකිය:

puts %x[cat bogus.txt].inspect
  => ""

puts %x[cat bogus.txt 2>&1].inspect
  => "cat: bogus.txt: No such file or directory\n"

මෙම 2>&1කාරක රීති හරහා වැඩ ලිනක්ස් , මැක් සහ වින්ඩෝස් MS-DOS මුල් දින සිට.

මම අනිවාර්යයෙන්ම රූබි විශේෂ expert යෙක් නොවෙමි, නමුත් මම එයට පහරක් දෙන්නෙමි:

$ irb 
system "echo Hi"
Hi
=> true

ඔබටත් මෙවැනි දේ කිරීමට හැකි විය යුතුය:

cmd = 'ls'
system(cmd)

ඉහත පිළිතුරු දැනටමත් ඉතා විශිෂ්ටයි, නමුත් මට ඇත්ත වශයෙන්ම පහත සාරාංශ ලිපිය බෙදා ගැනීමට අවශ්‍යයි: " රූබි තුළ ෂෙල් විධාන ක්‍රියාත්මක කිරීමට ක්‍රම 6 ක් "

මූලික වශයෙන්, එය අපට පවසන්නේ:

Kernel#exec:

exec 'echo "hello $HOSTNAME"'

systemසහ $?:

system 'false' 
puts $?

බැක්ටික්ස් (`):

today = `date`

IO#popen:

IO.popen("date") { |f| puts f.gets }

Open3#popen3 - stdlib:

require "open3"
stdin, stdout, stderr = Open3.popen3('dc') 

Open4#popen4 - මැණික්:

require "open4" 
pid, stdin, stdout, stderr = Open4::popen4 "false" # => [26327, #<IO:0x6dff24>, #<IO:0x6dfee8>, #<IO:0x6dfe84>]

ඔබට සැබවින්ම Bash අවශ්‍ය නම්, “හොඳම” පිළිතුරේ සටහනකට අනුව.

පළමුව, රූබි සහ shell අයැදින විට, එය සාමාන්යයෙන් හඳුන්වන බවයි සටහන් /bin/sh, නෑ බෑෂ්. සමහර /bin/shපද්ධතිවල සියලුම බාෂ් සින්ටැක්ස් සහාය නොදක්වයි .

ඔබට Bash භාවිතා කිරීමට අවශ්‍ය නම්, ඔබ bash -c "your Bash-only command"කැමති ඇමතුම් ක්‍රමයට ඇතුල් කරන්න :

quick_output = system("ls -la")

quick_bash = system("bash -c 'ls -la'")

පරීක්ෂා කිරීමට:

system("echo $SHELL")
system('bash -c "echo $SHELL"')

නැතහොත් ඔබ දැනට පවතින ස්ක්‍රිප්ට් ගොනුවක් වැනි ධාවනය කරන්නේ නම්

script_output = system("./my_script.sh")

රූබි ෂෙබාං වලට ගරු කළ යුතුය , නමුත් ඔබට සැමවිටම භාවිතා කළ හැකිය

system("bash ./my_script.sh")

/bin/shධාවනය සඳහා සුළු පොදු කාර්යයක් තිබිය හැකි බව සහතික කර ගැනීමට /bin/bash, ඔබ බොහෝ විට නොදකිනු ඇත.

ඔබට පර්ල්ට සමාන බැක්ටික් ක්‍රියාකරුවන් (`) භාවිතා කළ හැකිය:

directoryListing = `ls /`
puts directoryListing # prints the contents of the root directory

ඔබට සරල දෙයක් අවශ්‍ය නම් හැන්ඩි.

ඔබට භාවිතා කිරීමට අවශ්‍ය කුමන ක්‍රමයද යන්න ඔබ ඉටු කිරීමට උත්සාහ කරන දේ මත රඳා පවතී. විවිධ ක්‍රම පිළිබඳ වැඩි විස්තර සඳහා ලියකියවිලි පරීක්ෂා කරන්න.

අපට එය විවිධාකාරයෙන් සාක්ෂාත් කරගත හැකිය.

භාවිතා කිරීම Kernel#exec, මෙම විධානය ක්‍රියාත්මක කිරීමෙන් පසු කිසිවක්:

exec('ls ~')

භාවිතා කිරීම backticks or %x

`ls ~`
=> "Applications\nDesktop\nDocuments"
%x(ls ~)
=> "Applications\nDesktop\nDocuments"

Kernel#systemවිධානය භාවිතා කිරීම , trueසාර්ථක නම් ප්‍රතිලාභ , falseඅසාර්ථක නම් සහ nilවිධාන ක්‍රියාත්මක කිරීම අසමත් වුවහොත් නැවත පැමිණේ :

system('ls ~')
=> true

පහසුම ක්‍රමය, උදාහරණයක් ලෙස:

reboot = `init 6`
puts reboot

මෙහි ඇති පිළිතුරු භාවිතා කර මිහයිගේ පිළිතුරට සම්බන්ධ කර, මෙම අවශ්‍යතා සපුරාලන ශ්‍රිතයක් මම ඉදිරිපත් කළෙමි:

1. STDOUT සහ STDERR පිළිවෙලින් ග්‍රහණය කරගනී, එබැවින් මගේ ස්ක්‍රිප්ට් කොන්සෝලය වෙතින් ක්‍රියාත්මක වන විට ඒවා “කාන්දු නොවේ”.
2. අරාව ලෙස තර්ක ෂෙල් එකට යැවීමට ඉඩ දෙයි, එබැවින් පැන යාම ගැන කරදර විය යුතු නැත.
3. විධානයෙන් පිටවීමේ තත්වය ග්‍රහණය කර ගන්නා අතර දෝෂයක් ඇති වූ විට එය පැහැදිලි වේ.

ප්‍රසාද දීමනාවක් ලෙස, ෂෙල් විධානය සාර්ථකව පිටවන අවස්ථා වලදී (0) STDOUT නැවත ලබා දෙනු ඇත. මේ ආකාරයෙන්, එය වෙනස් වන අතර system, trueඑවැනි අවස්ථාවන්හිදී සරලවම ආපසු පැමිණේ .

කේතය පහත දැක්වේ. නිශ්චිත කාර්යය වන්නේ system_quietly:

require 'open3'

class ShellError < StandardError; end

#actual function:
def system_quietly(*cmd)
  exit_status=nil
  err=nil
  out=nil
  Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thread|
    err = stderr.gets(nil)
    out = stdout.gets(nil)
    [stdin, stdout, stderr].each{|stream| stream.send('close')}
    exit_status = wait_thread.value
  end
  if exit_status.to_i > 0
    err = err.chomp if err
    raise ShellError, err
  elsif out
    return out.chomp
  else
    return true
  end
end

#calling it:
begin
  puts system_quietly('which', 'ruby')
rescue ShellError
  abort "Looks like you don't have the `ruby` command. Odd."
end

#output: => "/Users/me/.rvm/rubies/ruby-1.9.2-p136/bin/ruby"

spawnනිශ්චිත විධානය ක්‍රියාත්මක කිරීම සඳහා පසුබිම් ක්‍රියාවලියක් නිර්මාණය කිරීමේ විධානය අමතක නොකරන්න . Processපංතිය සහ ආපසු පැමිණීම භාවිතා කර එය සම්පූර්ණ වන තෙක් ඔබට බලා සිටිය හැකිය pid:

pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
Process.wait pid

pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
Process.wait pid

ලේඛනය පවසයි: මෙම ක්‍රමය සමාන #systemනමුත් එය විධානය අවසන් වන තෙක් බලා නොසිටිනු ඇත.

ඔබට හැසිරවිය නොහැකි පොදු නඩුවට වඩා සංකීර්ණ නඩුවක් තිබේ ``නම්, පරීක්ෂා කරන්න Kernel.spawn(). බාහිර විධාන ක්‍රියාත්මක කිරීම සඳහා කොටස් රූබි විසින් සපයන ලද වඩාත්ම ජනක / පූර්ණ අංගයක් ලෙස මෙය පෙනේ.

ඔබට මෙය භාවිතා කළ හැකිය:

• ක්‍රියාවලි කණ්ඩායම් (වින්ඩෝස්) සාදන්න.
• ලිපිගොනු / එකිනෙකා වෙත හරවා යැවීම, පිටතට යාම.
• env vars, umask සකසන්න.
• විධානයක් ක්‍රියාත්මක කිරීමට පෙර නාමාවලිය වෙනස් කරන්න.
• CPU / data / etc සඳහා සම්පත් සීමාවන් නියම කරන්න.
• වෙනත් විකල්ප සමඟ වෙනත් පිළිතුරු සමඟ කළ හැකි නමුත් වැඩි කේතයකින් කළ හැකි සියල්ල කරන්න.

මෙම රූබි ප්රලේඛනය හොඳ උදාහරණ ඇත:

env: hash
  name => val : set the environment variable
  name => nil : unset the environment variable
command...:
  commandline                 : command line string which is passed to the standard shell
  cmdname, arg1, ...          : command name and one or more arguments (no shell)
  [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
options: hash
  clearing environment variables:
    :unsetenv_others => true   : clear environment variables except specified by env
    :unsetenv_others => false  : dont clear (default)
  process group:
    :pgroup => true or 0 : make a new process group
    :pgroup => pgid      : join to specified process group
    :pgroup => nil       : dont change the process group (default)
  create new process group: Windows only
    :new_pgroup => true  : the new process is the root process of a new process group
    :new_pgroup => false : dont create a new process group (default)
  resource limit: resourcename is core, cpu, data, etc.  See Process.setrlimit.
    :rlimit_resourcename => limit
    :rlimit_resourcename => [cur_limit, max_limit]
  current directory:
    :chdir => str
  umask:
    :umask => int
  redirection:
    key:
      FD              : single file descriptor in child process
      [FD, FD, ...]   : multiple file descriptor in child process
    value:
      FD                        : redirect to the file descriptor in parent process
      string                    : redirect to file with open(string, "r" or "w")
      [string]                  : redirect to file with open(string, File::RDONLY)
      [string, open_mode]       : redirect to file with open(string, open_mode, 0644)
      [string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
      [:child, FD]              : redirect to the redirected file descriptor
      :close                    : close the file descriptor in child process
    FD is one of follows
      :in     : the file descriptor 0 which is the standard input
      :out    : the file descriptor 1 which is the standard output
      :err    : the file descriptor 2 which is the standard error
      integer : the file descriptor of specified the integer
      io      : the file descriptor specified as io.fileno
  file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
    :close_others => false : inherit fds (default for system and exec)
    :close_others => true  : dont inherit (default for spawn and IO.popen)

රූබි වෙතින් ෂෙල් විධාන ඇමතීමට පහසුම ක්‍රමය වන්නේ බැක්ටික්ස් (`) ක්‍රමයයි. එය shell විධානයේ ප්‍රති result ලය ලබා දෙයි:

     url_request = 'http://google.com'
     result_of_shell_command = `curl #{url_request}`

වැනි විධානයක් ලබා දී ඇත attrib:

require 'open3'

a="attrib"
Open3.popen3(a) do |stdin, stdout, stderr|
  puts stdout.read
end

මෙම ක්‍රමය තරම් මතක තබා ගත නොහැකි වුවත් මම සොයාගෙන ඇත

system("thecommand")

හෝ

`thecommand`

බැක්ටික්ස් වලදී, වෙනත් ක්‍රම සමඟ සසඳන විට මෙම ක්‍රමය පිළිබඳ හොඳ දෙයක් putsනම්, විචල්‍යයන් තුළ ධාවනය කිරීමට අවශ්‍ය විධානය මම ධාවනය කිරීමට / ගබඩා කිරීමට විධානයට system("thecommand")ඉඩ නොදෙන බව පෙනේ, නමුත් ප්‍රතිදානය ලබා ගැනීමට මට ඉඩ නොදෙන බව පෙනේ. මෙම ක්‍රමය මඟින් මට ඒ දෙකම කිරීමට ඉඩ ලබා දෙන අතර, එය මට ස්වාධීනව stdin, stdout සහ stderr වෙත පිවිසීමට ඉඩ දෙයි.

" රුබියේ විධාන ක්‍රියාත්මක කිරීම " සහ රූබීගේ Open3 ප්‍රලේඛනය බලන්න .

මෙය සැබවින්ම පිළිතුරක් නොවන නමුත් සමහර විට යමෙකුට එය ප්‍රයෝජනවත් වනු ඇත:

වින්ඩෝස් හි TK GUI භාවිතා කරන විට, ඔබට රුබයිව් වෙතින් ෂෙල් විධාන ඇමතීමට අවශ්‍ය නම්, ඔබට සැමවිටම කරදරකාරී සීඑම්ඩී කවුළුවක් තත්පරයකට අඩු කාලයක් දක්වා ඉහළ යනු ඇත.

මෙය වළක්වා ගැනීමට ඔබට භාවිතා කළ හැකිය:

WIN32OLE.new('Shell.Application').ShellExecute('ipconfig > log.txt','','','open',0)

හෝ

WIN32OLE.new('WScript.Shell').Run('ipconfig > log.txt',0,0)

දෙකම ipconfigප්‍රතිදානය ඇතුළත ගබඩා කරනු ඇත log.txt, නමුත් කවුළු කිසිවක් එන්නේ නැත.

require 'win32ole'ඔබේ පිටපත ඇතුළත ඔබට අවශ්‍ය වනු ඇත.

system(), exec()සහ spawn()TK සහ rubyw භාවිතා කරන විට එම කරදරකාරී කවුළුව සියල්ලම උත්පතන වනු ඇත.

මෙන්න මම OS X හි රූබි ස්ක්‍රිප්ට් එකක භාවිතා කරන සිසිල් එකක් (එවිට මට ස්ක්‍රිප්ට් එකක් ආරම්භ කර කවුළුවෙන් ටොගල් කිරීමෙන් පසුව පවා යාවත්කාලීනයක් ලබා ගත හැකිය):

cmd = %Q|osascript -e 'display notification "Server was reset" with title "Posted Update"'|
system ( cmd )