Skip to content

common.md

Latest commit

 

History

History
605 lines (436 loc) · 12 KB

common.md

File metadata and controls

605 lines (436 loc) · 12 KB

Common Coding Style Guidelines

This is a set of coding conventions and rules for use in programming. This is basically for Javascript because we use Javascript grammer for all of projects.

Table of contents

Common important things

Formatting

Naming Conventions

Variables

Conditionals

Functions

Comments

Miscellaneous

Common important things

Please keep this in your mind.

Git Usage

Please commit your code as much as you can and describe comments in details as you can. All the day, please pull the codes from server when you start working.

Before you push code to server:

  1. Check your changes again if there is
  2. Pull the code

Formatting

You may want to use editorconfig.org to enforce the formatting settings in your editor. Use the Node.js Style Guide .editorconfig file to have indentation, newslines and whitespace behavior automatically set to the rules set up below.

Case Styles

  1. Camel Case (i.e: isComponentLoaded, ProfileHeader)
  2. Snake Case (i.e: USER_PROFILE_TYPE)
  3. Kebab Ccase (i.e: profile-id)

2 Spaces for indentation

Use 2 spaces for indenting your code and swear an oath to never mix tabs and spaces - a special kind of hell is awaiting you otherwise.

Newlines

Use UNIX-style newlines (\n), and a newline character as the last character of a file. Windows-style newlines (\r\n) are forbidden inside any repository.

No trailing whitespace

Just like you brush your teeth after every meal, you clean up any trailing whitespace in your JS files before committing. Otherwise the rotten smell of careless neglect will eventually drive away contributors and/or co-workers.

Use Semicolons

According to scientific research, the usage of semicolons is a core value of our community. Consider the points of the opposition, but be a traditionalist when it comes to abusing error correction mechanisms for cheap syntactic pleasures.

80 characters per line

Limit your lines to 80 characters. Yes, screens have gotten much bigger over the last few years, but your brain has not. Use the additional room for split screen, your editor supports that, right?

Not over 400 lines per file

Limit your file to 400 lines. Please split the file if you have to write more then 400 lines.

Use single quotes

Use single quotes, unless you are writing JSON.

Right:

let foo = 'bar';

Wrong:

let foo = "bar";

Opening braces go on the same line

Your opening braces go on the same line as the statement.

Right:

if (true) {
  console.log('winning');
}

Wrong:

if (true)
{
  console.log('losing');
}

Also, notice the use of whitespace before and after the condition statement.

Declare one variable per let statement

Declare one variable per let statement, it makes it easier to re-order the lines. However, ignore [Crockford][crockfordconvention] when it comes to declaring variables deeper inside a function, just put the declarations wherever they make sense.

Right:

let keys   = ['foo', 'bar'];
let values = [23, 42];

let object = {};
while (keys.length) {
  let key = keys.pop();
  object[key] = values.pop();
}

Wrong:

let keys = ['foo', 'bar'],
    values = [23, 42],
    object = {},
    key;

while (keys.length) {
  key = keys.pop();
  object[key] = values.pop();
}

React formatting

I recommend to use stateless-components rather then statefull-components.

Please split the components as much as you can. Keep in mind to put only one component per file.

Important: Always defind and check prop-types in all of components.

Please wrap all components with ().

Right:

return (
    <View>
        Some contents here.
    </View>
);

Wrong:

return <View>
    Some contents here.
</View>

Naming Conventions

Use lowerCamelCase for variables, properties and function names

Variables, properties and function names, not class based file names should use lowerCamelCase. They should also be descriptive. Single character variables and uncommon abbreviations should generally be avoided.

Right:

const adminUser = db.query('SELECT * FROM users ...');

profileHeaderUtils.js

Wrong:

const admin_user = db.query('SELECT * FROM users ...');

profile-header-utils.js
profile_header_utils.js

Use UpperCamelCase for class names

Class names and class based file names should be capitalized using UpperCamelCase.

Right:

function BankAccount() {
}

ProfileHeader.js
UserModel.js

Wrong:

function bank_Account() {
}

profileHeader.js
profile_header.js
profile-header.js

Use UPPERCASE for Constants

Constants should be declared as regular variables or static class properties, using all uppercase letters.

Right:

const SECOND = 1 * 1000;

function File() {
}
File.FULL_PERMISSIONS = 0777;

Wrong:

const Second = 1 * 1000;

function File() {
}
File.fullPermissions = 0777;

Variables

Object / Array creation

Use trailing commas and put short declarations on a single line. Only quote keys when your interpreter complains:

Right:

let a = ['hello', 'world'];
let b = {
  good: 'code',
  'is generally': 'pretty',
};

Wrong:

