Substitua todos os caracteres não alfanuméricos, novas linhas e vários espaços em branco por um espaço

136

Estou procurando uma solução limpa RegEx para substituir

  • Todos os caracteres não alfanuméricos
  • Todas as novas linhas
  • Todas as várias instâncias de espaço em branco

Com um único espaço


Para quem joga em casa ( o seguinte funciona )

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

Meu pensamento é que o RegEx provavelmente é poderoso o suficiente para conseguir isso em uma declaração. Os componentes que eu acho que precisam

  • [^a-z0-9] - para remover caracteres não alfanuméricos
  • \s+ - corresponda a qualquer coleção de espaços
  • \r?\n|\r - corresponder a todas as novas linhas
  • /gmi - global, multilinhas, sem distinção entre maiúsculas e minúsculas

No entanto, não consigo estilizar a regex da maneira correta ( o seguinte não funciona )

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


Entrada

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


Saída desejada

234 Me 2 2013 1080p x264 5 1 BluRay S01 asd 05 S1E5 1x05 1x5
TheGeneral
fonte
Como exatamente sua tentativa não funciona? O que deu errado?
Pointy 01/01

Respostas:

235

Esteja ciente, isso \W deixa o sublinhado . Um equivalente curto para [^a-zA-Z0-9]seria[\W_]

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

\Wé a negação da abreviação \w de [A-Za-z0-9_]caracteres de palavras (incluindo o sublinhado)

Exemplo em regex101.com

Jonny 5
fonte
Verificá-lo e testá-lo, não tenho muita experiência em js-regex ainda: p feliz que você goste
Jonny 5
6
Observe que \Wtambém reconhecerá caracteres não latinos como caracteres que não são de palavras.
Tyblitz 23/05
1
I marcado esta resposta correta após todos estes anos, porque eu olhei para trás e os aceites não excluem sublinhados
o general
143

Jonny 5 me venceu. Eu sugeriria usar o \W+sem o \scomo em text.replace(/\W+/g, " "). Isso também abrange espaço em branco.

T-CatSan
fonte
Obrigado @ T-CatSan por apontar isso! Aumentei, e Saruman, você está livre para alterar a melhor resposta para o que quer que seja :-) Mas não deve ser \W+, [W+]bom, feliz ano novo!
Jonny
Obrigado, @ Jonny5! Fiz a alteração que você sugeriu. Eu tinha testado com os suportes antes e agora vejo que funciona sem eles. Feliz Ano Novo para você também.
T-Catsan
1
ei @ T-CatSan, existe uma maneira de adicionar exceções? Eu quero manter os personagens &e -. Alguma dica?
Renato Gama
1
Fiz a seguinte alteração / (\ W +) | (_) / g para ignorar _ também. Mas só me pergunto por que não está ignorando no primeiro modelo e é o meu regex é o mais eficiente.
Sridhar Gudimela
14

Como a [^a-z0-9]classe de caracteres contém tudo o que não é alnum, também contém caracteres em branco!

 text.replace(/[^a-z0-9]+/gi, " ");
Casimir et Hippolyte
fonte
6

Bem, acho que você só precisa adicionar um quantificador para cada padrão. Além disso, a coisa de retorno de carro é um pouco engraçada:

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

editar As \spartidas coisa \re \ntambém.

Pontudo
fonte
Sim, houve algumas tolices de Tom coletadas de outras respostas sobre o tópico, no entanto, isso funciona muito bem!
TheGeneral
2

A viu um post diferente que também tinha marcas diacríticas, o que é ótimo

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

Dmitri R117
fonte
2

Este é um antigo post meu, as respostas aceitas são boas para a maior parte. No entanto, decidi avaliar cada solução e outra óbvia (apenas por diversão). Gostaria de saber se havia uma diferença entre os padrões regex em diferentes navegadores com cadeias de tamanhos diferentes.

Então, basicamente, eu usei o jsPerf em

  • Testando no Chrome 65.0.3325 / Windows 10 0.0.0
  • Testando no Edge 16.16299.0 / Windows 10 0.0.0

Os padrões regex que testei foram

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

Eu os carreguei com um comprimento de seqüência de caracteres aleatórios

  • comprimento 5000
  • comprimento 1000
  • comprimento 200

Exemplo de javascript que eu usei var newstr = str.replace(/[\W_]+/g," ");

Cada execução consistia em 50 ou mais amostras em cada regex e eu as executava 5 vezes em cada navegador.

Vamos correr nossos cavalos!

Resultados

                                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

Verdade seja dita, o Regex nos dois navegadores (levando em consideração o desvio) era quase indistinguível, no entanto, acho que se isso acontecer ainda mais, os resultados se tornarão um pouco mais claros (mas não muito).

Escala teórica para 1 caractere

                            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

Eu não levaria muito a esses resultados, já que essas diferenças não são realmente significativas, tudo o que podemos dizer é que a vantagem é mais lenta: o. Além disso, eu estava super entediado.

De qualquer forma, você pode executar o benchmark para si mesmo.

Jsperf Benchmark aqui

TheGeneral
fonte
0

Para substituir por hífens, faça o seguinte:

text.replace(/[\W_-]/g,' ');
Gregory R.
fonte