Un String replace un peu compliqué

Version imprimable

Bonjour,

Je butte sur une difficulté concernant le String.replaceAll. J'ai une chaîne de caractères contenant un texte dans lequel il y a des balise HTML et , puis des pseudo tag entre crochet. Voici un exemple:
Code:

1 2 3 [tag]un texte quelconque, contenant éventuellement des balises HTML[/tag] 
Je voudrais pouvoir supprimer ce type de chaîne de caractères (y compris les balises et qui sont associées) en conservant le reste.

J'ai essayé ceci:
Code:

1 2 3 4 5 6 String notes="Début à garder\n[tag]un texte quelconque, contenant éventuellement des balises HTML[/tag]\nLe reste à garder aussi"; String regex=".*\\[tag\\].*\\[/tag\\].*"; String s = notes.replaceAll(regex,""); System.out.println("Actual notes=\n{"+notes+"}\nreplacing by\n{"+s+"}");
Mais ça ne marche pas, quelqu'un pourrait-il m'aider? Merci d'avance.

14/12/2017, 08h30
andry.aime

Bonjour,

Code:

String regex="(\\<.*?\\>)|(\\[.*?\\])";

A+.
14/12/2017, 10h24
favdb

Si je comprends bien cette formule ça va enlever toutes les balises HTML et toutes mes pseudo-balises entre crochets. C'est n'est pas du tout ce que je recherche. Seulement de supprimer une succession précise des ces balises et pseudo-balises, à savoir une balise , suivi d'une nombre quelconque de caractères, suivi d'une pseudo-balise [tag], suivi d'un nombre quelconque de caractères, suivi de la pseudo-balise [/tag], suivi d'un nombre quelconque de caractères, suivi de la balise . Autrement dit: "" + ".*" + "[tag]" + ".*" + "[/tag]" + ".*" + "".
14/12/2017, 10h41
andry.aime

Tu veux dire supprimer la séquence [tag]*[/tag]?

Code:

String regex="(\\<p\\>\\s*\\[tag\\]).*(\\[\\/tag\\])\\s*(\\<\\/p\\>)";

A+.
14/12/2017, 11h31
andry.aime

Désolé, tu voulais supprimer les *[tag]*[/tag]*

Code:

String regex="\\<p\\>.*\\[tag\\].*\\[\\/tag\\].*\\<\\/p\\>";
14/12/2017, 16h56
favdb

Merci, j'ai essayé et ça ne marche pas.
14/12/2017, 17h56
thelvin

Hello,

tu devrais être encore plus explicite, il y a des gens qui risquent de te comprendre si tu continues.

C'est à dire, il n'a pas poussé des jambes à ton ordinateur, et il n'est pas en train de marcher vers la sortie, c'est ça ? C'est ce que tu voulais obtenir ? Ni Java, ni les regex ne sont un bon moyen de faire de la robotique.
14/12/2017, 18h17
favdb

Dans ce cas de figure "marcher" est synonyme de "fonctionner". C'est tout à fait français et ça ne prête même pas à confusion. C'est un troll tellement éculé qu'il n'est même plus humoristique. On aurait pu dire bien d'autres choses en somme, comme le dirait Cyrano.

Pour en revenir à mon problème, je suspends provisoirement mes recherches sur le String.replace avec une expression régulière. J'ai programmé une fonction équivalente à base de String.indexOf et String.lastIndexOf. Ça se traduire par 10 lignes de code et c'est vrai que j'aurais préféré n'en avoir qu'une seule. Donc si quelqu'un a une solution je suis preneur.
14/12/2017, 18h34
joel.drigo

Salut,

Ce serait beaucoup plus simple avec un parser html (exemple : JSoup).

