JavaScript Snippets (Visual Studio Code)

Code snippets for JavaScript in ES3/5/6+ syntax;

Download this extension from the Visual Studio Code Marketplace.

Declarations
Statement
Function
Array
Object
String
Number
Regexp
chore
Module
Class
Promise
Generator Iterator
Async
Symbol
Maps & Sets
Error
Event
AJAX
Proxy & Reflection
Math
DOM
BOM
Console
CommonJS/Node.js
BDD Testing (Mocha, Jasmine, etc.)

Supported languages (file extensions)

JavaScript (.js)
TypeScript (.ts)
JavaScript React (.jsx)
TypeScript React (.tsx)
Html (.html)
Vue (.vue)

Snippets

Note: All the snippets include the final semicolon ;

Declarations

Prefix	Body	Description
`usm`	`'use strict';`	use strict mode
`c`	`const name = value;`
`cdo`	`const {} = ;`	const destructing object
`cda`	`const [] = ;`	const destructing array
`l`	`let name = value;`
`ldo`	`let {} = ;`
`lda`	`let [] = ;`
`v`	`var name = value;`
`vdo`	`var {} = ;`
`vda`	`var [] = ;`
`dp`	`{}: parameter`	destructuring parameter

Statement

Prefix	Body	Description
`if`	`if (condition) { }`
`ife`	`if (condition) { } else { }`
`ei`	`else if (condition) { }`
`el`	`else { }`
`swi`	`switch () { case : break; default: break;}`
`cas`	`case : break;`
`fin`	`for (const key in object) { if (object.hasOwnProperty(key)) { }}`	for-in
`fof`	`for (const item of object) { }`	for-of
`fl`, `fo`, `for`	`for (const index = 0, length = iterable.length; index < length; index += 1) { }`
`flr`, `forr`	`for (const length = iterable.length - 1; length >= 0; length -= 1) { }`	for loop iterable(reverse)
`wh`	`while (condition) { }`
`whi`	`let iterableIndex = array.lengthwhile (iterableIndexIndex--) { }`

Function

Prefix	Body	Description
`fn`	`function name (params) { }`	function
`fna`	`function (params) { }`	function anonymous
`vfn`	`var name = function (params) { }`
`lfn`	`let name = function (params) { }`
`cfn`	`const name = function (params) { }`
`fnp`	`name: function(params) { }`	function as property
`fnapply`	`method.apply(context, [params]);`	function.apply
`fncall`	`method.call(context, params);`	function.call
`fnbind`	`method.bind(this);`	function.bind
`af`	`(params) => { }`	arrow function
`afr`	`(params) => { return }`	arrow function with return
`afd`	`({params}) => statement`	arrow function with destructuring
`laf`	`let name = (params) => { }`
`caf`	`const name = (params) => { }`
`iif`	`;((params) => { })()`
`iife`	`;(function (params) { })()`
`nt`	`if (typeof new.target === 'undefined') { throw new Error('Fn() must be called with new');}`" ]}	new.target

Array

Arr.<static_method> or arr.<instance_method>

