Concaténation de chaînes en Ruby

Je recherche une manière plus élégante de concaténer des cordes en Ruby.

J'ai la ligne suivante:

source = "#{ROOT_DIR}/" << project << "/App.config"

Existe-t-il une meilleure façon de procéder?

Et d'ailleurs, quelle est la différence entre <<et +?

Vous pouvez le faire de plusieurs manières:

1. Comme vous l'avez montré avec <<mais ce n'est pas la manière habituelle

2. Avec interpolation de chaîne

   source = "#{ROOT_DIR}/#{project}/App.config"

3. avec +

   source = "#{ROOT_DIR}/" + project + "/App.config"

La deuxième méthode semble être plus efficace en termes de mémoire / vitesse par rapport à ce que j'ai vu (non mesuré cependant). Les trois méthodes génèrent une erreur constante non initialisée lorsque ROOT_DIR est nul.

Lorsque vous traitez des noms de chemin, vous pouvez utiliser File.join pour éviter de gâcher le séparateur de nom de chemin.

Au final, c'est une question de goût.

le + opérateur est le choix de concaténation normal et est probablement le moyen le plus rapide de concaténer des chaînes.

La différence entre +et <<est que <<change l'objet sur son côté gauche, et +ne change pas.

irb(main):001:0> s = 'a'
=> "a"
irb(main):002:0> s + 'b'
=> "ab"
irb(main):003:0> s
=> "a"
irb(main):004:0> s << 'b'
=> "ab"
irb(main):005:0> s
=> "ab"

Si vous ne faites que concaténer des chemins, vous pouvez utiliser la méthode File.join de Ruby.

source = File.join(ROOT_DIR, project, 'App.config')

depuis http://greyblake.com/blog/2012/09/02/ruby-perfomance-tricks/

Utiliser <<aka concatest beaucoup plus efficace que +=, car ce dernier crée un objet temporel et remplace le premier objet par le nouvel objet.

require 'benchmark'

N = 1000
BASIC_LENGTH = 10

5.times do |factor|
  length = BASIC_LENGTH * (10 ** factor)
  puts "_" * 60 + "\nLENGTH: #{length}"

  Benchmark.bm(10, '+= VS <<') do |x|
    concat_report = x.report("+=")  do
      str1 = ""
      str2 = "s" * length
      N.times { str1 += str2 }
    end

    modify_report = x.report("<<")  do
      str1 = "s"
      str2 = "s" * length
      N.times { str1 << str2 }
    end

    [concat_report / modify_report]
  end
end

production:

____________________________________________________________
LENGTH: 10
                 user     system      total        real
+=           0.000000   0.000000   0.000000 (  0.004671)
<<           0.000000   0.000000   0.000000 (  0.000176)
+= VS <<          NaN        NaN        NaN ( 26.508796)
____________________________________________________________
LENGTH: 100
                 user     system      total        real
+=           0.020000   0.000000   0.020000 (  0.022995)
<<           0.000000   0.000000   0.000000 (  0.000226)
+= VS <<          Inf        NaN        NaN (101.845829)
____________________________________________________________
LENGTH: 1000
                 user     system      total        real
+=           0.270000   0.120000   0.390000 (  0.390888)
<<           0.000000   0.000000   0.000000 (  0.001730)
+= VS <<          Inf        Inf        NaN (225.920077)
____________________________________________________________
LENGTH: 10000
                 user     system      total        real
+=           3.660000   1.570000   5.230000 (  5.233861)
<<           0.000000   0.010000   0.010000 (  0.015099)
+= VS <<          Inf 157.000000        NaN (346.629692)
____________________________________________________________
LENGTH: 100000
                 user     system      total        real
+=          31.270000  16.990000  48.260000 ( 48.328511)
<<           0.050000   0.050000   0.100000 (  0.105993)
+= VS <<   625.400000 339.800000        NaN (455.961373)

Étant donné que c'est un chemin, j'utiliserais probablement un tableau et une jointure:

source = [ROOT_DIR, project, 'App.config'] * '/'

