Ruby on Rails
डिबगिंग

डिबगिंग रेल आवेदन

डिबग करने में सक्षम होने के लिए किसी एप्लिकेशन के तर्क और डेटा के प्रवाह को समझना बहुत महत्वपूर्ण है। यह तार्किक बग को हल करने में मदद करता है और प्रोग्रामिंग अनुभव और कोड गुणवत्ता के लिए मूल्य जोड़ता है। डिबगिंग के लिए दो लोकप्रिय रत्न डीबगर (रूबी 1.9.2 और 1.9.3 के लिए) और बायबग (रूबी के लिए = = 2.50 ) हैं।

डिबगिंग .rb फ़ाइलों के लिए, इन चरणों का पालन करें:

1. जोड़े debugger या byebug के development के समूह Gemfile
2. भागो bundle install
3. byebug रूप में debugger या byebug जोड़ें
4. कोड चलाएँ या अनुरोध करें
5. निर्दिष्ट ब्रेकपॉइंट पर रुकी हुई रेल सर्वर लॉग देखें
6. इस बिंदु पर आप अपने सर्वर टर्मिनल को rails console तरह उपयोग कर सकते हैं और चर और पैरामेस के मूल्यों की जांच कर सकते हैं
7. अगले निर्देश में जाने के लिए, टाइप next और प्रेस enter
8. टाइप करने के लिए c टाइप करें और एन्टर प्रेस enter

यदि आप .html.erb फ़ाइलों को डीबग करना चाहते हैं, तो ब्रेक पॉइंट को <% debugger %> रूप में जोड़ा जाएगा

आपके IDE में डिबगिंग

हर अच्छी IDE रूबी (और इस प्रकार रेल्स) अनुप्रयोगों को अंतःक्रियात्मक रूप से डिबगिंग के लिए GUI प्रदान करती है, जहाँ आप अपवाद पर ब्रेकप्वाइंट, घड़ियाँ, ऑटो रोक सकते हैं और आपको कोड निष्पादन का भी चरण दर चरण, लाइन द्वारा पालन करने की अनुमति देता है।

उदाहरण के लिए, चित्र पर रूबीमाइन की डिबगिंग विशेषताओं में से एक पर एक नज़र डालें

रूबी को रेल पर जल्दी से डिबग करना + शुरुआती सलाह

अपवाद बढ़ाकर डिबगिंग print लॉग स्टेटमेंट्स के माध्यम से निचोड़ने की तुलना में बहुत आसान है, और अधिकांश बग्स के लिए, आमतौर पर pry या byebug जैसे irb डिबगर को खोलने की तुलना में बहुत तेज़ है। वे उपकरण आपका पहला कदम नहीं होना चाहिए।

रूबी / रेल को जल्दी से डिबग करना:

1. फास्ट विधि: तब एक Exception उठाएं और इसके परिणाम को .inspect

रूबी (विशेषकर रेल) कोड को डिबग करने का सबसे तेज़ तरीका कॉलिंग करते समय अपने कोड के निष्पादन पथ के साथ एक अपवाद को raise । विधि या ऑब्जेक्ट (जैसे foo ) पर .inspect :

raise foo.inspect

उपरोक्त कोड में, raise एक से चलाता है Exception है कि हाल्ट अपने कोड के निष्पादन, और रिटर्न एक त्रुटि संदेश है कि आसानी से शामिल .inspect वस्तु / विधि के बारे में जानकारी (यानी foo लाइन पर) है कि आप डिबग करने की कोशिश कर रहे हैं।

यह तकनीक किसी वस्तु या विधि ( जैसे कि यह nil ? ) की तुरंत जांच करने के लिए उपयोगी है और तुरंत इस बात की पुष्टि करने के लिए कि क्या कोड की एक पंक्ति भी दिए गए संदर्भ में बिल्कुल निष्पादित हो रही है।

2. निवर्तन: उपयोग की तरह एक गहरे लाल रंग का आईआरबी डिबगर byebug या pry

जब आप अपने कोड निष्पादन प्रवाह की स्थिति के बारे में जानकारी रखते हैं, तब ही आपको pry या byebug जैसे एक माणिक रत्न irb डिबगर पर जाने पर विचार करना चाहिए, जहाँ आप अपने निष्पादन पथ के भीतर वस्तुओं की स्थिति में अधिक गहराई तक जा सकते हैं।

byebug में डिबगिंग के लिए byebug मणि का उपयोग करने के लिए:

