una - Comparación de cadenas insensibles de mayúsculas y minúsculas de JavaScript
manejo de cadenas en javascript (17)
¿Qué hay de NO lanzar excepciones y NO usar expresiones regulares lentas?
return str1 != null && str2 != null
&& typeof str1 === ''string'' && typeof str2 === ''string''
&& str1.toUpperCase() === str2.toUpperCase();
El fragmento de código anterior supone que no desea coincidir si alguna de las cadenas es nula o no está definida.
Si desea hacer coincidir nulo / indefinido, entonces:
return (str1 == null && str2 == null)
|| (str1 != null && str2 != null
&& typeof str1 === ''string'' && typeof str2 === ''string''
&& str1.toUpperCase() === str2.toUpperCase());
Si por alguna razón te importa undefined vs null:
return (str1 === undefined && str2 === undefined)
|| (str1 === null && str2 === null)
|| (str1 != null && str2 != null
&& typeof str1 === ''string'' && typeof str2 === ''string''
&& str1.toUpperCase() === str2.toUpperCase());
¿Cómo realizo una comparación de cadenas que no distingue mayúsculas de minúsculas en JavaScript?
Como ninguna respuesta proporcionó claramente un fragmento de código simple para usar RegExp , aquí está mi intento:
function compareInsensitive(str1, str2){
return typeof str1 === ''string'' &&
typeof str2 === ''string'' &&
new RegExp("^" + str1.replace(/[-////^$*+?.()|[/]{}]/g, ''//$&'') + "$", "i").test(str2);
}
Tiene varias ventajas:
- Verifica el tipo de parámetro (cualquier parámetro que no sea una cadena, como
undefinedpor ejemplo, bloquearía una expresión comostr1.toUpperCase()). - No sufre de posibles problemas de internacionalización.
- Escapa de la cadena
RegExp.
Como se dijo en comentarios recientes, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… admite comparaciones que no distinguen entre mayúsculas y minúsculas (entre otras cosas poderosas).
Aquí hay un ejemplo simple
''xyz''.localeCompare(''XyZ'', undefined, { sensitivity: ''base'' }); // returns 0
Y una función genérica que podrías usar.
function equalsIgnoringCase(text, other) {
text.localeCompare(other, undefined, { sensitivity: ''base'' }) === 0;
}
Tenga en cuenta que, en lugar de undefined , probablemente deba ingresar la configuración regional específica con la que está trabajando. Esto es importante como se indica en los documentos de MDN
en sueco, ä y a son letras base separadas
Opciones de sensibilidad
Soporte del navegador
A partir del momento de la publicación, UC Browser para Android y Opera Mini no son compatibles con la configuración regional y los parámetros de opciones . Consulte https://caniuse.com/#search=localeCompare para obtener información actualizada.
Con la ayuda de la expresión regular también podemos lograrlo.
(/keyword/i).test(source)
/i es para ignorar el caso. Si no es necesario, podemos ignorar y probar la coincidencia NO sensible a mayúsculas como
(/keyword/).test(source)
Escribí una extensión. muy trivial
if (typeof String.prototype.isEqual!= ''function'') {
String.prototype.isEqual = function (str){
return this.toUpperCase()==str.toUpperCase();
};
}
Hay dos formas de comparación entre mayúsculas y minúsculas:
- Convierta cadenas a mayúsculas y luego compárelas con el operador estricto (
===). Cómo el operador estricto trata a los operandos, lea cosas en: http://www.thesstech.com/javascript/relational-logical-operators - Coincidencia de patrones utilizando métodos de cadena:
Utilice el método de cadena de "búsqueda" para la búsqueda no sensible a mayúsculas. Lea acerca de la búsqueda y otros métodos de cadena en: http://www.thesstech.com/pattern-matching-using-string-methods
<!doctype html>
<html>
<head>
<script>
// 1st way
var a = "apple";
var b = "APPLE";
if (a.toUpperCase() === b.toUpperCase()) {
alert("equal");
}
//2nd way
var a = " Null and void";
document.write(a.search(/null/i));
</script>
</head>
</html>
Incluso esta pregunta ya ha respondido. Tengo un enfoque diferente para usar RegExp y hacer coincidir para ignorar las mayúsculas y minúsculas. Por favor vea mi enlace https://jsfiddle.net/marchdave/7v8bd7dq/27/
$("#btnGuess").click(guessWord);
function guessWord() {
var letter = $("#guessLetter").val();
var word = ''ABC'';
var pattern = RegExp(letter, ''gi''); // pattern: /a/gi
var result = word.match(pattern);
alert(''Ignore case sensitive:'' + result);
}
La forma más sencilla de hacerlo (si no está preocupado por los caracteres especiales de Unicode) es llamar a toUpperCase :
var areEqual = string1.toUpperCase() === string2.toUpperCase();
Muchas respuestas aquí, pero me gusta agregar una solución basada en la extensión del String lib:
String.prototype.equalIgnoreCase = function(str)
{
return (str != null
&& typeof str === ''string''
&& this.toUpperCase() === str.toUpperCase());
}
¡De esta manera puedes usarlo como lo haces en Java!
Ejemplo:
var a = "hello";
var b = "HeLLo";
var c = "world";
if (a.equalIgnoreCase(b)) {
document.write("a == b");
}
if (a.equalIgnoreCase(c)) {
document.write("a == c");
}
if (!b.equalIgnoreCase(c)) {
document.write("b != c");
}
La salida será:
"a == b"
"b != c"
String.prototype.equalIgnoreCase = function(str) {
return (str != null &&
typeof str === ''string'' &&
this.toUpperCase() === str.toUpperCase());
}
var a = "hello";
var b = "HeLLo";
var c = "world";
if (a.equalIgnoreCase(b)) {
document.write("a == b");
document.write("<br>");
}
if (a.equalIgnoreCase(c)) {
document.write("a == c");
}
if (!b.equalIgnoreCase(c)) {
document.write("b != c");
}
Recientemente, he creado una micro biblioteca que brinda ayuda a las cadenas que no distinguen entre mayúsculas y minúsculas: https://github.com/nickuraltsev/ignore-case . (Utiliza toUpperCase internamente.)
var ignoreCase = require(''ignore-case'');
ignoreCase.equals(''FOO'', ''Foo''); // => true
ignoreCase.startsWith(''foobar'', ''FOO''); // => true
ignoreCase.endsWith(''foobar'', ''BaR''); // => true
ignoreCase.includes(''AbCd'', ''c''); // => true
ignoreCase.indexOf(''AbCd'', ''c''); // => 2
Recuerde que la carcasa es una operación específica de locale. Dependiendo del escenario, es posible que desee tenerlo en cuenta. Por ejemplo, si está comparando nombres de dos personas, es posible que desee considerar la configuración regional, pero si está comparando valores generados por máquinas, como UUID, es posible que no lo haga. Esta es la razón por la que uso la siguiente función en mi biblioteca de utilidades (tenga en cuenta que la comprobación de tipos no se incluye por motivos de rendimiento)
function compareStrings (string1, string2, ignoreCase, useLocale) {
if (ignoreCase) {
if (useLocale) {
string1 = string1.toLocaleLowerCase();
string2 = string2.toLocaleLowerCase();
}
else {
string1 = string1.toLowerCase();
string2 = string2.toLowerCase();
}
}
return string1 === string2;
}
Si ambas cadenas tienen la misma configuración regional conocida, es posible que desee utilizar el objeto Intl.Collator esta manera:
function equalIgnoreCase(s1: string, s2: string) {
return new Intl.Collator("en-US", { sensitivity: "base" }).compare(s1, s2) === 0;
}
Obviamente, es posible que desee almacenar en caché el Collator para una mejor eficiencia.
Las ventajas de este enfoque es que debería ser mucho más rápido que el uso de RegExps y se basa en un conjunto extremadamente personalizable (consulte la descripción de las locales y los parámetros del constructor de options en el artículo anterior) de compiladores listos para usar.
Si está preocupado por la dirección de la desigualdad (quizás quiera ordenar una lista), tiene que hacer una conversión de mayúsculas, y ya que hay más caracteres en minúscula en unicode que en mayúsculas, toLowerCase es probablemente la mejor conversión a utilizar.
function my_strcasecmp( a, b )
{
if((a+'''').toLowerCase() > (b+'''').toLowerCase()) return 1
if((a+'''').toLowerCase() < (b+'''').toLowerCase()) return -1
return 0
}
Javascript parece usar la configuración regional "C" para las comparaciones de cadenas, por lo que el orden resultante será feo si las cadenas contienen letras que no sean ASCII. no se puede hacer mucho al respecto sin hacer una inspección mucho más detallada de las cuerdas.
Supongamos que queremos encontrar la needle variable de cadena en el haystack variable de cadena. Hay tres trampas:
- Las aplicaciones internacionalizadas deben evitar
string.toUpperCaseystring.toLowerCase. Utilice una expresión regular que ignora el caso en su lugar. Por ejemplo,var needleRegExp = new RegExp(needle, "i");seguido deneedleRegExp.test(haystack). - En general, es posible que no sepa el valor de la
needle. Tenga cuidado de que laneedleno contenga ningún carácter especial de expresión regular. Escape de estos usandoneedle.replace(/[-[/]{}()*+?.,//^$|#/s]/g, "//$&");. - En otros casos, si desea hacer coincidir con precisión la
needley elhaystack, simplemente ignorando el caso, asegúrese de agregar"^"al comienzo y"$"al final de su constructor de expresiones regulares.
Teniendo en cuenta los puntos (1) y (2), un ejemplo sería:
var haystack = "A. BAIL. Of. Hay.";
var needle = "bail.";
var needleRegExp = new RegExp(needle.replace(/[-[/]{}()*+?.,//^$|#/s]/g, "//$&"), "i");
var result = needleRegExp.test(haystack);
if (result) {
// Your code here
}
usar regix para la concordancia de cadenas o comparación,
en javaScript, puede usar match () para la comparación de cadenas, no olvide poner i en regix
ejemplo:
var matchString = "Test" ;
if(matchString.match(/test/i) ){
alert(''String matched) ;
}else{
alert(''String not matched'') ;
}
EDITAR : Esta respuesta tiene 7 años. Hoy deberías usar developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… .
Respuesta original
La mejor manera de hacer una comparación entre mayúsculas y minúsculas en JavaScript es usar el método RegExp match () con la marca ''i''.
JavaScript: búsqueda insensible a mayúsculas
Cuando las dos cadenas que se comparan son variables (no constantes), entonces es un poco más complicado porque necesita generar un RegExp desde la cadena, pero pasar la cadena al constructor RegExp puede dar como resultado coincidencias incorrectas o fallidas si la cadena tiene una expresión regular especial personajes en el
Si le importa la internacionalización, no use toLowerCase () o toUpperCase (), ya que no ofrece comparaciones precisas y sensibles a mayúsculas y minúsculas en todos los idiomas.
str = ''Lol'', str2 = ''lOl'', regex = new RegExp(''^'' + str + ''$'', ''i'');
if (regex.test(str)) {
console.log("true");
}