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

gramm 7435 javascript string substring contains string-matching

通常我会期待一种String.contains()方法,但似乎没有一种方法.

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

Fabien Ménag.. 12371

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

1.(ES6)includes - 去回答(没有IE支持)

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可能是最佳选择,如果它涉及速度问题.

  • @Steve`indexOf`总是返回一个数字,所以不需要使用`!==`.如果你想保存字节,可以使用`~'foo'.indexOf('oo')`如果找到子字符串则返回一个truthy值,如果不存在则返回一个虚假值(`0`). (922认同)
  • 对于好奇:在两个恭维系统中,-1以二进制表示为全1(对于32位,为1111 1111 1111 1111 1111 1111 1111 1111).这里的按位反转(〜)全是零,或者只是零,因此是假的.这就是为什么波浪诡计有效的原因,如果我必须自己这样说,那就太糟糕了. (696认同)
  • @NicolasBarbulesco我相信所有看过我代码的人都知道`[["\ t \n 987654321e-400"]] === 0`是假的.我不太相信每个查看我的代码的人都会知道`[["\ t \n \n \n通过987654321e-432"]] == 0`是真的. (75认同)
  • @SebNilsson你忘了在我的评论中包含我建议的`~`操作符.'〜 'hello'.indexOf(' H"); // -1,这是truthy`,但是`~'hello'.indexOf('x'); // 0,这是falsy`. (69认同)
  • @ pramodc84那个链接指的是`Array`对象`indexOf`方法而不是`String`对象方法 (38认同)
  • 盲目地遵循"总是使用`!==`"规则不是这里的答案,你可以放心使用!=如果你知道你正在比较两个数字.-1不是假的,因此在这个特定的实例中,`!=`总是合适的. (19认同)
  • @MathiasBynens实际上没有,因为如果它是第一个字母,它将返回虚假0,即使它包含值.只需在任何浏览器控制台中测试:''hello'.indexOf('h')` (14认同)
  • @Luke你是对的.应该注意的是,对于js(或开发)新手来说,作为一般实践,优于可读性/可维护性优于微调可能是最好的.在需要调整的情况下,在一个代码的未压缩版本中的解释性注释对于指出正在发生的事情以及为什么一个人是"棘手的"是非常宝贵的. (12认同)
  • @Greg阿门!我不能忍受那些不想理解正确的JS比较规则并且想盲目遵循"总是使用严格比较"规则(可能来自Crockford)的人.严格的比较也可能导致错误. (12认同)
  • 我想补充一点,使其不区分大小写对我有利:`var s ="foo",t ="oo"; alert(s.toLowerCase().indexOf(t.toLowerCase() )!= -1);` (11认同)
  • 到目前为止,squiggle(`~str.indexOf()`)可能被认为是惯用语.编写惯用JavaScript很好. (10认同)
  • @boxed这很大程度上取决于你编写代码的原因以及你正在使用的技巧.有时这样的技巧对于使代码更快/更高内存效率等是必要的.可读性并非一切. (8认同)
  • @NicolasBarbulesco如果您不确切地知道自己在做什么,自动输出真实/虚假的价值可能会非常危险.有关差异的更全面说明,请参阅[this post](http://stackoverflow.com/questions/359494/does-it-matter-which-equals-operator-vs-i-use-in-javascript-comparisons)在这两个比较运算符中. (8认同)
  • @dalgard这是惯用的吗?也许,但我发现它令人困惑 (8认同)
  • 这对IE有效吗? (7认同)
  • @ pramodc84,那是'Array.prototype.indexOf()`; `String.prototype.indexOf()`随处可用. (6认同)
  • @DesertIvy - 鉴于此,我确认我更喜欢`!=`,而不是`!==`.在这里,我不想测试类型,我只想测试值.而且,`!=`很清楚,而`!==`起初是神秘的. (6认同)
  • 我不明白为什么`indexOf`被引入为"过时的答案".它仍然是目前最好的答案,不是吗? (6认同)
  • 也许在2016年,如果ECMAScript 6被广泛采用和实施,我们将能够做到这一点!:P"橙汁".contains("果汁") (5认同)
  • @klors一个常见的例子是一个数字ID,可以作为字符串或数字传入(因为它可能来自查询字符串).这不是你不能解决它,但你需要额外的代码,如果你盲目地使用`===`它只适用于一个案例,所以你需要自己做转换.使用`if(id == myId)`将为您进行转换. (4认同)
  • 为什么`!==`?我更喜欢`!=`. (3认同)
  • @Adam字符串中的第一个字符的索引为0.这就是子字符串"foo"首次出现在"foo"中的位置.它也是""首次出现在"foo"中的地方.(要使用物理世界的比喻,空字符串足够薄,可以放在开头引号和"foo"的第一个字母之间.)所以,[indexOf](https://developer.mozilla.org/en-在两种情况下,US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf)都返回0. (3认同)
  • 我不同意'〜'的使用.使用按位运算符导致-1数值,该值被定义为未找到字符串时的结果,用作32位整数值并翻转位以获得32位整数值0,这是然后解释为布尔值false不值得保存几个字节的代码.我认为你只应该在操作位时使用按位运算符,而不是作为一种快捷方式,除非你正在进行代码高尔夫. (3认同)
  • @huggie:我发现很难断言"Javascript没有真正的整数"; 我当然明白是什么激发了这种说法,但我觉得它有点过分了.而不管 ...事实上,JavaScript的`~`在32位有符号(二进制补码)整数上运行.例如,`~3.7`的计算结果为'-4`(因为整数转换需要`3.7`到'3`). (2认同)
  • @JuanMendes如何严格比较导致错误? (2认同)
  • @JuanMendes啊,我以为你的意思是它存在一些问题,而不是它可能被误用了 (2认同)

Avi Flax.. 864

您可以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; }; }

  • 不要修改您不拥有的对象.http://www.nczonline.net/blog/2010/03/02/maintainable-javascript-dont-modify-objects-you-down-own/ (362认同)
  • @zachleat,在实践中可以理解.但是"foobar".contains("bar")对规则来说是一个非常有用的例外. (90认同)
  • 嗯,我的偏好是调整我的心智模型以适应JavaScript并只使用indexOf.它将使代码更易于理解下一个JavaScripter,并且必须阅读它. (82认同)
  • `if(typeof String.prototype.contains ==='undefined'){String.prototype.contains = function(it){return this.indexOf(it)!= -1; }; }` (79认同)
  • 如果您要经常使用这种indexOf,我最好使用此功能.@zachleat,我不同意使用indexOf比contains更具可读性.包含描述了正在发生的事情,某些`indexOf()!= -1`可能不是那么透明.但是对于每个人来说,只要你是一致的. (61认同)
  • 请注意,`String.prototype.contains`方法正在被标准化,这使得这种修改比第一次回答时更糟糕.正是这些由不假思索的Web开发人员进行的修改使得在Firefox中运行这种新方法变得如此痛苦.(它是在最新的夜间构建中实现的,我认为在Aurora版本中.但它是什么时候才能进入发布版本,因为必须首先费力地解决添加中的网站破坏.) (13认同)
  • ECMAScript 6包含`String.prototype.contains` http://wiki.ecmascript.org/doku.php?id=harmony:string_extras (6认同)
  • -100如果可以的话.不要这样做.永远.其他人解释了一些原因.但一般的原则是,如果你制造的物体看起来像是别的东西; 有人会认为他们是另一回事.这是如何最终导致维护噩梦.不要这样做.永远. (6认同)
  • 由于无效的polyfills,ECMAScript 6删除了`.contains`.它现在包含`.includes`. (6认同)
  • 我同意这是一般的最佳做法,但我觉得对于特定于应用的代码通常是可以的.但是对于图书馆来说这很糟糕. (5认同)
  • 如果您记录您的修改并与团队分享,那就没关系.这只是一个纪律问题.如果您的团队没有遵循文档,那么您将遇到更大的问题. (4认同)
  • `if(typeof String.prototype.contains ==='undefined'){String.prototype.contains = function(it){return this.indexOf(it)!= -1; }; } else {alert("您的代码现在可能已损坏!请检查String.prototype.contains的定义."); }` (4认同)
  • 我同意@Zachleat.这是一个很酷的概念,但我也认为编写在您离开后很久就能理解的代码非常重要.("包含"很容易理解,但很容易被迷失并用JavaScript编写自己的语言.它作为计算机科学练习很棒,但在生产环境中却很糟糕). (3认同)
  • 问题是这里的方法与内置方法不兼容.任何假定内置方法语义的代码都会暴露出来(页面上的广告,WordPress插件,其他任何东西)都会得到这个,并且会产生无意义的行为.请参阅https://bugzilla.mozilla.org/show_bug.cgi?id=789036,查看由于MooTools 1.2.x实现了一个不兼容的`String.prototype.contains`(可能仅通过有条件的修补,如果没有现有的`contains`方法),并且浏览器提供的版本的行为与预期的页面元素不同. (2认同)

Victor.. 456

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

indexof()

应该是

indexOf()

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

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

  • @JeremyW,我想在这一点上说这个答案的价值在于那些犯了同样错误的人(`indexof`而不是`indexOf`)可以找到这个答案并看看发生了什么.我不会再触及这个问题了. (11认同)

eliocs.. 415

string.includesES6中有一个:

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

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

require('es6-shim')

  • .contains()和.includes()都是实验性的,非:非标准的.我不建议将它们用于生产系统.我现在坚持使用.indexOf(). (9认同)
  • @Norris它在ES6中.加载ES6垫片.你现在可以使用它. (7认同)
  • 因为我习惯于在其他语言中"包含"并且只是用它实现了我的功能,我只是遇到了错误.所以,关于支持的简短反馈.Firefox 19 - OSX => OK,Firefox 19 - Windows => NOK,Chrome - OSX,Windows => NOK (6认同)
  • 像这样?`String.prototype.contains = function(segment){return this.indexOf(segment)!== -1; `(BTW:在原型上做事很糟糕) (5认同)
  • 它不支持铬..... :( (5认同)

pixeline.. 357

var index = haystack.indexOf(needle);


大智慧.. 246

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

语法是: string.search(regexp)

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

参见那里的例子:jsref_search

您不需要复杂的正则表达式语法.如果你不熟悉它们st.search("title")就会做一个简单的事情.如果您希望测试不区分大小写,那么您应该这样做st.search(/title/i).

  • 我没有运行基准测试,但是`str.toLowerCase().indexOf(searchstr.toLowerCase())`对于不区分大小写的搜索更有效吗? (31认同)
  • 这似乎比indexOf函数慢,因为它必须解析RegEx.但是,如果你想要一些不区分大小写的东西,你的方式就是你要走的路(我想),尽管那并不是我所要求的.即使没有被问到,我也会在不区分大小写的选项中对此进行投票_just_ _because_. (12认同)
  • 通过基准测试,结果发现搜索对于不区分大小写的搜索更有效.http://jsperf.com/string-compare-perf-test但是使用正则表达式搜索可能很棘手,因为你需要转义一些字符. (8认同)
  • 您可以使用escapeRegExp函数使serach文本安全.`function escapeRegExp(string){return string.replace(/([.*+?^ =!:$ {}()|\[\]\/ \\])/ g,"\\ $ 1"); 来自https://developer.mozilla.org/en/docs/Web/JavaScript/Guide/Regular_Expressions (4认同)
  • 搜索可能会导致错误.正如misaxi所说,你必须逃避一些角色.我使用搜索没有意识到参数预期正则表达式,并正在搜索管道字符.事实证明,任何字符串.search('|')== 0. (2认同)

Aniket Kulka.. 173

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垫片.


Christian La.. 126

如果你正在寻找一种替代方法来编写丑陋的-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
}

更多细节在这里


大智慧.. 88

这段代码应该运行良好:

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


zzzzBov.. 86

contains在JavaScript中编写方法的常用方法是:

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

按位~求反运算符()用于-1变为0(假),所有其他值将为非零(真值).

double boolean negation运算符用于将数字转换为布尔值.

  • @zzzzBov!~~同样依赖于幻数-1,以及它的按位表示是0的补码这一事实. (17认同)
  • `!! ~`超过`> -1`的优点是什么? (14认同)
  • `!! ~this.indexOf(arg);`不容易理解,在上下文中也不是很清楚.它还传达了"〜-1"为0的事实,同意@Martijn.它也比简单的-1比较慢.但清晰度是主要因素. (10认同)
  • @alex,除了不依赖魔术数字之外没有任何特别的优势.使用你觉得舒服的东西. (4认同)

Nisar.. 84

ES5中

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

ES6有三个新方法: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


nachtigall.. 73

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


第一个选项:使用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库,可以轻松操作字符串,Underscore.js的扩展,受Prototype.js,Right.js,Underscore和漂亮的Ruby语言的启发.

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兼容性表.

  • 如果您已经使用了Underscore,那么您应该使用这种方法,因为它使您的代码更易于阅读,并且对于那些不熟悉JavaScript的人来说更加自我解释...请记住,Stack Overflow答案对于更多人而言不仅仅是OP. (8认同)
  • 我不知道如何确定下划线方法在任何方面都优于使用javascript中提供的**记录良好的**核心功能,如此处所示.对于复制和粘贴代码的编码器类型,您的示例代码不会比这里提供的任何其他解决方案更多或更少"copy'n'paste代码片段,*除了*,它将需要添加库.添加库只是为了完成使用本地语言轻松完成的任务,无论库大小如何,都是不好的建议.-1来自我在旧问题上使用下意识的图书馆. (4认同)

Chorinator.. 68

你可以使用jQuery的:contains选择器.

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

在这里检查:包含选择器

  • 虽然搜索DOM元素... (25认同)
  • dom解析与问题无关 (21认同)
  • 它是松散相关的...如果您正在搜索的字符串恰好位于DOM元素中,则可以使用jQuery的`:contains`选择器. (4认同)

rahul.. 65

使用正则表达式:

RegExp.test(string)

  • 使用正则表达式只需要检查是否存在子字符串. (72认同)
  • 使用正则表达式通常会导致2个问题而不是1个问题. (23认同)
  • 如果您的字符串包括.或其他正则表达式文字,你会得到误报. (7认同)
  • 基准显示不然; 在许多情况下,正则表达式更有效,更重要的是,足够灵活,能够以其他解决方案所不具备的方式处理边缘情况. (5认同)

David Craig.. 62

这样做的另一个选择是:

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

x = "teststring";

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

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

x = "teststring";

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

  • 如果字符串"test"包括a.或其他正则表达式文字,你会得到误报. (7认同)

Travis J.. 54

您在寻找.indexOfMDN.

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


MillsJROSS.. 52

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

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

  • 您的第一种方法不正确:elm.getAttribute("class")== elm.className!= elm.getAttribute("className") (4认同)

大智慧.. 51

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

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


Jay Harris.. 36

由于这个问题很受欢迎,我想我可以在代码中加入一点现代风味.

// 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或使用正则表达式有点矫枉过正.


John Slegers.. 29

String.prototype.indexOf()还是String.prototype.search()?!

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

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

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

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

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

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

使用第三方实用程序库

如果您不想创建自己的自定义帮助程序库,当然 - 始终可以选择使用第三方实用程序库.正如提到@nachtigall,最流行的是LodashUnderscore.js.

在Lodash,您可以使用_.includes(),您使用如下:

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

在Underscore.js中,您可以使用_.str.include(),您使用如下:

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


Kiba.. 28

有一种更时尚,更好的方法,它使用(BitWise NOT)运算符.

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

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


Sriramajeyam.. 25

简单的解决方法

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

你可以用以下方式使用

"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参考


Ali Abbas.. 25

var a  = "Test String";

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


Tarun Gupta.. 21

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.

  • -1; 这个问题是关于字符串,而不是数组. (3认同)
  • 一个字符串是一个字符数组:) (3认同)

shA.t.. 20

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

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


Tjaart.. 18

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

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

这是我最终要做的妥协.


Alain Gauthi.. 17

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


frieder.. 14

最简单的方法确实是使用indexOf.要只检查字符串string中的子字符串substr,可以使用此方法:

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

正如您想要的那样string.contains(),您可以像下面这样自己实现:

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

现在,您可以使用此ecen更短的方法来检查字符串是否包含特殊子字符串:

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

这里也是一个JSFiddle.


Alireza.. 14

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

'str1'.includes('str2');

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

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


大智慧.. 13

使用内置的和最简单的一个,即match()字符串.要实现您期待的目标,请执行以下操作:

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


Kamil Ibadov.. 12

简单的答案,100%工作

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

一些例子

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


biziclop.. 10

如果你不喜欢!!~等等技巧,你可以简单地添加+1到结果中.indexOf().这种方式,如果找不到字符串,-1 + 1 = 0将是麻痹,0.. + 1 = 1..将是真实的:

if ("StackOverflow".indexOf("Stack") + 1 )
    alert('contains');
else 
    alert('does not contain');


Oliver Ni.. 8

试试这个:

if ('Hello, World!'.indexOf('orl') !== -1)
    alert("The string 'Hello World' contains the substring 'orl'!");
else
    alert("The string 'Hello World' does not contain the substring 'orl'!");

这是一个例子:jsfiddle


Mahendra Jel.. 8

还有一个功能search:

var str = "Stack Overflow";
var n = str.search("Overflow");
if (n != -1)
    alert('String exists')

  • `search`用于正则表达式 (3认同)

Satish Sharm.. 7

这是一个检查子字符串是否存在于字符串中的函数:

function isStringMatch(str, str_to_match) {
    return (str.indexOf(str_to_match) > -1);
}

  • 只是抬头......这应该是`> = 0`,`> -1`,或者(我的偏好)`!== -1`,因为如果字符串*开头,它将以当前形式失败*子串. (3认同)

Devashish Ja.. 7

有多种方法可以做到这一点.最常用的是indexOf()方法.indexOf()返回作为参数传递给它的字符串的位置,如果字符串不包含传递的字符串,则返回-1.

let str = "A cat and a dog";
str.indexOf("cat"); // returns 2
str.indexOf("panda"); // returns -1


Raman Sahasi.. 7

使用ECMAScript 2015,我们可以使用 includes()

let s = "foo";
console.log(s.includes("oo"));


Sherali Turd.. 6

我知道最好的方法是str.indexOf(s) !== -1; http://hayageek.com/javascript-string-contains/

我建议另一种方式(str.replace(s1, "") !== str):

var str = "Hello World!", s1 = "ello", s2 = "elloo";
alert(str.replace(s1, "") !== str);
alert(str.replace(s2, "") !== str);


大智慧.. 6

你可以使用indexOf它返回字符串的位置.如果未找到,则返回-1.所以如果方法返回-1字符串不存在

var string = "This is a test string",
substring = "test";
if(string.indexOf(substring) >= 0)
  //substring exist
else
  //substring does not exist


Josip Ivic.. 5

你也可以这样做

var snipers = " Vasily Zaytsev, Simo Hayha, Chris Kyle";
var me = "Josip";

function printSniperStatus (person) {
    if (aContainsB(snipers, person)) {
        console.log(person + " is a sniper.");
    } else {
        console.log(person + " is NOT a sniper.");
    }
}

// Outputs: "Josip is NOT a sniper."
printSniperStatus(me);


Behnam Moham.. 5

非常简单:

var a = "foo", b= "oo";
if (a.indexOf(substring) !== -1) {
    // has
}


归档时间:

查看次数:

5354744 次

最近记录:

9 月,3 周 前