هل هناك إصدار من String.indexOf() الخاص بجافا سكريبت يسمح بالتعبيرات العادية؟
https://stackoverflow.com/questions/273789
-
07-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russianسؤال
في جافا سكريبت، هل يوجد ما يعادل String.indexOf() الذي يأخذ تعبيرًا عاديًا بدلاً من سلسلة للمعلمة الأولى الأولى بينما لا يزال يسمح بالمعلمة الثانية؟
أحتاج إلى القيام بشيء مثل
str.indexOf(/[abc]/ , i);
و
str.lastIndexOf(/[abc]/ , i);
بينما يأخذ String.search() regexp كمعلمة فإنه لا يسمح لي بتحديد وسيطة ثانية!
يحرر:
تبين أن هذا أصعب مما كنت أعتقد في الأصل، لذا كتبت وظيفة اختبار صغيرة لاختبار جميع الحلول المقدمة...يفترض أنه تمت إضافة regexIndexOf وregexLastIndexOf إلى كائن السلسلة.
function test (str) {
var i = str.length +2;
while (i--) {
if (str.indexOf('a',i) != str.regexIndexOf(/a/,i))
alert (['failed regexIndexOf ' , str,i , str.indexOf('a',i) , str.regexIndexOf(/a/,i)]) ;
if (str.lastIndexOf('a',i) != str.regexLastIndexOf(/a/,i) )
alert (['failed regexLastIndexOf ' , str,i,str.lastIndexOf('a',i) , str.regexLastIndexOf(/a/,i)]) ;
}
}
وأنا أقوم بالاختبار على النحو التالي للتأكد من أن النتيجة هي نفسها كما لو استخدمنا مؤشر regexp لشخص واحد على الأقل
// ابحث عن a بين xes
اختبار('xxx');
اختبار ("أكس")؛
اختبار('ساكس');
اختبار('xxa');
اختبار('أكسا');
اختبار('xaa');
اختبار('آكس');
اختبار('أأأ');
المحلول
والجمع بين عدد قليل من الطرق التي سبق ذكرها (وindexOf من الواضح بسيطة إلى حد ما)، وأعتقد أن هذه هي المهام التي من شأنها أن تفعل خدعة:
String.prototype.regexIndexOf = function(regex, startpos) {
var indexOf = this.substring(startpos || 0).search(regex);
return (indexOf >= 0) ? (indexOf + (startpos || 0)) : indexOf;
}
String.prototype.regexLastIndexOf = function(regex, startpos) {
regex = (regex.global) ? regex : new RegExp(regex.source, "g" + (regex.ignoreCase ? "i" : "") + (regex.multiLine ? "m" : ""));
if(typeof (startpos) == "undefined") {
startpos = this.length;
} else if(startpos < 0) {
startpos = 0;
}
var stringToWorkWith = this.substring(0, startpos + 1);
var lastIndexOf = -1;
var nextStop = 0;
while((result = regex.exec(stringToWorkWith)) != null) {
lastIndexOf = result.index;
regex.lastIndex = ++nextStop;
}
return lastIndexOf;
}
ومن الواضح أن تعديل المدمج في سلسلة كائن سترسل أعلام حمراء بالنسبة لمعظم الناس، ولكن هذا قد يكون مرة واحدة عندما لا يكون كبيرا في التوصل الى اتفاق. ببساطة يكون على علم به.
وUPDATE: قام regexLastIndexOf() ذلك يبدو أن غير لتقليد lastIndexOf() الآن. واسمحوا لي أن أعرف إذا كان لا يزال فشل وتحت أي ظرف من الظروف.
وUPDATE: يمر كل الاختبارات وجدت في في تعليقات على هذه الصفحة، وبلدي. بالطبع، هذا لا يعني انها مضاد للرصاص. أي ردود فعل التقدير.
نصائح أخرى
ومثيلات منشئ String لها .search() طريقة حيث يقبل التعبير العادي وإرجاع المؤشر من المباراة الأولى.
لبدء البحث من موقف معين (تزوير المعلمة الثانية من .indexOf()) يمكنك slice من الأحرف الأولى i:
str.slice(i).search(/re/)
ولكن هذا سوف تحصل على مؤشر في سلسلة أقصر (بعد أن شرائح الجزء الأول إيقاف) لذلك عليك تريد ثم لإضافة طول قطعوا جزء (i) إلى مؤشر عاد إذا لم يكن -1 . هذا وسوف تعطيك المؤشر في السلسلة الأصلية:
function regexIndexOf(text, re, i) {
var indexInSuffix = text.slice(i).search(re);
return indexInSuffix < 0 ? indexInSuffix : indexInSuffix + i;
}
ولدي نسخة قصيرة بالنسبة لك. أنه يعمل بشكل جيد بالنسبة لي!
var match = str.match(/[abc]/gi);
var firstIndex = str.indexOf(match[0]);
var lastIndex = str.lastIndexOf(match[match.length-1]);
وإذا كنت ترغب في نسخة النموذج:
String.prototype.indexOfRegex = function(regex){
var match = this.match(regex);
return match ? this.indexOf(match[0]) : -1;
}
String.prototype.lastIndexOfRegex = function(regex){
var match = this.match(regex);
return match ? this.lastIndexOf(match[match.length-1]) : -1;
}
تعديل : إذا كنت ترغب في إضافة الدعم لfromIndex
String.prototype.indexOfRegex = function(regex, fromIndex){
var str = fromIndex ? this.substring(fromIndex) : this;
var match = str.match(regex);
return match ? str.indexOf(match[0]) + fromIndex : -1;
}
String.prototype.lastIndexOfRegex = function(regex, fromIndex){
var str = fromIndex ? this.substring(0, fromIndex) : this;
var match = str.match(regex);
return match ? str.lastIndexOf(match[match.length-1]) : -1;
}
لاستخدامها، بسيطة مثل هذا:
var firstIndex = str.indexOfRegex(/[abc]/gi);
var lastIndex = str.lastIndexOfRegex(/[abc]/gi);
هل يمكن استخدام SUBSTR.
str.substr(i).match(/[abc]/);
بناءً على إجابة BaileyP.والفرق الرئيسي هو أن هذه الأساليب تعود -1 إذا كان لا يمكن مطابقة النمط.
يحرر: بفضل إجابة جيسون بونتينج حصلت على فكرة.لماذا لا يتم تعديل .lastIndex خاصية regex؟على الرغم من أن هذا لن يعمل إلا مع الأنماط ذات العلم العالمي (/g).
يحرر: تم التحديث لاجتياز حالات الاختبار.
String.prototype.regexIndexOf = function(re, startPos) {
startPos = startPos || 0;
if (!re.global) {
var flags = "g" + (re.multiline?"m":"") + (re.ignoreCase?"i":"");
re = new RegExp(re.source, flags);
}
re.lastIndex = startPos;
var match = re.exec(this);
if (match) return match.index;
else return -1;
}
String.prototype.regexLastIndexOf = function(re, startPos) {
startPos = startPos === undefined ? this.length : startPos;
if (!re.global) {
var flags = "g" + (re.multiline?"m":"") + (re.ignoreCase?"i":"");
re = new RegExp(re.source, flags);
}
var lastSuccess = -1;
for (var pos = 0; pos <= startPos; pos++) {
re.lastIndex = pos;
var match = re.exec(this);
if (!match) break;
pos = match.index;
if (pos <= startPos) lastSuccess = pos;
}
return lastSuccess;
}
وأنها لا أصلا، ولكن من المؤكد أننا نستطيع إضافة هذه الوظيفة
<script type="text/javascript">
String.prototype.regexIndexOf = function( pattern, startIndex )
{
startIndex = startIndex || 0;
var searchResult = this.substr( startIndex ).search( pattern );
return ( -1 === searchResult ) ? -1 : searchResult + startIndex;
}
String.prototype.regexLastIndexOf = function( pattern, startIndex )
{
startIndex = startIndex === undefined ? this.length : startIndex;
var searchResult = this.substr( 0, startIndex ).reverse().regexIndexOf( pattern, 0 );
return ( -1 === searchResult ) ? -1 : this.length - ++searchResult;
}
String.prototype.reverse = function()
{
return this.split('').reverse().join('');
}
// Indexes 0123456789
var str = 'caabbccdda';
alert( [
str.regexIndexOf( /[cd]/, 4 )
, str.regexLastIndexOf( /[cd]/, 4 )
, str.regexIndexOf( /[yz]/, 4 )
, str.regexLastIndexOf( /[yz]/, 4 )
, str.lastIndexOf( 'd', 4 )
, str.regexLastIndexOf( /d/, 4 )
, str.lastIndexOf( 'd' )
, str.regexLastIndexOf( /d/ )
]
);
</script>
لم أكن اختبار تماما هذه الأساليب، ولكن يبدو أنها تعمل حتى الآن.
والحالات RexExp لها lastIndex الملكية بالفعل (إذا هم العالمي) وهلم ما أقوم به هو نسخ التعبير العادي، وتعديل طفيف عليه لتلائم أغراضنا، على سلسلة والنظر في exec جي lastIndex. وسيكون هذا حتما أسرع من حلقات في السلسلة. (لديك ما يكفي من الأمثلة لكيفية وضع هذا على نموذج سلسلة، أليس كذلك؟)
function reIndexOf(reIn, str, startIndex) {
var re = new RegExp(reIn.source, 'g' + (reIn.ignoreCase ? 'i' : '') + (reIn.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
function reLastIndexOf(reIn, str, startIndex) {
var src = /\$$/.test(reIn.source) && !/\\\$$/.test(reIn.source) ? reIn.source : reIn.source + '(?![\\S\\s]*' + reIn.source + ')';
var re = new RegExp(src, 'g' + (reIn.ignoreCase ? 'i' : '') + (reIn.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
reIndexOf(/[abc]/, "tommy can eat"); // Returns 6
reIndexOf(/[abc]/, "tommy can eat", 8); // Returns 11
reLastIndexOf(/[abc]/, "tommy can eat"); // Returns 11
ويمكنك أيضا أن النموذج الأولي وظائف على الكائن التعبير العادي:
RegExp.prototype.indexOf = function(str, startIndex) {
var re = new RegExp(this.source, 'g' + (this.ignoreCase ? 'i' : '') + (this.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
RegExp.prototype.lastIndexOf = function(str, startIndex) {
var src = /\$$/.test(this.source) && !/\\\$$/.test(this.source) ? this.source : this.source + '(?![\\S\\s]*' + this.source + ')';
var re = new RegExp(src, 'g' + (this.ignoreCase ? 'i' : '') + (this.multiLine ? 'm' : ''));
re.lastIndex = startIndex || 0;
var res = re.exec(str);
if(!res) return -1;
return re.lastIndex - res[0].length;
};
/[abc]/.indexOf("tommy can eat"); // Returns 6
/[abc]/.indexOf("tommy can eat", 8); // Returns 11
/[abc]/.lastIndexOf("tommy can eat"); // Returns 11
وشرح سريع لكيفية أنا تعديل RegExp: لindexOf أنا فقط لديها لضمان أن يتم تعيين علامة العمومية. لlastIndexOf من أنا باستخدام السلبي نظرة مسبقة للعثور على التواجد الأخير ما لم تكن RegExp كانت مطابقة بالفعل في نهاية السلسلة.
وبعد أن كل الحلول المقترحة تفشل بلدي التجارب بطريقة أو أخرى، (تحرير: بعض تم تحديثها لتمرير الاختبارات بعد أن كتبت هذا) وجدت تنفيذ موزيلا ل <لأ href = "HTTPS: // المطور. mozilla.org/En/Core_JavaScript_1.5_Reference:Objects:String:indexOf "يختلط =" نوفولو noreferrer "> Array.indexOf و <لأ href =" https://developer.mozilla.org/En/Core_JavaScript_1. 5_Reference: كائنات: سلسلة: lastIndexOf "يختلط =" نوفولو noreferrer "> Array.lastIndexOf
ولقد استخدمت تلك لتنفيذ نسختي من String.prototype.regexIndexOf وString.prototype.regexLastIndexOf كما يلي:
String.prototype.regexIndexOf = function(elt /*, from*/)
{
var arr = this.split('');
var len = arr.length;
var from = Number(arguments[1]) || 0;
from = (from < 0) ? Math.ceil(from) : Math.floor(from);
if (from < 0)
from += len;
for (; from < len; from++) {
if (from in arr && elt.exec(arr[from]) )
return from;
}
return -1;
};
String.prototype.regexLastIndexOf = function(elt /*, from*/)
{
var arr = this.split('');
var len = arr.length;
var from = Number(arguments[1]);
if (isNaN(from)) {
from = len - 1;
} else {
from = (from < 0) ? Math.ceil(from) : Math.floor(from);
if (from < 0)
from += len;
else if (from >= len)
from = len - 1;
}
for (; from > -1; from--) {
if (from in arr && elt.exec(arr[from]) )
return from;
}
return -1;
};
ويبدو أنهم لتمرير وظائف اختبار I المنصوص عليها في هذه المسألة.
من الواضح أنها تعمل فقط إذا كان التعبير العادي مباريات حرف واحد ولكن هذا يكفي لهدفي منذ أن كنت سيتم استخدامه لأشياء مثل ([ABC]، \ ق \ W \ D)
وسأبقي مراقبة السؤال في حالة شخص يوفر أسرع / نظافة / تنفيذ أفضل / أكثر عمومية تعمل على أي تعبير منتظم.
وأنا في حاجة إلى وظيفة regexIndexOf أيضا لمجموعة، لذلك أنا مبرمج نفسي واحد. ومع ذلك أشك، وأنه هو الأمثل، ولكن أعتقد أنه يجب أن تعمل بشكل صحيح.
Array.prototype.regexIndexOf = function (regex, startpos = 0) {
len = this.length;
for(x = startpos; x < len; x++){
if(typeof this[x] != 'undefined' && (''+this[x]).match(regex)){
return x;
}
}
return -1;
}
arr = [];
arr.push(null);
arr.push(NaN);
arr[3] = 7;
arr.push('asdf');
arr.push('qwer');
arr.push(9);
arr.push('...');
console.log(arr);
arr.regexIndexOf(/\d/, 4);
في بعض الحالات البسيطة، يمكنك تبسيط البحث العكسي باستخدام التقسيم.
function regexlast(string,re){
var tokens=string.split(re);
return (tokens.length>1)?(string.length-tokens[tokens.length-1].length):null;
}
هذا لديه بعض المشاكل الخطيرة:
- لن تظهر التطابقات المتداخلة
- الفهرس الذي تم إرجاعه مخصص لنهاية المطابقة وليس البداية (جيد إذا كان التعبير العادي الخاص بك ثابتًا)
ولكن على الجانب المشرق، فهي أقل كودًا بكثير.للحصول على تعبير عادي ذو طول ثابت لا يمكن أن يتداخل (مثل /\s\w/ للعثور على حدود الكلمات) هذا جيد بما فيه الكفاية.
بالنسبة للبيانات ذات التطابقات المتفرقة، يعد استخدام string.search هو الأسرع عبر المتصفحات.يقوم بإعادة تقطيع سلسلة في كل تكرار إلى:
function lastIndexOfSearch(string, regex, index) {
if(index === 0 || index)
string = string.slice(0, Math.max(0,index));
var idx;
var offset = -1;
while ((idx = string.search(regex)) !== -1) {
offset += idx + 1;
string = string.slice(idx + 1);
}
return offset;
}
بالنسبة للبيانات الكثيفة قمت بهذا.إنها معقدة مقارنة بطريقة التنفيذ، ولكن بالنسبة للبيانات الكثيفة، فهي أسرع بمقدار 2 إلى 10 مرات من أي طريقة أخرى جربتها، وأسرع بحوالي 100 مرة من الحل المقبول.النقاط الرئيسية هي:
- فهو يستدعي exec على التعبير العادي الذي تم تمريره مرة واحدة للتحقق من وجود تطابق أو الخروج مبكرًا.أفعل ذلك باستخدام (؟= بطريقة مماثلة، ولكن في IE يكون التحقق باستخدام exec أسرع بشكل كبير.
- يقوم بإنشاء وتخزين regex المعدل بالتنسيق "(r).(?!.؟ص)'
يتم تنفيذ التعبير العادي الجديد ويتم إرجاع النتائج من ذلك exec أو exec الأول؛
function lastIndexOfGroupSimple(string, regex, index) { if (index === 0 || index) string = string.slice(0, Math.max(0, index + 1)); regex.lastIndex = 0; var lastRegex, index flags = 'g' + (regex.multiline ? 'm' : '') + (regex.ignoreCase ? 'i' : ''), key = regex.source + '$' + flags, match = regex.exec(string); if (!match) return -1; if (lastIndexOfGroupSimple.cache === undefined) lastIndexOfGroupSimple.cache = {}; lastRegex = lastIndexOfGroupSimple.cache[key]; if (!lastRegex) lastIndexOfGroupSimple.cache[key] = lastRegex = new RegExp('.*(' + regex.source + ')(?!.*?' + regex.source + ')', flags); index = match.index; lastRegex.lastIndex = match.index; return (match = lastRegex.exec(string)) ? lastRegex.lastIndex - match[1].length : index; };
لا أفهم الغرض من الاختبارات في الأعلى.من المستحيل مقارنة المواقف التي تتطلب تعبيرًا عاديًا باستدعاء IndexOf، والذي أعتقد أنه هو الهدف من إنشاء الطريقة في المقام الأول.لاجتياز الاختبار، من المنطقي استخدام "xxx+(؟!x)" بدلاً من ضبط الطريقة التي يتكرر بها التعبير العادي.
ومؤشر جيسون الرايات الأخير من لا يعمل. الألغام ليس الأمثل، لكنه يعمل.
//Jason Bunting's
String.prototype.regexIndexOf = function(regex, startpos) {
var indexOf = this.substring(startpos || 0).search(regex);
return (indexOf >= 0) ? (indexOf + (startpos || 0)) : indexOf;
}
String.prototype.regexLastIndexOf = function(regex, startpos) {
var lastIndex = -1;
var index = this.regexIndexOf( regex );
startpos = startpos === undefined ? this.length : startpos;
while ( index >= 0 && index < startpos )
{
lastIndex = index;
index = this.regexIndexOf( regex, index + 1 );
}
return lastIndex;
}
لا توجد حتى الآن طرق أصلية تؤدي المهمة المطلوبة.
هذا هو الرمز الذي أستخدمه.إنه يحاكي سلوك String.prototype.indexOf و String.prototype.lastIndexOf الأساليب ولكنها تقبل أيضًا RegExp كوسيطة بحث بالإضافة إلى سلسلة تمثل القيمة المطلوب البحث عنها.
نعم، إنها طويلة جدًا طالما أن الإجابة تحاول اتباع المعايير الحالية في أقرب وقت ممكن وبالطبع تحتوي على قدر معقول من JSDOC تعليقات.ومع ذلك، بمجرد تصغيره، يصبح حجم الرمز 2.27 كيلو بايت فقط، وبمجرد ضغطه بواسطة gzip للإرسال يصبح 1023 بايت فقط.
الطريقتان اللتان يضيف إليهما هذا String.prototype (استخدام Object.defineProperty حيثما كان ذلك متاحا) هي:
searchOfsearchLastOf
لقد اجتاز جميع الاختبارات التي نشرها OP، بالإضافة إلى ذلك، قمت باختبار الإجراءات بشكل كامل في استخدامي اليومي، وحاولت التأكد من أنها تعمل عبر بيئات متعددة، ولكن التعليقات/المشكلات مرحب بها دائمًا.
/*jslint maxlen:80, browser:true */
/*
* Properties used by searchOf and searchLastOf implementation.
*/
/*property
MAX_SAFE_INTEGER, abs, add, apply, call, configurable, defineProperty,
enumerable, exec, floor, global, hasOwnProperty, ignoreCase, index,
lastIndex, lastIndexOf, length, max, min, multiline, pow, prototype,
remove, replace, searchLastOf, searchOf, source, toString, value, writable
*/
/*
* Properties used in the testing of searchOf and searchLastOf implimentation.
*/
/*property
appendChild, createTextNode, getElementById, indexOf, lastIndexOf, length,
searchLastOf, searchOf, unshift
*/
(function () {
'use strict';
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1,
getNativeFlags = new RegExp('\\/([a-z]*)$', 'i'),
clipDups = new RegExp('([\\s\\S])(?=[\\s\\S]*\\1)', 'g'),
pToString = Object.prototype.toString,
pHasOwn = Object.prototype.hasOwnProperty,
stringTagRegExp;
/**
* Defines a new property directly on an object, or modifies an existing
* property on an object, and returns the object.
*
* @private
* @function
* @param {Object} object
* @param {string} property
* @param {Object} descriptor
* @returns {Object}
* @see https://goo.gl/CZnEqg
*/
function $defineProperty(object, property, descriptor) {
if (Object.defineProperty) {
Object.defineProperty(object, property, descriptor);
} else {
object[property] = descriptor.value;
}
return object;
}
/**
* Returns true if the operands are strictly equal with no type conversion.
*
* @private
* @function
* @param {*} a
* @param {*} b
* @returns {boolean}
* @see http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.4
*/
function $strictEqual(a, b) {
return a === b;
}
/**
* Returns true if the operand inputArg is undefined.
*
* @private
* @function
* @param {*} inputArg
* @returns {boolean}
*/
function $isUndefined(inputArg) {
return $strictEqual(typeof inputArg, 'undefined');
}
/**
* Provides a string representation of the supplied object in the form
* "[object type]", where type is the object type.
*
* @private
* @function
* @param {*} inputArg The object for which a class string represntation
* is required.
* @returns {string} A string value of the form "[object type]".
* @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.2.4.2
*/
function $toStringTag(inputArg) {
var val;
if (inputArg === null) {
val = '[object Null]';
} else if ($isUndefined(inputArg)) {
val = '[object Undefined]';
} else {
val = pToString.call(inputArg);
}
return val;
}
/**
* The string tag representation of a RegExp object.
*
* @private
* @type {string}
*/
stringTagRegExp = $toStringTag(getNativeFlags);
/**
* Returns true if the operand inputArg is a RegExp.
*
* @private
* @function
* @param {*} inputArg
* @returns {boolean}
*/
function $isRegExp(inputArg) {
return $toStringTag(inputArg) === stringTagRegExp &&
pHasOwn.call(inputArg, 'ignoreCase') &&
typeof inputArg.ignoreCase === 'boolean' &&
pHasOwn.call(inputArg, 'global') &&
typeof inputArg.global === 'boolean' &&
pHasOwn.call(inputArg, 'multiline') &&
typeof inputArg.multiline === 'boolean' &&
pHasOwn.call(inputArg, 'source') &&
typeof inputArg.source === 'string';
}
/**
* The abstract operation throws an error if its argument is a value that
* cannot be converted to an Object, otherwise returns the argument.
*
* @private
* @function
* @param {*} inputArg The object to be tested.
* @throws {TypeError} If inputArg is null or undefined.
* @returns {*} The inputArg if coercible.
* @see https://goo.gl/5GcmVq
*/
function $requireObjectCoercible(inputArg) {
var errStr;
if (inputArg === null || $isUndefined(inputArg)) {
errStr = 'Cannot convert argument to object: ' + inputArg;
throw new TypeError(errStr);
}
return inputArg;
}
/**
* The abstract operation converts its argument to a value of type string
*
* @private
* @function
* @param {*} inputArg
* @returns {string}
* @see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tostring
*/
function $toString(inputArg) {
var type,
val;
if (inputArg === null) {
val = 'null';
} else {
type = typeof inputArg;
if (type === 'string') {
val = inputArg;
} else if (type === 'undefined') {
val = type;
} else {
if (type === 'symbol') {
throw new TypeError('Cannot convert symbol to string');
}
val = String(inputArg);
}
}
return val;
}
/**
* Returns a string only if the arguments is coercible otherwise throws an
* error.
*
* @private
* @function
* @param {*} inputArg
* @throws {TypeError} If inputArg is null or undefined.
* @returns {string}
*/
function $onlyCoercibleToString(inputArg) {
return $toString($requireObjectCoercible(inputArg));
}
/**
* The function evaluates the passed value and converts it to an integer.
*
* @private
* @function
* @param {*} inputArg The object to be converted to an integer.
* @returns {number} If the target value is NaN, null or undefined, 0 is
* returned. If the target value is false, 0 is returned
* and if true, 1 is returned.
* @see http://www.ecma-international.org/ecma-262/5.1/#sec-9.4
*/
function $toInteger(inputArg) {
var number = +inputArg,
val = 0;
if ($strictEqual(number, number)) {
if (!number || number === Infinity || number === -Infinity) {
val = number;
} else {
val = (number > 0 || -1) * Math.floor(Math.abs(number));
}
}
return val;
}
/**
* Copies a regex object. Allows adding and removing native flags while
* copying the regex.
*
* @private
* @function
* @param {RegExp} regex Regex to copy.
* @param {Object} [options] Allows specifying native flags to add or
* remove while copying the regex.
* @returns {RegExp} Copy of the provided regex, possibly with modified
* flags.
*/
function $copyRegExp(regex, options) {
var flags,
opts,
rx;
if (options !== null && typeof options === 'object') {
opts = options;
} else {
opts = {};
}
// Get native flags in use
flags = getNativeFlags.exec($toString(regex))[1];
flags = $onlyCoercibleToString(flags);
if (opts.add) {
flags += opts.add;
flags = flags.replace(clipDups, '');
}
if (opts.remove) {
// Would need to escape `options.remove` if this was public
rx = new RegExp('[' + opts.remove + ']+', 'g');
flags = flags.replace(rx, '');
}
return new RegExp(regex.source, flags);
}
/**
* The abstract operation ToLength converts its argument to an integer
* suitable for use as the length of an array-like object.
*
* @private
* @function
* @param {*} inputArg The object to be converted to a length.
* @returns {number} If len <= +0 then +0 else if len is +INFINITY then
* 2^53-1 else min(len, 2^53-1).
* @see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
*/
function $toLength(inputArg) {
return Math.min(Math.max($toInteger(inputArg), 0), MAX_SAFE_INTEGER);
}
/**
* Copies a regex object so that it is suitable for use with searchOf and
* searchLastOf methods.
*
* @private
* @function
* @param {RegExp} regex Regex to copy.
* @returns {RegExp}
*/
function $toSearchRegExp(regex) {
return $copyRegExp(regex, {
add: 'g',
remove: 'y'
});
}
/**
* Returns true if the operand inputArg is a member of one of the types
* Undefined, Null, Boolean, Number, Symbol, or String.
*
* @private
* @function
* @param {*} inputArg
* @returns {boolean}
* @see https://goo.gl/W68ywJ
* @see https://goo.gl/ev7881
*/
function $isPrimitive(inputArg) {
var type = typeof inputArg;
return type === 'undefined' ||
inputArg === null ||
type === 'boolean' ||
type === 'string' ||
type === 'number' ||
type === 'symbol';
}
/**
* The abstract operation converts its argument to a value of type Object
* but fixes some environment bugs.
*
* @private
* @function
* @param {*} inputArg The argument to be converted to an object.
* @throws {TypeError} If inputArg is not coercible to an object.
* @returns {Object} Value of inputArg as type Object.
* @see http://www.ecma-international.org/ecma-262/5.1/#sec-9.9
*/
function $toObject(inputArg) {
var object;
if ($isPrimitive($requireObjectCoercible(inputArg))) {
object = Object(inputArg);
} else {
object = inputArg;
}
return object;
}
/**
* Converts a single argument that is an array-like object or list (eg.
* arguments, NodeList, DOMTokenList (used by classList), NamedNodeMap
* (used by attributes property)) into a new Array() and returns it.
* This is a partial implementation of the ES6 Array.from
*
* @private
* @function
* @param {Object} arrayLike
* @returns {Array}
*/
function $toArray(arrayLike) {
var object = $toObject(arrayLike),
length = $toLength(object.length),
array = [],
index = 0;
array.length = length;
while (index < length) {
array[index] = object[index];
index += 1;
}
return array;
}
if (!String.prototype.searchOf) {
/**
* This method returns the index within the calling String object of
* the first occurrence of the specified value, starting the search at
* fromIndex. Returns -1 if the value is not found.
*
* @function
* @this {string}
* @param {RegExp|string} regex A regular expression object or a String.
* Anything else is implicitly converted to
* a String.
* @param {Number} [fromIndex] The location within the calling string
* to start the search from. It can be any
* integer. The default value is 0. If
* fromIndex < 0 the entire string is
* searched (same as passing 0). If
* fromIndex >= str.length, the method will
* return -1 unless searchValue is an empty
* string in which case str.length is
* returned.
* @returns {Number} If successful, returns the index of the first
* match of the regular expression inside the
* string. Otherwise, it returns -1.
*/
$defineProperty(String.prototype, 'searchOf', {
enumerable: false,
configurable: true,
writable: true,
value: function (regex) {
var str = $onlyCoercibleToString(this),
args = $toArray(arguments),
result = -1,
fromIndex,
match,
rx;
if (!$isRegExp(regex)) {
return String.prototype.indexOf.apply(str, args);
}
if ($toLength(args.length) > 1) {
fromIndex = +args[1];
if (fromIndex < 0) {
fromIndex = 0;
}
} else {
fromIndex = 0;
}
if (fromIndex >= $toLength(str.length)) {
return result;
}
rx = $toSearchRegExp(regex);
rx.lastIndex = fromIndex;
match = rx.exec(str);
if (match) {
result = +match.index;
}
return result;
}
});
}
if (!String.prototype.searchLastOf) {
/**
* This method returns the index within the calling String object of
* the last occurrence of the specified value, or -1 if not found.
* The calling string is searched backward, starting at fromIndex.
*
* @function
* @this {string}
* @param {RegExp|string} regex A regular expression object or a String.
* Anything else is implicitly converted to
* a String.
* @param {Number} [fromIndex] Optional. The location within the
* calling string to start the search at,
* indexed from left to right. It can be
* any integer. The default value is
* str.length. If it is negative, it is
* treated as 0. If fromIndex > str.length,
* fromIndex is treated as str.length.
* @returns {Number} If successful, returns the index of the first
* match of the regular expression inside the
* string. Otherwise, it returns -1.
*/
$defineProperty(String.prototype, 'searchLastOf', {
enumerable: false,
configurable: true,
writable: true,
value: function (regex) {
var str = $onlyCoercibleToString(this),
args = $toArray(arguments),
result = -1,
fromIndex,
length,
match,
pos,
rx;
if (!$isRegExp(regex)) {
return String.prototype.lastIndexOf.apply(str, args);
}
length = $toLength(str.length);
if (!$strictEqual(args[1], args[1])) {
fromIndex = length;
} else {
if ($toLength(args.length) > 1) {
fromIndex = $toInteger(args[1]);
} else {
fromIndex = length - 1;
}
}
if (fromIndex >= 0) {
fromIndex = Math.min(fromIndex, length - 1);
} else {
fromIndex = length - Math.abs(fromIndex);
}
pos = 0;
rx = $toSearchRegExp(regex);
while (pos <= fromIndex) {
rx.lastIndex = pos;
match = rx.exec(str);
if (!match) {
break;
}
pos = +match.index;
if (pos <= fromIndex) {
result = pos;
}
pos += 1;
}
return result;
}
});
}
}());
(function () {
'use strict';
/*
* testing as follow to make sure that at least for one character regexp,
* the result is the same as if we used indexOf
*/
var pre = document.getElementById('out');
function log(result) {
pre.appendChild(document.createTextNode(result + '\n'));
}
function test(str) {
var i = str.length + 2,
r,
a,
b;
while (i) {
a = str.indexOf('a', i);
b = str.searchOf(/a/, i);
r = ['Failed', 'searchOf', str, i, a, b];
if (a === b) {
r[0] = 'Passed';
}
log(r);
a = str.lastIndexOf('a', i);
b = str.searchLastOf(/a/, i);
r = ['Failed', 'searchLastOf', str, i, a, b];
if (a === b) {
r[0] = 'Passed';
}
log(r);
i -= 1;
}
}
/*
* Look for the a among the xes
*/
test('xxx');
test('axx');
test('xax');
test('xxa');
test('axa');
test('xaa');
test('aax');
test('aaa');
}());<pre id="out"></pre>إذا كنت تبحث عن البحث lastIndex بسيط جدا مع التعبير العادي ولا يهمني إذا كان يحاكي lastIndexOf إلى أدق التفاصيل، وهذا قد تجذب انتباهك.
وأنا ببساطة عكس سلسلة، وطرح مؤشر قوع أول من طول - 1. يحدث ذلك على اجتياز اختبار بلدي، ولكن أعتقد أن هناك يمكن أن تنشأ مشكلة أداء مع سلاسل طويلة
interface String {
reverse(): string;
lastIndex(regex: RegExp): number;
}
String.prototype.reverse = function(this: string) {
return this.split("")
.reverse()
.join("");
};
String.prototype.lastIndex = function(this: string, regex: RegExp) {
const exec = regex.exec(this.reverse());
return exec === null ? -1 : this.length - 1 - exec.index;
};
حسنا، كما كنت تبحث فقط لتتناسب مع موقف ذات طابع <م> ، التعابير المنطقية هو ربما مبالغة.
وافترض كل ما تريده هو، بدلا من "تجد أول هذه هذه الشخصية"، مجرد العثور على أول هذه الشخصيات.
وهذا بالطبع هو الجواب بسيط، ولكنه يفعل ما يحدد سؤالك القيام به، وإن كان ذلك دون الجزء رجإكس (لأنك لم يوضح لماذا على وجه التحديد أنه كان لابد من التعابير المنطقية)
function mIndexOf( str , chars, offset )
{
var first = -1;
for( var i = 0; i < chars.length; i++ )
{
var p = str.indexOf( chars[i] , offset );
if( p < first || first === -1 )
{
first = p;
}
}
return first;
}
String.prototype.mIndexOf = function( chars, offset )
{
return mIndexOf( this, chars, offset ); # I'm really averse to monkey patching.
};
mIndexOf( "hello world", ['a','o','w'], 0 );
>> 4
mIndexOf( "hello world", ['a'], 0 );
>> -1
mIndexOf( "hello world", ['a','o','w'], 4 );
>> 4
mIndexOf( "hello world", ['a','o','w'], 5 );
>> 6
mIndexOf( "hello world", ['a','o','w'], 7 );
>> -1
mIndexOf( "hello world", ['a','o','w','d'], 7 );
>> 10
mIndexOf( "hello world", ['a','o','w','d'], 10 );
>> 10
mIndexOf( "hello world", ['a','o','w','d'], 11 );
>> -1
