“Which in ruby”: Kiểm tra xem chương trình có tồn tại trong $ PATH từ ruby ​​không

các tập lệnh của tôi chủ yếu dựa vào các chương trình và tập lệnh bên ngoài. Tôi cần chắc chắn rằng có tồn tại một chương trình tôi cần gọi. Theo cách thủ công, tôi sẽ kiểm tra điều này bằng cách sử dụng 'which' trong dòng lệnh.

Có tương đương File.exists?với những thứ trong $PATHkhông?

(vâng, tôi đoán tôi có thể phân tích cú pháp %x[which scriptINeedToRun]nhưng điều đó không quá thanh lịch.

Cảm ơn! yannick

CẬP NHẬT: Đây là giải pháp tôi đã giữ lại:

 def command?(command)
       system("which #{ command} > /dev/null 2>&1")
 end

CẬP NHẬT 2: Một số câu trả lời mới đã xuất hiện - ít nhất một số câu trả lời trong số này cung cấp các giải pháp tốt hơn.

Cập nhật 3: Ptools gem đã thêm một phương thức "which" vào lớp File.

Giải pháp đa nền tảng thực sự, hoạt động bình thường trên Windows:

# Cross-platform way of finding an executable in the $PATH.
#
#   which('ruby') #=> /usr/bin/ruby
def which(cmd)
  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
    exts.each do |ext|
      exe = File.join(path, "#{cmd}#{ext}")
      return exe if File.executable?(exe) && !File.directory?(exe)
    end
  end
  nil
end

Điều này không sử dụng tính năng đánh hơi hệ điều hành máy chủ và tôn trọng $ PATHEXT, nơi liệt kê các phần mở rộng tệp hợp lệ cho các tệp thực thi trên Windows.

Bắn ra whichhoạt động trên nhiều hệ thống nhưng không phải tất cả.

Sử dụng find_executablephương thức mkmfđược đưa vào stdlib.

require 'mkmf'

find_executable 'ruby'
#=> "/Users/narkoz/.rvm/rubies/ruby-2.0.0-p0/bin/ruby"

find_executable 'which-ruby'
#=> nil

def command?(name)
  `which #{name}`
  $?.success?
end

Ban đầu được lấy từ trung tâm , được sử dụng type -tthay vì whichmặc dù (và không thành công cho cả zsh và bash đối với tôi).

Sử dụng MakeMakefile # find_executable0 với tính năng ghi nhật ký bị tắt

Đã có một số câu trả lời hay, nhưng đây là những gì tôi sử dụng:

require 'mkmf'

def set_mkmf_log(logfile=File::NULL)
  MakeMakefile::Logging.instance_variable_set(:@logfile, logfile)
end

# Return path to cmd as a String, or nil if not found.
def which(cmd)
  old_mkmf_log = MakeMakefile::Logging.instance_variable_get(:@logfile)
  set_mkmf_log(nil)
  path_to_cmd = find_executable0(cmd)
  set_mkmf_log(old_mkmf_log)
  path_to_cmd
end

Điều này sử dụng phương thức # find_executable0 không có giấy tờ được gọi bởi MakeMakefile # find_executable để trả về đường dẫn mà không làm lộn xộn đầu ra chuẩn. Phương thức #which cũng tạm thời chuyển hướng tệp nhật ký mkmf đến / dev / null để ngăn làm lộn xộn thư mục làm việc hiện tại với "mkmf.log" hoặc tương tự.

Bạn có thể truy cập các biến môi trường hệ thống bằng mã băm ENV:

puts ENV['PATH']

Nó sẽ trả về PATH trên hệ thống của bạn. Vì vậy, nếu bạn muốn biết chương trình nmapcó tồn tại hay không, bạn có thể làm như sau:

ENV['PATH'].split(':').each {|folder| puts File.exists?(folder+'/nmap')}

Điều này sẽ in truenếu tệp được tìm thấy hoặc falsenếu không.

Đây là những gì tôi đang sử dụng. Đây là nền tảng trung lập ( File::PATH_SEPARATORlà ":"trên Unix và ";"trên Windows), chỉ trông cho các tập tin chương trình mà thực sự là thực thi bởi người sử dụng có hiệu quả các quá trình hiện tại, và chấm dứt ngay sau khi chương trình được tìm thấy:

##
# Returns +true+ if the +program+ executable is found in the user's path.
def has_program?(program)
  ENV['PATH'].split(File::PATH_SEPARATOR).any? do |directory|
    File.executable?(File.join(directory, program.to_s))
  end
end

Có một GEM được gọi which_rubylà một Ruby thuần túy để triển khai. Nó không còn nữa.

Tuy nhiên, tôi đã tìm thấy cách triển khai thay thế thuần Ruby này .

Tôi muốn thêm rằng whichlấy cờ -scho chế độ im lặng, chỉ đặt cờ thành công, loại bỏ nhu cầu chuyển hướng đầu ra.

Đây là phiên bản cải tiến dựa trên câu trả lời của @ mislav . Điều này sẽ cho phép bất kỳ loại đầu vào đường dẫn nào và tuân thủ nghiêm ngặt cách cmd.exechọn tệp để thực thi trong Windows.

# which(cmd) :: string or nil
#
# Multi-platform implementation of "which".
# It may be used with UNIX-based and DOS-based platforms.
#
# The argument can not only be a simple command name but also a command path
# may it be relative or complete.
#
def which(cmd)
  raise ArgumentError.new("Argument not a string: #{cmd.inspect}") unless cmd.is_a?(String)
  return nil if cmd.empty?
  case RbConfig::CONFIG['host_os']
  when /cygwin/
    exts = nil
  when /dos|mswin|^win|mingw|msys/
    pathext = ENV['PATHEXT']
    exts = pathext ? pathext.split(';').select{ |e| e[0] == '.' } : ['.com', '.exe', '.bat']
  else
    exts = nil
  end
  if cmd[File::SEPARATOR] or (File::ALT_SEPARATOR and cmd[File::ALT_SEPARATOR])
    if exts
      ext = File.extname(cmd)
      if not ext.empty? and exts.any?{ |e| e.casecmp(ext).zero? } \
      and File.file?(cmd) and File.executable?(cmd)
        return File.absolute_path(cmd)
      end
      exts.each do |ext|
        exe = "#{cmd}#{ext}"
        return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
      end
    else
      return File.absolute_path(cmd) if File.file?(cmd) and File.executable?(cmd)
    end
  else
    paths = ENV['PATH']
    paths = paths ? paths.split(File::PATH_SEPARATOR).select{ |e| File.directory?(e) } : []
    if exts
      ext = File.extname(cmd)
      has_valid_ext = (not ext.empty? and exts.any?{ |e| e.casecmp(ext).zero? })
      paths.unshift('.').each do |path|
        if has_valid_ext
          exe = File.join(path, "#{cmd}")
          return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
        end
        exts.each do |ext|
          exe = File.join(path, "#{cmd}#{ext}")
          return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
        end
      end
    else
      paths.each do |path|
        exe = File.join(path, cmd)
        return File.absolute_path(exe) if File.file?(exe) and File.executable?(exe)
      end
    end
  end
  nil
end

Tôi có cái này:

def command?(name)
  [name,
   *ENV['PATH'].split(File::PATH_SEPARATOR).map {|p| File.join(p, name)}
  ].find {|f| File.executable?(f)}
end

hoạt động cho các đường dẫn đầy đủ cũng như các lệnh:

irb(main):043:0> command?("/bin/bash")
=> "/bin/bash"
irb(main):044:0> command?("bash")
=> "/bin/bash"
irb(main):006:0> command?("bush")
=> nil

Trên linux tôi sử dụng:

exists = `which #{command}`.size.>(0)

Thật không may, whichkhông phải là một lệnh POSIX và do đó hoạt động khác nhau trên Mac, BSD, v.v. (tức là, tạo ra lỗi nếu không tìm thấy lệnh). Có lẽ giải pháp lý tưởng sẽ là sử dụng

`command -v #{command}`.size.>(0)  # fails!: ruby can't access built-in functions

Nhưng điều này không thành công vì ruby ​​dường như không có khả năng truy cập các chức năng được tích hợp sẵn. Nhưng command -vsẽ là cách POSIX để làm điều này.

Giải pháp dựa trên rogeriovl, nhưng hoàn thành chức năng với kiểm tra thực thi hơn là kiểm tra tồn tại.

def command_exists?(command)
  ENV['PATH'].split(':').each {|folder| File.executable?(File.join(folder, command))}
end

Sẽ chỉ hoạt động với UNIX (Windows không sử dụng dấu hai chấm làm dấu phân tách)

Đây là một bản điều chỉnh câu trả lời của rogeriopvl, làm cho nó đa nền tảng:

require 'rbconfig'

def is_windows?
  Config::CONFIG["host_os"] =~ /mswin|mingw/
end

def exists_in_path?(file)
  entries = ENV['PATH'].split(is_windows? ? ";" : ":")
  entries.any? {|f| File.exists?("#{f}/#{file}")}
end

đối với jruby, bất kỳ giải pháp nào phụ thuộc vào mkmfcó thể không hoạt động, vì nó có phần mở rộng C.

đối với jruby, sau đây là một cách dễ dàng để kiểm tra xem thứ gì đó có thể thực thi được trên đường dẫn hay không:

main » unix_process = java.lang.Runtime.getRuntime().exec("git status")
=> #<Java::JavaLang::UNIXProcess:0x64fa1a79>
main » unix_process.exitValue()
=> 0
main »

nếu tệp thực thi không có ở đó, nó sẽ gây ra lỗi thời gian chạy, vì vậy bạn có thể muốn thực hiện việc này trong một khối try / catch trong cách sử dụng thực tế của bạn.

#####################################################
# add methods to see if there's an executable that's executable
#####################################################
class File
  class << self
    ###########################################
    # exists and executable
    ###########################################
    def cmd_executable?(cmd)
      !ENV['PATH'].split(':').select { |f| executable?(join(f, cmd[/^[^ \n\r]*/])) }.empty?
    end
  end
end

Không quá thanh lịch nhưng nó hoạt động :).

def cmdExists?(c)
  system(c + " > /dev/null")
  return false if $?.exitstatus == 127
  true
end

Cảnh báo : Đây là lời khuyên KHÔNG được khuyến khích, nguy hiểm !