Ruby: Tôi có thể viết chuỗi nhiều dòng không có nối không?


397

Có cách nào để làm cho cái nhìn này tốt hơn một chút?

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'

Giống như, có cách nào để ám chỉ sự kết hợp?


28
Hãy cẩn thận về các cuộc tấn công tiêm SQL. :)
Roy Tinker

Câu trả lời:


595

Có những phần cho câu trả lời này đã giúp tôi có được những gì tôi cần (ghép nối nhiều dòng dễ dàng mà không có khoảng trắng thừa), nhưng vì không có câu trả lời thực tế nào có nó, tôi đang biên dịch chúng ở đây:

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"

Là một phần thưởng, đây là một phiên bản sử dụng cú pháp HEREDOC vui nhộn (thông qua liên kết này ):

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

Điều thứ hai chủ yếu sẽ là cho các tình huống đòi hỏi linh hoạt hơn trong xử lý. Cá nhân tôi không thích nó, nó đặt quá trình xử lý ở một nơi kỳ lạ, viết chuỗi (tức là ở phía trước của nó, nhưng sử dụng các phương thức cá thể thường xuất hiện sau đó), nhưng nó ở đó. Lưu ý rằng nếu bạn thụt END_SQLđịnh danh cuối cùng (thường gặp, vì đây có thể là bên trong một hàm hoặc mô-đun), bạn sẽ cần sử dụng cú pháp gạch nối (nghĩa là p <<-END_SQLthay vì p <<END_SQL). Mặt khác, khoảng trắng thụt lề làm cho mã định danh được hiểu là sự tiếp nối của chuỗi.

Điều này không tiết kiệm nhiều thao tác gõ, nhưng nó trông đẹp hơn so với sử dụng dấu +, với tôi.

Ngoài ra (tôi nói trong một chỉnh sửa, vài năm sau), nếu bạn đang sử dụng Ruby 2.3+, toán tử << ~ cũng có sẵn , loại bỏ thụt lề bổ sung khỏi chuỗi cuối cùng. Bạn sẽ có thể loại bỏ .gsublời gọi, trong trường hợp đó (mặc dù nó có thể phụ thuộc vào cả thụt đầu dòng và nhu cầu cuối cùng của bạn).

EDIT: Thêm một:

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

2
Đây là một câu hỏi cũ NHƯNG có một lỗi trong câu trả lời hoặc đã có một sự thay đổi trong cú pháp kể từ đó. p <<END_SQLnên p <<-END_SQLNếu đây là câu trả lời. tùy ý bạn có thể loại bỏ khoảng trắng hàng đầu với toán tử HEREDOC nguệch ngoạc,<<~END_SQL
jaydel

Đó chỉ là một lỗi nếu số nhận dạng kết thúc được thụt lề (dấu gạch nối cho trình thông dịch viên ruby ​​cắt bớt khoảng trắng trước khi xác định số nhận dạng kết thúc). Tôi có thể đặt một ghi chú đề cập đến điều đó, mặc dù. Ngoài ra, ~ là không cần thiết, gsub \ s + và dải đã xóa khoảng trắng hàng đầu.
A. Wilson

Thêm <<~vào câu trả lời sẽ tốt đẹp, cuối cùng đã nghiên cứu nó từ đó. Cá nhân, tôi sử dụng <<~MSG.strip ... MSGmà cũng dải cuối cùng \n.
Qortex

1
Khi tôi viết câu trả lời này (chín năm trước, sheesh!), Ruby đã ở trên 1.9 và << ~ (hiển nhiên) không được giới thiệu cho đến 2.3. Dù sao, lịch sử cổ đại sang một bên, tôi sẽ đặt nó vào, cảm ơn vì đã đưa nó lên.
A. Wilson

Cảm ơn bạn đã là một trong số ít câu trả lời không thêm dòng mới, đó là điều tôi đã cố gắng tránh khi tôi tìm thấy câu hỏi này.
Josh

