Scala Costruttore/Metodo Parametro Controllo

Question

Volevo verificare alcune best practice della programmazione Scala, poiché sono nuovo di Scala. Ho letto online su come Scala non usa in genere le eccezioni tranne che per circostanze "eccezionali" (che non includono il controllo dei parametri). Proprio ora nel mio progetto sto usando un sacco di require, quindi mi sto chiedendo quale sarebbe il modo migliore per il controllo dei tipi.

Per esempio, se ho una classe

class Foo(String bar){ 
    require(StringUtils.isNotEmpty(bar), "bar can't be empty") 
} 

quali sono le mie alternative al controllo bar? Creo un oggetto companion come

Object Foo { 
    def apply(bar: String) = Try[Foo] { 
    bar match = { 
     case null => Failure("can't be null") 
     //rest of checks 
     case _ => Success[Foo] 
    } 
} 

Oppure dovrei usare Opzione invece?

Inoltre, per i metodi scala, come posso controllare il parametro del metodo? Se restituisco già un'opzione, restituisco un'opzione vuota solo se ottengo un parametro errato? Non significherebbe che devo verificare un'opzione vuota quando uso il ritorno del metodo e non farei un'eccezione per consentire un messaggio più specifico? (ad esempio, l'eccezione di runtime non può utilizzare valori null).

Answer 1

Penso che la parte Success dell'oggetto companion possa restituire anche l'oggetto Foo()?

Object Foo { 
     def apply(bar: String) = Try[Foo] { 
     bar match = { 
      case null => Failure("can't be null") 
      //rest of checks 
      case _ => Success[Foo](new Foo(bar)) 
     } 
    } 

di usarlo si potrebbe fare qualcosa con la Success si ottiene da Foo (bar):

val hehe = Foo(bar).map(foo => foo.someString()).getOrElse('failed') 

I metodi Try sarà avvolgere automaticamente le eccezioni generate dal someString() o qualsiasi altra cosa che si' stai facendo all'interno di Fallimenti. Se si desidera verificare i parametri di foo.someString(), si dovrebbe fare qualcosa di simile al tuo metodo apply(). Non è molto diverso dal lancio di eccezioni sulle condizioni, ma penso che sia più bello perché i "blocchi catch" si trovano in recover() o recoverWith(). È sempre possibile uscire dallo Try utilizzando getOrElse() se il codice non è stato progettato per concatenare Try s dall'alto verso il basso.