class ERB

Die Klasse ERB (der Name steht für Embedded Ruby) ist ein einfach zu bedienender, aber auch sehr leistungsfähiger Template-Prozessor.

Verwendung

Bevor Sie ERB verwenden können, müssen Sie es zuerst anfordern (die Beispiele auf dieser Seite gehen davon aus, dass dies geschehen ist)

require 'erb'

Kurz gesagt

So funktioniert ERB

Sie können ein Template erstellen: eine Plain-Text-Zeichenkette, die speziell formatierte Tags enthält.
Sie können ein ERB-Objekt erstellen, um das Template zu speichern.
Sie können die Instanzmethode ERB#result aufrufen, um das Ergebnis zu erhalten.

ERB unterstützt drei Arten von Tags

Ausdrucks-Tags: Jeder beginnt mit '<%=', endet mit '%>'; enthält einen Ruby-Ausdruck; im Ergebnis ersetzt der Wert des Ausdrucks den gesamten Tag
```
template = 'The magic word is <%= magic_word %>.'
erb = ERB.new(template)
magic_word = 'xyzzy'
erb.result(binding) # => "The magic word is xyzzy."
```
Der obige Aufruf von result übergibt das Argument binding, das die Bindung der Variablen magic_word an ihren Zeichenkettenwert 'xyzzy' enthält.

Der untenstehende Aufruf von result muss keine Bindung übergeben, da sein Ausdruck Date::DAYNAMES global definiert ist.
```
ERB.new('Today is <%= Date::DAYNAMES[Date.today.wday] %>.').result # => "Today is Monday."
```

Ausführungs-Tags: Jeder beginnt mit '<%', endet mit '%>'; enthält Ruby-Code, der ausgeführt werden soll

 template = '<% File.write("t.txt", "Some stuff.") %>'
 ERB.new(template).result
 File.read('t.txt') # => "Some stuff."

Kommentar-Tags: Jeder beginnt mit '<%#', endet mit '%>'; enthält Kommentartext; im Ergebnis wird der gesamte Tag weggelassen.

 template = 'Some stuff;<%# Note to self: figure out what the stuff is. %> more stuff.'
 ERB.new(template).result # => "Some stuff; more stuff."

Einige einfache Beispiele

Hier ist ein einfaches Beispiel für ERB in Aktion

template = 'The time is <%= Time.now %>.'
erb = ERB.new(template)
erb.result
# => "The time is 2025-09-09 10:49:26 -0500."

Details

Eine Plain-Text-Zeichenkette wird der Variablen template zugewiesen. Ihr eingebetteter Ausdrucks-Tag '<%= Time.now %>' enthält einen Ruby-Ausdruck, Time.now.
Die Zeichenkette wird in ein neues ERB-Objekt eingefügt und in der Variablen erb gespeichert.
Der Methodenaufruf erb.result generiert eine Zeichenkette, die den Laufzeitwert von Time.now enthält, wie er zum Zeitpunkt des Aufrufs berechnet wurde.

Das ERB-Objekt kann wiederverwendet werden

erb.result
# => "The time is 2025-09-09 10:49:33 -0500."

Ein weiteres Beispiel

template = 'The magic word is <%= magic_word %>.'
erb = ERB.new(template)
magic_word = 'abracadabra'
erb.result(binding)
# => "The magic word is abracadabra."

Details

Wie zuvor wird eine Plain-Text-Zeichenkette der Variablen template zugewiesen. Ihr eingebetteter Ausdrucks-Tag '<%= magic_word %>' hat einen Variablennamen, magic_word.
Die Zeichenkette wird in ein neues ERB-Objekt eingefügt und in der Variablen erb gespeichert; beachten Sie, dass magic_word nicht definiert sein muss, bevor das ERB-Objekt erstellt wird.
magic_word = 'abracadabra' weist der Variablen magic_word einen Wert zu.
Der Methodenaufruf erb.result(binding) generiert eine Zeichenkette, die den Wert von magic_word enthält.

Wie zuvor kann das ERB-Objekt wiederverwendet werden

magic_word = 'xyzzy'
erb.result(binding)
# => "The magic word is xyzzy."

Bindings

Ein Aufruf der Methode result, die die formatierte Ergebniszeichenkette erzeugt, erfordert ein Binding-Objekt als Argument.

Das Binding-Objekt stellt die Bindungen für Ausdrücke in Ausdrucks-Tags bereit.

