MongoDB: Czy można wykonać zapytanie bez rozróżniania wielkości liter?

304

Przykład:

> db.stuff.save({"foo":"bar"});

> db.stuff.find({"foo":"bar"}).count();
1
> db.stuff.find({"foo":"BAR"}).count();
0
Luke Dennis
źródło
3
Od wersji MongoDB 3.2 można wykonywać wyszukiwanie bez rozróżniania wielkości liter $caseSensitive: false. Zobacz: docs.mongodb.org/manual/reference/operator/query/text/…
martin
4
Pamiętaj, że dotyczy to tylko indeksów tekstowych.
Willem D'Haeseleer
1
@martin: domyślnie $caseSensitivejest fałszem i to nie odpowiada na pytanie, ponieważ działa tylko na indeksowanych polach. OP szukał porównania ciągów bez rozróżniania wielkości liter.
Dan Dascalescu

Odpowiedzi:

342

Możesz użyć wyrażenia regularnego .

W twoim przykładzie byłoby to:

db.stuff.find( { foo: /^bar$/i } );

Muszę jednak powiedzieć, że może po prostu zmniejszysz wartość (lub zwiększysz) wartość po drodze, zamiast ponosić dodatkowy koszt za każdym razem, gdy ją znajdziesz. Oczywiście nie zadziała to w przypadku nazwisk osób i tym podobnych, ale może przypadków użycia takich jak tagi.

