Comment supprimer un préfixe de chaînes dans Groovy

1. Introduction

Dans ce tutoriel rapide, nous allons apprendre à supprimer le préfixe d'une chaîne dans Groovy.

Tout d'abord, nous examinerons ce que la classe String offre à cet effet. Après cela, nous passerons aux expressions régulières et verrons comment nous pouvons les utiliser pour supprimer un préfixe.

2. Utilisation des méthodes de chaîne

Généralement, Groovy est considéré comme un langage dynamique pour l'écosystème Java. Par conséquent, nous pouvons toujours utiliser toutes les méthodes de classe Java String avec les nouvelles Groovy. Cependant, pour la suppression du préfixe, il n'y a toujours pas de méthode simple comme removePrefix () .

La suppression d'un préfixe des chaînes Groovy se compose de deux étapes: première confirmation, puis suppression . Ces deux étapes peuvent être effectuées à l'aide de la classe StringGroovyMethods qui offre de nombreuses méthodes utilitaires pour les manipulations de chaînes.

2.1. startsWith (), méthode

La méthode startWith () teste si une chaîne commence par un préfixe spécifique. Il renvoie true si le préfixe existe et false dans le cas contraire.

Commençons par une fermeture groovy:

@Test public void whenCasePrefixIsRemoved_thenReturnTrue(){ def trimPrefix = { it.startsWith('Groovy-') ? it.minus('Groovy-') : it } def actual = trimPrefix("Groovy-Tutorials at Baeldung") def expected = "Tutorials at Baeldung" assertEquals(expected, actual) } 

Une fois l'existence confirmée, nous pouvons également utiliser la méthode substring () pour la supprimer:

trimPrefix.substring('Groovy-'.length()) 

2.2. startsWithIgnoreCase (), méthode

La méthode startsWith () est sensible à la casse . Ainsi, un effort manuel est nécessaire pour annuler l'effet du cas en appliquant les méthodes toLowerCase () ou toUpperCase () .

Comme son nom l'indique, la fonction startsWithIgnoreCase () recherche un préfixe sans tenir compte de la casse. Il renvoie true si un préfixe existe et false dans le cas contraire.

Voyons comment utiliser cette méthode:

@Test public void whenPrefixIsRemovedWithIgnoreCase_thenReturnTrue() { String prefix = "groovy-" String trimPrefix = "Groovy-Tutorials at Baeldung" def actual if(trimPrefix.startsWithIgnoreCase(prefix)) { actual = trimPrefix.substring(prefix.length()) } def expected = "Tutorials at Baeldung" assertEquals(expected, actual) } 

2.3. startsWithAny (), méthode

Les solutions ci-dessus sont utiles lorsque nous ne devons vérifier qu'un seul préfixe. Lorsqu'il s'agit de vérifier plusieurs préfixes, Groovy fournit également un support pour vérifier plusieurs préfixes.

La méthode startsWithAny () vérifie si la CharSequence commence par les préfixes spécifiés. Une fois le préfixe confirmé, nous pouvons appliquer la logique selon les exigences:

String trimPrefix = "Groovy-Tutorials at Baeldung" if (trimPrefix.startsWithAny("Java", "Groovy", "Linux")) { // logic to remove prefix } 

3. Utilisation de Regex

Une expression régulière est un moyen puissant de faire correspondre ou de remplacer un modèle. Groovy a un opérateur de modèle ~ qui fournit un moyen simple de créer une instance java.util.regex.Pattern .

Définissons une expression régulière simple pour supprimer un préfixe:

@Test public void whenPrefixIsRemovedUsingRegex_thenReturnTrue() { def regex = ~"^groovy-" String trimPrefix = "groovy-Tutorials at Baeldung" String actual = trimPrefix - regex def expected = "Tutorials at Baeldung" assertEquals("Tutorials at Baeldung", actual) } 

La version insensible à la casse de l'expression régulière ci-dessus:

def regex = ~"^([Gg])roovy-" 

L'opérateur caret ^ s'assurera que la sous-chaîne spécifiée existe au début.

3.1. replaceFirst (), méthode

En utilisant des expressions régulières avec des méthodes de chaînes natives, nous pouvons effectuer des astuces très puissantes. La méthode replaceFirst () est l'une de ces méthodes. Il remplace la première occurrence qui correspond à l'expression régulière donnée.

Supprimons un préfixe en utilisant la méthode replaceFirst () :

@Test public void whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue() { def regex = ~"^groovy" String trimPrefix = "groovyTutorials at Baeldung's groovy page" String actual = trimPrefix.replaceFirst(regex, "") def expected = "Tutorials at Baeldung's groovy page" assertEquals(expected, actual) } 

3.2. replaceAll (), méthode

Tout comme replaceFirst () , replaceAll () accepte également une expression régulière et un remplacement donné. Il remplace chaque sous-chaîne qui correspond aux critères donnés . Pour supprimer un préfixe, nous pouvons également utiliser cette méthode.

Utilisons replaceAll () pour remplacer une sous-chaîne au début de la chaîne uniquement:

@Test public void whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue() { String trimPrefix = "groovyTutorials at Baeldung groovy" String actual = trimPrefix.replaceAll(/^groovy/, "") def expected = "Tutorials at Baeldung groovy" assertEquals(expected, actual) } 

4. Conclusion

Dans ce didacticiel rapide, nous avons exploré plusieurs façons de supprimer les préfixes d'une chaîne. Pour confirmer l'existence d'un préfixe, nous avons vu comment faire cela pour les chaînes majuscules et minuscules.

En même temps, nous avons vu comment détecter un préfixe parmi de nombreuses sous-chaînes fournies. Nous avons également examiné plusieurs méthodes pouvant être utilisées pour supprimer une sous-chaîne. Enfin, nous avons brièvement discuté du rôle des regex à cette fin.

Comme toujours, tous les exemples de code peuvent être trouvés sur GitHub.