unerreichbaren Code in scala

Question

val LIST = scala.collection.mutable.MutableList[String]() 
    val filterF = new Function[Path, Boolean] { 
    def apply(x: Path): Boolean = { 
     println("looking into " + x) 
     val flag = if (x.toString.split("/").last.split("_").last.toLong < System.currentTimeMillis) { 
     println("considered " + x) 
     LIST += x.toString 
     return true 
     } else { 
     println("NOT considered " + x) 
     return false 
     } 
     return flag 
    } 
    } 

Ich versuche, die externe Variable LIST innerhalb der Funktion filterF zu aktualisieren. Aber das Problem ist, dass nach der println("looking into "+x) Zeile der Rest des Codes nicht erreichbar ist.

val flag = if (x.toString.split("/").last.split("_").last.toLong < System.currentTimeMillis) { 
     println("considered " + x) 
     LIST += x.toString 
     return true 
     } else { 
     println("NOT considered " + x) 
     return false 
     } 
     return flag 

Ich kann nicht verstehen, warum dieser Code unerreichbar ist. Gibt es einen Code im Code, der eigentlich der Grund dafür ist?

Answer 1

nicht return

Verwenden Sie, wenn Sie return Kontrolle der Ausführung verwenden die Funktion und den gesamten Code nach der return-Anweisung verlassen wird nicht erreichbar sein

Code nach Rückgabe wird nicht erreichbar sein

def foo: Int = { 
return 1 
2 + 3 //unreachable 
} 

Bei if Ausdruck

def bar: Int = { 
    if (true) { 
    return 1 
    } else { 
    return 2 
    } 
    1 + 2 //unreachable 
} 

In Scala return-Anweisung ist optional und nicht empfohlen, da es nicht funktionelle Praxis Codierung prüfen.

Der Wert des letzten Ausdrucks im Codeblock ist der Rückgabewert in Scala. Also keine Sorge über explizite Rückkehr lass es einfach auf das Programm

val flag = if (x.toString.split("/").last.split("_").last.toLong < System.currentTimeMillis) { 
    println("considered " + x) 
    LIST += x.toString 
    true //removed return 
    } else { 
    println("NOT considered " + x) 
    false // removed return 
    } 

das Programm Aufhalten der Ausführung durch das Auslösen einer Ausnahme oder durch Wert zurückgegeben oder durch einen expliziten Aufruf Ausgang ist nicht funktional, Dinge zu tun. Scala erlaubt es leider. Aber wenn Sie ein guter Bürger der funktionalen Welt sein wollen. Sie vermeiden es besser.

Vermeiden wandelbar Sammlungen

Verwenden mutable Sammlungen, wenn Sie haben ein starkes Bedürfnis danach. Es gibt Vorteile von immutable Sammlungen

1) Sie sind Thread-Safe.

2) Fehlerfrei (keine Überraschungen durch zufällige Mutationen und keine Blockierung).

3) Referentielle Transparenz.

4) Angemessene Leistung.

Verwenden Sie immutable Liste statt mutable Liste.

Verwenden Scala Lambda-Notation und syntaktischer Zucker

syntaktischer Zucker ist es für einen Grund. Syntaktischer Zucker reduziert den Standardcode. Damit Ihr Code klar, sauberer und besser aussieht. Hilft bei der Pflege des Codes. Code bleibt für längere Zeit fehlerfrei.

Anstelle der Function1 Eigenschaft Lambda-Notation verwenden.

scala> val f = new Function1[String, String] { def apply(str: String): String = str} 
f: String => String = <function1> 

scala> val f = {str: String => str} 
f: String => String = <function1> 

So Ihr Code wird

val paths = List[Path]() //assume you have Paths in it. 

val filter = {path: Path => path.toString.split("/").last.split("_").last.toLong < System.currentTimeMillis } 

val resultList = paths.filter(filter) 

Answer 2

Dies verursacht wird, die flag ist val nicht def, aber Ihre Aussage wird mit dem returnwahr oder falsch zurückzukehren. Die return Schlüsselwörter sind nur für die Methode, nicht für die Funktion.

Der richtige Weg vielleicht mag:

val flag = if (x.toString.split("/").last.split("_").last.toLong < System.currentTimeMillis) { 
    println("considered " + x) 
    LIST += x.toString 
    true 
} 
else { 
    println("NOT considered " + x) 
    false 
}