JavaScript 中的字符串原语和字符串对象有什么区别？

Question

取自MDN

字符串字面量（用双引号或单引号表示）和字符串 从非构造函数上下文中的 String 调用返回（即，没有 使用 new 关键字）是原始字符串。 JavaScript 自动 将原语转换为 String 对象，以便可以使用 原始字符串的字符串对象方法。在上下文中 方法将在原始字符串或属性查找上调用 发生时，JavaScript 将自动包装字符串原语并 调用方法或执行属性查找。

所以，我认为（逻辑上）对字符串原语的操作（方法调用）应该比对字符串对象的操作慢，因为在将method 应用于字符串之前，任何字符串原语都会转换为字符串对象（额外的工作）。

但在这个test case 中，结果却相反。 code block-1 比 code block-2 运行得更快，两个代码块如下：

代码块 1：

var s = '0123456789';
for (var i = 0; i < s.length; i++) {
  s.charAt(i);
}

代码块 2：

var s = new String('0123456789');
for (var i = 0; i < s.length; i++) {
    s.charAt(i);
}

结果因浏览器而异，但 code block-1 总是更快。谁能解释一下，为什么 code block-1 比 code block-2 快。

Answer 1

当您声明时：

var s = '0123456789';

您创建了一个字符串原语。该字符串原语具有允许您在其上调用方法而无需将原语转换为第一类对象的方法。因此，您认为这会更慢，因为必须将字符串转换为对象的假设是不正确的。它不必转换为对象。原语本身可以调用方法。

将其转换为完整的对象（允许您向其添加新属性）是一个额外的步骤，并且不会使字符串操作更快（实际上您的测试表明它会使它们变慢）。

Answer 2

如果您使用new，则您明确声明您要创建一个Object 的实例。因此，new String 正在生成一个包装 String 原语的 Object，这意味着对其进行的任何操作都涉及额外的工作层。

typeof new String(); // "object"
typeof '';           // "string"

由于它们的类型不同，您的 JavaScript 解释器也可以对它们进行不同的优化，as mentioned in comments。

Answer 3

对象的存在与 ECMAScript/JavaScript 引擎中字符串的实际行为几乎没有关系，因为根范围将只包含用于此的函数对象。所以字符串字面量的charAt(int)函数会被搜索并执行。

对于一个真实的对象，您可以再添加一层，在标准行为开始之前，还会在对象本身上搜索 charAt(int) 方法（与上面相同）。显然，在这种情况下完成了大量的工作。

顺便说一句，我不认为原语实际上被转换为对象，但脚本引擎会简单地将这个变量标记为字符串类型，因此它可以找到所有提供的函数，所以看起来你调用了一个对象。不要忘记这是一个脚本运行时，其工作原理与 OO 运行时不同。

Answer 4

JavaScript 有两个主要的类型类别，原语和对象。

var s = 'test';
var ss = new String('test');

单引号/双引号模式在功能上是相同的。除此之外，您尝试命名的行为称为自动装箱。所以实际发生的是，当调用包装器类型的方法时，原语被转换为其包装器类型。简单地说：

var s = 'test';

是一种原始数据类型。它没有方法，只不过是一个指向原始数据内存引用的指针，这解释了随机访问速度要快得多。

例如，当您执行s.charAt(i) 时会发生什么？

由于s 不是String 的实例，JavaScript 将自动将s 封装成其包装类型typeof string，String，typeof object 或更准确地说是s.valueOf(s).prototype.toString.call = [object String]。

自动装箱行为根据需要将s 来回转换为其包装器类型，但标准操作速度非常快，因为您处理的是更简单的数据类型。但是自动装箱和Object.prototype.valueOf 有不同的效果。

如果您想强制自动装箱或将原语转换为其包装器类型，您可以使用Object.prototype.valueOf，但行为不同。基于各种各样的测试场景，自动装箱仅应用“必需”方法，而不会改变变量的原始性质。这就是您获得更快速度的原因。

Answer 5

这是相当依赖于实现的，但我会试一试。我将以 V8 为例，但我假设其他引擎使用类似的方法。

字符串原语被解析为v8::String 对象。因此，可以直接在其上调用方法，如 jfriend00 所述。

另一方面，String 对象被解析为扩展 Object 的 v8::StringObject，并且除了是一个完整的对象之外，还用作 v8::String 的包装器。

现在这是合乎逻辑的，对new String('').method() 的调用必须在执行该方法之前将这个v8::StringObject 的v8::String 拆箱，因此它更慢。

---

在许多其他语言中，原始值没有方法。

MDN 提出的方式似乎是解释原语的自动装箱如何工作的最简单方法（在 flav 的回答中也提到过），即 JavaScript 的 primitive 如何-y 值可以调用方法。

但是，智能引擎不会在您每次需要调用方法时将字符串 primitive-y 转换为 String 对象。 Annotated ES5 spec. 中也提到了关于解析原始值的属性（和“方法”¹）的信息：

注意 可能在步骤 1 中创建的对象无法在上述方法之外访问。实现可能会选择避免实际创建对象。 [...]

