def a
  __method__
end

p __method__ #=> nil
p a #=> :a

`echo hello` #=> "hello\n"
$?.exitstatus #=> 0

Array(1..5) #=> [1, 2, 3, 4, 5]

Complex(3, 9) #=> (3+9i)

Float(1) #=> 1.0
Float("123.456") #=> 123.456
Float(nil) #=> TypeError

Integer(123.999) #=> 123
Integer("0x1A") #=> 26
Integer(Time.new) #=> 1204973019
"A".to_i #=> 0
Integer("A") #=> ArgumentError

Rational(3, 2) #=> (3/2)
Rational(4, 7) #=> (4/7)
Rational(50, 100) #=> (1/2)

String(self) #=> "main"
String(self.class) #=> "Object"
String(123456) #=> "123456"

#Encoding: Windows-1252
puts "A"
abort("Ende im Gelände")
puts "B"

A
Ende im Gelände

def do_at_exit(str1)
  at_exit { print str1 }
end

at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit

goodbye cruel world

autoload(:EinModul, "ein_modul")
class A

  def initialize
    p defined? EinModul
  end

  def load_module
    EinModul
    p defined? EinModul
  end

end

x = A.new
x.load_module

Test.rb:9: warning: useless use of a constant in void context
nil
"constant"

p autoload? :EinModul #=> nil
autoload(:EinModul, "ein_modul")
p autoload? :EinModul #=> "ein_modul"

def get_binding(x)
  binding
end

b = get_binding("Hello!")
eval("x", b) #=> Hello!

def execute_block
  if block_given?
    yield
  else
    puts "No block given!"
  end
end

execute_block #=> No block given!
execute_block{puts "Hello world!"} #=> Hello world!
execute_block do
  puts "Hello world!"
end #=> Hello world!

def a(skip)
  caller(skip)
end

def b(skip)
  a(skip)
end

def c(skip)
  b(skip)
end

c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10"]
c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
c(2)   #=> ["prog:8:in `c'", "prog:12"]
c(3)   #=> ["prog:13"]

def routine(n)
  puts n
  throw :done if n <= 0
  routine(n-1)
end

catch(:done) { routine(3) }

3
2
1
0

code = 'puts "Hello!"'
eval(code) #=> Hello!

def scope
  x = 1
  return binding
end

code = "puts x"
eval(code) #=> NameError
eval(code, scope) #=> 1

invalid_code = "puts(1"
eval(invalid_code)
#=> Test.rb:3:in `eval': (eval):1: syntax error, unexpected $end, expecting ')' (SyntaxError)
eval(invalid_code, binding, "Absichtlich falscher Code")
#=> Test.rb:3:in `eval': Absichtlich falscher Code:1: syntax error, unexpected $end, expecting ')' (SyntaxError)
#binding musste übergeben werden, damit der letzte Parameter auch übergeben werden konnte. 
eval(invalid_code, binding, "Absichtlich falscher Code", 10)
#=> Test.rb:3:in `eval': Absichtlich falscher Code:10: syntax error, unexpected $end, expecting ')' (SyntaxError)

exec("echo *") #Listet alle Dateien im aktuellen Verzeichnis
puts("Das hier wird nicht ausgeführt.")

exec("echo", "*") #Gibt ein Sternchen aus
puts("Das hier wird nicht ausgeführt.")

puts "Vor exit"
exit
puts "Nach exit"

Vor exit

begin
  exit
  puts "Das wird nicht ausgeführt."
rescue SystemExit
  puts "SystemExit abgefangen. "
end
puts "Nach dem begin/rescue-Block. "

SystemExit abgefangen. 
Nach dem begin/rescue-Block.

END{puts "END"}
at_exit{puts "at_exit"}
exit!

fork{sleep(20)}

gem("rubylexer", "<0.7")
require "rubylexer"

print "Geben Sie Ihren Namen ein: "
name = gets.chomp
puts "Ihr Name ist #{name.length} Zeichen lang. "

ARGV << "testfile"
print while gets

This is line one
This is line two
This is line three
And so on...

puts global_variables.collect{|sym| sym.to_s}.sort

$!
$"
$$
$&
...

hello = lambda{puts "Hello world"}
hello.call #=> Hello word

def foo(pr)
  pr.call
end
x = 10
pr = lambda{puts x}
foo(pr) #=> 10

x = lambda{|val| puts val}
y = proc{|val| puts val}
x.call #=> ArgumentError
y.call #=>

#Load.rb
XY = 8
puts "Hello"

#Main.rb
load("Load.rb", true) #=> Hello!
puts XY #=> NameError
load("Load.rb") #=> Hello!
puts XY #=> 8

def lvars(var)
  x = 1
  p local_variables
end
y = :ruby
p local_variables
lvars(Math::PI)

[:y]
[:var, :x]

loop do
  print "Eingabe>"
  break if gets =~ /^q/i
end

class Roman

  def roman_to_int
    #Code...
  end
  
  def method_missing(name, *args, &block)
    super if !args.empty? or block
    roman_to_int(name.to_s)
  end
  
end

