Ersetzen Sie alle nicht alphanumerischen Zeichen, neuen Linien und mehrere Leerzeichen durch ein Leerzeichen

Ich suche nach einer netten RegEx- Lösung, die ich ersetzen kann

• Alle nicht alphanumerischen Zeichen
• Alle NewLines
• Alle mehrfachen Instanzen von Leerzeichen

Mit einem einzigen Leerzeichen

Für diejenigen, die zu Hause spielen ( das Folgende funktioniert )

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

Meiner Meinung nach ist RegEx wahrscheinlich stark genug, um dies in einer Aussage zu erreichen. Die Komponenten, von denen ich denke, dass sie benötigt werden, sind

• [^a-z0-9] - um nicht alphanumerische Zeichen zu entfernen
• \s+ - mit allen Sammlungen von Räumen übereinstimmen
• \r?\n|\r - Alle neuen Zeilen abgleichen
• /gmi - global, mehrzeilig, ohne Berücksichtigung der Groß- und Kleinschreibung

Allerdings kann ich den Regex nicht richtig stylen ( das Folgende funktioniert nicht )

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

Eingang

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

Gewünschte Ausgabe

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

Seien Sie sich bewusst, dass \W der Unterstrich bleibt . Ein kurzes Äquivalent für [^a-zA-Z0-9]wäre[\W_]

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

\Wist die Negation der Abkürzung \w für [A-Za-z0-9_]Wortzeichen (einschließlich des Unterstrichs)

Beispiel bei regex101.com

Jonny 5 hat mich geschlagen. Ich würde vorschlagen, das \W+ohne das \swie in zu verwenden text.replace(/\W+/g, " "). Dies gilt auch für Leerzeichen.

Da [^a-z0-9]die Zeichenklasse alles enthält, was nicht Alnum ist, enthält sie auch weiße Zeichen!

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

Nun, ich denke, Sie müssen jedem Muster nur einen Quantifizierer hinzufügen. Auch die Wagenrücklaufsache ist ein bisschen lustig:

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

bearbeiten Das \sDing passt \rund \nauch.

A sah einen anderen Beitrag, der auch diakritische Zeichen hatte, was großartig ist

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

Dies ist ein alter Beitrag von mir, die akzeptierten Antworten sind größtenteils gut. Ich entschied mich jedoch, jede Lösung und eine andere offensichtliche zu vergleichen (nur zum Spaß). Ich fragte mich, ob es einen Unterschied zwischen den Regex-Mustern in verschiedenen Browsern mit unterschiedlich großen Zeichenfolgen gab.

Also im Grunde verwendet i jsPerf auf

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

Die Regex-Muster, die ich getestet habe, waren

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

Ich habe sie mit einer Stringlänge von zufälligen Zeichen geladen

• Länge 5000
• Länge 1000
• Länge 200

Beispiel Javascript, das ich verwendet habe var newstr = str.replace(/[\W_]+/g," ");

Jeder Lauf bestand aus 50 oder mehr Beispielen auf jeder Regex, und ich habe sie 5 Mal in jedem Browser ausgeführt.

Lass uns unsere Pferde rennen!

Ergebnisse

                                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

Um ehrlich zu sein, Regex in beiden Browsern (unter Berücksichtigung der Abweichung) war fast nicht zu unterscheiden, aber ich denke, wenn es noch öfter ausgeführt wird, werden die Ergebnisse etwas klarer (aber nicht viel).

Theoretische Skalierung für 1 Zeichen

                            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

Ich würde nicht zu viel auf diese Ergebnisse eingehen, da dies keine signifikanten Unterschiede sind. Wir können nur sagen, dass die Kante langsamer ist: o. Außerdem war ich super gelangweilt.

Auf jeden Fall können Sie den Benchmark für sich selbst durchführen.

Jsperf Benchmark hier

Gehen Sie wie folgt vor, um durch Bindestriche zu ersetzen:

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