Estaba evaluando una microoptimización potencial que podría ayudar a acelerar uno de mis bucles más estrechos y obtuve algunos resultados interesantes:

https://jsbench.me/hyl3rhq5hx/2

La prueba estaba comprobando dos métodos diferentes para extraer propiedades de un objeto args:

 // simply using "if" to check if args have certain properties function checkIfIn(args) { if (args) { if (args.a) { out += args.a; } if (args.b) { out += args.b; } if (args.c) { out += args.c; } if (args.d) { out += args.d; } if (args.e) { out += args.e; } if (args.f) { out += args.f; } if (args.g) { out += args.g; } if (args.h) { out += args.h; } if (args.i) { out += args.i; } if (args.j) { out += args.j; } if (args.k) { out += args.k; } if (args.l) { out += args.l; } if (args.m) { out += args.m; } if (args.n) { out += args.n; } if (args.o) { out += args.o; } if (args.p) { out += args.p; } } } ---------- VS -------------------- // iterating over args keys and passing to function const fnMap = { a: (args) => out += args.a, b: (args) => out += args.b, c: (args) => out += args.c, d: (args) => out += args.d, e: (args) => out += args.e, f: (args) => out += args.f, g: (args) => out += args.g, h: (args) => out += args.h, i: (args) => out += args.i, j: (args) => out += args.j, k: (args) => out += args.k, l: (args) => out += args.l, m: (args) => out += args.m, n: (args) => out += args.n, o: (args) => out += args.o, p: (args) => out += args.p, } function iterateKeysIn(args) { if (args) { for (const key in args) { const fn = fnMap[key]; fn && fn(args); } } }

Para pequeñas cantidades de accesorios de argumento (~4), los dos puntos de referencia arrojan resultados casi iguales. Pero por cada argumento adicional, el método iterateKeysIn se vuelve progresivamente más eficaz (en mi caso, tengo ~20 argumentos que coincidentemente produce un aumento de velocidad de ~20 %).

Este resultado a la vez tiene sentido y me sorprende. Por un lado, no verificar propiedades que no existen es eficiente. Pero, por otro lado, obtener un iterador para claves, buscar propiedades en un objeto y luego pasar valores a otra función de flecha se siente demasiado complejo.

En particular, no veo cómo estos dos pueden estar tan cerca del rendimiento del otro con un bajo número de accesorios.

¿Es esta realmente la forma más rápida de consumir un objeto args en Javascript?