Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/capaj/vscode-standardjs-snippets below:

capaj/vscode-standardjs-snippets: a complete set of Javascript snippets for Visual Studio Code

Optinionated set of JS snippets. Originally forked from https://github.com/gaboesquivel/atom-standardjs-snippets, but we've added couple more. Also these are not using special characters because vscode doesn't accept them in the snippets.

A collection of javascript and react snippets for faster JavaScript development in Visual studio Code.

This collection is complementary to atom/language-javascript. It's based on extrabacon/atom-turbo-javascript.

Yes!, no semicolons:

• Are Semicolons Necessary in JavaScript?
• An Open Letter to JavaScript Leaders Regarding Semicolons
• JavaScript Semicolon Insertion - Everything You Need to Know

Snippets are optimized to be short and easy to remember. Shortest are the ones you should be using most often. Note that these links work only on github, not on VSCode marketplace:

• declarations
• flow control
• functions
• iterables
• objects and classes
• returning values
• types
• promises
• ES6 modules
• testing
• console
• timers
• DOM
• Node.js
• miscellaneous

var ${1:name} = ${2:value}

let ${1:name} = await ${2:value}

let ${1:name} = yield ${2:value}

const { ${1:name} } = ${2:value}

const ${1:name} = await ${2:value}

const { ${1:name} } = await ${2:value}

const ${1:name} = (${2:arguments}) => {\n\treturn ${0}\n}

const ${1:name} = yield ${2:value}

if (${1:condition}) {
  ${0}
}

${1:cond} ? ${2:true} : ${3: false}

const ${0} = ${1:cond} ? ${2:true} : ${3: false}

if (${1:condition}) {
  ${0}
} else {

}

else if (${1:condition}) {
  ${0}
}

for (let ${1:i} = 0, ${2:len} = ${3:iterable}.length ${1:i} < ${2:len}; ${1:i}++) {
  ${0}
}

for (let ${1:key} in ${2:source}) {
  if (${2:source}.hasOwnProperty(${1:key})) {
    ${0}
  }
}

for (const ${1:key} of ${2:source}) {
  ${0}
}

while (${1:condition}) {
  ${0}
}

let ${1:array}Index = ${1:array}.length
while (${1:array}Index--) {
  ${0}
}

try {
 ${0}
} catch (${1:err}) {

}

try {
  ${0}
} catch (${1:err}) {

} finally {

}

function (${1:arguments}) {${0}}

function ${1:name}(${2:arguments}) {
  ${0}
}

async function (${1:arguments}) {
  ${0}
}

async (${1:arguments}) => {
  ${0}
}

;(function (${1:arguments}) {
  ${0}
})(${2})

very useful when you don't have top level await(node 16 and lower)

;(async (${1:arguments}) => {
  ${0}
})(${2})

(${1:arguments}) => ${2:statement}

({${1:arguments}}) => ${2:statement}

({${1:arguments}}) => ${1:arguments}

(${1:arguments}) => {
  ${0}
}

(${1:arguments}) => {
  return ${0}
}

(${1:arguments}) => ({
  ${0}
})

function* (${1:arguments}) {
  ${0}
}

function* ${1:name}(${1:arguments}) {
  ${0}
}

${1:iterable}.forEach((${2:item}) => {
  ${0}
})

${1:iterable}.map((${2:item}) => {
  ${0}
})

${1:iterable}.map((${2:item}) => ${2:item})

${1:iterable}.reduce((${2:previous}, ${3:current}) => {
  ${0}
}${4:, initial})

${1:iterable}.filter((${2:item}) => {
  ${0}
})

${1:iterable}.find((${2:item}) => {
  ${0}
})

${1:iterable}.every((${2:item}) => {
  ${0}
})

${1:iterable}.some((${2:item}) => {
  ${0}
})

class ${1:name} {
  constructor(${2:arguments}) {
    ${0}
  }
}

class ${1:name} extends ${2:base} {
  constructor(${2:arguments}) {
    super(${2:arguments})
    ${0}
  }
}

${1:method} (${2:arguments}) {
  ${0}
}

get ${1:property} () {
  ${0}
}

set ${1:property} (${2:value}) {
  ${0}
}