174

Trong ruby ​​2.0 bây giờ bạn có thể chỉ cần sử dụng %

Ví dụ:

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

14
Hoạt động trong Ruby 1.9.3 cũng vậy.
Andy Stewart

26
Một chuỗi được tạo với cú pháp này sẽ bao gồm cả dòng mới và bất kỳ sự chú ý nào được thêm vào các dòng tiếp theo.
James

Điều này thậm chí còn tốt hơn << EOT ...... EOT (tài liệu ở đây)! nó cũng không nội suy nếu cần.
Nasser

1
@Nasser Một heredoc cũng nội suy.
Vụ kiện của Quỹ Monica

3
Nếu sử dụng Rails gọi squishtrên đầu ra sẽ hữu ích.
Jignesh Gohel

167

Có, nếu bạn không phiền những dòng mới được thêm vào:

 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'

Ngoài ra, bạn có thể sử dụng một di sả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

87
Bạn cũng có thể sử dụng%Q(...)
BaroqueBobcat

3
@Zombie: Dòng mới thường được cho phép trong các câu lệnh SQL và chỉ được coi là khoảng trắng thông thường.
Mark Byers

2
xem câu trả lời của tôi dưới đây để biết ví dụ, bạn chỉ có thể sử dụng% ngay bây giờ.
Robbie Guilfoyle

4
Bạn cũng có thể sử dụng%(...)
zero-divisor

1
Một điều quan trọng cần ghi nhớ nếu bạn cố tình thêm khoảng trắng theo dõi và sử dụng một trong những giải pháp này là trình soạn thảo của bạn có thể tự động xóa không gian dấu khi lưu tệp. Mặc dù tôi thường thích hành vi này, nó đã gây ra sự cố không mong muốn cho tôi một vài lần. Một giải pháp là viết chuỗi nhiều dòng của bạn giống như cách OP đã làm trong câu hỏi.
Dennis

50

Có nhiều cú pháp cho các chuỗi nhiều dòng như bạn đã đọc. Yêu thích của tôi là phong cách 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}