1. अपने Gemfile में विकास समूह के अंदर gem 'byebug' जोड़ें
2. भागो bundle install
3. फिर जिस कोड को आप byebug चाहते हैं, उसके निष्पादन मार्ग के अंदर वाक्यांश byebug डालें।

जब यह निष्पादित होता है तो यह byebug वैरिएबल आपके कोड का एक रूबी आईआरबी सत्र खोल देगा, जिससे आप वस्तुओं की स्थिति तक सीधे पहुंच प्राप्त कर लेंगे क्योंकि वे कोड के निष्पादन में उस बिंदु पर हैं।

बाईबग जैसे आईआरबी डिबगर आपके कोड की स्थिति का गहराई से विश्लेषण करने के लिए उपयोगी होते हैं क्योंकि यह निष्पादित होता है। हालांकि, वे त्रुटियों को बढ़ाने की तुलना में अधिक समय लेने वाली प्रक्रिया हैं, इसलिए ज्यादातर स्थितियों में उन्हें आपका पहला कदम नहीं होना चाहिए।

सामान्य शुरुआत की सलाह

जब आप किसी समस्या को डीबग करने का प्रयास कर रहे हैं, तो हमेशा के लिए अच्छी सलाह है: Read The! @ # $ Ing Error Message (RTFM)

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

1. त्रुटि संदर्भ किस वर्ग का है? (यानी मेरे पास सही ऑब्जेक्ट क्लास है या मेरी ऑब्जेक्ट nil ? )
2. त्रुटि संदर्भ किस विधि से आता है? (अर्थात विधि में उनका एक प्रकार है; क्या मैं इस प्रकार को वस्तु के वर्ग / वर्ग पर कह सकता हूं? )
3. अंत में, मैं अपने पिछले दो प्रश्नों से क्या अनुमान लगा सकता हूं, मुझे किस कोड की जांच करनी चाहिए? (याद रखें: स्टैक ट्रेस में कोड की अंतिम पंक्ति आवश्यक नहीं है कि समस्या कहाँ है।)

स्टैक ट्रेस में कोड की पंक्तियों पर विशेष ध्यान दें जो आपके प्रोजेक्ट से आती हैं (जैसे कि app/... साथ शुरू होने वाली लाइनें app/... यदि आप रेल का उपयोग कर रहे हैं)। समय का 99% समस्या आपके अपने कोड के साथ है।

यह बताने के लिए कि इस क्रम में व्याख्या करना क्यों महत्वपूर्ण है ...

उदा। एक रूबी त्रुटि संदेश जो कई शुरुआती को भ्रमित करता है:

आप कोड को निष्पादित करते हैं जो कुछ बिंदु पर इस तरह निष्पादित होता है:

@foo = Foo.new

...

@foo.bar

और आपको एक त्रुटि मिलती है जो बताता है:

undefined method "bar" for Nil:nilClass

शुरुआती लोग इस त्रुटि को देखते हैं और सोचते हैं कि समस्या bar विधि अपरिभाषित है । यह। इस त्रुटि में असली हिस्सा जो मायने रखता है:

for Nil:nilClass

for Nil:nilClass मतलब है कि @foo निल है! @foo एक Foo उदाहरण चर नहीं है! आपके पास एक वस्तु है जो Nil । जब आप इस त्रुटि को देखते हैं, तो यह आपको यह बताने की कोशिश कर रहा है कि क्लास Nil की वस्तुओं के लिए विधि bar मौजूद नहीं है। (अच्छी तरह से duh! क्योंकि हम एक विधि का उपयोग करने के लिए वर्ग Foo नहीं Nil कोशिश कर रहे हैं)।

दुर्भाग्य से, कैसे इस त्रुटि (लिखा है की वजह से undefined method "bar" for Nil:nilClass ) अपनी आसान धोखा नहीं खाना में इस त्रुटि सोच के साथ क्या करना है bar की जा रही undefined । जब ध्यान से नहीं पढ़ा जाता है तो इस त्रुटि के कारण शुरुआती लोग गलती से Foo पर bar विधि के विवरण में खुदाई कर जाते हैं, पूरी तरह से त्रुटि का वह हिस्सा गायब हो जाता है जो संकेत देता है कि वस्तु गलत वर्ग की है (इस मामले में: nil)। यह एक गलती है जो आसानी से त्रुटि संदेशों को उनकी संपूर्णता में पढ़ने से बचती है।

सारांश:

