Как вы делаете регулярные выражения (recex) более эффективными и повторно используемыми? ⇐ Android

[Anonymous]

Используя Kotlin , JetPack Compose и Android Studio Я пытаюсь разработать функцию для приложения, которое использует регулярное выражение или широко известное как REGEX .
, в котором есть вопрос, является стимулированием, который разделяет строку на серию строк. Функция предназначена для приложения контактов. Строка, которая будет проанализирована, представляет собой строку, которая представляет полное имя. Полное имя будет разделено на от одного до пяти меньших строк в зависимости от размера имени. Меньшие строки представляют собой префикс имени, имя, второе имя, фамилию и суффикс имени. Существует тринадцать возможных шаблонов, которые могут быть сопоставлены. Каждый со своей отдельной переменной, которая имеет их значение. < /P>
Вот код для пользовательского интерфейса. < /P>

Код: Выделить всё

// Text Field Values
var name by remember { mutableStateOf("") }
var namePrefix by remember { mutableStateOf("") }
var firstName by remember { mutableStateOf("") }
var middleName by remember { mutableStateOf("") }
var lastName by remember { mutableStateOf("") }
var nameSuffix by remember { mutableStateOf("") }

// Layout
Column(
modifier = Modifier.fillMaxSize(),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {

// Text Fields
TextField(value = name, onValueChange = { name = it }, label = { Text("Name") })
TextField(value = namePrefix, onValueChange = { namePrefix = it }, label = { Text("Name Prefix") })
TextField(value = firstName, onValueChange = { firstName = it }, label = { Text("First Name") })
TextField(value = middleName, onValueChange = { middleName = it }, label = { Text("Middle Name") })
TextField(value = lastName, onValueChange = { lastName = it }, label = { Text("Last Name") })
TextField(value = nameSuffix, onValueChange = { nameSuffix = it }, label = { Text("Name Suffix") })
}
< /code>
Вот код для шаблонов и совпадений. Они разделены на четыре группы. 1. С префиксом без суффикса, 2. Без префикса и суффикса, 3. С префиксом и суффиксом, 4. Без префикса с суффиксом.  < /P>
val namePrefixList = listOf("mr", "ms", "mrs", "dr")
val nameSuffixList = listOf("jr", "sr", "ii", "iii")

// PATTERNS -------------------------------------------------------------------------
val prefixPattern = "\\s*(?i)${namePrefixList.joinToString("\\s*|")}\\s*".toRegex()
val suffixPattern = "\\s*(?i)${nameSuffixList.joinToString("\\s*|")}\\s*".toRegex()
val namePattern = "\\s*\\w+|\\d+\\s*".toRegex()

// With Prefix Without Suffix
val lastNameWithPrefixWithoutSuffixPattern = "($prefixPattern) ($namePattern)\\s*".toRegex()
val firstAndLastNameWithPrefixWithoutSuffixPattern = "($prefixPattern) ($namePattern) ($namePattern)\\s*".toRegex()
val firstMiddleAndLastNameWithPrefixWithoutSuffixPattern = "($prefixPattern) ($namePattern) ($namePattern) ($namePattern)\\s*".toRegex()

// Without Prefix And Suffix
val firstNameWithoutPrefixAndSuffixPattern = "($namePattern)\\s*".toRegex()
val firstAndLastNameWithoutPrefixAndSuffixPattern = "($namePattern) ($namePattern)\\s*".toRegex()
val firstMiddleAndLastNameWithoutPrefixAndSuffixPattern = "($namePattern) ($namePattern) ($namePattern)\\s*".toRegex()

// With Prefix and Suffix
val lastNameWithPrefixAndSuffixPattern = "($prefixPattern) ($namePattern) ($suffixPattern)\\s*".toRegex()
val firstAndLastNameWithPrefixAndSuffixPattern = "($prefixPattern) ($namePattern) ($namePattern) ($suffixPattern)\\s*".toRegex()
val firstMiddleAndLastNameWithPrefixAndSuffixPattern = "($prefixPattern) ($namePattern) ($namePattern) ($namePattern) ($suffixPattern)\\s*".toRegex()

// Without Prefix With Suffix
val firstNameWithoutPrefixWithSuffixPattern = "($namePattern) ($suffixPattern)\\s*".toRegex()
val firstAndLastNameWithoutPrefixWithSuffixPattern = "($namePattern) ($namePattern) ($suffixPattern)\\s*".toRegex()
val firstMiddleAndLastNameWithoutPrefixWithSuffixPattern = "($namePattern) ($namePattern) ($namePattern) ($suffixPattern)\\s*".toRegex()
// -------------------------------------------------------------------------------------

// MATCHES -----------------------------------------------------------------------------
// With Prefix Without Suffix
val lastNameWithPrefixWithoutSuffixMatch = lastNameWithPrefixWithoutSuffixPattern.matchEntire(name)
val firstAndLastNameWithPrefixWithoutSuffixMatch = firstAndLastNameWithPrefixWithoutSuffixPattern.matchEntire(name)
val firstMiddleAndLastNameWithPrefixWithoutMatch = firstMiddleAndLastNameWithPrefixWithoutSuffixPattern.matchEntire(name)

// Without Prefix And Suffix
val firstNameWithoutPrefixAndSuffixMatch = firstNameWithoutPrefixAndSuffixPattern.matchEntire(name)
val firstAndLastNamePatternWithoutPrefixAndSuffixMatch = firstAndLastNameWithoutPrefixAndSuffixPattern.matchEntire(name)
val firstMiddleAndLastNameWithoutPrefixAndSuffixMatch = firstMiddleAndLastNameWithoutPrefixAndSuffixPattern.matchEntire(name)

// With Prefix And Suffix
val lastNameWithPrefixAndSuffixMatch = lastNameWithPrefixAndSuffixPattern.matchEntire(name)
val firstAndLastNameWithPrefixAndSuffixMatch = firstAndLastNameWithPrefixAndSuffixPattern.matchEntire(name)
val firstMiddleAndLastNameWithPrefixAndSuffixMatch = firstMiddleAndLastNameWithPrefixAndSuffixPattern.matchEntire(name)

// Without Prefix With Suffix
val firstNameWithoutPrefixWithSuffixMatch = firstNameWithoutPrefixWithSuffixPattern.matchEntire(name)
val firstAndLastNameWithoutPrefixWithSuffixMatch = firstAndLastNameWithoutPrefixWithSuffixPattern.matchEntire(name)
val firstMiddleAndLastNameWithoutPrefixWithSuffixMatch = firstMiddleAndLastNameWithoutPrefixWithSuffixPattern.matchEntire(name)
< /code>
Вот код для условного определения текущего шаблона. Он разделен на две группы. 1. С суффиксом, 2.  Без суффикса < /p>
if (name.matches(prefixPattern)) {
namePrefix = name.trim()
firstName = ""
middleName = ""
lastName = ""
nameSuffix = ""
currentPattern = "Prefix"

// WITH SUFFIX -------------------------------------------------------------------------
} else if (name.matches(lastNameWithPrefixAndSuffixPattern) && lastNameWithPrefixAndSuffixMatch != null) {
namePrefix = lastNameWithPrefixAndSuffixMatch.groups[1]!!.value.trim()
firstName = ""
middleName = ""
lastName = lastNameWithPrefixAndSuffixMatch.groups[2]!!.value.trim()
nameSuffix = lastNameWithPrefixAndSuffixMatch.groups[3]!!.value.trim()

} else if (name.matches(firstAndLastNameWithPrefixAndSuffixPattern) && firstAndLastNameWithPrefixAndSuffixMatch != null) {
namePrefix = firstAndLastNameWithPrefixAndSuffixMatch.groups[1]!!.value.trim()
firstName = firstAndLastNameWithPrefixAndSuffixMatch.groups[2]!!.value.trim()
middleName = ""
lastName = firstAndLastNameWithPrefixAndSuffixMatch.groups[3]!!.value.trim()
nameSuffix = firstAndLastNameWithPrefixAndSuffixMatch.groups[4]!!.value.trim()

} else if (name.matches(firstMiddleAndLastNameWithPrefixAndSuffixPattern) && firstMiddleAndLastNameWithPrefixAndSuffixMatch != null) {
namePrefix = firstMiddleAndLastNameWithPrefixAndSuffixMatch.groups[1]!!.value.trim()
firstName = firstMiddleAndLastNameWithPrefixAndSuffixMatch.groups[2]!!.value.trim()
middleName = firstMiddleAndLastNameWithPrefixAndSuffixMatch.groups[3]!!.value.trim()
lastName = firstMiddleAndLastNameWithPrefixAndSuffixMatch.groups[4]!!.value.trim()
nameSuffix =
firstMiddleAndLastNameWithPrefixAndSuffixMatch.groups[5]!!.value.trim()

} else if (name.matches(firstNameWithoutPrefixWithSuffixPattern) && firstNameWithoutPrefixWithSuffixMatch != null) {
namePrefix = ""
firstName = firstNameWithoutPrefixWithSuffixMatch.groups[1]!!.value.trim()
middleName = ""
lastName = ""
nameSuffix = firstNameWithoutPrefixWithSuffixMatch.groups[2]!!.value.trim()

} else if (name.matches(firstAndLastNameWithoutPrefixWithSuffixPattern) && firstAndLastNameWithoutPrefixWithSuffixMatch != null) {
namePrefix = ""
firstName = firstAndLastNameWithoutPrefixWithSuffixMatch.groups[1]!!.value.trim()
middleName = ""
lastName = firstAndLastNameWithoutPrefixWithSuffixMatch.groups[2]!!.value.trim()
nameSuffix = firstAndLastNameWithoutPrefixWithSuffixMatch.groups[3]!!.value.trim()

} else if (name.matches(firstMiddleAndLastNameWithoutPrefixWithSuffixPattern) && firstMiddleAndLastNameWithoutPrefixWithSuffixMatch != null) {
namePrefix = ""
firstName = firstMiddleAndLastNameWithoutPrefixWithSuffixMatch.groups[1]!!.value.trim()
middleName = firstMiddleAndLastNameWithoutPrefixWithSuffixMatch.groups[2]!!.value.trim()
lastName = firstMiddleAndLastNameWithoutPrefixWithSuffixMatch.groups[3]!!.value.trim()
nameSuffix = firstMiddleAndLastNameWithoutPrefixWithSuffixMatch.groups[4]!!.value.trim()
// -------------------------------------------------------------------------------------

// WITHOUT SUFFIX -------------------------------------------------------------------------
} else if (name.matches(lastNameWithPrefixWithoutSuffixPattern) && lastNameWithPrefixWithoutSuffixMatch != null) {
namePrefix = lastNameWithPrefixWithoutSuffixMatch.groups[1]!!.value.trim()
firstName = ""
middleName = ""
lastName = lastNameWithPrefixWithoutSuffixMatch.groups[2]!!.value.trim()
nameSuffix = ""

} else if (name.matches(firstAndLastNameWithPrefixWithoutSuffixPattern) && firstAndLastNameWithPrefixWithoutSuffixMatch != null) {
namePrefix = firstAndLastNameWithPrefixWithoutSuffixMatch.groups[1]!!.value.trim()
firstName = firstAndLastNameWithPrefixWithoutSuffixMatch.groups[2]!!.value.trim()
middleName = ""
lastName = firstAndLastNameWithPrefixWithoutSuffixMatch.groups[3]!!.value.trim()
nameSuffix = ""

} else if (name.matches(firstMiddleAndLastNameWithPrefixWithoutSuffixPattern) &&  firstMiddleAndLastNameWithPrefixWithoutMatch != null) {
namePrefix = firstMiddleAndLastNameWithPrefixWithoutMatch.groups[1]!!.value.trim()
firstName = firstMiddleAndLastNameWithPrefixWithoutMatch.groups[2]!!.value.trim()
middleName = firstMiddleAndLastNameWithPrefixWithoutMatch.groups[3]!!.value.trim()
lastName = firstMiddleAndLastNameWithPrefixWithoutMatch.groups[4]!!.value.trim()
nameSuffix = ""

} else if (name.matches(firstNameWithoutPrefixAndSuffixPattern) && firstNameWithoutPrefixAndSuffixMatch != null) {
namePrefix = ""
firstName = firstNameWithoutPrefixAndSuffixMatch.groups[1]!!.value.trim()
middleName = ""
lastName = ""
nameSuffix = ""

} else if (name.matches(firstAndLastNameWithoutPrefixAndSuffixPattern) && firstAndLastNamePatternWithoutPrefixAndSuffixMatch != null) {
namePrefix = ""
firstName = firstAndLastNamePatternWithoutPrefixAndSuffixMatch.groups[1]!!.value.trim()
middleName = ""
lastName = firstAndLastNamePatternWithoutPrefixAndSuffixMatch.groups[2]!!.value.trim()
nameSuffix = ""

} else if (name.matches(firstMiddleAndLastNameWithoutPrefixAndSuffixPattern) && firstMiddleAndLastNameWithoutPrefixAndSuffixMatch != null) {
namePrefix = ""
firstName = firstMiddleAndLastNameWithoutPrefixAndSuffixMatch.groups[1]!!.value.trim()
middleName = firstMiddleAndLastNameWithoutPrefixAndSuffixMatch.groups[2]!!.value.trim()
lastName = firstMiddleAndLastNameWithoutPrefixAndSuffixMatch.groups[3]!!.value.trim()
nameSuffix = ""

// ----------------------------------------------------------------------------------
} else if(name == "") {
namePrefix = ""
firstName = ""
middleName = ""
lastName = ""
nameSuffix = ""
}
< /code>
Пока что этот код выполняет задание, как и предполагалось. Найдя совпадение, имя, введенное в поле «Имя текстового поля» 

, разделено и помещается в другие текстовые поля . Однако, как вы можете видеть, код представляет собой нечитаемый раздутый беспорядок. Как я могу принять все это и сделать его меньшим, читаемым, многоразовым и эффективным?>

Подробнее здесь: https://stackoverflow.com/questions/792 ... d-reusable