Ik heb enkele eenvoudige shell scripting-taken die ik wil doen
Bijvoorbeeld: een bestand selecteren in de werkmap vanuit een lijst met de bestanden die overeenkomen met een regelmatige expressie.
Ik weet dat ik dit soort dingen kan doen met standaard bash en grep, maar ik zou leuk zijn om snel scripts te kunnen hacken die in Windows en Linux werken zonder dat ik een hoop opdrachtregelprogramma’s en vlaggen moeten onthouden enz.
Ik heb geprobeerd om dit in de gaten te krijgen, maar eindigde in de war over waar ik informatie zou krijgen, zoals een verwijzing naar de huidige directory
Dus de vraag is welke delen van de Ruby-bibliotheken ik moet weten om Ruby Shell-scripts te schrijven?
Antwoord 1, Autoriteit 100%
Standaard heeft u al toegang tot dir en bestand , die vanzelf vrij nuttig zijn.
Dir['*.rb'] #basic globs
Dir['**/*.rb'] #** == any depth of directory, including current dir.
#=> array of relative names
File.expand_path('~/file.txt') #=> "/User/mat/file.txt"
File.dirname('dir/file.txt') #=> 'dir'
File.basename('dir/file.txt') #=> 'file.txt'
File.join('a', 'bunch', 'of', 'strings') #=> 'a/bunch/of/strings'
__FILE__ #=> the name of the current file
Ook handig van de STDLIB is FILEUTILS
require 'fileutils' #I know, no underscore is not ruby-like
include FileUtils
# Gives you access (without prepending by 'FileUtils.') to
cd(dir, options)
cd(dir, options) {|dir| .... }
pwd()
mkdir(dir, options)
mkdir(list, options)
mkdir_p(dir, options)
mkdir_p(list, options)
rmdir(dir, options)
rmdir(list, options)
ln(old, new, options)
ln(list, destdir, options)
ln_s(old, new, options)
ln_s(list, destdir, options)
ln_sf(src, dest, options)
cp(src, dest, options)
cp(list, dir, options)
cp_r(src, dest, options)
cp_r(list, dir, options)
mv(src, dest, options)
mv(list, dir, options)
rm(list, options)
rm_r(list, options)
rm_rf(list, options)
install(src, dest, mode = <src's>, options)
chmod(mode, list, options)
chmod_R(mode, list, options)
chown(user, group, list, options)
chown_R(user, group, list, options)
touch(list, options)
Wat is best leuk
Antwoord 2, Autoriteit 74%
Zoals de anderen al hebben gezegd, moet uw eerste regel
zijn
#!/usr/bin/env ruby
En u moet het ook uitvoerbaar maken: (in de schaal)
chmod +x test.rb
Volg vervolgens de robijncode. Als u een bestand opent
File.open("file", "r") do |io|
# do something with io
end
Het bestand wordt geopend in de huidige map die u krijgt bij pwdin de schaal.
Het pad naar uw script is ook eenvoudig te krijgen. Met $0krijgt u het eerste argument van de schaal, wat het relatieve pad is naar uw script. Het absolute pad kan zo worden bepaald:
#!/usr/bin/env ruby
require 'pathname'
p Pathname.new($0).realpath()
Voor bestandssysteembewerkingen gebruik ik bijna altijd padnaam. Dit is een wikkel voor veel van de andere klassen met betrekking tot bestandsystemen. Ook handig: dir, bestand …
Antwoord 3, Autoriteit 45%
Hier is iets belangrijks dat ontbreekt in de andere antwoorden: de opdrachtregelparameters worden blootgesteld aan uw Ruby Shell-script via de Argv (Global) Array.
Dus, als u een script had genaamd My_Shell_Script:
#!/usr/bin/env ruby
puts "I was passed: "
ARGV.each do |value|
puts value
end
… maak het uitvoerbaar (zoals anderen hebben genoemd):
chmod u+x my_shell_script
en bel het zoals SO:
> ./my_shell_script one two three four five
u krijgt dit:
I was passed:
one
two
three
four
five
De argumenten werken mooi met bestandsnaamuitbreiding:
./my_shell_script *
I was passed:
a_file_in_the_current_directory
another_file
my_shell_script
the_last_file
Meestal werkt het alleen op Unix (Linux, Mac OS X), maar u kunt vergelijkbare (hoewel minder handige) dingen in Windows doen.
Antwoord 4, Autoriteit 22%
Er is hier veel goed advies, dus ik wilde een klein beetje meer toevoegen.
-
Backticks (of back-ticks) Laat je wat scripting dingen een stuk eenvoudiger doen. Overweeg
puts `find . | grep -i lib` -
Als u problemen tegenkomt met het verkrijgen van de uitvoer van Backticks, gaat het spul standaard ERR in plaats van standaard uit. Gebruik dit advies
out = `git status 2>&1` -
Backticks Do String Interpolation:
blah = 'lib' `touch #{blah}` -
kunt u in robijn buigen, te . Het is een link naar mijn blog, maar het koppelt hier terug, dus het is oké 🙂 Er zijn waarschijnlijk meer geavanceerde dingen die er op dit onderwerp zijn.
-
Zoals andere mensen merkten, als je serieus wilt worden, is er haast: niet alleen als een shell-vervanging (wat een beetje te zaneel voor mij is) maar ook Als een bibliotheek voor uw gebruik in shell-scripts en programma’s.
op Mac, gebruik AppleScript in Ruby voor meer kracht. Hier is mijn shell_hereScript:
#!/usr/bin/env ruby
`env | pbcopy`
cmd = %Q@tell app "Terminal" to do script "$(paste_env)"@
puts cmd
`osascript -e "${cmd}"`
Antwoord 5, Autoriteit 15%
Ga zelf een kopie van alledaagse scripting met Ruby . Het heeft veel nuttige tips voor het doen van de soorten dingen die u wilt doen.
Antwoord 6, Autoriteit 8%
Dit kan ook nuttig zijn: http://rush.heroku.com/
Ik heb het niet veel gebruikt, maar ziet er behoorlijk cool uit
Vanaf de site:
Rush is een vervanging voor de Unix Shell (bash, zsh, enz.) Die pure robijnse syntaxis gebruikt. GREP via bestanden, vind en doden processen, kopieer bestanden – alles wat u doet in de schaal, nu in Ruby
Antwoord 7, Autoriteit 8%
Laten we zeggen dat je je script.rbscript schrijft. Zet:
#!/usr/bin/env ruby
als de eerste regel en doe een chmod +x script.rb
Antwoord 8, Autoriteit 5%
Wanneer u meer complexe robijn-scripts wilt schrijven, kunnen deze gereedschappen helpen:
Bijvoorbeeld:
-
Thor (een scripting framework)
-
gli (git zoals interface)
-
methadon (voor het maken van eenvoudige tools)
Ze geven je een snelle start om je eigen scripts te schrijven, vooral ‘Opdrachtregel-app’.
Antwoord 9, autoriteit 3%
‘Hoe schrijf ik robijn’ valt iets buiten het bestek van SO.
Maar om deze ruby-scripts om te zetten in uitvoerbare scripts, zet u dit als de eerste regel van uw ruby-script:
#!/path/to/ruby
Maak het bestand vervolgens uitvoerbaar:
chmod a+x myscript.rb
en daar ga je.
Antwoord 10, autoriteit 3%
Het bovenstaande antwoord is interessant en erg handig bij het gebruik van Ruby als shellscript. Voor mij gebruik ik Ruby niet als mijn dagelijkse taal en ik gebruik liever ruby alleen als stroomregeling en gebruik nog steeds bash om de taken uit te voeren.
Sommige helperfuncties kunnen worden gebruikt voor het testen van het uitvoeringsresultaat
#!/usr/bin/env ruby
module ShellHelper
def test(command)
`#{command} 2> /dev/null`
$?.success?
end
def execute(command, raise_on_error = true)
result = `#{command}`
raise "execute command failed\n" if (not $?.success?) and raise_on_error
return $?.success?
end
def print_exit(message)
print "#{message}\n"
exit
end
module_function :execute, :print_exit, :test
end
Met helper kan het ruby-script hetzelfde zijn als bash:
#!/usr/bin/env ruby
require './shell_helper'
include ShellHelper
print_exit "config already exists" if test "ls config"
things.each do |thing|
next if not test "ls #{thing}/config"
execute "cp -fr #{thing}/config_template config/#{thing}"
end
Antwoord 11, autoriteit 3%
Plaats dit aan het begin van je script.rb
#!/usr/bin/env ruby
Markeer het dan als uitvoerbaar:
chmod +x script.rb
Antwoord 12, autoriteit 2%
Het antwoord van webmatis perfect. Ik wil u alleen wijzen op een toevoeging. Als je veel te maken hebt met command line parameters voor je scripts, gebruik dan optparse. Het is eenvoudig en helpt je enorm.
Antwoord 13, autoriteit 2%
In ruby geeft de constante __FILE__je altijd het pad van het script dat je uitvoert.
Onder Linux is /usr/bin/envje vriend:
#! /usr/bin/env ruby
# Extension of this script does not matter as long
# as it is executable (chmod +x)
puts File.expand_path(__FILE__)
In Windows hangt het ervan af of .rb-bestanden al dan niet aan ruby zijn gekoppeld.
Als ze zijn:
# This script filename must end with .rb
puts File.expand_path(__FILE__)
Als dat niet het geval is, moet je er expliciet ruby op aanroepen, ik gebruik een tussenliggend .cmd-bestand:
mijn_script.cmd:
@ruby %~dp0\my_script.rb
mijn_script.rb:
puts File.expand_path(__FILE__)