Jak sprawdzić, czy łańcuch zawiera podłańcuch w JavaScript?

Możesz łatwo dodać metodę contains do String z tą instrukcją:

String.prototype.contains = function(it) { return this.indexOf(it) != -1; };

Uwaga: Zobacz komentarze poniżej, aby uzyskać prawidłowy argument za niestosowaniem tego. Moja rada: używaj własnego osądu.

Alternatywnie:

if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }

Problem z Twoim kodem polega na tym, że JavaScript uwzględnia wielkość liter. Twoja metoda wywołania

indexof()

Powinno być

indexOf()

Spróbuj to naprawić i zobacz, czy to pomoże:

if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}

Istnieje string.includes w ES6:

"potato".includes("to");
> true

Uwaga Może być konieczne załadowanie es6-shim lub podobnego, aby to działało na starszych przeglądarkach.

require('es6-shim')

var index = haystack.indexOf(needle);

Możesz użyć metody JavaScript search().

Składnia to: string.search(regexp)

Zwraca pozycję meczu lub -1, jeśli nie znaleziono dopasowania.

Zobacz tam przykłady: jsref_search

Nie potrzebujesz skomplikowanej składni wyrażeń regularnych. Jeśli nie jesteś zaznajomiony z nimi proste st.search("title") zrobi. Jeśli chcesz, aby twój test był niewrażliwy na wielkość liter, powinieneś wykonać st.search(/title/i).

String.prototype.includes() został wprowadzony w ES6.

Określa, czy jeden łańcuch może być znaleziony w innym łańcuchu, zwracając odpowiednio wartość true lub false.

Składnia

var contained = str.includes(searchString [, position]);  

Parametry

searchString

Ciąg znaków do wyszukania w tym łańcuchu.

position

Pozycja w tym łańcuchu, na której należy rozpocząć wyszukiwanie searchString domyślnie wynosi 0.

Przykład

var str = "To be, or not to be, that is the question.";

console.log(str.includes("To be"));    // true
console.log(str.includes("question")); // true
console.log(str.includes("To be", 1)); // false  

Uwaga

To może wymagać ES6 shim w starszych przeglądarkach.

Jeśli szukałeś alternatywy dla wypisania brzydkiego czeku -1, zamiast tego dodajesz ~ tilde.

if (~haystack.indexOf('needle')) alert('found');

Joe Zimmerman - zobaczysz, że użycie ~ on -1 konwertuje go na 0. Liczba 0 to a wartość False, co oznacza, że po przekonwertowaniu na Boolean. To może na początku nie wydawać się wielkim spostrzeżeniem, ale zapamiętaj funkcje takie jak indexOf zwrócą -1, gdy zapytanie nie jest znaleziono. Oznacza to, że zamiast pisać coś podobne do tego:

if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

Możesz teraz mieć mniej znaków w kodzie, więc możesz go napisać tak:

if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

Więcej szczegóły tutaj

Ten fragment kodu powinien działać dobrze:

var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 

W języku JavaScript można zapisać metodę contains:

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

Operator negacji bitowej (~) służy do zamiany -1 na 0 (false), a wszystkie inne wartości będą niezerowe (True).

Operatory podwójnej negacji logicznej są używane do tworzenia liczby logicznej.

In ES5

var s = "foo";
alert(s.indexOf("oo") > -1);

W ES6 istnieją trzy nowe metody: includes(), startsWith(), endsWith().

var msg = "Hello world!";

console.log(msg.startsWith("Hello"));       // true
console.log(msg.endsWith("!"));             // true
console.log(msg.includes("o"));             // true

console.log(msg.startsWith("o", 4));        // true
console.log(msg.endsWith("o", 8));          // true
console.log(msg.includes("o", 8));          // false

Zamiast używać fragmentów kodu znalezionych tu i ówdzie w sieci, możesz również użyć dobrze przetestowanej i udokumentowanej biblioteki. Dwie opcje polecam:

1. opcja: użyj Lodash: ma includes "metoda": {]}

_.includes('foobar', 'ob');
// → true

Lodash jest najpopularniejszą zależnością biblioteki javascript dla npm i ma mnóstwo przydatnych metod javascript. Więc dla wielu projektów i tak byś tego chciał; -)

2. opcja: lub użyj podkreślenie.string : mA include "metoda": {]}

_.str.include('foobar', 'ob');
// → true

