Ruby: Могу ли я написать многострочную строку без конкатенации?

Есть ли способ сделать это немного лучше?

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'

Мол, есть ли способ подразумевать конкатенацию?

В этом ответе есть кусочки, которые помогли мне получить то, что мне было нужно (простая многострочная конкатенация БЕЗ лишних пробелов), но поскольку ни один из реальных ответов не дал этого, я собираю их здесь:

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"

В качестве бонуса, вот версия с забавным синтаксисом HEREDOC (по этой ссылке ):

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

Последнее будет в основном для ситуаций, которые требуют большей гибкости при обработке. Мне лично это не нравится, оно помещает обработку в странное место по отношению к строке (то есть перед ней, но с использованием методов экземпляра, которые обычно идут после), но она есть. Обратите внимание, что если вы делаете отступ для последнего END_SQLидентификатора (который является общим, поскольку он, вероятно, находится внутри функции или модуля), вам нужно будет использовать синтаксис дефисов (то есть p <<-END_SQLвместо p <<END_SQL). В противном случае пробел с отступом приводит к тому, что идентификатор интерпретируется как продолжение строки.

Это не сильно экономит время при наборе текста, но для меня это выглядит лучше, чем использование знаков +.

Также (я говорю в редакции, несколько лет спустя), если вы используете Ruby 2.3+, также доступен оператор << ~ , который удаляет лишние отступы из конечной строки. В этом случае вы сможете удалить .gsubвызов (хотя это может зависеть как от начального отступа, так и от ваших конечных потребностей).

РЕДАКТИРОВАТЬ: Добавление еще одного:

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

В ruby ​​2.0 теперь можно просто использовать %

Например:

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

Да, если вы не возражаете против добавления новых строк:

 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'

В качестве альтернативы вы можете использовать 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

Есть несколько синтаксисов для многострочных строк, как вы уже прочитали. Мой любимый стиль Perl:

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}

Многострочная строка начинается с% q, за которым следует {, [или (, а затем заканчивается соответствующим обратным символом.% Q не допускает интерполяцию;% Q делает так, что вы можете написать что-то вроде этого:

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}

На самом деле я понятия не имею, как называются эти типы многострочных строк, поэтому давайте просто назовем их Perl multilines.

Однако обратите внимание, что независимо от того, используете ли вы Perl multilines или heredocs, как предлагали Марк и Питер, вы получите потенциально ненужные пробелы. И в моих примерах, и в их примерах строки «from» и «where» содержат начальные пробелы из-за их отступа в коде. Если этот пробел не нужен, вы должны использовать объединенные строки, как вы делаете сейчас.

Иногда стоит удалить символы новой строки, \nтакие как:

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

Вы также можете использовать двойные кавычки

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

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

Если необходимо удалить разрывы строк "\ n", используйте обратную косую черту "\" в конце каждой строки.

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

Другие опции:

#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

Недавно, с новыми функциями в Ruby 2.3, новая squiggly HEREDOCпозволит вам писать наши многострочные строки приятным способом с минимальными изменениями, поэтому использование этого в сочетании с .squish(если вы используете rails) позволит вам писать многострочные записи хорошим способом! в случае просто использования ruby, вы можете сделать, <<~SQL.split.join(" ")что почти то же самое

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

ссылка: https://infinum.co/the-capsized-eight/multiline-strings-ruby-2-3-0-the-squiggly-heroc

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'

<< - оператор конкатенации для строк

Если вы не возражаете против лишних пробелов и новых строк, вы можете использовать

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} * ' '

(используйте% 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"

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

Это предложение имеет преимущество перед документами и длинными строками, заключающееся в том, что авто-отступы могут соответствующим образом создавать отступ для каждой части строки. Но это происходит за счет эффективности.

Ruby-way (TM) начиная с Ruby 2.3: используйте волнистый 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..."

Если правильное отступление не имеет значения, одинарные и двойные кавычки могут занимать несколько строк в Ruby:

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

Если одинарные или двойные кавычки громоздки, потому что для этого потребуется много экранирования, то строковая литеральная нотация % является наиболее гибким решением:

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

Если цель состоит в том, чтобы избежать перехода на новую строку (что вызовет как волнистый HEREDOC, так и кавычки и строковый литерал процента), то можно использовать продолжение строки , поместив обратную косую черту \в качестве последнего непробельного символа в строке. Это продолжит строку и заставит Ruby объединить строки подряд (следите за пробелами внутри строки в кавычках):

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

Если вы используете Rails, то String.squishвы уберете строку начального и конечного пробелов и свернете все последовательные пробелы (переводы строк, табуляции и все) в один пробел:

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...attr7 from...etc, where..."

Больше деталей:

Рубиновый синтаксис HEREDOC

Работы Here Document Notation for Strings - это способ обозначить длинные блоки текста, встроенные в код. За ним <<следует пользовательская строка (терминатор конца строки). Все последующие строки объединяются до тех пор, пока терминатор конца строки не будет найден в самом начале строки:

puts <<HEREDOC 
Text Text Text Text
Bla Bla
HEREDOC
# -> "Text Text Text Text\nBlaBla"

Терминатор конца строки может быть выбран свободно, но обычно используется что-то вроде «EOS» (конец строки) или что-то, что соответствует домену строки, например «SQL».

HEREDOC поддерживает интерполяцию по умолчанию или когда терминатор EOS заключен в двойные кавычки:

price = 10
print <<"EOS"  # comments can be put here
1.) The price is #{price}.
EOS
# -> "1.) The price is 10."

Интерполяция может быть отключена, если терминатор EOS заключен в одинарные кавычки:

print <<'EOS' # Disabled interpolation
3.) The price is #{price}.
EOS
# -> "3.) The price is #{price}."

