Respostas:
Adicione .toLowerCase()
depois referrer
. Esse método transforma a string em uma minúscula. Em seguida, use .indexOf()
usando em ral
vez de Ral
.
if (referrer.toLowerCase().indexOf("ral") === -1) {
O mesmo também pode ser alcançado usando uma expressão regular (especialmente útil quando você deseja testar padrões dinâmicos):
if (!/Ral/i.test(referrer)) {
// ^i = Ignore case flag for RegExp
.search
:var index = referrer.search(/Ral/i);
Outra opção é usar o método de pesquisa da seguinte maneira:
if (referrer.search(new RegExp("Ral", "i")) == -1) { ...
Parece mais elegante do que converter toda a cadeia para minúscula e pode ser mais eficiente.
Com toLowerCase()
o código tem duas passagens sobre a sequência, uma passagem está na sequência inteira para convertê-la em minúsculas e outra é procurar o índice desejado.
Com RegExp
o código, passe uma sobre a string que parece corresponder ao índice desejado.
Portanto, em cordas longas, recomendo usar a RegExp
versão (acho que em cordas curtas essa eficiência é responsável pela criação do RegExp
objeto)
Use um RegExp:
if (!/ral/i.test(referrer)) {
...
}
Ou use .toLowerCase()
:
if (referrer.toLowerCase().indexOf("ral") == -1)
No ES2016, você também pode usar o método um pouco melhor / mais fácil / mais elegante (diferencia maiúsculas de minúsculas):
if (referrer.includes("Ral")) { ... }
ou (sem distinção entre maiúsculas e minúsculas):
if (referrer.toLowerCase().includes(someString.toLowerCase())) { ... }
Aqui está uma comparação de .indexOf()
e .includes()
:
https://dev.to/adroitcoder/includes-vs-indexof-in-javascript
includes
faz distinção entre maiúsculas e minúsculas no Chrome: try 'fooBar'.includes('bar')
==>false
Existem algumas abordagens aqui.
Se você deseja executar uma verificação sem distinção entre maiúsculas e minúsculas apenas para esta instância, faça algo como o seguinte.
if (referrer.toLowerCase().indexOf("Ral".toLowerCase()) == -1) {
...
Como alternativa, se você estiver executando essa verificação regularmente, poderá adicionar um novo indexOf()
método semelhante a String
, mas torná-lo sem distinção entre maiúsculas e minúsculas.
String.prototype.indexOfInsensitive = function (s, b) {
return this.toLowerCase().indexOf(s.toLowerCase(), b);
}
// Then invoke it
if (referrer.indexOfInsensitive("Ral") == -1) { ...
defineProperty
, eu sugiro Object.defineProperty(String.prototype, 'indexOfInsensitive', {value: function(s,b){return this.toLowerCase().indexOf((s+'').toLowerCase(),b);}});
. Duas atualizações: Conversão explícita de cadeias usando (s+'')
e não enumerável em um loop ( for(var i in '') ...
não aparece indexOfInsensitive
.
if (referrer.toUpperCase().indexOf("RAL") == -1) { ...
Você pode tentar isso
str = "Wow its so COOL"
searchStr = "CoOl"
console.log(str.toLowerCase().includes(searchStr.toLowerCase()))
Exemplo para qualquer idioma:
'My name is Хведор'.toLocaleLowerCase().includes('ХвЕдОр'.toLocaleLowerCase())
É 2016 e não há uma maneira clara de como fazer isso? Eu estava esperando um pouco de copypasta. Eu vou tentar.
Notas de design: eu queria minimizar o uso de memória e, portanto, melhorar a velocidade - para que não haja cópia / mutação de strings. Presumo que o V8 (e outros mecanismos) possa otimizar essa função.
//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;
}
Minha razão para o nome:
Por que não...:
toLowerCase()
- possíveis chamadas repetidas para toLowerCase na mesma sequência.RegExp
- estranho procurar com variável. Até o objeto RegExp é estranho, tendo que escapar caracteresPara fazer uma pesquisa melhor, use o código a seguir,
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() ) );
No primeiro alerta (), o JavaScript retornou "-1" - em outras palavras, indexOf () não encontrou uma correspondência: isso ocorre simplesmente porque "JavaScript" está em minúscula na primeira string e em maiúscula na segunda. Para executar pesquisas que não diferenciam maiúsculas de minúsculas com indexOf (), você pode criar ambas as strings em maiúsculas ou minúsculas. Isso significa que, como no segundo alerta (), o JavaScript verificará apenas a ocorrência da sequência que você está procurando, com letras maiúsculas ignoradas.
Referência, http://freewebdesigntutorials.com/javaScriptTutorials/jsStringObject/indexOfMethod.htm
Se referrer
é uma matriz, você pode usarfindIndex()
if(referrer.findIndex(item => 'ral' === item.toLowerCase()) == -1) {...}
Aqui está a minha opinião:
Script :
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>
RegExp
entrada diretamente do usuário. Por exemplo, um usuário pode entrar*
e um erro será gerado noRegExp
construtor. A solução aceita não tem esse problema.