rfunduk
źródło
27
To działa idealnie. Działa w PHP z: $ collection-> find (array ('key' => new MongoRegex ('/'.$ val.' / I ')));
Luke Dennis,
2
Zwłaszcza jeśli interpolujesz ciąg znaków ({foo: / # {x} / i}), który może mieć w nim znak zapytania.
Peter Ehrlich
17
Nie zapomnij także ^ i $: MongoRegex ('/ ^'. Preg_quote ($ val). '$ / I')
Julien
20
Zauważ, że wykona to pełny skan zamiast używania indeksu.
Martin Konicek,
12
nie zrobi pełnego skanowania, jeśli użyje kotwicy na początku, stąd ważność porad Juliena.
Pax,
198

AKTUALIZACJA:

Oryginalna odpowiedź jest już nieaktualna. Mongodb obsługuje teraz zaawansowane wyszukiwanie pełnotekstowe z wieloma funkcjami.

ORYGINALNA ODPOWIEDŹ:

Należy zauważyć, że wyszukiwanie z rozróżnianiem wielkości liter w wyrażeniach regularnych / i oznacza, że ​​mongodb nie może wyszukiwać według indeksu, więc zapytania do dużych zestawów danych mogą zająć dużo czasu.

Nawet przy małych zestawach danych nie jest to zbyt wydajne. Przyjmujesz znacznie większą moc procesora niż twoje zapytanie, co może stać się problemem, jeśli próbujesz osiągnąć skalę.

Alternatywnie możesz przechowywać wielką kopię i wyszukiwać według niej. Na przykład mam tabelę użytkowników, która ma nazwę użytkownika, która jest wielkimi literami, ale identyfikator jest wielką literą nazwy użytkownika. Zapewnia to, że powielanie z rozróżnianiem wielkości liter jest niemożliwe (nie można zarówno używać „Foo”, jak i „foo”), i mogę wyszukiwać według id = nazwa_użytkownika.toUpperCase (), aby uzyskać wyszukiwanie nazwy użytkownika bez rozróżniania wielkości liter.

Jeśli twoje pole jest duże, na przykład treść wiadomości, powielanie danych prawdopodobnie nie jest dobrym rozwiązaniem. Uważam, że użycie zewnętrznego indeksatora, takiego jak Apache Lucene, jest najlepszą opcją w tym przypadku.

Dan
źródło
1
@Dan, tylko dla informacji, w najnowszym MongoDB: „Jeśli istnieje indeks dla pola, wówczas MongoDB dopasowuje wyrażenie regularne do wartości w indeksie, co może być szybsze niż skanowanie kolekcji”. - docs.mongodb.org/manual/reference/operator/query/regex/…
Sergiy Sokolenko
1
Dokumenty mogą być zaktualizowane. Mówią teraz: „W przypadku zapytań wyrażeń regularnych z rozróżnianiem wielkości liter, jeśli dla pola istnieje indeks, wówczas MongoDB dopasowuje wyrażenie regularne do wartości w indeksie, co może być szybsze niż skanowanie kolekcji”.
Jeff Lewis,
1
Kolejnym ograniczeniem z indeksem tekstowym jest to, że możesz mieć tylko jeden na kolekcję (wiele kolumn), więc nie pasuje, jeśli chcesz oddzielić wyszukiwania dla różnych pól dla różnych przypadków.
Paul Grimshaw
2
@SergiySokolenko: doktorzy mówią teraz (ostatni akapit w sekcji ): „Kwerendy wyrażeń regularnych bez rozróżniania wielkości liter zwykle nie mogą efektywnie używać indeksów. Implementacja $ regex nie rozpoznaje sortowania i nie może wykorzystywać indeksów bez rozróżniania wielkości liter”.
Dan Dascalescu
1
Korzystanie z wyszukiwania pełnotekstowego jest w tym przypadku niewłaściwe (i potencjalnie niebezpieczne ), bo pytanie było o dokonanie kwerendy bez uwzględniania wielkości liter, np username: 'bill'dopasowanie BILLlub Billnie kwerendy wyszukiwania pełnotekstowego, która będzie również mecz wynikała słowa o bill, takie jak Bills, billeditd.
Dan Dăscălescu
70

Jeśli chcesz utworzyć wyrażenie regularne ze zmiennej, jest to o wiele lepszy sposób: https://stackoverflow.com/a/10728069/309514

Następnie możesz zrobić coś takiego:

var string = "SomeStringToFind";
var regex = new RegExp(["^", string, "$"].join(""), "i");
// Creates a regex of: /^SomeStringToFind$/i
db.stuff.find( { foo: regex } );

Ma to tę zaletę, że jest bardziej programowy lub możesz zwiększyć wydajność, kompilując go wcześniej, jeśli często go używasz.

Zdjęcia
źródło
1
new RegExp("^" + req.params.term.toLowerCase(), "i") działa również dobrze
Tahir Yasin
2
powinieneś rozważyć ucieczkę łańcucha w celu zwiększenia bezpieczeństwa, jeśli zmienna pochodzi z żądania: stackoverflow.com/a/50633536/5195127
davidivad
Począwszy od wersji MongoDB 3.4 dostępna jest natywna obsługa indeksów bez
rozróżniania wielkości liter
64

Pamiętaj, że poprzedni przykład:

db.stuff.find( { foo: /bar/i } );

spowoduje, że wszystkie wpisy zawierające pasek będą pasować do zapytania (bar1, barxyz, openbar), może być bardzo niebezpieczne dla wyszukiwania nazwy użytkownika w funkcji auth ...

Może być konieczne dopasowanie go tylko do wyszukiwanego hasła przy użyciu odpowiedniej składni wyrażenia regularnego jako:

db.stuff.find( { foo: /^bar$/i } );

Zobacz http://www.regular-expressions.info/, aby uzyskać pomoc dotyczącą składni wyrażeń regularnych

jflaflamme
źródło
Ta odpowiedź wygląda jak komentarz.
Dan Dascalescu
62

Począwszy od MongoDB 3.4, zalecanym sposobem szybkiego wyszukiwania bez rozróżniania wielkości liter jest użycie indeksu bez rozróżniania wielkości liter .

Osobiście wysłałem e-maila do jednego z założycieli, aby ten działał, a on to sprawił! To był problem na JIRA od 2009 roku i wielu poprosiło o tę funkcję. Oto jak to działa:

Indeks bez rozróżniania wielkości liter jest tworzony przez określenie sortowania o sile 1 lub 2. Można utworzyć indeks bez rozróżniania wielkości liter, jak poniżej:

db.cities.createIndex(
  { city: 1 },
  { 
    collation: {
      locale: 'en',
      strength: 2
    }
  }
);

Możesz także określić domyślne sortowanie dla kolekcji podczas ich tworzenia:

db.createCollection('cities', { collation: { locale: 'en', strength: 2 } } );

W obu przypadkach, aby użyć indeksu bez rozróżniania wielkości liter, musisz określić to samo sortowanie w findoperacji, która była używana podczas tworzenia indeksu lub kolekcji:

db.cities.find(
  { city: 'new york' }
).collation(
  { locale: 'en', strength: 2 }
);

Zwróci „Nowy Jork”, „Nowy Jork”, „Nowy Jork” itp.

Inne notatki

  • Odpowiedzi sugerujące użycie wyszukiwania pełnotekstowego są w tym przypadku błędne (i potencjalnie niebezpieczne ). Pytanie dotyczyło rozróżnienia wielkości liter, npusername: 'bill' dopasowanie BILLlub Bill, a nie kwerendy wyszukiwanie pełnotekstowe, które również mecz wynikała słowa bill, takie jak Bills, billedetc.
  • Odpowiedzi sugerujące użycie wyrażeń regularnych są powolne, ponieważ nawet przy indeksach dokumentacja stwierdza :

    „Kwerendy wyrażeń regularnych bez rozróżniania wielkości liter na ogół nie mogą skutecznie korzystać z indeksów. Implementacja $ regex nie rozpoznaje sortowania i nie może korzystać z indeksów bez rozróżniania wielkości liter.”

    $regexodpowiedzi również narażają na ryzyko wprowadzenia danych przez użytkownika .

użytkownik3413723
źródło
Działa świetnie dla mnie, nawet z potokiem agregacji.
Morio
Myślę, że to właściwa odpowiedź, ponieważ szybkość odczytu danych jest ważna
Rndmax
Nie mogę znaleźć sposobu, aby dodać domyślne sortowanie do kolekcji po jej utworzeniu. Czy jest na to jakiś sposób?
IncrediblePony
19
db.zipcodes.find({city : "NEW YORK"}); // Case-sensitive
db.zipcodes.find({city : /NEW york/i}); // Note the 'i' flag for case-insensitivity
rshivamca
źródło
1
@ OlegV.Volkov musi mieć opis, w jaki sposób twoja odpowiedź jest odpowiednia, a co źle w kodzie pytającego.
Parth Trivedi,
1
Ta odpowiedź tylko do kodu nie dodaje niczego do zaakceptowanej, która została opublikowana 6 lat wcześniej.
Dan Dascalescu
19

TL; DR

Prawidłowy sposób na zrobienie tego w mongo

Nie używaj RegExp

Stań się naturalny I użyj wbudowanego indeksowania mongodb, szukaj

Krok 1 :

db.articles.insert(
   [
     { _id: 1, subject: "coffee", author: "xyz", views: 50 },
     { _id: 2, subject: "Coffee Shopping", author: "efg", views: 5 },
     { _id: 3, subject: "Baking a cake", author: "abc", views: 90  },
     { _id: 4, subject: "baking", author: "xyz", views: 100 },
     { _id: 5, subject: "Café Con Leche", author: "abc", views: 200 },
     { _id: 6, subject: "Сырники", author: "jkl", views: 80 },
     { _id: 7, subject: "coffee and cream", author: "efg", views: 10 },
     { _id: 8, subject: "Cafe con Leche", author: "xyz", views: 10 }
   ]
)

Krok 2 :

Musisz utworzyć indeks w dowolnym polu tekstowym, które chcesz przeszukać, bez zapytania o indeksowanie będzie to bardzo powolne

db.articles.createIndex( { subject: "text" } )

krok 3 :

db.articles.find( { $text: { $search: "coffee",$caseSensitive :true } } )  //FOR SENSITIVITY
db.articles.find( { $text: { $search: "coffee",$caseSensitive :false } } ) //FOR INSENSITIVITY
Vijay
źródło
1
Dobra opcja, ale nie ma nic bardziej „poprawnego” w stosowaniu indeksu tekstowego w porównaniu do wyrażenia regularnego, to tylko inna opcja. W przypadku PO to przesada.
JohnnyHK
2
Tyle że regex jest znacznie wolniejszy. Wyszukiwanie pełnotekstowe jest również wolne, ale nie tak wolne. Najszybszym (ale bardziej rozdętym) sposobem byłoby oddzielne pole, które zawsze jest ustawione na małe litery.
Tom Mettam,
4
Korzystanie z wyszukiwania pełnotekstowego jest nie tak w tym przypadku (i potencjalnie niebezpieczne ), bo pytanie było o dokonanie kwerendy bez uwzględniania wielkości liter, np username: 'bill'dopasowanie BILLlub Billnie kwerendy wyszukiwania pełnotekstowego, która będzie również mecz wynikała słowa o bill, takie jak Bills, billeditd.
Dan Dăscălescu
15
db.company_profile.find({ "companyName" : { "$regex" : "Nilesh" , "$options" : "i"}});
Nilesh
źródło
2
Czy przeglądałeś istniejące odpowiedzi przed opublikowaniem tego? Zamiast quasi-duplikatowej odpowiedzi tylko na kod, możesz wyjaśnić, w jaki sposób dodaje coś wartościowego w porównaniu do poprzednich odpowiedzi.
Dan Dascalescu,
1
Chcę tylko dodać, że ta odpowiedź doprowadziła mnie do rozwiązania. Używam frameworka PHP i to dobrze pasuje do składni ORM, podczas gdy inne rozwiązania tutaj nie. $existing = Users::masterFind('all', ['conditions' => ['traits.0.email' => ['$regex' => "^$value$", '$options' => 'i']]]);
Don Rzeszut
9

Mongo (aktualna wersja 2.0.0) nie zezwala na wyszukiwanie bez rozróżniania wielkości liter względem indeksowanych pól - zobacz ich dokumentację . W przypadku pól nieindeksowanych wyrażenia regularne wymienione w innych odpowiedziach powinny być w porządku.

Aidan Feldman
źródło
19
Wyjaśnij to: wyszukiwania indeksów bez rozróżniania wielkości liter są dozwolone w polach indeksowanych, po prostu nie będą korzystać z indeksu i będą tak wolne, jakby pole nie było indeksowane.
heavi5ide,
@ heavi5ide, ponieważ to pytanie jest używane do oznaczania duplikatów, pomyślałem, że wyjaśnię, że wyrażenia regularne (potrzebne do wyszukiwania bez rozróżniania wielkości liter) używają indeksu, jednak muszą wykonać pełne skanowanie indeksu. Innymi słowy, nie mogą efektywnie korzystać z indeksu. Na szczęście dokumentacja została zaktualizowana od 2011 roku, ale nadal warto o tym pamiętać.
Sammaye,
7

Podczas korzystania z zapytania opartego na Regex należy pamiętać o jednej bardzo ważnej rzeczy - robiąc to dla systemu logowania, unikaj każdego szukanego znaku i nie zapomnij o operatorach ^ i $. Lodash ma do tego przyjemną funkcję , jeśli już z niej korzystasz:

db.stuff.find({$regex: new RegExp(_.escapeRegExp(bar), $options: 'i'})

Dlaczego? Wyobraź sobie użytkownika wprowadzającego się .*jako jego nazwa użytkownika. To by pasowało do wszystkich nazw użytkowników, umożliwiając logowanie po prostu odgadując hasło dowolnego użytkownika.

Nick Kamer
źródło
6

Najlepsza metoda jest w wybranym języku, podczas tworzenia opakowania modelu dla twoich obiektów, niech twoja metoda save () iteruje przez zestaw pól, które będziesz przeszukiwał i które są również indeksowane; zestaw pól powinien zawierać małe litery, które są następnie używane do wyszukiwania.

Za każdym razem, gdy obiekt jest zapisywany, właściwości małych liter są następnie sprawdzane i aktualizowane o wszelkie zmiany w głównych właściwościach. To sprawi, że będziesz mógł efektywnie wyszukiwać, ale ukryjesz dodatkową pracę potrzebną do aktualizacji pól lc za każdym razem.

Pola pisane małymi literami mogą być kluczem: składnicą wartości obiektu lub po prostu nazwą pola z prefiksem lc_. Korzystam z drugiego, aby uprościć tworzenie zapytań (zapytania do obiektów głębokich mogą być czasami mylące).

Uwaga: chcesz zindeksować pola lc_, a nie główne pola, na których są oparte.

RobKohr
źródło
Dobre rozwiązanie, ale na szczęście, począwszy od MongoDB 3.4, istnieje natywne wsparcie dla indeksów niewrażliwych na wielkość liter .
Dan Dascalescu
6

Załóżmy, że chcesz wyszukać „kolumnę” w „Tabeli” i chcesz wyszukiwać bez rozróżniania wielkości liter. Najlepszy i skuteczny sposób jest taki jak poniżej;

//create empty JSON Object
mycolumn = {};

//check if column has valid value
if(column) {
    mycolumn.column = {$regex: new RegExp(column), $options: "i"};
}
Table.find(mycolumn);

Powyższy kod po prostu dodaje wartość wyszukiwania jako RegEx i wyszukuje według niewrażliwych kryteriów ustawionych z opcją „i”.

Wszystkiego najlepszego.

Ankur Soni
źródło
5

Przy użyciu Mongoose to działało dla mnie:

var find = function(username, next){
    User.find({'username': {$regex: new RegExp('^' + username, 'i')}}, function(err, res){
        if(err) throw err;
        next(null, res);
    });
}
ChrisRich
źródło
8
Czy nie jest .toLowerCase()zbędne, jeśli określasz flagę bez rozróżniania wielkości liter i?
k00k
Tak to jest. Nie potrzebujesz .toLowerCase (). Usunąłem go z odpowiedzi.
ChrisRich
hmm, czy to powinno tak działać? Kiedy szukam „mark”, dostaje także każdy rekord z „marko” - czy istnieje sposób, aby zignorować wielkość liter?
Suisse
Ok, znalazłem, poprawnym wyrażeniem regularnym byłoby: „^” + nazwa serach + „$”, „i”
Suisse
3
To jest niebezpieczne. Nie uciekasz od nazwy użytkownika, więc możesz wstawić dowolne wyrażenie regularne.
Tom Mettam,
3

Ramy agregacji zostały wprowadzone w mongodb 2.2. Możesz użyć operatora łańcuchowego „$ strcasecmp”, aby rozróżnić ciągi znaków bez rozróżniania wielkości liter. Jest to bardziej zalecane i łatwiejsze niż użycie wyrażenia regularnego.

Oto oficjalny dokument dotyczący operatora polecenia agregacji: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

Jogue Wasin
źródło
4
jak tego użyć w zapytaniu find ()? db.stuff.find ({name: $ strcasecmp (name)})?
Suisse
3

Możesz użyć indeksów bez rozróżniania wielkości liter :

Poniższy przykład tworzy kolekcję bez domyślnego sortowania, a następnie dodaje indeks do pola nazwy z sortowaniem bez rozróżniania wielkości liter. Międzynarodowe komponenty dla Unicode

/* strength: CollationStrength.Secondary
* Secondary level of comparison. Collation performs comparisons up to secondary * differences, such as diacritics. That is, collation performs comparisons of 
* base characters (primary differences) and diacritics (secondary differences). * Differences between base characters takes precedence over secondary 
* differences.
*/
db.users.createIndex( { name: 1 }, collation: { locale: 'tr', strength: 2 } } )

Aby użyć indeksu, zapytania muszą określać to samo sortowanie.

db.users.insert( [ { name: "Oğuz" },
                            { name: "oğuz" },
                            { name: "OĞUZ" } ] )

// does not use index, finds one result
db.users.find( { name: "oğuz" } )

// uses the index, finds three results
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 2 } )