Одним из важных ограничений <<HEREDOCявляется то, что терминатор конца строки должен находиться в начале строки:

  puts <<EOS 
    def foo
      print "foo"
    end
  EOS
EOS
#-> "....def foo\n......print "foo"\n....end\n..EOS

Чтобы обойти это, <<-синтаксис был создан. Это позволяет использовать терминатор EOS, чтобы код выглядел лучше. Строки между <<-терминатором и EOS по-прежнему используются в полном объеме, включая все отступы:

puts <<-EOS # Use <<- to indent End of String terminator
  def foo
    print "foo"
  end
EOS
# -> "..def foo\n....print "foo"\n..end"

Начиная с Ruby 2.3, теперь у нас есть волнистый HEREDOC, <<~удаляющий начальные пробелы:

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"

Пустые строки и строки, содержащие только табуляции и пробел, игнорируются << ~

puts <<~EOS.inspect 
  Hello

    World!
EOS
#-> "Hello\n..World!"

Если используются и табуляция, и пробелы, табуляция считается равной 8 пробелам. Если строка с наименьшим отступом находится в середине вкладки, эта вкладка не удаляется.

puts <<~EOS.inspect
<tab>One Tab
<space><space>Two Spaces
EOS
# -> "\tOne Tab\nTwoSpaces"

HEREDOC может делать некоторые сумасшедшие вещи, такие как выполнение команд с помощью обратных галочек:

puts <<`EOC`            
echo #{price}
echo #{price * 2}
EOC

Определения строк HEREDOC могут быть «сложены», что означает, что первый терминатор EOS (EOSFOO ниже) завершит первую строку и начнет вторую (EOSBAR ниже):

print <<EOSFOO, <<EOSBAR    # you can stack them
I said foo.
EOSFOO
I said bar.
EOSBAR

Я не думаю, что кто-нибудь когда-либо будет использовать его как таковой, но на <<EOSсамом деле это просто строковый литерал, и его можно поместить везде, где обычно может быть строка:

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

Если у вас нет Ruby 2.3, но есть Rails >=3.0, вы можете использовать String.strip_heredocто же самое, что и<<~

# 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

Процентные строковые литералы

См RubyDoc о том , как использовать знак процента следуют строки в скобках пары , такие как %(...), %[...], %{...}и т.д. , или пару любого не алфавитно - цифровой символ , такие как%+...+

Последние слова

Наконец, чтобы получить ответ на оригинальный вопрос "Есть ли способ подразумевать конкатенацию?" ответил: Ruby всегда подразумевает конкатенацию, если две строки (одинарные и двойные в кавычках) встречаются вплотную:

puts "select..." 'from table...' "where..."
# -> "select...from table...where..."

Предостережение в том, что это не работает через разрывы строк, потому что Ruby интерпретирует конец оператора, а последовательная строка, состоящая только из одних строк в строке, ничего не делает.

Элегантный ответ сегодня:

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

Существует разница в <<-TEXTи <<~TEXT, первый сохраняет интервал внутри блока, а второй нет.

Есть и другие варианты. Как конкатенация и т. Д., Но в целом это имеет больше смысла.

Если я ошибаюсь, дайте мне знать, как ...

Как и вы, я также искал решение, которое не включает переводы строк . (Хотя они могут быть безопасны в SQL, в моем случае они небезопасны, и у меня есть большой блок текста, чтобы иметь дело с ним)

Возможно, это так же уродливо, но вы можете использовать обратную черту-обратную черту в heredoc, чтобы исключить их из полученной строки:

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

Обратите внимание, что вы не можете сделать это без интерполяции (IE <<~'END_OF_INPUT'), поэтому будьте осторожны. #{expressions}будет оцениваться здесь, тогда как они не будут в вашем исходном коде. Ответ А. Уилсона может быть лучше по этой причине.