मैं शैल स्क्रिप्टिंग के लिए रूबी का उपयोग कैसे करूं?

Question

मेरे पास कुछ सरल शैल स्क्रिप्टिंग कार्य हैं जो मैं

उदाहरण के लिए: कुछ नियमित अभिव्यक्ति से मेल खाने वाली फ़ाइलों की सूची से कार्यशील निर्देशिका में फ़ाइल का चयन करना चाहता हूं।

मुझे पता है कि मैं मानक बैश और grep का उपयोग करके इस तरह की चीज कर सकता हूं लेकिन मुझे विंडोज़ और लिनक्स में काम करने के लिए त्वरित स्क्रिप्ट्स हैक करने में सक्षम होना अच्छा होगा, बिना मुझे कमांड लाइन प्रोग्राम के ढेर को याद रखना होगा और झंडे आदि

मैं इस चलते रहने के लिए कोशिश की, लेकिन इस तरह के वर्तमान निर्देशिका

के लिए एक संदर्भ के रूप में के बारे में मैं कहाँ जानकारी प्राप्त करने दिया जाना चाहिए उलझन में हो रही समाप्त हो गया तो सवाल क्या रूबी पुस्तकालयों के कुछ हिस्सों की आवश्यकता है है रूबी शैल स्क्रिप्ट लिखने के लिए पता है?

Answer 1

डिफ़ॉल्ट रूप से, आपके पास पहले से ही Dir और File तक पहुंच है, जो स्वयं के द्वारा बहुत उपयोगी हैं। यह बहुत है, लेकिन लगता http://rush.heroku.com/

मैं उपयोग नहीं किया है:

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 

इसके अलावा stdlib से उपयोगी 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) 

जो काफी अच्छा है

Answer 2

"मैं रूबी कैसे लिखूं" एसओ के दायरे से थोड़ा सा है।

#!/path/to/ruby 

फिर फ़ाइल निष्पादन योग्य बनाने:

chmod a+x myscript.rb 

और दूर तुम जाओ

लेकिन निष्पादन स्क्रिप्ट में इन रूबी स्क्रिप्ट चालू करने के लिए, अपने गहरे लाल रंग का स्क्रिप्ट की पहली पंक्ति के रूप में इस डाल

।

Answer 3

मान लें कि आप अपना script.rb स्क्रिप्ट लिखते हैं। डाल:

#!/usr/bin/env ruby 

पहली पंक्ति के रूप और अपने script.rb की शुरुआत में एक chmod +x script.rb

Answer 4

प्लेस ऐसा करने

#!/usr/bin/env ruby 

तब निष्पादन योग्य के रूप में चिह्नित:

chmod +x script.rb 

Answer 5

जैसा कि अन्य ने पहले ही कहा है, आपकी पहली पंक्ति

होनी चाहिए

#!/usr/bin/env ruby 

और तुम भी यह निष्पादन योग्य बनाना है: (शेल में)

chmod +x test.rb 

फिर गहरे लाल रंग का कोड इस प्रकार है। आप एक फ़ाइल

File.open("file", "r") do |io| 
    # do something with io 
end 

फ़ाइल वर्तमान निर्देशिका में खोला है खोलते हैं आप खोल में pwd साथ मिल चाहते हैं।

आपकी लिपि का मार्ग भी आसान है। $0 के साथ आपको खोल का पहला तर्क मिलता है, जो आपकी स्क्रिप्ट के सापेक्ष पथ है। पूर्ण पथ इस तरह निर्धारित किया जा सकता है:

#!/usr/bin/env ruby 
require 'pathname' 
p Pathname.new($0).realpath() 

फ़ाइल सिस्टम संचालन के लिए मैं लगभग हमेशा पथनाम का उपयोग करता हूं। यह कई अन्य फाइल सिस्टम से संबंधित वर्गों के लिए एक रैपर है। भी उपयोगी: Dir, फ़ाइल ...

Answer 6

रूबी में, निरंतर __FILE__ आपको हमेशा उस स्क्रिप्ट का पथ देगा जो आप चल रहे हैं।

#! /usr/bin/env ruby 
# Extension of this script does not matter as long 
# as it is executable (chmod +x) 
puts File.expand_path(__FILE__) 

Windows पर यह निर्भर करता है या नहीं, .rb फ़ाइलों माणिक के साथ जुड़े रहे:

लिनक्स पर, /usr/bin/env अपने दोस्त है। अगर वे कर रहे हैं:

my_script.cmd:

@ruby %~dp0\my_script.rb 

my_script

# This script filename must end with .rb 
puts File.expand_path(__FILE__) 

वे नहीं हैं, तो आप स्पष्ट रूप से उन पर गहरे लाल रंग का आह्वान करने के लिए है, मैं एक मध्यवर्ती .cmd फ़ाइल का उपयोग .rb:

puts File.expand_path(__FILE__) 

Answer 7

जाओ अपने आप को Everyday Scripting with Ruby की एक प्रति प्राप्त । इसमें चीजों के प्रकारों को कैसे करना है, इस पर बहुत उपयोगी टिप्स हैं।

Answer 8

