JavaScript RegEx - returns result but still not working

Here is what you regular expression looks like, looking at it through an automaton:

So you're actually correctly matching what you want, but you're also capturing two groups:

1. "<!ELEMENT note (to,from,body)"
2. "note"

but it will also match other kind of strings, like:

• <!ELEMENT%e
(jmopV|)
• <!ELEMENT r()

which are not well formed tags.

So you'd better want to make a more precise regex , like:

<!ELEMENT\s+\w+\s+\((\w+, ?)*\w+\)>

• here's what the regex matches:
  • text <!ELEMENT
  • \s+ one or more space
  • \w+ one or more in word character
  • \s+ one or more space
  • \( a real parenthesis
  • ( begin of a group
  • \w+ on or more in word character
  • , a comma
  • ? one or zero space (could be * zero or more spaces)
  • )* end of the group, that group being matched zero or more times
  • \w+ one or more in word character
  • (you may want to add \s* if you want to match optional spaces before the closing parenthesis)
  • \) closing parenthesis character
  • (you may want to add \s* if you want to match optional spaces before the end of the tag)
  • > closing tag character

Then, when you do match(/<!ELEMENT\s+\w+\s+\((\w+, *)*\w+\)>/i), you will still get two groups:

1. "<!ELEMENT note (to,from,body)>"
2. "from,"

and you have to get the first group, you just need to get the first element of the returned array:

var match = "<!ELEMENT note (to,from,body)>".match(/<!ELEMENT\s+\w+\s+\((\w+, *)*\w+\)>/i);
if (match !== null)
    match = match[0];

and if you want to use the regexp object to do so:

pattern = new RegExp(/<!ELEMENT\s+\w+\s+\((\w+, *)*\w+\)>/i)
match = pattern.exec(text)
if (match !== null)
    match = match[0]

that will get you the first group of match (which is the full match).

AFTER EDIT:

you want a regex that works on this set of values:

<!ENTITY Aring "&amp;#197;" >,
<!ENTITY aring "&amp;#229;" >,
<!ENTITY agrave "&amp;#224;" >,
<!ENTITY aacute  "&amp;#225;" >,
<!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED>,
<!ATTLIST ARTICLE EDITOR CDATA #IMPLIED>,
<!ATTLIST ARTICLE DATE CDATA #IMPLIED>,
<!ATTLIST ARTICLE EDITION CDATA #IMPLIED>,
<!ELEMENT note (to,from,heading,body)>,
<!ELEMENT to (#PCDATA)>,
<!ELEMENT from (#PCDATA)>,
<!ELEMENT heading (#PCDATA)>,
<!ELEMENT body (#PCDATA)>

so you want a regex that looks like this one:

/<!ELEMENT\s+\w+\s+\((\#?\w+,\s*)*\#?\w+\s*\)\s*>/

look it up here

var match = "<!ELEMENT note (to,from,body)>".match(/<!ELEMENT\s+\w+\s+\((\#?\w+,\s*)*\#?\w+\s*\)\s*>/i);
if (match !== null)
    match = match[0];

there it matches only the <!ELEMENT... nodes, not the <!ATTLIST... or <!ENTITY... nodes. For those ones, match will be equal to null. For <!ELEMENT... nodes, they will contain the full string of the matched node.

Providing the note part is fixed:

var node = '<!ELEMENT note (to,from,body)>';
node.match(/<!ELEMENT note \(.+,.+,.+\)/); // Will alert the whole element

var invalidNode = '<!ELEMENTnote (to,from,body)>';
invalidNode.match(/<!ELEMENT note \(.+,.+,.+\)/); // Will return null

See: http://jsfiddle.net/a5KkF/

The answer to both is because you are using .*, which matches everything zero or more times.

Instead, use the following regular expression:

/<!(?:ELEMENT|ENTITY|ATTLIST)\s+\w+\s+.+>/i

Proof the regular expression works

A fiddle to further demonstrate this works

And a lovely image to illustrate how the match works:

To summarize, this matches the string <!, followed by either ELEMENT or ENTITY or ATTLIST, followed by 1 or more spaces (\s+), followed by 1 or more word characters (\w+), followed by 1 or more spaces, followed by one or more characters, followed by the closing bracket.

The reason you get note is capturing. Sets of parentheses make that part of the match available later (or within backreferences). Since you don't even need the parentheses for grouping, just remove them, if you don't want note.

Then your spaces are optional (due to the ?) - hence, removing them in the string does not matter at all. Simply remove the ? or make it a + (so that more than one space is allowed).

The other problem is, that . can match spaces as well. You should maybe be a bit more restrictive (this way you can also avoid ungreedy quantifiers, which are generally worse in performance):

/<!ELEMENT\s+\S*\s+\([^)]*\)>/i

\S matches anything except space character and [^)] matches anything except ) characters (it's a negated character class). In fact, you might want to exclude ( from the \S as well, because otherwise it could already match into the parentheses:

/<!ELEMENT\s+[^\s(]*\s+\([^)]*\)>/i

If the note part has to contain at least one character you should make that clear in the regex as well, by using + instead of *

/<!ELEMENT\s+[^\s(]+\s+\([^)]*\)>/i

If the note part is optional on the other hand, my earlier version requires at least 2 spaces (due to the two \s+). In that case, you could group the note part along with the following space and make it optional together. This way you only require the space, if note is there. To suppress capturing (so you don't get two strings again), use (?:...) for grouping instead of (...):

/<!ELEMENT\s+(?:[^\s(]+\s+)?\([^)]*\)>/i

Note that match will still give you an array containing the string you are looking for (and you can't do anything about that), so you'll have to access it with [0].