dojo/regexp.js

  • Provides:

    • dojo.regexp
  • dojo.regexp

    • type
      Object
    • summary
      Regular expressions and Builder resources
  • dojo.regexp.escapeString

    • type
      Function
    • parameters:
      • str: (typeof String)
      • except: (typeof String)
        a String with special characters to be left unescaped
    • source: [view]
       return str.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(ch){
        if(except && except.indexOf(ch) != -1){
         return ch;
        }
        return "\\" + ch;
       }); // String
    • summary
      Adds escape sequences for special characters in regular expressions
  • dojo.regexp.buildGroupRE

    • type
      Function
    • parameters:
      • arr: (typeof Object|Array)
        A single value or an array of values.
      • re: (typeof Function)
        A function. Takes one parameter and converts it to a regular
        expression.
      • nonCapture: (typeof Boolean)
    • source: [view]
      define("dojo/regexp", ["dojo"], function(dojo) {
      dojo.getObject("regexp", true, dojo);




      dojo.regexp = {
       // summary: Regular expressions and Builder resources
      };




      dojo.regexp.escapeString = function(/*String*/str, /*String?*/except){
       // summary:
       //  Adds escape sequences for special characters in regular expressions
       // except:
       //  a String with special characters to be left unescaped


       return str.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, function(ch){
        if(except && except.indexOf(ch) != -1){
         return ch;
        }
        return "\\" + ch;
       }); // String
      };


      dojo.regexp.buildGroupRE = function(/*Object|Array*/arr, /*Function*/re, /*Boolean?*/nonCapture){
       // summary:
       //  Builds a regular expression that groups subexpressions
       // description:
       //  A utility function used by some of the RE generators. The
       //  subexpressions are constructed by the function, re, in the second
       //  parameter. re builds one subexpression for each elem in the array
       //  a, in the first parameter. Returns a string for a regular
       //  expression that groups all the subexpressions.
       // arr:
       //  A single value or an array of values.
       // re:
       //  A function. Takes one parameter and converts it to a regular
       //  expression.
       // nonCapture:
       //  If true, uses non-capturing match, otherwise matches are retained
       //  by regular expression. Defaults to false


       // case 1: a is a single value.
       if(!(arr instanceof Array)){
        return re(arr); // String
       }


       // case 2: a is an array
       var b = [];
       for(var i = 0; i < arr.length; i++){
        // convert each elem to a RE
        b.push(re(arr[i]));
       }


        // join the REs as alternatives in a RE group.
       return dojo.regexp.group(b.join("|"), nonCapture); // String
    • summary
      Builds a regular expression that groups subexpressions
    • description
      A utility function used by some of the RE generators. The
      subexpressions are constructed by the function, re, in the second
      parameter.  re builds one subexpression for each elem in the array
      a, in the first parameter. Returns a string for a regular
      expression that groups all the subexpressions.
    • returns
      String
  • dojo.regexp.group

    • type
      Function
    • parameters:
      • expression: (typeof String)
      • nonCapture: (typeof Boolean)
        If true, uses non-capturing match, otherwise matches are retained
        by regular expression.
    • source: [view]
       return "(" + (nonCapture ? "?:":"") + expression + ")"; // String
    • summary
      adds group match to expression
    • returns
      String
  • dojo

    • type
      Object
    • summary