get ${1:property} () {
  ${0}
}
set ${1:property} (${2:value}) {

}

${1:Class}.prototype.${2:methodName} = function (${3:arguments}) {
  ${0}
}

Object.assign(${1:dest}, ${2:source})

Object.getOwnPropertyDescriptor(${1:dest}, '${2:prop}')

Object.defineProperty(${1:dest}, '${2:prop}', {
  ${0}
})

return (${1:arguments}) => ${2:statement}

return new Promise((resolve, reject) => {
  ${0}
})

typeof ${1:source} === '${2:undefined}'

${1:source} instanceof ${2:Object}

Array.isArray(${1:source})

new Promise((resolve, reject) => {
  ${0}
})

${1:promise}.then((${2:value}) => {
  ${0}
})

${1:promise}.catch(error => {
  ${0}
})

export default ${1:member}

export default function ${1:name} (${2:arguments}) {\n\t${0}\n}

export const ${1:member} = ${2:value}

export function ${1:member} (${2:arguments}) {\n\t${0}\n}

import ${1:*} from '${2:module}'

import ${1:*} as ${2:name} from '${3:module}'

import { $1 } from '${2:module}'

describe('${1:description}', function () {
  ${0}
})

describe('${TM_FILENAME_BASE}', function () {
  ${0}
})

it('${1:description}', async () => {
  ${0}
})

it('${1:description}', (done) => {
  ${0}
})

it('${1:description}', () => {
  ${0}
})

before(function () {
  ${0}
})

beforeEach(function () {
  ${0}
})

after(function () {
  ${0}
})

afterEach(function () {
  ${0}
})

setTimeout(() => {
  ${0}
}, ${1:delay})

setTimeout(() => {
  ${0}
}, ${1:delay})

setImmediate(() => {
  ${0}
})

${1:document}.addEventListener('${2:event}', ${3:ev} => {
  ${0}
})

${1:document}.removeEventListener('${2:event}', ${3:listener})

ev.preventDefault()
ev.stopPropagation()
return false

${1:document}.getElementById('${2:id}')

Array.from(${1:document}.getElementsByClassName('${2:class}'))

Array.from(${1:document}.getElementsByTagName('${2:tag}'))

${1:document}.querySelector('${2:selector}')

Array.from(${1:document}.querySelectorAll('${2:selector}'))

${1:document}.createDocumentFragment(${2:elem});

${1:document}.createElement(${2:elem});

${1:document}.appendChild(${2:elem});

${1:document}.removeChild(${2:elem});

${1:document}.classList.add('${2:class}');

${1:document}.classList.toggle('${2:class}');

${1:document}.classList.remove('${2:class}');

${1:document}.getAttribute('${2:attr}');

${1:document}.setAttribute('${2:attr}', ${3:value});

${1:document}.removeAttribute('${2:attr}');

function (err, ${1:value}) {
  if (err) throw err
  t${0}
}

const ${1:module} = require('${1:module}')

exports.${1:name} = ${2:value}

module.exports = ${1:name}

${1:emitter}.on('${2:event}', (${3:arguments}) => {
  ${0}
})

await Promise.all(${1:value})

await Promise.all(${1:array}.map((async ${2:value}) => {\n\t${0}\n}))

await new Promise((r) => setTimeout(r, ${0}))

console.log('${0}:', ${0})

Are only enabled in jsx or tsx files. If you write your jsx in js files, you need to copy the react.json files manually and add it to your custom snippets.

If you're not writing react, including them should not really bother you because they are not short as the regular JS snippets. Also IMHO react is the leading solution for FE apps deserves to be included by default, because any JS dev will have to write some react eventually over the course of his/her careeer. By having them in a single package we can easily make sure --there aren't any conflicts in the trigger prefixes.

• JavaScript (.js)
• TypeScript (.ts)
• JavaScript React (.jsx)
• TypeScript React (.tsx)

These were originally taken from https://github.com/TimonVS/vscode-react-standard because the maintainer wasn't able to publish a new version for months even when there was a considerable flaw in the released version. Below is a list of all available snippets and the triggers of each one.

There are also snippets to be triggered with a text selection(trigger via insert snippet command):

jsx element wrap selection

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4