javascript - كيفية التحقق مما إذا كانت السلسلة تحتوي على سلسلة فرعية في جافا سكريبت؟


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



Answers


وفيما يلي قائمة بالإمكانيات الحالية:

1. إندكسوف

var string = "foo",
    substring = "oo";
string.indexOf(substring) !== -1;

String.prototype.indexOf ترجع موضع السلسلة في السلسلة الأخرى. إذا لم يتم العثور عليه، فإنه سيعود -1 .

2. (ES6) يتضمن - الذهاب إلى الإجابة ، أو هذه الإجابة

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

3. البحث - انتقل إلى الإجابة

var string = "foo",
    expr = /oo/;
string.search(expr);

4. لوداش يشمل - الذهاب إلى الإجابة

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

5. ريجيكس - الذهاب إلى الإجابة

var string = "foo",
    expr = /oo/;  // no quotes here
expr.test(string);

6. المباراة - انتقل إلى الإجابة

var string = "foo",
    expr = /oo/;
string.match(expr);

اختبارات الأداء ( http://jsben.ch/#/RVYk7 ) تظهر أن إندكسوف قد يكون الخيار الأفضل، إذا كان الأمر يتعلق بنقطة حيث السرعة.




يمكنك بسهولة إضافة أسلوب 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 index = haystack.indexOf(needle);






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

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

فإنه يعود موقف المباراة، أو -1 إذا لم يتم العثور على تطابق.

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

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




String.prototype.includes() تم عرضه في ES6.

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

بناء الجملة

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

المعلمات

searchString

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

position

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




إذا كنت تبحث عن بديل لكتابة القبيح -1 الاختيار، كنت مسبقا قبل تيلد بدلا من ذلك.

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

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

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

يمكنك الآن الحصول على عدد أقل من الأحرف في الشفرة حتى تتمكن من كتابتها كما يلي:

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

مزيد من التفاصيل هنا




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

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



في ES5

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

في ES6 هناك ثلاث طرق جديدة: 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




هناك طريقة شائعة لكتابة طريقة contains جافا سكريبت هي:

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

يتم استخدام عامل النفي ذروة ( ~ ) لتحويل -1 إلى 0 (فالسي)، وسوف تكون جميع القيم الأخرى غير صفر (تروثي).

يتم استخدام مشغلي النفي منطقية مزدوجة لإدخال الرقم إلى منطقية.




يمكنك استخدام جكري's :contains محدد.

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

التحقق من ذلك هنا: يحتوي على محدد




بدلا من استخدام مقتطفات الشفرة الموجودة هنا وهناك على الويب، يمكنك أيضا استخدام مكتبة تم اختبارها بشكل جيد وموثقة. خياران أوصيان:

الخيار الأول: استخدام لوداش : يحتوي على طريقة includes :

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

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

الخيار الثاني: أو استخدام وندرسكور. سترينغ : يحتوي على طريقة include :

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

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

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

وندرسكور. سترينغ يوفر لك العديد من الوظائف المفيدة: الاستفادة من، نظيفة، ويشمل، العد، هربلتمل، ونيسكابتمل، إدراج، لصق، يبدأ ويث، ينتهيث، تيتليز، تقليم، اقتطاع وهلم جرا.

لاحظ جيدا، يتأثر Undererscore.string التي undererscore.js ولكن يمكن استخدامها دون ذلك.

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

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

معظم المتصفحات الحديثة تدعم بالفعل ذلك، لديها العين على جدول التوافق ES6 .







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

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



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




تحتاج إلى استدعاء إندكسوف مع رأس المال "O" كما هو مذكور. وتجدر الإشارة أيضا إلى أنه في فئة جافا سكريبت كلمة محجوزة، تحتاج إلى استخدام كلاسنام للحصول على سمة البيانات هذه. السبب في أنه ربما فشل لأنه يرجع قيمة فارغة. يمكنك إجراء ما يلي للحصول على قيمة الفصل الدراسي ...

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



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

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

x = "teststring";

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



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

// 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 أو باستخدام التعبير العادي هو مبالغة قليلا.




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

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

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




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

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

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

انظر أيضا في جافا سكريبت، ما هو الفرق بين إندكسوف () والبحث ()؟ .

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

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

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

يمكنك استخدامه مثل هذا:

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

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

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

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

var helper = {};

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

يمكنك استخدامه مثل هذا:

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

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

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

في لوداش، يمكنك استخدام _.includes() ، والتي تستخدمها مثل هذا:

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

في _.str.include() ، يمكنك استخدام _.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

مرجع مدن




مثال

var a  = "Test String";

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



رمز جافا سكريبت لاستخدام الطريقة المحتوية في مصفوفة:

<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 ما إذا كان العنصر المحدد موجودا في المصفوفة أم لا. إذا كان العنصر المحدد موجودا في الصفيف، فإنه يرجع ترو، وإلا فإنه يقوم بإرجاع كاذبة.







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

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

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

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




جافا سكريبت

 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



استخدام يحمل في ثناياه عوامل وأبسط واحد أي 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");
}



أسهل طريقة هي في الواقع باستخدام إندكسوف . للتحقق فقط من سلسلة حروف string فرعية substr يمكنك استخدام هذه الطريقة:

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

هنا هو جسفيدل كذلك.