複数 文字列にJavaScriptで部分文字列が含まれているかどうかをチェックする方法




javascript 文字列 検索 複数 (24)

JavaScriptにcontainsメソッドを書き込む一般的な方法は次のとおりです。

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

ビット単位の否定演算子( ~ )は、 -10 (偽)にするために使用され、他のすべての値はゼロ以外(真実)になります。

数値をブール値にキャストするには、二重論理否定演算子を使用します。

通常、私はString.contains()メソッドを期待しますが、存在しないようです。

これをチェックする合理的な方法は何ですか?


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シムが必要になることがあります。


前述のように、大文字の "O"でindexOfを呼び出す必要があります。 また、JavaScriptクラスでは予約語であることに注意してください。このデータ属性を取得するには、classNameを使用する必要があります。 おそらく失敗している理由は、それがヌル値を戻しているからです。 あなたはあなたのクラスの価値を得るために次のことを行うことができます...

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

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

組み込みの、そして最も単純なもの、すなわち文字列の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");
}

ES5

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

ES6には、 startsWith()endsWith()endsWith() 3つの新しいメソッドがあります。

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


質問はかなり人気があるので、コードに少し現代的な味を加えることができると思った。

// 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を使ったり、 正規表現を使用したりするのは少しString.prototypeです。


簡単な回避策

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リファレンス


var index = haystack.indexOf(needle);

このステートメントを使用して、Stringにcontainsメソッドを簡単に追加できます。

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


このコードはうまくいくはずです:

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

現在の可能性のリストがあります:

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.ロダッシュが含まれています - 答えに行く

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が最適な選択肢である可能性が示されています。


いくつかの有効なソリューションを収集するには:

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



ES6にstring.includesがあります

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

旧式のブラウザでこれを動作させるには、 es6-shimなどをロードする必要があるかもしれないことに注意してください。

require('es6-shim')

String.prototype.indexOf()またはString.prototype.search() ?!

すでに述べたように、JavaScript文字列にはString.prototype.indexOfメソッドとsearchメソッドの両方がありsearch

両方の主な違いは、 indexOfはプレーンな部分文字列のみであり、 searchは正規表現もサポートしていることです。 もちろん、 indexOfを使用することの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などの標準オブジェクトに独自のカスタムメソッドを追加することは一般的には面倒です。

独自のメソッドやその他のカスタム文字列メソッドが必要な場合は、独自のユーティリティライブラリを作成し、そのライブラリにカスタム文字列メソッドを追加することをお勧めします。

var helper = {};

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

あなたはこれを次のように使用します:

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

サードパーティのユーティリティライブラリを使用する

独自のカスタムヘルパーライブラリを作成したくない場合は、サードパーティのユーティリティライブラリを使用するオプションが常にあります。 で述べたに、最も人気のあるものはLodashUnderscore.jsです。

Lodashでは、あなたは以下のように使用する_.includes()使うことができます:

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

Underscore.jsでは、次のように使用する_.str.include()使用できます。

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

あなたのコードの問題は、JavaScriptが大文字と小文字を区別するということです。 あなたのメソッド呼び出し

indexof()

実際には

indexOf()

それを修正し、それが役立つかどうか確認してください:

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

これを行うための洗練された良い方法があり、それは(BitWise NOT)演算子を使用しています。

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

Bitwise Notは、xがindexOfメソッドから-1になった場合、 - (-1 + 1)= -0に変換され、偽の値である場合、 - (x + 1)に変換します。


JavaScript search()メソッドを使用できます。

構文は次のとおりですstring.search(regexp)

一致の位置を返します。一致するものが見つからない場合は-1を返します。

そこにある例を見てください: jsref_search

複雑な正規表現構文は必要ありません。 あなたがそれらに精通していない場合、単純なst.search("title")が行います。 テストで大文字小文字を区別しないようにするには、 st.search(/title/i)を実行する必要があります。


あなたが醜い-1のチェックを書くための代替手段を探していたならば、代わりにチルダを前に付けます。

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

Joe Zimmerman - 〜を使用すると-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
}

詳細はこちら


Web上でここやそこにあるコードスニペットを使用する代わりに、十分にテストされ、文書化されたライブラリを使用することもできます。 2つのオプション私はお勧めします:

1番目のオプション: Use Lodash :それはincludesメソッドを持っていincludes

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

Lodashはnpmの最も人気のあるjavascriptライブラリの依存関係であり、便利なjavascriptユーティリティメソッドがたくさんあります。 ですから、多くのプロジェクトでは、これはとにかく欲しいでしょう;-)

2番目のオプション:またはUnderscore.string使用:それはincludeメソッドを持っていinclude

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

ここにUnderscore.stringの説明があります。ちょうど9kbが追加されていますが、十分にテストされ、文書化されたライブラリがcopy'n'pasteコードスニペットよりも優れています。

Underscore.stringは文字列を使った快適な操作のためのJavaScriptライブラリで、Prototype.js、Right.js、Underscore、そして美しいRuby言語からインスパイアされたUnderscore.jsの拡張機能です。

Underscore.stringはいくつかの便利な機能を提供します:大文字、クリーン、インクルード、カウント、エスケープHTML、エスケープHTML、挿入、スプライス、startsWith、endsWith、タイトル化、トリム、トランケートなど。

Underscore.strはUnderscore.jsの影響を受けますが、Underscore.jsなしで使用できます。

最後のものではありません: JavaScriptバージョンES6には組み込みincludesメソッドがあります:

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

最新のブラウザではすでにサポートされていますが、 ES6互換性テーブルに注目してください


プロトタイプの使用に関する苦情があり、 indexOfを使用するとコードの読みindexOfが低下し、regexpが過剰であるため、

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

それが私のために終わった妥協です。


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





string-matching