Oto opis podkreślenia.string, dodaje po prostu 9kb, ale daje wszystkie zalety dobrze przetestowanej i udokumentowanej biblioteki nad fragmentami kodu copy ' n ' Paste:

Podkreślenie.string jest biblioteką JavaScript dla wygodnej manipulacji z ciągami, rozszerzenie dla podkreślenia.js zainspirowany prototypem.js, Racja.js, podkreślenie i piękny język Ruby.

Podkreślenie.string zapewnia kilka przydatnych funkcji: capitalize, clean, includes, count, escapeHTML, unescapeHTML, insert, splice, startsWith, endsWith, titleize, trim, truncate i tak dalej.

Uwaga, podkreślam.ciąg jest pod wpływem podkreślenia.js ale może być używany bez niego.

Wreszcie: z wersją JavaScript ES6 jest wbudowany includes "metoda": {]}

'foobar'.includes('ob');
// → true

Większość nowoczesnych przeglądarek już go obsługuje, miej oko na Tabela kompatybilności ES6 .

Możesz użyć selektora jQuery :contains.

$("div:contains('John')")

Sprawdź tutaj: contains-selector

Użyj wyrażenia regularnego:

RegExp.test(string)

Inną opcją jest:

Możesz użyć funkcji match, czyli czegoś takiego jak:

x = "teststring";

if (x.match("test")) {
     // Code
}

Match () może również pracować z wyrażeniem regularnym:

x = "teststring";

if (x.match(/test/i)) {
     // Code
}

Szukałeś .indexOf^MDN.

indexOf zwróci indeks do dopasowanego podłańcucha. Indeks będzie skorelowany z miejscem, w którym zaczyna się podłańcuch. Jeśli nie ma dopasowania, zwracane jest -1. Oto simple demo tego pojęcia:

var str = "Hello World"; // For example, lets search this string,
var term = "World"; // for the term "World",
var index = str.indexOf(term); // and get its index.
if (index != -1) { // If the index is not -1 then the term was matched in the string,
  alert(index); // and we can do some work based on that logic. (6 is alerted)
}

Musisz wywołać indexOf przez wielkie "O", jak wspomniano. Należy również zauważyć, że w JavaScript klasa jest słowem zastrzeżonym, trzeba użyć className aby uzyskać ten atrybut danych. Prawdopodobnie zawodzi, ponieważ zwraca wartość null. Możesz wykonać następujące czynności, aby uzyskać wartość swojej klasy...

var test = elm.getAttribute("className");
//or
var test = elm.className

To mi po prostu zadziałało. Wybiera dla łańcuchów, które nie zawierają wyrażenia "Deleted:"

if (eventString.indexOf("Deleted:") == -1)

Ponieważ pytanie jest dość popularne, pomyślałem, że mogę dodać trochę nowoczesnego smaku do kodu.

// const           : creates an immutable constant
const allLinks   = document.getElementsByTagName("a");
// [].reduce.call  : gives access to the reduce method on a HTMLCollection
// () => {}        : ES6 arrow function
const foundLinks = [].reduce.call(allLinks, (sum, link) => {
     // bitwise OR : converts the boolean value to a number
     return sum + (link.classList.contains("title") | 0);
}, 0);

// template literal
console.log(`Found ${foundLinks || "no"} title class`);

BTW, poprawna odpowiedź to błędne zapisanie indexOf lub niestandardowe String.contains. Wczytywanie zewnętrznej biblioteki (szczególnie jeśli kod jest napisany w czystym JavaScript) lub mieszanie z String.prototype lub używanie wyrażenia regularnego jest trochę przesadą.

Istnieje elegancki i lepszy sposób, aby to zrobić i jest to za pomocą operatora (bitowo nie).

if(~"John".indexOf("J")) {
  alert("Found")
}
else {
  alert("Not Found");
}

Bitowe Not konwertuje " x " Na - (x + 1), więc jeśli x okaże się -1 z metody indexOf.następnie zostanie on zamieniony na - (-1 + 1) = -0, co jest wartością falsy .

String.prototype.indexOf() czy String.prototype.search()?!

Jak już wspomnieli inni, łańcuchy JavaScript mają zarówno indexOf oraz search metoda.

Zasadnicza różnica między obydwoma wersjami jest taka, że indexOf dotyczy tylko zwykłych podłańcuchów, podczas gdy search obsługuje również wyrażenia regularne. Oczywiście zaletą używania indexOf jest to, że jest szybszy.

