esecuzione di codice nel costruttore di overload prima di chiamare questo()

Question

Supponiamo di avere una classe come questa:

import java.net.URL 
import xml._ 

class SearchData(xml: Node) { 
    def this(url: URL) = this (XML.load(url)) 
} 

e vogliamo eseguire del codice prima di chiamare this (XML.load(url)) - dire di prova con try. Ci si aspetterebbe che scrivere qualcosa di simile a questo dovrebbe funzionare:

class SearchData(xml: Node) { 
    def this(url: URL) { 
    try { 
     this (XML.load(url)) 
    } catch { 
     case _ => this(<results/>) 
    } 
    } 
} 

, ma non sarà così, perché Scala richiede che si effettua la chiamata al this() la prima istruzione nel costruttore sovraccaricato e in questo caso try diventa la prima dichiarazione .

Quindi quale sarebbe la soluzione a questo problema?

Answer 1

def this(url: Url) = this(try {XML.load(url)} catch {case _ => <results/>}) 

Più in generale, la valutazione degli argomenti deve accadere prima che la chiamata al costruttore, in modo da fare che c'è (un blocco in Scala è un'espressione, ma scrivere una routine, in genere scritta nell'oggetto compagna , se sarà troppo lungo). Quello che non puoi fare è avere questo codice scegliere quale altro costruttore chiami. Ma poiché tutti devono essere diretti a quello primario, non perdi molto. Inoltre, è necessario che l'altro costruttore che chiami abbia almeno un argomento. Se ci sono diversi costruttori, quello primario dovrebbe normalmente non essere l'uno senza un argomento (vedi Scala problem optional constructor)

Answer 2

Metodo fabbrica in oggetto associato:

object SearchData { 
    def apply(xml: Node) = new SearchData(xml) //Added to provide uniform factories 
    def apply(url: URL) = { 
    try { 
     new SearchData(XML.load(url)) 
    } catch { 
     case _ => new SearchData(<results/>) 
    } 
    } 
} 

//Example 
val sd = SearchData(new URL("http://example.com/")) 

Non solo semplifica la progettazione, ma si può risparmiare la parola chiave new.

Answer 3

Mentre soluzione di didierd risolve il problema dichiarato ed è un po 'vicino a questo, non risolve il problema quando si devono eseguire più istruzioni prima di chiamare this. Questo fornisce un approccio generale a tutti gli scenari:

class SearchData(xml: Node) { 
    def this(url: URL) = this { 
    println(url) 
    try { 
     XML.load(url) 
    } catch { 
     case _ => <results/> 
    } 
    } 
} 

Il trucco è che this è alimentato con risultato dell'esecuzione di una funzione anonima in corpo di cui si è permesso di fare qualsiasi cosa.

Ma questo funziona solo quando si dispone di un costruttore principale singolo argomento - in altri scenari si dovrà introdurre un Tuple soluzione basata su:

class SearchData(xml: Node, valid: Boolean) { 
    def this(url: URL) = this { 
    println(url) 
    try { 
     (XML.load(url), true) 
    } catch { 
     case _ => (<results/>, false) 
    } 
    } 
    def this(t: (Node, Boolean)) = this(t._1, t._2) 
}