Code refactoring

Author: tshemsedinov

JavaScript/1-console-time.js

@@ -2,14 +2,13 @@
 
 const LOOP_COUNT = 50000;
 
-function fn() {
+const fn = () => {
   const a = [];
-  let i;
-  for (i = 0; i < LOOP_COUNT; i++) {
+  for (let i = 0; i < LOOP_COUNT; i++) {
     a.push(Array(i).join('A').length);
   }
   return a;
-}
+};
 
 console.time('experiment');
 const res1 = fn();

JavaScript/2-benchmark.js

@@ -55,35 +55,35 @@ benchmark.do = (count, tests) => {
   const times = tests.map(fn => {
     if (global.gc) gc();
     const result = [];
-    let i;
     const optBefore = opt(fn);
     optimize(fn);
     fn();
     const optAfter = opt(fn);
-    for (i = 0; i < PRE_COUNT; i++) result.push(fn());
+    for (let i = 0; i < PRE_COUNT; i++) result.push(fn());
     const optAfterHeat = opt(fn);
     const begin = process.hrtime();
-    for (i = 0; i < count; i++) result.push(fn());
+    for (let i = 0; i < count; i++) result.push(fn());
     const end = process.hrtime(begin);
     const optAfterLoop = opt(fn);
     const diff = end[0] * 1e9 + end[1];
-    const time = lpad(diff.toString(), '.', 15);
+    const time = diff.toString();
     const name = rpad(fn.name, '.', 25);
     const iterations = result.length - PRE_COUNT;
-    console.log(
-      `${name}${time} ${optBefore} ${optAfter} ${optAfterHeat} ${optAfterLoop}`
-    );
+    const log = [
+      name, time, optBefore, optAfter,
+      optAfterHeat, optAfterLoop
+    ];
+    console.log(log.join(' '));
     return { name, time: diff };
   });
   console.log();
   const top = times.sort((t1, t2) => (t1.time - t2.time));
   const best = top[0].time;
-  top.forEach((test) => {
+  top.forEach(test => {
     test.percent = relativePercent(best, test.time);
     const time = lpad(test.time.toString(), '.', 15);
-    const percent = lpad((
-      test.percent === 0 ? 'min' : '+' + test.percent + '%'
-    ), '.', 10);
-    console.log(test.name + time + percent);
+    const percent = test.percent === 0 ? 'min' : `+${test.percent}%`;
+    const line = lpad(percent, '.', 10);
+    console.log(test.name + time + line);
   });
 };

JavaScript/3-instantiation.js

@@ -2,52 +2,39 @@
 
 const benchmark = require('./2-benchmark.js');
 
-function makeClosure(hello, size, flag) {
-  return () => ({ hello, size, flag });
-  // try {} catch (e) {}
-}
+const makeClosure = (hello, size, flag) => () => (
+  { hello, size, flag }
+);
 
-function closureInstance() {
-  return makeClosure('world', 100500, true);
-}
+const closureInstance = () => makeClosure('world', 100500, true);
 
-function defineArray() {
-  return ['world', 100500, true];
-}
+const defineArray = () => ['world', 100500, true];
 
-function defineArrayOfString() {
-  return ['world', 'world', 'world'];
-}
+const defineArrayOfString = () => ['world', 'world', 'world'];
 
-function defineArrayOfNumber() {
-  return [100500, 100500, 100500];
-}
+const defineArrayOfNumber = () => [100500, 100500, 100500];
 
-function defineObject() {
-  return {
-    hello: 'world',
-    size: 100500,
-    flag: true
-  };
-}
+const defineObject = () => ({
+  hello: 'world',
+  size: 100500,
+  flag: true
+});
 
-function mixinObject() {
+const mixinObject = () => {
   const obj = {};
   obj.hello = 'world';
   obj.size = 100500;
   obj.flag = true;
   return obj;
-}
+};
 
 function ProtoItem(hello, size, flag) {
   this.hello = hello;
   this.size = size;
   this.flag = flag;
 }
 
-function newPrototype() {
-  return new ProtoItem('world', 100500, true);
-}
+const newPrototype = () => new ProtoItem('world', 100500, true);
 
 const ClassItem = class {
   constructor(hello, size, flag) {
@@ -57,33 +44,27 @@ const ClassItem = class {
   }
 };
 
-function newClass() {
-  return new ClassItem('world', 100500, true);
-}
+const newClass = () => new ClassItem('world', 100500, true);
 
-function newObject() {
+const newObject = () => {
   const obj = new Object();
   obj.hello = 'world';
   obj.size = 100500;
   obj.flag = true;
   return obj;
-}
+};
 
-function objectCreate() {
-  const obj = Object.create(objectCreate.prototype);
+const objectCreate = () => {
+  const obj = Object.create(null);
   obj.hello = 'world';
   obj.size = 100500;
   obj.flag = true;
   return obj;
-}
+};
 
-function callFactory() {
-  return itemFactory('world', 100500, true);
-}
+const itemFactory = (hello, size, flag) => ({ hello, size, flag });
 
-function itemFactory(hello, size, flag) {
-  return { hello, size, flag };
-}
+const callFactory = () => itemFactory('world', 100500, true);
 
 benchmark.do(1000000, [
   callFactory,

JavaScript/4-array.js

@@ -56,7 +56,7 @@ function buildGetter(proto, fieldName, fieldType, fieldIndex) {
         return new Date(this[fieldIndex]);
       }
     });
-  } else if (typeof(fieldType) === 'function') {
+  } else if (typeof fieldType === 'function') {
     Object.defineProperty(proto, fieldName, { get: fieldType });
   } else {
     Object.defineProperty(proto, fieldName, {

JavaScript/5-range.js

@@ -2,48 +2,47 @@
 
 const benchmark = require('./2-benchmark.js');
 
-function rangePush(min, max) {
+const rangePush = (min, max) => {
   const arr = [];
-  let i;
-  for (i = min; i <= max; i++) arr.push(i);
+  for (let i = min; i <= max; i++) arr.push(i);
   return arr;
-}
+};
 
-function rangeNew(from, to) {
+const rangeNew = (from, to) => {
   if (to < from) return [];
   const len = to - from + 1;
   const range = new Array(len);
-  let i;
-  for (i = from; i <= to; i++) {
+  for (let i = from; i <= to; i++) {
     range[i - from] = i;
   }
   return range;
-}
+};
 
-function rangeEx(range) {
+const rangeEx = range => {
   const from = range[0];
   let to = range[1];
-  const toType = typeof(to);
-  let count, res;
+  const toType = typeof to;
   if (toType === 'undefined') {
     to = range[2];
-    res = api.common.range(from, to);
+    return api.common.range(from, to);
   } else if (toType !== 'number') {
-    count = to[0];
+    let count = to[0];
     if (count < 0) {
-      cpus = api.os.cpus().length;
+      const cpus = api.os.cpus().length;
       count = cpus + count;
     }
-    range = api.common.range(from, from + count - 1);
+    return api.common.range(from, from + count - 1);
   }
-  return res;
-}
+};
 
 benchmark.do(1000000, [
   function testRangePush() {
     rangePush(1, 1000);
   },
   function testRangeNew() {
     rangeNew(1, 1000);
-  }
+  },
+  function testRangeEx() {
+    rangeNew(1, 1000);
+  },
 ]);

JavaScript/6-functions.js

@@ -3,8 +3,11 @@
 const benchmark = require('./2-benchmark.js');
 
 const fnLambdaBlock = () => {};
+// eslint-disable-next-line
 const fnLambdaBlockU = () => { return; };
+// eslint-disable-next-line
 const fnLambdaBlockN = () => { return null; };
+// eslint-disable-next-line
 const fnLambdaBlock0 = () => { return 0; };
 
 const fnLambdaExprU = () => undefined;

JavaScript/9-for-in.js

@@ -12,62 +12,35 @@ const data = {
   yz: 'xyz'
 };
 
-function testForKeys() {
+const testForKeys = () => {
   const a = Array(7);
-  let i, key;
   const keys = Object.keys(data);
-  const len = keys.length;
-  for (i = 0; i < len; i++) {
-    key = keys[i];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     a[i] = data[key];
   }
-}
-
-function testForIn() {
-  const a = Array(7);
-  let i = 0;
-  for (let key in data) {
-    a[i++] = data[key];
-  }
-}
+};
 
-function testForInLet() {
+const testForIn = () => {
   const a = Array(7);
   let i = 0;
-  let key;
-  for (key in data) {
+  for (const key in data) {
     a[i++] = data[key];
   }
-}
-
-function testForOf() {
-  const a = Array(7);
-  let i = 0;
-  let key, val;
-  const keys = Object.keys(data);
-  const len = keys.length;
-  for (key of keys) {
-    val = data[key];
-    a[i++] = val;
-  }
-}
+};
 
-function testForOfLet() {
+const testForOf = () => {
   const a = Array(7);
   let i = 0;
-  let key, val;
   const keys = Object.keys(data);
-  const len = keys.length;
-  for (let key of keys) {
-    val = data[key];
+  for (const key of keys) {
+    const val = data[key];
     a[i++] = val;
   }
-}
+};
 
-benchmark.do(1000000, [
+benchmark.do(10000000, [
   testForKeys,
   testForIn,
-  testForInLet,
   testForOf,
-  testForOfLet
 ]);

JavaScript/a-tick-template.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const benchmark = require('./2-benchmark.js');
+
+const testConcat = () => 'Hello user' + parseInt('5') * 10 + ' !';
+
+const testTick = () => `Hello user${parseInt('5') * 10} !`;
+
+benchmark.do(10000000, [
+  testConcat,
+  testTick,
+]);