if I’m doing: ```when (string){ "SomeString" -> { } }``` can i have it somewhere set to ign...

# getting-started

[oday]

if I’m doing:

when (string){

    "SomeString" -> { }
}

can i have it somewhere set to ignore case when matching?

[oday]

hmm it doesn’t really make sense to do that though cause it defeats the purpose

[Nilesh Rathod]

Try something like this

with("string") {
      when {
        equals("SomeString", ignoreCase = true) -> println("position is 1")
        contains("SomeString", ignoreCase = true) -> println("foo")
        startsWith("SomeString", ignoreCase = true) -> println("bar")
        else -> println("SomeString")
      }
    }

[oday]

never knew you could have functions there

[oday]

thanks

[Saku Ytti]

Why not when (string.lowercase()))

[df]

when(string.toLower()) {
 ... 
}

Might be the better option when all patterns should ignore the case

[oday]

the incoming string is always going to be lower case, and the thing being matched will be this enum class

enum class Options(val value: String) {
-->        NEARBY("nearby"),
-->        ANYWHERE("anywhere")
    }
}

i’m having to give each one a name so that this matching could makes sense

what I wanted to do is leave the enums without a name and just match the enum by its .name

[oday]

then i could do enum.name.toLower() I guess?

[Saku Ytti]

Yes (lowercase or toLowerCase which is deprecated)

[Nilesh Rathod]

@oday yes like this enum.name.lowercase()

[df]

depending on your use case, you might want to do sth like this

enum class Option(val value: String) {
    NEARBY("nearby"),
    ANYWHERE("anywhere");
    
    companion object {
        fun fromValue(value: String) = Option.values().first { it.value == value }
    }
}

fun main() {
    val enumValue = Option.fromValue("nearby")

    when (enumValue) {
        NEARBY -> ...
        ANYWHERE -> ...
    }
}

[df]

The main advantage is, that adding a new value to your enum will lead to a compile time error if you forget to add the new value to the when block

[oday]

that’s really good actually

[oday]

yea I didnt think further than the current case, and indeed there will be other values

[oday]

ok so I’ve implemented this and a strange thing has happened, there was an else branch inside the when that I rely on to know whether the value is not part of the enum defined, when it isn’t part of the enum defined, it’s going to be a cityId, and then I do something with that

the way it’s become now, all cases are covered and the else has become redundant

[oday]

should be .find() not .first()

[oday]

cause of this case that i just mentioned

[oday]

jep, that did it

[Stephan Schröder]

in the spirit of "don't repeat yourself", let's remove the value from the enum.

enum class Option {
    NEARBY,
    ANYWHERE;
    
    companion object {
        fun fromAnyCase(value: String) = with(value.uppercase()) {Option.values().find { it.name == this }}
    }
}

also maybe add a TODO-comment to replace Option.values() to Option.entries in Kotlin 1.9. Apparently Enum.values() isn't the most efficient thing: https://youtrack.jetbrains.com/issue/KT-48872

[oday]

ok yes that is nice and goes the other route of making the value upper case, so as not to repeat, very nice thank you