JavaScript zawiera przypadek niewrażliwe

Question

Mam następujący:

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

Co chciałbym zrobić, to zrobić Ral wielkość liter ma znaczenie, tak że może być RAl, rAl, itd. I nadal pasuje.

Czy istnieje sposób na stwierdzenie, że Ral musi być niewrażliwy na wielkość znaków?

Answer 1

Dodaj .toLowerCase() po referrer. Ta metoda zamienia łańcuch w łańcuch małych liter. Następnie użyj .indexOf(), używając ral zamiast Ral.

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

To samo można osiągnąć za pomocą wyrażenia regularnego (szczególnie przydatne, gdy chcesz przetestować przed dynamicznych wzorów):

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

Answer 2

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

Answer 3

Użyj RegExp:

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

Lub użyj .toLowerCase():

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

Answer 4

Istnieje kilka podejść tutaj.

Jeśli chcesz wykonać sprawdzanie niewrażliwe na wielkość liter tylko dla tego wystąpienia, wykonaj następujące czynności.

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

Alternatywnie, jeśli regularnie wykonywania tej kontroli, można dodać nową metodę indexOf() -Jak do String, ale sprawiają, że wielkość liter ma znaczenie.

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

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

Answer 5

zrobić lepiej szukaj użyć następującego kodu,

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())); 

W pierwszym alert(), JavaScript zwrócony "-1" - innymi słowy, indexOf() nie znaleźliśmy mecz : dzieje się tak dlatego, że "JavaScript" jest pisany małymi literami w pierwszym łańcuchu znaków i odpowiednio pisany wielkimi literami w drugim. Aby wykonać wyszukiwanie bez rozróżniania wielkości liter za pomocą metody indexOf(), możesz ustawić oba łańcuchy jako wielkie lub małe litery. Oznacza to, że podobnie jak w drugim alertu(), JavaScript sprawdza jedynie występowanie szukanego ciągu znaków, ignorując wielkie litery.

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

Answer 6

Kolejne opcji jest użycie metody wyszukiwania następująco:

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

To wygląda bardziej elegancki następnie przekształcając cały ciąg na małe i mogą być bardziej efektywne.
Z toLowerCase() kod ma dwa przejścia przez ciąg, jedno przejście jest na całym łańcuchu, aby przekonwertować go na małe litery, a drugie na szukanie pożądanego indeksu.
Z RegExp kod ma jedno przejście przez ciąg, który wygląda, aby dopasować żądany indeks.

Dlatego na długich ciągów polecam użyć wersji RegExp (myślę, że na krótkich ciągów sprawność ta przychodzi na rachunku tworzenia obiektu RegExp chociaż)

Answer 7

To 2016, i nie ma wyraźny sposób jak to zrobić? Miałem nadzieję na jakąś copypastę. Muszę iść.

Uwagi do projektu: chciałem zminimalizować wykorzystanie pamięci, a zatem poprawić prędkość - aby nie było kopiowania/mutowania ciągów. Zakładam, że V8 (i inne silniki) mogą zoptymalizować tę funkcję.

//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; 
} 

Mój powód dla nazwy:

• IndexOf powinien mieć w nazwie
• Nie dodanie przyrostka - Z odnosi się do następnego parametru
• nie wolno używać „CASEINSENSITIVE "To jest bardzo długie"
• "naturalny" jest dobrym kandydatem, ponieważ domyślne porównania wielkości liter nie są dla ludzi naturalne.

Dlaczego nie ...:

• toLowerCase() - potencjalne ponawianych wezwań toLowerCase na tym samym ciąg.
• RegExp - niezręczny do wyszukiwania ze zmienną. Nawet obiekt RegExp jest niewygodne konieczności ucieczki znaki

Answer 8

Oto moje zdanie:

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> 

Codepen