Javascript 为什么使用缓冲区转换日期格式比使用字符串操作慢？

考虑以下代码：

    //Buffers and views
    function convertDateTimeToFormat(date, format) {
        var buf = new ArrayBuffer(14);
        var result = new Uint8Array(buf);
        var positions = {
            y: 0,
            M: 4,
            d: 6,
            H: 8,
            m: 10,
            s: 12
        };
        for (var index = 0; index < 14; index++) {
            result[index] = date[positions[format[index]]++];
        }
        return result;
    }
var dt = new Date();
for (var i = 0; i < 100000; i++) {
    var results = {};
    //2019-03-01 13:03:50
    var buf = new ArrayBuffer( 14 );
    buf[0] = 2;
    buf[1] = 0;
    buf[2] = 1;
    buf[3] = 9;
    buf[4] = 0;
    buf[5] = 3;
    buf[6] = 0;
    buf[7] = 1;
    buf[8] = 1;
    buf[9] = 3;
    buf[10] = 0;
    buf[11] = 3
    buf[12] = 5;
    buf[13] = 0;
    convertDateTimeToFormat(buf, "MMddyyyyHHmmss");
}
var dt2 = new Date();
console.log(dt2 - dt);
console.log(convertDateTimeToFormat(buf, "yyyyMMddHHmmss"));
console.log(convertDateTimeToFormat(buf, "MMddyyyyHHmmss"));

//缓冲区和视图
函数convertDateTimeToFormat（日期，格式）{
var buf=新阵列缓冲（14）；
var结果=新的UINT8阵列（buf）；
变量位置={
y:0，
M:4，
d:6，
H:8，
m:10，
s:12
};
对于（var指数=0；指数<14；指数++）{
结果[索引]=日期[位置[格式[索引]]+]；
}
返回结果；
}
var dt=新日期（）；
对于（变量i=0；i<100000；i++）{
var结果={}；
//2019-03-01 13:03:50
var buf=新阵列缓冲（14）；
buf[0]=2；
buf[1]=0；
buf[2]=1；
buf[3]=9；
buf[4]=0；
buf[5]=3；
buf[6]=0；
buf[7]=1；
buf[8]=1；
buf[9]=3；
buf[10]=0；
buf[11]=3
buf[12]=5；
buf[13]=0；
convertDateTimeToFormat（基本单位，MMDDYYYYHMMSS）；
}
var dt2=新日期（）；
console.log（dt2-dt）；
log（convertDateTimeToFormat（buf，“yyyyMMddHHmmss”）；
log（convertDateTimeToFormat（buf，“mmddyyyhhmmss”）；

在10个实验中所需的时间为：

2001841951861971931981971121202

平均：196.3

我也尝试过字符串操作：

function convertDateTimeToFormat(date, format) {
    var result = "";
    var positions = {
        y: 0,
        M: 4,
        d: 6,
        H: 8,
        m: 10,
        s: 12
    };
    for (var index = 0; index < 14; index++) {
        result += date[positions[format[index]]++];
    }
    return result;
}
var dt = new Date();
for (var i = 0; i <100000; i++) {
    var source = "20190301130350";
    convertDateTimeToFormat(source, "MMddyyyyHHmmss");
}
var dt2 = new Date();
console.log(dt2 - dt);
console.log(convertDateTimeToFormat(source, "yyyyMMddHHmmss"));
console.log(convertDateTimeToFormat(source, "MMddyyyyHHmmss"));

函数convertDateTimeToFormat（日期，格式）{
var结果=”；
变量位置={
y:0，
M:4，
d:6，
H:8，
m:10，
s:12
};
对于（var指数=0；指数<14；指数++）{
结果+=日期[职位[格式[索引]]++]；
}
返回结果；
}
var dt=新日期（）；
对于（var i=0；i您的测试的测量结果与第一次测试的测量结果不一样，您在浪费时间创建一个新的ArrayBuffer，而在第二次测试中，字符串“已在内存中定义”，因此更便宜

我创建了一个具有不同日期编号（随机）的测试，在启动计时器之前为相同的编号创建了一个缓冲区和一个字符串。字符串速度更快，但更少。结果如下：



var SIZE=100000；
var日期=[]；
对于（变量i=0；iconsole.timeEnd（“String”）；
您的测试与第一次测试的测量结果不一样，您在浪费时间创建一个新的ArrayBuffer，而在第二次测试中，字符串“已在内存中定义”，因此更便宜

我创建了一个具有不同日期编号（随机）的测试，在启动计时器之前为相同的编号创建了一个缓冲区和一个字符串。字符串速度更快，但更少。结果如下：



var SIZE=100000；
var日期=[]；
对于（变量i=0；ivar buf = [];

var buf = new Uint8Array(14);