Dlaczego łączenie łańcuchów jest szybsze niż łączenie tablic?

Firefox jest szybki, ponieważ używa czegoś o nazwie liny (liny: alternatywa dla ciągów ). Lina jest w zasadzie tylko DAG, gdzie każdy węzeł jest ciągiem.

Na przykład, jeśli wykonasz a = 'abc'.concat('def'), nowo utworzony obiekt będzie wyglądał tak. oczywiście nie jest to dokładnie tak, jak to wygląda w pamięci, ponieważ nadal musisz mieć pole dla typu string, długość i może inne.

a = {
 nodeA: 'abc',
 nodeB: 'def'
}

I b = a.concat('123')

b = {
  nodeA: a, /* {
             nodeA: 'abc',
             nodeB: 'def'
          } */
  nodeB: '123'
}           

Więc w najprostszym przypadku VM nie musi wykonywać prawie żadnej pracy. Jedynym problemem jest to, że spowalnia to inne operacje na wynikowym łańcuchu. Również to oczywiście zmniejsza napowietrzność pamięci.

Z drugiej strony ['abc', 'def'].join('') Zwykle przydzielał pamięć, aby nowy ciąg był płaski w pamięci. (Może to powinno być zoptymalizowane)

Wiem, że to stary wątek, ale twój test jest nieprawidłowy. Robisz output += myarray[i]; podczas gdy powinno być bardziej output += "" + myarray[i];, ponieważ zapomniałeś, że musisz sklejać przedmioty razem z czymś. Kod concat powinien być podobny do:

var output = myarray[0];
for (var i = 1, len = myarray.length; i<len; i++){
    output += "" + myarray[i];
}

W ten sposób wykonujesz dwie operacje zamiast jednej z powodu klejenia elementów razem.

Array.join() jest szybszy.

Benchmarki tam są trywialne. Wielokrotne łączenie tych samych trzech elementów będzie inlinowane, wyniki zostaną udowodnione deterministycznie i zapamiętane, program obsługi śmieci będzie po prostu wyrzucał obiekty tablicy (które nie będą prawie niczym w rozmiarze) i prawdopodobnie po prostu wypchnął i wyskoczył ze stosu ze względu na brak zewnętrznych odniesień i ponieważ ciągi nigdy się nie zmieniają. Byłbym bardziej pod wrażeniem, gdyby test był dużą liczbą losowo generowanych ciągów. Jak na koncercie czy dwóch struny.

Array.dołącz do FTW!

Powiedziałbym, że z łańcuchami łatwiej jest wstępnie przydzielić większy bufor. Każdy element ma tylko 2 bajty (jeśli UNICODE), więc nawet jeśli jesteś zachowawczy, możesz wstępnie przydzielić dość duży bufor dla ciągu. Z arrays każdy element jest bardziej "złożony", ponieważ każdy element jest Object, więc konserwatywna implementacja prealokuje przestrzeń dla mniejszej liczby elementów.

Jeśli spróbujesz dodać for(j=0;j<1000;j++) Przed każdym for zobaczysz, że (pod chrome) różnica prędkości staje się mniejsza. W koniec był jeszcze 1,5 x dla konkatenacji strun, ale mniejszy niż 2,6, który był wcześniej.

I konieczność kopiowania elementów, znak Unicode jest prawdopodobnie mniejszy niż odniesienie do obiektu JS.

Należy pamiętać, że istnieje możliwość, że wiele implementacji silników JS ma optymalizację dla tablic jednego typu, które uczyniłyby wszystko, co napisałem bezużytecznym: -)

Ten test pokazuje karę za rzeczywiste użycie ciągu wykonanego z przypisaniem konkatenacji vs wykonanego z tablicą.metoda join. Podczas gdy ogólna prędkość przypisania jest nadal dwa razy szybsza w Chrome v31, ale nie jest już tak duża, jak przy braku użycia wynikowego ciągu.

To zależy od implementacji silnika javascript. Nawet dla różnych wersji jednego silnika można uzyskać znacznie różne wyniki. Powinieneś zrobić swój własny benchmark, aby to zweryfikować.

Powiedziałbym, że String.concat ma lepszą wydajność w ostatnich wersjach V8. Ale dla Firefoksa i opery, Array.join jest zwycięzcą.

Domyślam się, że podczas gdy każda wersja nosi koszt wielu konkatenacji, wersje join budują dodatkowo tablice.