Prefix	Body	Description
`ar`	`const arr = [];`
`arl`	`iterable.length;`
`isa`	`Array.isArray(value)`
`arfr`	`Array.from(arrayLike);`
`arfr`	`Array.from(arrayLike, (item) => { });`
`arof`	`Array.of(elementN);`
`arc`	`iterable.concat(valueN);`	array.concat
`arcw`	`iterable.copyWithin(target, start, end);`	array.copyWithin
`are`	`iterable.entries();`	array.entries
`arev`	`iterable.every((element) => { });`	array.every
`arfill`	`iterable.fill(value, start, end);`
`arf`	`iterable.filter((element) => { });`
`arfi`	`iterable.find((element) => { });`
`arfin`	`iterable.findIndex((element) => { })`
`arflat`	`iterable.flat();`
`arflatMap`	`iterable.flatMap((value) => value);`
`fea`	`iterable.forEach((currentValue) => { });`	forEach callback with arrow function
`feai`	`iterable.forEach((currentValue, index) => { });`
`fe`	`iterable.forEach(function(currentValue) { });`
`fei`	`iterable.forEach(function(currentValue, index) { });`
`ari`	`iterable.includes(valueToFind)`
`ario`	`iterable.indexOf(searchElement)`
`arj`	`iterable.join(separator);`
`ark`	`iterable.keys();`
`arlio`	`iterable.lastIndexOf(searchElement)`
`map`	`iterable.map((currentValue) => { });`
`arp`	`iterable.pop();`
`arj`	`iterable.push(elementN);`
`arr`	`iterable.reduce((accumulator, currentValue) => { return });`
`arrr`	`iterable.reduceRight((accumulator, currentValue) => { return });`
`arre`	`iterable.reverse();`
`ars`	`iterable.shift();`
`arsl`	`iterable.slice(begin, end);`
`arso`	`iterable.some((element) => { });`
`arsor`	`iterable.sort((firstEl, secondEl) => { });`
`arsp`	`iterable.splice(start, deleteCount, item);`
`aru`	`iterable.unshift(elementN);`
`arv`	`iterable.values();`
`arr.@@iterator`		`Array.prototype[@@iterator]()`
`arr.@@species`		`get Array[@@species]`
`seq`	`[...Array(length).keys()]`

Object

Obj.<static_method> or obj.<instance_method>

Prefix	Body	Description
`ol`	`{ key: value }`
`kv`	`key: value,`
`oa`	`Object.assign(target, source);`
`oc`	`Object.create(obj);`
`odp`	`Object.defineProperty(dest, 'propertyName', { value: undefined, configurable: false, enumerable: false, writable: false})`	Object.defineProperty(data descriptors)
`odpa`	`Object.defineProperty(dest, 'propertyName', { get() { return value; }, set(newValue) { value = newValue; }, enumerable: false, configurable: false})`	Object.defineProperty(accessor descriptors)
`odps`	`Object.defineProperties(dest, { propertyName: { configurable: false, enumerable: false, value: undefined, writable: false }, propertyName: { get() { return value; }, set(newValue) { value = newValue; }, enumerable: false, configurable: false }});`	Object.defineProperties
`oe`	`Object.entries(obj);`
`of`	`Object.freeze(obj);`
`ofe`	`Object.fromEntries(iterable);`
`ogopd`	`Object.getOwnPropertyDescriptor(obj, 'propertyName');`	Object.getOwnPropertyDescriptor
`ogopds`	`Object.getOwnPropertyDescriptors(obj);`	Object.getOwnPropertyDescriptors
`ogopn`	`Object.getOwnPropertyNames(obj);`	Object.getOwnPropertyNames
`ogops`	`Object.getOwnPropertySymbols(obj);`	Object.getOwnPropertySymbols
`ogpo`	`Object.getPrototypeOf(obj);`	Object.getPrototypeOf
`oi`	`Object.is(value1, value2);`
`oie`	`Object.isExtensible(obj)`
`oif`	`Object.isFrozen(obj)`
`ois`	`Object.isSealed(obj)`
`ok`	`Object.keys(obj);`
`ope`	`Object.preventExtensions(obj);`
`os`	`Object.seal(obj);`
`ospo`	`Object.setPrototypeOf(obj, prototype);`	Object.setPrototypeOf
`ov`	`Object.values(obj);`
`hop`	`obj.hasOwnProperty(propertyName)`	hasOwnProperty
`ipo`	`prototypeObj.isPrototypeOf(object)`	isPrototypeOf
`pie`	`obj.propertyIsEnumerable(propertyName)`	propertyIsEnumerable
`tls`	`objects.toLocaleString();`	toLocaleString
`ts`	`objects.toString();`	toString
`vo`	`objects.valueOf();`	valueOf

String

Str.<static_method> or str.<instance_method>

