javascript.snip

# Prototype
snippet proto
  ${1:class_name}.prototype.${2:method_name} =
  function(${3:first_argument}) {
    ${4:// body...}
  };

# Function
snippet fun
  function ${1:function_name}(${2:argument}) {
    ${3:// body...}
  }

# Anonymous Function
snippet f
  function (${1}) {
    ${3}
  }${2:;}

# Immediate function
snippet (f
  (function (${1}) {
    ${3:/* code */}
  }(${2}));

# if
snippet if
  if (${1:true}) {
    ${2}
  }

# if ... else
snippet ife
  if (${1:true}) {
    ${2}
  } else {
    ${3}
  }

# tertiary conditional
snippet ter
  ${1:/* condition */} ? ${2:a} : ${3:b}

# switch
snippet switch
  switch (${1:expression}) {
    case '${3:case}':
      ${4:// code}
      break;
    ${5}
    default:
      ${2:// code}
  }

# case
snippet case
  case '${1:case}':
    ${2:// code}
    break;
  ${3}

# for (...) {...}
snippet for
  for (var ${2:i} = 0, l = ${1:arr}.length; $2 < l; $2 ++) {
    var ${3:v} = $1[$2];${4:}
  }

# for (...) {...} (Improved Native For-Loop)
snippet forr
  for (var ${2:i} = ${1:arr}.length - 1; $2 >= 0; $2 --) {
    var ${3:v} = $1[$2];${4:}
  }

# while (...) {...}
snippet wh
  while (${1:/* condition */}) {
    ${2:/* code */}
  }

# try
snippet try
  try {
    ${1:/* code */}
  } catch (${2:e}) {
    ${3:/* handle error */}
  }

# do...while
snippet do
  do {
    ${2:/* code */}
  } while (${1:/* condition */});

# Object Method
snippet :f
  ${1:method_name}: function (${2:attribute}) {
    ${4}
  }${3:,}

# setTimeout function
snippet timeout
  setTimeout(function () {${3}}${2}, ${1:10});

# Get Elements
snippet get
  getElementsBy${1:TagName}('${2}')${3}

# Get Element
snippet gett
  getElementBy${1:Id}('${2}')${3}

# console.log (Firebug)
snippet cl
  console.log(${1});

# return
snippet ret
  return ${1:result}

# for (property in object ) { ... }
snippet fori
  for (var ${1:prop} in ${2:Things}) {
    ${3:$2[$1]}
  }

# hasOwnProperty
snippet has
  hasOwnProperty(${1})

# docstring
snippet /**
  /**
   * ${1:description}
   *
   */

snippet @par
  @param {${1:type}} ${2:name} ${3:description}

snippet @ret
  @return {${1:type}} ${2:description}

# JSON.parse
snippet jsonp
  JSON.parse(${1:jstr});

# JSON.stringify
snippet jsons
  JSON.stringify(${1:object});

# self-defining function
snippet sdf
  var ${1:function_name} = function (${2:argument}) {
    ${3:// initial code ...}
    $1 = function ($2) {
      ${4:// main code}
    };
  };

# singleton
snippet sing
  function ${1:Singleton} (${2:argument}) {
    // the cached instance
    var instance;
    // rewrite the constructor
    $1 = function $1($2) {
      return instance;
    };
    // carry over the prototype properties
    $1.prototype = this;
    // the instance
    instance = new $1();
    // reset the constructor pointer
    instance.constructor = $1;
    ${3:// code ...}
    return instance;
  }

# Crockford's object function
snippet obj
  function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
  }

# Define multiple properties
snippet props
  var ${1:my_object} = Object.defineProperties(
    ${2:new Object()},
    {
      ${3:property} : {
        get : function $1_$3_getter() {
          // getter code
        },
        set : function $1_$3_setter(value) {
          // setter code
        },
        value        : ${4:value},
        writeable    : ${5:boolean},
        enumerable   : ${6:boolean},
        configurable : ${7:boolean}
      }
    }
  );

# Define single property
snippet prop
  Object.defineProperty(
    ${1:object},
    "${2:property}",
    {
      get : function $1_$2_getter() {
        // getter code
      },
      set : function $1_$2_setter(value) {
        // setter code
      },
      value        : ${3:value},
      writeable    : ${4:boolean},
      enumerable   : ${5:boolean},
      configurable : ${6:boolean}
    }
  );