// does not use the index, finds three results (different strength)
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 1 } )

lub możesz utworzyć kolekcję z domyślnym zestawieniem:

db.createCollection("users", { collation: { locale: 'tr', strength: 2 } } )
db.users.createIndex( { name : 1 } ) // inherits the default collation
Gencebay D.
źródło
Wydaje drobny problem składni (brak Szelki) Zadawala zaktualizować zapytanie: db.users.createIndex( { name: 1 }, {collation: { locale: 'tr', strength: 2 } } )
Mohd Belal
3

Aby wyszukać zmienną i uciec od niej:

const escapeStringRegexp = require('escape-string-regexp')
const name = 'foo'
db.stuff.find({name: new RegExp('^' + escapeStringRegexp(name) + '$', 'i')})   

Zmiana znaczenia chroni kwerendę przed atakami za pomocą „. *” Lub innego wyrażenia regularnego.

wyrażenie-łańcuchowe-wyrażenie-regularne

davidivad
źródło
1

Użyj RegExp , w przypadku, gdy jakiekolwiek inne opcje nie działają dla Ciebie, RegExp jest dobrą opcją. Powoduje to, że ciąg nie rozróżnia wielkości liter.

var username = new RegExp("^" + "John" + "$", "i");;

użyj nazwy użytkownika w zapytaniach, a następnie gotowe.

