JavaScript profiling tool and library of profiling modules and benchmarks.

JS-Profiler allows you to compare different techniques, operators and functions regarding execution speed and memory consumption. It reports results either in text or JSON format.

JS-Profiler powers https://js-profiler.com.

• Installation
• Updates
  • v2.3.0: New contributor and profile: shallow array copying.
  • v2.2.0: Migrate to Node.js Performance Hooks
  • New in version 2 & Migration
    • Comparison of v1 vs. v2 profile object
      • v1 profile object
      • v2 profile object
• Usage
  • CLI
  • Library
• Profiles
  • array concatenation
  • array copying
  • comparison operators
  • (de-)composition
  • guards
  • loops
  • map access
  • map creation
  • object iteration
  • recursion
• Documentation
• Changelog
• License

npm i [-gS] js-profiler

We are happy to welcome Josh Howe as a contributor to JS-Profiler! He added a new profile comparing ways to shallow copy arrays.

Due to updated dependencies, JS-Profiler now requires a minimum Node.js version of 10.12.0.

As of version 2.2.0 js-profiler gathers function timing information via the Performance Hooks API instead of process.hrtime().

• profile.tests is renamed to profile.functions
• function.description (formerly test.description) now contains a nice human readable description.
• function.codeSample now contains a short pseudo-code sample of the function under test.
• use function.code to access the full source code of the function under test.
• function.keywords contains keywords associated with the function under test.
• profile.keywords contains keywords associated with this profile.

// v1
{
  "name" : "recursion",
  "description" : "Recursion variations: Calculating sum of array of integers. Profile contains a simple for-loop for reference.",
  "tests" : [
      {
          "description" : "for loop sum for reference",
          "time" : {
              "average" : "1.4923μs",
              "minimum" : "1.0970μs",
              "maximum" : "38.8230μs"
          }
      }, 
      {
          "description" : "recursive sum",
          "time" : {
              "average" : "1080.3024μs",
              "minimum" : "703.3320μs",
              "maximum" : "10215.1650μs"
          }
      }, 
      {
          "description" : "tail recursive sum",
          "time" : {
              "average" : "1041.0375μs",
              "minimum" : "704.2790μs",
              "maximum" : "16476.7110μs"
          }
      }
  ],
  "fastest" : [
      {
          "description" : "for loop sum for reference",
          "time" : {
              "average" : "1.4923μs",
              "minimum" : "1.0970μs",
              "maximum" : "38.8230μs"
          }
      }
  ]
}

// v2
{
  "name": "recursion",
  "description": "Recursion.",
  "keywords": [
    "for",
    "loop",
    "recursion",
    "sum",
    "tail",
    "tailrecursion"
  ],
  "functions": [
    {
      "description": "for loop sum for reference",
      "keywords": [
        "for",
        "loop",
        "sum"
      ],
      "codeSample": "for (...) { sum += d[i] }",
      "code": "(d) => {\n    let sum = 0;\n    for (let i = 0; i < d.length; i++) {\n      sum += d[i];\n    }\n\n    return sum;\n  }",
      "time": {
        "average": "3.8774µs"
      }
    },
    {
      "description": "recursive sum",
      "keywords": [
        "recursion",
        "sum"
      ],
      "codeSample": "const f = (d) => (d && d.length && (d[0] + f(d.slice(1)))) || 0",
      "code": "(d) => (d && d.length && (d[0] + recursiveSum.f(d.slice(1)))) || 0",
      "time": {
        "average": "733.7537µs"
      }
    },
    {
      "description": "tail recursive sum",
      "keywords": [
        "recursion",
        "sum",
        "tail",
        "tailrecursion"
      ],
      "codeSample": "const f = (d, i = 0) => (!d.length && i) || f(d.slice(1), i + d[0])",
      "code": "(d, i = 0) => (!d.length && i)\n    || tailRecursiveSum.f(d.slice(1), i + d[0])",
      "time": {
        "average": "769.7328µs"
      }
    }
  ],
  "fastest": [
    {
      "description": "for loop sum for reference",
      "keywords": [
        "for",
        "loop",
        "sum"
      ],
      "codeSample": "for (...) { sum += d[i] }",
      "code": "(d) => {\n    let sum = 0;\n    for (let i = 0; i < d.length; i++) {\n      sum += d[i];\n    }\n\n    return sum;\n  }",
      "time": {
        "average": "3.8774µs"
      }
    }
  ]
}