Prefix	Body	Description
`sfcc`	`String.fromCharCode(numN)`	String.fromCharCode
`sfcp`	`String.fromCodePoint(numN)`
`sr`	`String.rawtemplateString`
`sca`	`str.charAt(index)`
`scca`	`str.charCodeAt(index)`
`scpa`	`str.codePointAt(position)`
`sc`	`str.concat(stringN)`
`sew`	`str.endsWith(searchString)`
`sin`	`str.includes(searchString)`
`sio`	`str.indexOf(searchValue)`
`slio`	`str.lastIndexOf(searchValue)`
`slc`	`str.localeCompare(compareString)`
`sm`	`str.match(regexp)`
`sma`	`str.matchAll(regexp)`
`sn`	`str.normalize('NFC')`
`spe`	`str.padEnd(targetLength, padString)`
`sps`	`str.padStart(targetLength, padString)`
`sr`	`str.repeat(count)`
`sre`	`str.replace(regexp, newSubStr)`
`ss`	`str.search(regexp)`
`ssl`	`str.slice(beginIndex, endIndex)`
`ssp`	`str.split(separator)`
`ssw`	`str.startsWith(searchString, position)`
`sss`	`str.substring(indexStart, indexEnd)`
`stllc`	`str.toLocaleLowerCase()`
`stluc`	`str.toLocaleUpperCase()`
`stlc`	`str.toLowerCase()`
`stuc`	`str.toUpperCase()`
`str`	`str.trim()`
`ste`	`str.trimEnd() //trimRight()`
`sts`	`str.trimStart() //trimLeft()`
`ssi`	`str[Symbol.iterator]`

Number

Num.<static_method> or num.<instance_method>

Prefix	Body
`ne`	`Number.EPSILON`
`nmasi`	`Number.MAX_SAFE_INTEGER`
`nmav`	`Number.MAX_VALUE`
`nmisi`	`Number.MIN_SAFE_INTEGER`
`nmav`	`Number.MIN_VALUE`
`nni`	`Number.NEGATIVE_INFINITY`
`nn`	`Number.NaN`
`npi`	`Number.POSITIVE_INFINITY`
`nif`	`Number.isFinite(value)`
`nii`	`Number.isInteger(value)`
`nin`	`Number.isNaN(value)`
`nisi`	`Number.isSafeInteger(value)`
`npf`	`Number.parseFloat(string)`
`npi`	`Number.parseInt(string)`
`nte`	`number.toExponential()`
`ntf`	`number.toFixed()`
`ntp`	`number.toPrecision()`

RegExp

re.<method>

Prefix	Body	Description
`re`	`let regex = RegExp('pattern');`	RegExp
`rep`	`let regex = /pattern/;`	RegExp pattern
`ree`	`let regex = RegExp('pattern');let result = regex.exec(str);`
`ret`	`let regex = RegExp('pattern');let result = regex.test(str);`
`re.@@species`		`get RegExp[@@species]`
`re.@@match`		`RegExp.prototype[@@match]()`
`re.@@matchAll`		`RegExp.prototype[@@matchAll]()`
`re.@@replace`		`RegExp.prototype[@@replace]()`
`re.@@search`		`RegExp.prototype[@@search]()`
`re.@@split`		`RegExp.prototype[@@split]()`

Chore

Prefix	Body	Description
`to`	`typeof object === 'undefined'`	typeof
`to<type>`	`typeof object === '<function\|string\|number\|boolean\|symbol>'`	typeof
`io`	`object instanceof 'constructor'`	instanceof
`jp`	`JSON.parse(obj);`
`js`	`JSON.stringify(obj);`
`tc`	`try { } catch (err) { }`
`tcf`	`try { } catch (err) { } finally { }`
`tf`	`try { } finally { }`
`r`	`return ;`
`rn`	`return null;`
`rt`	`return this;`
`ro`	`return { };`
`ternary`	`? : ;`
`de`/`bug`	`debugger;`
`eu`	`encodeURI(URI)`	encodeURI
`du`	`decodeURI(encodedURI)`	decodeURI
`euc`	`encodeURIComponent(str)`	encodeURIComponent
`duc`	`decodeURIComponent(encodedURI)`	decodeURIComponent

