REGEX_A: 55 * [Это соответствует «5», «55», «555» и т. д. и делает НЕ соответствует «4», «54» и т. Д.]
REGEX_B: 5 * [Это соответствует «", "5" "55", "555" и т. Д. И не соответствует "4", "54 "и т. д.]
[Здесь мы предположили, что 55 * неявно. 55 . * и 5 * нет. 5 . * - Вот почему 5 * не соответствует 4]
{A} - 5 - & gt; {B} - epsilon - & gt; {C} - 5 - & gt; {D} - epsilon - & gt; {E} {B} ----------------- epsilon - ------- & GT; {E} {C} & lt; --- epsilon ------ {E}
{A} - epsilon - & gt; {B} - 5 - & gt; {C} - epsilon - & gt; {D} {A} -------------- epsilon ----------- & gt; {D} {B} & lt; --- epsilon ------ {D}
NFA: {состояние A} --- epsilon - & gt; {состояние B} --- 5 - & gt; {state C} --- 5 - & gt; {состояние D} {состояние C} --- epsilon - & gt; {состояние D} {состояние C} & lt; --- epsilon - {состояние D} {состояние A} --- epsilon - & gt; {state E} --- 5 - & gt; {состояние F} {состояние E} --- epsilon - & gt; {состояние F} {состояние E} & lt; --- epsilon - {состояние F} NFA - & gt; DFA: | 5 | epsilon * ---- + -------------- + -------- A | B, C, E, F, G | A, C, E, F B | C, D, E, F | B, C, E, F c | C, D, E, F | C D | C, D, E, F, G | C, D, E, F E | C, D, E, F, G | C, E, F F | C, E, F, G | F G | C, D, E, G | C, E, F, G 5 (epsilon *) ------------- + --------------------- A | B, C, E, F, G B, C, E, F, G | C, D, E, F, G C, D, E, F, G | C, D, E, F, G Наконец, DFA для (REGEX_A | REGEX_B): {A} - 5 --- & gt; {B, C, E, F, G} - 5 --- & gt; {C, D, E, F, G} {C, D, E, F, G} --- 5 - & gt; {C, D, E, F, G} Примечание: {A} является начальным состоянием и {C, D, E, F, G} принимает состояние.
| 5 | epsilon * ---- + -------- + -------- A | B, C, E | A B | C, D, E | B, C, E C | C, D, E | C D | C, D, E | C, D, E E | C, D, E | C, E 5 (epsilon *) ------- + --------------------- A | B, C, E B, C, E | C, D, E C, D, E | C, D, E {A} ---- 5 ----- & gt; {B, C, E} - 5 --- {C, D, E} {C, D, E} - 5 --- & gt; {C, D, E} Примечание: {A} является (C, D, E) принимает состояние
| 5 | epsilon * ---- + -------- + -------- A | B, C, D | A, B, D B | B, C, D | B C | B, C, D | B, C, D D | B, C, D | B, D 5 (epsilon *) ------- + --------------------- A | B, C, D B, C, D | B, C, D {A} ---- 5 ----- & gt; {B, C, D} {B, C, D} --- 5 --- & gt; {B, C, D} Примечание: {A} является начальным состоянием и {B, C, D} принимает состояние
DFA REGX_A | REGX_B, идентичный DFA REGX_A, подразумевает, что REGEX_A является подмножеством REGEX_B DFA REGX_A | REGX_B НЕ идентичен DFA REGX_B - не может выводиться ни о каких gerexes.
Самый простой способ сделать это (если вас не беспокоят специальные символы Unicode) - вызвать toUpperCase
:
var areEqual = string1.toUpperCase() === string2.toUpperCase();
Существует два способа сравнения без учета регистра:
===
). Как строго оператор обрабатывает операнды, читает материал по адресу: http://www.thesstech.com/javascript/relational-logical-operators Используйте метод строки поиска для поиска без учета регистра. Читайте о методах поиска и других строковых методах по адресу: 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>
Если обе строки имеют одну и ту же известную локаль, вы можете использовать объект Intl.Collator
следующим образом:
function equalIgnoreCase(s1: string, s2: string) {
return new Intl.Collator("en-US", { sensitivity: "base" }).compare(s1, s2) === 0;
}
Очевидно, что вам может понадобиться кэшировать Collator
для повышения эффективности.
Преимущества этого подхода заключаются в том, что он должен быть намного быстрее, чем при использовании RegExps, и основан на чрезвычайно настраиваемом (см. описание параметров конструктора locales
и options
в статья выше) набор готовых к использованию коллакторов.
accent
, что делает регистр нечувствительным к регистру, но рассматривает a
и á
как отдельные символы. Таким образом, base
или accent
могут быть подходящими в зависимости от конкретных потребностей.
– Matthew Crumley
13 April 2018 в 16:28
Как насчет того, чтобы НЕ выбрасывать исключения и НЕ использовать медленное регулярное выражение?
return str1 != null && str2 != null
&& typeof str1 === 'string' && typeof str2 === 'string'
&& str1.toUpperCase() === str2.toUpperCase();
Вышеприведенный фрагмент предполагает, что вы не хотите, чтобы строка была нулевой или неопределенной.
Если вы хотите совместить null / undefined, то:
return (str1 == null && str2 == null)
|| (str1 != null && str2 != null
&& typeof str1 === 'string' && typeof str2 === 'string'
&& str1.toUpperCase() === str2.toUpperCase());
Если по какой-то причине вам небезразличен неопределенный 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());
Предположим, мы хотим найти строковую переменную needle
в строковой переменной haystack
. Есть три ошибки:
string.toUpperCase
и string.toLowerCase
. Используйте регулярное выражение, которое вместо этого игнорирует случай. Например, var needleRegExp = new RegExp(needle, "i");
, а затем needleRegExp.test(haystack)
. needle
. Будьте осторожны, чтобы needle
не содержал никаких регулярных выражений специальных символов . Побегите их с помощью needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
. needle
и haystack
, просто игнорируя случай, не забудьте добавить "^"
в начале и "$"
в конце вашего конструктора регулярных выражений. Принимая во внимание точки (1) и (2), примером может быть:
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
}
new RegExp(...)
в строке 3 следующим: new RegExp("^" + needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") + "$", "i");
. Это гарантирует, что нет других символов до или после строки поиска needle
.
– Chris Chute
26 July 2016 в 21:23
Даже этот вопрос уже ответил. У меня есть другой подход к использованию RegExp и совпадение, чтобы игнорировать регистр. См. Мою ссылку 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);
}
С помощью регулярного выражения мы также можем достичь.
(/keyword/i).test(source)
/i
для случая игнорирования. Если это не необходимо, мы можем игнорировать и проверять соответствие нечувствительности к регистру, например
(/keyword/).test(source)
keyWORD
будет указывать результат в положительном совпадении. Но строка this is a keyword yo
или keywords
также приведет к положительному совпадению. Помните об этом :-)
– Elmer
25 October 2017 в 10:25
, если вас беспокоит направление неравенства (возможно, вы хотите отсортировать список), вам очень нужно сделать case-преобразование, а так как в юникоде есть более строчные символы, чем в верхнем регистре toLowerCase, вероятно, лучшее преобразование для использования.
function my_strcasecmp( a, b )
{
if((a+'').toLowerCase() > (b+'').toLowerCase()) return 1
if((a+'').toLowerCase() < (b+'').toLowerCase()) return -1
return 0
}
Javascript, похоже, использует языковой стандарт «C» для сравнения строк, поэтому результирующий порядок будет уродлив, если строки содержат буквы, отличные от ASCII. не так много можно сделать по этому поводу, не делая более подробного осмотра строк.
Как сказано в последних комментариях, string::localCompare
поддерживает нечувствительные к регистру сравнения (среди других мощных вещей).
Вот простой пример
'xyz'.localeCompare('XyZ', undefined, { sensitivity: 'base' }); // returns 0
И общую функцию, которую вы могли бы использовать
function equalsIgnoringCase(text, other) {
text.localeCompare(other, undefined, { sensitivity: 'base' }) === 0;
}
Обратите внимание, что вместо undefined
вы, вероятно, должны ввести конкретный язык, с которым работаете. Это важно, как указано в документах MDN
на шведском языке, а а - отдельные базовые буквы
Параметры чувствительности
Поддержка браузера
С момента публикации UC Browser для Android и Opera Mini не поддерживает locale и параметры . Пожалуйста, проверьте https://caniuse.com/#search=localeCompare для актуальной информации.
Я написал расширение. очень тривиальный
if (typeof String.prototype.isEqual!= 'function') {
String.prototype.isEqual = function (str){
return this.toUpperCase()==str.toUpperCase();
};
}
String#isEqual
или Object#isEqual
, все ваши страницы ведут себя по-другому и могут делать странные вещи, если спецификация не соответствует вашим требованиям.
– Robert
8 December 2014 в 01:07
prototype.ksxIsEqual
, тогда, если вы захотите найти все свои расширения, у вас будет простой способ сделать это, и это, вероятно, никогда не конфликтует.
– Eric Bishard
23 August 2015 в 05:35
Здесь много ответов, но я хотел бы добавить решение, основанное на расширении String lib:
String.prototype.equalIgnoreCase = function(str)
{
return (str != null
&& typeof str === 'string'
&& this.toUpperCase() === str.toUpperCase());
}
Таким образом вы можете просто использовать его так же, как в Java!
Пример:
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");
}
Выход будет:
"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");
}
Недавно я создал микробиблиотеку, которая предоставляет нечувствительные к регистру строковые помощники: https://github.com/nickuraltsev/ignore-case . (Он внутренне использует toUpperCase
.)
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
Поскольку никакой ответ явно не предоставил простой фрагмент кода для использования RegExp
, вот моя попытка:
function compareInsensitive(str1, str2){
return typeof str1 === 'string' &&
typeof str2 === 'string' &&
new RegExp("^" + str1.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + "$", "i").test(str2);
}
Он имеет ряд преимуществ:
undefined
, например, вырвал бы выражение, подобное str1.toUpperCase()
). RegExp
. используйте regex для сопоставления строк или сравнения,
в javaScript, вы можете использовать match () для сравнения строк, не забудьте поставить i в примере regex
:
var matchString = "Test" ;
if(matchString.match(/test/i) ){
alert('String matched) ;
}else{
alert('String not matched') ;
}
str = 'Lol', str2 = 'lOl', regex = new RegExp('^' + str + '$', 'i');
if (regex.test(str)) {
console.log("true");
}
EDIT: Этот ответ 7 лет. Сегодня вы должны использовать localeCompare
.
Оригинальный ответ
Лучший способ сделать нечувствительное к регистру сравнение в JavaScript - использовать метод RegExp match () с флагом 'i'.
JavaScript: нечувствительный к регистру поиск
Когда обе сравниваемые строки являются переменными (не константами), то это немного сложнее, потому что вам нужно сгенерируйте RegExp из строки, но передача строки в конструктор RegExp может привести к неправильным совпадениям или неудачным совпадениям, если строка содержит специальные символы регулярных выражений.
Если вы интересуетесь интернационализацией, не используйте toLowerCase () или toUpperCase (), поскольку он не обеспечивает точных нечувствительных к регистру сравнений на всех языках.
'a'.localeCompare('A')
и, как и op, я ищу сравнение строк, нечувствительное к регистру.
– StingyJack
19 March 2018 в 02:53
Помните, что корпус - это специфичная для локали операция. В зависимости от сценария вы можете принять это за счет. Например, если вы сравниваете имена двух человек, вы можете захотеть рассмотреть локаль, но если вы сравниваете машинные сгенерированные значения, такие как UUID, то вы можете этого не сделать. Поэтому я использую следующую функцию в моей утилите utils (обратите внимание, что проверка типа не включена для повышения производительности).
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;
}
if you're not worried about special Unicode characters
. – SLaks 26 January 2010 в 17:22toUpperCase
по сравнению сtoLowerCase
? – jpmc26 27 May 2014 в 16:57