Corrispondenza del modello avido / non avido e suffissi opzionali in Lua



0 Answers

Perché analizzare questo in un modello quando è possibile utilizzare diversi?

Innanzitutto, ottieni il numero:

local num, rest = string.match(test_string, "([%+%-]?%d+)%S*(.+)")

Quindi crea una tabella che enumeri le possibilità per il tipo di colpo.

local hitTypes =
{
  "Hit",
  "Critical Strike",
  -- Insert more.
}

Ora, scorrere l'elenco, testandoli contro ciascuno.

local hitIndex = nil
local reforge = nil

for i, htype in ipairs(hitTypes) do
  local final = string.match(rest, htype .. "%S*(.*)")
  if(final) then
    hitIndex = i
    reforge = string.match(final, "%(Reforged from (.+)%)")
  end
end

I modelli Lua sono limitati, quindi è meglio usare il codice reale per evitare i loro limiti.

Question

In Lua, sto provando a modellare la corrispondenza e catturare:

+384 Critical Strike (Reforged from Parry Chance)

come

(+384) (Critical Strike)

dove il suffisso (Reforged from %s) è facoltativo.

Versione lunga

Sto cercando di abbinare una stringa in Lua usando i pattern (cioè strfind )

Nota : in Lua non li chiamano espressioni regolari , li chiamano modelli perché non sono regolari .

Stringhe di esempio:

+384 Critical Strike
+1128 Hit

Questo è suddiviso in due parti che voglio catturare:

  • Il numero , con l'indicatore principale positivo o negativo; int il suo caso è +384
  • La stringa , in questo caso, è Critical Strike .

Posso catturarli usando un modello abbastanza semplice:

E questo modello in lua funziona:

local text = "+384 Critical Strike";
local pattern = "([%+%-]%d+) (.+)";
local _, _, value, stat = strfind(text, pattern);
  • valore = +384
  • stat = Critical Strike

The Tricky Part

Ora ho bisogno di espandere quel modello di espressioni regolari per includere un suffisso opzionale :

+384 Critical Strike (Reforged from Parry Chance)

Che è suddiviso in:

Nota: non mi interessa particolarmente il suffisso finale opzionale; il che significa che non ho alcun obbligo di catturarlo, anche se catturarlo sarebbe utile.

Questo è il punto in cui comincio a entrare nei problemi con l'acquisizione avida. Subito il modello che ho già fatto fa quello che non voglio:

  • pattern = ([%+%-]%d+) (.+)
  • valore = +384
  • stat = Critical Strike (Reforged from Parry Chance)

Ma proviamo a includere il suffisso nel pattern:

con il modello:

pattern = "([%+%-]%d+) (.+)( %(Reforged from .+%))?"

E sto usando il ? operatore per indicare 0 o 1 aspetto del suffisso ma che non corrisponde a nulla .

