Wenn's Schwierigkeiten gibt

Der Ruby-Debugger

ruby -r debug [options][programfile][arguments]

% ruby -rdebug t.rb
Debug.rb
Emacs support available.
t.rb:1:def fact(n)
(rdb:1) list 1-9
[1, 10] in t.rb
=> 1  def fact(n)
   2    if n <= 0
   3      1
   4    else
   5      n * fact(n-1)
   6    end
   7  end
   8
   9  p fact(5)
(rdb:1) b 2
Set breakpoint 1 at t.rb:2
(rdb:1) c
breakpoint 1, fact at t.rb:2
t.rb:2:  if n <= 0
(rdb:1) disp n
  1: n = 5
(rdb:1) del 1
(rdb:1) watch n==1
Set watchpoint 2
(rdb:1) c
watchpoint 2, fact at t.rb:fact
t.rb:1:def fact(n)
1: n = 1
(rdb:1) where
--> #1  t.rb:1:in `fact'
    #2  t.rb:5:in `fact'
    #3  t.rb:5:in `fact'
    #4  t.rb:5:in `fact'
    #5  t.rb:5:in `fact'
    #6  t.rb:9
(rdb:1) del 2
(rdb:1) c
120

Interaktives Ruby

irb [irb-options][ruby_script][options]

% irb
irb(main):001:0> a = 1 +
irb(main):002:0* 2 * 3 /
irb(main):003:0* 4 % 5
2
irb(main):004:0> 2+2
4
irb(main):005:0> def test
irb(main):006:1> puts "Hello, world!"
irb(main):007:1> end
nil
irb(main):008:0> test
Hello, world!
nil
irb(main):009:0> 

Editor Support

:w!ruby

Es klappt aber nicht!

• Der Attribut-Setter wird nicht aufgerufen. Innerhalb eines Objekts erkennt Ruby setter= als eine Zuweisung an eine lokale Variable, nicht als Methodenaufruf. Nimm stattdessen self.setter= für den Methoden-Aufruf.

• Ein Parse-Error in der letzten Zeile des Source-Codes weist oft auf ein fehlendes end hin.

• Vergewissere dich, dass der Typ des Objekts, das du benutzt, auch der ist, den du möchtest. Im Zweifelsfalle solltest du den Typ eines Objekts mit Object#type überprüfen.

• Vergewissere dich, dass deine Methoden mit einem Kleinbuchstaben anfangen und dass Klassen und Konstanten mit einem Großbuchstaben anfangen.

• Wenn du ein ``,'' in einer Argument-Liste vergisst --- besonders bei print ---, bekommst du einige sehr seltsame Fehlermeldungen.

• Parameter von Blöcken sind tatsächlich lokale Variablen. Wenn eine schon vorhandene lokale Variable denselben Namen hat, wenn der Block ausgeführt wird, wird diese Variable durch den Aufruf des Blocks geändert. Das kann erwünscht sein oder auch nicht.

• Achte auf die Rangfolge, besonders wenn du {} statt do/end benutzt.

• Vergewissere dich, dass die öffnende Klammer der Parameter einer Methode direkt nach dem Methodennamen kommt, da dürfen keine Leerzeichen dazwischen sein.

• Wenn der Output an ein Terminal geht, kann er gepuffert werden. Das heißt du siehst eine geschriebene Meldung nicht sofort. Wenn du dann auch noch Meldungen an sowohl $stdout als auch $stderr schreibst, kann der Output in einer anderen Reihenfolge auftauchen, als du erwartest. Benutze immer ungepuffertes I/O (setze sync=true) für Debug-Meldungen.

• Wenn Zahlen nicht richtig erscheinen, sind es vielleicht Strings. Text, der aus einer Datei gelesen wird, ist ein String und er wird nicht automatisch in eine Zahl konvertiert. Ein Aufrufg von to_i wirkt da Wunder. Ein üblicher Fehler von Perl-Programmierern ist

  while gets   num1, num2 = split /,/   # ... end