किसी भी डीबगिंग की शुरुआत करने से पहले पूरी त्रुटि संदेश को हमेशा ध्यान से पढ़ें । इसका मतलब है कि: हमेशा एक वस्तु के वर्ग प्रकार एक त्रुटि संदेश में अपने तरीकों की जांच पहले, फिर, इससे पहले कि आप किसी भी स्टैकट्रेस या कोड का लाइन में sleuthing जहां आपको लगता है त्रुटि होने वाली हो सकती है शुरू करते हैं। वे 5 सेकंड आपको 5 घंटे की निराशा से बचा सकते हैं।

tl; dr: प्रिंट लॉग में स्क्विंट न करें: इसके बजाय अपवाद बढ़ाएं। डिबगिंग से पहले त्रुटियों को ध्यान से पढ़कर खरगोश के छेद से बचें।

माणिक के साथ रूबी-ऑन-रेल आवेदन डीबग करना

प्राइ एक शक्तिशाली उपकरण है जिसका उपयोग किसी भी रूबी अनुप्रयोग को डीबग करने के लिए किया जा सकता है। इस मणि के साथ एक रूबी-ऑन-रेल आवेदन स्थापित करना बहुत आसान और सीधा है।

सेट अप

अपने आवेदन को pry के साथ डिबग करना शुरू करने के लिए

• आवेदन के Gemfile gem 'pry' जोड़ें और इसे बंडल करें

group :development, :test do
  gem 'pry'
end

• टर्मिनल कंसोल पर एप्लिकेशन की रूट निर्देशिका पर नेविगेट करें और bundle install चलाएं। आप अपने एप्लिकेशन पर कहीं भी इसका उपयोग शुरू करने के लिए पूरी तरह तैयार हैं।

उपयोग

अपने आवेदन में pry का उपयोग करना, बस उस binding.pry को शामिल binding.pry , जिसे डीबगिंग करते समय आप निरीक्षण करना चाहते हैं। आप अपने एप्लिकेशन में कहीं भी binding.pry ब्रेकप्वाइंट जोड़ सकते हैं जो रूबी दुभाषिया (किसी भी ऐप / कंट्रोलर, ऐप / मॉडल, ऐप / व्यू फाइल) द्वारा व्याख्या की गई है

i) एक नियंत्रक डिबगिंग

एप्लिकेशन / नियंत्रक / users_controller.rb

class UsersController < ApplicationController
  def show
    use_id = params[:id]
    // breakpoint to inspect if the action is receiving param as expected
    binding.pry
    @user = User.find(user_id)
    respond_to do |format|
      format.html
    end
  end
end

इस उदाहरण में, रेल सर्वर ब्रेक-पॉइंट पर एक UsersController कंसोल के साथ रुकता है जब आप UsersController पर कार्रवाई show लिए एक पेज रूटिंग पर जाने की UsersController । आप निरीक्षण कर सकते हैं params वस्तु और पर ActiveRecord क्वेरी बनाने के User कि ब्रेकप्वाइंट से मॉडल

ii) किसी दृश्य को डीबग करना

एप्लिकेशन / विचारों / उपयोगकर्ताओं / show.html.haml

%table
  %tbody
    %tr
      %td ID
      %td= @user.id
    %tr
      %td email
      %td= @user.email
    %tr
      %td logged in ?          
      %td
        - binding.pry
        - if @user.logged_in?
          %p= "Logged in"
        - else
          %p= "Logged out"

इस उदाहरण में, जब users/show पेज रेल सर्वर में वापस भेजने से पहले क्लाइंट के ब्राउज़र में वापस भेज दिया जाता है, तो प्राइ-कंसोल के साथ ब्रेक-पॉइंट रुक जाता है। यह ब्रेक-पॉइंट @user.logged_in? की शुद्धता को डीबग करने की अनुमति देता है @user.logged_in? जब यह दुर्व्यवहार कर रहा है।

ii) एक मॉडल डिबगिंग

app/models/user.rb

class User < ActiveRecord::Base    
  def full_name
    binding.pry
    "#{self.first_name} #{self.last_name}"
  end      
end

इस उदाहरण में, ब्रेक-पॉइंट का उपयोग User मॉडल की आवृत्ति विधि को full_name करने के लिए किया जा सकता है जब इस पद्धति को एप्लिकेशन में कहीं से भी कॉल किया जाता है।

अंत में, आसान पटरियों और सीधी डिबगिंग गाइडलाइन के साथ रेल आवेदन के लिए एक शक्तिशाली डिबगिंग उपकरण है। यह एक कोशिश दे।