Skopiowałem następujący kod Ruby z Internetu i wprowadziłem kilka zmian, ale to nie działa.

Co mogę zrobić, aby samodzielnie debugować program?

Użyj Pry ( GitHub ).

Zainstaluj przez:

$ gem install pry
$ pry

Następnie dodaj:

require 'pry'; binding.pry

do swojego programu.

Począwszy od pry0.12.2 jednak nie ma poleceń, takich jak nawigacja next, breakitp Niektóre inne perełki dodatkowo zapewnić to, patrz na przykład pry-byedebug.

1. W Rubim:

   ruby -rdebug myscript.rb 

   następnie,

   • b <line>: wstaw punkt przerwania
   • i n(ext)lub s(tep)ic(ontinue)
   • p(uts) do wyświetlenia

   (jak debugowanie Perla)

2. W Railsach: uruchom serwer z

   script/server --debugger

   i dodaj debuggerkod.

Zgodnie z zaleceniami: użyj podważenia! Mogę się tylko co do tego zgodzić.

pry jest znacznie lepszą odpowiedzią niż irb.

Musisz dodać

require 'pry'

do pliku źródłowego, a następnie wstaw punkt przerwania w kodzie źródłowym, dodając

binding.pry

w miejscu, w którym chcesz się przyjrzeć rzeczom (to jest jak wyzwalanie punktu przerwania w klasycznym środowisku IDE)

Gdy Twój program trafi do

binding.pry

linii, zostaniesz wrzucony prosto do podważonej odpowiedzi, z całym kontekstem twojego programu pod ręką, dzięki czemu możesz po prostu eksplorować wszystko dookoła, badać wszystkie obiekty, zmieniać stan, a nawet zmieniać kod w locie.

Uważam, że nie możesz zmienić kodu metody, w której się obecnie znajdujesz, więc nie możesz niestety zmienić kolejnej linii do wykonania. Ale dobry kod ruby ​​i tak ma tendencję do składania się z jednej linii ;-)

Debugowanie przez wywołanie wyjątków jest znacznie łatwiejsze niż mrużenie oka przezprintinstrukcje dziennika, a w przypadku większości błędów jest zwykle znacznie szybsze niż otwieranie debugera irb, takiego jakprylubbyebug. Te narzędzia nie zawsze powinny być pierwszym krokiem.

Szybkie debugowanie Ruby / Rails:

1. Szybka metoda: Podnieś Exceptionto i .inspectjego wynik

Najszybsza droga do debugowania Ruby (zwłaszcza Rails) kod jest raisewyjątek wzdłuż ścieżki wykonanie kodu podczas wywoływania .inspectna metody lub obiektu (np foo):

raise foo.inspect

W powyższym kodzie, raisewyzwala Exceptionże wstrzymuje wykonanie kodu , i zwraca komunikat o błędzie, który dogodnie zawiera .inspectinformacje na temat obiektu / metody (tj foo) w wierszu, który próbujesz do debugowania.

Technika ta jest przydatna do szybkiego zbadania obiektu lub metody ( np. Czy to jest nil? ) I do natychmiastowego potwierdzenia, czy wiersz kodu jest w ogóle wykonywany w danym kontekście.

2. Zastępstwo: użyj debuggera Ruby IRB, takiego jak byebuglubpry

Dopiero po uzyskaniu informacji o stanie przepływu wykonywania kodu należy rozważyć przejście do debugera ruby ​​gem irb, takiego jak prylub w byebugktórym można głębiej zagłębić się w stan obiektów na ścieżce wykonywania.

Ogólne porady dla początkujących

Kiedy próbujesz debugować problem, dobrą radą jest zawsze: Przeczytaj! @ # $ Ing Komunikat o błędzie (RTFM)

Oznacza to, że czytanie komunikatów o błędach dokładnie i całkowicie przed podjęciem działań, tak aby zrozumieć, co próbuje powiedzieć. Podczas debugowania podczas odczytywania komunikatu o błędzie zadaj następujące pytania mentalne w podanej kolejności :

