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




हिंदी में जावास्क्रिप्ट परिचय (20)

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

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

https://code.i-harness.com


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


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

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

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


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

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

indexof()

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

indexOf()

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

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

उदाहरण

var a  = "Test String";

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

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

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

x = "teststring";

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

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

x = "teststring";

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

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

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

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


कोड का यह टुकड़ा अच्छी तरह से काम करना चाहिए:

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

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

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

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


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

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

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

RegExp.test(string)


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

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

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

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


सरल कामकाज

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

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


स्ट्रिंग पर अंतर्निर्मित और सरलतम यानी 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");
}

ES6 में string.includes है :

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

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

require('es6-shim')

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


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

 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

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

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

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

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





string-matching