• Ungewolltes Aliasing --- wenn du ein Objekt als Schlüssel für einen Hash benutzt, vergewissere dich, dass es seine Hash-Wert nicht ändert (oder sorge für einen Hash#rehash-Aufruf, falls es das doch macht).

• Benutze trace_var, um Änderungen an Variablen zu überwachen.

• Benutze den Debugger.

• Benutze Object#freeze. Wenn du argwöhnst, dass irgendeine nicht so genau bekannte Stelle im Code deine Variable verändert, versuch die Variable einzufrieren. Der Bösewicht wird dann erwischt, wenn er versucht, deine Variable zu ändern.

Aber es ist zu langsam!

Erzeuge lokale Variablen außerhalb von Blöcken

require "benchmark"
include Benchmark
n = 1000000
bm(12) do |test|
  test.report("normal:")    do
    n.times do |x|
      y = x + 1
    end
  end
  test.report("predefine:") do
    x = y = 0
    n.times do |x|
      y = x + 1
    end
  end
end

                  user     system      total        real
normal:       2.510000   0.000000   2.510000 (  2.390549)
predefine:    2.220000   0.010000   2.230000 (  2.157877)

Benutze den Profiler

require "profile"
class Peter
  def initialize(amt)
    @value = amt
  end
  def rob(amt)
    @value -= amt
    amt
  end
end

class Paul
  def initialize
    @value = 0
  end
  def pay(amt)
    @value += amt
    amt
  end
end

peter = Peter.new(1000)
paul = Paul.new
1000.times do
  paul.pay(peter.rob(10))
end

 time   seconds   seconds    calls  ms/call  ms/call  name
 40.22     0.37      0.37        1   370.00   920.00  Fixnum#times
 25.00     0.60      0.23     1000     0.23     0.25  Paul#pay
 25.00     0.83      0.23     1000     0.23     0.30  Peter#rob
  7.61     0.90      0.07     1000     0.07     0.07  Fixnum#-
  2.17     0.92      0.02     1000     0.02     0.02  Fixnum#+
  0.00     0.92      0.00        1     0.00     0.00  Peter#initialize
  0.00     0.92      0.00        2     0.00     0.00  Class#inherited
  0.00     0.92      0.00        1     0.00     0.00  Paul#initialize
  0.00     0.92      0.00        4     0.00     0.00  Module#method_added
  0.00     0.92      0.00        2     0.00     0.00  Class#new
  0.00     0.92      0.00        1     0.00   920.00  #toplevel

Debugger-Kommandos b[reak] [file:]line Setze einen Breakpoint in der durch line angegebenen Zeile in Datei file (Default: aktuelle Datei). b[reak] [file:]name Setze einen Breakpoint auf Methode method in file. b[reak] Zeige die Breakpoints und Watchpoints (Überwachungspunkte) an. wat[ch] expr Break, wenn der Ausdruck true wird. del[ete] [nnn] Entferne Breakpoint nnn (Default: alle). disp[lay] expr Zeige den Inhalt von nnn an, jedesmal wenn der Debugger die Kontrolle übernimmt. disp[lay] Zeige die aktuellen Anzeigen. undisp[lay] [nnn] Entferne diese Anzeige (Default: alle). c[ont] Ausführung weiter laufen lassen. s[tep] nnn=1 Die nächsten nnn Zeilen ausführen, dabei in Methoden hineinspringen. n[ext] nnn=1 Die nächsten nnn Zeilen ausführen, dabei über Methoden hinwegspringen. fi[nish] Ausführung der aktuellen Funktion beenden. q[uit] Debugger verlasen. w[here] Aktuellen Stack anzeigen. f[rame] dasselbe wie where. l[ist] [start--end] Die Zeilen von start bis end des Quellcodes anzeigen. up nnn=1 nnn Ebenen im Stack hinaufgehen. down nnn=1 nnn Ebenen im Stack hinab gehen. v[ar] g[lobal] Globale Variablen anzeigen. v[ar] l[ocal] Lokale Variablen anzeigen. v[ar] i[stance] obj Instanz-Variablen von obj anzeigen. v[ar] c[onst] Name Konstanten einer Klasse oder Modul-Namen anzeigen. m[ethod] i[nstance] obj Instanz-Methoden von obj anzeigen. m[ethod] Name Instanz-Methoden der Klasse oder Modul-Namen anzeigen. th[read] l[ist] Alle Threads auflisten. th[read] [c[ur[rent]]] Status des aktuellen Threads anzeigen. th[read] [c[ur[rent]]] nnn Mache Thread nnn zum aktuellen Thread und halte ihn an. th[read] stop nnn Mach Thread nnn zum aktuellen Thread und halte ihn an. th[read] resume nnn Thread nnn wiederaufnehmennnn. [p] expr Berechne den Wert von expr im aktuellen Kontext. expr darf dabei Zuweisungen an Variablen und Methodenaufrufe enthalten. empty Ein null-Kommando wiederholt das letzte Kommando.