À propos de la connexion

Étonnamment, ruby a une concaténation de chaînes avec une grammaire similaire à C.

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

Puisque String # + est (je pense) un appel de méthode quoi qu'il arrive, la concaténation de chaînes est significative en termes d'efficacité d'exécution. Ce n'est pas le cas avec Java ou (probablement) perl.

alors.

Je ne peux pas écrire de parenthèses car le résultat de la concaténation est littéral et la concaténation elle-même n'est pas une opération.

p( ( "x" )"Y" ) #=> SyntaxError: unexpected ')',Ce qui suit est omis

Cette zone est la même que C / C ++.

De plus, puisque la concaténation n'est pas une opération, elle a une priorité plus élevée que n'importe quel opérateur.

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

Ce point est le même que C / C ++.

Divers littéraux

Contrairement à C / C ++, ruby a plusieurs chaînes.

p( ?x 'Y' ) #=> "xY"
p( 'x' ?Y ) #=> SyntaxError: unexpected ')', expecting ':'
p( %Q!x! "Y" ) #=> "xY"
p( 'x' %Q!Y! ) #=> SyntaxError: unexpected tFID,(Ce qui suit est omis)

Cela dépend de la commande. S'il y a un «?» Ou «%» après la chaîne, cela ressemblera à un opérateur.

La même chose s'applique aux documents ici

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

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

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

p( "x" <<HOGE ) #=> NameError: uninitialized constant HOGE
Y
HOGE
#=>NameError avec Y et HOGE: uninitialized constant

Pour Groovy

Au fait. Dans groovy, écrire quelque chose qui ressemble à une concaténation de chaînes est un appel de méthode.

"print" "x" //Sortie "x"

Pour Python

Grâce à ciel, j'ai découvert que python avait aussi une connexion, alors je l'ai étudié.

#coding:utf-8
from pprint import pprint

#Les guillemets doubles, simples et triples sont liés sans distinction.
pprint( "x" "Y" ) #=> 'xY'
pprint( "x" 'Y' ) #=> 'xY'
pprint( "x" """Y""" ) #=> 'xY'
pprint( """x""" 'Y' ) #=> 'xY'
pprint( '''x''' """Y""" ) #=> 'xY'

#u dans le préfixe est valide s'il est attaché à l'un quelconque.
#C requis pour tous/C++Est différent.
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 dans le préfixe n'est valide que pour ceux avec.
# C++Je pense que cela fonctionne de la même manière que R en 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'

J'ai été surpris que python ait une concaténation de chaînes en premier lieu. Il est encore plus surprenant que vous n'ayez besoin que d'un des préfixes ʻu`s.

Pour la langue D

Comme le langage D est fortement influencé par C / C ++, j'ai pensé qu'il y aurait quand même une concaténation, et je l'ai trouvé. Mais quand je pensais que ce serait la même règle que C / C ++, c'était un peu différent. Pour plus d'informations http://www.kmonos.net/alang/d/lex.html vérification ...

Pour citer les points importants:

Les chaînes connectées par l'opérateur ~ ou simplement écrites côte à côte sont combinées:

Et cela. Cependant, il y a une différence entre la connexion avec «~» et la connexion avec un vide.

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

Sera.

Recrutement lâche: Langages avec des chaînes concaténées (autres que C / C ++ / ruby / python / D)

Article de référence

tbpgr "Ruby | Méthodes de jointure standard et non standard pour les chaînes littérales" http://qiita.com/tbpgr/items/08014f867f7d8cc1200f