1. Do jakiej klasy odnosi się błąd? (tj. czy mam poprawną klasę obiektu, czy jest to mój obiekt nil? )
2. Do jakiej metody odnosi się błąd? (tj. jest ich typem w metodzie; czy mogę wywołać tę metodę dla tego typu / klasy obiektu? )
3. Na koniec, korzystając z tego, co mogę wywnioskować z moich dwóch ostatnich pytań, jakie wiersze kodu powinienem zbadać? (pamiętaj: ostatnia linijka kodu w śladzie stosu niekoniecznie oznacza problem).

W śladzie stosu zwróć szczególną uwagę na linie kodu pochodzące z twojego projektu (np. Linie zaczynające się od, app/...jeśli używasz Railsów). W 99% przypadków problem dotyczy Twojego własnego kodu.

Aby zilustrować, dlaczego tłumaczenie w tej kolejności jest ważne ...

Np. Komunikat o błędzie Ruby, który dezorientuje wielu początkujących:

Wykonujesz kod, który w pewnym momencie jest wykonywany jako taki:

@foo = Foo.new

...

@foo.bar

i otrzymujesz błąd, który mówi:

undefined method "bar" for Nil:nilClass

Początkujący widzą ten błąd i myślą, że problem polega na tym, że metoda barjest niezdefiniowana . To nie jest. W tym błędzie najważniejsza część to:

for Nil:nilClass

for Nil:nilClassoznacza, że @foojest zero! @foonie jest Foozmienną instancji! Masz przedmiot, który jest Nil. Kiedy widzisz ten błąd, to po prostu ruby ​​próbuje ci powiedzieć, że metoda barnie istnieje dla obiektów tej klasy Nil. (no cóż! ponieważ próbujemy użyć metody dla obiektu klasy Foonie Nil).

Niestety, ze względu na sposób zapisu tego błędu ( undefined method "bar" for Nil:nilClass) łatwo jest dać się zwieść myśleniu, że ten błąd ma związek z barbytem undefined. Jeśli nie przeczytasz uważnie, ten błąd powoduje, że początkujący omyłkowo zagłębiają się w szczegóły barmetody Foo, całkowicie pomijając część błędu, która wskazuje, że obiekt jest niewłaściwej klasy (w tym przypadku: zero). To błąd, którego łatwo uniknąć, czytając w całości komunikaty o błędach.

Podsumowanie:

Zawsze uważnie przeczytaj cały komunikat o błędzie przed rozpoczęciem debugowania. Oznacza to: Zawsze najpierw sprawdź typ klasy obiektu w komunikacie o błędzie , a następnie jego metody , zanim zaczniesz szukać śladu stosu lub wiersza kodu, w którym uważasz, że może wystąpić błąd. Te 5 sekund może zaoszczędzić 5 godzin frustracji.

tl; dr: Nie mruż oczy na wydruki logów: zgłaszaj wyjątki lub używaj debuggera irb. Unikaj króliczych nory, uważnie czytając błędy przed debugowaniem.

1. Wydrukuj zmienne, jeśli to możliwe. (Nazywa się to debugowaniem printf) Możesz to zrobić uruchamiając

   STDERR.puts x.inspect

   lub

   STDERR.puts "Variable x is #{x.inspect}"

   Jeśli chcesz, aby było to łatwiejsze do wpisania , możesz użyć klejnotu wzorcowego .

2. Włącz ostrzeżenia. Jeśli używasz, rubyuruchom go za pomocą -wprzełącznika (np ruby -w script.rb.). Jeśli uruchamiasz go z irb i używasz wersji Ruby wcześniejszej niż 1.9.2, wpisz $VERBOSE = truena początku sesji. Jeśli pomylisz się w zmiennej instancji, po pojawieniu się ostrzeżeń otrzymasz

   ostrzeżenie: zmienna instancji @valeusnie została zainicjowana

3. Zrozum pojęcie binarnego cięcia (poniższy cytat pochodzi z Practices of an Agile Developer )

   Podziel obszar problemu na pół i zobacz, która połowa zawiera problem. Następnie ponownie podziel tę połowę na pół i powtórz.