Module

Prefix	Body	Description
`im`	`import { moduleName } from 'module';`	import
`imd`	`import moduleName from 'module';`	import default export
`imas`	`import { originalName as alias } from 'module';`	import as renamed exports
`imall`	`import * as alias from 'module';`	import all module as alias
`imn`	`import 'module';`	import without module name
`ex`	`export {nameN};`	export
`exas`	`export {variable as name};`	export as renaming
`exl`	`export let name = value;`
`exc`	`export const name = value;`
`exfn`	`export function name (){ }`
`exafn`	`export const name = (params) => { };`	export named arrow function
`exd`	`export default expression;`	export default
`exdas`	`export {name as default};`
`exdc`	`export default class className { constructor (params) { } }`
`exdce`	`export default class className extends baseClassName { constructor (params) { super(); } }`
`exdaf`	`export default (params) => { }`
`exdfn`	`export default function name (params) { }`
`exfr`	`export {default} from otherModule;`	export from
`exallo`	`export * from otherModule;`	export all from other module

Class

Prefix	Body	Description
`cl`	`class name { constructor (params) { } }`	class
`cle`	`class className extends baseClassName { constructor (params) { super(); } }`	class extends
`cls`	`static create(params) { return new PersonClass(params);}`	class static
`cons`	`constructor(params) { }`	class constructor
`get`	`get propertyName () { return this.element; }`	get propertyName
`set`	`set propertyName (value) { this.element = value; }`	set propertyName
`gs`	`get propertyName () { return this.element; } set propertyName (value) { this.element = value; }`	getter and setter
`m`	`method (params) { }`	method
`asm`	`async method(params) { }`	async method
`protoc`	`var Constructor = function(params) { };`	prototype constructor
`protom`	`Constructor.prototype.method = function (params) { };`	prototype method

Promise

Prefix	Body	Description
`p`	`const promise = new Promise((resolve, reject) => { });promise.then(result => { }).catch(error => { });`	new promise
`pa`	`Promise.all([promises]);`	Promise.all
`pan`	`Promise.any([promises]);`	Promise.any
`pas`	`Promise.allSettled([promises]);`	Promise.allSettled
`pr`	`Promise.race([promises]);`	Promise.race
`prj`	`Promise.reject(value);`	Promise.reject
`prs`	`Promise.resolve(value);`	Promise.resolve
`rj`	`reject(err);`	reject
`rs`	`resolve(value);`	resolve
`pc`	`promise.catch(error => { });`	promise.catch
`pf`	`promise.finally(() => { });`	promise.finally
`pt`	`promise.then(result => { })`	promise.then()
`ptc`	`promise.then(result => { }).catch(error => { });`	promise.then().catch()
`ptcf`	`promise.then(result => { }).catch(error => { }).finally(() => { });`	promise.then().catch().finally()
`rp`	`return new Promise((resolve, reject) => { })`

Generator Iterator

Prefix	Body	Description
`cy`	`const name = yield value;`
`ly`	`let name = yield value;`
`gf`	`function* name(params) { yield ;}`	generator function
`y`	`yield expression;`
`yg`	`yield* expression;`

Async

Prefix	Body	Description
`caw`	`const result = await promise;`	const awaited
`law`	`let result = await promise;`
`asfn`	`async function name (params) { const result = await promise; return result;}name().then(result => { });`	async function named
`asfna`	`async function (params) { }`	async function anonymous
`asgfn`	`async function* name (params) { }`	async generator function named
`asgfna`	`async function* (params) { }`	async generator function anonymous
`asaf`	`async (params) => { }`	async arrow function
`aw`	`await promise`
`awpa`	`await Promise.all(value)`
`awpam`	`await Promise.all(array.map((value) => { }))`

Symbol

Prefix	Body	Description
lsy	`let symObj = Symbol();`
csy	`const symObj = Symbol();`
symf	`Symbol.for('key');`
symk	`Symbol.keyFor('symObj');`

