Ruby: Kann ich mehrzeilige Zeichenfolgen ohne Verkettung schreiben?


397

Gibt es eine Möglichkeit, dies ein wenig besser aussehen zu lassen?

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'

Gibt es eine Möglichkeit, eine Verkettung zu implizieren?


28
Seien Sie vorsichtig bei SQL-Injection-Angriffen. :)
Roy Tinker

Antworten:


595

Es gibt Teile dieser Antwort, die mir geholfen haben, das zu bekommen, was ich brauchte (einfache mehrzeilige Verkettung OHNE zusätzliches Leerzeichen), aber da keine der tatsächlichen Antworten dies hatte, kompiliere ich sie hier:

str = 'this is a multi-line string'\
  ' using implicit concatenation'\
  ' to prevent spare \n\'s'

=> "this is a multi-line string using implicit concatenation to eliminate spare
\\n's"

Als Bonus gibt es hier eine Version mit lustiger HEREDOC-Syntax (über diesen Link ):

p <<END_SQL.gsub(/\s+/, " ").strip
SELECT * FROM     users
         ORDER BY users.id DESC
END_SQL
# >> "SELECT * FROM users ORDER BY users.id DESC"

Letzteres gilt hauptsächlich für Situationen, die mehr Flexibilität bei der Verarbeitung erfordern. Ich persönlich mag es nicht, es bringt die Verarbeitung an einen seltsamen Ort für den String (dh davor, aber mit Instanzmethoden, die normalerweise danach kommen), aber es ist da. Beachten Sie, dass Sie beim Einrücken des letzten END_SQLBezeichners (was häufig vorkommt, da dieser wahrscheinlich in einer Funktion oder einem Modul enthalten ist) die Syntax mit Bindestrich verwenden müssen (dh p <<-END_SQLanstelle von p <<END_SQL). Andernfalls wird der Bezeichner durch das Leerzeichen beim Einrücken als Fortsetzung der Zeichenfolge interpretiert.

Das spart nicht viel Tippen, sieht aber für mich besser aus als die Verwendung von + Zeichen.

Wenn Sie Ruby 2.3+ verwenden (ich sage in einer Bearbeitung einige Jahre später), ist auch der Operator << ~ verfügbar , der zusätzliche Einrückungen aus der endgültigen Zeichenfolge entfernt. .gsubIn diesem Fall sollten Sie in der Lage sein, den Aufruf zu entfernen (obwohl dies möglicherweise sowohl vom Starteinzug als auch von Ihren endgültigen Anforderungen abhängt).

BEARBEITEN: Hinzufügen eines weiteren:

p %{
SELECT * FROM     users
         ORDER BY users.id DESC
}.gsub(/\s+/, " ").strip
# >> "SELECT * FROM users ORDER BY users.id DESC"

2
Dies ist eine alte Frage, ABER es liegt entweder ein Fehler in der Antwort vor oder die Syntax wurde seitdem geändert. p <<END_SQLsollte sein p <<-END_SQLAndernfalls ist dies die Antwort. Optional können Sie führende Leerzeichen mit dem schnörkellosen HEREDOC-Operator <<~END_SQL
entfernen

Dies ist nur dann ein Fehler, wenn die Endkennung eingerückt ist (der Bindestrich weist den Ruby-Interpreter an, Leerzeichen zu kürzen, bevor die Endkennung ermittelt wird). Ich kann dies jedoch erwähnen. Außerdem ist das ~ nicht erforderlich, da gsub \ s + und strip bereits führende Leerzeichen entfernen.
A. Wilson

Es <<~wäre schön, die Antwort zu ergänzen, und das von dort aus zu untersuchen. Persönlich benutze ich das, <<~MSG.strip ... MSGwas auch das letzte abstreift \n.
Qortex

1
Als ich diese Antwort schrieb (vor neun Jahren, meine Güte!), War Ruby auf 1.9 und << ~ (offensichtlich) wurde erst auf 2.3 eingeführt. Abgesehen von der alten Geschichte werde ich sie einfügen, danke, dass Sie sie angesprochen haben.
A. Wilson

