Scala controlla se l'elemento è presente in una lista

87

Devo controllare se una stringa è presente in un elenco e chiamare una funzione che accetta un booleano di conseguenza.

È possibile ottenere questo risultato con un rivestimento?

Il codice seguente è il migliore che potrei ottenere:

val strings = List("a", "b", "c")
val myString = "a"

strings.find(x=>x == myString) match {
  case Some(_) => myFunction(true)
  case None => myFunction(false)
}

Sono sicuro che sia possibile farlo con meno codice, ma non so come!

— Dario Oddenino
fonte

125

Basta usare contains

myFunction(strings.contains(myString))

— Kim Stebel
fonte

3

Cosa succede se non gestisco una stringa ma ho bisogno di controllare se un valore è una qualsiasi delle possibili corrispondenze?

— tutuca

2

@tutuca, controlla questo controllo-se-valori-in-lista-fa-parte-di-stringa .

— Om Prakash

33

E se non volessi usare la rigorosa uguaglianza, potresti usare esistente:


myFunction(strings.exists { x => customPredicate(x) })

— Matt Hughes
fonte

14

Ancora più facile!

strings contains myString

— Taylrl
fonte

4

In che modo è diverso dalla risposta accettata ?

— Alper t. Turker

2

Fondamentalmente è lo stesso ma le differenze sono: 1. Meno parentesi 2. Meno periodi 3. Nessun riferimento a myFunction 4. Più spazio bianco. Complessivamente; La mia risposta = 25 caratteri vs la risposta accettata = 38 caratteri

— Taylrl

Era una domanda retorica;) Per darti un contesto ho ottenuto qui da LQP . Non ho consigliato l'eliminazione, ma se pubblichi una risposta in ritardo prova a fornire un valore aggiuntivo. Un po 'di zucchero sintattico non ne ha voglia, sai. Sto solo dicendo ...

— Alper t. Turker

3

Nessun problema. Capisco. Penso che aggiunga valore mostrando una maggiore semplicità. Grazie comunque :)

— Taylrl

3

questo dovrebbe funzionare anche con predicati diversi

myFunction(strings.find( _ == mystring ).isDefined)

— DanieleDM
fonte

3

Potresti semplicemente usare exist invece di dover usare find combinato con isDefined

— Ciaran0

2

Nel tuo caso, prenderei in considerazione l'utilizzo di Set e non List, per assicurarti di avere solo valori univoci. a meno che non sia necessario includere talvolta duplicati.

In questo caso, non è necessario aggiungere alcuna funzione wrapper attorno agli elenchi.

— guykaplan
fonte

-3

Puoi anche implementare un containsmetodo con foldLeft, è davvero fantastico. Adoro gli algoritmi foldLeft.

Per esempio:

object ContainsWithFoldLeft extends App {

  val list = (0 to 10).toList
  println(contains(list, 10)) //true
  println(contains(list, 11)) //false

  def contains[A](list: List[A], item: A): Boolean = {
    list.foldLeft(false)((r, c) => c.equals(item) || r)
  }
}

— Johnny
fonte