nv-time-now 1.0.0

package/TEST/check-diff.js

@@ -0,0 +1,133 @@
+// compare_time.js
+const { performance } = require('perf_hooks');
+const timeFunc = require('../index');
+
+// 测试配置
+const ITERATIONS = 100_000_000; // 1亿次
+const REPORT_INTERVAL = 10_000_000; // 每1000万次报告一次进度
+
+// 统计变量
+let countEqual = 0;
+let countGreater = 0;
+let countLess = 0;
+let totalDiff = 0; // timeFunc - Date.now()
+let totalAbsDiff = 0; // |timeFunc - Date.now()|
+let minDiff = Infinity;
+let maxDiff = -Infinity;
+let lastReportTime = performance.now();
+
+// 主测试函数
+function runComparisonTest() {
+    console.log(`开始比较测试，共 ${ITERATIONS.toLocaleString()} 次调用...`);
+    console.log('='.repeat(60));
+    
+    for (let i = 0; i < ITERATIONS; i++) {
+        const t1 = timeFunc();
+        const t2 = Date.now();
+        const diff = t1 - t2;
+        
+        // 更新统计
+        if (diff === 0) {
+            countEqual++;
+        } else if (diff > 0) {
+            countGreater++;
+        } else {
+            countLess++;
+        }
+        
+        totalDiff += diff;
+        totalAbsDiff += Math.abs(diff);
+        
+        if (diff < minDiff) minDiff = diff;
+        if (diff > maxDiff) maxDiff = diff;
+        
+        // 定期报告进度
+        if ((i + 1) % REPORT_INTERVAL === 0) {
+            const currentTime = performance.now();
+            const elapsed = (currentTime - lastReportTime) / 1000;
+            const progress = ((i + 1) / ITERATIONS * 100).toFixed(1);
+            console.log(`进度: ${progress}% | 已用时间: ${elapsed.toFixed(1)}秒 | 当前差值: ${diff}`);
+            lastReportTime = currentTime;
+        }
+    }
+    
+    // 计算结果
+    const avgDiff = totalDiff / ITERATIONS;
+    const avgAbsDiff = totalAbsDiff / ITERATIONS;
+    const totalCount = countEqual + countGreater + countLess;
+    
+    // 输出结果
+    console.log('='.repeat(60));
+    console.log('测试结果汇总:');
+    console.log(`总调用次数: ${ITERATIONS.toLocaleString()}`);
+    console.log(`相等次数 (==): ${countEqual.toLocaleString()} (${(countEqual/totalCount*100).toFixed(4)}%)`);
+    console.log(`大于次数 (>): ${countGreater.toLocaleString()} (${(countGreater/totalCount*100).toFixed(4)}%)`);
+    console.log(`小于次数 (<): ${countLess.toLocaleString()} (${(countLess/totalCount*100).toFixed(4)}%)`);
+    console.log('-'.repeat(40));
+    console.log(`平均差值 (timeFunc - Date.now): ${avgDiff.toFixed(6)} ms`);
+    console.log(`平均绝对差值: ${avgAbsDiff.toFixed(6)} ms`);
+    console.log(`最小差值: ${minDiff.toFixed(6)} ms`);
+    console.log(`最大差值: ${maxDiff.toFixed(6)} ms`);
+    console.log('='.repeat(60));
+    
+    // 分析结论
+    analyzeResults(countEqual, countGreater, countLess, avgDiff, avgAbsDiff);
+}
+
+// 结果分析函数
+function analyzeResults(equal, greater, less, avgDiff, avgAbsDiff) {
+    console.log('\n分析结论:');
+    
+    // 1. 比较关系分析
+    if (equal > 0) {
+        console.log(`- 发现 ${equal} 次相等情况，表明两个函数在相同时间点可能返回相同值`);
+    }
+    
+    if (greater > less) {
+        console.log(`- timeFunc 大于 Date.now() 的情况更多 (${greater} > ${less})`);
+    } else if (less > greater) {
+        console.log(`- timeFunc 小于 Date.now() 的情况更多 (${less} > ${greater})`);
+    } else {
+        console.log(`- timeFunc 和 Date.now() 大小关系均衡 (${greater} = ${less})`);
+    }
+    
+    // 2. 差值分析
+    if (Math.abs(avgDiff) < 1) {
+        console.log(`- 平均差值接近零 (${avgDiff.toFixed(6)} ms)，表明两个函数高度同步`);
+    } else if (avgDiff > 0) {
+        console.log(`- 平均而言，timeFunc 比 Date.now() 大 ${avgDiff.toFixed(3)} ms`);
+    } else {
+        console.log(`- 平均而言，timeFunc 比 Date.now() 小 ${(-avgDiff).toFixed(3)} ms`);
+    }
+    
+    // 3. 精度分析
+    if (avgAbsDiff < 0.1) {
+        console.log(`- 平均绝对差值很小 (${avgAbsDiff.toFixed(3)} ms)，表明两个函数非常接近`);
+    } else if (avgAbsDiff < 1) {
+        console.log(`- 平均绝对差值较小 (${avgAbsDiff.toFixed(3)} ms)，表明两个函数基本一致`);
+    } else {
+        console.log(`- 平均绝对差值较大 (${avgAbsDiff.toFixed(3)} ms)，表明两个函数存在显著差异`);
+    }
+    
+    // 4. 误差来源解释
+    console.log('\n误差来源分析:');
+    console.log('- timeFunc 基于进程启动时的时间戳，而 Date.now() 基于系统时间');
+    console.log('- 系统时间调整（NTP同步、用户修改）会导致 Date.now() 突变');
+    console.log('- 高精度计时器(performance.now)与系统时钟可能存在微小漂移');
+    console.log('- JavaScript事件循环和CPU调度可能导致测量微小偏差');
+    
+    // 5. 使用建议
+    console.log('\n使用建议:');
+    if (avgAbsDiff < 0.5) {
+        console.log('✅ 对于大多数应用，timeFunc 可以替代 Date.now()，提供更高精度');
+    } else {
+        console.log('⚠️ 当需要精确时间时，建议直接使用 Date.now() 或 performance.now()');
+    }
+    
+    if (Math.abs(avgDiff) > 5) {
+        console.log('⚠️ 注意：两个函数存在系统性偏差，不适合需要精确同步的场景');
+    }
+}
+
+// 执行测试
+runComparisonTest();

