«Still, things might have happened differently, had not the two dead men come out from under the stones and hushed the hot words in his throat. They led him quite gently from the cache, which he forgot to close. That consummation was reached; that something they had whispered to him in his dreams was about to happen. They guided him gently, very gently, to the woodpile, where they put the axe in his hands. Then they helped him shove open the cabin door, and he felt sure they shut it after him, or at least he heard it slam and the latch fall sharply into place. And he knew they were waiting just without, waiting for him to do his task.» [Jack London, In A Far Country]

• match:
  Its form is: STRING.match(RegExp)
  namely in our case:
  "Hallo folks, I said Hallo".match(/\w{5}/gi)
  Do not be fooled by the fact I included a so to name it physical string before it: it may hold a variable that holds as a value a string as well!
  It returns either keyword null if no match was found, or an Array indexed from zero onward, whose each entry is the text of the searched string. So:

  ---

  ---

• search:
  Its form is: STRING.search(RegExp)
  namely in our case:
  "Hallo folks, I said Hallo".match(/\w{5}/gi)
  It returns a number, either -1 if no match is found, or a positive number from zero onward representing the offset position in the string where the first occurency of the first match was found. In our example would return zero, for the first Hallo is at the very beginning. Try to put some word of less or more than 5 letters before it to see a different index number returned.
  So:

  ---

  ---

