Ruby에서 문자열을 작성할 때 삽 연산자 (<<)가 더하기 등호 (+ =)보다 선호되는 이유는 무엇입니까?

Ruby에서 문자열을 작성할 때 삽 연산자 (<<)가 더하기 등호 (+ =)보다 선호되는 이유는 무엇입니까?

---

Ruby Koans를 통해 작업하고 있습니다.

about_strings.rb 의 test_the_shovel_operator_modifies_the_original_stringKoan 은 다음 주석을 포함합니다.

루비 프로그래머는 문자열을 만들 때 삽 연산자 (+)보다 삽 연산자 (<<)를 선호하는 경향이 있습니다. 왜?

내 생각에는 속도가 관련되어 있지만 삽 작동자가 더 빠를 수있는 후드 아래의 동작을 이해하지 못합니다.

누군가이 환경 설정의 세부 사항을 설명 할 수 있습니까?

---

증명:

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

따라서 <<새 문자열을 작성하지 않고 원래 문자열을 변경하십시오. 그 이유는 루비 에서 과제 인 다른 a += b구문도 a = a + b마찬가지 <op>=입니다. 반면에 수신기를 제자리에서 변경 <<하는 별명이 concat()있습니다.

---

성능 증명 :

#!/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)

---

Ruby를 그의 첫 프로그래밍 언어로 배우고있는 친구가 Ruby Koans 시리즈에서 Ruby의 Strings를 살펴보면서 이와 같은 질문을했습니다. 나는 다음 비유를 사용하여 그에게 설명했다.

물이 반으로 가득 차면 유리를 다시 채워야합니다.

첫 번째 방법은 새 유리를 가져다가 수도꼭지에서 물을 반 정도 채우고 두 번째 반 전체 유리를 사용하여 마시는 유리를 채우는 것입니다. 유리를 리필해야 할 때마다이 작업을 수행하십시오.

두 번째 방법은 반 전체 유리를 가져 와서 수도꼭지에서 바로 물로 채우십시오.

하루가 끝나면 유리를 리필해야 할 때마다 새 유리를 선택하기로 선택하면 더 많은 안경을 청소해야합니다.

삽 연산자와 더하기 등 연산자에도 동일하게 적용됩니다. 또한 균등 작업자는 유리를 리필해야 할 때마다 새로운 '유리'를 선택하지만 삽 작업자는 동일한 유리를 사용하여 리필합니다. 하루가 끝나면 Plus equal operator를위한 더 많은 'glass'컬렉션이 있습니다.

---

이것은 오래된 질문이지만 방금 질문에 부딪 쳤으며 기존 답변에 완전히 만족하지 않습니다. 삽 <<이 연결 + =보다 빠르다는 점에는 좋은 점이 많이 있지만 의미 론적 고려 사항도 있습니다.

@noodl의 대답은 <<가 기존 개체를 수정하는 반면 + =는 새 개체를 생성한다는 것을 보여줍니다. 따라서 문자열에 대한 모든 참조가 새 값을 반영하도록 하려는지 또는 기존 참조를 그대로두고 로컬에서 사용할 새 문자열 값을 작성 하려는지 고려해야합니다. 업데이트 된 값을 반영하기 위해 모든 참조가 필요한 경우 <<를 사용해야합니다. 다른 참조를 그대로 두려면 + =을 사용해야합니다.

가장 일반적인 경우는 문자열에 대한 단일 참조 만 있다는 것입니다. 이 경우 시맨틱 차이는 중요하지 않으며 속도 때문에 <<를 선호하는 것이 당연합니다.

---

더 빠르거나 문자열의 복사본을 만들지 않기 때문에 <-> 가비지 수집기를 실행할 필요가 없습니다.

---

While a majority of answers cover += is slower because it creates a new copy, it's important to keep in mind that += and << are not interchangeable! You want to use each in different cases.

Using << will also alter any variables that are pointed to b. Here we also mutate a when we may not want to.

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"

Because += makes a new copy, it also leaves any variables that are pointing to it unchanged.

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"

Understanding this distinction can save you a lot of headaches when you're dealing with loops!

---

While not a direct answer to your question, why's The Fully Upturned Bin always has been one of my favorite Ruby articles. It also contains some info on strings in regards to garbage collection.

참고URL : https://stackoverflow.com/questions/4684446/why-is-the-shovel-operator-preferred-over-plus-equals-when-building-a