草庐IT

javascript - 为什么在 Nodejs 中比较两个字符串时 '===' 比逐字符比较慢

coder 2024-05-08 原文

我发现在 Nodejs 通过比较它们的每个字符来比较两个字符串比使用语句 'str1 === str2' 更快。
这是什么原因？而在 浏览器 ，正好相反。

这是我试过的代码，两个长字符串相等。节点版本是 v8.11.3 

function createConstantStr(len) {
  let str = "";
  for (let i = 0; i < len; i++) {
    str += String.fromCharCode((i % 54) + 68);
  }

  return str;
}

let str = createConstantStr(1000000);
let str2 = createConstantStr(1000000);

console.time('equal')
console.log(str === str2);
console.timeEnd('equal')

console.time('equal by char')
let flag = true;
for (let i = 0; i < str.length; i++) {
  if (str[i] !== str2[i]) {
    flag = false;
    break;
  }
}

console.log(flag);
console.timeEnd('equal by char');

最佳答案

已经向您指出，如果您翻转两个测试，那么与 === 进行比较将比逐个字符进行比较要快。到目前为止，您对为什么的解释并没有精确地限定为什么会这样。有几个问题会影响您的结果。

第一次 console.log 调用很昂贵

如果我试试这个:

console.time("a");
console.log(1 + 2);
console.timeEnd("a");

console.time("b");
console.log("foo");
console.timeEnd("b");

我得到类似的东西:
3
a: 3.864ms
foo
b: 0.050ms

如果我翻转代码以便我有这个:
console.time("b");
console.log("foo");
console.timeEnd("b");

console.time("a");
console.log(1 + 2);
console.timeEnd("a");

然后我得到这样的东西:
foo
b: 3.538ms
3
a: 0.330ms

如果我在进行任何计时之前通过添加 console.log 来修改代码，如下所示:
console.log("start");

console.time("a");
console.log(1 + 2);
console.timeEnd("a");

console.time("b");
console.log("foo");
console.timeEnd("b");

然后我得到类似的东西:
start
3
a: 0.422ms
foo
b: 0.027ms

通过在开始计时之前放置 console.log，我从计时中排除了调用 console.log 的初始成本。

按照您设置测试的方式，第一个 console.log 调用由 === 或 char-by-char 测试中的哪一个先完成，并且第一个 console.log 调用的成本被添加到该测试中。无论哪个测试排在第二位，都无需承担该费用。最终，对于这样的测试，我宁愿将 console.log 移到正在计时的区域之外。例如，第一个定时区域可以这样写:
console.time('equal');
const result1 = str === str2;
console.timeEnd('equal');
console.log(result1);

将结果存储在 result1 中，然后在定时区域外使用 console.log(result1) 确保您可以看到结果，同时不计算 console.log 产生的成本。

无论您先进行哪个测试，都会承担扁平化 v8 内部创建的字符串树的成本

Node 使用 v8 JavaScript 引擎来运行你的 JavaScript。 v8 以多种方式实现字符串。 objects.h 在注释中显示了 v8 支持的类层次结构。这是 section relevant to strings :
//       - String
//         - SeqString
//           - SeqOneByteString
//           - SeqTwoByteString
//         - SlicedString
//         - ConsString
//         - ThinString
//         - ExternalString
//           - ExternalOneByteString
//           - ExternalTwoByteString
//         - InternalizedString
//           - SeqInternalizedString
//             - SeqOneByteInternalizedString
//             - SeqTwoByteInternalizedString
//           - ConsInternalizedString
//           - ExternalInternalizedString
//             - ExternalOneByteInternalizedString
//             - ExternalTwoByteInternalizedString

有两个类对我们的讨论很重要: SeqString 和 ConsString 。它们的不同之处在于它们在内存中存储字符串的方式。 SeqString class 是一个简单的实现:字符串只是一个字符数组。 (实际上 SeqString 本身是抽象的。真正的类是 SeqOneByteString 和 SeqTwoByteString 但这并不重要。)然而 ConsString 将字符串存储为二叉树。 ConcString 有一个 first 字段和一个 second 字段，它们是指向其他字符串的指针。

考虑这个代码:
let str = "";
for (let i = 0; i < 10; ++i) {
  str += i;
}
console.log(str);

