如何在慣用的 Kotlin 中將駱駝案例字符串轉換為蛇案例並返回？

Question

尋找可以進行如下轉換的代碼：“MyCamelCaseA”到“my_camel_case_a”“AMultiWordString”到“a_multi_word_string”“my_camel_case_a”到“myCamelCaseA”或“MyCamelCaseA”“a_multi_word_string”到“aMultiWordString”或“AMultiWordString”

Answer 1

以下是 String 類的擴展，它們使用正則表達式和替換將字符串從駝峰式轉換為蛇式，以及從蛇式轉換為駝式：

val camelRegex = "(?<=[a-zA-Z])[A-Z]".toRegex()
val snakeRegex = "_[a-zA-Z]".toRegex()

// String extensions
fun String.camelToSnakeCase(): String {
    return camelRegex.replace(this) {
        "_${it.value}"
    }.toLowerCase()
}

fun String.snakeToLowerCamelCase(): String {
    return snakeRegex.replace(this) {
        it.value.replace("_","")
            .toUpperCase()
    }
}

fun String.snakeToUpperCamelCase(): String {
    return this.snakeToLowerCamelCase().capitalize()
}

以下是使用 String 擴展名的示例：

print("${"MyCamelCaseA".camelToSnakeCase()}\n")
my_camel_case_a

print("${"AMultiWordString".camelToSnakeCase()}\n")
a_multi_word_string

"my_camel_case_a".snakeToLowerCamelCase()
myCamelCaseA

"my_camel_case_a".snakeToUpperCamelCase()
MyCamelCaseA

Answer 2

這是我的嘗試。

fun String.camelToSnakeCase() = fold(StringBuilder(length)) { acc, c ->
    if (c in 'A'..'Z') (if (acc.isNotEmpty()) acc.append('_') else acc).append(c + ('a' - 'A'))
    else acc.append(c)
}.toString()

我的做法也是用擴展函數的形式寫的，但是它沒有使用正則表達式，而是逐個字符進行處理，然后將處理結果折疊到累加器中，累加器一開始是一個空的StringBuilder 。 處理如下：

• 如果字符不是大寫拉丁字母，則按原樣將其添加到累加器
• 如果字符是大寫拉丁字母，則還要檢查這是否不是字符串的第一個字符（累加器不為空）。 如果不是，則向累加器添加下划線。 最后添加小寫字符。

需要注意的一件事是，使用的是kotlin.text.StringBuilder ，而不是 JDK。

Answer 3

我會使用這些實現：

fun String.toCamelCase() = 
    split('_').joinToString("", transform = String::capitalize)

...使用蛇作為分隔符分割字符串，然后將部分重新附加為沒有分隔符的大寫單詞。

fun String.toSnakeCase() = replace(humps, "_").toLowerCase()
private val humps = "(?<=.)(?=\\p{Upper})".toRegex()

...它使用正則表達式找到駝峰之前的位置，插入蛇，然后將整個字符串轉換為小寫。 正則表達式由兩部分組成，第一部分(?<=.)是一個肯定的后視，表示它前面必須有一個字符，第二部分(?=\\\\p{Upper})是使用一個肯定的前瞻說它后面必須跟一個大寫字符。

Answer 4

這只是我對 kotlin 的嘗試

   val  camelCaseString = "thisIsCamelCase"
    val snakeCaseString = camelCaseString.map {
        if (it.isUpperCase()){
            "_${it.toLowerCase()}"
        }else
{"$it"}
    }
.joinToString(separator = "")
System.out.println("here is your snake string: $snake_case_string")

這是你的蛇字符串：this_is_camel_case

從蛇變成駱駝

val snakeCaseString = "snake_case_string"
val camelCase = StringBuilder()
var prevChar = '$'
snakeCaseString.forEach {
if(prevChar.equals('_')){
    camelCase.append(it.toUpperCase())
}else if(!it.equals('_')){
    camelCase.append(it)
}
    prevChar = it
}

System.out.println(camelCase.toString())

---

蛇形字符串

Answer 5

如果您的類路徑中有jackson-databind ，則可以使用以下實用程序 function：

import com.fasterxml.jackson.databind.PropertyNamingStrategies

fun String.toSnakeCase(): String = 
    PropertyNamingStrategies.SnakeCaseStrategy().translate(this)

fun main() {
    // should output this_is_the_case
    println("thisIsTheCase".toSnakeCase())
}

Answer 6

如果你想要一個帶有輸入和輸出的方法，我就是這樣做的：

private fun convertCamelToSnakeCase(camelCase : String) : String {
    val snakeCase = StringBuilder()
    for(character in camelCase) {
        if(character.isUpperCase()) {
            snakeCase.append("_${character.toLowerCase()}")
        } else {
            snakeCase.append(character)
        }
    }
    return snakeCase.removePrefix("_").toString()
}

Answer 7

我在這里接受了其中一個答案，添加了標題案例並稍微更改了 API

val camelRegex = "(?<=[a-zA-Z])[A-Z]".toRegex()
val snakeRegex = "_[a-zA-Z]".toRegex()

@JvmInline
value class SnakeCaseString(private val string: String) {
    fun toCamelCase(): String = snakeRegex.replace(string) { it.value.replace("_", "").uppercase() }
    fun toUpperCamelCase(): String =
        toCamelCase().replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
    fun toTitleCase(): String = snakeRegex.replace(string) { it.value.replace("_", " ").uppercase() }
        .replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
}

@JvmInline
value class CamelCaseString(private val string: String) {
    fun toSnakeCase(): String = camelRegex.replace(string) { "_${it.value}" }.lowercase()
    fun toTitleCase(): String = camelRegex.replace(string) { "_${it.value}" }
        .replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
}

fun String.asSnakeCase() = SnakeCaseString(this)
fun String.asCamelCase() = CamelCaseString(this)