Es gibt drei Möglichkeiten, das erforderliche Binding bereitzustellen

Wenn Sie kein binding-Argument an die Methode new_toplevel übergeben, verwendet die Methode ihr Standard-Binding: das von der Methode new_toplevel zurückgegebene. Dieses Binding hat die von Ruby selbst definierten Bindungen, also die für Rubys Konstanten und Variablen.

Dieses Binding ist ausreichend für einen Ausdrucks-Tag, der sich nur auf Rubys Konstanten und Variablen bezieht; diese Ausdrucks-Tags beziehen sich nur auf Rubys globale Konstante RUBY_COPYRIGHT und die globale Variable $0

template = <<TEMPLATE
The Ruby copyright is <%= RUBY_COPYRIGHT.inspect %>.
The current process is <%= $0 %>.
TEMPLATE
puts ERB.new(template).result
The Ruby copyright is "ruby - Copyright (C) 1993-2025 Yukihiro Matsumoto".
The current process is irb.

(Der aktuelle Prozess ist irb, da wir dort diese Beispiele durchführen!)

Lokales `Binding`

Das Standard-Binding ist für einen Ausdruck, der sich auf eine Konstante oder Variable bezieht, die dort nicht definiert ist, nicht ausreichend.

Foo = 1 # Defines local constant Foo.
foo = 2 # Defines local variable foo.
template = <<TEMPLATE
The current value of constant Foo is <%= Foo %>.
The current value of variable foo is <%= foo %>.
The Ruby copyright is <%= RUBY_COPYRIGHT.inspect %>.
The current process is <%= $0 %>.
TEMPLATE
erb = ERB.new(template)

Dieser Aufruf unten löst eine NameError aus, weil obwohl Foo und foo lokal definiert sind, sie nicht im Standard-Binding definiert sind.

erb.result # Raises NameError.

Um die lokal definierten Konstanten und Variablen verfügbar zu machen, können Sie result mit dem lokalen Binding aufrufen.

puts erb.result(binding)
The current value of constant Foo is 1.
The current value of variable foo is 2.
The Ruby copyright is "ruby - Copyright (C) 1993-2025 Yukihiro Matsumoto".
The current process is irb.

Erweitertes `Binding`

Eine weitere Möglichkeit, Variablen-Bindungen (aber keine Konstanten-Bindungen) verfügbar zu machen, ist die Verwendung der Methode result_with_hash(hash); der übergebene Hash enthält Namens-/Wertpaare, die zur Definition und Zuweisung von Variablen in einer Kopie des Standard-Bindings verwendet werden.

template = <<TEMPLATE
The current value of variable bar is <%= bar %>.
The current value of variable baz is <%= baz %>.
The Ruby copyright is <%= RUBY_COPYRIGHT.inspect %>.
The current process is <%= $0 %>.
TEMPLATE
erb = ERB.new(template)

Beide diese Aufrufe lösen eine NameError aus, weil bar und baz weder im Standard-Binding noch im lokalen Binding definiert sind.

puts erb.result          # Raises NameError.
puts erb.result(binding) # Raises NameError.

Dieser Aufruf übergibt einen Hash, der bewirkt, dass bar und baz in einem neuen Binding definiert werden (abgeleitet von new_toplevel).

hash = {bar: 3, baz: 4}
puts erb.result_with_hash(hash)
The current value of variable bar is 3.
The current value of variable baz is 4.
The Ruby copyright is "ruby - Copyright (C) 1993-2025 Yukihiro Matsumoto".
The current process is irb.

Tags

Die obigen Beispiele verwenden Ausdrucks-Tags. Dies sind die verfügbaren Tags in ERB.

Ausdrucks-Tag: Der Tag enthält einen Ruby-Ausdruck; im Ergebnis soll der gesamte Tag durch den Laufzeitwert des Ausdrucks ersetzt werden.
Ausführungs-Tag: Der Tag enthält Ruby-Code; im Ergebnis soll der gesamte Tag durch den Laufzeitwert des Codes ersetzt werden.
Kommentar-Tag: Der Tag enthält Kommentarcode; im Ergebnis soll der gesamte Tag weggelassen werden.

Ausdrucks-Tags

Sie können einen Ruby-Ausdruck in ein Template einbetten, indem Sie einen Ausdrucks-Tag verwenden.