Voici une autre référence inspirée de cet essentiel . Il compare la concaténation ( +), l'ajout ( <<) et l'interpolation ( #{}) pour les chaînes dynamiques et prédéfinies.

require 'benchmark'

# we will need the CAPTION and FORMAT constants:
include Benchmark

count = 100_000


puts "Dynamic strings"

Benchmark.benchmark(CAPTION, 7, FORMAT) do |bm|
  bm.report("concat") { count.times { 11.to_s +  '/' +  12.to_s } }
  bm.report("append") { count.times { 11.to_s << '/' << 12.to_s } }
  bm.report("interp") { count.times { "#{11}/#{12}" } }
end


puts "\nPredefined strings"

s11 = "11"
s12 = "12"
Benchmark.benchmark(CAPTION, 7, FORMAT) do |bm|
  bm.report("concat") { count.times { s11 +  '/' +  s12 } }
  bm.report("append") { count.times { s11 << '/' << s12 } }
  bm.report("interp") { count.times { "#{s11}/#{s12}"   } }
end

production:

Dynamic strings
              user     system      total        real
concat    0.050000   0.000000   0.050000 (  0.047770)
append    0.040000   0.000000   0.040000 (  0.042724)
interp    0.050000   0.000000   0.050000 (  0.051736)

Predefined strings
              user     system      total        real
concat    0.030000   0.000000   0.030000 (  0.024888)
append    0.020000   0.000000   0.020000 (  0.023373)
interp    3.160000   0.160000   3.320000 (  3.311253)

Conclusion: l'interpolation en IRM est lourde.

Je préfère utiliser Pathname:

require 'pathname' # pathname is in stdlib
Pathname(ROOT_DIR) + project + 'App.config'

sur <<et à +partir de ruby ​​docs:

+: Renvoie une nouvelle chaîne contenant other_str concaténée à str

<<: Concatène l'objet donné à str. Si l'objet est un Fixnum compris entre 0 et 255, il est converti en caractère avant la concaténation.

donc la différence est dans ce qui devient le premier opérande ( <<fait des changements sur place, +retourne une nouvelle chaîne donc c'est de la mémoire plus lourde) et ce qui sera si le premier opérande est Fixnum ( <<ajoutera comme s'il s'agissait d'un caractère avec un code égal à ce nombre, +augmentera Erreur)

Permettez-moi de vous montrer toute mon expérience avec cela.

J'ai eu une requête qui a retourné 32k d'enregistrements, pour chaque enregistrement, j'ai appelé une méthode pour formater cet enregistrement de base de données dans une chaîne formatée et ensuite la concaténer en une chaîne qui, à la fin de tout ce processus, se transformera en un fichier sur le disque.

Mon problème était que d'après le dossier, vers 24k, le processus de concaténation de la chaîne s'est avéré douloureux.

Je faisais cela en utilisant l'opérateur "+" normal.

Quand je suis passé au «<<», c'était comme par magie. C'était vraiment rapide.

Donc, je me suis souvenu de mes vieux temps - en quelque sorte 1998 - quand j'utilisais Java et concaténais String en utilisant '+' et que je passais de String à StringBuffer (et maintenant nous, développeur Java, avons StringBuilder).

Je crois que le processus de + / << dans le monde Ruby est le même que + / StringBuilder.append dans le monde Java.

Le premier réalloue l'objet entier en mémoire et l'autre pointe simplement vers une nouvelle adresse.

Concaténation vous dites? Et la #concatméthode alors?

a = 'foo'
a.object_id #=> some number
a.concat 'bar' #=> foobar
a.object_id #=> same as before -- string a remains the same object

En toute équité, concatest alias comme <<.

Voici d'autres façons de procéder:

"String1" + "String2"

"#{String1} #{String2}"

String1<<String2

Etc ...

Vous pouvez également utiliser %comme suit:

source = "#{ROOT_DIR}/%s/App.config" % project

Cette approche fonctionne également avec les 'guillemets (simples).

Vous pouvez utiliser +ou <<opérateur, mais dans la .concatfonction rubis est la plus préférable, car elle est beaucoup plus rapide que les autres opérateurs. Vous pouvez l'utiliser comme.

source = "#{ROOT_DIR}/".concat(project.concat("/App.config"))

La situation est importante, par exemple:

# this will not work
output = ''

Users.all.each do |user|
  output + "#{user.email}\n"
end
# the output will be ''
puts output

# this will do the job
output = ''

Users.all.each do |user|
  output << "#{user.email}\n"
end
# will get the desired output
puts output

Dans le premier exemple, la concaténation avec l' +opérateur ne mettra pas à jour l' outputobjet, cependant, dans le deuxième exemple, l' <<opérateur mettra à jour l' outputobjet à chaque itération. Donc, pour le type de situation ci-dessus, <<c'est mieux.

Vous pouvez concaténer directement dans la définition de chaîne:

nombre_apellido = "#{customer['first_name']} #{customer['last_name']} #{order_id}"

Pour votre cas particulier, vous pouvez également utiliser Array#joinlors de la construction du type de chaîne de chemin de fichier:

string = [ROOT_DIR, project, 'App.config'].join('/')]

Cela a un effet secondaire agréable de convertir automatiquement différents types en chaîne:

['foo', :bar, 1].join('/')
=>"foo/bar/1"

Pour les marionnettes:

$username = 'lala'
notify { "Hello ${username.capitalize}":
    withpath => false,
}