Maps & Sets

map.<method>
weakmap.<method>
set.<method>
weakset.<method>

Prefix	Body	Description
`lm`	`let resourceMap = new Map();`
`ls`	`let resourceSet = new Set();`
`lwm`	`let resourceWeakMap = new WeakMap();`
`lws`	`let resourceWeakSet = new WeakSet();`
`cm`, `ma`	`const resourceMap = new Map();`
`cs`, `se`	`const resourceSet = new Set();`
`cwm`, `wm`	`const resourceWeakMap = new WeakMap();`
`cws`, `ws`	`const resourceWeakSet = new WeakSet();`

Error

throw.<Type>

Prefix	Body	Description
`tn`	`throw new Error('message')`
`tne`	`throw new EvalError('message')`
`tnr`	`throw new RangeError('message')`
`tnre`	`throw new ReferenceError('message')`
`tns`	`throw new SyntaxError('message')`
`tnt`	`throw new TypeError('message')`
`tnu`	`throw new URIError('message')`

Event

Prefix	Body	Description
`ael`	`document.addEventListener('type', event => { });`	addEventListener arrow function
`aelfn`	`document.addEventListener('type', function (event) { });`	addEventListener
`rel`	`document.removeEventListener('event', listener);`	removeEventListener
`eps`	`event.preventDefault();event.stopPropagation();return false;`	event preventDefault and stopPropagation
`epd`	`event.preventDefault();`	event preventDefault
`esp`	`event.stopPropagation();`	event stopPropagation
`dev`	`const cancelled = !target.dispatchEvent(event);`
`click`	`document.addEventListener('click', () => { });`
`keydown`	`document.addEventListener('keydown', event => { });`
`load`	`window.addEventListener('load', () => { });`
`ready`	`window.addEventListener('DOMContentLoaded', () => { });`

Ajax

Prefix	Body	Description
`xhr`		XMLHttpRequest
`fetch`		fetch
`fetchget`,`fg`		fetch get
`fetchpost`,`fp`		fetch post

Proxy & Reflection

proxy.<method>

Prefix	Body	Description
`proxy.set`		Validating Properties Using the `set` Trap
`proxy.get`		Object Shape Validation Using the `get` Trap
`proxy.has`		Hiding Property Existence Using the `has` Trap
`proxy.delete`		Preventing Property Deletion with the deleteProperty Trap
`proxy.prototype`		Prototype Proxy Traps
`proxy.extensibility`		Object Extensibility Traps
`proxy.property`		Property Descriptor Traps
`proxy.ownKeys`		The `ownKeys` Trap
`proxy.function`		Function Proxies with the `apply` and `construct` Traps
`proxy.revocable`		Revocable Proxies

Math

Prefix	Body	Description
`mr`	`Math.random()`
`mro`	`Math.round()`	20.49 → 20, 20.5 → 21
`mc`	`Math.ceil()`	7.004 → 8, -7.004 → -7
`mf`	`Math.floor()`	5.95 → 5, -5.05 → -6
`mtr`	`Math.trunc()`	5.05 → 5, -0.123 → -0

Dom

dom.<method> or dom.<property>

