Recherche…
Idioms pour Regex correspondant à quand expression
Utiliser des locaux immuables:
Utilise moins d'espace horizontal mais plus d'espace vertical que le modèle "anonymous temporaries". Préférable sur le modèle "anonymous temporaries" si l'expression when est dans une boucle - dans ce cas, les définitions regex doivent être placées en dehors de la boucle.
import kotlin.text.regex
var string = /* some string */
val regex1 = Regex( /* pattern */ )
val regex2 = Regex( /* pattern */ )
/* etc */
when {
regex1.matches(string) -> /* do stuff */
regex2.matches(string) -> /* do stuff */
/* etc */
}
Utiliser des temporaires anonymes:
Utilise moins d'espace vertical mais plus d'espace que le modèle "locaux immuables". Ne doit pas être utilisé si alors when expression est en boucle.
import kotlin.text.regex
var string = /* some string */
when {
Regex( /* pattern */ ).matches(string) -> /* do stuff */
Regex( /* pattern */ ).matches(string) -> /* do stuff */
/* etc */
}
En utilisant le modèle de visiteur:
A l'avantage de reproduire étroitement le "argument-ful" when syntaxe. Cela est bénéfique car il indique plus clairement l'argument de l'expression when , et exclut également certaines erreurs de programmeur qui pourraient découler de la répétition de l'argument when dans chaque whenEntry . Le modèle "immuable locals" ou "anonymous temporaries" peut être utilisé avec cette implémentation du pattern visiteur.
import kotlin.text.regex
var string = /* some string */
when (RegexWhenArgument(string)) {
Regex( /* pattern */ ) -> /* do stuff */
Regex( /* pattern */ ) -> /* do stuff */
/* etc */
}
Et la définition minimale de la classe wrapper pour l'argument expression when :
class RegexWhenArgument (val whenArgument: CharSequence) {
operator fun equals(whenEntry: Regex) = whenEntry.matches(whenArgument)
override operator fun equals(whenEntry: Any?) = (whenArgument == whenEntry)
}
Introduction aux expressions régulières dans Kotlin
Cet article montre comment utiliser la plupart des fonctions de la classe Regex , travailler avec des valeurs null liées aux fonctions Regex , et comment les chaînes brutes facilitent l'écriture et la lecture des modèles regex.
La classe RegEx
Pour travailler avec des expressions régulières dans Kotlin, vous devez utiliser la classe Regex(pattern: String) et appeler des fonctions telles que find(..) ou replace(..) sur cet objet regex.
Un exemple d'utilisation de la classe Regex qui renvoie true si la chaîne d' input contient c ou d:
val regex = Regex(pattern = "c|d")
val matched = regex.containsMatchIn(input = "abc") // matched: true
La chose essentielle à comprendre avec toutes les fonctions Regex est que le résultat est basé sur la correspondance du pattern expression régulière et de la chaîne d' input . Certaines fonctions nécessitent une correspondance complète, tandis que le reste ne nécessite qu'une correspondance partielle. La fonction containsMatchIn(..) utilisée dans l'exemple nécessite une correspondance partielle et est expliquée plus loin dans cette publication.
Sécurité nulle avec des expressions régulières
Les deux find(..) et matchEntire(..) MatchResult? un MatchResult? objet. Le ? caractère après MatchResult est nécessaire pour Kotlin pour gérer NULL en toute sécurité .
Un exemple qui montre comment Kotlin gère NULL en toute sécurité depuis une fonction Regex , lorsque la fonction find(..) renvoie null:
val matchResult =
Regex("c|d").find("efg") // matchResult: null
val a = matchResult?.value // a: null
val b = matchResult?.value.orEmpty() // b: ""
a?.toUpperCase() // Still needs question mark. => null
b.toUpperCase() // Accesses the function directly. => ""
Avec la fonction orEmpty() , b ne peut pas être nul et le ? le caractère est inutile lorsque vous appelez des fonctions sur b .
Si vous ne vous souciez pas de cette manipulation sécurisée des valeurs NULL, Kotlin vous permet de travailler avec des valeurs NULL comme en Java avec le !! personnages:
a!!.toUpperCase() // => KotlinNullPointerException
Chaînes brutes dans les modèles d'expressions rationnelles
Kotlin fournit une amélioration par rapport à Java avec une chaîne brute qui permet d'écrire des modèles de regex purs sans double barre oblique inverse, nécessaires avec une chaîne Java. Une chaîne brute est représentée avec un triple devis:
"""\d{3}-\d{3}-\d{4}""" // raw Kotlin string
"\\d{3}-\\d{3}-\\d{4}" // standard Java string
find (input: CharSequence, startIndex: Int): MatchResult?
La chaîne d' input sera comparée au pattern dans l'objet Regex . Il retourne un Matchresult? objet avec le premier texte correspondant après le startIndex , ou null si le motif ne correspond pas à la chaîne d' input . La chaîne de résultat est extraite de MatchResult? propriété value objet. Le paramètre startIndex est facultatif avec la valeur par défaut 0.
Pour extraire le premier numéro de téléphone valide d'une chaîne avec ses coordonnées:
val phoneNumber :String? = Regex(pattern = """\d{3}-\d{3}-\d{4}""")
.find(input = "phone: 123-456-7890, e..")?.value // phoneNumber: 123-456-7890
En l'absence de numéro de téléphone valide dans la chaîne d' input , la variable phoneNumber sera null .
findAll (entrée: CharSequence, startIndex: Int): séquence
Renvoie toutes les correspondances de la chaîne d' input correspondant au pattern regex.
Pour imprimer tous les nombres séparés par un espace, à partir d'un texte avec des lettres et des chiffres:
val matchedResults = Regex(pattern = """\d+""").findAll(input = "ab12cd34ef")
val result = StringBuilder()
for (matchedText in matchedResults) {
result.append(matchedText.value + " ")
}
println(result) // => 12 34
La variable matchedResults est une séquence MatchResult objets MatchResult . Avec une chaîne d' input sans chiffres, la fonction findAll(..) renvoie une séquence vide.
matchEntire (entrée: CharSequence): MatchResult?
Si tous les caractères de la chaîne d' input correspondent au pattern expression régulière, une chaîne égale à l' input sera renvoyée. Sinon, null sera retourné.
Renvoie la chaîne d'entrée si la chaîne d'entrée entière est un nombre:
val a = Regex("""\d+""").matchEntire("100")?.value // a: 100
val b = Regex("""\d+""").matchEntire("100 dollars")?.value // b: null
correspond à (input: CharSequence): booléen
Renvoie true si la chaîne d'entrée complète correspond au modèle de regex. Faux sinon.
Teste si deux chaînes ne contiennent que des chiffres:
val regex = Regex(pattern = """\d+""")
regex.matches(input = "50") // => true
regex.matches(input = "50 dollars") // => false
containsMatchIn (input: CharSequence): Booléen
Renvoie true si une partie de la chaîne d'entrée correspond au modèle de regex. Faux sinon.
Testez si deux chaînes contiennent au moins un chiffre:
Regex("""\d+""").containsMatchIn("50 dollars") // => true
Regex("""\d+""").containsMatchIn("Fifty dollars") // => false
split (input: CharSequence, limite: Int): Liste
Renvoie une nouvelle liste sans toutes les correspondances regex.
Pour retourner des listes sans chiffres:
val a = Regex("""\d+""").split("ab12cd34ef") // a: [ab, cd, ef]
val b = Regex("""\d+""").split("This is a test") // b: [This is a test]
Il y a un élément dans la liste pour chaque division. La première chaîne d' input comporte trois chiffres. Cela se traduit par une liste de trois éléments.
replace (input: CharSequence, replacement: String): String
Remplace toutes les correspondances du pattern regex dans la chaîne d' input par la chaîne de remplacement.
Pour remplacer tous les chiffres d'une chaîne par un x:
val result = Regex("""\d+""").replace("ab12cd34ef", "x") // result: abxcdxef