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




string substring contains string-matching (25)

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

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


Answers

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

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

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

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


ES6 में string.includes है :

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

ध्यान दें कि आपको पुराने ब्राउज़र पर काम करने के लिए es6-shim या इसी तरह लोड करने की आवश्यकता हो सकती है।

require('es6-shim')

var index = haystack.indexOf(needle);

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

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

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


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

'str1'.includes('str2');

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

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

यह सिर्फ मेरे लिए काम किया। यह उन तारों के लिए चयन करता है जिनमें "हटाया गया" शब्द नहीं है:

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

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

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

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


आप .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
}

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


वेब पर यहां और वहां पाए गए कोड स्निपेट का उपयोग करने के बजाय, आप एक अच्छी तरह से परीक्षण और दस्तावेजीकृत लाइब्रेरी का भी उपयोग कर सकते हैं। दो विकल्प मैं अनुशंसा करता हूं:

पहला विकल्प: Lodash उपयोग करें: इसमें एक विधि includes है:

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

लोडाश एनपीएम के लिए सबसे लोकप्रिय जावास्क्रिप्ट लाइब्रेरी निर्भरता है और इसमें आसान जावास्क्रिप्ट उपयोगिता विधियों का भार है। तो कई परियोजनाओं के लिए आप इसे वैसे भी चाहते हैं ;-)

दूसरा विकल्प: या Underscore.string उपयोग करें: इसमें एक विधि include है:

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

यहां Underscore.string का विवरण दिया गया है, यह सिर्फ 9 केबी जोड़ता है लेकिन आपको सभी फायदे देता है जो एक अच्छी तरह से परीक्षण और दस्तावेजीकृत लाइब्रेरी की प्रतिलिपि 'स्नैप कोड स्निपेट पर है:

Underscore.string स्ट्रिंग्स के साथ आरामदायक हेरफेर के लिए जावास्क्रिप्ट लाइब्रेरी है, प्रोटोटाइप.जेएस, राइट.जेएस, अंडरस्कोर और सुंदर रूबी भाषा से प्रेरित Underscore.js के लिए एक्सटेंशन।

Underscore.string आपको कई उपयोगी फ़ंक्शंस प्रदान करता है: पूंजीकरण, साफ, शामिल, गिनती, एस्केप HTML, unescapeHTML, डालें, splice, startWith, endwith, titleize, trim, truncate और इसी तरह से।

ध्यान दें, Underscore.string Underscore.js से प्रभावित है लेकिन इसका उपयोग बिना किया जा सकता है।

आखिरी नहीं कम: जावास्क्रिप्ट संस्करण ES6 के साथ एक अंतर्निहित विधि includes है:

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

अधिकांश आधुनिक ब्राउज़र पहले से ही इसका समर्थन करते हैं, ईएस 6 संगतता तालिका पर नजर रखते हैं।


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

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


उदाहरण

var a  = "Test String";

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

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

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

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

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

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

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


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


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

// 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 या नियमित अभिव्यक्ति का उपयोग करना थोड़ा अधिक है।


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

 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

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

indexof()

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

indexOf()

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

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

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

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


ईएस 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


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

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

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

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

शायद आप ऐसा कुछ कर सकते हैं

$(document).ready(function() {
   var visible = $('#tElement').is(':visible');

   if(visible) {
      alert("visible");
                    // Code
   }
   else
   {
      alert("hidden");
   }
});
<script src="https://code.jquery.com/jquery-1.10.2.js"></script>

<input type="text" id="tElement" style="display:block;">Firstname</input>





javascript string substring contains string-matching