Prefix	Body
`dom.createDocumentFragment`	`document.createDocumentFragment();`
`dom.createElement`	`document.createElement(elem);`
`dom.createTextNode`	`document.createTextNode(data);`
`dom.getElementById`	`document.getElementById('id');`
`dom.getElementsByClassName`	`document.getElementsByClassName('className');`
`dom.getElementsByTagName`	`document.getElementsByTagName('tagName');`
`dom.querySelector`	`document.querySelector('selector');`
`dom.querySelectorAll`	`document.querySelectorAll('selector');`
`dom.childNodes`	`const nodeList = node.childNodes;`
`dom.parentElement`	`const parentElement = node.parentElement;`
`dom.parentNode`	`const parentNode = node.parentNode;`
`dom.firstChild`	`const childNode = node.firstChild;`
`dom.lastChild`	`const childNode = node.lastChild;`
`dom.previousSibling`	`const previousNode = node.previousSibling;`
`dom.nextSibling`	`const nextNode = node.nextSibling;`
`dom.textContent`	`element.textContent = 'content';`
`dom.previousElementSibling`	`const prevNode = NonDocumentTypeChildNode.previousElementSibling;`
`dom.nextElementSibling`	`const nextNode = NonDocumentTypeChildNode.nextElementSibling;`
`dom.closest`	`const closestElement = targetElement.closest('selectorString');`
`dom.insertBefore`	`node.insertBefore(newNode, referenceNode);`
`dom.appendChild`	`node.appendChild(element);`
`dom.cloneNode`	`const newClone = node.cloneNode(true);`
`dom.getRootNode`	`const root = node.getRootNode(true);`
`dom.compareDocumentPosition`	`const compareMask = node.compareDocumentPosition(otherNode);`
`dom.contains`	`node.contains(otherNode);`
`dom.removeChild`	`node.removeChild(child);`
`dom.replaceChild`	`parentNode.replaceChild(newChild, oldChild);`
`dom.hasChildNodes`	`node.hasChildNodes()`
`dom.firstElementChild`	`const element = parentNode.firstElementChild;`
`dom.lastElementChild`	`const element = parentNode.lastElementChild;`
`dom.childElementCount`	`const count = parentNode.childElementCount;`
`dom.children`	`const children = parentNode.children;`
`dom.append`	`parentNode.append(Nodes/DOMStrings);`
`dom.prepend`	`parentNode.prepend(Nodes/DOMStrings);`
`dom.before`	`childNode.before(Nodes/DOMStrings);`
`dom.after`	`childNode.after(Nodes/DOMStrings);`
`dom.remove`	`childNode.remove();`
`dom.replaceWith`	`childNode.replaceWith(Node/DOMString);`
`dom.before.html`	`element.insertAdjacentHTML('beforebegin', 'DOMString');`
`dom.after.html`	`element.insertAdjacentHTML('afterend', 'DOMString');`
`dom.prepend.html`	`element.insertAdjacentHTML('afterbegin', 'DOMString');`
`dom.append.html`	`element.insertAdjacentHTML('beforeend', 'DOMString');`
`dom.before.element`	`element.insertAdjacentElement('beforebegin', element);`
`dom.after.element`	`element.insertAdjacentElement('afterend', element);`
`dom.prepend.element`	`element.insertAdjacentElement('afterbegin', element);`
`dom.append.element`	`element.insertAdjacentElement('beforeend', element);`
`dom.before.text`	`element.insertAdjacentText('beforebegin', value);`
`dom.after.text`	`element.insertAdjacentText('afterend', value);`
`dom.prepend.text`	`element.insertAdjacentText('afterbegin', value);`
`dom.append.text`	`element.insertAdjacentText('beforeend', value);`
`dom.getClientRects`	`const rectCollection = element.getClientRects();`
`dom.getBoundingClientRect`	`const domRect = element.getBoundingClientRect();`
`dom.setAttribute`	`element.setAttribute('attrName', 'value');`
`dom.getAttribute`	`const attribute = element.getAttribute('attrName');`
`dom.hasAttribute`	`element.hasAttribute('attrName')`
`dom.removeAttribute`	`element.removeAttribute('attrName');`
`dom.toggleAttribute`	`element.toggleAttribute('attrName');`
`dom.matches`	`element.matches('selectorString')`
`dom.innerHTML`	`element.innerHTML = 'DOMString';`
`dom.outerHTML`	`element.outerHTML = 'DOMString';`
`dom.innerText`	`element.innerText = 'renderText';`
`dom.classList.add`	`element.classList.add('className');`
`dom.classList.contains`	`element.classList.contains('className');`
`dom.classList.remove`	`element.classList.remove('className');`
`dom.classList.toggle`	`element.classList.toggle('className');`
`dom.scroll`	`element.scroll({top, left, behavior: 'smooth'});`
`dom.scrollBy`	`element.scrollBy({top, left, behavior: 'smooth'});`
`dom.scrollTo`	`element.scrollTo({top, left, behavior: 'smooth'});`
`dom.scrollIntoView`	`element.scrollIntoView({behavior: 'smooth'});`
`dom.clientWidth`	`element.clientWidth`
`dom.clientHeight`	`element.clientHeight`
`dom.clientLeft`	`element.clientLeft`
`dom.clientTop`	`element.clientTop`
`dom.scrollWidth`	`element.scrollWidth`
`dom.scrollHeight`	`element.scrollHeight`
`dom.scrollLeft`	`element.scrollLeft`
`dom.scrollTop`	`element.scrollTop`
`dom.offsetWidth`	`HTMLElement.offsetWidth`
`dom.offsetHeight`	`HTMLElement.offsetHeight`
`dom.offsetTop`	`HTMLElement.offsetTop`
`dom.offsetLeft`	`HTMLElement.offsetLeft`
`dom.offsetParent`	`HTMLElement.offsetParent`

