Существует ли версия JavaScript String.indexOf(), позволяющая использовать регулярные выражения?
https://stackoverflow.com/questions/273789
-
07-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Существует ли в javascript эквивалент String.indexOf(), который принимает регулярное выражение вместо строки для первого первого параметра, но при этом допускает второй параметр?
мне нужно сделать что-то вроде
str.indexOf(/[abc]/ , i);
и
str.lastIndexOf(/[abc]/ , i);
Хотя String.search() принимает регулярное выражение в качестве параметра, я не могу указать второй аргумент!
Редактировать:
Это оказалось сложнее, чем я думал изначально, поэтому я написал небольшую тестовую функцию для проверки всех предложенных решений...предполагается, что regexIndexOf и regexLastIndexOf были добавлены к объекту String.
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)]) ;
}
}
и я тестирую следующим образом, чтобы убедиться, что хотя бы для одного регулярного выражения символов результат такой же, как если бы мы использовали indexOf
//Ищем a среди xes
тест('ххх');
тест('ахх');
тест('xax');
тест('хха');
тест('акса');
тест('хаа');
тест('аакс');
тест('ааа');
Решение
Объединив несколько уже упомянутых подходов (очевидно, 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;
}
Очевидно, что изменение встроенного объекта String вызовет тревогу у большинства людей, но это может быть один раз, когда это не так уж важно;просто осознавайте это.
ОБНОВЛЯТЬ:Отредактировано regexLastIndexOf() так что это похоже на имитацию lastIndexOf() сейчас.Пожалуйста, дайте мне знать, если это все еще не удается и при каких обстоятельствах.
ОБНОВЛЯТЬ:Проходит все тесты, указанные в комментариях на этой странице и мои собственные.Конечно, это не значит, что он пуленепробиваемый.Любая обратная связь приветствуется.
Другие советы
Экземпляры String у конструктора есть .search() метод который принимает RegExp и возвращает индекс первого совпадения.
Чтобы начать поиск с определенной позиции (подделка второго параметра .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);
Вы можете использовать подстр.
str.substr(i).match(/[abc]/);
На основе ответа BaileyP.Основное отличие состоит в том, что эти методы возвращают -1 если шаблон не может быть сопоставлен.
Редактировать: Благодаря ответу Джейсона Бантинга у меня появилась идея.Почему бы не изменить .lastIndex свойство регулярного выражения?Хотя это будет работать только для шаблонов с глобальным флагом (/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 экземпляры имеют последнийиндекс свойство уже есть (если оно глобальное), поэтому я копирую регулярное выражение, слегка изменяя его в соответствии с нашими целями, 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:
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 уже совпадало в конце строки.
После того, как все предложенные решения так или иначе провалили мои тесты (редактировать:некоторые были обновлены, чтобы пройти тесты после того, как я написал это) Я нашел реализацию Mozilla для Array.indexOf и Массив.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;
};
Кажется, они проходят тестовые функции, которые я указал в вопросе.
Очевидно, они работают только в том случае, если регулярное выражение соответствует одному символу, но для моей цели этого достаточно, поскольку я буду использовать его для таких вещей, как ([abc] , \s , \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 происходит значительно быстрее.
- Он создает и кэширует измененное регулярное выражение в формате '(r).(?!.?р)'
Новое регулярное выражение выполняется, и возвращаются результаты либо этого выполнения, либо первого выполнения;
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 КБ, а после сжатия для передачи — всего 1023 байта.
2 метода, которые это добавляет к String.prototype (с использованием Object.defineProperty если таковые имеются):
searchOfsearchLastOf
Он проходит все тесты, опубликованные в ОП, и, кроме того, я довольно тщательно протестировал эти процедуры в своем ежедневном использовании и постарался убедиться, что они работают в нескольких средах, но отзывы/проблемы всегда приветствуются.
/*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 с помощью RegExp и вас не волнует, имитирует ли он 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
