Le migliori pratiche con STDIN in Ruby?

Voglio occuparmi dell'input della riga di comando in Ruby:

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

Qual'è il miglior modo di farlo? In particolare, voglio occuparmi di STDIN vuoto e spero in una soluzione elegante.

#!/usr/bin/env ruby

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

ARGV.each do |b|
    puts b
end

Di seguito sono riportate alcune cose che ho trovato nella mia collezione di oscuri Ruby.

Quindi, in Ruby, una semplice implementazione senza comandi del comando Unix catsarebbe:

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

ARGFè tuo amico quando si tratta di input; è un file virtuale che ottiene tutti gli input dai file con nome o tutti da STDIN.

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

Per fortuna non abbiamo ottenuto l'operatore di diamanti in Ruby, ma abbiamo ottenuto ARGFin sostituzione. Sebbene oscuro, in realtà si rivela utile. Considera questo programma, che antepone le intestazioni del copyright sul posto (grazie a un altro Perlismo -i) a ogni file menzionato sulla riga di comando:

#!/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.
#++

Credito a:

• 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 fornisce un altro modo di gestire STDIN: il flag -n. Tratta l'intero programma come all'interno di un loop su STDIN, (inclusi i file passati come argomenti della riga di comando). Vedi ad esempio il seguente script di 1 riga:

#!/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

Non sono sicuro di cosa tu abbia bisogno, ma userei qualcosa del genere:

#!/usr/bin/env ruby

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

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

Si noti che poiché l'array ARGV è vuoto prima gets, Ruby non tenterà di interpretare l'argomento come file di testo da cui leggere (comportamento ereditato da Perl).

Se lo stdin è vuoto o non ci sono argomenti, non viene stampato nulla.

Pochi casi di test:

$ 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!

Qualcosa del genere forse?

#/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

Esempio:

> 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

Questo è ispirato a Perl:

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

Veloce e semplice:

STDIN.gets.chomp == 'YES'

Aggiungerò che per usare i ARGFparametri, devi cancellare ARGVprima di chiamare ARGF.each. Questo perché ARGFtratterà qualsiasi cosaARGV come un nome file e leggeranno prima le righe da lì.

Ecco un esempio di implementazione 'tee':

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

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

Faccio qualcosa del genere:

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

Sembra che la maggior parte delle risposte ipotizzino che gli argomenti siano nomi di file che contengono contenuti da associare allo stdin. Sotto tutto viene trattato come un semplice argomento. Se STDIN proviene dal TTY, viene ignorato.

$ cat tstarg.rb

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

Gli argomenti o lo stdin possono essere vuoti o contenere dati.

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