Sinon, ce que voulait (je suppose) dire @Thelvin, c'est que "ça marche pas" ça ne nous dit pas grand chose et qu'il est préférable que tu nous dises ce qu'il se passe ou ce qu'il ne se passe pas, si ça génère une exception, ou si ça ne compile pas (et, donc, l’intitulé précis de l'erreur), ou quelles différences y a t-il entre le résultat que tu obtiens et celui que tu voudrais obtenir. Des informations qui nous permettent de te répondre sans avoir à se perdre en conjectures, ou à tenter de tester nous même ce qui est plutôt difficile vu qu'on n'a pas les données exactes avec lesquelles tu as testé !

Comme solution avec expression régulières, éventuellement, s'il n'y a que des whitespaces (que \n par exemple) entre balise (ouvrante/fermante) p et tag, tu peux utiliser ça : \\s*\\[tag\\].*\\[/tag\\]\\s*.

Citation:

Envoyé par favdb

Dans ce cas de figure "marcher" est synonyme de "fonctionner". C'est tout à fait français et ça ne prête même pas à confusion. C'est un troll tellement éculé qu'il n'est même plus humoristique. On aurait pu dire bien d'autres choses en somme, comme le dirait Cyrano.

Cool, et donner plus d'infos ça aurait pas été plus efficace que te lancer dans une tirade justifiant le bon usage du verbe "marcher"?

Si t'as pas envie d'expliquer en français ce qu'il se passe tu nous donne un test junit qui fail et nous on te le fait marcher... c'est pas plus compliqué:
Code:

1 2 3 4 5 6 7 8 @Test public void please_make_it_work() { String input = "Salut pouet <tag> pouetpouet</tag> pouetpouetpouet ça va"; String regexp = "\\s*\\[tag\\].*\\[/tag\\]\\s*"; // merci de corriger ça pour que ça marche et m'expliquer pourquoi ça marche Assert.assertTrue(input.replace(regexp, "cacahuete").equals("Salut cacachuete ça va")); }
Mais ne pas donner d'infos et se plaindre est également tellement réchauffé que c'est même plus drôle non plus...

15/12/2017, 18h41
favdb

"ça ne marche pas" veut dire tout simplement que ça ne marche pas. Pas d'exception, pas d'erreur de compilation, c'est comme si la chaîne recherchée ne correspond pas au pattern défini.

@ Phill_S

Je n'avais pas imaginé utiliser le "\s*" dans la mesure ou entre le "" et le [tag] il peut y avoir des caractères autres que l'espace.

Je vais me refaire un exemple de test que je copierai/collerai ici pour na pas avoir de doute.

Voici donc la procédure de test:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 package testreplace; public class TestReplace { public static void main(String[] args) { String notes = "Début à garder\\n[tag]un texte " + "quelconque, contenant éventuellement des balises HTML[/tag]\\n" + "Le reste à garder aussi"; System.out.println("résultats andry.aime"); String regex; regex = "(\\\\<.*?\\\\>)|(\\\\[.*?\\\\])"; System.out.println("résultats"); System.out.println("andry.aime 1 : " + regex); System.out.println(notes.replaceAll(regex, "")); regex = "(\\\\<p\\\\>\\\\s*\\\\[tag\\\\]).*(\\\\[\\\\/tag\\\\])\\\\s*(\\\\<\\\\/p\\\\>)"; System.out.println("andry.aime 2 : " + regex); System.out.println(notes.replaceAll(regex, "")); regex = "\\\\s*\\\\[tag\\\\].*\\\\[/tag\\\\]\\\\s*"; System.out.println("joel.drigo : " + regex); System.out.println(notes.replaceAll(regex, "")); regex = "\\\\s*\\\\[tag\\\\].*\\\\[/tag\\\\]\\\\s*"; System.out.println(removeTag(notes, "tag")); } public static String removeTag(String notes, String tag) { System.out.println("procédure de substitution removeTag"); if (notes.length() == 0) { return (""); } int dtag = notes.indexOf("[" + tag + "]"); if (dtag == -1) { return (notes); } dtag = notes.lastIndexOf("", dtag); int ftag = notes.indexOf("[/" + tag + "]"); if (ftag != -1) { ftag = notes.indexOf("", ftag) + "".length(); } else { ftag = notes.length() - 1; } String z = notes.substring(dtag, ftag); String s = notes.replace(z, ""); return (s); } }
Erreur de compilation : néant

Les résultats:

Citation:

résultats
andry.aime 1 : (\\<.*?\\>)|(\\[.*?\\])
Début à garder\n[tag]un texte quelconque, contenant éventuellement des balises HTML[/tag]\nLe reste à garder aussi
andry.aime 2 : (\\<p\\>\\s*\\[tag\\]).*(\\[\\/tag\\])\\s*(\\<\\/p\\>)
Début à garder\n[tag]un texte quelconque, contenant éventuellement des balises HTML[/tag]\nLe reste à garder aussi
joel.drigo : \\s*\\[tag\\].*\\[/tag\\]\\s*
Début à garder\n[tag]un texte quelconque, contenant éventuellement des balises HTML[/tag]\nLe reste à garder aussi
procédure de substitution removeTag
Début à garderLe reste à garder aussi

Exception à l'exécution : néant.

À noter que la procédure de substitution n'effectue le travail que sur la première occurrence de ce qui est recherché. Pour obtenir la même chose que le replaceAll il faut donc réitérer la procédure jusqu'à ce que replace soit égal au résultat.

Oui, m'enfin, le bon code c'est plutôt :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package testmem; 
 
public class TestReplace {
 
	public static void main(String[] args) {
		String notes = "<p>Début à garder</p><p>\n[tag]un texte "
			+ "quelconque, contenant éventuellement des balises HTML[/tag]\n</p>"
			+ "<p>Le reste à garder aussi</p>";
		System.out.println("résultats andry.aime");
		String regex;
		regex = "(\\<.*?\\>)|(\\[.*?\\])";
		System.out.println("résultats");
		System.out.println("andry.aime 1 : " + regex);
		System.out.println(notes.replaceAll(regex, ""));
		regex = "(\\<p\\>\\s*\\[tag\\]).*(\\[\\/tag\\])\\s*(\\<\\/p\\>)";
		System.out.println("andry.aime 2 : " + regex);
		System.out.println(notes.replaceAll(regex, ""));
		regex = "<p>\\s*\\[tag\\].*\\[/tag\\]\\s*</p>";
		System.out.println("joel.drigo : " + regex);
		System.out.println(notes.replaceAll(regex, ""));
		regex = "<p>\\s*\\[tag\\].*\\[/tag\\]\\s*</p>";
		System.out.println(removeTag(notes, "tag"));
	}
 
	public static String removeTag(String notes, String tag) {
		System.out.println("procédure de substitution removeTag");
		if (notes.length() == 0) {
			return ("");
		}
		int dtag = notes.indexOf("[" + tag + "]");
		if (dtag == -1) {
			return (notes);
		}
		dtag = notes.lastIndexOf("<p>", dtag);
		int ftag = notes.indexOf("[/" + tag + "]");
		if (ftag != -1) {
			ftag = notes.indexOf("</p>", ftag) + "</p>".length();
		} else {
			ftag = notes.length() - 1;
		}
		String z = notes.substring(dtag, ftag);
		String s = notes.replace(z, "");
		return (s);
	}
}

avec pour résultat :

Citation:

résultats andry.aime
résultats
andry.aime 1 : (\<.*?\>)|(\[.*?\])
Début à garder
un texte quelconque, contenant éventuellement des balises HTML
Le reste à garder aussi
andry.aime 2 : (\<p\>\s*\[tag\]).*(\[\/tag\])\s*(\<\/p\>)
Début à garderLe reste à garder aussi
joel.drigo : \s*\[tag\].*\[/tag\]\s*
Début à garderLe reste à garder aussi
procédure de substitution removeTag
Début à garderLe reste à garder aussi

Et les trois derniers résultats sont bons à priori.

Et si on inclus bien des tags html entre [tag] :

Code:

1
2
3
String notes = "<p>Début à garder</p><p>\n[tag]un texte "
			+ "quelconque, contenant éventuellement des balises HTML comme <span>par exemple</span>...[/tag]\n</p>"
			+ "<p>Le reste à garder aussi</p>";

On a toujours un résultat correct :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
résultats andry.aime
résultats
andry.aime 1 : (\<.*?\>)|(\[.*?\])
Début à garder
un texte quelconque, contenant éventuellement des balises HTML comme par exemple...
Le reste à garder aussi
andry.aime 2 : (\<p\>\s*\[tag\]).*(\[\/tag\])\s*(\<\/p\>)
<p>Début à garder</p><p>Le reste à garder aussi</p>
joel.drigo : <p>\s*\[tag\].*\[/tag\]\s*</p>
<p>Début à garder</p><p>Le reste à garder aussi</p>
procédure de substitution removeTag
<p>Début à garder</p><p>Le reste à garder aussi</p>

Seulement tu parlais dans ton dernier message de pouvoir avoir autre chose qu'un \n entre et [tag] (ou) [/tag] et , et là, effectivement, les expressions régulières proposées ne fonctionnent plus, forcément.
En plus, d'après le code de ta méthode removeTag, il semble que tu veuilles en plus configurer le nom du tag entre crochets.

Remarque qu'on pourrait procéder par 2 expressions aussi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
	public static String removeTag(String notes, String tag) {
		Matcher pmatcher = Pattern.compile("(?s)<p>.*?</p>").matcher(notes);
		Pattern tagpattern = Pattern.compile("(?s).*?\\["+Pattern.quote(tag)+"\\].*?\\[/"+Pattern.quote(tag)+"\\].*?");
		StringBuffer stringBuffer = new StringBuffer();
		while( pmatcher.find() ) {
			String p = pmatcher.group();
			if ( tagpattern.matcher(p).matches() ) {
				p="";
			}
			pmatcher.appendReplacement(stringBuffer, p);
		}
		pmatcher.appendTail(stringBuffer);
		return stringBuffer.toString();
	}

Et avec JSoup qui traite vraiment du html :

Code:

1
2
3
4
5
6
7
8
9
10
public static String removeJSoup(String notes, String tag) {
		Pattern tagpattern = Pattern.compile("(?s).*?\\["+Pattern.quote(tag)+"\\].*?\\[/"+Pattern.quote(tag)+"\\].*?");
		Document doc = Jsoup.parse(notes); 
		Predicate<Element> filter = e-> {
			return tagpattern.matcher(e.text()).matches();
		};
		doc.select("p").stream().filter(filter).forEach(e-> e.remove());
		doc.outputSettings().indentAmount(0).prettyPrint(false); // pour remettre à plat éventuellement
		return doc.select("body").html();
	}

16/12/2017, 17h19
favdb

Donc au final un poil plus complexe que je ne le croyais initialement. Je vais quand même retenir la solution:

Citation:

andry.aime 2 :
(\\<p\\>\\s*\\[tag\\]).*(\\[\\/tag\\])\\s*(\\<\\/p\\>)

Dans ce cas les "\s* peuvent-ils être remplacés par ".*"? En effet, il n'est obligatoire qu'un espace suive les balises "" ou " dans le future usage.

Et au passage je confirme que pour mon utilisation le pseudo-tag est à paramétrer.