Discussion :

[favdb]

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 <p> et </p>, puis des pseudo tag entre crochet. Voici un exemple:

Code html :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
<p>
[tag]un texte quelconque, contenant éventuellement des balises HTML[/tag]
</p>

Je voudrais pouvoir supprimer ce type de chaîne de caractères (y compris les balises <p> et </p> qui sont associées) en conservant le reste.

J'ai essayé ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
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>";
 
String regex="<p>.*\\[tag\\].*\\[/tag\\].*</p>";
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.

[andry.aime]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

A+.

[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 <p>, 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 </p>. Autrement dit: "<p>" + ".*" + "[tag]" + ".*" + "[/tag]" + ".*" + "</p>".

[andry.aime]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

A+.

[andry.aime]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[favdb]

Merci, j'ai essayé et ça ne marche pas.

[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.

[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.

[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 : <p>\\s*\\[tag\\].*\\[/tag\\]\\s*</p>.

[Pill_S]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
@Test 
public void please_make_it_work() {
    String input = "Salut <p>pouet <tag> pouetpouet</tag> pouetpouetpouet</p> ça va";
    String regexp = "<p>\\s*\\[tag\\].*\\[/tag\\]\\s*</p>"; // 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...

[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 "<p>" 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.

[favdb]

Voici donc la procédure de test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 = "<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);
	}
}

Erreur de compilation : néant

Les résultats:

résultats
andry.aime 1 : (\\<.*?\\>)|(\\[.*?\\])
<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>
andry.aime 2 : (\\<p\\>\\s*\\[tag\\]).*(\\[\\/tag\\])\\s*(\\<\\/p\\>)
<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>
joel.drigo : <p>\\s*\\[tag\\].*\\[/tag\\]\\s*</p>
<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>
procédure de substitution removeTag
<p>Début à garder</p><p>Le reste à garder aussi</p>

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.

[joel.drigo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

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\>)
<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>

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 <p> et [tag] (ou) [/tag] et </p>, 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
	}

[favdb]

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

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 "<p>" ou "</p> dans le future usage.

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