Esiste un buon parser riutilizzabile che converte una stringa in una gerarchia di elenchi?

Question

Vorrei prendere una stringa come questa:

[One, Two[A, B[i, ii, iii, iv], C], Three]

E convertilo in una gerarchia di elenchi, in modo che se eseguo codice come il seguente:

Console.Write(myList[1][1][2]);

L'output sarà:

iii

Spero che questo sia un requisito abbastanza comune che ci sia un semplice codice di analisi scritto in C # questo.

Fammi sapere se la mia domanda potrebbe essere formulata in modo più chiaro.

Answer 1

XML o JSON sono metodi eccellenti per archiviare cose come questa.

Come ha detto Spence - questo è un problema difficile - non raccomando di fare il tuo.

Scorri verso il basso fino alla fine di quel link JSON per implementazioni nella maggior parte delle lingue.

Answer 2

Dovrei andare con un'espressione regolare. Le corrispondenze e le espressioni secondarie di sottostringa possono darti la ricorsione per ottenere i livelli di sub-sub -....

Usa qualcosa come /^\[(.+)\[$/ in preg per raccogliere un singolo livello di oggetti. Elaboralo fino a quando non ricevi più un livello, esplodi su "," dopo aver ottenuto il coraggio di una singola serie.

Dividi il risultato per un ','.

dovrebbe uscire come

• [Uno, Due [A, B [i, ii, iii, iv], C], Three]
  • Un
  • due
  • [A, B [i, ii, iii, iv], C]
    • A
    • B
    • [i, ii, iii, iv]
      • i
      • ii
      • III
      • IV
    • C
  • tre

Infine taglia gli spazi a sinistra / a destra per ottenere il risultato lucido.

Answer 3

Stai cercando array o elenchi?

Questo sarebbe estremamente difficile da fare con le stringhe poiché devi occuparti degli spazi, o l'uso di una virgola in un elemento ecc.

Se hai il controllo su ciò che è in questo elenco, ti suggerisco di guardare in XML o serializzazione binaria, che hanno librerie per aiutarti a farlo.

Answer 4

Non è una risposta pratica, ma se si è in grado di utilizzare la versione beta di .NET 4.0, è possibile esaminare Oslo (e gli strumenti successivi) che Microsoft sta sviluppando per DSL testuali, che sembra esattamente ciò di cui hai bisogno.

Answer 5

Il mio voto è anche per XML o JSON o un altro formato se hai la possibilità di controllare il formato. Ma a parte questo, ecco un'implementazione Python del parser perché ero annoiato.

class ExprParser(object):
current = []
list_stack = []

def __init__(self):
    pass

def parse(self,input):
    for atom in [s.strip() for s in input.split(',')]:
        self.parse_atom(atom)
    return self.current

def do_pushes(self,atom):
    """ Strip off the '[' and push new lists """
    i = 0
    while i < len(atom) and atom[i] == '[':
        self.push()
        i += 1
    return atom[i:]

def do_pops(self,atom):
    """ Pop the lists """
    i = 0
    while i < len(atom) and atom[i] == ']':
        self.pop()
        i += 1

def parse_atom(self,atom):
    push_start = atom.find('[')

    rest = self.do_pushes(atom[push_start:]) if push_start >= 0 else atom

    pop_start = rest.find(']')

    val = rest[:pop_start] if pop_start >= 0 else rest

    self.add(val)

    if pop_start >= 0:
        self.do_pops(rest[pop_start:])

def push(self):
    self.current = []
    self.list_stack.append(self.current)

def pop(self):
    done = self.list_stack.pop()
    self.current = self.list_stack[-1] if self.list_stack else done
    if self.current is not done:
        self.add(done)

def add(self,val):
    self.current.append(val)

Usa come:

parser = ExprParser()
parser.parse('[One, Two[A, B[i, ii, iii, iv], C], Three]')

Nessuna gestione degli errori però per input non valido.