Vielen Dank, dass Sie eine der wenigen Antworten sind, die keine zusätzlichen Zeilenumbrüche hinzufügen. Dies wollte ich vermeiden, als ich diese Frage fand.
Josh

174

In Ruby 2.0 können Sie jetzt einfach verwenden %

Zum Beispiel:

SQL = %{
SELECT user, name
FROM users
WHERE users.id = #{var}
LIMIT #{var2}
}

14
Funktioniert auch in Ruby 1.9.3.
Andy Stewart

26
Eine mit dieser Syntax erstellte Zeichenfolge enthält sowohl Zeilenumbrüche als auch Einrückungen, die nachfolgenden Zeilen hinzugefügt werden.
James

Dies ist sogar besser als << EOT ...... EOT (hier Dokument)! Bei Bedarf wird auch interpoliert.
Nasser

1
@Nasser Ein Heredoc interpoliert ebenfalls.
Fund Monica Klage

3
Bei Verwendung von Rails sollte das Aufrufen squishder Ausgabe hilfreich sein.
Jignesh Gohel

167

Ja, wenn Ihnen die zusätzlichen Zeilenumbrüche nichts ausmachen:

 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'

Alternativ können Sie einen Heredoc verwenden :

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

87
Sie könnten auch verwenden%Q(...)
BaroqueBobcat

3
@Zombies: Zeilenumbrüche sind normalerweise in SQL-Anweisungen zulässig und werden nur als normale Leerzeichen behandelt.
Mark Byers

2
In meiner Antwort unten finden Sie ein Beispiel. Sie können jetzt nur% verwenden.
Robbie Guilfoyle

4
Sie könnten auch%(...)
Null-Teiler

1
Wenn Sie absichtlich nachgestellte Leerzeichen hinzufügen und eine dieser Lösungen verwenden, sollten Sie beachten, dass Ihr Editor beim Speichern der Datei möglicherweise automatisch nachgestellte Leerzeichen entfernt . Normalerweise bevorzuge ich dieses Verhalten, aber es hat einige Male unerwartete Probleme für mich verursacht. Eine Lösung besteht darin, Ihre mehrzeilige Zeichenfolge so zu schreiben, wie es das OP in der Frage getan hat.
Dennis

50

Wie Sie bereits gelesen haben, gibt es mehrere Syntaxen für mehrzeilige Zeichenfolgen. Mein Favorit ist Perl-Stil:

conn.exec %q{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}