在非常低的级别上，字符串最常被实现为不可变的标量值。示例包装结构：

StringObject > String (> ...) > char[]

离原语越远，到达它所需的时间就越长。在实践中，String 原语比StringObjects 更频繁，因此引擎将方法添加到 String 原语的对应（解释）对象的类而不是在 String 之间来回转换并不奇怪和 StringObject 正如 MDN 的解释所暗示的那样。

---

¹ 在 JavaScript 中，“方法”只是解析为函数类型值的属性的命名约定。

Answer 6

字符串字面量：

字符串字面量是不可变的，这意味着一旦它们被创建，它们的状态就不能改变，这也使得它们是线程安全的。

var a = 's';
var b = 's';

a==b 结果将是 'true' 两个字符串都引用同一个对象。

字符串对象：

这里创建了两个不同的对象，它们有不同的引用：

var a = new String("s");
var b = new String("s");

a==b 结果将是错误的，因为它们有不同的引用。

Answer 7

如果是字符串文字，我们不能分配属性

var x = "hello" ;
x.y = "world";
console.log(x.y); // this will print undefined

而对于字符串对象，我们可以分配属性

var x = new String("hello");
x.y = "world";
console.log(x.y); // this will print world

Answer 8

我看到这个问题早就解决了，字符串字面量和字符串对象之间还有一个微妙的区别，因为似乎没有人触及它，我想我只是为了完整性而写它。

基本上，两者之间的另一个区别是使用 eval 时。 eval('1 + 1') 给出 2，而 eval(new String('1 + 1')) 给出 '1 + 1'，所以如果某个代码块可以“正常”或使用 eval 执行，它可以导致奇怪的结果

Answer 9

字符串原语和字符串对象的最大区别是对象必须跟在this rule for the == operator后面：

仅当操作数引用时，比较对象的表达式才为真 同一个对象。

因此，虽然字符串原语有一个方便的 == 来比较值，但在使任何其他不可变对象类型（包括字符串对象）表现得像值类型时，您就不走运了。

"hello" == "hello"
-> true
new String("hello") == new String("hello") // beware!
-> false

（其他人注意到字符串对象在技术上是可变的，因为您可以向其添加属性。但不清楚这有什么用处；字符串值本身是不可变的。）

Answer 10

代码在运行前由 javascript 引擎优化。 通常，微基准测试可能会产生误导，因为编译器和解释器会重新排列、修改、删除和对部分代码执行其他技巧，以使其运行得更快。 换句话说，书面代码告诉目标是什么，但编译器和/或运行时将决定如何实现该目标。

Block 1 更快主要是因为： var s = '0123456789';总是比 var s = new String('0123456789'); 因为对象创建的开销。

循环部分不是导致速度变慢的部分，因为chartAt() 可以由解释器内联。 尝试移除环路并重新运行测试，您将看到速度比与未移除环路时相同。换句话说，对于这些测试，执行时的循环块具有完全相同的字节码/机器码。

对于这些类型的微基准，查看字节码或机器码将提供更清晰的画面。

Answer 11

在 Javascript 中，string 等原始数据类型是非复合构建块。这意味着它们只是值，仅此而已： let a = "string value"; 默认情况下没有内置方法，如 toUpperCase、toLowerCase 等...

但是，如果你尝试写：

console.log( a.toUpperCase() ); or console.log( a.toLowerCase() );

这不会引发任何错误，而是会正常工作。

发生了什么？ 好吧，当您尝试访问字符串 a 的属性时，Javascript 会将字符串强制转换为 new String(a); 称为 wrapper object 的对象。

此过程与 JavaScript 中称为 函数构造函数 的概念相关联，其中函数用于创建新对象。

当您在此处键入new String('String value'); 时，String 是函数构造函数，它接受一个参数并在函数范围内创建一个空对象，这个空对象被分配给 this，在这种情况下，String 提供我们之前提到的所有已知的内置函数。并且一旦操作完成，例如做大写操作，包装对象就会被丢弃。

为了证明这一点，让我们这样做：

let justString = 'Hello From String Value';
justString.addNewProperty = 'Added New Property';
console.log( justString );

这里的输出将是未定义的。为什么 ？ 在这种情况下，Javascript 创建包装器字符串对象，设置新属性 addNewProperty 并立即丢弃包装器对象。这就是你不确定的原因。伪代码如下所示：

let justString = 'Hello From String Value';
let wrapperObject = new String( justString );
wrapperObject.addNewProperty = 'Added New Property'; //Do operation and discard

Answer 12

我们可以用三种方式定义字符串

1. var a = "第一种方式";
2. var b = String("第二种方式");
3. var c = new String("第三条路");

// 我们也可以使用创建 4. var d = a + '';

检查使用 typeof 运算符创建的字符串的类型

• typeof a //“字符串”
• typeof b //“字符串”
• typeof c // “对象”

当你比较 a 和 b var a==b ( // yes)

当你比较 String 对象时

var StringObj = new String("third way")
var StringObj2 = new String("third way")
StringObj  == StringObj2 // no result will be false, because they have different references