wooandoo · August 20, 2020 06:55
diff --git a/index.html b/index.html
 <!DOCTYPE html>
 <html>
 <head>
 	<meta charset="utf-8"/>
 	<title>compare array of strings</title>
 	<script src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/1.0.0/benchmark.min.js"></script>
 	<script src="./suite.js"></script>
 </head>
 <body>
 	<h1>Open the console to view the results</h1>
 	<h2><code>cmd + alt + j</code> or <code>ctrl + alt + j</code></h2>
 </body>
 </html>
diff --git a/suite.js b/suite.js
 "use strict";

 (function (factory) {
 	if (typeof Benchmark !== "undefined") {
 		factory(Benchmark);
 	} else {
 		factory(require("benchmark"));
 	}
 })(function (Benchmark) {
 	var suite = new Benchmark.Suite;

 	Benchmark.prototype.setup = function () {
 		function dynamicallyLoadScript(url) {
 		    var script = document.createElement("script");  // create a script DOM node
 		    script.src = url;  // set its src to the provided URL
 		
 		    document.head.appendChild(script);  // add it to the end of the head section of the page (could change 'head' to 'body' to add it to the end of the body section instead)
 		}
 		
 		dynamicallyLoadScript("https://cdn.jsdelivr.net/npm/[email protected]/dist/ramda.js")
 		// dynamicallyLoadScript("https://cdn.jsdelivr.net/npm/[email protected]/index.js")
 		
 		let urlAlphabet =
 		  'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'
 		
 		let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
 		
 		let customRandom = (alphabet, size, getRandom) => {
 		  // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
 		  // values closer to the alphabet size. The bitmask calculates the closest
 		  // `2^31 - 1` number, which exceeds the alphabet size.
 		  // For example, the bitmask for the alphabet size 30 is 31 (00011111).
 		  // `Math.clz32` is not used, because it is not available in browsers.
 		  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
 		  // Though, the bitmask solution is not perfect since the bytes exceeding
 		  // the alphabet size are refused. Therefore, to reliably generate the ID,
 		  // the random bytes redundancy has to be satisfied.
 		
 		  // Note: every hardware random generator call is performance expensive,
 		  // because the system call for entropy collection takes a lot of time.
 		  // So, to avoid additional system calls, extra bytes are requested in advance.
 		
 		  // Next, a step determines how many random bytes to generate.
 		  // The number of random bytes gets decided upon the ID size, mask,
 		  // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
 		  // according to benchmarks).
 		
 		  // `-~f => Math.ceil(f)` if f is a float
 		  // `-~i => i + 1` if i is an integer
 		  let step = -~((1.6 * mask * size) / alphabet.length)
 		
 		  return () => {
 		    let id = ''
 		    while (true) {
 		      let bytes = getRandom(step)
 		      // A compact alternative for `for (var i = 0; i < step; i++)`.
 		      let j = step
 		      while (j--) {
 		        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
 		        id += alphabet[bytes[j] & mask] || ''
 		        // `id.length + 1 === size` is a more compact option.
 		        if (id.length === +size) return id
 		      }
 		    }
 		  }
 		}
 		
 		let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random)
 		
 		let nanoid = (size = 21) => {
 		  let id = ''
 		  let bytes = crypto.getRandomValues(new Uint8Array(size))
 		
 		  // A compact alternative for `for (var i = 0; i < step; i++)`.
 		  while (size--) {
 		    // It is incorrect to use bytes exceeding the alphabet size.
 		    // The following mask reduces the random byte in the 0-255 value
 		    // range to the 0-63 value range. Therefore, adding hacks, such
 		    // as empty string fallback or magic numbers, is unneccessary because
 		    // the bitmask trims bytes down to the alphabet size.
 		    let byte = bytes[size] & 63
 		    if (byte < 36) {
 		      // `0-9a-z`
 		      id += byte.toString(36)
 		    } else if (byte < 62) {
 		      // `A-Z`
 		      id += (byte - 26).toString(36).toUpperCase()
 		    } else if (byte < 63) {
 		      id += '_'
 		    } else {
 		      id += '-'
 		    }
 		  }
 		  return id
 		}
 		
 		
 		let items = R.range(0, 10).map(_ => nanoid())
 		
 		
 		let string_key = items.join(',')
 		let json_key = JSON.stringify(items)
 		let data = JSON.parse(JSON.stringify(items))
 		
 		let is_equals = (list1, list2) => {
 		    if (list1.length !== list2.length)
 		    return false
 		    
 		    for (let index = 0; index < data.length; index++) {
 		        if (data[index] !== items[index])
 		        return false
 		    }
 		    
 		    return true
 		}
 	};


 	suite.add("let is_found = string_key === data.join(',')", function () {
 		let is_found = string_key === data.join(',')
 	});

 	suite.add("let is_found = json_key === JSON.stringify(data)", function () {
 		let is_found = json_key === JSON.stringify(data)
 	});

 	suite.add("let is_found = is_equals(data, items)", function () {
 		let is_found = is_equals(data, items)
 	});

 	suite.on("cycle", function (evt) {
 		console.log(" - " + evt.target);
 	});

 	suite.on("complete", function (evt) {
 		console.log(new Array(30).join("-"));

 		var results = evt.currentTarget.sort(function (a, b) {
 			return b.hz - a.hz;
 		});

 		results.forEach(function (item) {
 			console.log((idx + 1) + ". " + item);
 		});
 	});

 	console.log("compare array of strings");
 	console.log(new Array(30).join("-"));
 	suite.run();
 });
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="utf-8"/>
	<title>compare array of strings</title>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/1.0.0/benchmark.min.js"></script>
	<script src="./suite.js"></script>
	</head>
	<body>
	<h1>Open the console to view the results</h1>
	<h2><code>cmd + alt + j</code> or <code>ctrl + alt + j</code></h2>
	</body>
	</html>
	"use strict";

	(function (factory) {
	if (typeof Benchmark !== "undefined") {
	factory(Benchmark);
	} else {
	factory(require("benchmark"));
	}
	})(function (Benchmark) {
	var suite = new Benchmark.Suite;

	Benchmark.prototype.setup = function () {
	function dynamicallyLoadScript(url) {
	var script = document.createElement("script"); // create a script DOM node
	script.src = url; // set its src to the provided URL

	document.head.appendChild(script); // add it to the end of the head section of the page (could change 'head' to 'body' to add it to the end of the body section instead)
	}

	dynamicallyLoadScript("https://cdn.jsdelivr.net/npm/[email protected]/dist/ramda.js")
	// dynamicallyLoadScript("https://cdn.jsdelivr.net/npm/[email protected]/index.js")

	let urlAlphabet =
	'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'

	let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))

	let customRandom = (alphabet, size, getRandom) => {
	// First, a bitmask is necessary to generate the ID. The bitmask makes bytes
	// values closer to the alphabet size. The bitmask calculates the closest
	// `2^31 - 1` number, which exceeds the alphabet size.
	// For example, the bitmask for the alphabet size 30 is 31 (00011111).
	// `Math.clz32` is not used, because it is not available in browsers.
	let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1
	// Though, the bitmask solution is not perfect since the bytes exceeding
	// the alphabet size are refused. Therefore, to reliably generate the ID,
	// the random bytes redundancy has to be satisfied.

	// Note: every hardware random generator call is performance expensive,
	// because the system call for entropy collection takes a lot of time.
	// So, to avoid additional system calls, extra bytes are requested in advance.

	// Next, a step determines how many random bytes to generate.
	// The number of random bytes gets decided upon the ID size, mask,
	// alphabet size, and magic number 1.6 (using 1.6 peaks at performance
	// according to benchmarks).

	// `-~f => Math.ceil(f)` if f is a float
	// `-~i => i + 1` if i is an integer
	let step = -~((1.6 * mask * size) / alphabet.length)

	return () => {
	let id = ''
	while (true) {
	let bytes = getRandom(step)
	// A compact alternative for `for (var i = 0; i < step; i++)`.
	let j = step
	while (j--) {
	// Adding `\|\| ''` refuses a random byte that exceeds the alphabet size.
	id += alphabet[bytes[j] & mask] \|\| ''
	// `id.length + 1 === size` is a more compact option.
	if (id.length === +size) return id
	}
	}
	}
	}

	let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random)

	let nanoid = (size = 21) => {
	let id = ''
	let bytes = crypto.getRandomValues(new Uint8Array(size))

	// A compact alternative for `for (var i = 0; i < step; i++)`.
	while (size--) {
	// It is incorrect to use bytes exceeding the alphabet size.
	// The following mask reduces the random byte in the 0-255 value
	// range to the 0-63 value range. Therefore, adding hacks, such
	// as empty string fallback or magic numbers, is unneccessary because
	// the bitmask trims bytes down to the alphabet size.
	let byte = bytes[size] & 63
	if (byte < 36) {
	// `0-9a-z`
	id += byte.toString(36)
	} else if (byte < 62) {
	// `A-Z`
	id += (byte - 26).toString(36).toUpperCase()
	} else if (byte < 63) {
	id += '_'
	} else {
	id += '-'
	}
	}
	return id
	}


	let items = R.range(0, 10).map(_ => nanoid())


	let string_key = items.join(',')
	let json_key = JSON.stringify(items)
	let data = JSON.parse(JSON.stringify(items))

	let is_equals = (list1, list2) => {
	if (list1.length !== list2.length)
	return false

	for (let index = 0; index < data.length; index++) {
	if (data[index] !== items[index])
	return false
	}

	return true
	}
	};


	suite.add("let is_found = string_key === data.join(',')", function () {
	let is_found = string_key === data.join(',')
	});

	suite.add("let is_found = json_key === JSON.stringify(data)", function () {
	let is_found = json_key === JSON.stringify(data)
	});

	suite.add("let is_found = is_equals(data, items)", function () {
	let is_found = is_equals(data, items)
	});

	suite.on("cycle", function (evt) {
	console.log(" - " + evt.target);
	});

	suite.on("complete", function (evt) {
	console.log(new Array(30).join("-"));

	var results = evt.currentTarget.sort(function (a, b) {
	return b.hz - a.hz;
	});

	results.forEach(function (item) {
	console.log((idx + 1) + ". " + item);
	});
	});

	console.log("compare array of strings");
	console.log(new Array(30).join("-"));
	suite.run();
	});