यह कैसे जांचा जाए कि स्ट्रिंग में जावास्क्रिप्ट में सबस्ट्रिंग के टेक्स्ट से पाठ है?

Question

बहुत सीधा। जावास्क्रिप्ट में, मुझे यह जांचने की आवश्यकता है कि क्या किसी स्ट्रिंग में किसी सरणी में आयोजित कोई सबस्ट्रिंग है।

Comments

क्या map()नए HTML5-JavaScript-संस्करण में कोई फ़ंक्शन नहीं है ? मुझे याद है कि उस विषय पर कुछ पढ़ा ...

— मार्टिन हेन्निंग्स

@ मर्टिन: अच्छी बात है, mapजितना नहीं some। someमदद करेगा, लेकिन आपको इसे एक फ़ंक्शन पास करना होगा।

— टीजे क्राउडर

Answer 1

इसमें कुछ भी अंतर्निहित नहीं है जो आपके लिए ऐसा करेगा, आपको इसके लिए एक फ़ंक्शन लिखना होगा।

यदि आप जानते हैं कि स्ट्रिंग्स में कोई भी ऐसा अक्षर नहीं है जो नियमित अभिव्यक्तियों में विशेष हो, तो आप इस तरह से थोड़ा धोखा दे सकते हैं:

if (new RegExp(substrings.join("|")).test(string)) {
    // At least one match
}

... जो एक नियमित अभिव्यक्ति बनाता है जो आपके द्वारा खोजे जाने वाले सबस्ट्रिंग्स के लिए विकल्पों की एक श्रृंखला है (उदाहरण के लिए one|two) और यह देखने के लिए परीक्षण करता है कि उनमें से किसी के लिए मैच हैं, लेकिन यदि किसी भी सब्सट्रेट में कोई भी वर्ण हैं जो विशेष हैं regexes ( *और [, आदि) में, आपको पहले उनसे बचना होगा और आप इसके बजाय सिर्फ बोरिंग लूप से बेहतर कर सकते हैं।

लाइव उदाहरण:

var substrings = ["one", "two", "three"];
var str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (new RegExp(substrings.join("|")).test(str)) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (new RegExp(substrings.join("|")).test(str)) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

---

सवाल पर एक टिप्पणी में, मार्टिनArray.prototype.map ECMAScript5 में नई विधि के बारे में पूछता है । mapयह सब बहुत मदद नहीं है, लेकिन someयह है:

if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    // There's at least one
}

लाइव उदाहरण:

var substrings = ["one", "two", "three"];
var str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

आपके पास केवल ECMAScript5- अनुरूप कार्यान्वयन पर है, हालांकि यह पॉलीफ़िल के लिए तुच्छ है।

---

2020 में अपडेट : someउदाहरण एक तीर फ़ंक्शन (ES2015 +) के साथ सरल हो सकता है, और आप includesइसके बजाय उपयोग कर सकते हैं indexOf:

if (substrings.some(v => str.includes(v))) {
    // There's at least one
}

लाइव उदाहरण:

const substrings = ["one", "two", "three"];
let str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (substrings.some(v => str.includes(v))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(v => str.includes(v))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

या यहां तक ​​कि bindइसे फेंक दो, हालांकि मेरे लिए तीर फ़ंक्शन बहुत अधिक पठनीय है:

if (substrings.some(str.includes.bind(str))) {
    // There's at least one
}

लाइव उदाहरण:

const substrings = ["one", "two", "three"];
let str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (substrings.some(str.includes.bind(str))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(str.includes.bind(str))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

Comments

"माइंड यू, इसका मतलब कुछ ओवरहेड है ..." लेकिन परवाह करने के लिए कुछ भी नहीं ।

— टीजे क्राउडर

आप '' | 'को छोड़कर सभी रेगेक्स वर्णों को हटाकर उपरोक्त समाधान का विस्तार कर सकते हैं new RegExp(substrings.join("|").replace(/[^\w\s^|]/gi, '')).test(string)।

— user007

IndexOf का उपयोग बहुत अधिक फजी हो सकता है और एक अजीब परिणाम दे सकता है। इसे समान ऑपरेटर के उपयोग से स्ट्रिंग से मिलान करने के लिए रखा जा सकता है। जैसे ('disconnect'.indexOf('connect') >= 0) === trueलेकिन('disconnect' === 'conenct') === false

— kylewelsby

@ झरना: हुह? मैं तुम्हें समझ नहीं रहा हूँ, मुझे डर है। जवाब में कुछ भी ऊपर चलता है कि 'disconnect' === 'connect'कुछ भी लेकिन हो जाएगा false। इसके अलावा, indexOfफजी नहीं है, यह वास्तव में बहुत स्पष्ट रूप से परिभाषित है।

— टीजे क्राउडर

indexOfदोनों से मेल खाएगा disconnectऔर connectजहां एक मामले में मैंने अनुभव किया है, ये दो अलग-अलग मामले हैं जो मैं एक सशर्त के लिए परिणाम वापस करना चाहता हूं।

— केलवेल्स्बी

Answer 2

var yourstring = 'tasty food'; // the string to check against


var substrings = ['foo','bar'],
    length = substrings.length;
while(length--) {
   if (yourstring.indexOf(substrings[length])!=-1) {
       // one of the substrings is in yourstring
   }
}

Answer 3

एक लाइन समाधान

substringsArray.some(substring=>yourBigString.includes(substring))

true\falseयदि विकल्प हो तो लौटाता हैexists\does'nt exist

ES6 समर्थन की आवश्यकता है

Comments

तीर के कार्यों का उपयोग करते हुए महान समाधान

— GuerillaRadio

आप बच्चे ... वापस जब मैं एक बच्चा था तो हमें इन चीजों का उपयोग 'लूप्स' के लिए करना था, और आपको कई लाइनों का उपयोग करना था और यह जानना था कि क्या आपका सरणी 1 या शून्य आधारित था, हाँ ... आधा समय आपको मिला यह गलत था और डीबग करना पड़ा और 'आई' नामक एक छोटे से बग्गर की तलाश की।

— aamarks

Answer 4

function containsAny(str, substrings) {
    for (var i = 0; i != substrings.length; i++) {
       var substring = substrings[i];
       if (str.indexOf(substring) != - 1) {
         return substring;
       }
    }
    return null; 
}

var result = containsAny("defg", ["ab", "cd", "ef"]);
console.log("String was found in substring " + result);

Comments

समझने में आसान!

— डेरिल एच।

साथ ही यह स्ट्रिंग में शब्द की पहली घटना लौटाता है, जो बहुत मददगार है। केवल सच / झूठ नहीं।

— काई नैक

Answer 5

Googling के लोगों के लिए,

ठोस जवाब होना चाहिए।

const substrings = ['connect', 'ready'];
const str = 'disconnect';
if (substrings.some(v => str === v)) {
   // Will only return when the `str` is included in the `substrings`
}

Comments

या इससे कम: यदि (सबस्ट्रिंग

— .some

ध्यान दें कि यह थोड़ा अलग प्रश्न का उत्तर है, जो पूछता है कि क्या स्ट्रिंग में सबस्ट्रिंग के एक पाठ से पाठ होता है । यह कोड जाँचता है कि क्या एक स्ट्रिंग सबस्ट्रिंग में से एक है। निर्भर करता है कि "समाहित" से क्या मतलब है "मुझे लगता है।

— 19

Answer 6

var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = 0, len = arr.length; i < len; ++i) {
    if (str.indexOf(arr[i]) != -1) {
        // str contains arr[i]
    }
}

संपादित करें: यदि परीक्षणों का क्रम मायने नहीं रखता है, तो आप इसका उपयोग कर सकते हैं (केवल एक लूप चर के साथ):

var str = "texttexttext";
var arr = ["asd", "ghj", "xtte"];
for (var i = arr.length - 1; i >= 0; --i) {
    if (str.indexOf(arr[i]) != -1) {
        // str contains arr[i]
    }
}

Comments

आपके पहले उदाहरण को lenचर की जरूरत नहीं है , बस जाँच करें i < arr.length।

— ग्रेसेज

Answer 7

यदि सरणी बड़ी नहीं है, तो आप बस लूप कर सकते हैं और प्रत्येक प्रतिस्थापन के खिलाफ स्ट्रिंग की जांच कर सकते हैं indexOf()। वैकल्पिक रूप से आप विकल्प के रूप में सब्सट्रिंग्स के साथ एक नियमित अभिव्यक्ति का निर्माण कर सकते हैं, जो अधिक कुशल हो सकता है या नहीं।

Comments

मान लीजिए कि हमारे पास 100 सबस्ट्रिंग की एक सूची है। कौन सा तरीका अधिक कुशल होगा: RegExp या लूप?

— डायोरबेक सादुल्लायव

Answer 8

जावास्क्रिप्ट फ़ंक्शन खोज स्ट्रिंग या खोज स्ट्रिंग के एक सरणी का उपयोग करके टैग या कीवर्ड की एक सरणी की खोज करने के लिए कार्य करता है। ( ES5 कुछ सरणी विधि और ES6 तीर फ़ंक्शन का उपयोग करता है )

// returns true for 1 or more matches, where 'a' is an array and 'b' is a search string or an array of multiple search strings
function contains(a, b) {
    // array matches
    if (Array.isArray(b)) {
        return b.some(x => a.indexOf(x) > -1);
    }
    // string match
    return a.indexOf(b) > -1;
}

उदाहरण उपयोग:

var a = ["a","b","c","d","e"];
var b = ["a","b"];
if ( contains(a, b) ) {
    // 1 or more matches found
}

Answer 9

ऐसा नहीं है कि मैं सुझाव दे रहा हूं कि आप जाएं और Stringप्रोटोटाइप को बढ़ाएं / संशोधित करें , लेकिन यही मैंने किया है:

String.prototype.includes ()

String.prototype.includes = function (includes) {
    console.warn("String.prototype.includes() has been modified.");
    return function (searchString, position) {
        if (searchString instanceof Array) {
            for (var i = 0; i < searchString.length; i++) {
                if (includes.call(this, searchString[i], position)) {
                    return true;
                }
            }
            return false;
        } else {
            return includes.call(this, searchString, position);
        }
    }
}(String.prototype.includes);

console.log('"Hello, World!".includes("foo");',          "Hello, World!".includes("foo")           ); // false
console.log('"Hello, World!".includes(",");',            "Hello, World!".includes(",")             ); // true
console.log('"Hello, World!".includes(["foo", ","])',    "Hello, World!".includes(["foo", ","])    ); // true
console.log('"Hello, World!".includes(["foo", ","], 6)', "Hello, World!".includes(["foo", ","], 6) ); // false

Answer 10

टीजे क्राउडर के समाधान से आकर्षित, मैंने इस समस्या से निपटने के लिए एक प्रोटोटाइप बनाया:

Array.prototype.check = function (s) {
  return this.some((v) => {
    return s.indexOf(v) >= 0;
  });
};

Answer 11

substringsArray.every(substring=>yourBigString.indexOf(substring) === -1)

पूर्ण समर्थन के लिए;)

Answer 12

सबसे अच्छा जवाब यहाँ है: यह मामला असंवेदनशील होने के साथ-साथ है

    var specsFilter = [.....];
    var yourString = "......";

    //if found a match
    if (specsFilter.some((element) => { return new RegExp(element, "ig").test(yourString) })) {
        // do something
    }

Answer 13

अंडरस्कोर.जेएस या लॉश.जेएस का उपयोग करके, आप स्ट्रिंग्स की एक सरणी पर निम्न कार्य कर सकते हैं:

var contacts = ['Billy Bob', 'John', 'Bill', 'Sarah'];

var filters = ['Bill', 'Sarah'];

contacts = _.filter(contacts, function(contact) {
    return _.every(filters, function(filter) { return (contact.indexOf(filter) === -1); });
});

// ['John']

और एक ही तार पर:

var contact = 'Billy';
var filters = ['Bill', 'Sarah'];

_.every(filters, function(filter) { return (contact.indexOf(filter) >= 0); });

// true

Answer 14

यह सुपर लेट है, लेकिन मैं इस समस्या में भाग गया। अपने स्वयं के प्रोजेक्ट में मैंने यह जांचने के लिए निम्नलिखित का उपयोग किया कि क्या एक स्ट्रिंग एक सरणी में थी:

["a","b"].includes('a')     // true
["a","b"].includes('b')     // true
["a","b"].includes('c')     // false

इस तरह आप एक पूर्वनिर्धारित सारणी ले सकते हैं और जाँच सकते हैं कि उसमें कोई तार है या नहीं:

var parameters = ['a','b']
parameters.includes('a')    // true

Answer 15

टीजे क्राउडर के जवाब पर निर्माण

"कम से कम एक बार" घटना के लिए परीक्षण करने के लिए बच निकले RegExp का उपयोग करते हुए, कम से कम सबस्ट्रिंग में से एक।

function buildSearch(substrings) {
  return new RegExp(
    substrings
    .map(function (s) {return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');})
    .join('{1,}|') + '{1,}'
  );
}


var pattern = buildSearch(['hello','world']);

console.log(pattern.test('hello there'));
console.log(pattern.test('what a wonderful world'));
console.log(pattern.test('my name is ...'));

Answer 16

यदि आप रिक्त स्थान या किसी अन्य सामान्य चरित्र द्वारा अलग किए गए "पूर्ण" शब्दों से मिलकर सबस्ट्रिंग की एक लंबी सूची के साथ काम कर रहे हैं, तो आप अपनी खोज में थोड़ा चतुर हो सकते हैं।

पहले अपनी स्ट्रिंग को X के समूहों में विभाजित करें, फिर X + 1, फिर X + 2, ..., Y. X और Y तक क्रमशः आपके सबसे कम और सबसे अधिक शब्दों के स्थान पर आपके शब्दों की संख्या होनी चाहिए। उदाहरण के लिए यदि X 1 है और Y 4 है, तो "अल्फा बीटा गामा डेल्टा" बन जाता है:

"अल्फा" "बीटा" "गामा" "डेल्टा"

"अल्फा बीटा" "बीटा गामा" "गामा डेल्टा"

"अल्फा बीटा गामा" "बीटा गामा डेल्टा"

"अल्फा बीटा गामा डेल्टा"

यदि X 2 होगा और Y 3 होगा, तो आप पहली और अंतिम पंक्ति छोड़ देंगे।

अब आप इस सूची पर जल्दी से खोज कर सकते हैं यदि आप इसे एक सेट (या मैप) में सम्मिलित करते हैं, तो स्ट्रिंग तुलना की तुलना में बहुत तेज।

नकारात्मक पक्ष यह है कि आप "ता गाम" जैसे सबस्ट्रिंग की खोज नहीं कर सकते हैं। बेशक आप इसके लिए शब्द के बजाय चरित्र से विभाजित करके अनुमति दे सकते हैं, लेकिन फिर आपको अक्सर एक बड़े पैमाने पर सेट बनाने की आवश्यकता होगी और ऐसा करने में लगने वाले समय / स्मृति को लाभ मिलेगा।

Answer 17

पूर्ण समर्थन के लिए (@ricca के verions के अतिरिक्त )।

wordsArray = ['hello', 'to', 'nice', 'day']
yourString = 'Hello. Today is a nice day'.toLowerCase()
result = wordsArray.every(w => yourString.includes(w))
console.log('result:', result)

Answer 18

आप इस तरह की जाँच कर सकते हैं:

<!DOCTYPE html>
<html>
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
      <script>
         $(document).ready(function(){
         var list = ["bad", "words", "include"] 
         var sentence = $("#comments_text").val()

         $.each(list, function( index, value ) {
           if (sentence.indexOf(value) > -1) {
                console.log(value)
            }
         });
         });
      </script>
   </head>
   <body>
      <input id="comments_text" value="This is a bad, with include test"> 
   </body>
</html>

Answer 19

let obj = [{name : 'amit'},{name : 'arti'},{name : 'sumit'}];
let input = 'it';

फ़िल्टर का उपयोग करें:

obj.filter((n)=> n.name.trim().toLowerCase().includes(input.trim().toLowerCase()))

Comments

कृपया देखें और देखें कि किसी प्रश्न का उत्तर कैसे दिया जाए ।

— यूनुस टेमुरलेनक

@YunusTemurlenk thnx

— ArtiSK