[Proposal] ignoreCase method

# Robert Wozniak (5 months ago)

ignoreCase - JavaScript proposal

It's a proposal to implement a new function to compare two strings but without case sensitivity.

The proposal is bringing an important function, which is being used in Java. Many times in my career I had to compare two strings but ignore case sensitivity.

I had to convert it first and then I could compare. I'd like developers to be able to use the function and compare two strings without worrying about case sensitivity.

  1. Syntax

String.prototype.ignoreCase = function(value, arrayOfStrings) { var secondOption = value.toLowerCase() || arrayOfStrings.join(',').toLowerCase().split(','); var firstOption = this.valueOf().toLowerCase(); if(typeof secondOption === 'object') { for(var i = 0, l = arrayOfStrings.length; i < l; i++) { if(firstOption === secondOption[i]) { return true; break; } } } else { if(firstOption === secondOption) { return true; } else { return false; } } };

Above code presents ignoreCase function and what's happening inside.

The function takes two parameters: (value, arrayOfStrings)

1.1 "value" parameter

The value parameter is the string which is going to be compared with the parent string is chosen by the developer, for example:

const stringOne = "Matheus"; stringOne.ignoreCase("matheus"); // true;

1.2 "arrayOfStrings" parameter

The "arrayOfStrings" parameter is an array of strings, which are going to be compared with the parent string chosen by the developer. Once the parent string equals one of the strings in an array, it will return true and stops iterating through.

Example:

const stringOne = "Matheus"; const manyStrings = ['robert', 'lucas','matheus']; stringOne.ignoreCase('', manyStrings) // true;

  1. Response

The function is going to return true or false. The result depends on equality between chosen strings.

  1. How does it work?

The function converts all of the strings, which the developer chose to the lower case. After performing the previous operation, it compares all of them. If at least one, equals the provided parent string, then the function returns true.

You can the proposal formatted in a proper way on my GitHub: robertjwozniak/ignoreCase

# Michael Luder-Rosefield (5 months ago)

Would it not be simpler to simply change the signature from function(value, arrayOfStrings) to function(...values)?

I'd also suggest that a better, more general purpose formulation of comparing a string against multiple values might be to use #match. Something like:

const checkString = (str, { ignoreCase, startsWith, endsWith, equals }={} )
=> {

const start = startsWith || equals ? '^' : '';
    const end = endsWith || equals ? '$' : '';
    const rx = v => new RegExp(`${start}${v}${end}`,ignoreCase && 'i');

return { against: (...values) => values.some(value => str.match(rx(value)))
};
}
# Isiah Meadows (5 months ago)

BTW, have you tried string.localeCompare(other, null, {sensitivity: "base"}) or sensitivity: "accent"?

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare


Isiah Meadows me at isiahmeadows.com, www.isiahmeadows.com

# Robert Wozniak (5 months ago)

I think you’re right, It could be simpler to do it like that.

I have checked “localeCompare”, it does compare case sensitive strings but it doesn’t compare strings in an array and to do it, you will have to execute the method as many times as strings in an array. By using ignoreCase method, you will pass specific array and the method will do it for you inside. Second thing, “localeCompare” returns numbers: 0, 1, -1, -2 depends on the result, a method proposed by me returns true or false.

Another thing would be that “localeCompare” is heavier that ignoreCase method. I think we should have lightweight alternative to compare case sensitive strings.

# T.J. Crowder (5 months ago)

On Wed, Jun 27, 2018 at 4:37 PM, Robert Wozniak <wozniakj.robert at gmail.com>

wrote:

...Second thing, “localeCompare” returns numbers: 0, 1, -1, -2 depends on the result, a method proposed by me returns true or false.

This makes your method markedly less useful than localeCompare. It's really useful to know not just that the strings are equal or not equal, but how they relate to one another lexicographically. For instance, for sorting:

const array = ["c", "a", "B"];
array.sort((a, b) => a.localeCompare(b, undefined, {sensitivity: "base"}));

console.log(array); // "a", "B", "c"

-- T.J. Crowder

# T.J. Crowder (5 months ago)

On Wed, Jun 27, 2018 at 4:37 PM, Robert Wozniak <wozniakj.robert at gmail.com>

wrote:

...it does compare case sensitive strings but it doesn’t compare strings in an array and to do it, you will have to execute the method as many times as strings in an array

That's not a problem. For the "does this string match any in this array" case, use Array#some:

const stringOne = "Matheus";
const manyStrings = ['robert', 'lucas', 'matheus'];
if (manyStrings.some(s => s.localeCompare(stringOne, undefined,
{sensitivity: "base"}) == 0)) {
    // Yes, it was found
}

(.localeCompare(stringOne, undefined, {sensitivity: "base"}) is fairly verbose, so I'd probably have a utility function for it.)

...and the method will do it for you inside.

There's not all that much in it, doing the loop within the standard API function vs. outside it. If it's a hotspot for execution, it'll get aggressively optimized either way. If it isn't, you don't care.

-- T.J. Crowder

# Oriol _ (5 months ago)

(.localeCompare(stringOne, undefined, {sensitivity: "base"}) is

fairly verbose, so I'd probably have a utility function for it.)

I would just create a collator outside the loop:

const stringOne = "Matheus";
const manyStrings = ['robert', 'lucas', 'matheus'];
const {compare} = new Intl.Collator(undefined, {sensitivity: "base"});
if (manyStrings.some(s => compare(s, stringOne) == 0)) {
    // Yes, it was found
}
# T.J. Crowder (5 months ago)

On Wed, Jun 27, 2018 at 6:03 PM, Oriol _ <oriol-bugzilla at hotmail.com> wrote:

(.localeCompare(stringOne, undefined, {sensitivity: "base"}) is fairly verbose, so I'd probably have a utility function for it.)

I would just create a collator outside the loop:

I meant verbose to write every time you need to do a case-insensitive comparison; instead, I'd drop a utility function in my standard lib somewhere.

I like that approach to creating that utility function, though. :-)

-- T.J. Crowder

# Isiah Meadows (5 months ago)

I would be a fan of adding a string.compare(other, {ignoreCase = false, unicode = false}) that purely works by character code/code point and is required to return 1, 0, or -1. That would be easier to spec, and is more generally useful when you're working with strings for computers, not people.

But that's largely independent of this proposal.


Isiah Meadows me at isiahmeadows.com, www.isiahmeadows.com

# Robert (4 months ago)

Well, that's fair enough. I don't think that I can argue with that. Seems like ignoreCase method is not necessary.