Standard - JavaScript Style Guide, with linter & automatic code fixer

  •        66

Standard is a JavaScript style guide, with linter & automatic code fixer. This module saves you (and others!) time in three ways:

  • No configuration. The easiest way to enforce consistent style in your project. Just drop it in.
  • Automatically format code. Just run standard --fix and say goodbye to messy or inconsistent code.
  • Catch style issues & programmer errors early. Save precious code review time by eliminating back-and-forth between reviewer & contributor.

https://standardjs.com
https://github.com/standard/standard

Tags
Implementation
License
Platform

   




Related Projects


credo - A static code analysis tool for the Elixir language with a focus on code consistency and teaching


Credo is a static code analysis tool for the Elixir language with a focus on teaching and code consistency. It implements its own style guide.

lint-staged - 🚫💩 — Run linters on git staged files


Linting makes more sense when running before committing your code. By doing that you can ensure no errors are going into repository and enforce code style. But running a lint process on a whole project is slow and linting results can be irrelevant. Ultimately you only want to lint files that will be committed. This project contains a script that will run arbitrary npm and shell tasks with a list of staged files as an argument, filtered by a specified glob pattern.

luacheck - A tool for linting and static analysis of Lua code.


Luacheck is a static analyzer and a linter for Lua. Luacheck detects various issues such as usage of undefined global variables, unused variables and values, accessing uninitialized variables, unreachable code and more. Most aspects of checking are configurable: there are options for defining custom project-related globals, for selecting set of standard globals (version of Lua standard library), for filtering warnings by type and name of related variable, etc. The options can be used on the command line, put into a config or directly into checked files as Lua comments. Luacheck supports checking Lua files using syntax of Lua 5.1, Lua 5.2, Lua 5.3 and LuaJIT. Luacheck itself is written in Lua and runs on all of mentioned Lua versions.

continuation - A compiler for JavaScript asynchronous Continuation-Passing Style transformation


Continuation.js is a compiler for Continuation-Passing Style transformation, which simplifies asynchronous JavaScript programming. It translates slightly flavored JavaScript syntax into standard JavaScript, so it can be also called a "translator". Continuation.js introduces a virtual function cont, which allow you to write continuation-passing style code (or asynchronous callback style code) far easier. cont is not a actual function, but a mark with the same syntax to function calls in JavaScript. By using Continuation.js you can write asynchronous control flows like flat threaded code, and it compiles it into continuation-passing style code. The code above is flatted by using the virtual function cont. Control flow must "wait" for the return of asynchronous function call fs.readFile. Parameters in the argument list of cont will be set after it returns. "Return" here is a little confusing because in an asynchronous function "return" means callback function called, not "return" in the literal sense. An asynchronous function usually returns immediately (by encountering return statement or the end of the function scope) while the callback function could be called later. You can be understood as all the statements after cont until the end of the function are the callback function of the asynchronous function call. The code feels like threaded code, but it is still asynchronous while executing.

JSLint - The JavaScript Code Quality Tool


JSLint is a JavaScript program that looks for problems in JavaScript programs. It is a code quality tool. JSLint takes a JavaScript source and scans it. If it finds a problem, it returns a message describing the problem and an approximate location within the source. The problem is not necessarily a syntax error, although it often is. JSLint looks at some style conventions as well as structural problems. It does not prove that your program is correct.

Checkstyle - Checks Java coding standard


Checkstyle is a tool to help programmers write Java code that adheres to a coding standard. Checkstyle is highly configurable and can be made to support almost any coding standard. Checkstyle provides checks that find class design problems, duplicate code, or bug patterns like double checked locking. This tool could be integrated as Ant task.

JSHint - A Static Code Analysis Tool for JavaScript


JSHint is a community-driven tool to detect errors in JavaScript code and enforce your team's coding conventions.

javascript - JavaScript Style Guide


Note: this guide assumes you are using Babel, and requires that you use babel-preset-airbnb or the equivalent. It also assumes you are installing shims/polyfills in your app, with airbnb-browser-shims or the equivalent.1.1 Primitives: When you access a primitive type you work directly on its value.

Codelyzer - Static analysis for Angular projects.


A set of tslint rules for static code analysis of Angular TypeScript projects.You can run the static code analyzer over web apps, NativeScript, Ionic, etc.

yapf - A formatter for Python files


Most of the current formatters for Python --- e.g., autopep8, and pep8ify --- are made to remove lint errors from code. This has some obvious limitations. For instance, code that conforms to the PEP 8 guidelines may not be reformatted. But it doesn't mean that the code looks good.YAPF takes a different approach. It's based off of 'clang-format', developed by Daniel Jasper. In essence, the algorithm takes the code and reformats it to the best formatting that conforms to the style guide, even if the original code didn't violate the style guide. The idea is also similar to the 'gofmt' tool for the Go programming language: end all holy wars about formatting - if the whole codebase of a project is simply piped through YAPF whenever modifications are made, the style remains consistent throughout the project and there's no point arguing about style in every code review.

puppet-lint - Check that your Puppet manifests conform to the style guide


Puppet Lint tests Puppet code against the recommended Puppet language style guide. Puppet Lint validates only code style; it does not validate syntax. To test syntax, use Puppet's puppet parser validate command. Puppet Lint version 2 is the last planned version with support for Puppet 3 and Ruby 1.8.7. The next major version of Puppet Lint will drop support for these versions.

polyjuice - A utility to convert JSHint and JSCS files into ESLint files and vice-versa


Polyjuice is a utility that converts JSHint and JSCS files into ESLint files and the other way around. When using polyjuice.from.eslint an object with keys jscs and jshint is returned.

eslint-plugin-node - Additional ESLint's rules for Node.js


Note: It recommends a use of the "engines" field of package.json. The "engines" field is used by node/no-unsupported-features/* rules. eslint-plugin-node follows semantic versioning and ESLint's Semantic Versioning Policy.

node-style-guide - A guide for styling your node.js / JavaScript code. Fork & adjust to your taste.


This is a guide for writing consistent and aesthetically pleasing node.js code. It is inspired by what is popular within the community, and flavored with some personal opinions.There is a .jshintrc which enforces these rules as closely as possible. You can either use that and adjust it, or use this script to make your own.