Mam nadzieję, że to również zadziała dla ciebie. Wszystkiego najlepszego.

Gouri Shankar Karanam
źródło
0

Stworzyłem prosty Func dla wyrażenia regularnego bez rozróżniania wielkości liter, którego używam w moim filtrze.

private Func<string, BsonRegularExpression> CaseInsensitiveCompare = (field) => 
            BsonRegularExpression.Create(new Regex(field, RegexOptions.IgnoreCase));

Następnie po prostu filtruj według pola w następujący sposób.

db.stuff.find({"foo": CaseInsensitiveCompare("bar")}).count();
Nitesh
źródło
0

Użycie filtra działa dla mnie w C #.

string s = "searchTerm";
    var filter = Builders<Model>.Filter.Where(p => p.Title.ToLower().Contains(s.ToLower()));
                var listSorted = collection.Find(filter).ToList();
                var list = collection.Find(filter).ToList();

Może nawet użyć indeksu, ponieważ uważam, że metody są wywoływane po powrocie, ale jeszcze tego nie przetestowałem.

Pozwala to również uniknąć problemu

var filter = Builders<Model>.Filter.Eq(p => p.Title.ToLower(), s.ToLower());

ten mongodb uzna, że ​​p.Title.ToLower () jest właściwością i nie będzie poprawnie mapowany.

