Я хотел бы разделить строку ввода на первом двоеточие, у которого по-прежнему есть символы после него в той же строке.
Для этого я использую регулярное выражение /:(.+)/
Таким образом, строка
aaa:
bbb:ccc
Я ожидаю вывод
["aaa:\nbbb", "ccc"]
И учитывая строку
aaa:bbb:ccc
Я ожидаю вывод
["aaa", "bbb:ccc"]
Но когда я действительно запускаю эти команды, я получаю
["aaa:\nbbb", "ccc", ""]
["aaa", "bbb:ccc", ""]
Как вывод.
Итак, как-то javascript добавляет пустую строку в конец массива.
Я проверил документацию для String.split и в то же время упоминает, что если вы выполняете String.split в пустой строке с указанный разделитель, вы получите массив с 1 пустой строкой в нем (а не пустой массив). Он не упоминает о том, что всегда всегда есть пустая строка на выходе или предупреждение о том, что вы можете получить этот результат, если вы совершаете распространенную ошибку или что-то в этом роде.
Я бы понял, была ли в моей строке ввода двоеточие в конце или что-то в этом роде; то он разбивается на двоеточие, а остальная часть матча - пустая строка. Это проблема, упомянутая в Разделение строки с регулярным выражением, чтобы сделать ее массивом без пустого элемента - но у меня нет этой проблемы, так как моя строка ввода не заканчивается моим сепаратор.
Я знаю, что быстрым решением в моем случае будет просто ограничение количества совпадений, через "aaa:bbb:ccc".split(/:(.+)/, 2), но мне все же интересно:
Почему этот вызов String.split возвращает массив, заканчивающийся пустой строкой?
Если мы изменим регулярное выражение на /:.+/ и выполним разделение на него, вы получите:
["aaa", ""]
Это имеет смысл, поскольку регулярное выражение соответствует :bbb:ccc.
И дает вам тот же результат, если вы должны вручную разбить эту строку.
>>> 'aaa:bbb:ccc'.split(':bbb:ccc')
['aaa', '']
Добавление группы захвата просто сохраняет bbb:ccc, но не должно изменять исходное поведение разложения.
Интересно. Многому научился у этого вопроса. Позвольте мне поделиться тем, что я узнал.
Если мы подумаем об этом, мы намерены разделить строку на основе :, за которой следует одно или несколько символов. Если это так, выход должен был быть
['aaa', '\nbbb:ccc', '']
правильно? Потому что .+ соответствует жадности. Таким образом, он должен быть разбит на :\nbbb:ccc, где : соответствует : и .+ соответствует \nbbb:ccc. Но фактический результат, который вы получили, был
[ 'aaa:\nbbb', 'ccc', '' ]
Это связано с тем, что . не соответствует терминаторам строк. Цитирование MDN,
(точка, десятичная точка) соответствует любому одиночному символу, кроме терминаторов строк:\n,\r,\u2028 или \u2029.
Итак, :\n не соответствует :(.+). Вот почему он не ломается. Если вы на самом деле должны совпадать с новой строкой,, используйте либо [^], либо [\s\S].
Например,
console.log(data.split(/:([\s\S]+)/));
// [ 'aaa:\nbbb', 'ccc', '' ]
console.log(data.split(/:([\s\S]+)/));
// [ 'aaa', '\nbbb:ccc', '' ]
console.log(data.split(/:([^]+)/));
// [ 'aaa', '\nbbb:ccc', '' ]
Теперь, чтобы ответить на ваш реальный вопрос, почему в конце разделения есть пустая строка. Когда вы сокращаете большую линию, сколько строк вы получаете? Две маленькие линии. Поэтому всякий раз, когда вы делаете разрез, должны быть два объекта. В вашем случае aaa:\nbbb - это первый разрез, фактическое место обрезания - :ccc, и поскольку строка заканчивается там, пустая строка включается, чтобы указать, что это конец строки.
Из спецификация ECMAScript 2015 (String.prototype.split):
Если разделитель является регулярным выражением, которое содержит захват круглые скобки, то каждый раз, когда разделитель сопоставляется с результатами (включая любые результаты undefined) скользящих круглых скобок сплайсируется в выходной массив. Например,
"A<B>bold</B>and<CODE>coded</CODE>".split(/<(\/)?([^<>]+)>/)вычисляет массив:
["A", undefined, "B", "bold", "/", "B", "and", undefined, "CODE", "coded", "/", "CODE", ""]
Как и в примере вашего примера, выходной массив здесь содержит завершающую пустую строку, которая является частью входной строки минус "coded", которая не захватывается шаблоном разделителя (который захватывает "/" и "CODE").
Не очевидно, но имеет смысл, поскольку в противном случае разделители будут заканчиваться в конце разделенного массива, где они фактически ничего не будут отделять.