如果 v8 使用 SeqString 来实现上面的代码，那么:
  • 在迭代 0 时，它必须分配一个大小为 1 的新字符串，将 str ( "" ) 的旧值复制到它，并附加到该 "0" 并将 str 设置为新字符串 ( "0" )。
  • 在迭代 1 时，它必须分配一个大小为 2 的新字符串，将 str ( "0" ) 的旧值复制到它，并附加到该 "1" ) 并将 str 设置为新字符串 ( "01" )。
  • ...
  • 在迭代 9 时，它必须分配一个大小为 10 的新字符串，将 str ( "012345678" ) 的旧值复制到它，并附加到该 "9" 并将 str 设置为新字符串 ( "0123456789" )。

    • 10 个步骤复制的字符总数为 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55 个字符。对于最终包含 10 个字符的字符串，移动了 55 个字符。

    相反，v8 实际上像这样使用 ConsString:
  • 在迭代 0 时，分配一个新的 ConcString，其中 first 设置为 str 的旧值，second 设置为 i(作为字符串)0，并将 str 设置为刚刚分配的新 ConcString。
  • 在迭代 1 时，分配一个新的 ConcString，其中 first 设置为 str 的旧值，second 设置为 "1" ，并将 str 设置为刚刚分配的这个新 ConcString。
  • ...
  • 在迭代 9 时，分配一个新的 ConcString，其中 first 设置为 str 的旧值，second 设置为 "9" 。

    • 如果我们将每个 ConcString 表示为 (<first>, <second>)，其中 <first> 是其 first 字段的内容，<second> 是 second 字段的内容，那么最终结果是这样的:
    (((((((((("", "0"), "1"), "2"), "3"), "4"), "5"), "6"), "7"), "8"), "9")

    通过这样做，v8 避免了一步一步地一遍又一遍地复制字符串。每一步只是一个分配和调整几个指针。虽然将字符串存储为树有助于加快连接速度，但它的缺点是其他操作会变慢。 v8 通过 flattening ConsString 树缓解了这种情况。将上面的例子展平后，就变成了:
    ("0123456789", "")

    请注意，当 ConsString 变平时，这个 ConsString 对象会发生变异。 (从 JS 代码的 Angular 来看，字符串保持不变。只是它的内部 v8 表示发生了变化。)
    比较扁平的 ConsString 树更容易，而这正是 v8 所做的( ref ):
    bool String::Equals(Isolate* isolate, Handle<String> one, Handle<String> two) {
  if (one.is_identical_to(two)) return true;
  if (one->IsInternalizedString() && two->IsInternalizedString()) {
    return false;
  }
  return SlowEquals(isolate, one, two);
}

    我们正在谈论的字符串没有内化，所以 SlowEquals 被称为( ref ):
    bool String::SlowEquals(Isolate* isolate, Handle<String> one,
                        Handle<String> two) {
[... some shortcuts are attempted ...]
  one = String::Flatten(isolate, one);
  two = String::Flatten(isolate, two);

    我在这里展示了比较字符串的相等性会在内部将它们展平，但在许多其他地方都可以找到对 String::Flatten 的调用。您的两个测试最终都通过不同的方式使字符串变平。

    对于您的代码，结果是这样的:
  • 您的 createConstantStr 创建的字符串在内部存储为 ConsString 。所以 str 和 str2 是 ConsString 对象，就 v8 而言。
  • 您运行的第一个测试会导致 str 和 str2 被展平，因此:a) 该测试必须承担展平字符串的成本，b) 第二个测试受益于使用已经展平的 ConcString 对象。 (记住，当一个 ConcString 对象被扁平化时，这个对象就会发生变异。所以如果以后再次访问它，它已经扁平化了。)

    • 关于javascript - 为什么在 Nodejs 中比较两个字符串时 '===' 比逐字符比较慢，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55932435/

    中比逐字codeconsole34javascriptstringperformance

    有关javascript - 为什么在 Nodejs 中比较两个字符串时 '===' 比逐字符比较慢的更多相关文章

    1. ruby - 如何从 ruby​​ 中的字符串运行任意对象方法？ - 2

      总的来说，我对ruby​​还比较陌生，我正在为我正在创建的对象编写一些rspec测试用例。许多测试用例都非常基础，我只是想确保正确填充和返回值。我想知道是否有办法使用循环结构来执行此操作。不必为我要测试的每个方法都设置一个assertEquals。例如:describeitem,"TestingtheItem"doit"willhaveanullvaluetostart"doitem=Item.new#HereIcoulddotheitem.name.shouldbe_nil#thenIcoulddoitem.category.shouldbe_nilendend但我想要一些方法来使用

    2. Ruby 解析字符串 - 2

      我有一个字符串input="maybe(thisis|thatwas)some((nice|ugly)(day|night)|(strange(weather|time)))"Ruby中解析该字符串的最佳方法是什么？我的意思是脚本应该能够像这样构建句子:maybethisissomeuglynightmaybethatwassomenicenightmaybethiswassomestrangetime等等，你明白了......我应该一个字符一个字符地读取字符串并构建一个带有堆栈的状态机来存储括号值以供以后计算，还是有更好的方法？也许为此目的准备了一个开箱即用的库？

    3. ruby - 为什么我可以在 Ruby 中使用 Object#send 访问私有(private)/ protected 方法？ - 2

      类classAprivatedeffooputs:fooendpublicdefbarputs:barendprivatedefzimputs:zimendprotecteddefdibputs:dibendendA的实例a=A.new测试a.foorescueputs:faila.barrescueputs:faila.zimrescueputs:faila.dibrescueputs:faila.gazrescueputs:fail测试输出failbarfailfailfail.发送测试[:foo,:bar,:zim,:dib,:gaz].each{|m|a.send(m)resc

    4. ruby-on-rails - 在 Rails 中将文件大小字符串转换为等效千字节 - 2

      我的目标是转换表单输入，例如“100兆字节”或“1GB”，并将其转换为我可以存储在数据库中的文件大小(以千字节为单位)。目前，我有这个:defquota_convert@regex=/([0-9]+)(.*)s/@sizes=%w{kilobytemegabytegigabyte}m=self.quota.match(@regex)if@sizes.include?m[2]eval("self.quota=#{m[1]}.#{m[2]}")endend这有效，但前提是输入是倍数(“gigabytes”，而不是“gigabyte”)并且由于使用了eval看起来疯狂不安全。所以，功能正常，

    5. ruby-on-rails - unicode 字符串的长度 - 2

      在我的Rails(2.3，Ruby1.8.7)应用程序中，我需要将字符串截断到一定长度。该字符串是unicode，在控制台中运行测试时，例如'א'.length，我意识到返回了双倍长度。我想要一个与编码无关的长度，以便对unicode字符串或latin1编码字符串进行相同的截断。我已经了解了Ruby的大部分unicode资料，但仍然有些一头雾水。应该如何解决这个问题？ 最佳答案 Rails有一个返回多字节字符的mb_chars方法。试试unicode_string.mb_chars.slice(0,50)

    6. ruby-on-rails - rails : "missing partial" when calling 'render' in RSpec test - 2

      我正在尝试测试是否存在表单。我是Rails新手。我的new.html.erb_spec.rb文件的内容是:require'spec_helper'describe"messages/new.html.erb"doit"shouldrendertheform"dorender'/messages/new.html.erb'reponse.shouldhave_form_putting_to(@message)with_submit_buttonendendView本身，new.html.erb，有代码:当我运行rspec时，它失败了:1)messages/new.html.erbshou

    7. ruby-on-rails - Rails - 子类化模型的设计模式是什么？ - 2

      我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？ 最佳答案 通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co

    8. ruby-on-rails - 'compass watch' 是如何工作的/它是如何与 rails 一起使用的 - 2

      我在我的项目目录中完成了compasscreate.和compassinitrails。几个问题:我已将我的.sass文件放在public/stylesheets中。这是放置它们的正确位置吗？当我运行compasswatch时，它不会自动编译这些.sass文件。我必须手动指定文件:compasswatchpublic/stylesheets/myfile.sass等。如何让它自动运行？文件ie.css、print.css和screen.css已放在stylesheets/compiled。如何在编译后不让它们重新出现的情况下删除它们？我自己编译的.sass文件编译成compiled/t

    9. ruby - 将差异补丁应用于字符串/文件 - 2

      对于具有离线功能的智能手机应用程序，我正在为Xml文件创建单向文本同步。我希望我的服务器将增量/差异(例如GNU差异补丁)发送到目标设备。这是计划:Time=0Server:hasversion_1ofXmlfile(~800kiB)Client:hasversion_1ofXmlfile(~800kiB)Time=1Server:hasversion_1andversion_2ofXmlfile(each~800kiB)computesdeltaoftheseversions(=patch)(~10kiB)sendspatchtoClient(~10kiBtransferred)Cl

    10. ruby-on-rails - Rails 常用字符串(用于通知和错误信息等) - 2

      大约一年前，我决定确保每个包含非唯一文本的Flash通知都将从模块中的方法中获取文本。我这样做的最初原因是为了避免一遍又一遍地输入相同的字符串。如果我想更改措辞，我可以在一个地方轻松完成，而且一遍又一遍地重复同一件事而出现拼写错误的可能性也会降低。我最终得到的是这样的:moduleMessagesdefformat_error_messages(errors)errors.map{|attribute,message|"Error:#{attribute.to_s.titleize}#{message}."}enddeferror_message_could_not_find(obje

    随机推荐