Der Ruby-Weg (TM) seit Ruby 2.3: Um eine mehrzeilige Zeichenfolge mit Zeilenumbrüchen und korrekter Identifizierung zu definieren, verwenden Sie das schnörkellose HEREDOC <<~ :
conn.exec <<~EOS
select attr1, attr2, attr3, attr4, attr5, attr6, attr7
from table1, table2, table3, etc, etc, etc, etc, etc
where etc etc etc etc etc etc etc etc etc etc etc etc etc
EOS
# -> "select...\nfrom...\nwhere..."
Wenn die richtige Identifizierung kein Problem darstellt, können einfache und doppelte Anführungszeichen in Ruby mehrere Zeilen umfassen:
conn.exec "select attr1, attr2, attr3, attr4, attr5, attr6, attr7
from table1, table2, table3, etc, etc, etc, etc, etc,
where etc etc etc etc etc etc etc etc etc etc etc etc etc"
# -> "select...\n from...\n where..."
Wenn einfache oder doppelte Anführungszeichen umständlich sind, da dies viel Escapezeichen erfordern würde, ist die prozentuale Zeichenfolgenliteralnotation %die flexibelste Lösung:
conn.exec %(select attr1, attr2, attr3, attr4, attr5, attr6, attr7
from table1, table2, table3, etc, etc, etc, etc, etc
where (ProductLine = 'R' OR ProductLine = "S") AND Country = "...")
# -> "select...\n from...\n where..."
Wenn das Ziel darin besteht, die Zeilenumbrüche zu vermeiden (die sowohl das schnörkellose HEREDOC als auch die Anführungszeichen und das prozentuale Zeichenfolgenliteral verursachen), setzt ein Backslash als letztes Nicht-Leerzeichen die Zeile fort und veranlasst Ruby, die Zeichenfolgen hintereinander zu verketten (Achten Sie auf die Leerzeichen in der angegebenen Zeichenfolge):
conn.exec 'select attr1, attr2, attr3, attr4, attr5, attr6, attr7 ' \
'from table1, table2, table3, etc, etc, etc, etc, etc, ' \
'where etc etc etc etc etc etc etc etc etc etc etc etc etc'
# -> "select...from...where..."
Wenn Sie Rails verwenden, String.squishwird die Zeichenfolge aus führendem und nachfolgendem Leerzeichen entfernt und alle aufeinander folgenden Leerzeichen (Zeilenumbrüche, Tabulatoren und alle) in einem einzigen Leerzeichen zusammengefasst:
conn.exec "select attr1, attr2, attr3, attr4, attr5, attr6, attr7
from table1, table2, table3, etc, etc, etc, etc, etc,
where etc etc etc etc etc etc etc etc etc etc etc etc etc".squish
# -> "select...from...where..."
Mehr Details:
Ruby HEREDOC-Syntax
Die Here Document Notation für Strings ist eine Möglichkeit, lange Textblöcke inline im Code zu kennzeichnen. Es wird <<gefolgt von einem benutzerdefinierten String (dem Terminator für das Ende des Strings) gestartet . Alle folgenden Zeilen werden verkettet, bis der Terminator End of String ganz am Anfang einer Zeile steht:
puts <<HEREDOC
Text Text Text Text
Bla Bla
HEREDOC
# -> "Text Text Text Text\nBlaBla"
Der End of String-Terminator kann frei gewählt werden, es ist jedoch üblich, etwas wie "EOS" (End of String) oder etwas zu verwenden, das mit der Domäne des Strings übereinstimmt, wie z. B. "SQL".
HEREDOC unterstützt standardmäßig die Interpolation oder wenn der EOS-Terminator in doppelte Anführungszeichen gesetzt ist:
price = 10
print <<"EOS" # comments can be put here
1.) The price is #{price}.
EOS
# -> "1.) The price is 10."
Die Interpolation kann deaktiviert werden, wenn der EOS-Terminator in einfachen Anführungszeichen steht:
print <<'EOS' # Disabled interpolation
3.) The price is #{price}.
EOS
# -> "3.) The price is #{price}."
Eine wichtige Einschränkung von <<HEREDOCist, dass der End of String-Terminator am Anfang der Zeile stehen muss:
puts <<EOS
def foo
print "foo"
end
EOS
EOS
#-> "....def foo\n......print "foo"\n....end\n..EOS
Um dies zu <<-umgehen, wurde die Syntax erstellt. Dadurch kann der EOS-Terminator eingerückt werden, damit der Code besser aussieht. Die Zeilen zwischen dem <<-und dem EOS-Terminator werden weiterhin in vollem Umfang einschließlich aller Einrückungen verwendet:
puts <<-EOS # Use <<- to indent End of String terminator
def foo
print "foo"
end
EOS
# -> "..def foo\n....print "foo"\n..end"
Seit Ruby 2.3 haben wir jetzt das schnörkellose HEREDOC, <<~das führende Leerzeichen entfernt:
puts <<~EOS # Use the squiggly HEREDOC <<~ to remove leading whitespace (since Ruby 2.3!)
def foo
print "foo"
end
EOS
# -> "def foo\n..print "foo"\nend"
Leere Zeilen und Zeilen, die nur Tabulatoren und Leerzeichen enthalten, werden von << ~ ignoriert
puts <<~EOS.inspect
Hello
World!
EOS
#-> "Hello\n..World!"
Wenn sowohl Tabulatoren als auch Leerzeichen verwendet werden, werden Tabulatoren als 8 Leerzeichen betrachtet. Wenn sich die Zeile mit dem geringsten Einzug in der Mitte einer Registerkarte befindet, wird diese Registerkarte nicht entfernt.
puts <<~EOS.inspect
<tab>One Tab
<space><space>Two Spaces
EOS
# -> "\tOne Tab\nTwoSpaces"
HEREDOC kann einige verrückte Dinge tun, wie das Ausführen von Befehlen mit Backticks:
puts <<`EOC`
echo #{price}
echo #{price * 2}
EOC
HEREDOC-String-Definitionen können "gestapelt" werden, was bedeutet, dass der erste EOS-Terminator (EOSFOO unten) den ersten String beendet und den zweiten startet (EOSBAR unten):
print <<EOSFOO, <<EOSBAR # you can stack them
I said foo.
EOSFOO
I said bar.
EOSBAR
Ich glaube nicht, dass irgendjemand es jemals als solches verwenden würde, aber das <<EOSist wirklich nur ein String-Literal und kann überall dort platziert werden, wo normalerweise ein String platziert werden kann:
def func(a,b,c)
puts a
puts b
puts c
end
func(<<THIS, 23, <<THAT)
Here's a line
or two.
THIS
and here's another.
THAT
Wenn Sie nicht über Ruby 2.3, sondern über Rails >=3.0 verfügen, können Sie Folgendes verwenden String.strip_heredocwie<<~
# File activesupport/lib/active_support/core_ext/string/strip.rb, line 22
class String
def strip_heredoc
gsub(/^#{scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
end
end
puts <<-USAGE.strip_heredoc # If no Ruby 2.3, but Rails >= 3.0
This command does such and such.
Supported options are:
-h This message
...
USAGE
Prozent String Literals
Siehe RubyDoc , wie Sie die Prozentzeichen verwenden , gefolgt von einer Zeichenkette in einem Klammerpaar wie ein %(...), %[...],%{...} usw. , oder ein Paar von jedem nicht-alphanumerischen Zeichen wie%+...+
Letzte Worte
Zuletzt, um die Antwort auf die ursprüngliche Frage zu erhalten: "Gibt es eine Möglichkeit, eine Verkettung zu implizieren?" geantwortet: Ruby impliziert immer eine Verkettung, wenn zwei Zeichenfolgen (einfache und doppelte Anführungszeichen) hintereinander gefunden werden:
puts "select..." 'from table...' "where..."
# -> "select...from table...where..."
Die Einschränkung ist, dass dies nicht über Zeilenumbrüche hinweg funktioniert, da Ruby ein Ende der Anweisung interpretiert und die konsequente Zeile von nur Zeichenfolgen allein in einer Zeile nichts bewirkt.