Seine Syntax lautet <%= Ausdruck %>, wobei Ausdruck jeder gültige Ruby-Ausdruck ist.

Wenn Sie die Methode result aufrufen, wertet die Methode den Ausdruck aus und ersetzt den gesamten Ausdrucks-Tag durch den Wert des Ausdrucks.

ERB.new('Today is <%= Date::DAYNAMES[Date.today.wday] %>.').result
# => "Today is Monday."
ERB.new('Tomorrow will be <%= Date::DAYNAMES[Date.today.wday + 1] %>.').result
# => "Tomorrow will be Tuesday."
ERB.new('Yesterday was <%= Date::DAYNAMES[Date.today.wday - 1] %>.').result
# => "Yesterday was Sunday."

Beachten Sie, dass Leerzeichen vor und nach dem Ausdruck erlaubt, aber nicht erforderlich sind und dass solche Leerzeichen aus dem Ergebnis entfernt werden.

ERB.new('My appointment is on <%=Date::DAYNAMES[Date.today.wday + 2]%>.').result
# => "My appointment is on Wednesday."
ERB.new('My appointment is on <%=     Date::DAYNAMES[Date.today.wday + 2]    %>.').result
# => "My appointment is on Wednesday."

Ausführungs-Tags

Sie können ausführbaren Ruby-Code in ein Template einbetten, indem Sie einen Ausführungs-Tag verwenden.

Seine Syntax lautet <% Code %>, wobei Code jeder gültige Ruby-Code ist.

Wenn Sie die Methode result aufrufen, führt die Methode den Code aus und entfernt den gesamten Ausführungs-Tag (erzeugt keinen Text im Ergebnis).

ERB.new('foo <% Dir.chdir("C:/") %> bar').result # => "foo  bar"

Leerzeichen vor und nach dem eingebetteten Code sind optional.

ERB.new('foo <%Dir.chdir("C:/")%> bar').result   # => "foo  bar"

Sie können Text mit Ausführungs-Tags verschachteln, um eine Kontrollstruktur wie eine Bedingung, eine Schleife oder eine case-Anweisung zu bilden.

Bedingung

template = <<TEMPLATE
<% if verbosity %>
An error has occurred.
<% else %>
Oops!
<% end %>
TEMPLATE
erb = ERB.new(template)
verbosity = true
erb.result(binding)
# => "\nAn error has occurred.\n\n"
verbosity = false
erb.result(binding)
# => "\nOops!\n\n"

Beachten Sie, dass der verschachtelte Text selbst Ausdrucks-Tags enthalten kann.

Schleife

template = <<TEMPLATE
<% Date::ABBR_DAYNAMES.each do |dayname| %>
<%= dayname %>
<% end %>
TEMPLATE
ERB.new(template).result
# => "\nSun\n\nMon\n\nTue\n\nWed\n\nThu\n\nFri\n\nSat\n\n"

Andere, nicht-steuernde Zeilen von Ruby-Code können mit dem Text verschachtelt werden, und der Ruby-Code kann selbst reguläre Ruby-Kommentare enthalten.

template = <<TEMPLATE
<% 3.times do %>
<%= Time.now %>
<% sleep(1) # Let's make the times different. %>
<% end %>
TEMPLATE
ERB.new(template).result
# => "\n2025-09-09 11:36:02 -0500\n\n\n2025-09-09 11:36:03 -0500\n\n\n2025-09-09 11:36:04 -0500\n\n\n"

Der Ausführungs-Tag kann auch mehrere Codezeilen enthalten.

template = <<TEMPLATE
<%
  (0..2).each do |i|
    (0..2).each do |j|
%>
* <%=i%>,<%=j%>
<%
    end
  end
%>
TEMPLATE
ERB.new(template).result
# => "\n* 0,0\n\n* 0,1\n\n* 0,2\n\n* 1,0\n\n* 1,1\n\n* 1,2\n\n* 2,0\n\n* 2,1\n\n* 2,2\n\n"

Kurzform für Ausführungs-Tags

Sie können das Schlüsselwortargument trim_mode: '%' verwenden, um eine Kurzform für Ausführungs-Tags zu aktivieren; dieses Beispiel verwendet die Kurzform % Code anstelle von <% Code %>.

template = <<TEMPLATE
% priorities.each do |priority|
  * <%= priority %>
% end
TEMPLATE
erb = ERB.new(template, trim_mode: '%')
priorities = [ 'Run Ruby Quiz',
               'Document Modules',
               'Answer Questions on Ruby Talk' ]
