Замените все не алфавитно-цифровые символы, новые строки и несколько пробелов одним пробелом

Я ищу аккуратный RegEx решение заменить

  • все не алфавитно-цифровые символы
  • Все Новые Строки
  • все несколько экземпляров пробела

С одним пробелом

для тех, кто играет дома (далее работает)

text.replace(/[^a-z0-9]/gmi, " ").replace(/s+/g, " ");

Я думаю RegEx вероятно, достаточно мощный, чтобы достичь это в одном заявлении. Компоненты, которые я думаю, id нужны

  • [^a-z0-9] - для удаления не буквенно-цифровых символов
  • s+ матч семейств пространств
  • r?n|r матч все новые строки
  • /gmi - глобальные, многоканальный регистр

тем не менее, я не могу, кажется, стиль регулярного выражения в правильном направлении (следующую не работа)

text.replace(/[^a-z0-9]|s+|r?n|r/gmi, " ");

вход

234&^%,Me,2 2013 1080p x264 5 1 BluRay
S01(*&asd 05
S1E5
1x05
1x5

Нужный Выход

234 Me 2 2013 1080p x264 5 1 BluRay S01 asd 05 S1E5 1x05 1x5
87
alphanumeric javascript regex replace

6 ответов

имейте в виду, что \W листья подчеркивания. Короткий эквивалент для [^a-zA-Z0-9] будет [\W_]

text.replace(/[\W_]+/g," ");

\W это отрицание сокращение \w на [A-Za-z0-9_] символы слов (включая подчеркивание)

пример на regex101.com

131

Джонни 5 опередил меня. Я собирался предложить использовать \W+ без \s а в text.replace(/\W+/g, " "). Это также покрывает пустое пространство.

136

С [^a-z0-9] класс символов содержит все, что не является alnum, он также содержит белые символы!

 text.replace(/[^a-z0-9]+/gi, " ");
9

Ну, я думаю, вам просто нужно добавить Квантор к каждому шаблону. Также карета-возвращение вещь немного смешно:

text.replace(/[^a-z0-9]+|\s+/gmi, " ");

редактировать The \s что соответствует \r и \n тоже.

5

a видел другой пост, который также имел диакритические метки, что здорово

s.replace(/[^a-zA-Z0-9À-ž\s]/g, "")

1

это мой старый пост, принятые ответы по большей части хороши. Однако я решил проверить каждое решение и еще одно очевидное (просто для удовольствия). Я задавался вопросом, есть ли разница между шаблонами регулярных выражений в разных браузерах с разными строками размера.

поэтому в основном я использовал см. Этот тест jsperf on

  • тестирование в Chrome 65.0.3325 / Windows 10 0.0.0
  • тестирование в Edge 16.16299.0 / Windows 10 0.0.0

шаблоны регулярных выражений, которые я тестировал, были

  • /[\W_]+/g
  • /[^a-z0-9]+/gi
  • /[^a-zA-Z0-9]+/g

Я загрузил их с длиной строки случайных символов

  • длина 5000
  • длина 1000
  • длина 200

пример javascript, который я использовал var newstr = str.replace(/[\W_]+/g," ");

каждый прогон состоял из 50 или более образцов на каждом регулярном выражении, и я запускаю их 5 время в каждом браузере.

давайте наперегонки наших лошадей!

результаты

                                Chrome                  Edge
Chars   Pattern                 Ops/Sec     Deviation   Op/Sec      Deviation
------------------------------------------------------------------------
5,000   /[\W_]+/g                19,977.80  1.09         10,820.40  1.32
5,000   /[^a-z0-9]+/gi           19,901.60  1.49         10,902.00  1.20
5,000   /[^a-zA-Z0-9]+/g         19,559.40  1.96         10,916.80  1.13
------------------------------------------------------------------------
1,000   /[\W_]+/g                96,239.00  1.65         52,358.80  1.41
1,000   /[^a-z0-9]+/gi           97,584.40  1.18         52,105.00  1.60
1,000   /[^a-zA-Z0-9]+/g         96,965.80  1.10         51,864.60  1.76
------------------------------------------------------------------------
  200   /[\W_]+/g               480,318.60  1.70        261,030.40  1.80
  200   /[^a-z0-9]+/gi          476,177.80  2.01        261,751.60  1.96
  200   /[^a-zA-Z0-9]+/g        486,423.00  0.80        258,774.20  2.15

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

теоретическое масштабирование для 1 символа

                            Chrome                        Edge
Chars   Pattern             Ops/Sec     Scaled            Op/Sec    Scaled
------------------------------------------------------------------------
5,000   /[\W_]+/g            19,977.80  99,889,000       10,820.40  54,102,000
5,000   /[^a-z0-9]+/gi       19,901.60  99,508,000       10,902.00  54,510,000
5,000   /[^a-zA-Z0-9]+/g     19,559.40  97,797,000       10,916.80  54,584,000
------------------------------------------------------------------------

1,000   /[\W_]+/g            96,239.00  96,239,000       52,358.80  52,358,800
1,000   /[^a-z0-9]+/gi       97,584.40  97,584,400       52,105.00  52,105,000
1,000   /[^a-zA-Z0-9]+/g     96,965.80  96,965,800       51,864.60  51,864,600
------------------------------------------------------------------------

  200   /[\W_]+/g           480,318.60  96,063,720      261,030.40  52,206,080
  200   /[^a-z0-9]+/gi      476,177.80  95,235,560      261,751.60  52,350,320
  200   /[^a-zA-Z0-9]+/g    486,423.00  97,284,600      258,774.20  51,754,840

Я не сильно в эти результаты это не очень значительные различия, все, что мы можем сказать, это edge медленнее :o . Кроме того, мне было очень скучно.

в любом случае вы можете выполнить тест для себя.

jsperf Benchmark здесь

1