A_Arnold
źródło
Dzięki, to działa dla mnie. Tutaj musimy uzyskać filtr w zmiennej, a następnie przekazać metodę Find ().
Nilay
0

Dla każdego, kto używa Golanga i chce mieć rozróżnianie wielkości liter w wyszukiwaniu pełnotekstowym za pomocą mongodb i biblioteki globalsign mgo godoc .

collation := &mgo.Collation{
    Locale:   "en",
    Strength: 2, 
}


err := collection.Find(query).Collation(collation)
okandas
źródło
-1

Jak widać w dokumentach mongo - ponieważ $textindeks wersji 3.2 domyślnie nie rozróżnia wielkości liter: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insenssens

Utwórz indeks tekstowy i użyj operatora $ text w zapytaniu .

lawina 1
źródło
Korzystanie z wyszukiwania pełnotekstowego jest nie tak w tym przypadku (i potencjalnie niebezpieczne ), bo pytanie było o dokonanie kwerendy bez uwzględniania wielkości liter, np username: 'bill'dopasowanie BILLlub Billnie kwerendy wyszukiwania pełnotekstowego, która będzie również mecz wynikała słowa o bill, takie jak Bills, billeditd.
Dan Dăscălescu
-1

Zostały one przetestowane pod kątem wyszukiwania ciągów