Ho provato ciecamente a cambiare il suffisso opzionale da parentesi ( tra parentesi [ :

pattern = "([%+%-]%d+) (.+)[ %(Reforged from .+%)]?"

Ma ora la partita è di nuovo avida:

  • valore = +384
  • stat = Critical Strike (Reforged from Parry Chance)

Basato sul riferimento del modello Lua ):

  • x : (dove x non è uno dei caratteri magici ^ $ ()%. [] * + -?) rappresenta il carattere x stesso.
  • . : (un punto) rappresenta tutti i caratteri.
  • % a : rappresenta tutte le lettere.
  • % c : rappresenta tutti i caratteri di controllo.
  • % d : rappresenta tutte le cifre.
  • % l : rappresenta tutte le lettere minuscole.
  • % p : rappresenta tutti i caratteri di punteggiatura.
  • % s : rappresenta tutti i caratteri dello spazio.
  • % u : rappresenta tutte le lettere maiuscole.
  • % w : rappresenta tutti i caratteri alfanumerici.
  • % x : rappresenta tutte le cifre esadecimali.
  • % z : rappresenta il carattere con rappresentazione 0.
  • % x : (dove x è un qualsiasi carattere non alfanumerico) rappresenta il carattere x. Questo è il modo standard per sfuggire ai personaggi magici. Qualsiasi carattere di punteggiatura (anche quello non magico) può essere preceduto da un '%' quando viene usato per rappresentare se stesso in un modello.
  • [set] : rappresenta la classe che è l'unione di tutti i caratteri nel set. È possibile specificare un intervallo di caratteri separando i caratteri finali dell'intervallo con un '-'. Tutte le classi% x descritte sopra possono anche essere utilizzate come componenti nel set. Tutti gli altri personaggi nel set rappresentano se stessi. Ad esempio, [% w_] (o [_% w]) rappresenta tutti i caratteri alfanumerici più il carattere di sottolineatura, [0-7] rappresenta le cifre ottali e [0-7% l% -] rappresenta le cifre ottali più il carattere minuscolo lettere più il carattere '-'. L'interazione tra intervalli e classi non è definita. Pertanto, modelli come [% az] o [a - %%] non hanno alcun significato.
  • [^ set] : rappresenta il complemento del set, dove set è interpretato come sopra.

Per tutte le classi rappresentate da singole lettere (% a,% c, ecc.), La lettera maiuscola corrispondente rappresenta il complemento della classe. Ad esempio,% S rappresenta tutti i caratteri non spaziali.

Le definizioni di lettera, spazio e altri gruppi di caratteri dipendono dalle impostazioni locali correnti. In particolare, la classe [az] potrebbe non essere equivalente a% l.

e gli incantatori di magia:

  • * , che corrisponde a 0 o più ripetizioni di caratteri nella classe. Queste voci di ripetizione corrisponderanno sempre alla sequenza più lunga possibile;
  • + , che corrisponde a 1 o più ripetizioni di caratteri nella classe. Queste voci di ripetizione corrisponderanno sempre alla sequenza più lunga possibile;
  • - , che corrisponde anche a 0 o più ripetizioni di caratteri nella classe. A differenza di "*", questi elementi di ripetizione corrispondono sempre alla sequenza più breve possibile;
  • ? , che corrisponde a 0 o 1 occorrenza di un personaggio nella classe;

Ho notato che c'è un modificatore avido * e non avido . Dal mio matcher per le corde di mezzo:

(%d) (%s) (%s)

sembra assorbire il testo fino alla fine, forse dovrei cercare di renderlo non-goloso , cambiando il * in a - :

oldPattern = "([%+%-]%d+) (.*)[ %(Reforged from .+%)]?"
newPattern = "([%+%-]%d+) (.-)[ %(Reforged from .+%)]?"

Tranne ora non riesce a eguagliare:

  • valore = +384
  • stat = nil

Invece del gruppo intermedio che cattura il carattere "qualsiasi" (es . ), Ho provato un set che contiene tutto tranne ( :

pattern = "([%+%-]%d+) ([^%(]*)( %(Reforged from .+%))?"

e da lì le ruote uscirono dal carro:

local pattern = "([%+%-]%d+) ([^%(]*)( %(Reforged from .+%))?"
local pattern = "([%+%-]%d+) ((^%()*)( %(Reforged from .+%))?"
local pattern = "([%+%-]%d+) (%a )+)[ %(Reforged from .+%)]?"

Pensavo di essere vicino a:

local pattern = "([%+%-]%d+) ([%a ]+)[ %(Reforged from .+%)]?"

che cattura

- value = "+385"
- stat = "Critical Strike "  (notice the trailing space)

Quindi qui è dove sbatto la testa contro il cuscino e vado a dormire; Non posso credere di aver passato quattro ore su questo modello regolare ...

@NicolBolas L'insieme di tutte le stringhe possibili, definite usando un linguaggio di espressione pseudo-regolare, sono:

+%d %s (Reforged from %s)

dove

  • + rappresenta il segno più ( + ) o il "segno meno" ( - )
  • %d rappresenta qualsiasi carattere di caratteri latini (es. 0..9 )
  • %s rappresenta lettere maiuscole o minuscole latine o spazi incorporati (ad es. A-Za-z )
  • i caratteri rimanenti sono letterali.

Se dovessi scrivere un'espressione regolare che ovviamente cerca di fare ciò che voglio:

\+\-\d+ [\w\s]+( \(Reforged from [\w\s]+\))?

Ma posso darti quasi un elenco completo di tutti i valori che probabilmente incontrerò in natura se non lo spiegassi abbastanza bene.

  • +123 Parry Numero +123 Parry positivo, parola singola
  • +123 Critical Strike Numero positivo di +123 Critical Strike , due parole
  • -123 Parry numero negativo, singola parola
  • -123 Critical Strike Numero -123 Critical Strike negativo, due parole
  • +123 Parry (Reforged from Dodge) numero positivo, singola parola, suffisso opzionale presente con una sola parola
  • +123 Critical Strike (Reforged from Dodge) numero positivo, due parole, suffisso opzionale presente con due parole
  • -123 Parry (Reforged from Hit Chance) numero negativo, singola parola, suffisso opzionale presente con due parole
  • -123 Critical Strike (Reforged from Hit Chance) numero negativo, due parole, suffisso opzionale presente con due parole

Ci sono schemi bonus che sembrerebbero ovvi che anche i pattern corrispondessero:

  • +1234 Critical Strike Chance numero a quattro cifre, tre parole
  • +12345 Mount and run speed increase numero di cinque cifre, cinque parole
  • +123456 Mount and run speed increase numero di sei cifre, cinque parole
  • -1 MoUnT aNd RuN sPeEd InCrEaSe un numero di cifre, cinque parole
  • -1 HiT (Reforged from CrItIcAl StRiKe ChAnCe) numero negativo di una cifra, una parola, suffisso opzionale presente con 3 parole

E mentre il modello ideale dovrebbe corrispondere alle voci bonus sopra, non è necessario .

Localizzazione

In realtà tutti i "numeri" che sto tentando di analizzare saranno localizzati, ad es .:

  • +123,456 in inglese (en-US)
  • +123.456 in Germania (de-DE)
  • +123'456 in francese (fr-CA)
  • +123 456 in estone (et-EE)
  • +1,23,456 in Assamese (come-IN)

Qualsiasi risposta non deve tentare di tenere conto di questi problemi di localizzazione. Non si conosce il luogo in cui verrà presentato un numero, per cui la localizzazione del numero è stata rimossa dalla domanda. È necessario assumere che i numeri contengano il plus sign , il hyphen minus e le cifre latine da 0 a 9 . So già come analizzare i numeri localizzati. Questa domanda riguarda il tentativo di abbinare il suffisso opzionale con un parser di pattern avidi.

Modifica : non dovevi davvero provare a gestire il numero localizzato. A un certo livello, provare a gestirli, senza conoscere il locale, è sbagliato. Ad esempio, non ho incluso tutte le possibili localizzazioni di numeri. Per un altro: non so quali potrebbero essere le future localizzazioni in futuro.




Related



Tags

lua lua