puts erb.result(binding)
  * Run Ruby Quiz
  * Document Modules
  * Answer Questions on Ruby Talk

Beachten Sie, dass in der Kurzform das Zeichen '%' das erste Zeichen in der Codezeile sein muss (keine führenden Leerzeichen).

Unterdrücken unerwünschter Leerzeilen

Wenn das Schlüsselwortargument trim_mode nicht angegeben ist, gehen alle Leerzeilen in das Ergebnis ein.

template = <<TEMPLATE
<% if true %>
<%= RUBY_VERSION %>
<% end %>
TEMPLATE
ERB.new(template).result.lines.each {|line| puts line.inspect }
"\n"
"3.4.5\n"
"\n"

Sie können trim_mode: '-' angeben, um jede Leerzeile zu unterdrücken, deren Quellzeile mit -%> endet (anstelle von %>).

template = <<TEMPLATE
<% if true -%>
<%= RUBY_VERSION %>
<% end -%>
TEMPLATE
ERB.new(template, trim_mode: '-').result.lines.each {|line| puts line.inspect }
"3.4.5\n"

Es ist ein Fehler, die nachgestellte '-%>'-Notation ohne trim_mode: '-' zu verwenden.

ERB.new(template).result.lines.each {|line| puts line.inspect } # Raises SyntaxError.

Unterdrücken unerwünschter Zeilenumbrüche

Betrachten Sie dieses Template

template = <<TEMPLATE
<% RUBY_VERSION %>
<%= RUBY_VERSION %>
foo <% RUBY_VERSION %>
foo <%= RUBY_VERSION %>
TEMPLATE

Wenn das Schlüsselwortargument trim_mode nicht angegeben ist, gehen alle Zeilenumbrüche in das Ergebnis ein.

ERB.new(template).result.lines.each {|line| puts line.inspect }
"\n"
"3.4.5\n"
"foo \n"
"foo 3.4.5\n"

Sie können trim_mode: '>' angeben, um den nachgestellten Zeilenumbruch für jede Zeile zu unterdrücken, die mit '%>' endet (unabhängig von ihrem Anfang).

ERB.new(template, trim_mode: '>').result.lines.each {|line| puts line.inspect }
"3.4.5foo foo 3.4.5"

Sie können trim_mode: '<>' angeben, um den nachgestellten Zeilenumbruch für jede Zeile zu unterdrücken, die sowohl mit '<%' beginnt als auch mit '%>' endet.

ERB.new(template, trim_mode: '<>').result.lines.each {|line| puts line.inspect }
"3.4.5foo \n"
"foo 3.4.5\n"

Kombinieren von Trim-Modi

Sie können bestimmte Trim-Modi kombinieren.

'%-': Aktiviert die Kurzform und lässt jede Leerzeile weg, die mit '-%>' endet.
'%>': Aktiviert die Kurzform und unterdrückt den Zeilenumbruch für jede Zeile, die mit '%>' endet.
'%<>': Aktiviert die Kurzform und unterdrückt den Zeilenumbruch für jede Zeile, die mit '<%' beginnt und mit '%>' endet.

Kommentar-Tags

Sie können einen Kommentar in ein Template einbetten, indem Sie einen Kommentar-Tag verwenden; seine Syntax lautet <%# Text %>, wobei Text der Text des Kommentars ist.

Wenn Sie die Methode result aufrufen, entfernt sie den gesamten Kommentar-Tag (erzeugt keinen Text im Ergebnis).

Beispiel

template = 'Some stuff;<%# Note to self: figure out what the stuff is. %> more stuff.'
ERB.new(template).result # => "Some stuff; more stuff."

Ein Kommentar-Tag kann überall im Template erscheinen.

Beachten Sie, dass der Anfang des Tags '<%#' sein muss, nicht '<% #'.

In diesem Beispiel beginnt der Tag mit '<% #' und ist daher ein Ausführungs-Tag, kein Kommentar-Tag; der zitierte Code besteht ausschließlich aus einem Ruby-ähnlichen Kommentar (der natürlich ignoriert wird).

ERB.new('Some stuff;<% # Note to self: figure out what the stuff is. %> more stuff.').result
# => "Some stuff;"

Kodierungen

