String Comparison

[zeeshan595]

What is the problem this feature will solve?

Currently in java script if you want to compare 2 strings ignoring case sensitivity. The general practice is to make everything lower case and then compare the strings.

What is the feature you are proposing to solve the problem?

I propose there should be a function that should be capable of comparing the strings ignoring case sensitivity. You could pass an option to the function to do this.

What alternatives have you considered?

I tried a pure js implementation just to test the theory but since toLower() === toLower() is running as Native C++.
toLower() === toLower() ends up being faster.

Here is a c# version of what I am talking about

bool areEqualIgnoreCase = string.Equals(str1, str2, StringComparison.OrdinalIgnoreCase); // true

[richardlau]

See String.prototype.localeCompare() and the sensitivity option.

[zeeshan595]

@richardlau This is not the same thing. I should have added that I have tried this and it is actually slower than just doing
toLower() === toLower()

const apple = "APPLE";
function makeString(len: number, words: number) {
  let str = "";
  for (let i = 0; i < len; i++) {
    let word = "";
    for (let j = 0; j < apple.length; j++) {
      word +=
        Math.random() < 0.5 ? apple[j].toUpperCase() : apple[j].toLowerCase();
    }
    str += word.repeat(words);
  }
  return str;
}

const str1 = makeString(10, 5);
const str2 = makeString(10, 5);
let result = false;

let start = process.hrtime.bigint();
for (let i = 0; i < 1e6; i++) {
  result = str1.toLowerCase() === str2.toLowerCase();
}
let toLowerTime = process.hrtime.bigint() - start;

start = process.hrtime.bigint();
for (let i = 0; i < 1e6; i++) {
  result = str1.localeCompare(str1, undefined, { sensitivity: "accent" }) === 0;
}
let compareTime = process.hrtime.bigint() - start;

if (compareTime < toLowerTime) {
  console.log("Compare is faster");
} else {
  console.log("toLower is faster");
}

console.log(`toLower: ${toLowerTime}ns, compare: ${compareTime}ns`);

This code results in

toLower is faster
toLower: 7327242ns, compare: 2523403685ns

Even running toLower once it completes at 2503ns while compare takes 5979195ns

I am okay with changing the github feature to making String.prototype.localeCompare() faster

[ljharb]

That would be something that needs to be done in v8, since node doesn't define builtin functions like that.

[zeeshan595]

I am going to close this because this is part of v8 and not node
If anyone is interested they can follow it here
https://groups.google.com/g/v8-dev/c/7ip7AowVGHY/m/G7SjYfWfAwAJ