Como fazer Case Insensitive String Comparação em JavaScript

Ao escrever o código, um desenvolvedor pode precisar comparar duas seqüências para garantir que tarefas específicas sejam concluídas. Comparando strings sem prestar atenção em seus casos, como capital e letras minúsculas, são conhecidas como uma comparação insensível ao caso. Muitos idiomas suportam a comparação de strings com sensibilidade e insensibilidade ao caso.

Este artigo ilustrará os métodos para comparação de caso insensível ao caso de strings em JavaScript.

Como fazer Case Insensitive String Comparação em JavaScript?

Para comparação de strings insensíveis ao caso em JavaScript, use os seguintes métodos predefinidos:

• • Método localCompare ()
  • Método ToupPercase () e TolowerCase ()
  • Expressão regular com o método test ()

Vejamos o funcionamento de cada uma das abordagens acima mencionadas separadamente.

Método 1: comparação de string insensível ao caso usando o método localECompare ()

A comparação de strings insensível ao caso usa o “LocalecMare ()”Método. Este método retorna um número (positivo, negativo ou zero). As strings são comparadas em uma ordem de classificação, se a string de referência for mais longa que a string de comparação ou ocorre após a string comparada, ela fornecerá um número positivo. Se a sequência de referência for mais curta ou vier antes da string comparada, ele retornará um número negativo. Um zero deve ser retornado se a sequência de referência for equivalente à string comparada.

Sintaxe

Siga a sintaxe fornecida fornecida para o método localECompare ():

String1.LOCALECOMPARE (String2, Locais, Opções)

Aqui,

• • ““String2”É a string de comparação, onde a string 1 será comparada.
  • ““Locais”É a tag de linguagem.
  • ““opções”São o local fornecido pelo usuário enquanto trabalha com ele.

Exemplo

Crie duas cordas “String1" e "String2", Com cordas"Linuxhint" e "Linuxhint”Respectivamente:

var string1 = 'linuxhint';
var string2 = 'linuxhint';

Compare String1 com String2 usando o “LocalecMare ()”Método e armazene o resultado em uma variável“comp”. O terceiro argumento do método será definido como “Sensibilidade: 'base'”Isso indica que as letras base de strings comparadas não são diferentes:

var comp = string1.LOCALECOMPARE (String2, indefinido, sensibilidade: 'base')

Na declaração condicional, verifique se o valor retornado do método localCompare () é equivalente a zero, ele imprime “Strings são iguais", outro, "Strings não são iguais”:

if (comp == 0)
console.log ("Strings são iguais");
outro
console.log ("Strings não são iguais");

Saída

Método 2: comparação de string insensível a casos usando o método Touppercase () e TolowerCase ()

As abordagens mais utilizadas para comparar strings insensíveis ao caso são o método touppercase () ou tolowercase (). Eles convertem as cordas em maiúsculas ou minúsculas e depois as comparam com a ajuda de operadores rígidos de igualdade.

Sintaxe

Para o método touppercase (), use o seguinte método:

corda.toupppercase ();

Use a sintaxe abaixo para o método tolowerCase ().

corda.tolowerCase ();

Exemplo: comparação de string insensível ao caso usando o método touppercase ()

Considere as cordas criadas acima “String1" e "String2”E, em seguida, compare -os usando o método touppercase () com o operador estrito de igualdade:

if (string1.toupppercase () === String2.toupppercase ())
console.log ("Strings são iguais");
outro
console.log ("Strings não são iguais");

A saída indica que ambas as cordas são iguais ao ignorar o caso:

Exemplo: comparação de string insensível ao caso usando o método TolowerCase ()

Aqui, as strings são comparadas usando o método TolowerCase () que primeiro converterá as seqüências em minúsculas e depois as comparará usando o operador ===:

if (string1.tolowerCase () === String2.tolowerCase ())
console.log ("Strings são iguais");
outro
console.log ("Strings não são iguais");

A saída correspondente será:

Método 3: Comparação de strings insensível a casos usando a expressão regular com o método test ()

O javascript predefinido “teste()”O método, que usa uma expressão regular, é outra maneira de comparar duas strings. Com base no regex especificado, ele determina se as seqüências são iguais ou não.

Sintaxe

Siga a sintaxe dada para usar uma expressão regular para comparar as strings:

Regexp (string, "gi")

Aqui,

• • ““Regexp" apoia "expressão regular”.
  • ““g”É a variável global que permite verificar todas as cordas.
  • ““eu”É uma variável de bandeira que indica que um caso deve ser ignorado ao usar uma string para corresponder ao padrão.

Exemplo

Primeiro, crie um novo objeto do regexp (), passando uma string e a expressão regular como argumento:

var comp = novo regexp (string1, "gi");

Compare as cordas usando o método test ():

if (comp.teste (string2))
console.log ("Strings são iguais");
outro
console.log ("Strings não são iguais");

Saída

Conclusão

Para comparar as seqüências insensíveis de casos em JavaScript, use os métodos predefinidos JavaScript, incluindo o método localCompare (), Touppercase () e TolowerCase (), ou o método test () com expressão regular. Os métodos “touppercase () e tolowercase ()” são a abordagem mais usada para comparar duas strings insensíveis a casos. Este artigo ilustrou as diferentes maneiras de comparação entre minúsculas de caso de strings em JavaScript.