Realizacja Twojego metoda własna String.prototype.contains()

Jeśli chcesz dodać własną metodę contains do każdego ciągu, najlepszym sposobem na to będzie podejście @zzzzBov:

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

Użyłbyś go tak:

'Hello World'.contains('orl');

Implementacja niestandardowej biblioteki narzędzi

Jest ogólnie źle widziane dodawanie własnych metod do standardowych obiektów w JavaScript, na przykład, ponieważ może to zakłócić kompatybilność.

Jeśli naprawdę chcesz własną metodę contains i / lub inne niestandardowe metody łańcuchowe, lepiej utworzyć własną bibliotekę narzędzi i dodać własne metody łańcuchowe do tej biblioteki:

var helper = {};

helper.string = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    },
    ...
};

Użyłbyś go tak:

helper.string.contains('Hello World', 'orl');

Korzystanie z biblioteki narzędzi innych firm

Jeśli nie chcesz tworzyć własnej biblioteki pomocniczej, zawsze istnieje - oczywiście - opcja użycia biblioteki narzędzi innej firmy. Jak wspomina @Nachtigall, najpopularniejsze to Lodash i podkreślenie.js .

W Lodash możesz użyć _.includes(), którego używasz tak:

_.includes('Hello World', 'orl');

W Podkreśleniu.js, możesz użyć _.str.include(), którego używasz w ten sposób:

_.str.include('Hello World', 'orl');

Przykład

var a  = "Test String";

if(a.search("ring")!=-1){
     //exist 
} else {
     //not found 
}

Proste obejście

if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

Możesz użyć w następujący sposób

"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains("  ")//false

MDN reference

ES6 zawiera String.prototype.includes.

Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes

Kod JavaScript do użycia metody contains w tablicy:

<html>
    <head>
        <h2>Use of contains() method</h2>
        <script>
            Array.prototype.contains = function (element) {
                for (var i = 0; i < this.length; i++) {
                    if (this[i] == element) {
                        return true;
                    }
                }
                return false;
            }
            arr1 = ["Rose", "India", "Technologies"];
            document.write("The condition is "+arr1.contains("India")+"<br>");
        </script>
    </head>

    <b>[If the specified element is present in the array, it returns true otherwise
    returns false.]</b>

</html>

W podanym kodzie metoda contains określa czy dany element jest obecny w tablicy czy nie. Jeśli podany element jest obecny w tablicy, zwraca true, w przeciwnym razie zwraca false.

Aby zebrać jakieś poprawne rozwiązania:

var stringVariable = "some text";
var findString = "text";

//using `indexOf()`
var containResult1 = stringVariable.indexOf(findString) != -1;
document.write(containResult1+', ');

//using `lastIndexOf()`
var containResult2 = stringVariable.lastIndexOf(findString) != -1;
document.write(containResult2+', ');

//using `search()`
var containResult3 = stringVariable.search(findString) != -1;
document.write(containResult3+', ');
     
//using `split()`
var containResult4 = stringVariable.split(findString)[0] != stringVariable;
document.write(containResult4+'');

Ponieważ istnieje Skarga na używanie prototypu, i ponieważ użycie {[1] } sprawia, że kod jest mniej czytelny, a ponieważ wyrażenie regularne jest overkill:

function stringContains(inputString, stringToFind) {
    return (inputString.indexOf(stringToFind) != -1);
}

JavaScript

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

JQuery

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found

Użyj wbudowanego i najprostszego, tj. match() na łańcuchu. Aby osiągnąć to, czego oczekujesz, zrób to:

var stringData ="anyString Data";

var subStringToSearch = "any";

// This will give back the substring if matches and if not returns null
var doesContains = stringData.match(subStringToSearch);

if(doesContains !=null) {
    alert("Contains Substring");
}

Najprostszym sposobem jest użycie indexOf . Aby sprawdzić łańcuch string dla fragmentu substr możesz użyć tej metody:

string = "asdf";
substr = "as";
alert(string.indexOf(substr) == -1 ? false : true);

Jak chciałeś funkcję string.contains(), możesz zaimplementować ją samodzielnie w następujący sposób:

String.prototype.contains = function(test) {
    return this.indexOf(test) == -1 ? false : true;
};

Teraz możesz użyć tej metody ecen shorter, aby sprawdzić, czy łańcuch zawiera specjalny podłańcuch:

string = "asdf";
alert(string.contains("as"));

OtoJSFiddle .