Über die Verbindung

Überraschenderweise hat Ruby eine String-Verkettung mit einer Grammatik ähnlich wie C.

p( "x" "Y" ) #=> "xY"
p( "x" 'Y' ) #=> "xY"
p( 'x' 'Y' ) #=> "xY"

Da "String # +" (glaube ich) ein Methodenaufruf ist, ist die Verkettung von Strings für die Laufzeiteffizienz von Bedeutung. Die Situation unterscheidet sich von Java und (wahrscheinlich) Perl.

damit.

Ich kann keine Klammern schreiben, da das Ergebnis der Verkettung wörtlich ist und die Verkettung selbst keine Operation ist.

p( ( "x" )"Y" ) #=> SyntaxError: unexpected ')',Folgendes wird weggelassen

Dieser Bereich entspricht C / C ++.

Da die Verkettung keine Operation ist, hat sie eine höhere Priorität als jeder andere Operator.

p( ! "x" "y" ) #=> false
p( "x" "y".size ) #=> 2
p( { "x" "y"=>"a" "b" } ) #=> {"xy"=>"ab"}

Dieser Punkt ist der gleiche wie in C / C ++.

Verschiedene Literale

Im Gegensatz zu C / C ++ hat Ruby verschiedene Zeichenfolgen.

p( ?x 'Y' ) #=> "xY"
p( 'x' ?Y ) #=> SyntaxError: unexpected ')', expecting ':'
p( %Q!x! "Y" ) #=> "xY"
p( 'x' %Q!Y! ) #=> SyntaxError: unexpected tFID,(Folgendes wird weggelassen)

Das hängt von der Reihenfolge ab. Wenn nach der Zeichenfolge ein "?" Oder "%" steht, sieht es wie ein Operator aus.

Gleiches gilt für hier Dokumente

p( <<"HOGE" "Y" ) #=> "x\nY"
x
HOGE

p( <<HOGE "Y" ) #=> "x\nY"
x
HOGE

p( "x" <<"HOGE" ) #=> "xHOGE"
Y
HOGE
#=>NameError mit Y und HOGE: uninitialized constant

p( "x" <<HOGE ) #=> NameError: uninitialized constant HOGE
Y
HOGE
#=>NameError mit Y und HOGE: uninitialized constant

Für Groovy

Apropos. In groovy ist das Schreiben von etwas, das wie eine Zeichenfolgenverkettung aussieht, ein Methodenaufruf.

"print" "x" //Ausgabe "x"

Für Python

Dank ciel habe ich herausgefunden, dass Python auch eine Verbindung hat, also habe ich es untersucht.

#coding:utf-8
from pprint import pprint

#Doppelte Anführungszeichen, einfache Anführungszeichen und dreifache Anführungszeichen sind ohne Unterschied miteinander verbunden.
pprint( "x" "Y" ) #=> 'xY'
pprint( "x" 'Y' ) #=> 'xY'
pprint( "x" """Y""" ) #=> 'xY'
pprint( """x""" 'Y' ) #=> 'xY'
pprint( '''x''' """Y""" ) #=> 'xY'

#u im Präfix ist gültig, wenn es an eine angehängt ist.
#C für alle erforderlich/C++Ist anders.
pprint( u'x' u'Y' ) #=>u'xY'
pprint( u'x' 'Y' ) #=>u'xY'
pprint( 'x' u'Y' ) #=>u'xY'
pprint( u'x' Ur'Y' ) #=>u'xY'
pprint( 'a' "b" '''c''' """d""" u'e' "f" '''g''' """i""" ) #=>u'abcdefgi'

#R im Präfix gilt nur für diejenigen mit.
# C++Ich denke, es funktioniert genauso wie R in 11.
pprint( '\x78' '\x59' ) #=>'xY'
pprint( R'\x78' '\x59' ) #=>'\\x78Y'
pprint( '\x78' R'\x59' ) #=>'x\\x59'
pprint( uR'\x78' R'\x59' ) #=>u'\\x78\\x59'
pprint( r'\x78' u'\x59' ) #=>u'\\x78Y'

Ich war überrascht, dass Python in erster Linie eine String-Verkettung hat. Es ist noch überraschender, dass Sie nur eines der Präfixe "u" benötigen.

Für D-Sprache

Da die D-Sprache stark von C / C ++ beeinflusst wird, dachte ich, dass es sowieso zu einer Verkettung kommen würde, und fand sie. Aber als ich dachte, es wäre die gleiche Regel wie in C / C ++, war es etwas anders. Für mehr Informationen http://www.kmonos.net/alang/d/lex.html Überprüfung ...

Um die wichtigen Punkte zu zitieren:

Zeichenfolgen, die vom Operator ~ verbunden oder einfach nebeneinander geschrieben werden, werden kombiniert:

Und das. Es gibt jedoch einen Unterschied zwischen der Verbindung mit ~ und der Verbindung mit einem Leerzeichen.

  writeln("Hel" "lo W" "orld!".length); //=> 12
  writeln("Hel"~"lo W"~"orld!".length); //=>Error

Wird sein.

Lose Rekrutierung: Sprachen mit verketteten Zeichenfolgen (außer C / C ++ / Ruby / Python / D)

Referenzartikel

tbpgr's "Ruby | Standard- und Nicht-Standard-Join-Methoden für String-Literale" http://qiita.com/tbpgr/items/08014f867f7d8cc1200f