JavaScript function Lookup Table

Create an object with function values. Perform lookups on the table to reduce branches.

Function lookup table. A switch statement can run a block of code when a value equals a specific string. But an object with function values can do the same thing.

In this benchmark, we test an object with function values. Each function is the value for a string key. We then invoke a method by its key.Object function

Lookup table example. A lookup table of functions lets us encode branches in memory. We put a function object in each index of an array.Array

Then: We invoke functions based on an array element access. We simply call the array element as a function.

So: Instead of having one or many branches (with an if-statement chain) we can just access the function directly.

Tip: This approach can speed up applications where many possible branches—many functions—are needed.

JavaScript program that calls lookup table functions // A function lookup table. var data = [function(value) { console.log("FUNCTION A: " + (value + 1)); }, function(value) { console.log("FUNCTION B: " + (value * 10)); }, function(value) { console.log("FUNCTION C: " + (value + 2)); }]; // The indexes of the functions we wish to call. var calls = [1, 2, 0, 1]; // Loop through the call numbers and invoke the functions in the table. for (var i = 0; i < calls.length; i++) { data[calls[i]](10); } Output FUNCTION B: 100 FUNCTION C: 12 FUNCTION A: 11 FUNCTION B: 100

Benchmark, lookup table. What is the performance of a lookup table of functions? The same assignment statement is executed on the value string (which is set to "dog").

Version 1: We create an object (dict) with 3 string keys and use an anonymous function for each value.

Version 2: We use a string switch and inline all the functions. Each version of the code times its execution.

Result: The switch statement on strings is slightly faster than the lookup table of anonymous functions.

JavaScript program that times lookup table, functions var value = "dog"; var y = 0; var dict = { "fish": function() { y = 0; }, "cat": function() { y = 10; }, "dog": function() { y = 20; } } var x1 = performance.now(); // Version 1: call method in dictionary. for (var i = 0; i < 100000000; i++) { dict[value](); } var x2 = performance.now(); // Version 2: use switch to run code based on a string value. for (var i = 0; i < 100000000; i++) { switch (value) { case "fish": y = 0; break; case "cat": y = 10; break; case "dog": y = 20; break; } } var x3 = performance.now(); // Results. console.log("TIME 1: " + (x2 - x1)); console.log("TIME 2: " + (x3 - x2)); Output TIME 1 (2019): 186.135 TIME 2: 185.485

Switch performance. In another test I found that the switch statement is faster than if-statements. Thus it appears in JavaScript a switch is the best option for max performance.Switch

Some considerations. A lookup table may lead to clearer code, and often lookup time is not an important part of web application performance. But on a low level, the switch appears superior.

The Dev Codes

.Net

.NET Array Dictionary List String 2D Async DataTable Dates DateTime Enum File For Foreach Format IEnumerable If IndexOf Lambda LINQ Parse Path Process Property Regex Replace Sort Split Static StringBuilder Substring Switch Tuple

Java

Core Array ArrayList HashMap String 2D Cast Character Console Deque Duplicates File For Format HashSet If IndexOf Lambda Math ParseInt Process Random Regex Replace Sort Split StringBuilder Substring Switch Vector While

TheDeveloperBlog.com

JavaScript function Lookup Table

Related Links:

.Net

Java

Related Links