- nv-facutil-simple-test simple test tools
- npm install nv-facutil-simple-test
const {sync,async,Ahook} = require("nv-facutil-simple-test")
function tst0(ary0,ary1) {
ary0.concat(ary1)
}
> sync(10000000,tst0,[1,2],[3,4,5])
{ rounds: 10000000, f: [Function: tst0], costed: 2894.0468668937683 }
>
function tst1(delay) {
let p = new Promise(
(rs,rj)=> {
setTimeout(()=>{rs(true)},delay)
}
);
return(p)
}
var p = async(5,tst1,3000)
> p
Promise { <pending> }
> p
Promise {
{ rounds: 5, f: [Function: tst1], costed: 15013.968754768372 }
}
>
class Cnode {
constructor(a,b) {
this.a = a;
this.b = b;
}
}
function Fnode(a,b) {
this.a = a;
this.b = b;
}
class Anode extends Array {
get a() {return(this[0])}
set a(v) {this[0]=v}
get b() {return(this[1])}
set b(v) {this[1]=v}
}
var new_cnd = (a,b)=>new Cnode(a,b);
var new_fnd = (a,b)=>new Fnode(a,b);
var new_arynd = (a,b)=>new Anode(a,b);
var obj_creat = (a,b) => {
let nd = Object.create(Cnode.prototype)
nd.a = a;
nd.b = b;
return(nd)
}
var nul_creat = (a,b) => {
let nd = Object.create(null);
nd.a = a;
nd.b = b;
return(nd)
}
var shape = { a:0,b:0}
var plain_obj = (a,b) => ({a,b})
var plain_ary = (a,b) => [a,b]
var reflect = (a,b) => Reflect.construct(Fnode, [a,b]);
class Priv {
#a
#b
constructor(a,b) {
this.#a = a;
this.#b = b;
}
}
var priv = (a,b) =>new Priv(a,b);
var obj_with_gtst = (a,b) =>({
"#a":100,
"#b":200,
get a() {return(this["#a"])},
set a(v) {this["#a"] =v},
get b() {return(this["#b"])},
set b(v) {this["#b"] =v}
})
cmp(10000000,[new_cnd,new_fnd,obj_creat,nul_creat,plain_obj,new_arynd,plain_ary,reflect,priv,obj_with_gtst],111,222)
/*
[
{
rounds: 10000000,
f: [Function: plain_obj],
costed: 167.5416979789734
},
{
rounds: 10000000,
f: [Function: plain_ary],
costed: 197.22762298583984
},
{
rounds: 10000000,
f: [Function: new_arynd],
costed: 202.34725713729858
},
{
rounds: 10000000,
f: [Function: new_fnd],
costed: 208.09321069717407
},
{
rounds: 10000000,
f: [Function: new_cnd],
costed: 211.60849380493164
},
{
rounds: 10000000,
f: [Function: obj_creat],
costed: 332.6821961402893
},
{
rounds: 10000000,
f: [Function: reflect],
costed: 514.2599349021912
},
{
rounds: 10000000,
f: [Function: nul_creat],
costed: 675.6858191490173
},
{ rounds: 10000000, f: [Function: priv], costed: 2362.0123538970947 },
{
rounds: 10000000,
f: [Function: obj_with_gtst],
costed: 13023.659306049347
}
]
*/
- only work in nodejs, coz it use async_hook
var a = new Ahook();
a.enable();
> a.lst_
{
id: 222,
type: 'TickObject',
trigger: 5,
resource: {
callback: [Function: afterWriteTick],
args: [ [Object] ],
[Symbol(async_id_symbol)]: 222,
[Symbol(trigger_async_id_symbol)]: 5
}
}
> a.Timeout_
[
{
id: 201,
type: 'Timeout',
trigger: 5,
resource: Timeout {
_idleTimeout: 15,
_idlePrev: null,
_idleNext: null,
_idleStart: 75616,
_onTimeout: [Function: flushHistory],
_timerArgs: undefined,
_repeat: null,
_destroyed: true,
[Symbol(refed)]: true,
[Symbol(kHasPrimitive)]: false,
[Symbol(asyncId)]: 201,
[Symbol(triggerId)]: 5
}
},
{
id: 202,
type: 'Timeout',
trigger: 5,
resource: {
callback: [Function: maybeReadMore_],
args: [Array],
[Symbol(async_id_symbol)]: 202,
[Symbol(trigger_async_id_symbol)]: 5
}
},
......
]
a.disable();
Ahook.prototype.enable
Ahook.prototype.disable
Ahook.prototype.clear
Ahook.prototype.FSEVENTWRAP_ Ahook.prototype.FSREQCALLBACK_
Ahook.prototype.GETADDRINFOREQWRAP_ Ahook.prototype.GETNAMEINFOREQWRAP_
Ahook.prototype.HTTPCLIENTREQUEST_ Ahook.prototype.HTTPINCOMINGMESSAGE_
Ahook.prototype.Immediate_ Ahook.prototype.JSSTREAM_
Ahook.prototype.Microtask_ Ahook.prototype.PBKDF2REQUEST_
Ahook.prototype.PIPECONNECTWRAP_ Ahook.prototype.PIPEWRAP_
Ahook.prototype.PROCESSWRAP_ Ahook.prototype.PROMISE_
Ahook.prototype.QUERYWRAP_ Ahook.prototype.RANDOMBYTESREQUEST_
Ahook.prototype.SHUTDOWNWRAP_ Ahook.prototype.SIGNALWRAP_
Ahook.prototype.SSLCONNECTION_ Ahook.prototype.STATWATCHER_
Ahook.prototype.TCPCONNECTWRAP_ Ahook.prototype.TCPSERVERWRAP_
Ahook.prototype.TCPWRAP_ Ahook.prototype.TLSWRAP_
Ahook.prototype.TTYWRAP_ Ahook.prototype.TickObject_
Ahook.prototype.Timeout_ Ahook.prototype.UDPSENDWRAP_
Ahook.prototype.UDPWRAP_ Ahook.prototype.WRITEWRAP_
Ahook.prototype.ZLIB_
Ahook.prototype.all_
Ahook.prototype.length_
Ahook.prototype.lst_
- sync(rounds,f,...args)
- async(rounds,f,...args)
- cmp(rounds,func_ary,...args)
- acmp(rounds,func_ary,...args)
- fastest(rounds,func_ary,...args)
- afastest(rounds,func_ary,...args)
> var i =0
> var f0 = ()=>i++ //a little little slightly faster,can be ignored
> var f1 = ()=>i=i+1
> const {sync} = require("nv-facutil-simple-test");
> sync(10000000,f0)
{ rounds: 10000000, f: [Function: f0], costed: 127.74292135238647 }
> sync(10000000,f1)
{ rounds: 10000000, f: [Function: f1], costed: 130.06517267227173 }
> sync(10000000,f0)
{ rounds: 10000000, f: [Function: f0], costed: 139.97180604934692 }
> sync(10000000,f1)
{ rounds: 10000000, f: [Function: f1], costed: 130.97596168518066 }
> sync(10000000,f0)
{ rounds: 10000000, f: [Function: f0], costed: 132.0758399963379 }
> sync(10000000,f1)
{ rounds: 10000000, f: [Function: f1], costed: 144.76730298995972 }
>
> sync(100000000,f0)
{ rounds: 100000000, f: [Function: f0], costed: 1218.9988231658936 }
> sync(100000000,f1)
{ rounds: 100000000, f: [Function: f1], costed: 1279.4322390556335 }
> sync(100000000,f0)
{ rounds: 100000000, f: [Function: f0], costed: 1324.279109954834 }
> sync(100000000,f1)
{ rounds: 100000000, f: [Function: f1], costed: 1343.4789361953735 }
>
> sync(100000000,f0)
{ rounds: 100000000, f: [Function: f0], costed: 1257.3673729896545 }
> sync(100000000,f1)
{ rounds: 100000000, f: [Function: f1], costed: 1372.1064085960388 }
>
> var f0 = (a,b)=>a>b;
> var f1 = (i)=>i++;
> sync(10000000,f0,100,200)
{ rounds: 10000000, f: [Function: f0], costed: 215.06074380874634 }
> sync(10000000,f1,3)
{ rounds: 10000000, f: [Function: f1], costed: 236.30819702148438 }
> i =0
0
> var f2 = ()=>i++;
> sync(10000000,f2)
> sync(10000000,f0,100,200)
{ rounds: 10000000, f: [Function: f0], costed: 209.85319900512695 }
>
{ rounds: 10000000, f: [Function: f2], costed: 235.23615026474 }
const x = require("nv-facutil-simple-test")
function push_and_then_shift(arr,v) {
arr.push(v)
arr.shift()
}
function just_move_ele(arr,v) {
let lngth = arr.length;
for(let i=0;i<lngth-1;i++) {
arr[i]= arr[i+1]
}
arr[lngth-1] = v
}
> push_and_then_shift(arr0,8888)
> arr0
[ 20, 30, 40, 8888 ]
>
> just_move_ele(arr0,7777)
> arr0
[ 30, 40, 8888, 7777 ]
>
//seemed just_move_ele MAYBE faster
var arr = [10,20,30,40]
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 161.05021619796753
}
>
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 162.34449529647827
},
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 385.70706367492676
}
]
> x.sync(10000000,just_move_ele,arr0,888)
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 202.35962390899658
}
> x.sync(10000000,push_and_then_shift,arr0,888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 382.8467917442322
}
>
//seemed push_and_then_shift MAYBE faster
var arr0 = Array.from({length:128}).map((r,i)=>i)
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 1024.305088043213
}
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 947.6514468193054
},
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 1104.9360208511353
}
]
>
> x.sync(10000000,just_move_ele,arr0,888)
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 1109.8695631027222
}
> x.sync(10000000,push_and_then_shift,arr0,888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 999.6719512939453
}
>
var arr0 = Array.from({length:2**26}).map((r,i)=>i)
x.fastest(100,[push_and_then_shift,just_move_ele],arr0,8888)
> x.fastest(100,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 100,
f: [Function: push_and_then_shift],
costed: 6895.157344341278
}
var arr0 = Array.from({length:2**16}).map((r,i)=>i)
> x.fastest(100000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 100000,
f: [Function: push_and_then_shift],
costed: 2241.0950689315796
}
>
var arr0 = Array.from({length:2**15}).map((r,i)=>i)
x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 9688.172526836395
}
>
> var arr0 = Array.from({length:2**14}).map((r,i)=>i)
>
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 4321.872590065002
}
>
var arr0 = Array.from({length:2**13}).map((r,i)=>i)
x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
> var arr0 = Array.from({length:2**13}).map((r,i)=>i)
>
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 113.6801929473877
}
>
var arr0 = Array.from({length:2**12}).map((r,i)=>i)
x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 139.2634081840515
}
var arr0 = Array.from({length:2**11}).map((r,i)=>i)
x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 112.35720729827881
}
var arr0 = Array.from({length:2**10}).map((r,i)=>i)
x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 109.84335327148438
}
>
var arr0 = Array.from({length:2**9}).map((r,i)=>i)
x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> x.fastest(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 104.96030282974243
}
> x.cmp(1000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 1000000,
f: [Function: push_and_then_shift],
costed: 109.10006427764893
},
{
rounds: 1000000,
f: [Function: just_move_ele],
costed: 354.9349093437195
}
]
>
*/
var arr0 = Array.from({length:2**8}).map((r,i)=>i)
x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 965.2179284095764
}
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 1006.8404927253723
},
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 1912.6992869377136
}
]
>
*/
var arr0 = Array.from({length:2**7}).map((r,i)=>i)
x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> var arr0 = Array.from({length:2**7}).map((r,i)=>i)
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 975.0886740684509
}
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 1021.1277914047241
},
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 1123.0839891433716
}
]
>
*/
var arr0 = Array.from({length:2**6}).map((r,i)=>i)
x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 506.3333601951599
}
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 634.4168033599854
},
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 697.2383561134338
}
]
>
*/
var arr0 = Array.from({length:2**5}).map((r,i)=>i)
x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> var arr0 = Array.from({length:2**5}).map((r,i)=>i)
undefined
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 270.8724579811096
}
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 266.78145694732666
},
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 378.65622091293335
}
]
>
*/
var arr0 = Array.from({length:2**4}).map((r,i)=>i)
x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> x.fastest(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 228.02108192443848
}
> x.cmp(10000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 10000000,
f: [Function: push_and_then_shift],
costed: 259.8764510154724
},
{
rounds: 10000000,
f: [Function: just_move_ele],
costed: 264.2375192642212
}
]
>
*/
var arr0 = Array.from({length:2**3}).map((r,i)=>i)
x.fastest(100000000,[push_and_then_shift,just_move_ele],arr0,8888)
x.cmp(100000000,[push_and_then_shift,just_move_ele],arr0,8888)
/*
> x.fastest(100000000,[push_and_then_shift,just_move_ele],arr0,8888)
{
rounds: 100000000,
f: [Function: just_move_ele],
costed: 1979.1184711456299
}
> x.cmp(100000000,[push_and_then_shift,just_move_ele],arr0,8888)
[
{
rounds: 100000000,
f: [Function: just_move_ele],
costed: 2022.5493369102478
},
{
rounds: 100000000,
f: [Function: push_and_then_shift],
costed: 2156.524836063385
}
]
>
*/
const {sync,mem_change} = require("nv-facutil-simple-test")
class GPS0 {
constructor(lat,lon,alt) {
this.latitude = lat;
this.longitude = lon;
this.altitude = alt;
}
}
class GPS1 {
constructor(lat,lon,alt) {
this.x = lat;
this.y = lon;
this.z = alt;
}
get latitude_() {return(this.x)}
get longitude_() {return(this.y)}
get altitude_() {return(this.z)}
}
function f0() {return(new GPS0(100,100,100))}
function f1() {return(new GPS1(100,100,100))}
sync(5000000,f0)
sync(5000000,f1)
/* creat speed nearly same
> sync(5000000,f0)
{ rounds: 5000000, f: [Function: f0], costed: 88.10719192028046 }
> sync(5000000,f1)
{ rounds: 5000000, f: [Function: f1], costed: 86.56737101078033 }
>
> sync(5000000,f0)
{ rounds: 5000000, f: [Function: f0], costed: 87.2494729757309 }
> sync(5000000,f1)
{ rounds: 5000000, f: [Function: f1], costed: 89.2833321094513 }
>
*/
> process.memoryUsage()
{
rss: 46972928,
heapTotal: 8511488,
heapUsed: 6355072,
external: 1058023,
arrayBuffers: 17147
}
>
> mem_change()
{
rss: -2600960,
heapTotal: -3145728,
heapUsed: -1426304,
external: 4,
arrayBuffers: -15
}
> mem_change()
{ rss: 0, heapTotal: 0, heapUsed: 83224, external: 4, arrayBuffers: 4 }
>
var arr0 = Array.from({length:1000000})
var arr1 = Array.from({length:1000000})
> mem_change()
{
rss: 14991360,
heapTotal: 16277504,
heapUsed: 15118816,
external: -1823,
arrayBuffers: -1056
}
>
arr0.forEach((r,i)=>{arr0[i]=f0()})
> mem_change()
{
rss: 72437760,
heapTotal: 63700992,
heapUsed: 47852128,
external: -1138,
arrayBuffers: 1
}
>
arr1.forEach((r,i)=>{arr0[i]=f1()})
> mem_change()
{
rss: 35741696,
heapTotal: 31457280,
heapUsed: 33430368, //
external: 35,
arrayBuffers: 36
}
>
var u8a = new Uint8Array(4);
var f0 = (o)=>(o instanceof Uint8Array);
var f1 = (o)=>o.constructor.name === 'Uint8Array';
> f0(u8a)
true
> f1(u8a)
true
>
> x.sync(10000000,f0,u8a)
{ rounds: 10000000, f: [Function: f0], costed: 148.99506187438965 }
>
> x.sync(10000000,f1,u8a)
{ rounds: 10000000, f: [Function: f1], costed: 385.277530670166 }
> x.sync(20000000,f0,u8a)
{ rounds: 20000000, f: [Function: f0], costed: 294.7771701812744 }
>
> x.sync(20000000,f1,u8a)
{ rounds: 20000000, f: [Function: f1], costed: 673.4802875518799 }
>
const {sync} = require("../index");
var ra = ["v0","v1"]
const get_from_rawa_with_index = ()=>[ra[0],ra[1]]
sync(10000000,get_from_rawa_with_index)
/*
> sync(10000000,get_from_rawa_with_index)
{
rounds: 10000000,
f: [Function: get_from_rawa_with_index],
costed: 210.45516967773438
}
> sync(10000000,get_from_rawa_with_index)
{
rounds: 10000000,
f: [Function: get_from_rawa_with_index],
costed: 211.53196907043457
}
> sync(10000000,get_from_rawa_with_index)
{
rounds: 10000000,
f: [Function: get_from_rawa_with_index],
costed: 208.35104370117188
}
> sync(10000000,get_from_rawa_with_index)
{
rounds: 10000000,
f: [Function: get_from_rawa_with_index],
costed: 216.23346519470215
}
>
*/
class EA extends Array {
constructor(v0,v1) {
super();
this.push(v0,v1)
}
get v0() {return(this[0])}
get v1() {return(this[1])}
}
var ea = new EA("v0","v1")
const get_from_ea_with_index = ()=>[ea[0],ea[1]]
sync(10000000,get_from_ea_with_index)
/*
> sync(10000000,get_from_ea_with_index)
{
rounds: 10000000,
f: [Function: get_from_ea_with_index],
costed: 202.84191703796387
}
> sync(10000000,get_from_ea_with_index)
{
rounds: 10000000,
f: [Function: get_from_ea_with_index],
costed: 215.38772010803223
}
> sync(10000000,get_from_ea_with_index)
{
rounds: 10000000,
f: [Function: get_from_ea_with_index],
costed: 214.39294815063477
}
> sync(10000000,get_from_ea_with_index)
{
rounds: 10000000,
f: [Function: get_from_ea_with_index],
costed: 210.52841758728027
}
>
*/
const get_from_ea_with_getter = ()=>[ea.v0,ea.v1]
sync(10000000,get_from_ea_with_getter)
/*
> sync(10000000,get_from_ea_with_getter)
{
rounds: 10000000,
f: [Function: get_from_ea_with_getter],
costed: 208.8599624633789
}
> sync(10000000,get_from_ea_with_getter)
{
rounds: 10000000,
f: [Function: get_from_ea_with_getter],
costed: 199.53731155395508
}
> sync(10000000,get_from_ea_with_getter)
{
rounds: 10000000,
f: [Function: get_from_ea_with_getter],
costed: 205.06519317626953
}
> sync(10000000,get_from_ea_with_getter)
{
rounds: 10000000,
f: [Function: get_from_ea_with_getter],
costed: 209.24454879760742
}
>
*/
var rd = {v0:"v0",v1:"v1"}
const get_from_rd = ()=> [rd.v0,rd.v1]
sync(10000000,get_from_rd)
/*
> sync(10000000,get_from_rd)
{
rounds: 10000000,
f: [Function: get_from_rd],
costed: 201.54963493347168
}
> sync(10000000,get_from_rd)
{
rounds: 10000000,
f: [Function: get_from_rd],
costed: 203.9611873626709
}
> sync(10000000,get_from_rd)
{
rounds: 10000000,
f: [Function: get_from_rd],
costed: 211.65743827819824
}
>
*/
var mp = new Map(Object.entries(rd));
const get_from_mp = () =>[mp.get("v0"),mp.get("v1")]
sync(10000000,get_from_mp)
/*
> sync(10000000,get_from_mp)
{
rounds: 10000000,
f: [Function: get_from_mp],
costed: 431.3168029785156
}
> sync(10000000,get_from_mp)
{
rounds: 10000000,
f: [Function: get_from_mp],
costed: 436.4684009552002
}
> sync(10000000,get_from_mp)
{
rounds: 10000000,
f: [Function: get_from_mp],
costed: 453.76171684265137
}
> sync(10000000,get_from_mp)
{
rounds: 10000000,
f: [Function: get_from_mp],
costed: 470.9776554107666
}
>
*/
class D {
v0="v0"
v1="v1"
}
var d = new D()
const get_from_d = ()=> [d.v0,d.v1]
/*
> sync(10000000,get_from_d)
{
rounds: 10000000,
f: [Function: get_from_d],
costed: 201.63967323303223
}
> sync(10000000,get_from_d)
{
rounds: 10000000,
f: [Function: get_from_d],
costed: 200.51382064819336
}
> sync(10000000,get_from_d)
{
rounds: 10000000,
f: [Function: get_from_d],
costed: 201.8022174835205
}
> sync(10000000,get_from_d)
{
rounds: 10000000,
f: [Function: get_from_d],
costed: 228.96243858337402
}
>
*/
class PA extends Array {
constructor(v0,v1) {
super();
this.push(v0,v1)
}
}
Object.defineProperty(PA.prototype,"v0",{get:function(){return(this[0])}})
Object.defineProperty(PA.prototype,"v1",{get:function(){return(this[1])}})
var pa = new PA("v0","v1")
/*
> pa
PA(2) [ 'v0', 'v1' ]
>
*/
const get_from_pa_with_index = ()=>[pa[0],pa[1]]
/*
> sync(10000000,get_from_pa_with_index)
{
rounds: 10000000,
f: [Function: get_from_pa_with_index],
costed: 207.52319526672363
}
> sync(10000000,get_from_pa_with_index)
{
rounds: 10000000,
f: [Function: get_from_pa_with_index],
costed: 212.59967613220215
}
> sync(10000000,get_from_pa_with_index)
{
rounds: 10000000,
f: [Function: get_from_pa_with_index],
costed: 211.38087272644043
}
> sync(10000000,get_from_pa_with_index)
{
rounds: 10000000,
f: [Function: get_from_pa_with_index],
costed: 222.359037399292
}
>
*/
const get_from_pa_with_getter = ()=>[pa.v0,pa.v1]
/*
> sync(10000000,get_from_pa_with_getter)
{
rounds: 10000000,
f: [Function: get_from_pa_with_getter],
costed: 207.68007278442383
}
> sync(10000000,get_from_pa_with_getter)
{
rounds: 10000000,
f: [Function: get_from_pa_with_getter],
costed: 208.297456741333
}
> sync(10000000,get_from_pa_with_getter)
{
rounds: 10000000,
f: [Function: get_from_pa_with_getter],
costed: 223.48654747009277
}
> sync(10000000,get_from_pa_with_getter)
{
rounds: 10000000,
f: [Function: get_from_pa_with_getter],
costed: 226.50678253173828
}
> sync(10000000,get_from_pa_with_getter)
{
rounds: 10000000,
f: [Function: get_from_pa_with_getter],
costed: 211.12835502624512
}
>
*/
var a = ["v0","v1"]
var px = new Proxy(
a,
{
get: function(target, property, receiver) {
if(property === "v0") {
return(Reflect.get(target,0))
} else if(property === "v1") {
return(Reflect.get(target,1))
} else {
return(Reflect.get(target,property))
}
}
}
)
/*
> px.v0
'v0'
> px.v1
'v1'
> px[0]
'v0'
> px[1]
'v1'
>
*/
const get_from_px_with_index = ()=>[px[0],px[1]]
/*
> sync(10000000,get_from_px_with_index)
{
rounds: 10000000,
f: [Function: get_from_px_with_index],
costed: 6042.160470962524
}
> sync(10000000,get_from_px_with_index)
{
rounds: 10000000,
f: [Function: get_from_px_with_index],
costed: 6012.279012680054
}
>
*/
const get_from_px_with_prop = ()=>[px.v0,px.v1]
/*
> sync(10000000,get_from_px_with_prop)
{
rounds: 10000000,
f: [Function: get_from_px_with_prop],
costed: 1954.2461643218994
}
> sync(10000000,get_from_px_with_prop)
{
rounds: 10000000,
f: [Function: get_from_px_with_prop],
costed: 1921.415605545044
}
> sync(10000000,get_from_px_with_prop)
{
rounds: 10000000,
f: [Function: get_from_px_with_prop],
costed: 1951.849027633667
}
>
*/
const rnd_sen = require("nv-random-sentence");
var D = {}
const creat_frag = (D,idx) =>{
let d = {}
for(let i=0;i<500000;i++) {
let k = rnd_sen.NVN_
d[k] = rnd_sen.NVN_
D[k] = d[k]
}
fs.writeFileSync(`frag${idx}.json`,JSON.stringify(d))
}
for(let idx=0;idx<10;idx++) {
creat_frag(D,idx)
}
TEST# ls -l
total 275796
-rw-r--r-- 1 root root 28234445 Oct 19 15:33 frag0.json
-rw-r--r-- 1 root root 28243940 Oct 19 15:33 frag1.json
-rw-r--r-- 1 root root 28241764 Oct 19 15:33 frag2.json
-rw-r--r-- 1 root root 28240741 Oct 19 15:33 frag3.json
-rw-r--r-- 1 root root 28245468 Oct 19 15:33 frag4.json
-rw-r--r-- 1 root root 28239630 Oct 19 15:33 frag5.json
-rw-r--r-- 1 root root 28240529 Oct 19 15:33 frag6.json
-rw-r--r-- 1 root root 28239675 Oct 19 15:34 frag7.json
-rw-r--r-- 1 root root 28232199 Oct 19 15:34 frag8.json
-rw-r--r-- 1 root root 28237992 Oct 19 15:34 frag9.json
TEST#
> Object.keys(D).length
5000000
>
const len = (D)=>Object.keys(D).length;
/*
> sync(10,len,D)
{ rounds: 10, f: [Function: len], costed: 41091.69201660156 } //計算一個length就需要4秒
>
*/
const get = (k)=>D[k];
> get('dialyzer_chouse_brill')
'callboard_imitate_estaminet'
>
> sync(10000000,get,'dialyzer_chouse_brill')
{ rounds: 10000000, f: [Function: get], costed: 253.25781440734863 }
>
.exit
var entries = Array(5000000);
for(let i=0;i<5000000;i++) {
entries[i] = ['','']
}
var c = 0
for(let idx=0;idx<10;idx++) {
let frag = JSON.parse(fs.readFileSync(`frag${idx}.json`).toString());
for(let k in frag) {
entries[c] = [k,frag[k]]
c=c+1;
}
}
> entries.length
5000000
const len = (es)=>es.length;
> sync(10,len,entries)
{ rounds: 10, f: [Function: len], costed: 0.028247833251953125 } //計算length基本不需要時間
>
> entries[2500000]
[ 'dialyzer_chouse_brill', 'callboard_imitate_estaminet' ]
>
const get = (k)=> {
for(let i=0;i<5000000;i++) {
if(entries[i][0] === k) {
return(entries[i][1])
}
}
}
> get('dialyzer_chouse_brill')
'callboard_imitate_estaminet'
>
> sync(10,get,'dialyzer_chouse_brill')
{ rounds: 10, f: [Function: get], costed: 263.88294410705566 } //耗時不可接受 單次需要25毫秒
>
.exit
var mp = new Map();
for(let idx=0;idx<10;idx++) {
let frag = JSON.parse(fs.readFileSync(`frag${idx}.json`).toString());
for(let k in frag) {
mp.set(k,frag[k])
}
}
const len = (mp)=>mp.size;
> sync(10,len,mp)
{ rounds: 10, f: [Function: len], costed: 0.009061813354492188 } //計算length基本不需要時間
>
const get = (k)=> {
return(mp.get(k))
}
> get('dialyzer_chouse_brill')
'callboard_imitate_estaminet'
>
> sync(10000000,get,'dialyzer_chouse_brill')
{ rounds: 10000000, f: [Function: get], costed: 390.18969535827637 } //1千萬次調用get 400ms，單次耗時忽略不記
>
.exit
var entries = Array(5000000);
for(let i=0;i<5000000;i++) {
entries[i] = ['','']
}
var c = 0
for(let idx=0;idx<10;idx++) {
let frag = JSON.parse(fs.readFileSync(`frag${idx}.json`).toString());
for(let k in frag) {
entries[c] = [k,frag[k]]
entries[k] = frag[k]
c=c+1;
}
}
var PAIR_WITH_ARY_TYPE_MARK = [100,200];
var FST;
var SND;
var f0 = () => {
[FST,SND] = PAIR_WITH_ARY_TYPE_MARK;
}
var f1 = () => {
FST = PAIR_WITH_ARY_TYPE_MARK[0];
SND = PAIR_WITH_ARY_TYPE_MARK[1];
}
console.log(sync(100000000,f0))
console.log(sync(100000000,f1))
/*
> console.log(sync(100000000,f0))
{ rounds: 100000000, f: [Function: f0], costed: 1398.456472992897 }
> console.log(sync(100000000,f1))
{ rounds: 100000000, f: [Function: f1], costed: 1185.4215869903564 }
//--- this is because , the destrotor need to call iterator
*/
var ary = [1,2,3,4,5,6];
var FST;
var SND;
var TRD;
var QUA;
var PNT;
var HEX;
var f0 = () => {[FST,SND,TRD,QUA,PNT,HEX] = ary;}
var f1 = () => {
FST = ary[0];
SND = ary[1];
TRD = ary[2];
QUA = ary[3];
PNT = ary[4];
HEX = ary[5];
}
console.log(sync(100000000,f0))
console.log(sync(100000000,f1))
/*
{ rounds: 100000000, f: [Function: f0], costed: 1607.1520830392838 }
{ rounds: 100000000, f: [Function: f1], costed: 897.0708520412445 }
// 被解構的結構越複雜 這個差異越明顯
*/
10000
{
rounds: 65536,
f: [Function: using_char_code_at],
costed: 5297.109977960587
}
{
rounds: 65536,
f: [Function: using_many_if],
costed: 6676.725782871246
}
{
rounds: 65536,
f: [Function: using_many_case],
costed: 6721.5950429439545
}
{ rounds: 65536, f: [Function: using_tbl], costed: 18946.27202105522 }
const make_using_u16a = (dt=new Date) => {
let mts = dt.getTime();
let r0 = mts % 4294967296;
let q0 = (mts - r0)/4294967296;
let r1 = r0 % (65536);
let q1 = (r0-r1) /65536;
let u16a = new Uint16Array(4);
u16a[3] = 0x7ffa;
u16a[2]=q0;
u16a[1]=q1;
u16a[0]=r1;
return(new Uint8Array(u16a.buffer))
}
const make_using_u32a = (dt=new Date) => {
let mts = dt.getTime();
let r0 = mts % 4294967296;
let q0 = (mts - r0)/4294967296;
let u32a = new Uint32Array(2);
u32a[1] = 0x7ffa0000 | q0;
u32a[0] = r0 ;
return(new Uint8Array(u32a.buffer))
}
const make_using_u64a = (dt=new Date) => {
let mts = dt.getTime();
let u64a = new BigUint64Array(1);
u64a[0] = BigInt(mts);
let u16a = new Uint16Array(u64a.buffer);
u16a[3] = 0x7ffa;
return(new Uint8Array(u64a.buffer))
}
const {sync} = require("nv-facutil-simple-test");
console.log(sync(10000000,make_using_u16a))
console.log(sync(10000000,make_using_u32a))
console.log(sync(10000000,make_using_u64a))
/*
{
rounds: 10000000,
f: [Function: make_using_u16a],
costed: 6253.4816637039185
}
{
rounds: 10000000,
f: [Function: make_using_u32a],
costed: 6245.351312637329
}
{
rounds: 10000000,
f: [Function: make_using_u64a],
costed: 7142.871691703796
}
*/
class V {
_v =888
set v(val) { console.log("setter enter");this._v=val; console.log("setter exit");}
get v() { console.log("getter enter");return(this._v);}
}
/*
> ++v.v
getter enter
setter enter
setter exit
889
> v
V { _v: 889 }
>
> v.v++
getter enter
setter enter
setter exit
889
> v
V { _v: 890 }
> v.v = 0
setter enter
setter exit
0
*/
/*
> (1+v.v++)
getter enter
setter enter
setter exit
1
> v.v = 0
setter enter
setter exit
0
>
*/
/*
> (1+ ++v.v)
getter enter
setter enter
setter exit
2
> (((v.v)))++
getter enter
setter enter
setter exit
1
>
*/
class V1 {
_v =888
set v(val) { this._v=val;}
get v() { return(this._v);}
}
var v = 888;
var v1 = new V1();
var v2 = {v:888}
var f0 = ()=>++v;
var f1 = ()=>++v1.v;
var f2 = ()=>++v2.v;
console.log(sync(1000000000,f0))
//{ rounds: 1000000000, f: [Function: f0], costed: 12089.421229362488 }
console.log(sync(1000000000,f1))
//{ rounds: 1000000000, f: [Function: f1], costed: 12359.855974197388 }
console.log(sync(1000000000,f2))
//{ rounds: 1000000000, f: [Function: f2], costed: 7612.168771743774 }
/*
> v
1000000888
> v1
V1 { _v: 1000000888 }
> v2
{ v: 1000000888 }
>
*/
console.log(sync(1000000000,f0))
//{ rounds: 1000000000, f: [Function: f0], costed: 7590.657766342163 }
console.log(sync(1000000000,f1))
//{ rounds: 1000000000, f: [Function: f1], costed: 7561.783745765686 }
console.log(sync(1000000000,f2))
//{ rounds: 1000000000, f: [Function: f2], costed: 11850.260585784912 }
console.log(sync(1000000000,f0))
//{ rounds: 1000000000, f: [Function: f0], costed: 19522.066294670105 }
console.log(sync(1000000000,f1))
//{ rounds: 1000000000, f: [Function: f1], costed: 9180.399136543274 }
console.log(sync(1000000000,f2))
//{ rounds: 1000000000, f: [Function: f2], costed: 13682.482397079468 }
console.log(sync(1000000000,f0))
console.log(sync(1000000000,f1))
console.log(sync(1000000000,f2))
> console.log(sync(1000000000,f0))
{ rounds: 1000000000, f: [Function: f0], costed: 28632.76893234253 }
> console.log(sync(1000000000,f1))
{ rounds: 1000000000, f: [Function: f1], costed: 9588.860234260559 }
> console.log(sync(1000000000,f2))
{ rounds: 1000000000, f: [Function: f2], costed: 14136.279594421387 }