Remplacez tous les caractères non alphanumériques, les nouvelles lignes et plusieurs espaces blancs par un espace

Je recherche une solution RegEx soignée à remplacer

• Tous les caractères non alphanumériques
• Tous les NewLines
• Toutes les instances multiples d'espaces blancs

Avec un seul espace

Pour ceux qui jouent à la maison ( ce qui suit fonctionne )

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

Je pense que RegEx est probablement assez puissant pour y parvenir en une seule déclaration. Les composants dont je pense avoir besoin sont

• [^a-z0-9] - pour supprimer les caractères non alphanumériques
• \s+ - correspond à toutes les collections d'espaces
• \r?\n|\r - correspond à toute nouvelle ligne
• /gmi - global, multiligne, insensible à la casse

Cependant, je n'arrive pas à styler l'expression régulière de la bonne manière ( ce qui suit ne fonctionne pas )

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

Contribution

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

Sortie désirée

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

Attention, cela \W laisse le trait de soulignement . Un court équivalent pour [^a-zA-Z0-9]serait[\W_]

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

\West la négation du raccourci \w pour les [A-Za-z0-9_]caractères de mot (y compris le trait de soulignement)

Exemple sur regex101.com

Jonny 5 m'a battu. J'allais suggérer d'utiliser le \W+sans le \scomme dans text.replace(/\W+/g, " "). Cela couvre également les espaces blancs.

Puisque la [^a-z0-9]classe de caractères contient tout ce qui n'est pas alnum, elle contient aussi des caractères blancs!

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

Eh bien, je pense qu'il vous suffit d'ajouter un quantificateur à chaque motif. Aussi la chose du retour chariot est un peu drôle:

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

modifier La \schose correspond \ret \naussi.

A a vu un article différent qui avait également des signes diacritiques, ce qui est génial

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

C'est un ancien de mes messages, les réponses acceptées sont bonnes pour la plupart. Cependant, j'ai décidé de comparer chaque solution et une autre évidente (juste pour le plaisir). Je me suis demandé s'il y avait une différence entre les modèles de regex sur différents navigateurs avec des chaînes de tailles différentes.

Donc, fondamentalement, j'ai utilisé jsPerf sur

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

Les modèles de regex que j'ai testés étaient

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

Je les ai chargés avec une longueur de chaîne de caractères aléatoires

• longueur 5000
• longueur 1000
• longueur 200

Exemple de javascript que j'ai utilisé var newstr = str.replace(/[\W_]+/g," ");

Chaque exécution consistait en 50 échantillons ou plus sur chaque expression régulière, et je les ai exécutés 5 fois sur chaque navigateur.

Faisons courir nos chevaux!

Résultats

                                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

À vrai dire, Regex dans les deux navigateurs (en tenant compte de la déviation) était presque impossible à distinguer, mais je pense que si cela fonctionnait encore plus de fois, les résultats deviendraient un peu plus clairs (mais pas beaucoup).

Mise à l'échelle théorique pour 1 caractère

                            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

Je n'apprécierais pas trop ces résultats car ce n'est pas vraiment une différence significative, tout ce que nous pouvons vraiment dire, c'est que le bord est plus lent: o. De plus, je m'ennuyais vraiment.

Quoi qu'il en soit, vous pouvez exécuter la référence pour vous-même.

Jsperf Benchmark ici

Pour remplacer par des tirets, procédez comme suit:

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