package.json

{
  "name": "ionicabizau-code-style",
  "version": "1.0.12",
  "description": "Or how I build things.",
  "main": "lib/index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/IonicaBizau/code-style.git"
  },
  "keywords": [
    "code",
    "style",
    "ionicabizau"
  ],
  "author": "Ionică Bizău <bizauionica@gmail.com> (https://ionicabizau.net)",
  "license": "MIT",
  "bugs": {
    "url": "https://github.com/IonicaBizau/code-style/issues"
  },
  "homepage": "https://github.com/IonicaBizau/code-style#readme",
  "blah": {
    "title": ":book: Ionică Bizău's Code Style :heart:",
    "show_description": false,
    "description": [
      {
        "p": [
          "This document contains guides that *I* defined and follow when building things.",
          "[Open issues](/code-style/issues) with any questions, ideas, fixes etc. :innocent:"
        ]
      },
      {
        "h1": "Contents"
      },
      {
        "ul": [
          [
            "[Variable declarations](#variable-declarations-pencil)",
            {
              "ul": [
                "[Variables](#variables-speech_balloon)",
                "[Constants](#constants-triangular_flag_on_post)",
                "[Globals](#globals-earth_africa)"
              ]
            }
          ],
          "[Semicolons](#semicolons-pencil2)",
          "[Method and property definitions](#method-and-property-definitions-paperclip)",
          "[Deleting properties](#deleting-properties-x)",
          "[`eval()`](#eval)",
          "[Iterating objects and arrays](#iterating-objects-and-arrays)",
          "[Multiline strings](#multiline-strings-guitar)",
          "[Modifying prototypes of built-in objects](#modifying-prototypes-of-built-in-objects-shit)",
          "[Naming things](#naming-things-thought_balloon)",
          "[Curly braces](#curly-braces-curly_loop)",
          "[Array and Object Initializers](#array-and-object-initializers-file_folder)",
          "[Commas](#commas)",
          "[Blank lines](#blank-lines)",
          "[Binary and Ternary operators](#binary-and-ternary-operators)",
          "[Quotes](#quotes-speech_balloon)",
          "[Comments](#comments-notes)",
          "[Project naming](#project-naming)"
        ]
      },
      {
        "h2": "Variable declarations :pencil:"
      },
      {
        "h3": "Variables :speech_balloon:"
      },
      {
        "p": "Using `var` in general or `let` when they should be accesible only in specific blocks (e.g. `if`)."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "// One declaration",
            "var foo = 1;",
            "",
            "// Multiple declarations",
            "var foo = 1",
            "  , bar = \"Hello World\"",
            "  , anotherOne = [{ foo: \"bar\" }]",
            "  ;",
            "",
            "if (...) {",
            "   let baz = 42;",
            "  /* do something with baz */",
            "}"
          ]
        }
      },
      {
        "h3": "Constants :triangular_flag_on_post:"
      },
      {
        "p": "Using `const`. The constant names are written with UPPERCASE letters. I also use `const` when including libraries using `require` and when they should not be changed. In this case, the names will not be with caps."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "// Dependencies",
            "const http = require(\"http\")",
            "   , fs = require(\"fs\")",
            "   , EventEmitter = require(\"events\").EventEmitter",
            "// Constants",
            "const PI = Math.PI",
            "    , MY_CONSTANT = 42",
            "    ;"
          ]
        }
      },
      {
        "h3": "Globals :earth_africa:"
      },
      {
        "p": "I define globals when there is no commonjs environment (this is actually handled by [`dist-it`](https://github.com/IonicaBizau/dist-it). When I manually define globals, I do that using `window.MyGlobal` (on the client) and `global.MyGlobal` (on the server)."
      },
      {
        "h2": "Semicolons :pencil2:"
      },
      {
        "p": "I *use* semicolons. Almost always."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "var foo = 1;",
            "function bar (x) {",
            "    var someMethod = function (m) {",
            "        console.log(m);",
            "    };",
            "    return { y: x, foo: someMethod };",
            "}",
            "class Foo {",
            "    ...",
            "}"
          ]
        }
      },
      {
        "h2": "Method and property definitions :paperclip:"
      },
      {
        "p": "I use the ES6 `class` for creating classes."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "class Person {",
            "    constructor (name, age) {",
            "        this.name = name;",
            "        this.age = age;",
            "    }",
            "    getName () {",
            "        return this.name;",
            "    }",
            "}"
          ]
        }
      },
      {
        "h2": "Deleting properties :x:"
      },
      {
        "p": "I nullify the properties when that's fine:"
      },
      {
        "code": {
          "language": "js",
          "content": [
            "var foo = {",
            "    bar: 42",
            "};",
            "foo.bar = null;"
          ]
        }
      },
      {
        "p": "However, I use the `delete` keyword when I really want to delete them."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "delete foo.bar;"
          ]
        }
      },
      {
        "h2": "`eval()`"
      },
      {
        "p": "`eval` is evil. :rage: Do not use it. However I use it in some test files and in places where I have to execute the JavaScript code provided by the user."
      },
      {
        "p": "For converting strings to JSON, use `JSON.parse(strObj)`."
      },
      {
        "h2": "Iterating objects and arrays"
      },
      {
        "p": "For arrays, most of times, I use the `forEach` function:"
      },
      {
        "code": {
          "language": "js",
          "content": [
            "arr.forEach(c => {",
            "    // do something",
            "});"
          ]
        }
      },
      {
        "p": "However, using `for` loops is fine too:"
      },
      {
        "code": {
          "language": "js",
          "content": [
            "for (var i = 0; i < arr.length; ++i) {",
            "    for (var ii = 0; ii < arr[i].length; ++ii) {",
            "        ...",
            "    }",
            "    ...",
            "}"
          ]
        }
      },
      {
        "p": "For objects, I use the following style:"
      },
      {
        "code": {
          "language": "js",
          "content": [
            "Object.keys(obj).forEach(k => {",
            "    var cValue = obj[k];",
            "    // do something",
            "});"
          ]
        }
      },
      {
        "p": "To simplify this, I created [`iterate-object`](https://github.com/IonicaBizau/iterate-object), which abstracts this functionality:"
      },
      {
        "code": {
          "language": "js",
          "content": [
            "const iterateObject = require(\"iterate-object\");",
            "iterateObject(obj, (value, key) => {",
            "    // do something",
            "});"
          ]
        }
      },
      {
        "h2": "Multiline strings :guitar:"
      },
      {
        "p": "I use backticks to create multiline strings:"
      },
      {
        "code": {
          "language": "js",
          "content": [
            "var multiLineStr = `Lorem ipsum dolor sit amet, consectetur adipisicing elit",
            "sed do eiusmod tempor incididunt ut labore et dolore magna",
            "aliqua. Ut enim ad minim veniam, quis nostrud exercitation",
            "ullamco laboris nisi ut aliquip ex ea commodo consequat",
            "New line again...`;"
          ]
        }
      },
      {
        "h2": "Modifying prototypes of built-in objects :shit:"
      },
      {
        "p": "Just don't, unless that's the scope of the library."
      },
      {
        "h2": "Naming things :thought_balloon:"
      },
      {
        "p": "Using camel case notation for variables, in general. For constructors I capitalize the variable name (e.g. `EventEmitter`)."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "// Node.JS require",
            "const fs = require(\"fs\")",
            "    , events = require(\"events\")",
            "    , EventEmitter = events.EventEmitter",
            "    ;",
            "",
            "// Local variables",
            "var x = 1",
            "  , twoWords = \"Hello World\"",
            "  ;",
            "",
            "// Functions",
            "function fooBar () {...}",
            "",
            "// Classes",
            "class Person {",
            "    constructor (name, age) {",
            "        this.name = name;",
            "        this.age = age;",
            "    }",
            "    getName () {",
            "        return this.name;",
            "    }",
            "}",
            "// Object fields",
            "var obj = {",
            "    full_name: \"Johnny B.\"",
            "  , age: 20",
            "};",
            "obj.methodA = function () {...};"
          ]
        }
      },
      {
        "h2": "Curly braces :curly_loop:"
      },
      {
        "p": "Open the curly brace at the end of the line. Always put the instructions between curly braces, even there is only one instruction."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "if (expr) {",
            "    instr;",
            "} else {",
            "    instr2;",
            "    instr3;",
            "}"
          ]
        }
      },
      {
        "h2": "Array and Object Initializers :file_folder:"
      },
      {
        "p": "See examples."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "// Arrays",
            "var arr = [1, 2, 3, 4];",
            "",
            "var lotOfElms = [",
            "    1, 2, 3, 4, 5, 6, 7",
            "  , 8, 9, 10, 11, 12, 13",
            "  , 14, 15, 16, 17, 18",
            "];",
            "",
            "var bigElms = [",
            "    \"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod.\"",
            "  , \"Tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim.\"",
            "  , \"Veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea.\"",
            "  , \"Commodo consequat. Duis aute irure dolor in reprehenderit in voluptate\"",
            "];",
            "",
            "// Objects",
            "var obj = { a: 1 };",
            "",
            "var obj1 = {",
            "    full_name: \"Johnny B.\"",
            "  , age: 20",
            "};"
          ]
        }
      },
      {
        "h2": "Commas"
      },
      {
        "p": "Put commas at the beginning of the line, not at the end."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "var x = 1",
            "  , y = 2",
            "  ;",
            "",
            "const C_1 = 42",
            "    , C_2 = -42",
            "    ;",
            "",
            "var obj = {",
            "    x: 1",
            "  , y: 2",
            "};"
          ]
        }
      },
      {
        "h2": "Blank lines"
      },
      {
        "p": "Group the instructions inserting some blank lines where it's needed."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "foo(x);",
            "bar(x);",
            "",
            "foo(y);",
            "bar(y);"
          ]
        }
      },
      {
        "h2": "Binary and Ternary operators"
      },
      {
        "p": "See examples."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "var foo = someObj",
            "    .method()",
            "    .method2()",
            "    .method3()",
            "    ;",
            "",
            "var a = cond ? v1 : v2;",
            "",
            "var b = long_condition_here",
            "        ? v1 : v2",
            "        ;",
            "",
            "var c = another_long_condition_here",
            "        ? with_some_long_value",
            "        : or_another_some_long_value",
            "        ;"
          ]
        }
      },
      {
        "h2": "Quotes :speech_balloon:"
      },
      {
        "p": "Double quotes, with some exceptions when single quotes are used."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "var foo = \"\\\"Hello\\\", he said.\";",
            "var jQuerySelector = \"div.myClass[data-foo='bar']\";"
          ]
        }
      },
      {
        "h2": "Comments :notes:"
      },
      {
        "p": "Put relevant comments. The comments start with uppercase letter."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "// Dependencies",
            "const lib1 = require(\"lib1\")",
            "    , lib2 = require(\"lib2\")",
            "    ;",
            "",
            "// Constants",
            "const FOURTY_TWO = 42;"
          ]
        }
      },
      {
        "p": "Use JSDoc comments for functions and methods."
      },
      {
        "code": {
          "language": "js",
          "content": [
            "/**",
            "* sum",
            "* Calculates the sum of two numbers.",
            "*",
            "* @name sum",
            "* @function",
            "* @param {Number} a The first number,",
            "* @param {Number} b The second number.",
            "* @return {Number} The sum of the two numbers.",
            "*/",
            "function sum (a, b) {",
            "  return a + b;",
            "};"
          ]
        }
      },
      {
        "p": "I use the [`blah` tool](https://github.com/IonicaBizau/blah) to generate documentation."
      },
      {
        "code": {
          "language": "sh",
          "content": [
            "$ npm install -g blah",
            "$ blah --readme",
            "$ blah --docs some-file.js"
          ]
        }
      },
      {
        "h2": "Project naming"
      },
      {
        "p": "I use [`name-it`](https://github.com/IonicaBizau/name-it) to generate project names."
      },
      {
        "h2": "Project licenses"
      },
      {
        "p": "I :sparkling_heart: open-source! I prefer the MIT license."
      }
    ]
  },
  "files": [
    "bin/",
    "app/",
    "lib/",
    "dist/",
    "src/",
    "scripts/",
    "resources/",
    "menu/",
    "cli.js",
    "index.js",
    "bloggify.js",
    "bloggify.json",
    "bloggify/"
  ]
}