كيفية التحقق مما إذا كانت سلسلة تحتوي على سلسلة فرعية في JavaScript؟




string substring (20)

عادة ما أتوقع طريقة String.contains() ، ولكن لا يبدو أن هناك واحدة.

ما هي الطريقة المعقولة للتحقق من ذلك؟


String.prototype.indexOf() أو String.prototype.search() ؟!

كما ذكر آخرون بالفعل ، تحتوي سلاسل جافا سكريبت على كل من String.prototype.indexOf وطريقة search .

والفرق الرئيسي بينهما هو أن indexOf مخصص لسلاسل فرعية بسيطة فقط ، بينما يدعم search أيضًا التعبيرات العادية. بطبيعة الحال ، فإن الاتجاه الصعودي لاستخدام indexOf هو أنه أسرع.

راجع أيضًا في JavaScript ، ما هو الفرق بين indexOf () و search ()؟ .

تنفيذ طريقة String.prototype.contains() الخاصة بك

إذا كنت ترغب في إضافة طريقة خاصة بك contains على كل سلسلة ، فإن أفضل طريقة لفعل ذلك هي نهج :

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

سوف تستخدمها على هذا النحو:

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

تنفيذ مكتبة أدوات مخصصة

عادةً ما يتم العبوس عند إضافة طرق مخصصة خاصة بك إلى كائنات قياسية في JavaScript ، على سبيل المثال ، لأنها قد تقطع التوافق.

إذا كنت ترغب بالفعل في احتواء منطقتك contains الطريقة و / أو غيرها من طرق السلسلة المخصصة ، فمن الأفضل إنشاء مكتبة الأدوات الخاصة بك وإضافة أساليب السلسلة المخصصة إلى تلك المكتبة:

var helper = {};

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

سوف تستخدمها على هذا النحو:

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

باستخدام مكتبة أدوات خارجية

إذا كنت لا ترغب في إنشاء مكتبة المساعد المخصصة الخاصة بك ، فهناك - بالطبع - خيار استخدام مكتبة أدوات خارجية. كما ذكرنا من قبل ، الأكثر شعبية هي Lodash و Underscore.js .

في Lodash ، يمكنك استخدام _.includes() ، الذي تستخدمه على _.includes() :

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

في Underscore.js ، يمكنك استخدام _.str.include() ، الذي تستخدمه على _.str.include() :

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

إذا كنت تبحث عن بديل لكتابة الشيك القبيح -1 ، فأنت تقترب من التيلدا بدلاً من ذلك.

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

جو زيمرمان - سترى أن استخدام ~ في -1 يحولها إلى 0. الرقم 0 هو قيمة خادعة ، بمعنى أنه سيتم تقييمه إلى خطأ عند تحويله إلى قيمة منطقية. قد لا يبدو ذلك بمثابة إحصاء كبير في البداية ، ولكن تذكر أن الدالات مثل indexOf ستعود -1 عندما لا يتم العثور على الاستعلام. هذا يعني أنه بدلاً من كتابة شيء مشابه لهذا:

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

Lodash هو الأكثر شعبية في مكتبة جافا سكريبت التبعية ل npm ولديه الكثير من أساليب فائدة جافا سكريبت في متناول يدي. لذلك بالنسبة للعديد من المشاريع التي تريدها على أي حال ؛-)

الخيار الثاني: أو استخدم Underscore.string : يحتوي على أسلوب include :

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

هنا هو وصف Underscore.string ، فإنه يضيف فقط 9kb لكنه يمنحك جميع المزايا مكتبة مختبرة جيدا وموثقة على نسخ مقتطفات copy'n'paste code:

Underscore.string هي مكتبة جافا سكريبت لمعالجة مريحة مع السلاسل ، وامتداد ل Underscore.js مستوحاة من Prototype.js و Right.js و Underscore ولغة Ruby الجميلة.

يوفر لك Underscore.string العديد من الوظائف المفيدة: تكبير ، تنظيف ، تضمين ، فرز ، escapeHTML ، unescapeHTML ، إدراج ، لصق ، startWith ، ينتهي مع ، titleize ، trim ، اقتطاع وهكذا.

لاحظ جيدًا ، يتأثر Underscore.js بـ Underscore.js ولكن يمكن استخدامه بدونه.

