Restituzione di più valori in Javascript

Question

Restituzione di più valori in Javascript

#1 da (6 voti)
#2 da (3 voti)
#3 da (1 voti)
#4 da (0 voti)

3

Spesso sto scrivendo una funzione che restituisce più valori, come una coppia di coordinate:

function get_coords() {
  return ???;
}

Se usassi un linguaggio come Python, userei una tupla:

return (x, y)

Oppure, in un linguaggio OOP come Java, vorrei creare una classe di coordinate personalizzate:

class Coordinates {
  public int x;
  public int y;

  public Coordinates(x, y) {
    this.x = x;
    this.y = y;
  }
}

Quindi ritorna in questo modo:

return new Coordinates(x, y);

Sì a JavaScript.

In JavaScript, abbiamo la possibilità di restituire un oggetto semplice:

return {x: x, y: y}

o un approccio simile a Java, con un oggetto personalizzato:

return new coordinates(x, y)

Ci sono dei motivi per usare uno sopra l'altro?

javascript class object

posta JJJollyjim 02.10.2013 - 11:54

fonte

4 risposte

3

Dipende interamente da ciò che il codice chiamante dovrebbe fare con le coordinate restituite. Se il tuo codice attuale richiede solo l'accesso diretto alle proprietà x e y , utilizza il letterale:

return {x: x, y: y};

Se e quando decidi di dover "aggiornare" il valore restituito, è piuttosto semplice modificarlo in questo modo:

return new Coordinates(x, y);

O questo:

return BuildCoordinate(x, y);

Senza impedire che il codice legacy funzioni ancora direttamente con .x e .y , fintanto che il costruttore Coordinates li fornisce.

E il tuo codice chiamante può essere facilmente "aggiornato" per chiamare i tuoi metodi speciali Coordinates , come questo:

GetCoords().calculateDistanceTo(anotherX, anotherY);

O esegui il controllo dei tipi, come questo:

var coords = GetCoords();
if (coords instanceof Coordinates) {
  coords.plot(canvas);
}

Ma di nuovo, probabilmente stai meglio usando il valore di ritorno nudo (letterale dell'oggetto) finché non hai bisogno del bagaglio che viene fornito con un valore di ritorno "tipizzato" (l'oggetto costruito).

risposta data 02.10.2013 - 19:49

fonte

1

Bene, entrambi gli approcci sono uguali, poiché entrambi sono Oggetti con le stesse proprietà, solo prototipi diversi.

Per semplicità, dovresti probabilmente andare con la prima opzione. O ancora più semplice, con la matrice della forma [x, y] .

risposta data 02.10.2013 - 12:01

fonte

0

Utilizza quello che corrisponde al significato dei tuoi dati.

La mia travolgente abitudine è di utilizzare semplici letterali oggetto come dizionari / hash e di usare oggetti prototipati personalizzati in modo OOP.

Stai restituendo una semplice raccolta di valori convenienti che saranno immediatamente disassemblati dalla funzione chiamante? Quindi utilizza un oggetto veloce letterale.

Il tuo valore di ritorno è una cosa che fa e rappresenta elementi concettuali importanti nel tuo modello di dati? Quindi prenditi il tempo necessario per scrivere un costruttore e renderlo un'istanza prototipata.

Certo, javascript ci consente di essere flessibili (sciatti) e intelligenti (criptici) mescolando queste idee, ma trovo che il mio codice è molto più chiaro se aderisco a questa regola.

risposta data 06.10.2013 - 07:08

fonte

Leggi altre domande sui tag javascript class object

Come migliorare il codice dopo aver conosciuto molte lingue? [chiuso] Come dovrei affrontare il test del codice su un progetto solista?

score 6 · Accepted Answer

Questa è l'opzione migliore (e dettagliata) in questo momento.

return {'x': x, 'y': y}

Il chiamante dovrebbe fare questo per usare i valori

var c = get_coords();
alert(c.x + ' ' + c.y);    // c.x and c.y holds the coordinates

Se ti interessa utilizzare solo assi singoli, puoi fare -

alert(get_coords().x);

Con ECMAScript 6 saresti in grado di eseguire la destrutturazione (nel chiamante).

var { x, y} = get_coords();

Peccato che dovremo aspettare abbastanza a lungo per usare ECMAScript 6 in sicurezza nella produzione (in modo cross-browser).

Maggiori informazioni sulla destrutturazione - link