Ein ERB-Objekt hat eine Kodierung, die standardmäßig die Kodierung der Template-Zeichenkette ist; die Ergebniszeichenkette wird ebenfalls diese Kodierung haben.

template = <<TEMPLATE
<%# Comment. %>
TEMPLATE
erb = ERB.new(template)
template.encoding   # => #<Encoding:UTF-8>
erb.encoding        # => #<Encoding:UTF-8>
erb.result.encoding # => #<Encoding:UTF-8>

Sie können eine andere Kodierung angeben, indem Sie einen Magic Comment am Anfang des gegebenen Templates hinzufügen.

template = <<TEMPLATE
<%#-*- coding: Big5 -*-%>
<%# Comment. %>
TEMPLATE
erb = ERB.new(template)
template.encoding   # => #<Encoding:UTF-8>
erb.encoding        # => #<Encoding:Big5>
erb.result.encoding # => #<Encoding:Big5>

Fehlerberichterstattung

Betrachten Sie dieses Template (enthält einen Fehler).

template = '<%= nosuch %>'
erb = ERB.new(template)

Wenn ERB einen Fehler meldet, enthält es einen Dateinamen (falls verfügbar) und eine Zeilennummer; der Dateiname stammt von der Methode filename, die Zeilennummer von der Methode lineno.

Anfangs sind diese Werte nil und 0; diese Anfangswerte werden als '(erb)' und 1 gemeldet.

erb.filename # => nil
erb.lineno   # => 0
erb.result
(erb):1:in '<main>': undefined local variable or method 'nosuch' for main (NameError)

Sie können die Methoden filename= und lineno= verwenden, um Werte zuzuweisen, die in Ihrem Kontext aussagekräftiger sind.

erb.filename = 't.txt'
erb.lineno = 555
erb.result
t.txt:556:in '<main>': undefined local variable or method 'nosuch' for main (NameError)

Sie können die Methode location= verwenden, um beide Werte festzulegen.

erb.location = ['u.txt', 999]
erb.result
u.txt:1000:in '<main>': undefined local variable or method 'nosuch' for main (NameError)

Plain Text mit eingebettetem Ruby

Hier ist ein Plain-Text-Template; es verwendet die literale Notation '%q{ ... }', um das Template zu definieren (siehe %q Literale); dies vermeidet Probleme mit Backslashes.

template = %q{
From:  James Edward Gray II <james@grayproductions.net>
To:  <%= to %>
Subject:  Addressing Needs

<%= to[/\w+/] %>:

Just wanted to send a quick note assuring that your needs are being
addressed.

I want you to know that my team will keep working on the issues,
especially:

<%# ignore numerous minor requests -- focus on priorities %>
% priorities.each do |priority|
  * <%= priority %>
% end

Thanks for your patience.

James Edward Gray II
}

Das Template benötigt diese.

to = 'Community Spokesman <spokesman@ruby_community.org>'
priorities = [ 'Run Ruby Quiz',
               'Document Modules',
               'Answer Questions on Ruby Talk' ]

Schließlich erstellen Sie das ERB-Objekt und erhalten das Ergebnis.

erb = ERB.new(template, trim_mode: '%<>')
puts erb.result(binding)

From:  James Edward Gray II <james@grayproductions.net>
To:  Community Spokesman <spokesman@ruby_community.org>
Subject:  Addressing Needs

Community:

Just wanted to send a quick note assuring that your needs are being
addressed.

I want you to know that my team will keep working on the issues,
especially:

* Run Ruby Quiz
* Document Modules
* Answer Questions on Ruby Talk

Thanks for your patience.

James Edward Gray II

HTML mit eingebettetem Ruby

Dieses Beispiel zeigt ein HTML-Template.

Zuerst hier eine benutzerdefinierte Klasse, Product.

class Product
  def initialize(code, name, desc, cost)
    @code = code
    @name = name
    @desc = desc
    @cost = cost
    @features = []
  end

  def add_feature(feature)
    @features << feature
  end

  # Support templating of member data.
  def get_binding
    binding
  end

end

Das folgende Template benötigt diese Werte.

toy = Product.new('TZ-1002',
                  'Rubysapien',
                  "Geek's Best Friend!  Responds to Ruby commands...",
                  999.95
                  )
toy.add_feature('Listens for verbal commands in the Ruby language!')
toy.add_feature('Ignores Perl, Java, and all C variants.')
toy.add_feature('Karate-Chop Action!!!')
toy.add_feature('Matz signature on left leg.')
toy.add_feature('Gem studded eyes... Rubies, of course!')

