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

| |