• You got it: we have a missing feature here: what if I want to return all the indexes of all the matches, even the ones that may be double (like Hallo in our example)? Strangely enough, no one thought of producing such a function despite its obvious utility and absence.
  United Scripters is here precisely for this. I made the function that does it.
  It is called imatch, i stands for Indexes in a php naming style this time, and the function wants two arguments: the first a String, the second a RegExp (if by chance you pass a String also as its second argument, it -would you guess?- compiles it!): standard invocation on our example:
  imatch("Hallo folks, I said Hallo" , /\w{5}/gi)
  There is a third possible arguments named flags: only if you pass a string as second argument instead than a RegExp object expression you may want to pass such third argument: it must be a string and include either a g or a i or both gi in case you want to add them as the modifiers argument to the compile method run to generate the RegExp out of the string. If you don't pass it and the second argument is still a String, no modifiers will be applied (and therefore the default compilation would not set the generated RegExp to global)!
  Example:
  imatch("Hallo folks, I said Hallo" , "\\w{5}" , "gi")
  Eventually, the fourth and last argument named doubleReturn, if passed and set as, for instance, number 1, would slightly modify the output, returning this time an array of two entries: the first entry is an array on its own holding once again the indexes of the matches, whereas the second entry is still again another array but this time holding the corresponding found matches.
  The arguments are obviously separated by a comma.
   
  The function returns either keyword null if no match was found at all, or an array whose each entry is the search equivalent index, but this time for each match: thus if you run in parallel first the built in match method and then my function, you will generate two identical arrays the one returned by match carrying the matches and the other one returned by my imatch, at the corresponding array indexes, the... positions!

  ---

  function imatch(string, regexp, flags, doubleReturn){/*october 2004 version*/ if(typeof(string)!="string" || !regexp){return null;}; flags=(flags && typeof(flags)=="string")?flags:""; var re=(typeof(regexp)=="string")?new RegExp(regexp, flags):regexp; var matches=string.match(re); if(!matches){return null;}; var found=0; var indexes=new Array(matches.length); for(var m=0; m < matches.length; m++){ found=string.substring(0, found).length; indexes[m]=found+string.substring(found).search(re); found=indexes[m]+matches[m].length; }; return (!doubleReturn)? indexes: [indexes, matches]; /*keep this comment to use freely http://www.unitedscripters.com */}

  ---

  Be warned that in the textfields below I set the scripts inside this file to be run always as global and case insensitive by default (if you use imatch with a string meant to be compiled, you'd have to pass the third argument named flag as "gi" to actually achieve this: but here, in this file, to simplify I set the option in our test form as always implicitly present and set to global and case insensitive)
   
  Also, I slightly rearranged our RegExp (taken from a form, therefore a string: the imatch function can work out whether it has to compile it or not); I rearranged it in this fashion:
  \b\w{5}\b
  Why?
  I added two pattern definitions: two \b which means word boundaries.
  Therefore our example regular expression now by and large means: search for something which is not a letter, followed by 5 letters, followed by something which is not a letter.
  If it weren't so and instead of number 5 you would have inserted number 4 (with the intention, for instance, to produce a match on the word "said" which is present in our string "Hallo folks, I said Hallo"), well you would have got not only 3 items, but as many as 4: in fact if you don't instruct a regular expression to match only whole words, it can match even substrings in the words, and therefore return not only "said" but even "Hall" "folk" and "Hall" again: in fact, all of them are strings of 4 letters, correct?
  Morale: you have to specify something more, if you want to get only those words that are composed of a x amount of letters and are also whole isolated words.

  ---

  no alert? »
  Matches appear here for your CONVENIENCE. imatch would not return matches though, but INDEXES of matches.

  ---

• test
  It has the following shape:
  aRegExp.test(STRING)
  It merely checks whether one instance of a given pattern is present and returns a boolean true of false.
  So consider these methods for searching a match as basically differing in this: the returned type:
  • match returns array (or null)
  • search returns number
  • test returns boolean (note also that unlike the previous two methods, it gets a STRING as an argument and a RegExp as the object it is invoked from)

  ---

  ---

• replace
  It has the following shape:
  String.replace(RegExp, replaceString)
  It just replaces the occurrences of the pattern RegExp passed as argument with the string passed as second argument (in between quotes, for it must be a String), if it finds any of them on the String. That simple (and useful!).
  Instance:
  aString.replace(/\b\w{5}\b/gi , "")
  which replaces all 5 letters long words with nothing: an empty string in this particular case; it is a standard procedure to remove words; of course, you could have inserted in between quotes a word.
  No, actually it doesn't let you specify the second argument as another Regular Expression: in fact a pattern as such is anonymous, so whereas you can find specific incarnations of a pattern to search for (and replace), you cannot replace it with a ghost (a pattern) but with something more concrete than just a pattern specification.
   
  Anyway it is not entirely true that replace does not let you specify as its second argument something similar to a regular expressions: it lets you in fact include a highly specific type of string which appears like this (when I say like this, I mean exactly like this, comrade):
  "$1 $2"
  Now, what is that?
  It is called backreferencing: if in a regular expression you include round brackets, they have a special meaning (and if you do not mean a round bracket as carrying the special meaning Regular Expressions attach to round brackets I?m going to explain to you, well: escape it pre-pending to it a \!): such meaning is: keep in memory the incarnation of the instance of the pattern segment included in between these parenthesis, if you found a match.
   
  So consider a RegExp like:
  /\(\w{4})\d{2}/
  meaning (regardless of how much sense it may have or have not: it is just a trivial example) get those patterns which are 4 letters followed by 2 numbers (d=digits); the round brackets would allow for the storage of the, let's call it so, subquery \w{4} (the parenthesized element indeed!) as if it were independent of the main query and should be appointed with a memory of it; storing, but storing where, you may be wondering?
  Well, we saw that every RegExp is an object (although I always sponsored against this lexicon "object", preferring to it structured data as I already stated on my essay on pointers): as such it can memorize properties: the mystery in this can last only as long as you ignore the names of these properties, by calling which you could read the values.
  We're going to see it better, although you're to see it in action in replace as well: parenthesis do let the RegExp object store and memorize elements on what it does, and one of these elements are the so called captured parenthesized elements whose names are as funny a thing like $1, $2, $3... and so on (funny if you never coded in Perl or Php, obviously: for in Perl and Php both all the names of variables start exactly with a dollar sign, believe it or not).
   
  Thus if you memorized as many as two of such captured elements, the replace method allows you by the syntax
  aString.replace(/(\w{5})(\d{2})/gi , "$1 $2")
  replace the first captured element with the second captured element thus performing an actual swapping! In our latest example, it would find matches like Helen67 and would turn them into 67Helen!
  Enjoy.
• Perhaps you got it again: we miss another logical dovetail to these methods: a method that allows you to split a String accordingly to a RegExp pattern.
  You guessed: here it is:

  ---

  function isplit(string, regexp, flags){ if(typeof(string)!="string" || !regexp){return null;}; var splitter="@#"; while(string.indexOf(splitter)!=-1){ splitter+="#"; }; flags=(flags && typeof(flags)=="string")?flags: (!isNaN(parseFloat(flags)))?"":"g"; string=string.replace( ((typeof(regexp)=="string")?new RegExp(regexp, flags):regexp), splitter ); return string.split(splitter); /*keep this comment to use freely http://www.unitedscripters.com */}

  ---

  It is called isplit and gets arguments as follows: input String, regexp, flags.
  This last one (flags) only if regexp is a string itself: flags defaults to ignite a global search (global split) if it is not passed at all.
  If it is passed as a Number, it would add no modifiers (an arguably senseless feature for if you want to split a string most of the time you want to split it after all the recurrences of the found matches, and not just after the first one enocuntered - which would be exactly what happens if you pass the regexp argument as a String and the flags as a Number).
  The returned type: it is either null if invalid arguments were provided, or an Array: if it is of one entry only [index 0], it is probably the very same string meaning it was found no match to split it with (the reason I return it in the shape of an array instead of just returning the string itself, is that by doing so I keep consistency with the output type -an array once again as you're to see- and thus I arguably spare you the time to scramble different functions to handle different outputs).
   
  If the function finds matches, it can remove them all (every split process, since it splits by a given element -in our case a... pattern!- excludes and drops off the splitting element/s: it is a split, not a join: a join includes the joiner whereas a split excludes the splitter) and would return an Array whose each entry [indexes from zero onward as usual for arrays] is the fragmented rests of the string (this may well include apparently empty items, for they may just be white spaces in the input string once removed the matches, or even those typical Regular Expression phantasmal start of line and end of line invisible "entities", showing up in the appearences of empty strings, much alike vampires become showing up like festering bats ya see...).
  Test it:

  ---

  no alert? »

• index: is a number, and is the first numerical index of the first match for the given RegExp pattern found inside String.
• [0]: is a string and is the matching text whose index is equivalent to index (see above)
• input: it is the entire String text of the original string. You wonder: I already knew that. Well, the idea is the one described by Danny Goodman in his exceptional JavaScript Bible (no comparison on earth as far as JavaScript is concerned, period):

  «The value of having [properties you already know stored] in the object, is that their contents are safely stowed in the [returned] object, w[hereas] the RegExp object and its properties [and the input String itself] may be modified soon by another call [process] to a regular expression method.»

  It is something I myself do often when I ideate my own functions: I try to return as much as possible, to be sure that either you pick only one data, or you can arguably find in the returned stuff some meat indeed.
• [1-x] namely array indexes from 1 onward such as [1] or [10]: each of them stores one parenthesized captured item (remember?): therefore I deem that exec is mainly useful exactly to store a relevant amount of captured sub-patterns!
• An example:
  var foo=/\b(\w{2})\b/.exec("Do you think I am sexy?");
  foo.input;
  foo.index;
  foo[0];
  foo[1];
  foo[NUMBER] //if any. Indexes exceeding the captured sets, return undefined.

1. Be read before and after the given Regular Expression has been run on a String (before it gets actually used, that is)
2. Read only after it has been engaged on some String, and as such these latter type of "used" Regular Expressions reflect only the relationships each of them entertained with the last string it has been employed upon, regardless of which method has called the given Regular Expression in: either a built in one or one crafted by yourself.
   Remember what I have said to you in the beginning? Regular Expressions are meant to be used.
   In fact as soon as they are used, their last usage stores in the Regular Expression object new information on the latest usage it underwent.
3. Let me stress it is critical you don't blur your mental focus out of the fact that a Regular Expression object is not an creature of the Aether, but an actual variable to which you have assigned the role or Regular Expression either by the syntax foo=new RegExp(), or igniting it directly as, say, foo=/stuff/gi
   Namely, this elusive "Regular Expression Object" is precisely, in this example, the variable you named foo! That is the object. The only competitor to such regular expression as embodied in the variable name (in our case foo) would be the keyword RegExp which is case sensitive and is the so called constructor object.
4. Last but not least, it may be useful to stress that the properties that are available to be used on a regular expression before it is run on a String by whatever method employing such regular expressions, can be read also after the regular expressions has been used.
   It is not true the vice versa: until a regular expressions doesn't get employed and engaged on the field at least once, you cannot read prior to some usage the properties defined as to be read only after at least one usage.
   Yeah, makes sense doesn't it? In fact when either you understand it or they explain it to you clearly, it does!