Sostituisci tutti i caratteri non alfabetici, le nuove linee e più spazi bianchi con uno spazio


136

Sto cercando una soluzione RegEx pulita da sostituire

  • Tutti i caratteri non alfanumerici
  • Tutti i NewLines
  • Tutte le istanze multiple di spazio bianco

Con un unico spazio


Per quelli che giocano a casa ( il seguente funziona )

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

Il mio pensiero è che RegEx sia probabilmente abbastanza potente da raggiungere questo obiettivo in una frase. I componenti che ritengo necessari sono

  • [^a-z0-9] - per rimuovere caratteri non alfanumerici
  • \s+ - abbina qualsiasi raccolta di spazi
  • \r?\n|\r - abbina tutta la nuova linea
  • /gmi - globale, multilinea, senza distinzione tra maiuscole e minuscole

Tuttavia, non riesco a modellare la regex nel modo giusto ( il seguente non funziona )

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


Ingresso

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


Uscita desiderata

234 Me 2 2013 1080p x264 5 1 BluRay S01 asd 05 S1E5 1x05 1x5

Come funziona esattamente il tuo tentativo? Cosa non va?
Punta

Risposte:


235

Attenzione, questo \W lascia il carattere di sottolineatura . Un breve equivalente [^a-zA-Z0-9]sarebbe[\W_]

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

\Wè la negazione della scorciatoia \w per i [A-Za-z0-9_]caratteri di parole (incluso il trattino basso)

Esempio su regex101.com


Controllalo e provalo, non hai ancora molta esperienza in js-regex: p Felice che ti piaccia
Jonny 5

6
Si noti che \Wriconoscerà anche i caratteri non latini come caratteri non di parole.
Tyblitz,

1
Ho segnato questa risposta corretta dopo tutti questi anni, perché ho guardato indietro e le accettate, non ha escluso di sottolineatura
thegeneral

143

Jonny 5 mi ha battuto. Stavo per suggerire di usare il \W+senza il \scome in text.replace(/\W+/g, " "). Questo copre anche gli spazi bianchi.


Grazie @ T-CatSan per averlo sottolineato! Upped it, e Saruman, sei libero di cambiare la migliore risposta a qualunque cosa :-) Ma dovrebbe essere \W+, non [W+]beh, buon anno a tutti!
Jonny 5

Grazie, @ Jonny5! Ho apportato la modifica che mi hai suggerito. Prima avevo provato con le parentesi e ora vedo che funziona senza di loro. Buon anno anche a te.
T-CatSan,

1
hey @ T-CatSan c'è un modo per aggiungere eccezioni? Voglio mantenere personaggi &e -. Qualche consiglio?
Renato Gama,

1
Ho apportato la seguente modifica / (\ W +) | (_) / g per ignorare anche _. Ma mi chiedo solo perché non ignori nel primo modello ed è il mio regex è quello efficiente.
Sridhar Gudimela,

14

Poiché la [^a-z0-9]classe di caratteri contiene tutto ciò che non è alnum, contiene anche caratteri bianchi!

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

6

Bene, penso che devi solo aggiungere un quantificatore a ciascun modello. Anche la cosa di ritorno in carrozza è un po 'divertente:

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

modificare I \scosa partite \re \ntroppo.


Sì, c'era un po 'di stupidità nei confronti di Tom raccolta da altre risposte sull'argomento, tuttavia funziona alla grande grazie!
thegeneral

2

A ha visto un post diverso che aveva anche segni diacritici, il che è fantastico

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


2

Questo è un mio vecchio post, le risposte accettate sono per lo più buone. Tuttavia, ho deciso di confrontare ogni soluzione e un'altra ovvia (solo per divertimento). Mi chiedevo se ci fosse una differenza tra i pattern regex su diversi browser con stringhe di dimensioni diverse.

Quindi sostanzialmente ho usato jsPerf su

  • Test in Chrome 65.0.3325 / Windows 10 0.0.0
  • Test in Edge 16.16299.0 / Windows 10 0.0.0

I modelli regex che ho testato erano

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

Li ho caricati con una lunghezza di stringa di caratteri casuali

  • lunghezza 5000
  • lunghezza 1000
  • lunghezza 200

Esempio di javascript che ho usato var newstr = str.replace(/[\W_]+/g," ");

Ogni esecuzione consisteva in 50 o più campioni su ogni regex e li eseguo 5 volte su ciascun browser.

Facciamo correre i nostri cavalli!

risultati

                                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

A dire il vero, Regex in entrambi i browser (tenendo conto della deviazione) era quasi indistinguibile, tuttavia penso che se lo eseguisse ancora più volte i risultati diventerebbero un po 'più chiari (ma non di molto).

Ridimensionamento teorico per 1 carattere

                            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

Non prenderei molto in questi risultati in quanto questa non è davvero una differenza significativa, tutto ciò che possiamo davvero dire è che il vantaggio è più lento: o. Inoltre, ero molto annoiato.

Ad ogni modo puoi eseguire il benchmark per te stesso.

Jsperf Benchmark qui


0

Per sostituire con trattini, procedi come segue:

text.replace(/[\W_-]/g,' ');
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.