javascript - regulares - Contiene mayúsculas y minúsculas

validar expresiones regulares online

Question

Tengo los siguientes

if (referrer.indexOf("Ral") == -1) { ... }

Lo que me gusta hacer es hacer que Ral sea ​​insensible a mayúsculas, para que pueda ser RAl , rAl , etc. y aún así coincidir.

¿Hay alguna manera de decir que Ral debe ser sensible a mayúsculas y minúsculas?

Answer 1

¿Es 2016 y no hay una forma clara de cómo hacer esto? Esperaba algo de copypasta. Voy a tener una oportunidad.

Notas de diseño: quería minimizar el uso de la memoria y, por lo tanto, mejorar la velocidad, por lo que no hay que copiar / mutar las cadenas. Supongo que V8 (y otros motores) pueden optimizar esta función.

//TODO: Performance testing
String.prototype.naturalIndexOf = function(needle) {
    //TODO: guard conditions here

    var haystack = this; //You can replace `haystack` for `this` below but I wan''t to make the algorithm more readable for the answer
    var needleIndex = 0;
    var foundAt = 0;
    for (var haystackIndex = 0; haystackIndex < haystack.length; haystackIndex++) {
        var needleCode = needle.charCodeAt(needleIndex);
        if (needleCode >= 65 && needleCode <= 90) needleCode += 32; //ToLower. I could have made this a function, but hopefully inline is faster and terser
        var haystackCode = haystack.charCodeAt(haystackIndex);
        if (haystackCode >= 65 && haystackCode <= 90) haystackCode += 32; //ToLower. I could have made this a function, but hopefully inline is faster and terser

        //TODO: code to detect unicode characters and fallback to toLowerCase - when > 128?
        //if (needleCode > 128 || haystackCode > 128) return haystack.toLocaleLowerCase().indexOf(needle.toLocaleLowerCase();
        if (haystackCode !== needleCode)
        {
            foundAt = haystackIndex;
            needleIndex = 0; //Start again
        }
        else
            needleIndex++;

        if (needleIndex == needle.length)
            return foundAt;
    }

    return -1;
}

Mi razón para el nombre:

• Debería tener IndexOf en el nombre
• No agregue un sufijo - De se refiere al siguiente parámetro
• No use "CaseInsensitive" que es muy largo
• "natural" es un buen candidato, porque las comparaciones por defecto entre mayúsculas y minúsculas no son naturales para los humanos en primer lugar.

Por qué no...:

• toLowerCase() : posibles llamadas repetidas a toLowerCase en la misma cadena.
• RegExp - torpe para buscar con la variable. Incluso el objeto RegExp es torpe tener que escapar de los personajes

Answer 2

Agregue .toLowerCase() después de la referrer . Este método convierte la cadena en una cadena minúscula. Luego, use .indexOf() usando ral lugar de Ral .

if (referrer.toLowerCase().indexOf("ral") === -1) { 

Lo mismo se puede lograr usando una expresión regular (especialmente útil cuando se quiere probar contra patrones dinámicos):

if (!/Ral/i.test(referrer)) {
   //    ^i = Ignore case flag for RegExp

Answer 3

Aquí está mi opinión:

Guión :

var originalText = $("#textContainer").html()
$("#search").on(''keyup'', function () {
  $("#textContainer").html(originalText)
  var text = $("#textContainer").html()
  var val = $("#search").val()
  if(val=="") return;
  var matches = text.split(val)
  for(var i=0;i<matches.length-1;i++) {
    var ind =  matches[i].indexOf(val)
    var len = val.length
      matches[i] = matches[i] + "<span class=''selected''>" + val + "</span>"
  }
  $("#textContainer").html(matches.join(""))

HTML:

<input type="text" id="search">
<div id="textContainer">
lorem ipsum is simply dummy text of the printing and typesetting industry. lorem ipsum has been the industry''s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of letraset sheets containing lorem ipsum passages, and more recently with desktop publishing software like Aldus pagemaker including versions of lorem ipsum.</div>

Codepen

Answer 4

Desde ES2016 también puede utilizar un método ligeramente mejor / más sencillo / más elegante:

if (referrer.includes("Ral")) { ... }

o

if (referrer.toLowerCase().includes(someString.toLowerCase())) { ... }

Aquí hay una comparación de .indexOf() y .includes() : https://dev.to/adroitcoder/includes-vs-indexof-in-javascript

Answer 5

Hay un par de enfoques aquí.

Si desea realizar una comprobación que no distinga mayúsculas y minúsculas solo para esta instancia, haga algo como lo siguiente.

if (referrer.toLowerCase().indexOf("Ral".toLowerCase()) == -1) {
    ...

Alternativamente, si realiza esta comprobación con regularidad, puede agregar un nuevo método similar a indexOf() a la String , pero puede hacer que sea insensible.

String.prototype.indexOfInsensitive = function (s, b) {
    return this.toLowerCase().indexOf(s.toLowerCase(), b);
}

// Then invoke it
if (referrer.indexOfInsensitive("Ral") == -1) { ...

Answer 6

Otra opción es usar el método de búsqueda de la siguiente manera:

if (referrer.search(new RegExp("Ral", "i")) == -1) { ...

Parece más elegante que la conversión de toda la cadena a minúsculas y puede ser más eficiente.
Con toLowerCase() el código tiene dos pasadas sobre la cadena, una pasada está en toda la cadena para convertirla en minúsculas y otra es buscar el índice deseado.
Con RegExp el código tiene una pasada sobre la cadena que parece coincidir con el índice deseado.

Por lo tanto, en cadenas largas recomiendo usar la versión RegExp (aunque supongo que en cadenas cortas, esta eficiencia viene de la cuenta de la creación RegExp objeto RegExp )

Answer 7

Para hacer una mejor búsqueda usa el siguiente código,

var myFav   = "javascript";
var theList = "VB.NET, C#, PHP, Python, JavaScript, and Ruby";

// Check for matches with the plain vanilla indexOf() method:
alert( theList.indexOf( myFav ) );

// Now check for matches in lower-cased strings:
alert( theList.toLowerCase().indexOf( myFav.toLowerCase() ) );

En la primera alerta (), JavaScript devolvió "-1"; en otras palabras, indexOf () no encontró una coincidencia: esto se debe simplemente a que "JavaScript" está en minúscula en la primera cadena y correctamente en mayúscula en la segunda. Para realizar búsquedas sin distinción de mayúsculas y minúsculas con indexOf (), puede hacer que ambas cadenas estén en mayúsculas o minúsculas. Esto significa que, al igual que en la segunda alerta (), JavaScript solo comprobará la aparición de la cadena que está buscando, ignorando el uso de mayúsculas.

Referencia, http://freewebdesigntutorials.com/javaScriptTutorials/jsStringObject/indexOfMethod.htm

Answer 8

Utilice un RegExp:

if (!/ral/i.test(referrer)) {
    ...
}

O, use .toLowerCase() :

if (referrer.toLowerCase().indexOf("ral") == -1)

Answer 9

if (referrer.toUpperCase().indexOf("RAL") == -1) { ...