آخر ليس أقل: مع إصدار جافا سكريبت ES6 يأتي المدمج في includes طريقة:

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

معظم المستعرضات الحديثة تدعمها بالفعل ، تراقب جدول التوافق مع ES6 .


بما أن السؤال شائع جدًا ، أعتقد أنه يمكنني إضافة القليل من النكهة الحديثة إلى الشفرة.

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

راجع للشغل ، والإجابة الصحيحة هي الخطأ الإملائي indexOf أو String.contains غير قياسي. تحميل مكتبة خارجية (خاصة إذا كانت الشفرة مكتوبة بلغة JavaScript خالصة) أو العبث مع String.prototype أو باستخدام تعبير عادي هو مبالغة صغيرة.


تكمن المشكلة في التعليمة البرمجية في أن جافا سكريبت حساس لحالة الأحرف. استدعاء الأسلوب الخاص بك

indexof()

يجب أن يكون في الواقع

indexOf()

جرّب إصلاحه ومعرفة ما إذا كان ذلك يساعد على:

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

تم تقديم String.prototype.includes() في ES6.

يحدد ما إذا كان يمكن العثور على سلسلة واحدة داخل سلسلة أخرى ، وإرجاع صواب أو خطأ كما هو مناسب.

بناء الجملة

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

المعلمات

searchString

سلسلة يتم البحث عنها ضمن هذه السلسلة.

position

الموضع في هذه السلسلة التي تبدأ searchString البحث عن searchString الافتراضي إلى 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 الرقائق في المتصفحات القديمة.


خيار آخر للقيام بذلك هو:

يمكنك استخدام وظيفة المطابقة ، أي شيء من هذا القبيل:

x = "teststring";

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

يمكن أن تعمل match () أيضًا مع التعبير العادي:

x = "teststring";

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

شفرة جافا سكريبت لاستخدام الطريقة التي 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 ما إذا كان العنصر المحدد موجودًا في الصفيف أم لا. إذا كان العنصر المحدد موجودًا في المصفوفة ، فسوف يعرض true ، وإلا فسيرجع false.


كنت تبحث عن .indexOf String.prototype.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)
}


لجمع بعض الحلول الصالحة:

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 يجعل التعليمة البرمجية أقل قابلية للقراءة ، وبما أن التعبير العادي هو overkill:

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

هذا هو الحل الوسط الذي انتهى به الأمر.


هذا فقط عملت بالنسبة لي. وهي تحدد السلاسل التي لا تحتوي على المصطلح "المحذوفة:"

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

هناك طريقة أنيق وأفضل للقيام بذلك وهو يستخدم عامل التشغيل (BitWise NOT).

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

Bitwise لا يحول "x" إلى - (x + 1) ، إذا كان x يتحول إلى -1 من أسلوب indexOf.then سيتم تحويله إلى - (-1 + 1) = -0 وهي قيمة كاذبة.


يجب أن تعمل هذه الشفرة بشكل جيد:

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

يمكنك استخدام jQuery's :contains المحدّد.

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

التحقق من ذلك هنا: contains-selector


يمكنك استخدام طريقة JavaScript search() .

البناء هو: string.search(regexp)

تقوم بإرجاع موضع المطابقة أو -1 إذا لم يتم العثور على تطابق.

انظر الأمثلة هناك: jsref_search

لست بحاجة إلى صيغة تعبير عادية معقدة. إذا لم تكن على دراية بها st.search("title") بسيط. إذا كنت تريد أن يكون الاختبار الخاص بك غير حساس لحالة الأحرف ، فيجب عليك القيام بـ st.search(/title/i) .


هناك string.includes في ES6 :

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

ملاحظة قد تحتاج إلى تحميل es6-shim أو ما شابه ذلك للحصول على هذا العمل على المتصفحات القديمة.

require('es6-shim')

جافا سكريبت

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

مسج

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found

استخدم inbuilt وأبسط واحد أي 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 ، لدينا مكالمات تتضمن ما يقوم به بالضبط ما تريد: لذا يمكنك ببساطة القيام بهذا:

'str1'.includes('str2');

أيضًا في ES5 ، إذا كنت تستخدمه على نطاق واسع ، فيمكنك ببساطة إضافته كما يلي:

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




string-matching