package/TEST/check.js

@@ -0,0 +1,98 @@
+// check.js (修改后的版本)
+const timeFunc = require('../index');
+const { performance } = require('perf_hooks');
+
+function testMonotonicity(iterations = 10_000_000) {
+    console.log(`开始测试 ${iterations.toLocaleString()} 次调用...`);
+    
+    let last = -Infinity;
+    let violations = 0;       // 后值 < 前值
+    let equalCount = 0;       // 后值 == 前值
+    let greaterCount = 0;     // 后值 > 前值
+    let minIncrement = Infinity;
+    let maxIncrement = 0;
+    let lastPrint = 0;
+    
+    const startTime = performance.now();
+    
+    for (let i = 0; i < iterations; i++) {
+        const current = timeFunc();
+        
+        // 跳过第一次比较（没有前值）
+        if (i > 0) {
+            // 检查单调性
+            if (current < last) {
+                violations++;
+                // console.error(`❌ 违反单调性 @ ${i}: ${last} → ${current} (Δ${(current-last).toFixed(6)})`);
+            } else if (current === last) {
+                equalCount++;
+            } else {
+                greaterCount++;
+            }
+            
+            // 记录增量
+            const increment = current - last;
+            if (increment > 0 && increment < minIncrement) minIncrement = increment;
+            if (increment > maxIncrement) maxIncrement = increment;
+        }
+        
+        last = current;
+        
+        // 进度报告
+        if (i > 0 && i % 1_000_000 === 0) {
+            process.stdout.write('.');
+            lastPrint = i;
+        }
+    }
+    
+    const duration = performance.now() - startTime;
+    
+    // 计算比率
+    const totalComparisons = iterations - 1;
+    const violationRatio = (violations / totalComparisons * 100).toFixed(4);
+    const equalRatio = (equalCount / totalComparisons * 100).toFixed(4);
+    const greaterRatio = (greaterCount / totalComparisons * 100).toFixed(4);
+    
+    console.log('\n\n测试结果:');
+    console.log(`调用次数: ${iterations.toLocaleString()}`);
+    console.log(`比较次数: ${totalComparisons.toLocaleString()}`);
+    console.log(`后值 < 前值: ${violations.toLocaleString()} (${violationRatio}%)`);
+    console.log(`后值 == 前值: ${equalCount.toLocaleString()} (${equalRatio}%)`);
+    console.log(`后值 > 前值: ${greaterCount.toLocaleString()} (${greaterRatio}%)`);
+    console.log('-'.repeat(40));
+    console.log(`最小正增量: ${minIncrement === Infinity ? 'N/A' : minIncrement.toFixed(6)} ms`);
+    console.log(`最大增量: ${maxIncrement.toFixed(3)} ms`);
+    console.log(`总耗时: ${duration.toFixed(3)} ms`);
+    console.log(`平均耗时: ${(duration / iterations * 1000).toFixed(6)} μs/次`);
+    
+    return {
+        violations,
+        equalCount,
+        greaterCount,
+        minIncrement,
+        maxIncrement,
+        duration,
+        ratios: {
+            violationRatio,
+            equalRatio,
+            greaterRatio
+        }
+    };
+}
+
+// 执行测试
+const iterations = Number(process.argv[2] ?? 100000000);
+const result = testMonotonicity(iterations);
+const passed = result.violations === 0;
+
+console.log(`\n最终结果: ${passed ? '✅ 通过非递减测试' : '❌ 未通过测试'}`);
+console.log(`单调性: ${result.equalCount > 0 ? '非严格单调 (有相等值)' : '严格单调'}`);
+
+// 打印比率摘要
+console.log('\n比率摘要:');
+console.log(`后值 < 前值: ${result.ratios.violationRatio}%`);
+console.log(`后值 == 前值: ${result.ratios.equalRatio}%`);
+console.log(`后值 > 前值: ${result.ratios.greaterRatio}%`);
+console.log(`总和: ${(parseFloat(result.ratios.violationRatio) + parseFloat(result.ratios.equalRatio) + parseFloat(result.ratios.greaterRatio)).toFixed(4)}%`);
+
+