Hier ist das HTML.

template = <<TEMPLATE
<html>
  <head><title>Ruby Toys -- <%= @name %></title></head>
  <body>
    <h1><%= @name %> (<%= @code %>)</h1>
    <p><%= @desc %></p>
    <ul>
      <% @features.each do |f| %>
        <li><b><%= f %></b></li>
      <% end %>
    </ul>
    <p>
      <% if @cost < 10 %>
        <b>Only <%= @cost %>!!!</b>
      <% else %>
         Call for a price, today!
      <% end %>
    </p>
  </body>
</html>
TEMPLATE

Schließlich erstellen Sie das ERB-Objekt und erhalten das Ergebnis (einige Leerzeilen werden weggelassen).

erb = ERB.new(template)
puts erb.result(toy.get_binding)
<html>
  <head><title>Ruby Toys -- Rubysapien</title></head>
  <body>
    <h1>Rubysapien (TZ-1002)</h1>
    <p>Geek's Best Friend!  Responds to Ruby commands...</p>
    <ul>
        <li><b>Listens for verbal commands in the Ruby language!</b></li>
        <li><b>Ignores Perl, Java, and all C variants.</b></li>
        <li><b>Karate-Chop Action!!!</b></li>
        <li><b>Matz signature on left leg.</b></li>
        <li><b>Gem studded eyes... Rubies, of course!</b></li>
    </ul>
    <p>
         Call for a price, today!
    </p>
  </body>
</html>

Andere Template-Prozessoren

Verschiedene Ruby-Projekte haben ihre eigenen Template-Prozessoren. Das Ruby Processing System RDoc hat zum Beispiel eines, das auch anderswo verwendet werden kann.

Andere beliebte Template-Prozessoren finden Sie auf der Seite Template Engines der Ruby Toolbox.

Constants

VERSION: Die ERB-Version als Zeichenkette.

Attribute

encoding [R]

Gibt die Kodierung von self zurück; siehe Kodierungen.

filename [RW]

Legt den Dateinamen fest oder gibt ihn zurück, der zur Fehlerberichterstattung verwendet wird; siehe Fehlerberichterstattung.

lineno [RW]

Legt die Zeilennummer fest oder gibt sie zurück, die zur Fehlerberichterstattung verwendet wird; siehe Fehlerberichterstattung.

src [R]

Gibt den Ruby-Code zurück, der beim Ausführen das Ergebnis generiert; der Code wird von der Methode result und ihren Wrapper-Methoden result_with_hash und run ausgeführt.

template = 'The time is <%= Time.now %>.'
erb = ERB.new(template)
erb.src
# => "#coding:UTF-8\n_erbout = +''; _erbout.<< \"The time is \".freeze; _erbout.<<(( Time.now ).to_s); _erbout.<< \".\".freeze; _erbout"
erb.result
# => "The time is 2025-09-18 15:58:08 -0500."

In einem lesbareren Format

# puts erb.src.split('; ')
  # #coding:UTF-8
  # _erbout = +''
  # _erbout.<< "The time is ".freeze
  # _erbout.<<(( Time.now ).to_s)
  # _erbout.<< ".".freeze
  # _erbout

Die Variable _erbout wird verwendet, um die Zwischenergebnisse im Code zu speichern; der Name _erbout ist der Standardwert in ERB.new und kann über das Schlüsselwortargument eoutvar geändert werden.

erb = ERB.new(template, eoutvar: '_foo')
puts template.src.split('; ')
#coding:UTF-8
_foo = +''
_foo.<< "The time is ".freeze
_foo.<<(( Time.now ).to_s)
_foo.<< ".".freeze
_foo

Öffentliche Klassenmethoden

new(template, trim_mode: nil, eoutvar: '_erbout')

Source

# File lib/erb.rb, line 831
def initialize(str, trim_mode: nil, eoutvar: '_erbout')
  compiler = make_compiler(trim_mode)
  set_eoutvar(compiler, eoutvar)
  @src, @encoding, @frozen_string = *compiler.compile(str)
  @filename = nil
  @lineno = 0
  @_init = self.class.singleton_class
end

Gibt ein neues ERB-Objekt zurück, das die gegebene Zeichenkette template enthält.

Details zu template, seinen eingebetteten Tags und den generierten Ergebnissen finden Sie unter ERB.

