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




15 Answers

वर्तमान संभावनाओं की एक सूची यहां दी गई है:

1. (ईएस 6) में includes - उत्तर पर जाएं

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

2. ईएस 5 और पुरानी 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 सबसे अच्छा विकल्प हो सकता है, अगर यह उस बिंदु पर आता है जहां गति मायने रखती है।

आमतौर पर मैं एक String.contains() विधि की अपेक्षा करता String.contains() , लेकिन ऐसा प्रतीत नहीं होता है।

इसके लिए जांच करने का एक उचित तरीका क्या है?




आपके कोड के साथ समस्या यह है कि जावास्क्रिप्ट केस संवेदनशील है। आपकी विधि कॉल

indexof()

वास्तव में होना चाहिए

indexOf()

इसे ठीक करने का प्रयास करें और देखें कि क्या इससे मदद मिलती है:

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



var index = haystack.indexOf(needle);



String.prototype.includes() ES6 में पेश किया गया था।

यह निर्धारित करता है कि एक स्ट्रिंग किसी अन्य स्ट्रिंग के भीतर पाई जा सकती है, जो सही या गलत के रूप में उपयुक्त हो रही है।

वाक्य - विन्यास

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

पैरामीटर

searchString

इस स्ट्रिंग के भीतर एक स्ट्रिंग की खोज की जाएगी।

position

इस स्ट्रिंग में स्थिति जिस पर खोज स्ट्रिंग के लिए खोज शुरू करना 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 str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 



ईएस 5 में

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

endsWith() में तीन नए तरीके हैं: 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




आप jQuery का उपयोग कर सकते हैं :contains चयनकर्ता :contains

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

इसे यहां देखें: contains-selector




ऐसा करने का एक और विकल्प यह है:

आप मैच फ़ंक्शन का उपयोग कर सकते हैं, यानी कुछ ऐसा है:

x = "teststring";

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

मैच () नियमित अभिव्यक्ति के साथ भी काम कर सकते हैं:

x = "teststring";

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



जैसा कि बताया गया है, आपको पूंजी "ओ" के साथ indexOf को कॉल करने की आवश्यकता है। यह भी ध्यान दिया जाना चाहिए कि जावास्क्रिप्ट क्लास में एक आरक्षित शब्द है, आपको इस डेटा विशेषता प्राप्त करने के लिए कक्षा नाम का उपयोग करने की आवश्यकता है। संभवतः यह असफल होने का कारण यह है कि यह एक शून्य मान लौटा रहा है। आप अपनी कक्षा मूल्य प्राप्त करने के लिए निम्नलिखित कर सकते हैं ...

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



चूंकि सवाल बहुत लोकप्रिय है, मैंने सोचा कि मैं कोड में थोड़ा आधुनिक स्वाद जोड़ सकता हूं।

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

बीटीडब्लू, सही जवाब गलत वर्तनी String.contains या गैर-मानक String.contains । बाहरी पुस्तकालय लोड करना (विशेष रूप से यदि कोड शुद्ध जावास्क्रिप्ट में लिखा गया है) या String.prototype साथ String.prototype या नियमित अभिव्यक्ति का उपयोग करना थोड़ा अधिक है।




String.prototype.indexOf() या String.prototype.search() ?

जैसा कि अन्य ने पहले से ही उल्लेख किया है, जावास्क्रिप्ट तारों में एक String.prototype.indexOf और search विधि दोनों हैं।

दोनों के बीच महत्वपूर्ण अंतर यह है कि indexOf केवल सादे सबस्ट्रिंग के लिए है, जबकि search नियमित अभिव्यक्तियों का भी समर्थन करती है। बेशक, indexOf का उपयोग करने का एक उछाल यह है कि यह तेज़ है।

जावास्क्रिप्ट में भी देखें , indexOf () और खोज () के बीच क्या अंतर है?

अपनी खुद की String.prototype.contains() विधि को कार्यान्वित करना

यदि आप प्रत्येक स्ट्रिंग contains अपना स्वयं का तरीका जोड़ना चाहते हैं, तो ऐसा करने का सबसे अच्छा तरीका का दृष्टिकोण होगा:

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

आप इसका इस्तेमाल इस तरह करेंगे:

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

एक कस्टम उपयोगिता पुस्तकालय कार्यान्वित करना

यह आम तौर पर जावास्क्रिप्ट में मानक वस्तुओं के लिए अपनी खुद की कस्टम विधियों को जोड़ने के लिए तैयार है, उदाहरण के लिए, क्योंकि यह संगतता को तोड़ सकता है।

यदि आप वास्तव में अपनी खुद की विधि और / या अन्य कस्टम स्ट्रिंग विधियों को चाहते हैं, तो अपनी खुद की उपयोगिता लाइब्रेरी बनाना बेहतर है और उस लाइब्रेरी में अपनी कस्टम स्ट्रिंग विधियां जोड़ें:

var helper = {};

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

आप इसका इस्तेमाल इस तरह करेंगे:

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

किसी तृतीय-पक्ष उपयोगिता लाइब्रेरी का उपयोग करना

यदि आप अपनी खुद की कस्टम सहायक लाइब्रेरी नहीं बनाना चाहते हैं, तो निश्चित रूप से - हमेशा एक तृतीय-पक्ष उपयोगिता लाइब्रेरी का उपयोग करने का विकल्प होता है। जैसा कि द्वारा उल्लेख किया गया है, सबसे लोकप्रिय लोग Lodash और Underscore.js

लोडाश में, आप _.includes() उपयोग कर सकते हैं, जिसका आप इस तरह उपयोग करते हैं:

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

Underscore.js में, आप _.str.include() उपयोग कर सकते हैं, जिसका आप इस तरह उपयोग करते हैं:

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



सरल कामकाज

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

एमडीएन संदर्भ




एक सरणी में contains विधि का उपयोग करने के लिए जावास्क्रिप्ट कोड:

<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 विधि निर्धारित करती है कि निर्दिष्ट तत्व सरणी में मौजूद है या नहीं। यदि निर्दिष्ट तत्व सरणी में मौजूद है, तो यह सत्य लौटाता है, अन्यथा यह झूठा लौटाता है।




चूंकि प्रोटोटाइप का उपयोग करने के बारे में कोई शिकायत है, और indexOf का उपयोग करने से आपका कोड कम पठनीय बनाता है, और चूंकि regexp अधिक है:

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

यही वह समझौता है जिसके लिए मैं जा रहा हूं।




ईएस 6 में , हमारे पास कुछ कॉल शामिल हैं जो वास्तव में आप जो चाहते हैं: तो आप बस ऐसा ही कर सकते हैं:

'str1'.includes('str2');

ईएस 5 में भी, यदि आप इसका व्यापक रूप से उपयोग करते हैं, तो आप इसे आसानी से जोड़ सकते हैं:

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



Related

javascript string substring contains string-matching