let a = [
  'hello', 'world'
];
let b = {"good": 'code'
        , is generally: 'pretty'
        };

Conditionals

Use the === operator

Programming is not about remembering stupid rules. Use the triple equality operator as it will work just as expected.

Right:

let a = 0;
if (a !== '') {
  console.log('winning');
}

Wrong:

let a = 0;
if (a == '') {
  console.log('losing');
}

Use multi-line ternary operator

The ternary operator should not be used on a single line. Split it up into multiple lines instead.

Right:

let foo = (a === b)
  ? 1
  : 2;

Wrong:

let foo = (a === b) ? 1 : 2;

Use descriptive conditions

Any non-trivial conditions should be assigned to a descriptively named variable or function:

Right:

let isValidPassword = password.length >= 4 && /^(?=.*\d).{4,}$/.test(password);

if (isValidPassword) {
  console.log('winning');
}

Wrong:

if (password.length >= 4 && /^(?=.*\d).{4,}$/.test(password)) {
  console.log('losing');
}

Functions

Write small functions

Keep your functions short. A good function fits on a slide that the people in the last row of a big room can comfortably read. So don't count on them having perfect vision and limit yourself to ~15 lines of code per function.

Return early from functions

To avoid deep nesting of if-statements, always return a function's value as early as possible.

Right:

function isPercentage(val) {
  if (val < 0) {
    return false;
  }

  if (val > 100) {
    return false;
  }

  return true;
}

Wrong:

function isPercentage(val) {
  if (val >= 0) {
    if (val < 100) {
      return true;
    } else {
      return false;
    }
  } else {
    return false;
  }
}

Or for this particular example it may also be fine to shorten things even further:

function isPercentage(val) {
  let isInRange = (val >= 0 && val <= 100);
  return isInRange;
}

Name your closures

Feel free to give your closures a name. It shows that you care about them, and will produce better stack traces, heap and cpu profiles.

Right:

req.on('end', function onEnd() {
  console.log('winning');
});

Wrong:

req.on('end', function() {
  console.log('losing');
});

No nested closures

Use closures, but don't nest them. Otherwise your code will become a mess.

Right:

setTimeout(function() {
  client.connect(afterConnect);
}, 1000);

function afterConnect() {
  console.log('winning');
}

Wrong:

setTimeout(function() {
  client.connect(function() {
    console.log('losing');
  });
}, 1000);

Method chaining

One method per line should be used if you want to chain methods.

You should also indent these methods so it's easier to tell they are part of the same chain.

Right:

User
  .findOne({ name: 'foo' })
  .populate('bar')
  .exec(function(err, user) {
    return true;
  });

Wrong:

User
.findOne({ name: 'foo' })
.populate('bar')
.exec(function(err, user) {
  return true;
});

User.findOne({ name: 'foo' })
  .populate('bar')
  .exec(function(err, user) {
    return true;
  });

User.findOne({ name: 'foo' }).populate('bar')
.exec(function(err, user) {
  return true;
});

User.findOne({ name: 'foo' }).populate('bar')
  .exec(function(err, user) {
    return true;
  });

Comments

Use slashes for comments

Use slashes for both single line and multi line comments. Try to write comments that explain higher level mechanisms or clarify difficult segments of your code. Don't use comments to restate trivial things.

Right:

// 'ID_SOMETHING=VALUE' -> ['ID_SOMETHING=VALUE', 'SOMETHING', 'VALUE']
let matches = item.match(/ID_([^\n]+)=([^\n]+)/));

// This function has a nasty side effect where a failure to increment a
// redis counter used for statistics will cause an exception. This needs
// to be fixed in a later iteration.
function loadUser(id, cb) {
  // ...
}

let isSessionValid = (session.expires < Date.now());
if (isSessionValid) {
  // ...
}

Wrong:

// Execute a regex
let matches = item.match(/ID_([^\n]+)=([^\n]+)/);

// Usage: loadUser(5, function() { ... })
function loadUser(id, cb) {
  // ...
}

// Check if the session is valid
let isSessionValid = (session.expires < Date.now());
// If the session is valid
if (isSessionValid) {
  // ...
}

Miscellaneous

Requires At Top

Always put requires and imports at top of file to clearly illustrate a file's dependencies. Besides giving an overview for others at a quick glance of dependencies and possible memory impact, it allows one to determine if they need a package.json file should they choose to use the file elsewhere.

Do not extend built-in prototypes

Do not extend the prototype of native JavaScript objects. Your future self will be forever grateful.

Right:

let a = [];
if (!a.length) {
  console.log('winning');
}

Wrong:

Array.prototype.empty = function() {
  return !this.length;
}

let a = [];
if (a.empty()) {
  console.log('losing empties');
}