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


Answers

आप इस कथन के साथ स्ट्रिंग contains आसानी से एक विधि 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; }; }
Question

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

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




जावास्क्रिप्ट में एक विधि लिखने का एक आम तरीका है:

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

Bitwise negation ऑपरेटर ( ~ ) का उपयोग -1 में 0 (झूठी) को चालू करने के लिए किया जाता है, और अन्य सभी मान गैर-शून्य (सत्य) होंगे।

डबल बुलियन नकारात्मक ऑपरेटर का उपयोग बुलियन में संख्या डालने के लिए किया जाता है।




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




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

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

x = "teststring";

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

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

x = "teststring";

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



जावास्क्रिप्ट

 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



आप जावास्क्रिप्ट search() विधि का उपयोग कर सकते हैं।

सिंटेक्स है: string.search(regexp)

यह मैच की स्थिति देता है, या -1 यदि कोई मैच नहीं मिलता है।

वहां उदाहरण देखें: jsref_search

आपको एक जटिल नियमित अभिव्यक्ति वाक्यविन्यास की आवश्यकता नहीं है। यदि आप उनके साथ परिचित नहीं हैं तो एक साधारण st.search("title") करेगा। यदि आप चाहते हैं कि आपका परीक्षण केस असंवेदनशील हो, तो आपको st.search(/title/i) करना चाहिए।




var index = haystack.indexOf(needle);



ऐसा करने के लिए एक चिकना और बेहतर तरीका है और यह (बिटवाइज नोट) ऑपरेटर का उपयोग कर रहा है।

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

बिटवाईव "x" में परिवर्तित नहीं होता है - (x + 1) तो, यदि एक्स इंडेक्स से विधि -1 से बाहर हो जाता है। तो इसे - (-1 + 1) = -0 में परिवर्तित किया जाएगा जो एक झूठा मूल्य है।




सरल कामकाज

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

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




किसी प्रकार के वैध समाधान एकत्र करने के लिए:

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




सबसे आसान तरीका वास्तव में indexOf का उपयोग कर रहा है। एक सबस्ट्रिंग substr लिए केवल स्ट्रिंग string जांच करने के लिए आप इस विधि का उपयोग कर सकते हैं:

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

अब आप इस पारिस्थितिक छोटी विधि का उपयोग यह जांचने के लिए कर सकते हैं कि एक स्ट्रिंग में एक विशेष सबस्ट्रिंग है या नहीं:

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

यहां एक JSFiddle भी है।




नियमित अभिव्यक्ति का प्रयोग करें:

RegExp.test(string)




आप .indexOf लिए .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)
}




यदि आप बदसूरत -1 चेक लिखने के विकल्प की तलाश में थे, तो आप इसके बजाय ~ tilde तैयार करते हैं।

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

जो ज़िमर्मन - आप देखेंगे कि ~ ऑन -1 का उपयोग करके इसे 0 तक बदल दिया गया है। संख्या 0 एक झूठा मूल्य है, जिसका अर्थ है कि यह एक बूलियन में परिवर्तित होने पर झूठी मूल्यांकन करेगा। यह पहली बार एक बड़ी अंतर्दृष्टि की तरह प्रतीत नहीं होता है, लेकिन इंडेक्सऑफ जैसे कार्यों को याद रखें जब क्वेरी नहीं मिलती है। इसका मतलब है कि इस तरह कुछ लिखने के बजाय:

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

अब आपके कोड में कम वर्ण हो सकते हैं ताकि आप इसे इस तरह लिख सकें:

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

यहां अधिक जानकारी




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

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

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




Links