js字符串contains 如何检查字符串是否包含JavaScript中的子字符串?




js字符串contains (24)

这对我有用。 它选择不包含术语“已删除:”的字符串

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

通常我会期望一个String.contains()方法,但似乎没有。

检查这个的合理方法是什么?


如上所述,您需要使用大写“O”调用indexOf。 还应该注意,在JavaScript类中是保留字,您需要使用className来获取此数据属性。 它可能失败的原因是因为它返回一个空值。 您可以执行以下操作来获取类值...

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

这段代码应该运行良好:

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

您正在寻找.indexOf String.prototype.indexOf

indexOf将返回匹配的子字符串的索引。 索引将与子字符串的开始位置相关联。 如果没有匹配,则返回-1。 以下是该概念的简单演示

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)
}



在数组中使用contains方法的JavaScript代码:

<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>

在给定的代码中, contains方法确定指定的元素是否存在于数组中。 如果指定的元素存在于数组中,则返回true,否则返回false。


这样做的另一个选择是:

您可以使用匹配功能,即:

x = "teststring";

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

match()也可以使用正则表达式:

x = "teststring";

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

你可以使用jQuery :contains selector。

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

在这里检查: contains-selector


如果你正在寻找一种替代方法来编写丑陋的-1检查,那么你可以先添加一个〜代替。

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

Joe Zimmerman - 你会看到使用~on -1将它转换为0.数字0是一个假值,意味着它在转换为布尔值时会计算为false。 这可能看起来不像是一个很大的洞察力,但是当找不到查询时,记住像indexOf这样的函数将返回-1。 这意味着不要写类似于此的东西:

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

您现在可以在代码中使用更少的字符,因此您可以像这样编写它:

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

更多细节在这里


由于这个问题非常受欢迎,我认为我可以为代码添加一些现代风格。

// 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`);

顺便说一句,正确的答案是拼写错误的indexOf或非标准的String.contains 。 加载外部库(特别是如果代码是用纯JavaScript编写的)或搞乱String.prototype或使用正则表达式有点矫枉过正。


var a  = "Test String";

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

String.prototype.indexOf()String.prototype.search()

正如其他人已经提到的,JavaScript字符串同时具有String.prototype.indexOfsearch方法。

两者之间的关键区别在于indexOf仅用于普通子串,而search也支持正则表达式。 当然,使用indexOf的好处是它更快。

另请参见在JavaScript中,indexOf()和search()之间有什么区别?

实现自己的String.prototype.contains()方法

如果你想为每个字符串添加你自己的contains方法,那么最好的方法就是的方法:

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

你会像这样使用它:

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

实现自定义实用程序库

例如,通常不赞成将自己的自定义方法添加到JavaScript中的标准对象,因为它可能会破坏兼容性。

如果您真的需要自己的contains方法和/或其他自定义字符串方法,最好创建自己的实用程序库并将自定义字符串方法添加到该库:

var helper = {};

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

你会像这样使用它:

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

使用第三方实用程序库

如果您不想创建自己的自定义帮助程序库,当然 - 始终可以选择使用第三方实用程序库。 正如所提到的,最受欢迎的是LodashLodash

在Lodash中,你可以使用_.includes() ,你可以这样使用:

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

_.str.include() ,您可以使用_.str.include() ,您可以像这样使用:

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

您可以使用JavaScript search()方法。

语法是: string.search(regexp)

它返回匹配的位置,如果未找到匹配则返回-1。

参见那里的例子: jsref_search

您不需要复杂的正则表达式语法。 如果您不熟悉它们,可以使用简单的st.search("title") 。 如果您希望测试不区分大小写,那么您应该进行st.search(/title/i)


您的代码存在的问题是JavaScript区分大小写。 你的方法调用

indexof()

应该是

indexOf()

尝试修复它,看看是否有帮助:

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

ES6中有一个string.includes

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

请注意,您可能需要加载es6-shim或类似内容才能在旧版浏览器上使用它。

require('es6-shim')

String.prototype.includes()是在ES6中引入的。

确定是否可以在另一个字符串中找到一个字符串,并根据需要返回true或false。

句法

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

参数

searchString

要在此字符串中搜索的字符串。

position

此字符串中开始搜索searchString默认为0。

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  

注意

这可能需要旧版浏览器中的ES6垫片。


收集某种有效的解决方案:

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+'');


您可以使用经过充分测试和记录的库,而不是使用网络上此处和此处找到的代码段。 我建议的两个选项:

第一个选项:使用Lodash :它有一个includes方法:

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

Lodash是npm最受欢迎的javascript库依赖项,并且有大量方便的javascript实用程序方法。 因此,对于许多项目,无论如何你都会想要这个;-)

第二个选项:或者使用Underscore.string :它有一个include方法:

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

这里是Underscore.string的描述,它只增加了9kb,但是为您提供了经过充分测试和记录的库具有over copy'n'paste代码片段的所有优点:

Underscore.string是用于使用字符串进行舒适操作的JavaScript库,受Prototype.js,Right.js,Underscore和漂亮的Ruby语言启发的Underscore.js的扩展。

Underscore.string为您提供了几个有用的函数:capitalize,clean,includes,count,escapeHTML,unescapeHTML,insert,splice,startsWith,endsWith,titleize,trim,truncate等。

请注意,Underscore.string受Underscore.js的影响,但可以在没有它的情况下使用。

最后不是最少:使用JavaScript版本ES6内置includes方法:

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

大多数现代浏览器已经支持它,请关注ES6兼容性表


var index = haystack.indexOf(needle);

有一种更流畅,更好的方法,它使用(BitWise NOT)运算符。

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

按位不将“x”转换为 - (x + 1)所以,如果x从indexOf方法变为-1,那么它将转换为 - (-1 + 1)= -0这是一个假值。


以下列出了当前的可能性:

1.(ES6) includes - 去回答

var string = "foo",
    substring = "oo";
string.includes(substring);

2. ES5和更老的indexOf

var string = "foo",
    substring = "oo";
string.indexOf(substring) !== -1;

String.prototype.indexOf返回另一个字符串中字符串的位置。 如果未找到,则返回-1

3. search - 去回答

var string = "foo",
    expr = /oo/;
string.search(expr);

4. lodash包括 - 去回答

var string = "foo",
    substring = "oo";
_.includes(string, substring);

5. RegExp - 去回答

var string = "foo",
    expr = /oo/;  // no quotes here
expr.test(string);

6.匹配 - 去回答

var string = "foo",
    expr = /oo/;
string.match(expr);

性能测试表明,如果速度很重要, indexOf可能是最佳选择。


ES6中 ,我们有一些调用包含 ,它完全符合你的要求:所以你可以这样做:

'str1'.includes('str2');

同样在ES5中 ,如果你广泛使用它,你可以简单地添加它:

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}

由于存在关于使用原型的抱怨,并且因为使用indexOf会使您的代码可读性降低,并且因为regexp是过度杀伤:

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

这就是我最终要做的妥协。


您可以使用以下语句轻松地将contains方法添加到String:

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

注意:请参阅以下注释,了解不使用此参数的有效参数。 我的建议:用你自己的判断。

或者:

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




string-matching