Scala - mutable (var) riferimento parametro parametro

Question

EDIT: Continuo a ottenere voti positivi qui. Solo per la cronaca, non penso più che questo sia importante. Non ne ho avuto bisogno da quando l'ho pubblicato.

Vorrei fare seguito a Scala ...

def save(srcPath: String, destPath: String) { 
    if (!destPath.endsWith('/')) 
     destPath += '/' 
    // do something 
} 

... ma non riesco a Allucinante destPath è un val. C'è un modo per dichiarare destPath come var?

Nota: ci sono domande simili ma in tutte OP si voleva solo modificare l'array.

Si prega di non consiglio seguente:

La modifica dei dettagli i parametri di input è spesso visto come un cattivo stile e lo rende più difficile di ragionare sul codice.

Penso che sia valido nella programmazione imperativa (Scala consente entrambi, giusto?) E aggiungendo qualcosa come tmpDestPath aggiungerebbe solo confusione.

MODIFICA: non fraintendere. So che le stringhe non sono modificabili e non desidero un riferimento come riferimento perché non desidero modificare i dati del chiamante. Voglio solo modificare il riferimento locale alla stringa che il chiamante mi ha fornito con la mia stringa (ad esempio orig + '/'). Voglio modificare tale valore solo nell'ambito del metodo corrente. Guarda, questo è perfettamente valido in Java:

void printPlusOne(int i) { 
    i++; 
    System.out.println("i is: " + i); 
    System.out.println("and now it's same: " + i); 
} 

non ho per creare nuova variabile e non devo calcolare i + 1 due volte.

Answer 1

La JVM non consente il riferimento pass-by dei puntatori agli oggetti (che è come si farebbe in C++), quindi non si può fare esattamente ciò che si desidera.

Una possibilità è quella di restituire il nuovo valore:

def save(srcPath: String, destPath: String): String = { 
    val newPath = (if (!destPath.endsWith("/")) destPath+'/' else destPath) 
    // do something 
    newPath 
} 

Un altro è quello di creare un wrapper:.

case class Mut[A](var value: A) {} 

def save(srcPath: String, destPath: Mut[String]) { 
    if (!destPath.value.endsWith("/")) destPath.value += '/' 
    // do something 
} 

cui gli utenti dovranno quindi utilizzare sul modo in (Naturalmente, saranno tentati di save("/here",Mut("/there")) che getterà via le modifiche, ma questo è sempre il caso con argomenti della funzione pass-by-reference.)

---

Modifica: ciò che stai proponendo è una delle maggiori fonti di confusione tra i programmatori non esperti. Cioè, quando modifichi l'argomento di una funzione, stai modificando una copia locale (pass-by-value) o l'originale (pass-by-reference)? Se lo non lo puoi nemmeno modificare, è abbastanza chiaro che qualsiasi cosa tu faccia è una copia locale.

Basta fare così.

val destWithSlash = destPath + (if (!destPath.endsWith("/")) "/" else "") 

Vale la pena la mancanza di confusione su ciò che sta effettivamente accadendo.

Answer 2

Gli oggetti stringa sono immutabili in Scala (e Java).Le alternative a cui posso pensare sono:

1. Restituisce la stringa del risultato come valore di ritorno.
2. Invece di utilizzare un parametro String, utilizzare un StringBuffer o StringBuilder, che non sono immutabili.

Nel secondo scenario si dovrebbe avere qualcosa di simile:

def save(srcPath: String, destPath: StringBuilder) { 
    if (!destPath.toString().endsWith("/")) 
     destPath.append("/") 
    // do something 
    // 
} 

EDIT

Se ho capito bene, si desidera utilizzare l'argomento come una variabile locale. Non puoi, perché tutti gli argomenti del metodo sono val in Scala. L'unica cosa da fare è quello di copiarlo in una variabile locale prima:

def save(srcPath: String, destPath: String) { 
    var destP = destPath 
    if (!destP.endsWith("/")) 
     destP += "/" 
    // do something 
    // 
} 

Answer 3

Non è possibile.

Dovrai dichiarare un extra var (o usare uno stile più funzionale :-)).

esempio semplicistico:

def save(srcPath: String, destPath: String) { 
    val normalizedDestPath = 
     if (destPath.endsWith('/')) destPath 
     else destPath + '/' 
    // do something with normalizedDestPath 
} 

Answer 4

Ecco un paio di suggerimenti:

1) Aggiorna il tuo funzione un po '

def save(srcPath: String, destPath: String) { 
    var dp = destPath 
    if (!dp.endsWith('/')) 
    dp+= '/' 
    // do something, but with dp instead of destPath 
} 

2) Creazione di una funzione di utilità da utilizzare prima di chiamare Salva

def savedPath(path: String) = 
    if(path.endsWith("/")) 
    path 
    else 
    path + "/" 

//call your save method on some path 
val myDestPath = ... 
val srcPath = ... 
save(srcPath, savedPath(myDestPath)) 

Answer 5

No, non è consentito in Scala. Altri hanno descritto alcuni workaround di basso livello (tutti buoni), ma ne aggiungerò uno di livello superiore. Proprio per questo tipo di stringhe di normalizzazione, torno a un'estensione pimped a scala.String con metodi come suffisso, prefisso, removeSuffix e removePrefix. suffisso e prefisso aggiungono o anteporre una stringa a un'altra, a meno che il suffisso o il prefisso non siano già presenti. removeSuffix e removePrefix fanno l'ovvio, rimuovendo una stringa dalla fine o dall'inizio di un'altra, se è presente. Il tuo caso d'uso sarebbe scritto

val normalizedPath = destPath.addSuffix("/") 

Se fate un po 'di operazioni di analisi dei dati o di file, questi metodi sono così a portata di mano che non si creda che tu abbia mai fatto senza di loro.

Answer 6

Forse si potrebbe ottenere il sistema di tipi per fare il lavoro per voi, quindi non c'è nemmeno bisogno di preoccuparsi di aggiunta di una barra di volta in volta:

class SlashString(s: String) { 
    override val toString = if (s endsWith "/") s else s + "/" 
} 
implicit def toSlashString(s: String) = new SlashString(s) 

Ora non è necessario alcun codice tutto per cambiare l'ingresso String:

def save(srcPath: String, destPath: SlashString) { 
    printf("saving from %s to %s", srcPath, destPath) 
} 

val src: String = "abc" 
val dst: String = "xyz" 

scala> save(src, dst) 
saving from abc to xyz/ 

è vero, c'è un po 'di messa a punto all'inizio, ma questo sarà meno così con le classi implicite nella versione 2.10, e rimuove tutto il disordine dal metodo, che era di cosa eri preoccupato

Answer 7

So che questa è una vecchia questione, ma se si desidera solo per riutilizzare il nome di argomento forse:

def save(srcPath: String, destPath: String) { 
    ((destPath: String) => { 
    // do something 
    })(if (!destPath.endsWith('/')) destPath + '/' else destPath) 
}