Javascript regex - разделительная строка

Борьба с требованием регулярного выражения. Мне нужно разбить строку на массив везде, где он находит косую черту. Но нет, если передняя косая черта предшествует побегу.

Например, если у меня есть эта строка:

hello/world

Я бы хотел, чтобы он был разбит на массив следующим образом:

arrayName[0] = hello
arrayName[1] = world

И если у меня есть эта строка:

hello/wo\/rld

Я хотел бы, чтобы он был разбит на массив следующим образом:

arrayName[0] = hello
arrayName[1] = wo/rld

Любые идеи?

Ответы

Ответ 1

Ниже приведен немного длинный, но он будет работать и избегает проблемы с IE с разбивкой раздельной реализации, не используя регулярное выражение.

function splitPath(str) {
    var rawParts = str.split("/"), parts = [];
    for (var i = 0, len = rawParts.length, part; i < len; ++i) {
        part = "";
        while (rawParts[i].slice(-1) == "\\") {
            part += rawParts[i++].slice(0, -1) + "/";
        }
        parts.push(part + rawParts[i]);
    }
    return parts;
}

var str = "hello/world\\/foo/bar";
alert( splitPath(str).join(",") );

Ответ 2

Я бы не использовал split() для этого задания. Гораздо проще сопоставлять компоненты пути, а не разделители. Например:

var subject = 'hello/wo\\/rld';
var regex = /(?:[^\/\\]+|\\.)+/g;
var matched = null;
while (matched = regex.exec(subject)) {
  print(matched[0]);
}

выход:

hello
wo\/rld

протестируйте его на ideone.com

Ответ 3

Вот способ, адаптированный из методов в этом сообщении в блоге:

var str = "Testing/one\\/two\\/three";
var result = str.replace(/(\\)?\//g, function($0, $1){
  return $1 ? '/' : '[****]';
}).split('[****]');

Пример в реальном времени

Дано:

Testing/one\/two\/three

Результат:

[0]: Testing
[1]: one/two/three

Вначале используется простой "поддельный" lookbehind для замены / на [****] и для замены \/ на /, затем разбивается на значение [****]. (Очевидно, замените [****] на все, что не будет в строке.)

Ответ 4

/* Если вы получаете строку из ответа ajax или запроса базы данных, то есть строка не была интерпретирована javascript, вы можете сопоставлять последовательности символов, которые либо не имеют косой черты, либо имеют экранированные косые черты. Если вы определяете строку в script, избегайте экранов и разделяйте их после совпадения. */

var s='hello/wor\\/ld';
s=s.match(/(([^\/]*(\\\/)+)([^\/]*)+|([^\/]+))/g) || [s];
alert(s.join('\n'))
s.join('\n').replace(/\\/g,'')

/*  returned value: (String)
hello
wor/ld
*/

Ответ 6

Для короткого кода вы можете использовать reverse для имитации негативного lookbehind

function reverse(s){
  return s.split('').reverse().join('');
}

var parts = reverse(myString).split(/[/](?!\\(?:\\\\)*(?:[^\\]|$))/g).reverse();
for (var i = parts.length; --i >= 0;) { parts[i] = reverse(parts[i]); }

но для того, чтобы быть эффективным, вероятно, лучше разделить на /[/]/, а затем пройти массив и вернуться к элементам, у которых есть побег в конце.

Ответ 7

Что-то вроде этого может позаботиться о нем для вас.

var str = "/hello/wo\\/rld/";
var split = str.replace(/^\/|\\?\/|\/$/g, function(match) {
  if (match.indexOf('\\') == -1) {
    return '\x00';
  }
  return match;
}).split('\x00');       

alert(split);