var urlReg     = /(\w+):\/\/([\w.]+)\/(\S*)/;
var myHomepage = "http://www.wanjilong.com/homepage";
var result     = myHomepage.match(urlReg);

console.log(result);
for (var i = 0, len = result.length; i < len; ++i) {
    console.log(i, result[i]);
}

var patt = new RegExp(pattern,modifiers);

或者，更简单的方法

var patt = /pattern/modifiers;

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      private static void showMatch(string text, string expr)
      {
         Console.WriteLine("The Expression: " + expr);
         MatchCollection mc = Regex.Matches(text, expr);
         foreach (Match m in mc)
         {
            Console.WriteLine(m);
         }
      }
      static void Main(string[] args)
      {
         string str = "make maze and manage to measure it";

         Console.WriteLine("Matching words start with 'm' and ends with 'e':");
         showMatch(str, @"\bm\S*e\b");
         Console.ReadKey();
      }
   }
}

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         string input       = "Hello   World   ";
         string pattern     = "\\s+";
         string replacement = " ";
         Regex rgx = new Regex(pattern);
         string result = rgx.Replace(input, replacement);

         Console.WriteLine("Original String: {0}", input);
         Console.WriteLine("Replacement String: {0}", result);    
         Console.ReadKey();
      }
   }
}

(function (a) {}).length            // 1
(function (a = 5) {}).length        // 0
(function (a, b, c = 5) {}).length  // 2

(function(...args) {}).length // 0

/**
 * 只计算最后一个有默认值参数之前的”未默认初始化“的参数的个数
 */
(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1

let x = 1;

function f(y = x) {   # 调用函数f时，参数形成一个单独的作用域
  let x = 2;          # 这一条语句　其实没用
  console.log(y);
}

f() // 1

let foo = 'outer';

function bar( func = () => foo ) {　　//　同理,foo是外层的
  let foo = 'inner';
  console.log(func());
}

bar(); // outer

var x = 1;
function foo( x, y = function() { x = 2; } ) {　　// 参数中的x是单独的作用域
  var x = 3;                                     // 函数内部的x是另一个作用域　　
  y();                                           // 执行y后，内部变量x和外部全局变量x的值都没变
  console.log(x);
}

foo() // 3
x // 1

var x = 1;
function foo(x, y = function() { x = 2; }) {
  x = 3;                                      　　// 内部变量x就指向第一个参数x
  y();
  console.log(x);
}

foo() // 2
x // 1

function foo(optional = undefined) { ··· }

// arguments变量的写法
function sortNumbers() {
  return Array.prototype.slice.call(arguments).sort();
}

// arguments对象不是数组，而是一个类似数组的对象。
// 所以为了使用数组的方法，必须使用Array.prototype.slice.call先将其转为数组。

-----------------------------------------------------------------------

// rest参数的写法
const sortNumbers = (...numbers) => numbers.sort();

// rest 参数就不存在这个问题，它就是一个真正的数组，数组特有的方法都可以使用。

// 数组参数的典型用法

function push(array, ...items) {
  items.forEach(function(item) {
    array.push(item);
    console.log(item);
  });
}

var a = [];
push(a, 1, 2, 3)

// 报错
function doSomething(value = 070) {
  'use strict';　　# 在执行这里前，如何处理参数是个问题
  return value;
}

'use strict';

function doSomething(a, b = a) {
  // code
}

const doSomething = (function () {
  'use strict';
  return function(value = 42) {
    return value;
  };
}());

function f(x) {
  if (x > 0) {
    return m(x)
  }
  return n(x);
}

function f() {
  let m = 1;
  let n = 2;
  return g(m + n);
}
f();

// 等同于
function f() {
  return g(3);
}
f();

// 等同于
g(3);

function addOne(a){
  var one = 1;
  function inner(b){
    return b + one;　　// 因为这里，所以被迫在调用inner时还需要保留住var one，也就不是tail call了
  }
  return inner(a);
}

function factorial(n) {
  if (n === 1) return 1;
  return n * factorial(n - 1);
}

factorial(5) // 120

--------------------------------------------------
改写成尾递归，只保留一个调用记录，复杂度由O(n) --> O(1) 。

function factorial(n, total) {
  if (n === 1) return total;
  return factorial(n - 1, n * total);
}

factorial(5, 1) // 120