Início / coding / Perguntas / 79150227
Accepted
gstackoverflow
Asked: 2024-11-02 16:13:09 +0800 CST

Existe uma maneira de adicionar mais um argumento à função (que tem var args) com valor padrão sem interromper as chamadas existentes?

  • 772

Eu tenho uma função

fun foo(
    id: String,
    vararg values: Int,
){
  ...    
}

e há chamadas como essas

fun bar1(){
    foo("id_1")
    foo("id_2", 1)
    foo("id_3", 1, 2, 3)
}

Agora entendi que preciso adicionar mais um argumento para foo. mas não quero interromper chamadas existentes, então tentei adicioná-lo com valores padrão:

fun foo(
    id: String,
    attributes: Array<String> = arrayOf("a", "b"),
    vararg values: Int,
){
  ...
}

Mas

foo("id_2", 1)
foo("id_3", 1, 2, 3)

ficou quebrado.

Existe uma maneira de adicionar mais um argumento com valor padrão sem interromper as chamadas existentes?

function

2 respostas

  1. Sou novo em Kotlin, mas você me fez aprender isso hoje, obrigado! Estava usando o Kotlin Playground.

    Você estava perguntando sobre uma maneira de adicionar mais um argumento com valor padrão sem interromper as chamadas existentes.

    Você pode fazer isso usando atributos após vararg como

    fun foo(
    id: String,
    vararg values: Int,
    attributes: Array<String> = arrayOf("a", "b"),
){
  ...
}

    Mas espere, isso vai gerar um erro em relação ao tipo, porque o atributo que você quis transmitir no final de foo() também será considerado como vararg, então para usar esse código teremos que chamar a função assim:

    foo("id_3", 1, 2, 3,attributes=loremipsum)

    onde for necessário você pode adicionar ,attributes=loremipsume se não for possível deixe-o.

    • 1
  2. Best Answer

    Opção 1:

    Você pode, se mover o novo parâmetro para o final:

    fun foo(
    id: String,
    vararg values: Int,
    attributes: Array<String> = arrayOf("a", "b"),
) {
    // ...
}

    Mas fica um pouco estranho chamar:

    fun bar1() {
    foo("id_1")
    foo("id_2", 1)
    foo("id_3", 1, 2, 3)
    foo("id_3", 1, 2, 3, attributes = arrayOf("a", "b"))
}

    Você precisa especificar o nome do parâmetro, caso contrário o compilador pensará que o array ainda faz parte do parâmetro varargs.

    Opção 2:

    Você pode sobrecarregar a função:

    fun foo(
    id: String,
    vararg values: Int,
) {
    foo(id, arrayOf("a", "b"), *values)
}

fun foo(
    id: String,
    attributes: Array<String>,
    vararg values: Int,
) {
    // ...
}

    Então você pode chamá-lo assim:

    fun bar1() {
    foo("id_1")
    foo("id_2", 1)
    foo("id_3", 1, 2, 3)
    foo("id_3", arrayOf("a", "b"), 1, 2, 3)
}

    Isso é mais elegante no local da chamada, mas há uma pequena sobrecarga no lado da declaração.

    • 1

relate perguntas