Schlüsselwortargument trim_mode

Sie können das Schlüsselwortargument trim_mode: '%' verwenden, um die Kurzform für Ausführungs-Tags zu aktivieren.

Dieser Wert ermöglicht die Kontrolle von Leerzeilen.

'-': Lässt jede Leerzeile weg, die mit '%>' endet.

Andere Werte ermöglichen die Kontrolle von Zeilenumbrüchen.

'>': Lässt den Zeilenumbruch für jede Zeile weg, die mit '%>' endet.
'<>': Lässt den Zeilenumbruch für jede Zeile weg, die mit '<%' beginnt und mit '%>' endet.

Sie können auch Trim-Modi kombinieren.

Schlüsselwortargument eoutvar

Der Zeichenkettenwert des Schlüsselwortarguments eoutvar gibt den Namen der Variablen an, die die Methode result zum Erstellen ihrer Ergebniszeichenkette verwendet; siehe src.

Dies ist nützlich, wenn Sie mehrere ERB-Templates mit demselben Binding ausführen müssen und/oder wenn Sie steuern möchten, wo die Ausgabe landet.

Es ist eine gute Praxis, einen Variablennamen zu wählen, der mit einem Unterstrich beginnt: '_'.

version → string

Source

# File lib/erb.rb, line 786
def self.version
  VERSION
end

Gibt die ERB-Version als Zeichenkette zurück.

Öffentliche Instanzmethoden

def_class(super_class = Object, method_name = 'result') → new_class

Source

# File lib/erb.rb, line 1169
def def_class(superklass=Object, methodname='result')
  cls = Class.new(superklass)
  def_method(cls, methodname, @filename || '(ERB)')
  cls
end

Gibt eine neue namenlose Klasse zurück, deren Oberklasse super_class ist und die die Instanzmethode method_name hat.

Erstellen Sie ein Template aus HTML, das eingebettete Ausdrucks-Tags hat, die @arg1 und @arg2 verwenden.

html = <<TEMPLATE
<html>
<body>
  <p><%= @arg1 %></p>
  <p><%= @arg2 %></p>
</body>
</html>
TEMPLATE
template = ERB.new(html)

Erstellen Sie eine Basisklasse, die @arg1 und @arg2 hat.

class MyBaseClass
  def initialize(arg1, arg2)
    @arg1 = arg1
    @arg2 = arg2
  end
end

Verwenden Sie die Methode def_class, um eine Unterklasse zu erstellen, die die Methode :render hat.

MySubClass = template.def_class(MyBaseClass, :render)

Generieren Sie das Ergebnis.

puts MySubClass.new('foo', 123).render
<html>
<body>
  <p>foo</p>
  <p>123</p>
</body>
</html>

def_method(module, method_signature, filename = '(ERB)') → method_name

Source