{'_id': /.*CM.*/}               ||find _id where _id contains   ->CM
{'_id': /^CM/}                  ||find _id where _id starts     ->CM
{'_id': /CM$/}                  ||find _id where _id ends       ->CM

{'_id': /.*UcM075237.*/i}       ||find _id where _id contains   ->UcM075237, ignore upper/lower case
{'_id': /^UcM075237/i}          ||find _id where _id starts     ->UcM075237, ignore upper/lower case
{'_id': /UcM075237$/i}          ||find _id where _id ends       ->UcM075237, ignore upper/lower case
Ar maj
źródło
-1

Miałem do czynienia z podobnym problemem i właśnie to działało dla mnie:

  const flavorExists = await Flavors.findOne({
    'flavor.name': { $regex: flavorName, $options: 'i' },
  });
Woppi
źródło
To rozwiązanie było już dawane dwukrotnie. Sprawdź istniejące odpowiedzi przed opublikowaniem nowej.
Dan Dascalescu
@DanDascalescu nie jestem pewien, o czym mówisz, po CTRL + F podobne rozwiązanie z wieloma opiniami opublikowało go we wrześniu 2018 r. Opublikowałem swoją odpowiedź w kwietniu 2018 r. Właściwie opublikowałem to, ponieważ w tym czasie nie ma żadnych. Sprawdź też, kiedy został opublikowany, zanim ostrzeżesz tych, którzy naprawdę próbują pomóc.
Woppi
Mówię o tej odpowiedzi od kwietnia 2016 r. I tej odpowiedzi od maja 2016 r. Zarówno użyj, jak $regexi $options. Co zrobiłeś Ctrl + F?
Dan Dascalescu
Ponadto używanie $regexjest nieefektywne i potencjalnie niebezpieczne, jak wyjaśniłem w mojej edycji tej drugiej odpowiedzi z 2016 r . Nie ma wstydu w usuwaniu odpowiedzi, jeśli nie służą już społeczności!
Dan Dascalescu
Zauważono nieefektywne wyrażenie regularne $, wielkie dzięki. I Ctrl + F $ opcje. Jest nas tutaj tylko dwóch, bez nowego Regexp w naszym kodzie $ regex, kwiecień 2018 i wrzesień 2018. Nie użyłem nowego Regexp w mojej odpowiedzi. Zapomniałem konkretnego problemu, który miałem z nowym Regexp, który został rozwiązany, gdy go usunąłem i po prostu użyj tego rozwiązania, które opublikowałem.
Woppi