JavaScript regex i riferimenti indietro che restituiscono una serie di corrispondenze dal singolo gruppo di acquisizione (più gruppi)

Question

Sono abbastanza sicuro dopo aver passato la notte a cercare una risposta che non è possibile, e ho sviluppato un lavoro in giro - ma, se qualcuno conosce un metodo migliore, mi piacerebbe sentirlo ...

Ho passato molte iterazioni sul codice, e il seguente è solo una linea di pensiero. Ad un certo punto stavo usando il flag globale, credo, in modo per match() al lavoro, e non mi ricordo se era necessario ora o meno.

var str = "@abc@def@ghi&jkl"; 
var regex = /^(?:@([a-z]+))?(?:&([a-z]+))?$/; 

L'idea qui, in questo codice semplificato, è il gruppo opzionale 1, di cui v'è una quantità specificata, corrisponderà @abc, @def e @ghi. Catturerà solo i caratteri alfa di cui ce ne sarà uno o più. Gruppo 2 è lo stesso, tranne corrispondenze su & simbolo. Dovrebbe anche essere ancorato all'inizio e alla fine della stringa.

Voglio essere in grado di eseguire tutte le partite di riferimento di entrambi i gruppi, vale a dire:

result = str.match(regex); 
alert(result[1]); //abc,def,ghi 
alert(result[1][0]); //abc 
alert(result[1][1]); //def 
alert(result[1][2]); //ghi 
alert(result[2]); //jkl 

Il mio compagno dice che questo funziona bene per lui in .net, purtroppo non riesco a farlo funzionare - solo l'ultima corrispondenza di qualsiasi gruppo viene restituito nel riferimento posteriore, come si può vedere nella seguente:

(aggiuntivo, rendendo entrambi i gruppi opzionale rende un disastro, come fa impostazione flag globale)

var str = "@abc@def@ghi&jkl"; 
var regex = /(?:@([a-z]+))(?:&([a-z]+))/; 

var result = str.match(regex); 

alert(result[1]); //ghi 
alert(result[1][0]); //g 
alert(result[2]); //jkl 

---

Quello che segue è la soluzione sono arrivato al, catturando tutta la parte in questione, e creare l'array stesso:

var str = "@abc@def@ghi&jkl"; 
var regex = /^([@a-z]+)?(?:&([a-z]+))?$/; 

var result = regex.exec(str); 

alert(result[1]); //@abc@def@ghi 
alert(result[2]); //jkl 

var result1 = result[1].toString(); 
result[1] = result1.split('@') 

alert(result[1][1]); //abc 
alert(result[1][2]); //def 
alert(result[1][3]); //ghi 
alert(result[2]); //jkl 

Answer 1

Questo non è semplicemente il modo .match() opere in JavaScript. L'array restituito è una matrice di stringhe semplici. Non c'è "annidamento" di gruppi di cattura; basta contare i ( simboli da sinistra a destra.

La prima stringa (all'indice [0]) è sempre la stringa corrispondente complessiva. Poi vengono i gruppi di cattura, una stringa (o null) per ogni elemento dell'array.

È possibile, come è stato fatto, riorganizzare l'array di risultati in base al contenuto del cuore. È solo un array.

modificare — oh, e la ragione per la vostra result[1][0] era "g" è che la notazione di matrice indicizzazione applicata a una stringa che ottiene i singoli caratteri della stringa.