Che cosa sto facendo di sbagliato con il mio regex?

Question

Sto cercando di catturare "Rio Grande do Leste" da:

...
<h1>Rio Grande Do Leste<br />
...

con

var myregexp = /<h1>()<br/;

var nomeAldeiaDoAtaque = myregexp.exec(document);

quello che sto facendo di sbagliato?

Aggiornamento:

2 domande rimangono:

1) la ricerca (documento) hanno ragione't produce alcun risultato, ma a cambiarlo con (document.body.innerHTML) ha funzionato. Perché?

2) ho dovuto cambiare a: myregexp.exec (document.body.innerHTML) [1] ; per ottenere ciò che voglio, altrimenti mi avrebbe dato qualche risultato, che comprende <h1>. perché?

3) (risposta) perché ho bisogno di usare "*"? Ho insegnato che sarebbe raccogliere qualcosa tra ()?

Answer 1

Prova /<h1>(.*?)<br/.

Answer 2

Il gruppo di cattura

un gruppo di cattura tentativi di cattura ciò che corrisponde . Questo ha delle conseguenze importanti:

• Un gruppo che corrisponde nulla, non può mai catturare qualsiasi cosa.
• Un gruppo che corrisponde solo a una stringa vuota, può catturare solo una stringa vuota.
• Un gruppo che cattura ripetutamente in un tentativo partita ottiene solo di mantenere l'ultima cattura
  • generalmente vero per la maggior parte i sapori, ma NET espressioni regolari è un'eccezione (vedi domanda relativa)

Ecco un semplice schema che contiene 2 gruppi di cattura:

(\d+) (cats|dogs)
\___/ \_________/
  1        2

Dato i have 16 cats, 20 dogs, and 13 turtles, ci sono 2 partite ( come visto in rubular.com ):

• 16 cats è una partita: gruppo 1 cattura 16, gruppo 2 cattura cats
• 20 dogs è una partita: gruppo 1 cattura 20, gruppo 2 cattura dogs

Ora consideriamo questa piccola modifica sul modello:

(\d)+ (cats|dogs)
\__/  \_________/
 1         2

Ora gruppo 1 partite \d, vale a dire una sola cifra. Nella maggior parte sapore, un gruppo che corrisponde ripetutamente (grazie alla + in questo caso) ottiene solo di mantenere l'ultima partita. Pertanto, nella maggior parte dei sapori, solo l'ultima cifra che è stato abbinato viene catturato dal gruppo 1 ( come visto in Rubular. it ):

• 16 cats è una partita: gruppo 1 cattura 6, gruppo 2 cattura cats
• 20 dogs è una partita: gruppo 1 cattura 0, gruppo 2 cattura dogs

Bibliografia

• regular-expressions.info/Use rotonde Staffe per catturare
• c'è un sapore regex che mi permette di contare il numero di ripetizioni corrispondenti da * e +?
  • NET espressioni regolari mantiene cattura intermedi!

---

Il avido vs riluttanti vs classe di caratteri negata

Consideriamo ora il problema della corrispondenza "tutto tra A e ZZ". Come si è visto, questa specifica è ambigua: faremo venire con 3 modelli che fa questo, e produrranno partite diverse. Quale è "corretto" dipende dalla aspettativa, che non è propriamente convogliata nella dichiarazione originale.

Usiamo la seguente come input:

eeAiiZooAuuZZeeeZZfff

Usiamo 3 modelli differenti:

• A(.*)ZZ cede 1 partita: AiiZooAuuZZeeeZZ ( come visto in ideone.com )
  • Questo è il avido variante; gruppo 1 accoppiati e iiZooAuuZZeee catturato
• A(.*?)ZZ cede 1 partita: AiiZooAuuZZ ( come visto in ideone.com )
  • Questo è il riluttanti variante; gruppo 1 accoppiati e iiZooAuu catturato
• A([^Z]*)ZZ cede 1 partita: AuuZZ ( come visto in ideone.com )
  • Questo è il classe di caratteri negata variante; gruppo 1 accoppiati e uu catturato

Ecco una rappresentazione visiva di ciò che essi abbinati:

         ___n
        /   \              n = negated character class
eeAiiZooAuuZZeeeZZfff      r = reluctant
  \_________/r   /         g = greedy
   \____________/g

Vedere domanda relativa per un trattamento più approfondita sulla differenza tra queste 3 tecniche.

Domande correlate

• Differenza tra .*? e .* per regex
  • Greedy vs riluttanti vs classe di caratteri negata, spiegazione dettagliata con esempi illustrativi

---

Tornando alla domanda

Quindi torniamo alla domanda e vedere cosa c'è di sbagliato con il modello:

<h1>()<br
    \/
     1

Gruppo 1 corrisponde alla stringa vuota, quindi l'intero schema generale può corrispondere solo <hr1><br, e il gruppo 1 può corrispondere solo la stringa vuota.

Si può cercare di "fissare" in molti modi diversi. I 3 quelli ovvi da provare sono:

• <h1>(.*)<br; avida
• <h1>(.*?)<br; riluttanti
• <h1>([^<]*)<br; classe di caratteri negata

Troverete che nessuno dei precedenti "lavoro" per tutto il tempo; ci saranno problemi con il linguaggio HTML. Questo è da aspettarselo: regex è lo strumento di "sbagliato" per il lavoro. Si può cercare di rendere il modello più complicato, per farlo "giusto" più spesso e "sbagliato" meno spesso. Più che probabile che vi ritroverete con un pasticcio orribile che nessuno può capire e / o mantenere, e sarebbe ancora probabilmente non funzionerà "giusto" il 100% del tempo.

Answer 3

o

^(<h1>)(.)+(<br />)

Vai qui per prova gskinner.com