字符串和字符串生成器

为什么会这样？

从V8 sorts来看，字符串针对连接进行了优化。连接时，不是创建新字符串，而是创建一个引用被连接片段的实例。每个块也可以引用子块。这样一棵二叉树就建立起来了。

// The ConsString class describes string values built by using the
// addition operator on strings.  A ConsString is a pair where the
// first and second components are pointers to other string values.
// One or both components of a ConsString can be pointers to other
// ConsStrings, creating a binary tree of ConsStrings where the leaves
// are non-ConsString string values.  The string value represented by
// a ConsString can be obtained by concatenating the leaf string
// values in a left-to-right depth-first traversal of the tree.
class ConsString : public String {
 public:
  // First string of the cons cell.
  inline String* first();
  inline void set_first(String* first,
    WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
  // Second string of the cons cell.
  inline String* second();
  inline void set_second(String* second,
    WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
  // Minimum length for a cons string.
  static const int kMinLength = 13;
  // ...
}

还有子字符串的字符串子类，单字节和双字节字符串显式分开等等。

// The Sliced String class describes strings that are substrings of another
// sequential string.  The motivation is to save time and memory when creating
// a substring.  A Sliced String is described as a pointer to the parent,
// the offset from the start of the parent string and the length.  Using
// a Sliced String therefore requires unpacking of the parent string and
// adding the offset to the start address.  A substring of a Sliced String
// are not nested since the double indirection is simplified when creating
// such a substring.
// Currently missing features are:
//  - handling externalized parent strings
//  - external strings as parent
//  - truncating sliced string to enable otherwise unneeded parent to be GC'ed.
class SlicedString : public String {
 public:
  inline String* parent();
  inline void set_parent(String* parent,
                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
  inline int offset() const;
  inline void set_offset(int offset);
  // Minimum length for a sliced string.
  static const int kMinLength = 13;
  // ...
}

结果，像连接这样简单的操作变成了这样：

MaybeHandle<String> Factory::NewConsString(Handle<String> left,
                                           Handle<String> right) {
  if (left->IsThinString()) {
    left = handle(Handle<ThinString>::cast(left)->actual(), isolate());
  }
  if (right->IsThinString()) {
    right = handle(Handle<ThinString>::cast(right)->actual(), isolate());
  }
  int left_length = left->length();
  if (left_length == 0) return right;
  int right_length = right->length();
  if (right_length == 0) return left;

  int length = left_length + right_length;

  if (length == 2) {
    uint16_t c1 = left->Get(0);
    uint16_t c2 = right->Get(0);
    return MakeOrFindTwoCharacterString(isolate(), c1, c2);
  }

  // Make sure that an out of memory exception is thrown if the length
  // of the new cons string is too large.
  if (length > String::kMaxLength || length < 0) {
    THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
  }

  bool left_is_one_byte = left->IsOneByteRepresentation();
  bool right_is_one_byte = right->IsOneByteRepresentation();
  bool is_one_byte = left_is_one_byte && right_is_one_byte;
  bool is_one_byte_data_in_two_byte_string = false;
  if (!is_one_byte) {
    // At least one of the strings uses two-byte representation so we
    // can't use the fast case code for short one-byte strings below, but
    // we can try to save memory if all chars actually fit in one-byte.
    is_one_byte_data_in_two_byte_string =
        left->HasOnlyOneByteChars() && right->HasOnlyOneByteChars();
    if (is_one_byte_data_in_two_byte_string) {
      isolate()->counters()->string_add_runtime_ext_to_one_byte()->Increment();
    }
  }

  // If the resulting string is small make a flat string.
  if (length < ConsString::kMinLength) {
    // Note that neither of the two inputs can be a slice because:
    STATIC_ASSERT(ConsString::kMinLength <= SlicedString::kMinLength);
    DCHECK(left->IsFlat());
    DCHECK(right->IsFlat());

    STATIC_ASSERT(ConsString::kMinLength <= String::kMaxLength);
    if (is_one_byte) {
      Handle<SeqOneByteString> result =
          NewRawOneByteString(length).ToHandleChecked();
      DisallowHeapAllocation no_gc;
      uint8_t* dest = result->GetChars();
      // Copy left part.
      const uint8_t* src =
          left->IsExternalString()
              ? Handle<ExternalOneByteString>::cast(left)->GetChars()
              : Handle<SeqOneByteString>::cast(left)->GetChars();
      for (int i = 0; i < left_length; i++) *dest++ = src[i];
      // Copy right part.
      src = right->IsExternalString()
                ? Handle<ExternalOneByteString>::cast(right)->GetChars()
                : Handle<SeqOneByteString>::cast(right)->GetChars();
      for (int i = 0; i < right_length; i++) *dest++ = src[i];
      return result;
    }

    return (is_one_byte_data_in_two_byte_string)
        ? ConcatStringContent<uint8_t>(
            NewRawOneByteString(length).ToHandleChecked(), left, right)
        : ConcatStringContent<uc16>(
            NewRawTwoByteString(length).ToHandleChecked(), left, right);
  }

  bool one_byte = (is_one_byte || is_one_byte_data_in_two_byte_string);
  return NewConsString(left, right, length, one_byte);
}

任何这样的智慧总是一种妥协，上面覆盖着启发式方法。JavaScript 引擎会尝试猜测何时使用哪种方法更有利可图：何时创建完整的字符串，何时构建字符串的二叉树；当连接速度更重要时，当迭代速度更重要时；等等。

一个明显的优势：可能非常慢的操作变得更快。这对于程序员经常使用某些类使用模式的情况尤其重要，例如字符串连接。但缺点也很明显：其他操作变慢，此外，引擎并不总是猜测程序员的意图并选择最优化的方式。

为什么这是在 JavaScript 中完成的？

因为有意使语言易于理解和使用。魔法越多，你就越不用考虑内部表示，写程序就越容易。

此外，在创建该语言时，执行速度根本不重要，因为没有人用该语言编写复杂的程序。复杂的程序出现得晚得多。如果您不是在最新版本的 Chrome 中运行此程序，而是在任何 20 年前的浏览器中运行，您会发现性能有很大不同。

为什么不用其他语言来完成？

这取决于语言及其目的。例如，C++中的字符串简单而笨拙，要求程序员指定每个动作，在循环体中或外部声明字符串，通过引用和通过值将字符串传递给函数之间在性能上存在差异，程序员需要提前指明字符串的长度，等等。进一步。

另一方面，在 PHP 中，数组就像 JS 中的字符串，在复杂性方面会让你领先一步。数组可以是向量、字典、集合等。它们具有针对每种情况进行优化的复杂结构。

通常，标准类的方法因语言而异，甚至在同一语言编译器的不同版本之间也不同。今天，类型化数组出现在 JavaScript 和 PHP 中，明天可能会出现 StringBuilder。