यह भी उपयोगी हो सकता है है बहुत अच्छा

साइट से:

भीड़ यूनिक्स खोल (बैश, zsh, आदि) के लिए एक प्रतिस्थापन है जो शुद्ध रूबी वाक्यविन्यास का उपयोग करता है। फ़ाइलों के माध्यम से ग्रेप, खोजने के लिए और प्रक्रियाओं को बंद, फ़ाइलों की प्रतिलिपि - सब कुछ आप रूबी में खोल में करते हैं, अब

Answer 9

यहाँ महत्वपूर्ण कुछ है कि अन्य उत्तर से लापता है: कमांड लाइन पैरामीटर आपकी रूबी खोल स्क्रिप्ट के संपर्क में हैं एआरजीवी (वैश्विक) सरणी के माध्यम से।

तो, आप एक स्क्रिप्ट कहा जाता my_shell_script था:

#!/usr/bin/env ruby 
puts "I was passed: " 
ARGV.each do |value| 
    puts value 
end 

...यह निष्पादन योग्य बनाने के (के रूप में दूसरों का उल्लेख किया है):

chmod u+x my_shell_script 

और यह इतनी तरह फोन:

I was passed: 
one 
two 
three 
four 
five 

तर्क फ़ाइल नाम विस्तार के साथ अच्छी तरह से काम करते हैं:

> ./my_shell_script one two three four five 

आप इस प्राप्त होता :

./my_shell_script * 

I was passed: 
a_file_in_the_current_directory 
another_file  
my_shell_script 
the_last_file 

इनमें से अधिकांश केवल यूनिक्स (लिनक्स, मैक ओएस एक्स) पर काम करता है, लेकिन आप विंडोज़ में समान (हालांकि कम सुविधाजनक) चीजें कर सकते हैं।

Answer 10

यहां बहुत अच्छी सलाह है, इसलिए मैं थोड़ा और जोड़ना चाहता था।

1. बैकिक्स (या बैक-टिक) आपको कुछ स्क्रिप्टिंग सामग्री को बहुत आसान बनाने देता है। पर विचार करें

   puts `find . | grep -i lib` 
   

2. आप बैकटिक के उत्पादन में हो रही के साथ समस्याएं आ रही हों, सामान मानक गलती करना बजाय मानक से बाहर जा रहा है।

   blah = 'lib' 
   `touch #{blah}` 
   

3. You can pipe inside Ruby, too: Use this advice

   out = `git status 2>&1` 
   

4. बैकटिक स्ट्रिंग प्रक्षेप है। यह मेरे ब्लॉग का एक लिंक है, लेकिन यह यहां वापस लिंक करता है, इसलिए यह ठीक है :) इस विषय पर शायद अधिक उन्नत चीजें हैं।

5. अन्य लोगों के रूप में बताया गया है, आप गंभीर प्राप्त करना चाहते हैं, अगर वहाँ रश है: न सिर्फ एक खोल प्रतिस्थापन लेकिन यह भी as a library for your use in shell scripts and programs.

---

(जो थोड़ा भी मेरे लिए बौड़म है) पर के रूप में मैक, अधिक शक्ति के लिए रूबी के अंदर एप्पलस्क्रिप्ट का उपयोग करें।

#!/usr/bin/env ruby 
`env | pbcopy` 
cmd = %Q@tell app "Terminal" to do script "$(paste_env)"@ 
puts cmd 

`osascript -e "${cmd}"` 

Answer 11

जवाब webmat से एकदम सही है: यहाँ मेरी shell_here स्क्रिप्ट है। मैं बस आपको एक जोड़ के लिए इंगित करना चाहता हूँ। यदि आपको अपनी स्क्रिप्ट के लिए कमांड लाइन पैरामीटर के साथ बहुत कुछ सौदा करना है, तो आपको optparse का उपयोग करना चाहिए। यह आसान है और आपको बहुत मदद करता है।

Answer 12

जब आप और अधिक जटिल रूबी स्क्रिप्ट लिखना चाहते हैं, इन उपकरणों की मदद कर सकते:

उदाहरण के लिए:

• thor (एक पटकथा ढांचा)

• gli (इंटरफ़ेस की तरह Git)

• methadone (सरल उपकरण बनाने के लिए)

वे आपको अपनी स्क्रिप्ट लिखने के लिए त्वरित शुरुआत देते हैं, खासकर 'कमांड लाइन ऐप'।

Answer 13

रूबी को शेल स्क्रिप्ट के रूप में उपयोग करते समय उपर्युक्त उत्तर दिलचस्प और बहुत उपयोगी है। मेरे लिए, मैं रुबी का उपयोग अपनी दैनिक भाषा के रूप में नहीं करता हूं और मैं रूबी को केवल प्रवाह नियंत्रण के रूप में उपयोग करना पसंद करता हूं और अभी भी कार्य करने के लिए बैश का उपयोग करता हूं।

कुछ सहायक समारोह परीक्षण निष्पादन परिणाम के लिए इस्तेमाल किया जा सकता

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

सहायक के साथ

, माणिक स्क्रिप्ट एक जैसे बैश हो सकता है:

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