Mengapa operator shovel (<<) lebih disukai daripada plus-sama (+ =) saat membuat string di Ruby?

Saya bekerja melalui Ruby Koans.

The test_the_shovel_operator_modifies_the_original_stringKoan di about_strings.rb termasuk komentar berikut:

Pemrogram Ruby cenderung lebih menyukai operator shovel (<<) daripada operator plus sama dengan (+ =) saat membangun string. Mengapa?

Dugaan saya adalah ini melibatkan kecepatan, tetapi saya tidak mengerti aksi di bawah kap yang akan menyebabkan operator shovel lebih cepat.

Apakah seseorang dapat menjelaskan detail di balik preferensi ini?

Bukti:

a = 'foo'
a.object_id #=> 2154889340
a << 'bar'
a.object_id #=> 2154889340
a += 'quux'
a.object_id #=> 2154742560

Jadi <<ubah string asli daripada membuat yang baru. Alasan untuk ini adalah bahwa dalam ruby a += badalah singkatan sintaksis untuk a = a + b(yang sama berlaku untuk <op>=operator lain ) yang merupakan tugas. Di sisi lain <<adalah alias concat()yang mengubah penerima di tempat.

Bukti kinerja:

#!/usr/bin/env ruby

require 'benchmark'

Benchmark.bmbm do |x|
  x.report('+= :') do
    s = ""
    10000.times { s += "something " }
  end
  x.report('<< :') do
    s = ""
    10000.times { s << "something " }
  end
end

# Rehearsal ----------------------------------------
# += :   0.450000   0.010000   0.460000 (  0.465936)
# << :   0.010000   0.000000   0.010000 (  0.009451)
# ------------------------------- total: 0.470000sec
# 
#            user     system      total        real
# += :   0.270000   0.010000   0.280000 (  0.277945)
# << :   0.000000   0.000000   0.000000 (  0.003043)

Seorang teman yang mempelajari Ruby sebagai bahasa pemrograman pertamanya bertanya kepada saya pertanyaan yang sama saat ini melalui Strings in Ruby pada seri Ruby Koans. Saya menjelaskannya kepadanya menggunakan analogi berikut;

Anda memiliki segelas air yang setengah penuh dan Anda perlu mengisi ulang gelas Anda.

Cara pertama Anda melakukannya dengan mengambil gelas baru, mengisinya setengah dengan air dari keran dan kemudian menggunakan gelas setengah penuh kedua ini untuk mengisi gelas minum Anda. Anda melakukan ini setiap kali Anda perlu mengisi ulang gelas Anda.

Cara kedua Anda mengambil setengah gelas penuh dan isi ulang dengan air langsung dari keran.

Pada akhir hari, Anda akan memiliki lebih banyak kacamata untuk dibersihkan jika Anda memilih untuk mengambil gelas baru setiap kali Anda perlu mengisi ulang gelas Anda.

Hal yang sama berlaku untuk operator shovel dan operator plus sama. Ditambah lagi operator yang sama mengambil 'gelas' baru setiap kali perlu mengisi ulang gelasnya sementara operator shovel hanya mengambil gelas yang sama dan mengisinya kembali. Pada akhirnya, lebih banyak koleksi 'gelas' untuk operator setara Plus.

Ini adalah pertanyaan lama, tetapi saya hanya berlari melewatinya dan saya tidak sepenuhnya puas dengan jawaban yang ada. Ada banyak poin bagus tentang shovel << lebih cepat daripada concatenation + =, tetapi ada juga pertimbangan semantik.

Jawaban yang diterima dari @noodl menunjukkan bahwa << memodifikasi objek yang ada di tempatnya, sedangkan + = membuat objek baru. Jadi, Anda perlu mempertimbangkan apakah Anda ingin semua referensi ke string mencerminkan nilai baru, atau apakah Anda ingin meninggalkan referensi yang ada sendirian dan membuat nilai string baru untuk digunakan secara lokal. Jika Anda membutuhkan semua referensi untuk mencerminkan nilai yang diperbarui, maka Anda perlu menggunakan <<. Jika Anda ingin meninggalkan referensi lain sendirian, maka Anda perlu menggunakan + =.

Kasus yang sangat umum adalah hanya ada satu referensi ke string. Dalam hal ini, perbedaan semantik tidak masalah dan itu wajar untuk memilih << karena kecepatannya.

Karena lebih cepat / tidak membuat salinan string <-> pengumpul sampah tidak perlu dijalankan.

Meskipun sebagian besar jawaban mencakup +=lebih lambat karena membuat salinan baru, penting untuk diingat bahwa +=dan << tidak dapat dipertukarkan! Anda ingin menggunakan masing-masing dalam kasus yang berbeda.

Menggunakan <<juga akan mengubah variabel apa pun yang diarahkan b. Di sini kita juga bermutasi aketika kita mungkin tidak mau.

2.3.1 :001 > a = "hello"
 => "hello"
2.3.1 :002 > b = a
 => "hello"
2.3.1 :003 > b << " world"
 => "hello world"
2.3.1 :004 > a
 => "hello world"

Karena +=membuat salinan baru, itu juga meninggalkan variabel apa pun yang menunjuk ke sana tidak berubah.

2.3.1 :001 > a = "hello"
 => "hello"
2.3.1 :002 > b = a
 => "hello"
2.3.1 :003 > b += " world"
 => "hello world"
2.3.1 :004 > a
 => "hello"

Memahami perbedaan ini dapat menghemat banyak sakit kepala saat Anda berurusan dengan loop!

Meskipun bukan jawaban langsung untuk pertanyaan Anda, mengapa The Fully Upturned Bin selalu menjadi salah satu artikel Ruby favorit saya. Ini juga berisi beberapa info tentang string terkait dengan pengumpulan sampah.