# File lib/erb.rb, line 1087
def def_method(mod, methodname, fname='(ERB)')
  src = self.src.sub(/^(?!#|$)/) {"def #{methodname}\n"} << "\nend\n"
  mod.module_eval do
    eval(src, binding, fname, -1)
  end
end

Erstellt und gibt eine neue Instanzmethode im gegebenen Modul module zurück; gibt den Methodennamen als Symbol zurück.

Die Methode wird aus der gegebenen method_signature erstellt, die aus dem Methodennamen und seinen Argumentnamen (falls vorhanden) besteht.

Die filename setzt den Wert von filename; siehe Fehlerberichterstattung.

template = '<%= arg1 %> <%= arg2 %>'
erb = ERB.new(template)
MyModule = Module.new
erb.def_method(MyModule, 'render(arg1, arg2)') # => :render
class MyClass; include MyModule; end
MyClass.new.render('foo', 123)                      # => "foo 123"

def_module(method_name = 'erb') → new_module

Source

# File lib/erb.rb, line 1112
def def_module(methodname='erb')
  mod = Module.new
  def_method(mod, methodname, @filename || '(ERB)')
  mod
end

Gibt ein neues namenloses Modul zurück, das die Instanzmethode method_name hat.

template = '<%= arg1 %> <%= arg2 %>'
erb = ERB.new(template)
MyModule = template.def_module('render(arg1, arg2)')
class MyClass
  include MyModule
end
MyClass.new.render('foo', 123)
# => "foo 123"

location = [filename, lineno] → [filename, lineno]

location = filename → filename

Source

# File lib/erb.rb, line 936
def location=((filename, lineno))
  @filename = filename
  @lineno = lineno if lineno
end

Legt die Werte von filename und, falls gegeben, lineno fest; siehe Fehlerberichterstattung.

make_compiler → erb_compiler

Source

# File lib/erb.rb, line 853
def make_compiler(trim_mode)
  ERB::Compiler.new(trim_mode)
end

Gibt ein neues ERB::Compiler mit dem gegebenen trim_mode zurück; für trim_mode-Werte siehe ERB.new.

ERB.new('').make_compiler(nil)
# => #<ERB::Compiler:0x000001cff9467678 @insert_cmd="print", @percent=false, @post_cmd=[], @pre_cmd=[], @put_cmd="print", @trim_mode=nil>

result(binding = new_toplevel) → new_string

Source

# File lib/erb.rb, line 1007
def result(b=new_toplevel)
  unless @_init.equal?(self.class.singleton_class)
    raise ArgumentError, "not initialized"
  end
  eval(@src, b, (@filename || '(erb)'), @lineno)
end

Gibt das Zeichenkettenergebnis zurück, das durch Verarbeitung der in self gespeicherten ERB-Tags im Template gebildet wird.

Wenn kein Argument angegeben ist, wird das Standard-Binding verwendet; siehe Standard-Binding.

Wenn das Argument binding angegeben ist, wird das lokale Binding verwendet; siehe Lokales Binding.

Siehe auch result_with_hash.

result_with_hash(hash) → new_string

Source

# File lib/erb.rb, line 1026
def result_with_hash(hash)
  b = new_toplevel(hash.keys)
  hash.each_pair do |key, value|
    b.local_variable_set(key, value)
  end
  result(b)
end

Gibt das Zeichenkettenergebnis zurück, das durch Verarbeitung der in self gespeicherten ERB-Tags in der Zeichenkette gebildet wird; siehe Erweitertes Binding.

Siehe auch result.

run(binding = new_toplevel) → nil

Source

# File lib/erb.rb, line 985
def run(b=new_toplevel)
  print self.result(b)
end

Wie result, aber gibt die Ergebniszeichenkette aus (anstatt sie zurückzugeben); gibt nil zurück.

set_eoutvar(compiler, eoutvar = '_erbout') → [eoutvar]

Source

# File lib/erb.rb, line 971
def set_eoutvar(compiler, eoutvar = '_erbout')
  compiler.put_cmd = "#{eoutvar}.<<"
  compiler.insert_cmd = "#{eoutvar}.<<"
  compiler.pre_cmd = ["#{eoutvar} = +''"]
  compiler.post_cmd = [eoutvar]
end

Legt den eoutvar-Wert im ERB::Compiler-Objekt compiler fest; gibt ein Array mit einem Element zurück, das den Wert von eoutvar enthält.

template = ERB.new('')
compiler = template.make_compiler(nil)
pp compiler
#<ERB::Compiler:0x000001cff8a9aa00
 @insert_cmd="print",
 @percent=false,
 @post_cmd=[],
 @pre_cmd=[],
 @put_cmd="print",
 @trim_mode=nil>
template.set_eoutvar(compiler, '_foo') # => ["_foo"]
pp compiler
#<ERB::Compiler:0x000001cff8a9aa00
 @insert_cmd="_foo.<<",
 @percent=false,
 @post_cmd=["_foo"],
 @pre_cmd=["_foo = +''"],
 @put_cmd="_foo.<<",
 @trim_mode=nil>

Private Instanzmethoden

new_toplevel(symbols) → new_binding

Source

# File lib/erb.rb, line 1050
def new_toplevel(vars = nil)
  b = TOPLEVEL_BINDING
  if vars
    vars = vars.select {|v| b.local_variable_defined?(v)}
    unless vars.empty?
      return b.eval("tap {|;#{vars.join(',')}| break binding}")
    end
  end
  b.dup
end

Gibt ein neues Binding zurück, das auf TOPLEVEL_BINDING basiert; wird verwendet, um ein Standard-Binding für einen Aufruf von result zu erstellen.

Siehe Standard-Binding.

Das Argument symbols ist ein Array von Symbolen; jedes Symbol symbol wird als neue Variable definiert, um eine Variable mit demselben Namen zu verstecken und zu verhindern, dass sie eine bereits im Binding definierte Variable überschreibt.