4. Jeśli odniesiesz sukces w przypadku binarnego cięcia, może się okazać, że jest jedna linia, która nie robi tego, czego oczekujesz. Na przykład

   [1, 2, 3].include?([1,2])

   daje wartość false, nawet jeśli można by pomyśleć, że zwróci true. W takim przypadku możesz zajrzeć do dokumentacji. Witryny internetowe zawierające dokumentację obejmują ruby-doc.org lub APIdock . W tym drugim przypadku piszesz include?obok lupy w prawym górnym rogu i wybierz to, include?co ma Arraypod nią (jeśli nie wiesz, jaką klasę[1, 2, 3] jest , wpisz [1, 2, 3].classirb), a otrzymasz ? (Array) , który opisuje, co robi.

   Jeśli jednak dokumentacja nie pomoże, bardziej prawdopodobne jest, że uzyskasz dobrą odpowiedź, jeśli możesz zadać pytanie, w jaki sposób konkretna linia nie robi tego, co powinna, zamiast dlaczego cały skrypt nie robi tego, co powinno.

usuwa wszystkie rzeczy

Witamy w 2017 ^ _ ^

Okay, więc jeśli nie jesteś przeciwny wypróbowaniu nowego IDE, możesz wykonać następujące czynności za darmo .

Szybkie instrukcje

1. Zainstaluj vscode
2. Zainstaluj Ruby Dev Kit, jeśli jeszcze tego nie zrobiłeś
3. Zainstaluj rozszerzenia Ruby, ruby-linter i ruby-rubocop dla vscode
4. Zainstaluj ręcznie wszystkie klejnoty określone przez rubyide / vscode-ruby razie potrzeby
5. Skonfigurować launch.jsondo korzystania "cwd"i i "program" pola za pomocą{workspaceRoot} makra
6. Dodaj pole o nazwie "showDebuggerOutput"i ustaw je natrue
7. Włącz punkty przerwania wszędzie w preferencjach debugowania jako "debug.allowBreakpointsEverywhere": true

Szczegółowe instrukcje

1. Pobierz Visual Studio Code aka vscode; to nie to samo, co Visual Studio . Jest darmowy, lekki i ogólnie pozytywnie oceniany.
2. Zainstaluj zestaw deweloperski Ruby; powinieneś postępować zgodnie z instrukcjami w ich repozytorium tutaj: https://github.com/oneclick/rubyinstaller/wiki/Development-Kit
3. Następnie możesz zainstalować rozszerzenia za pomocą przeglądarki internetowej lub wewnątrz IDE; to jest dla wewnątrz IDE. Jeśli wybierzesz drugą opcję, możesz przejść tutaj . Przejdź do części vscode Extensions; możesz to zrobić na kilka sposobów, ale najbardziej przyszłościową metodą będzie prawdopodobnie uderzanie F1i wpisywanie, extdopóki nie stanie się dostępna opcja o nazwie Rozszerzenia: Zainstaluj rozszerzenia . Alternatywami są CtrlShiftxiz górnego paska menu,View->Extensions
4. Następnie będziesz potrzebować następujących rozszerzeń; nie są one w 100% konieczne, ale pozwolę ci zdecydować, co zachować po tym, jak trochę majstrujesz:
   • Rubin; autor rozszerzenia Peng Lv
   • rubin-rubocop; autor rozszerzenia misogi
   • rubinowa linter; autor rozszerzenia Cody Hoover
5. W katalogu twojego skryptu ruby ​​utworzymy katalog za pomocą wiersza poleceń o nazwie, .vscodea tam będziemy tylko plik o nazwie, w launch.jsonktórym będziemy przechowywać kilka opcji konfiguracyjnych.
   • launch.json zawartość

{ "version": "0.2.0", "configurations": [ { "name": "Debug Local File", "type":"Ruby", "request": "launch", "cwd": "${workspaceRoot}", "program": "{workspaceRoot}/../script_name.rb", "args": [], "showDebuggerOutput": true } ] }

6. Postępuj zgodnie z instrukcjami autorów rozszerzenia dotyczące ręcznej instalacji klejnotów. Na razie znajduje się tutaj: https://github.com/rubyide/vscode-ruby#install-ruby-dependencies
7. Prawdopodobnie będziesz chciał mieć możliwość umieszczania punktów przerwania w dowolnym miejscu; brak włączonej tej opcji może powodować zamieszanie. Aby to zrobić, przejdziemy do górnego paska menu i wybierzemy File->Preferences->Settings(lub Ctrl,) i przewiniemy, aż dojdziesz do Debugsekcji. Rozwiń go i poszukaj pola o nazwie "debug.allowBreakpointsEverywhere"- wybierz to pole, kliknij małą ikonę przypominającą ołówek i ustaw na true.

