Ruby: Kann ich mehrzeilige Zeichenfolgen ohne Verkettung schreiben?

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?

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"

In Ruby 2.0 können Sie jetzt einfach verwenden %

Zum Beispiel:

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

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

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.

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

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

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

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

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

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

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)

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"

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.

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.

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

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.