If installed with the -g flag you can simply run js-profiler from your command line:

For further information please refer to the CLI documentation and the man page.

// 1. Import the library
const jsProfiler = require('js-profiler');

// 2. Run the profiler
jsProfiler.run()
  .then((report) => {
    console.log(JSON.stringify(report, null, 2));
  });

For configuration options please refer to the Library documentation.

Array concatenation variations: Combining two arrays using different techniques.

Profiled operations:

• a.concat(b)
• for (...) { a.push(b[i])}
• for (...) { b.unshift(a[i])}
• a.push.apply(a, b)
• Array.prototype.unshift.apply(b, a)
• b.reduce((arr, item) => arr.push(item), a)
• a.reduceRight((arr, item) => arr.unshift(item), b)
• [...a, ...b]

Array copying variations: creating a new array with the same elements as an existing array.

Profiled operations:

• a.slice()
• [...a]
• Array.from(a)
• new Array(...a)
• a.concat([])
• [].concat(a)
• Array.prototype.unshift.apply([], a)
• Array.prototype.unshift.apply(new Arrray(), a)
• [].push(...a)
• (new Array()).push(...a)
• b = []; for(...){ b.push(a[i]) }
• b = new Array(); for(...){ b.push(a[i]) }
• b = new Array(a.length); for(...){ b[i] = a[i] }

(De-)Composition: composing objects, arrays and variables from each other.

Profiled operations:

• const { a, b } = obj
• const { a = i } = obj
• const [a, b] = arr
• const [a = i, b] = d
• const [a, b, ...tail] = d
• const a = arr[i]
• const a = arr[i] || j
• const a = obj.b
• const a = obj.b || i
• const [a, b] = [b, a]
• const c = b; b = a; a = c

Variable comparison operators.

Profiled operations:

• a > b
• a >= b
• a < b
• a <= b
• ==
• ===
• !=
• !==
• &&
• ||

Variable guards: checking whether a variable is defined or of a certain type.

Profiled operations:

• typeof !== 'undefined'
• typeof != 'undefined'
• typeof === 'function'
• typeof == 'function'
• typeof === 'number'
• typeof == 'number'
• typeof === 'object'
• typeof == 'object'
• typeof === 'string'
• typeof == 'string'
• Array.isArray
• !!var
• !var
• isNaN(var)
• Number.isNaN(var)
• !isNaN(var)
• !Number.IsNaN(var)
• prop in obj
• obj.hasOwnProperty(prop)
• Object.prototype.hasOwnProperty.call(obj, prop)

Loop variations: Converting an array of integers into an array of booleans satisfying a conjunction of two simple relational operations.

Profiled operations:

• [].forEach() => []
• for(i++, i < d.length) => []
• for(i++, i < len) => []
• while(i--) => []
• [].map() => []
• while(i < d.length) => []
• while(i < len) => []
• do { } while (i < d.length)
• do { } while (i < len)
• for (prop of [])

Object literal vs. Map: retrieving values.

Profiled operations:

• Map.get()
• {}.prop

Object literal vs. Map: creating a map.

Profiled operations:

• Map.set()
• new Map([props])
• {}.prop = val
• Object.defineProperty({}, prop, desc)
• Object.defineProperties({}, props)
• { ...props }

Object iteration: different ways of iterating over properties of an object and concatenating property names into a single string.

Profiled operations:

• for (const prop in obj) {}
• Object.keys(obj).forEach()
• Object.entries(obj).forEach()
• for (prop of Map.keys())
• for (prop of Object.keys(obj))
• for (prop of Object.keys(obj) { obj.hasOwnProperty(prop) && ... })
• for (prop of Object.getOwnPropertyNames(obj))
• Object.getOwnPropertyNames(obj).forEach()

Recurstion variations: Calculating sum of array of integers. Profile contains a simple for-loop for reference.

Profiled operations:

• for loop sum for reference
• recursive sum
• tail recursive sum