Chuỗi nhiều dòng bắt đầu bằng% q, theo sau là {, [hoặc (và sau đó được chấm dứt bởi ký tự đảo ngược tương ứng.% Q không cho phép nội suy;% Q làm như vậy bạn có thể viết những thứ như thế này:

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}

Tôi thực sự không biết làm thế nào các loại chuỗi đa dòng này được gọi như vậy, vì vậy hãy gọi chúng là đa dòng Perl.

Tuy nhiên, xin lưu ý rằng cho dù bạn sử dụng đa tuyến Perl hay heredocs như Mark và Peter đã đề xuất, bạn sẽ kết thúc với các khoảng trắng không cần thiết. Cả trong ví dụ của tôi và ví dụ của họ, các dòng "từ" và "ở đâu" đều chứa các khoảng trắng hàng đầu vì sự thụt dòng của chúng trong mã. Nếu khoảng trắng này không mong muốn thì bạn phải sử dụng các chuỗi nối như bạn đang làm bây giờ.


4
từ # {table_names} sẽ không hoạt động trong ví dụ này, vì bạn đã sử dụng% q {}, nó sẽ hoạt động nếu bạn sử dụng% q [] hoặc ()
MatthewFord

2
Yêu thích của tôi trong tĩnh mạch này chỉ là% {chuỗi siêu đa dòng có hỗ trợ nội suy}
Duke

các chuỗi được tạo ra từ %qgia đình sẽ bao gồm các dòng mới không tương đương với mã gốc.
Josh

29

Đôi khi có giá trị để xóa các ký tự dòng mới \nnhư:

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
đây là đường ray không dựa trên ruby
a14m

23

Bạn cũng có thể sử dụng dấu ngoặc kép

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

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

Nếu cần để xóa ngắt dòng "\ n", hãy sử dụng dấu gạch chéo ngược "\" ở cuối mỗi dòng


5
Bạn có thể đạt được kết quả tương tự với dấu ngoặc kép số ít. Không có những thứ như ba dấu ngoặc kép trong Ruby. Nó chỉ diễn giải chúng là "" + "double quotes with some content" + "".
rakvium

Vâng, nhưng `" "+" \ n xin chào \ n "+" "Trông có vẻ lạ
juliangonzalez

1
Vâng, nó có vẻ kỳ lạ, và đây là lý do tại sao không có lý do để thêm dấu ngoặc kép khi bạn chỉ có thể sử dụng dấu ngoặc kép số ít với cùng kết quả.
rakvium

Vâng, tôi có nghĩa là dấu cộng. Các trích dẫn kép mà không có vẻ tốt, dễ đọc và dễ phát hiện hơn thay vì một trích dẫn duy nhất, nên được sử dụng trên các chuỗi đơn.
juliangonzalez

1
Tôi có nghĩa là chỉ "x"trông tốt hơn và hoạt động nhanh hơn """x"""(về cơ bản là giống như ""+"x"+"") hoặc """""x"""""(giống như "" + "" + "x" + "" + ""). Đó là Ruby, không phải Python, nơi bạn sử dụng """thay vì "khi bạn cần một chuỗi nhiều dòng.
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
sử dụng heredoc mà không có '-', như trong '<< - eos', sẽ bao gồm các không gian lãnh đạo bổ sung. xem phản hồi của Mark Byers.
ives

heredoc sẽ bao gồm các dòng mới không tương đương với mã gốc.
Josh

15

Sự lựa chọn khác:

#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
Có nên đổi <<EOMsang <<-EOMkhông?
kingPuppy

Có lẽ, nó dường như làm việc cho <<-EOFví dụ của tôi . Tôi đoán là một trong hai cách làm việc.
Alex Cohen

heredoc sẽ bao gồm các dòng mới không tương đương với mã gốc.
Josh

11

Gần đây với các tính năng mới trong Ruby 2.3, tính năng mới squiggly HEREDOCsẽ cho phép bạn viết các chuỗi đa dòng của chúng tôi một cách tốt đẹp với một sự thay đổi tối thiểu, vì vậy sử dụng kết hợp này với .squish(nếu bạn đang sử dụng đường ray) sẽ cho phép bạn viết nhiều dòng một cách hay! trong trường hợp chỉ sử dụng ruby, bạn có thể làm một <<~SQL.split.join(" ")cái gần giống nhau

[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


squish là đường ray, không phải ruby
Josh

1
@Josh, yeah bạn nói đúng, cập nhật câu trả lời, chúc mừng.
Đánh dấu

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'

<< là toán tử nối cho chuỗi


2
+là toán tử nối thường xuyên, <<là toán tử chắp thêm tại chỗ . Sử dụng các tác dụng phụ trên một nghĩa đen xảy ra ở đây (chuỗi đầu tiên được sửa đổi hai lần và trả lại) nhưng IMHO thật kỳ lạ và khiến tôi thực hiện gấp đôi, nơi +sẽ hoàn toàn rõ ràng. Nhưng có lẽ tôi chỉ mới biết về Ruby ...
Beni Cherniavsky-Paskin

Điều này sẽ không hoạt động nếu frozen_string_literalđược bật
Raido

6

Nếu bạn làm không gian thêm tinh thần và dòng mới, bạn có thể sử dụng

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

(sử dụng% W cho các chuỗi nội suy)


Tôi thích cái này rất nhiều vì nó cho phép kết hợp sử dụng nhiều hơn nữa.
schmijos

1
Điều này sẽ squish nhiều không gian liền kề thành một. (Squishing của dòng mới + sau khi thụt lề là một chiến thắng ở đây nhưng ở giữa dòng có thể gây ngạc nhiên.)
Beni Cherniavsky-Paskin

5

Để tránh việc đóng dấu ngoặc đơn cho mỗi dòng, bạn chỉ cần sử dụng dấu ngoặc kép với dấu gạch chéo ngược để thoát dòng mới:

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

Đây là một trong số ít câu trả lời trên trang này thực sự trả lời câu hỏi!
Josh

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

Đề xuất này có lợi thế hơn ở đây - tài liệu và chuỗi dài mà người dùng tự động thụt lề có thể thụt lề từng phần của chuỗi một cách thích hợp. Nhưng nó đi kèm với một chi phí hiệu quả.


@Aidan, Bạn có thể thay thế dấu phẩy bằng dấu gạch chéo ngược (a la C) và không cần nối (hoặc mảng): Trình thông dịch sẽ nối các chuỗi tại (tôi nghĩ) phân tích thời gian, làm cho nó khá nhanh so với hầu hết các lựa chọn thay thế . Tuy nhiên, một lợi thế của việc tham gia một chuỗi các chuỗi là một số trình tự động thụt lề hoạt động tốt hơn so với thực hiện, ví dụ, ở đây là chuỗi doc hoặc với \.
Wayne Conrad

1
Một lưu ý, cú pháp heredoc << - sẽ cho phép thụt lề thích hợp.
A. Wilson

3

Ruby-way (TM) kể từ Ruby 2.3: Sử dụng HEREDOC nguệch ngoạc <<~ để xác định chuỗi nhiều dòng với dòng mới và thụt lề thích hợp:

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

Nếu thụt lề thích hợp không phải là một mối quan tâm, thì dấu ngoặc đơn và dấu ngoặc kép có thể trải dài trên nhiều dòng trong 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..."

Nếu trích dẫn đơn hoặc kép là cồng kềnh vì điều đó sẽ cần nhiều lối thoát, thì ký hiệu chuỗi phần trăm % là giải pháp linh hoạt nhất:

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

Nếu mục đích là để tránh các dòng mới (mà cả HEREDOC nguệch ngoạc, trích dẫn và chuỗi phần trăm theo nghĩa đen sẽ gây ra), thì có thể sử dụng tiếp tục dòng bằng cách đặt dấu gạch chéo ngược \làm ký tự không khoảng trắng cuối cùng trong một dòng. Điều này sẽ tiếp tục dòng và sẽ khiến Ruby nối chuỗi trở lại (xem ra những khoảng trống bên trong chuỗi được trích dẫn):

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

Nếu bạn sử dụng Rails String.squishsẽ tách chuỗi không gian hàng đầu và dấu và thu gọn tất cả các khoảng trắng liên tiếp (dòng mới, tab và tất cả) vào một khoảng trắng:

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

Thêm chi tiết:

Cú pháp của Ruby HEREDOC

Ký hiệu tài liệu ở đây cho chuỗi hoạt động là một cách để chỉ định các khối văn bản dài trong mã. Nó được bắt đầu bằng <<theo sau bởi một chuỗi do người dùng định nghĩa (bộ kết thúc chuỗi kết thúc). Tất cả các dòng sau được nối cho đến khi kết thúc chuỗi kết thúc được tìm thấy ở đầu dòng:

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

Bộ kết thúc chuỗi kết thúc có thể được chọn tự do, nhưng thông thường sử dụng một cái gì đó như "EOS" (Kết thúc chuỗi) hoặc thứ gì đó phù hợp với miền của Chuỗi như "SQL".

HEREDOC hỗ trợ nội suy theo mặc định hoặc khi bộ kết thúc EOS được trích dẫn kép:

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

Nội suy có thể bị vô hiệu hóa nếu bộ kết thúc EOS được trích dẫn đơn:

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

Một hạn chế quan trọng của việc <<HEREDOCđó là bộ kết thúc Chuỗi kết thúc cần ở đầu dòng:

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

Để giải quyết vấn đề này, <<-cú pháp đã được tạo. Nó cho phép bộ kết thúc EOS được thụt lề để làm cho mã trông đẹp hơn. Các đường giữa bộ <<-kết thúc và EOS vẫn được sử dụng trong phần mở rộng đầy đủ của chúng bao gồm tất cả các vết lõm:

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

Kể từ Ruby 2.3, giờ đây chúng ta có HEREDOC nguệch ngoạc <<~loại bỏ khoảng trắng hàng đầu:

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"

Các dòng và dòng trống chỉ chứa các tab và khoảng trắng bị bỏ qua bởi << ~

puts <<~EOS.inspect 
  Hello

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

Nếu cả tab và khoảng trắng được sử dụng, các tab được coi là bằng 8 khoảng trắng. Nếu dòng thụt lề ít nhất ở giữa một tab, tab này sẽ không bị xóa.

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

HEREDOC có thể thực hiện một số nội dung điên rồ như thực thi các lệnh bằng cách sử dụng backticks:

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

Các định nghĩa Chuỗi HEREDOC có thể được "xếp chồng", điều đó có nghĩa là bộ kết thúc EOS đầu tiên (EOSFOO bên dưới) sẽ kết thúc chuỗi đầu tiên và bắt đầu chuỗi thứ hai (EOSebar bên dưới):

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

Tôi không nghĩ có ai từng sử dụng nó như vậy, nhưng <<EOSthực sự chỉ là một chuỗi theo nghĩa đen và có thể được đặt ở bất cứ nơi nào một chuỗi thường có thể được đặt:

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

Nếu bạn không có Ruby 2.3, nhưng Rails >=3.0 thì bạn có thể sử dụng String.strip_heredocnó giống như<<~

# 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

Phần trăm chuỗi ký tự

Xem RubyDoc về cách sử dụng các dấu hiệu tỷ lệ phần trăm theo sau là một chuỗi trong một cặp ngoặc đơn như một %(...), %[...],%{...} , vv hoặc một cặp bất kỳ ký tự chữ và số không như%+...+

Những từ cuối

Cuối cùng, để có được câu trả lời cho câu hỏi ban đầu "Có cách nào để ám chỉ sự kết hợp không?" đã trả lời: Ruby luôn ngụ ý nối nếu hai chuỗi (trích dẫn đơn và kép) được tìm thấy trở lại:

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

Thông báo trước là điều này không hoạt động trên các ngắt dòng, bởi vì Ruby đang diễn giải một kết thúc của câu lệnh và dòng kết quả của chỉ một chuỗi trên một dòng không làm gì cả.


1

Trả lời thanh lịch hôm nay:

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

Có một sự khác biệt trong <<-TEXT<<~TEXT , trước đây giữ lại khoảng cách bên trong khối và sau đó không.

Có những lựa chọn khác là tốt. Giống như nối, vv nhưng điều này có ý nghĩa hơn nói chung.

Nếu tôi sai ở đây, hãy cho tôi biết ...


heredoc sẽ bao gồm các dòng mới không tương đương với mã gốc.
Josh

1

Giống như bạn, tôi cũng đang tìm kiếm một giải pháp không bao gồm các dòng mới . (Mặc dù chúng có thể an toàn trong SQL, nhưng chúng không an toàn trong trường hợp của tôi và tôi có một khối lớn văn bản để giải quyết)

Điều này được cho là xấu xí, nhưng bạn có thể gạch chéo lại các dòng mới trong một di sản để bỏ qua chúng khỏi chuỗi kết quả:

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

Lưu ý rằng bạn không thể do điều này mà không có phép nội suy (IE <<~'END_OF_INPUT') vì vậy hãy cẩn thận. #{expressions}sẽ được đánh giá ở đây, trong khi chúng sẽ không nằm trong mã gốc của bạn. Câu trả lời của A. Wilson có thể tốt hơn cho lý do đó.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.