[JS] Risalire al nodo superiore di una matrice

[daneel]

Come è possibile risalire a matrice[4][7] all'interno del prototipo prova se lo si chiama per matrice[4][7][2]?

matrice[4][7][2].prova();

Array.prototype.prova = function(){
	// qui devo risalire da this a matrice[4][7]
}

[standard]

in questo caso non devi pensare ad una matrice come se ci fossero parentele tra i vari array, quando setti un prototipo per gli array, sarà valido per tutti gli array e non si fa differenza tra gli array semplici e o gli array composti.

Una soluzione che potresti utilizzare è quella di crearti le tue matrice passando per metodi nei quali puoi inserire delle flag o delle proprietà che indichino il livello di indentazione dell'array.

Spero di essermi spiegato, cmq il concetto di fondo è:

array1= new Array();
array1.padre=true;

array2 = new Array();
array2.figlio=true;

array1[0]=array2;

l'idea l'ho buttata così di getto, potrebbero esserci strade più convenienti che ora mi sfuggono, cmq poi potresti mettere tutto sottoforma di metodi per gli array.
ciauz

[nosferatu_net]

Io ti suggerirei di passarti l'indice del padre come parametro del metodo.

[nosferatu_net]

No scusa, era una ca**ata. Non considerare il post. Non funziona così.

[daneel]

Ho realizzato un prototipo per array che lavora nel modo seguente:

variabile=7;

// crea tre nuovi array
matrice2=new Array();
matrice3=new Array();
matrice4=new Array();

/* l'uso del prototipo set trasforma l'array matrice2 in una matrice
   bidimensionale e posiziona la variabile alla posizione (6,4) */
matrice2.set(variabile,6,4);
/* trasforma l'array matrice3 in una matrice tridimensionale
   e posiziona la variabile alla posizione (5,9,8) */
matrice3.set(variabile,5,9,8);
/* trasforma l'array matrice4 in una matrice quadridimensionale
   e posiziona la variabile alla posizione (5,8,7,4) */
matrice4.set(variabile,5,8,7,4);

// restituisce il valore inserito in matrice3
alert(matrice3[5][9][8]);

Tra l'altro, il prototipo adatta anche la disposizione dei dati nel caso che una matrice venga ridefinita con un numero maggiore di dimensioni. Comunque, quello che importa è che non vengono inseriti in nessun modo degli indici o delle proprietà aggiuntive per gli array che vanno a costituire la matrice, e non posso più modificare il codice per fare in modo che siano posizionati dei flag per indicare il livello di "parentela" tra gli array (cosa che non sarebbe gestibile all'interno dell'applicazione in cui uso il metodo set).

[nosferatu_net]

Potrebbe essere interessante e utile, ma non credo che le tue esigenze siano state capite da noi comuni mortali.

Ti va di spiegare meglio qual era il problema da risolvere, perché avevi deciso di risolverlo con un nuovo metodo da aggiungere alla classe Array, e magari postare il codice del metodo, così vediamo se si riesce ad astrarlo per ricondursi ad un problema generico?

[daneel]

Mi scuso se sono stato poco chiaro. Il problema in sostanza è questo: come posso, applicando ad un array (o anche ad un altro dato qualsiasi, ma a me interessano gli array) un prototipo da realizzare per l'occasione, risalire alla posizione dell'array di "livello superiore" che contiene l'oggetto per il quale ho utilizzato il metodo?

/* la posizione 0 dell'array chiamato matrice contiene
   un altro array, alla posizione 1 del quale applico
   il prototipo nuovoMetodo */

matrice[0][1].nuovoMetodo();

Array.prototype.nuovoMetodo = function(){
	/* qui devo risalire da this (la posizione 1
	   dell'array contenuto in matrice[1]) alla
	   posizione 0 dell'array matrice (matrice[0]) */
}

Preferirei non inviare per ora il codice del metodo per la gestione delle matrici; non fa altro che inserire con alcuni accorgimenti nuovi array all'interno di un array di partenza, esattamente come farei se scrivessi il codice a mano.

[daneel]

Un esempio un po' più chiaro.

matrice=new Array();
matrice[0]=new Array();
matrice[0][1]=new Array();

arraySuperiore=matrice[0][1].mioMetodo();

Il metodo non viene ovviamente chiamato in modo diretto, come faccio qui (altrimenti non avrebbe nessun senso).
Come valore di ritorno vorrei un qualche tipo di riferimento a matrice[0] (l'indice, ...).

[nosferatu_net]

Mmm...
A me sembra un po' un'assurdità a livello di concetto.
Mi spiego:

1- il metodo, se è della classe Array funziona solo se l'oggetto di cui vuoi conoscere il padre è esso stesso un array.
Se dentro c'hai un'altra cosa, il padre è sconosciuto e il tuo metodo non funge.

2- JavaScript è come Java: non puoi manipolare oggetti in modo diretto, ma solo puntatori agli stessi. Di conseguenza un oggetto in memoria può avere infiniti puntatori.
Bene. Ora ipotizziamo che abbiamo 2 puntatori alla stessa istanza di Array. Se uno e dentro una matrice e un'altro è fuori?!? L'oggetto a cui i due puntatori si riferiscono fa parte o no della matrice?
Tu parti dal presupposto fuorviante che un oggetto è contenuto in un array, quando in realtà un array è una banale lista di puntatori. Per continuare con il nostro assurdo, io posso anche avere un array che colleziona 1000 puntatori diversi allo stesso array "figlio". Quale comportamento dovrà avere il tuo metodo?
L'array vero e proprio non è figlio di nessuno, né può esserlo. Almeno a livello concettuale.

Esempio pratico:

var ar = new Array();
ar.push(new Array());
// ar[0] ora punta ad un'istanza di Array

var pippo = ar[0];
// ora pippo e ar[0] sono due puntatori distinti che
// si riferiscono alla stessa identica locazione di
// memoria: se ar[0].tuoMetodo() ritornasse 0, anche
// pippo.tuoMetodo() ritornerebbe 0 (sbagliando)

[standard]

nosferatu_net ha ragione,
come ti dicevo prima, non puoi intervenire direttamente sul prototipo dell'Array in questo caso, al massimo potresti farti un metodo apposta per la creazione di matrici (inserendo delle flag, come ti dicevo prima).
E' ovvio che anche in quel caso rimangono validi i discorsi di referenziazione fatti di nosferatu_net.

ciauz