r = Roman.new
r.iv #=> 4
r.xxiii #=> 23
r.mm #=> 2000

class MyDelegator
  
  def initialize(an_object)
    @object = an_object
  end
  
  def method_missing(name, *args, &block)
    @object.send(name, *args, &block)
  end
  
end

d = MyDelegator.new(10)
puts(d / 2) #=> 5

file = open("Test.txt", "w")
file.write("Test")
file.close
open("Test.txt"){|f| puts f.read} #=> Test

cmd = open("|date")
puts cmd.gets #=> Do 2. Jul 10:47:52 CEST 2009
cmd.close

p "a" #=> "a"
p Hash[1, 2, 3, 4] #=> {1=>2, 3=>4}
#Um den Unterschied zu puts zu verdeutlichen: 
puts nil #=>
p nil #=> nil

print "Eingabe >"
gets
$\ = "--"
$, = "|"
print 1, 2 #=> 1|2--

$stdout.write(sprintf(format_string, *obj))

printf("Eine Zahl: %i", 5) #=> Eine Zahl: 5

proc{|a| p a}.call #=> nil
lambda{|a| p a}.call #=> ArgumentError

putc("ABC") #=> A
putc(65) #=> A
putc(131.0/2.0) #=> A

puts "a"
puts 7
puts("A", "B")

a
7
A
B

raise "A" #=> RuntimeError: A
raise(ArgumentError, "B") #=> ArgumentError: B

def a
  raise("Error in A")
end

def b
  a
end

def c
  b
end

c #=> Test.rb:5:in `a': Error in A (RuntimeError)
#        from Test.rb:9:in `b'
#        from Test.rb:13:in `c'
#        from Test.rb:16:in `<main>'

def a
  raise(RuntimeError, "Error in a!", caller)
end

c #=> Test.rb:9:in `b': Error in a! (RuntimeError)
#        from Test.rb:13:in `c'
#        from Test.rb:25:in `<main>'

rand #=> 0.663831935617695
rand #=> 0.665359685021351
rand(10) #=> 7

#Eingabe: ABC
puts readline #=> ABC
#Eingabe: ^d
puts readline #=> EOFError
puts gets #=> nil

#Eingabe ist die Datei Test.txt
puts readlines #=> ["ABC\n", "DEF\n"]

require "timeout" #Impliziert .rb
require "win32/api" #Impliziert .so (auf MinGW)

require_relative "../lib/my_module/backend"

#Beispiel folgt!

set_trace_func lambda{|event, filename, lineno, object_id, bind, classname| p object_id}
x = 0
x += 1
puts x

:set_trace_func
nil
nil
nil
:puts
:puts
:to_s
:to_s
:write
1:write
:write

:write
:puts
:puts

sleep(3)

ts = []
puts Time.now
10.times{ts.push(Thread.new{puts(sleep(1.9))})}
ts.each{|thread| thread.join}
puts Time.now

2009-07-21 12:50:06 +0200
1
1
1
1
1
1
1
1
1
1
2009-07-21 12:50:07 +0200

spawn({"MEINE_VAR" => "Toll!"}, "sleep 5;echo $MEINE_VAR")
puts "Hauptprogramm"
sleep 6

Hauptprogramm
Toll!

#Beispiel folgt!

srand(1020304050)
puts rand #=> 0.639737924661234
puts rand(10) #=> 7
srand(1020304050)
puts rand #=> 0.639737924661234
puts rand(10) #=> 7

syscall(4, 1, "hello\n", 6) #=> hello #=> 6

system("echo *") #=> true
system("uname -unknownoption") #=> false
system("kuddelmuddel") #=> nil
system({"MEINE_VAR" => "Test"}, "echo $MEINE_VAR") #=> Test #=> true

test("A", "Test.txt") #=> 2009-08-02 18:42:33 +0200
test("-", "test1.txt", "test2.txt") #=> false

catch(:a) do
  throw(:a)
  puts "Das wird nicht ausgeführt"
end
#Kein Output. 

p catch(:a) do
  throw(:a, "ABC")
end
#=> "ABC"

trace_var(:$abc){|val| puts "$abc ist jetzt '#{val}'. "}
$abc = 1 #=> $abc ist jetzt '1'. 
$abc = /regexp/ #=> $abc ist jetzt '(?-mix:regexp)'.

puts "Erstelle Kindprozess"
pid = fork do
  Signal.trap("TERM"){puts "SIGTERM"; exit}
  loop{sleep 1}
end
puts "Warten"
sleep 5
puts "Sende SIGTERM zum Kindprozess #{pid}"
Process.kill("SIGTERM", pid)
puts "Ende des Programms"

Erstelle Kindprozess
Warten
Sende SIGTERM zum Kindprozess 5565
Ende des Programms
SIGTERM

trace_var(:$abc){|val| puts val}
x = lambda{|val| p val}
trace_var(:$abc, x)
$abc = "Z"
untrace_var(:$abc, x)
$abc = "Y"
untrace_var(:$abc)
$abc = "X"

"Z"
Z
Y

def dangerous
  warn("Warning: Using this method could result in data loss")
  #Code...
end