Po wykonaniu wszystkich tych zabawnych rzeczy powinieneś być w stanie ustawić punkty przerwania i debugować w menu podobnym do tego w połowie 2017 r. I ciemniejszym motywie: ze wszystkimi zabawnymi rzeczami, takimi jak stos wywołań, przeglądarka zmiennych itp.

Największe PITA to 1) zainstalowanie wymagań wstępnych i 2) Pamiętanie o skonfigurowaniu .vscode\launch.jsonpliku. Tylko # 2 powinien dodać bagaż do przyszłych projektów i możesz po prostu skopiować wystarczająco ogólną konfigurację, taką jak wymieniona powyżej. Prawdopodobnie jest bardziej ogólna lokalizacja konfiguracji, ale nie wiem od początku mojej głowy.

Gorąco polecam ten film, aby w tej chwili wybrać odpowiednie narzędzie do debugowania naszego kodu.

https://www.youtube.com/watch?v=GwgF8GcynV0

Osobiście przedstawiłbym dwa duże tematy w tym filmie.

• Pry jest świetny do debugowania danych, „pry is a data explorer” (sic)
• Wydaje się, że debuger jest lepszy do debugowania krok po kroku.

To moje dwa centy!

Wszystkie inne odpowiedzi dają już prawie wszystko ... Tylko mały dodatek.

Jeśli potrzebujesz więcej debuggera podobnego do IDE (nie-CLI) i nie boisz się używać Vima jako edytora, sugeruję wtyczkę Vim Ruby Debugger .

Jego dokumentacja jest dość prosta, więc kliknij link i zobacz. Krótko mówiąc, pozwala ustawić punkt przerwania w bieżącej linii w edytorze, przeglądać zmienne lokalne w sprytnym oknie podczas pauzy, przechodzić / przechodzić do - prawie wszystkie zwykłe funkcje debuggera.

Dla mnie używanie tego debuggera vim do debugowania aplikacji Railsów było całkiem przyjemne, chociaż bogate możliwości rejestratora Railsów prawie eliminują jego potrzebę.

Właśnie odkryłem ten klejnot (zmienia Pry w debugger dla MRI Ruby 2.0+)

https://github.com/deivid-rodriguez/pry-byebug

Zainstaluj za pomocą:

gem install pry-byebug

następnie użyj dokładnie tak pry, jak zaznacz linię, w której chcesz przerwać:

require 'pry'; binding.pry

W przeciwieństwie wanilia pry jednak ten klejnot ma kilka kluczowych GDB-jak nawigacja poleceń takich jak next, stepi break:

break SomeClass#run            # Break at the start of `SomeClass#run`.
break Foo#bar if baz?          # Break at `Foo#bar` only if `baz?`.
break app/models/user.rb:15    # Break at line 15 in user.rb.
break 14                       # Break at line 14 in the current file.

1. Możesz wydrukować swoje zmienne po drodze
2. Włącz -w flagę (ostrzeżenia)
3. Użyj narzędzia takiego jak ruby-debug

Aby łatwo debugować skrypt powłoki Ruby, po prostu zmień jego pierwszą linię z:

#!/usr/bin/env ruby

do:

#!/usr/bin/env ruby -rdebug

Następnie za każdym razem, gdy zostanie wyświetlona konsola debugera, możesz wybrać:

• cdla Kontynuuj (do następnego wyjątku, punktu przerwania lub linii z:) debugger,
• n dla następnej linii,
• w/ wheredo wyświetlania ramki / stosu wywołań,
• l aby pokazać aktualny kod,
• cat aby pokazać punkty zaczepienia.
• h aby uzyskać dodatkową pomoc.

Zobacz też: Debugowanie za pomocą ruby-debug , Skróty klawiszowe dla ruby-debug gem .

W przypadku, gdy skrypt po prostu się zawiesił i potrzebujesz śledzenia wstecznego, spróbuj użyć lldb/ gdblike:

echo 'call (void)rb_backtrace()' | lldb -p $(pgrep -nf ruby)

a następnie sprawdź pierwszy plan procesu.

Wymień lldbsię gdbjeśli działa lepiej. Prefiks z, sudoaby debugować proces nienależący do firmy.

Od wersji 2.4.0 Rubiego łatwiej jest rozpocząć sesję IRB REPL w środku dowolnego programu Ruby. Umieść te wiersze w punkcie programu, który chcesz debugować:

require 'irb'
binding.irb

Możesz uruchomić kod Ruby i wydrukować zmienne lokalne. Naciśnij Ctrl + D lub, quitaby zakończyć REPL i pozwolić programowi Ruby działać dalej.

Możesz także użyć putsi, paby wydrukować wartości z programu w trakcie jego działania.

Jeśli używasz RubyMine , debugowanie skryptów Ruby jest proste i nieskomplikowane.

Załóżmy, że masz skrypt Ruby hello_world.rb

1. Ustaw punkty przerwania

Ustaw punkt przerwania w linii 6, jak poniżej.

2. Rozpocznij debugowanie

Teraz możesz po prostu uruchomić debuger, aby uruchomić skrypt:

3. Sprawdź zmienne itp.

Następnie, gdy wykonanie osiągnie punkt przerwania, będziesz mógł sprawdzić zmienne itp.

Dalsze informacje w celach informacyjnych

1. Jeśli chcesz używać RubyMine do zdalnego debugowania , możesz to zrobić.
2. Jeśli chciałbyś używać RubyMine do zdalnego debugowania szyn działających w dokerze , jest to również proste.

debugowanie printf

Zawsze istniały kontrowersje wokół technik debugowania, niektórzy ludzie lubią debugować za pomocą instrukcji print, inni lubią kopać głęboko za pomocą debugera.

Sugerowałbym wypróbowanie obu podejść.

Właściwie jeden ze starych ludzi od Uniksa powiedział niedawno, że debugowanie printf było w niektórych przypadkach szybszym sposobem.

Ale jeśli jesteś nowy w jakiejś pracy i musisz zrozumieć dużą porcję kodu, to naprawdę przydatne jest przejście przez to, umieszczanie punktów przerwania tu i tam, i śledzenie, jak to działa.

Powinien dać ci trochę zrozumienia, jak tkany jest kod.

Jeśli jesteś nowy w oprogramowaniu innych ludzi, może ci to pomóc.

Szybko dowiesz się, czy sprytnie to ułożyli, czy to tylko kupa gówna.

Cóż, biblioteka Ruby standard ma łatwy w użyciu debugger konsoli podobny do gdb: http://ruby-doc.org/stdlib-2.1.0/libdoc/debug/rdoc/DEBUGGER__.html Nie ma potrzeby instalowania żadnych dodatkowych klejnotów. W ten sposób można również debugować skrypty Railsowe.

na przykład

def say(word)
  require 'debug'
  puts word
end

Matką wszystkich debuggerów jest zwykły stary ekran wydruku. W większości przypadków prawdopodobnie chcesz sprawdzić tylko niektóre proste obiekty, szybki i łatwy sposób jest następujący:

@result = fetch_result

p "--------------------------"
p @result

Spowoduje to wydrukowanie zawartości @result na STDOUT z linią z przodu w celu łatwej identyfikacji.

Bonus, jeśli korzystasz z platformy obsługującej automatyczne ładowanie / ponowne ładowanie, takiej jak Rails, nie musisz nawet ponownie uruchamiać aplikacji. (O ile kod, który debugujesz, nie zostanie ponownie załadowany z powodu ustawień specyficznych dla platformy)

Uważam, że działa to dla mnie w 90% przypadków użycia. Możesz także użyć ruby-debug, ale uważam, że przez większość czasu jest to przesada.

Istnieje wiele debuggerów z różnymi funkcjami, na podstawie których dokonujesz wyboru. Moje priorytety były zadowalające z ruchami podważającymi, które były:

• szybko zrozumiałe informacje, jak używać
• intuicyjne kroki (jak łatwe wchodzenie w bloki)
• „cofanie się” (ruchy podważania częściowo zaspokajają potrzebę)