package/TEST/estimate.js

@@ -0,0 +1,21 @@
+const _debug_estimate_limit = ()=>{
+   var old = Date.now();
+   var c = 0;
+   while(true) {
+       var now = Date.now();
+       if(now === old) {
+           ++c;
+       } else {
+           break;
+       }
+   }
+   return c;
+}
+const debug_estimate_limit = (ROUNDS=1000000)=>{
+    var mx =0 ;
+    for(var i=0;i<ROUNDS;++i) {
+        var r = _debug_estimate_limit();
+        if(r>mx) {mx=r}
+    }
+    return mx
+}

package/TEST/tst-tmid.js

@@ -0,0 +1,34 @@
+const {mts_seq_pair} = require("../index")
+
+// 生成UUID
+const tmid = (salt_len=3) => {
+    var [mts, seq] = mts_seq_pair();
+    // mts 变成 hex  XXXXXXXXXXXX      最多6个不足前面补0       12个字符   
+    //  seq 变成 hex  XXXX ,            最多4个不足前面补0        4个字符
+    var mts_str = mts.toString(16);
+    mts_str = mts_str.slice(0,12);
+    mts_str = mts_str.padStart(12, '0');
+
+    var seq_str = seq.toString(16);
+    seq_str = seq_str.slice(0,4);
+    seq_str = seq_str.padStart(4, '0');
+
+    var salt = Math.random()*(2**53);
+    var salt_str = salt.toString(16);
+    salt_str = salt_str.slice(0,salt_len);
+    salt_str = salt_str.padStart(salt_len, '0');
+
+    // 组合成UUID格式：mts-seq-salt
+    return mts_str + "-" + seq_str + "-" + salt_str;
+}
+
+const extract_tmid = (tmseq)=>{
+    var mts  = parseInt(tmseq.substr(0, 12),16);  // 0-11: 12字符时间戳
+    var seq   = parseInt(tmseq.substr(13, 4),16);   // 13-16: 4字符序列ID
+    var salt = parseInt(tmseq.substr(18),   16);    // 18到结束: 盐值
+    return [new Date(mts),seq,salt]
+}
+
+id = tmid();
+console.log(id)
+console.log(extract_tmid(id))

package/index.js

@@ -0,0 +1,26 @@
+const ORIG0 = Date.now();
+const ORIG1 = performance.now();
+
+let OLD = Date.now();
+let  ID = 0;
+const mts_seq_pair = ()=>{
+    var now = Date.now();
+    if(now === OLD) {
+	++ID;
+	return [now,ID];
+    } else          {
+	var pair = [now,0];
+        OLD = now;
+	ID = 0;
+	return pair;
+    }
+}
+
+const PRECISION = 0.0009765625;
+module.exports       = ()=>ORIG0 + (performance.now()-ORIG1);
+module.exports.PRECISION = PRECISION;
+
+
+module.exports.mts_seq_pair  = mts_seq_pair;
+
+

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "nv-time-now",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}