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;
co/lo/vo →	const/let/var feature = {};
ca/la/va →	const/let/var feature = [];
cs/ls/vs →	const/let/var feature = '';
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
po →	property: { property, },	property object
pa →	property: [item],	property array
ps →	property: 'value',	property string

Statement

Prefix	Body	Description
if →	if (condition) { }
ife →	if (condition) { } else { }
ei →	else if (condition) { }
el →	else { }
swi →	switch () { case : statements; break; default: statements; break;}
cas →	case value: statements; 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(param) { }	function
fna →	function(param) { }	function anonymous
vfn →	var name = function (param) { }
lfn →	let name = function (param) { }
cfn →	const name = function (param) { }
fnp →	name: function (param) { }	function as property
fnapply →	method.apply(context, [param]);	function.apply
fncall →	method.call(context, param);	function.call
fnbind →	method.bind(this);	function.bind
af →	(param) => { }	arrow function
afr →	(param) => { return }	arrow function with return
afd →	({param}) => statement	arrow function with destructuring
laf →	let name = (param) => { }
caf →	const name = (param) => { }
iif →	;((param) => { })()
iife →	;(function (param) { })()
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);
ara →	iterable.at(index);	array.at
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((previousValue, currentValue) => { });
arrr →	iterable.reduceRight((accumulator, currentValue) => { });
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,
om →	method(param) { },	object method()
oset →	set property(value) { },	object set
oget →	get property() { },	object get
oam →	method: (param) => { },	object arrow method statements
oame →	method: (param) => $3,	object arrow method expression
oasm →	async method(param) { },	object async method()
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
tl →	${expression}	Template literals
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 operand === 'undefined'	typeof
tou →	typeof operand === 'undefined'	typeof Undefined
too →	typeof operand === 'object'	typeof Null
tob →	typeof operand === 'boolean'	typeof Boolean
ton →	typeof operand === 'number'	typeof Number
tob →	typeof operand === 'bigint'	typeof BigInt
tos →	typeof operand === 'string'	typeof String
tos →	typeof operand === 'symbol'	typeof Symbol
tof →	typeof operand === 'function'	typeof Function
too →	typeof operand === 'object'	typeof Any other object
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 { feature };	export
exas →	export { variable as feature };	export as renaming
exc →	export const name = value;
exfn →	export function name (){ }	export function
exaf →	export const name = (param) => { };	export named arrow function
exafe →	export const name = (param) => $3;	export named arrow function
exd →	export default expression;	export default
exdas →	export { name as default };
exdc →	export default class className { constructor (param) { } }
exdce →	export default class className extends baseClassName { constructor (param) { super(); } }
exdaf →	export default (param) => { }
exdafe →	export default (param) => $3
exdfn →	export default function name (param) { }
exfr →	export {default} from otherModule;	export from
exallo →	export * from otherModule;	export all from other module

Class

Prefix	Body	Description
cl →	class ClassName { constructor (param) { } }	class
cle →	class ClassName extends BaseClassName { constructor (param) { super(); } }	class extends
clc/cons →	constructor(param) { }	class constructor
p/clp →	property = value;	class property
m/clm →	method (param) { }	class method
clsm →	static methodName(param) { return; }	class static method()
clsp →	static property = value;	class static property
clpm →	#methodName(param) { return ; }	class private method()
clpp →	#property = value;	class private property
clspm →	static #methodName(param) { return ; }	class static private method()
clspp →	static #property = value;	class static private property
clgm →	*methodName(params) { yield ; }	class generator method()
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
asm →	async method(param) { }	async method
pc/protoc →	var Constructor = function(param) { };	prototype constructor
pm/protom →	Constructor.prototype.method = function (param) { };	prototype method

Promise

Prefix	Body	Description
pr →	const promise = new Promise((resolve, reject) => { });promise.then(result => { }).catch(error => { });	new Promise
pa →	const results = await Promise.all([promises]);	Promise.all
pan →	const result = await Promise.any([promises]);	Promise.any
pas →	const results = await Promise.allSettled([promises]);	Promise.allSettled
pra →	const result = await 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(param) { yield expression;}	generator function
gm →	*generator(param) { },	generator method
asgm →	async *generator(param) { },	generator method
y →	yield expression;
yg →	yield* expression();

Async

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

Symbol

Prefix	Body	Description
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
cm/map →	const resourceMap = new Map();
cs/set →	const resourceSet = new Set();
cwm/wm →	const resourceWeakMap = new WeakMap();
cws/ws →	const resourceWeakSet = new WeakSet();
	map.size
	map.clear()
	map.delete()
	map.forEach()
	map.get()
	map.has()
	map.set()
	map.entries()
	map.keys()
	map.values()
	weakmap.delete()
	weakmap.get()
	weakmap.has()
	weakmap.set()
	set.size
	set.add()
	set.clear()
	set.delete()
	set.forEach()
	set.has()
	set.entries()
	set.values()
	weakset.add()
	weakset.delete()
	weakset.has()

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.replace →	element.classList.replace('oldToken', 'newToken');
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();
cta →	console.table(object);
ct →	console.time('label'); console.timeEnd('label');
ctr →	console.trace(object);

Common Js/Node.js

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

Bdd Testing (Mocha, Jasmine, etc.)

test.<method>

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

License

MIT License

---

Donate