Best Practices mit STDIN in Ruby?

Ich möchte mich mit der Befehlszeileneingabe in Ruby befassen:

> cat input.txt | myprog.rb
> myprog.rb < input.txt
> myprog.rb arg1 arg2 arg3 ...

Was ist der beste Weg, um es zu tun? Insbesondere möchte ich mich mit leerem STDIN befassen und hoffe auf eine elegante Lösung.

#!/usr/bin/env ruby

STDIN.read.split("\n").each do |a|
   puts a
end

ARGV.each do |b|
    puts b
end

Im Folgenden sind einige Dinge aufgeführt, die ich in meiner Sammlung von obskurem Ruby gefunden habe.

In Ruby wäre eine einfache No-Bells-Implementierung des Unix-Befehls catalso:

#!/usr/bin/env ruby
puts ARGF.read

ARGFist dein Freund, wenn es um Input geht; Es ist eine virtuelle Datei, die alle Eingaben von benannten Dateien oder alle von STDIN erhält.

ARGF.each_with_index do |line, idx|
    print ARGF.filename, ":", idx, ";", line
end

# print all the lines in every file passed via command line that contains login
ARGF.each do |line|
    puts line if line =~ /login/
end

Gott sei Dank haben wir den Diamantenbetreiber in Ruby nicht bekommen, aber wir haben ihn ARGFals Ersatz bekommen. Obwohl dunkel, erweist es sich tatsächlich als nützlich. Betrachten Sie dieses Programm, bei dem Copyright-Header (dank eines anderen Perlismus -i) jeder in der Befehlszeile genannten Datei vorangestellt werden:

#!/usr/bin/env ruby -i

Header = DATA.read

ARGF.each_line do |e|
  puts Header if ARGF.pos - e.length == 0
  puts e
end

__END__
#--
# Copyright (C) 2007 Fancypants, Inc.
#++

Gutschrift an:

• http://www.oreillynet.com/ruby/blog/2007/04/trivial_scripting_with_ruby.html#comment-565558
• http://blog.nicksieger.com/articles/2007/10/06/obscure-and-ugly-perlisms-in-ruby

Ruby bietet eine andere Möglichkeit, mit STDIN umzugehen: Das Flag -n. Es behandelt Ihr gesamtes Programm als eine Schleife über STDIN (einschließlich Dateien, die als Befehlszeilenargumente übergeben werden). Siehe zB das folgende 1-zeilige Skript:

#!/usr/bin/env ruby -n

#example.rb

puts "hello: #{$_}" #prepend 'hello:' to each line from STDIN

#these will all work:
# ./example.rb < input.txt
# cat input.txt | ./example.rb
# ./example.rb input.txt

Ich bin mir nicht ganz sicher, was Sie brauchen, aber ich würde so etwas verwenden:

#!/usr/bin/env ruby

until ARGV.empty? do
  puts "From arguments: #{ARGV.shift}"
end

while a = gets
  puts "From stdin: #{a}"
end

Beachten Sie, dass getsRuby , da das ARGV-Array zuvor leer war , nicht versucht, das Argument als Textdatei zu interpretieren, aus der gelesen werden soll (von Perl geerbtes Verhalten).

Wenn stdin leer ist oder keine Argumente vorhanden sind, wird nichts gedruckt.

Einige Testfälle:

$ cat input.txt | ./myprog.rb
From stdin: line 1
From stdin: line 2

$ ./myprog.rb arg1 arg2 arg3
From arguments: arg1
From arguments: arg2
From arguments: arg3
hi!
From stdin: hi!

So etwas vielleicht?

#/usr/bin/env ruby

if $stdin.tty?
  ARGV.each do |file|
    puts "do something with this file: #{file}"
  end
else
  $stdin.each_line do |line|
    puts "do something with this line: #{line}"
  end
end

Beispiel:

> cat input.txt | ./myprog.rb
do something with this line: this
do something with this line: is
do something with this line: a
do something with this line: test
> ./myprog.rb < input.txt 
do something with this line: this
do something with this line: is
do something with this line: a
do something with this line: test
> ./myprog.rb arg1 arg2 arg3
do something with this file: arg1
do something with this file: arg2
do something with this file: arg3

while STDIN.gets
  puts $_
end

while ARGF.gets
  puts $_
end

Dies ist inspiriert von Perl:

while(<STDIN>){
  print "$_\n"
}

Schnell und einfach:

STDIN.gets.chomp == 'YES'

Ich werde das hinzufügen, um ARGFmit Parametern zu verwenden, müssen Sie ARGVvor dem Aufruf löschen ARGF.each. Dies liegt daran ARGF, dass alles in ARGVals Dateiname behandelt wird und zuerst die Zeilen von dort gelesen werden.

Hier ist ein Beispiel für eine Tee-Implementierung:

File.open(ARGV[0], 'w') do |file|
  ARGV.clear

  ARGF.each do |line|
    puts line
    file.write(line)
  end
end

Ich mache so etwas:

all_lines = ""
ARGV.each do |line|
  all_lines << line + "\n"
end
puts all_lines

Es scheint, dass die meisten Antworten davon ausgehen, dass die Argumente Dateinamen sind, die Inhalte enthalten, die dem Standard zugeordnet werden sollen. Im Folgenden wird alles nur als Argument behandelt. Wenn STDIN vom TTY stammt, wird es ignoriert.

$ cat tstarg.rb

while a=(ARGV.shift or (!STDIN.tty? and STDIN.gets) )
  puts a
end

Entweder Argumente oder stdin können leer sein oder Daten enthalten.

$ cat numbers 
1
2
3
4
5
$ ./tstarg.rb a b c < numbers
a
b
c
1
2
3
4
5