Die mehrzeilige Zeichenfolge beginnt mit% q, gefolgt von einem {, [oder (und endet dann mit dem entsprechenden umgekehrten Zeichen.% Q erlaubt keine Interpolation;% Q erlaubt dies, sodass Sie Folgendes schreiben können:

conn.exec %Q{select attr1, attr2, attr3, attr4, attr5, attr6, attr7
      from #{table_names},
      where etc etc etc etc etc etc etc etc etc etc etc etc etc}

Ich habe eigentlich keine Ahnung, wie diese Arten von mehrzeiligen Zeichenfolgen genannt werden, also nennen wir sie einfach Perl-mehrzeilig.

Beachten Sie jedoch, dass Sie möglicherweise unnötige Leerzeichen erhalten, unabhängig davon, ob Sie Perl-Multilines oder Heredocs verwenden, wie Mark und Peter vorgeschlagen haben. Sowohl in meinen Beispielen als auch in ihren Beispielen enthalten die Zeilen "von" und "wo" aufgrund ihrer Einrückung im Code führende Leerzeichen. Wenn dieses Leerzeichen nicht gewünscht wird, müssen Sie wie jetzt verkettete Zeichenfolgen verwenden.


4
from # {table_names} würde in diesem Beispiel nicht funktionieren, da Sie% q {} verwendet haben. Es würde funktionieren, wenn Sie% q [] oder () verwenden würden
MatthewFord

2
Mein Favorit in diesem Sinne ist nur% {Super Multiline String mit Interpolationsunterstützung}
Duke

Von der %qFamilie erzeugte Zeichenfolgen enthalten die Zeilenumbrüche, die nicht dem ursprünglichen Code entsprechen.
Josh

29

Manchmal lohnt es sich, neue Zeilenzeichen zu entfernen \nwie:

conn.exec <<-eos.squish
 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

5
Dies ist Schienen basiert nicht Ruby
a14m

23

Sie können auch doppelte Anführungszeichen verwenden

x = """
this is 
a multiline
string
"""

2.3.3 :012 > x
 => "\nthis is\na multiline\nstring\n"

Verwenden Sie bei Bedarf zum Entfernen von Zeilenumbrüchen "\ n" den Backslash "\" am Ende jeder Zeile


5
Sie können das gleiche Ergebnis mit den einfachen doppelten Anführungszeichen erzielen. In Ruby gibt es keine dreifachen doppelten Anführungszeichen. Es interpretiert sie nur als "" + "double quotes with some content" + "".
Rakvium

Ja, aber "+" \ n hallo \ n "+" "Sieht komisch aus
juliangonzalez

1
Ja, es sieht komisch aus, und deshalb gibt es keinen Grund, zusätzliche doppelte Anführungszeichen hinzuzufügen, wenn Sie nur die einfachen doppelten Anführungszeichen mit demselben Ergebnis verwenden können.
Rakvium

Ja, ich meinte das Pluszeichen. Die doppelten Anführungszeichen ohne sie sehen gut aus, sind lesbar und leichter zu erkennen als ein einfaches Anführungszeichen, das für einzeilige Zeichenfolgen verwendet werden sollte.
Juliangonzalez

1
Ich meine, das "x"sieht einfach besser aus und funktioniert schneller als """x"""(was im Grunde das gleiche ist wie ""+"x"+"") oder """""x"""""(was das gleiche ist wie "" + "" + "x" + "" + ""). Es ist Ruby, nicht Python, wo Sie verwenden, """anstatt "wenn Sie eine mehrzeilige Zeichenfolge benötigen.
Rakvium

15
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

1
Wenn Sie heredoc ohne das '-' verwenden, wie in '<< - eos', werden die zusätzlichen Führungsfelder eingeschlossen. siehe Mark Byers 'Antwort.
Ives

heredoc enthält die Zeilenumbrüche, die nicht dem ursprünglichen Code entsprechen.
Josh

15

Andere Optionen:

#multi line string
multiline_string = <<EOM
This is a very long string
that contains interpolation
like #{4 + 5} \n\n
EOM

puts multiline_string

#another option for multiline string
message = <<-EOF
asdfasdfsador #{2+2} this month.
asdfadsfasdfadsfad.
EOF

puts message

1
Sollte ändern <<EOMzu <<-EOM, nicht wahr?
kingPuppy

Vielleicht schien es für mein <<-EOFBeispiel zu funktionieren . Ich vermute, dass so oder so funktioniert.
Alex Cohen

heredoc enthält die Zeilenumbrüche, die nicht dem ursprünglichen Code entsprechen.
Josh

11

Mit den neuen Funktionen in Ruby 2.3 können squiggly HEREDOCSie kürzlich unsere mehrzeiligen Zeichenfolgen mit einer minimalen Änderung auf eine nette Art und Weise schreiben. .squishWenn Sie diese in Kombination mit (wenn Sie Schienen verwenden) verwenden, können Sie mehrzeilig auf eine nette Art und Weise schreiben! bei Rubin nur verwenden, können Sie eine tun , <<~SQL.split.join(" ")das ist fast die gleiche

[1] pry(main)> <<~SQL.squish
[1] pry(main)*   select attr1, attr2, attr3, attr4, attr5, attr6, attr7
[1] pry(main)*   from table1, table2, table3, etc, etc, etc, etc, etc,
[1] pry(main)*   where etc etc etc etc etc etc etc etc etc etc etc etc etc
[1] pry(main)* SQL
=> "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"

ref: https://infinum.co/the-capsized-eight/multiline-strings-ruby-2-3-0-the-squiggly-heredoc


Quetschen ist Schienen, nicht Rubin
Josh

1
@ Josh, ja du hast recht, aktualisierte die Antwort, Prost.
Mark Jad

6
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'

<< ist der Verkettungsoperator für Zeichenfolgen


2
+ist der reguläre Verkettungsoperator, <<ist der In-Place- Append-Operator. Die Verwendung von Nebenwirkungen auf ein Literal funktioniert hier zufällig (die erste Zeichenfolge wird zweimal geändert und zurückgegeben), aber meiner Meinung nach ist es seltsam und bringt mich dazu, eine doppelte Aufnahme zu machen, wo +dies vollkommen klar wäre. Aber vielleicht bin ich neu bei Ruby ...
Beni Cherniavsky-Paskin

Dies wird nicht funktionieren, wenn frozen_string_literalaktiviert ist
Raido

6

Wenn Sie tun Geist zusätzliche Leerzeichen und Zeilenumbrüche, können Sie

conn.exec %w{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} * ' '

(Verwenden Sie% W für interpolierte Zeichenfolgen)


Ich mag dieses sehr, weil es viel mehr Kombinationen der Verwendung erlaubt.
schmijos

1
Dadurch werden mehrere benachbarte Felder zu einem zusammengedrückt. (Das Quetschen von Newline + nach dem Einrücken ist hier ein Sieg, aber in der Mitte der Linie könnte es überraschend sein.)
Beni Cherniavsky-Paskin

5

Um zu vermeiden, dass die Klammern für jede Zeile geschlossen werden, können Sie einfach doppelte Anführungszeichen mit einem Backslash verwenden, um die neue Zeile zu umgehen:

"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"

Dies ist eine der wenigen Antworten auf dieser Seite, die die Frage tatsächlich beantwortet!
Josh

4
conn.exec [
  "select attr1, attr2, attr3, ...",
  "from table1, table2, table3, ...",
  "where ..."
].join(' ')

Dieser Vorschlag hat gegenüber Dokumenten und langen Zeichenfolgen den Vorteil, dass automatische Einrückungen jeden Teil der Zeichenfolge entsprechend einrücken können. Aber es kommt zu Effizienzkosten.


@Aidan, Sie können die Kommas durch Backslashes (a la C) ersetzen, und es wird kein Join (oder Array) benötigt: Der Interpreter verkettet die Strings zur (meiner Meinung nach) Analysezeit, was sie im Vergleich zu den meisten Alternativen ziemlich schnell macht . Ein Vorteil des Verbindens einer Reihe von Zeichenfolgen besteht jedoch darin, dass einige automatische Einrückungen eine bessere Arbeit leisten als beispielsweise mit Zeichenfolgen, die hier dokumentiert sind, oder mit \.
Wayne Conrad

1
Ein Hinweis: Die Heredoc-Syntax << - ermöglicht einen entsprechenden Einzug.
A. Wilson

3

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.


1

Elegante Antwort heute:

<<~TEXT
Hi #{user.name}, 

Thanks for raising the flag, we're always happy to help you.
Your issue will be resolved within 2 hours.
Please be patient!

Thanks again,
Team #{user.organization.name}
TEXT

Es gibt einen Unterschied in <<-TEXTund <<~TEXT, erstere behält den Abstand innerhalb des Blocks bei und letztere nicht.

Es gibt auch andere Optionen. Wie Verkettung usw., aber diese ist im Allgemeinen sinnvoller.

Wenn ich mich hier irre, lass es mich wissen ...


heredoc enthält die Zeilenumbrüche, die nicht dem ursprünglichen Code entsprechen.
Josh

1

Wie Sie habe auch ich nach einer Lösung gesucht, die keine Zeilenumbrüche enthält . (Während sie in SQL sicher sind, sind sie in meinem Fall nicht sicher und ich habe einen großen Textblock zu bearbeiten)

Dies ist wohl genauso hässlich, aber Sie können Zeilenumbrüche in einem Heredoc rückgängig machen, um sie aus der resultierenden Zeichenfolge zu entfernen:

conn.exec <<~END_OF_INPUT
    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
  END_OF_INPUT

Beachten Sie, dass dies ohne Interpolation (IE <<~'END_OF_INPUT') nicht möglich ist. Seien Sie also vorsichtig. #{expressions}werden hier ausgewertet, während sie nicht in Ihrem Originalcode enthalten sind. A. Wilsons Antwort könnte aus diesem Grund besser sein.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.