Bom

Prefix	Body	Description
`wa`	`window.alert('msg');`
`wc`	`window.confirm('msg');`
`wp`	`window.prompt('title', 'defaultText');`
`st`	`const timeout = window.setTimeout(() => { }, delay); window.clearTimeout(timeout);`	setTimeout
`stfn`	`var timeout = window.setTimeout(function() { }, delay); window.clearTimeout(timeout);`
`si`	`const timer = window.setInterval(() => { }, interval); window.clearInterval(timer);`	setInterval
`sifn`	`var timer = window.setInterval(function() { }, interval); window.clearInterval(timer);`
`lss`	`localStorage.setItem('key', 'value');`	localStorage.setItem
`lsg`	`localStorage.getItem('key');`
`lsr`	`localStorage.removeItem('key');`
`lsc`	`localStorage.clear();`
`wsaw`	`window.screen.availWidth`	window.screen.availWidth
`wsah`	`window.screen.availHeight`
`wsw`	`window.screen.width`
`wsh`	`window.screen.height`
`wlh`	`window.location.href`
`wlhn`	`window.location.hostname`
`wlp`	`window.location.pathname`
`wlpr`	`window.location.protocol`
`wls`	`window.location.assign(url)`
`whb`	`window.history.back();`
`whf`	`window.history.forward();`
`wnl`	`window.navigator.language`
`wnls`	`window.navigator.languages`
`wnu`	`window.navigator.userAgent`

Console

Prefix	Body	Description
`cd`	`console.dir();`	console.dir
`ce`	`console.error();`
`celb`	`console.error('foo: %o', foo);`
`ci`	`console.info();`
`clg`	`console.log();`	console.log
`clgl`	`console.log('foo: %o', foo);`
`cw`	`console.warn();`
`cwl`	`console.warn('foo: %o', foo);`
`ca`	`console.assert(expression, object);`
`cc`	`console.clear();`
`cco`	`console.count(label);`
`cg`	`console.group('label');`
`cge`	`console.groupEnd();`
`ct`	`console.table(object);`
`ctr`	`console.trace(object);`

Common Js/Node.js

Prefix	Body	Description
`ec`	`class name { constructor (params) { }} module.exports = name`
`em`	`exports.member = value`
`me`	`module.exports = name`
`rq`	`require('module')`
`crq`	`const module = require('module');`

Bdd Testing (Mocha, Jasmine, etc.)

Prefix	Body
`desc`	`describe('description', () => { })`
`cont`	`context('description', callback);`
`it`	`it('description', () => { })`
`ita`	`it('description', async (done) => { done();});`
`afe`	`afterEach(() => { })`
`bfe`	`beforeEach(() => { })`
`aft`	`after(() => { })`
`bf`	`before(() => { })`

License

MIT License

Donate

xianghongai@gmail.com

JavaScript Code Snippet

NicholasHsiang