Javascript 切片/合并斑点的渐近复杂性

我想大量使用JavaScript blob。但我不确定某些操作的性能。所以在这个简单的例子中

let n = 10; // not a constant :-)
let blob = e.dataTransfer.files[0]; // some file from user...

let blob1 = blob.slice(0, n); // O(1) or O(n)?
let blob2 = blob.slice(n); // O(1), O(n), O(blob2.length) or O(blob.length)?
let merged = new Blob([blob1, blob2]); // O(1) or O(blob.length)?

URL.createObjectURL(merged); // O(blob.length) - just to ensure, that blob will be used...

---

我对时间和空间复杂性都感兴趣。

每个函数对每个引擎都有不同的实现。
对于WebKit，您可以在此处检查切片：

对于Firefox，它的位置如下：

也可以使用新版本进行更改。
所以最好的方法是在真实的浏览器中尝试真实的数据并测量结果。那你就可以决定了

正如我从WebKit的源代码中看到的，Blob.slice是O（Blob.length），即使您有startIndex和endIndex。
Blob（[b1，b2..）是O（b1.length+b2.length+…）
但是URL.createObjectURL只是生成指向Blob的链接，所以它是O（1）

Blob是不可变的，所以每次更改Blob时都会创建一个新的Blob。这就是为什么不能用slice获取对Blob的一部分的引用

为了处理blob，我创建了以下代码：

var container = document.getElementById('container');
var getReaderPromise = function(bl) {
  var blReader = new FileReader();
  return new Promise(function(resolve, reject) {
    blReader.onload = function() { resolve(blReader.result) };
    blReader.readAsArrayBuffer(bl);
  });
}

var showContent = function(arrbuf) {
  console.log(String.fromCharCode.apply(null, new Uint8Array(arrbuf)));
}

var foo = new Blob('abcdefghjklmnopqrstuvwxyz'.split(''), {type : 'text/plain'});
var promiseFoo = getReaderPromise(foo);
var foores = undefined;
promiseFoo.then(function(res) {
  foores = res;
});

var bar1 = foo.slice(2,10);
var promiseBar1 = getReaderPromise(bar1);
var bar1res = undefined;
promiseBar1.then(function(res) {
  bar1res = res;
});

var bar2 = foo.slice(12,20);
var promiseBar2 = getReaderPromise(bar2);
var bar2res = undefined;
promiseBar2.then(function(res) {
  bar2res = res;
});

var bars = new Blob([bar1, bar2]);
var promiseBars = getReaderPromise(bars);
var barsres = undefined;
promiseBars.then(function(res) {
  barsres = res;
});

Promise.all([promiseFoo, promiseBar1, promiseBar2, promiseBars]).then(function() {
  showContent(foores);
  showContent(bar1res);
  showContent(bar2res);
  showContent(barsres);

  var bar2arr = new Uint8Array(bar2res);
  bar2arr[4] = '2'.charCodeAt();

  showContent(bar2res);
  showContent(barsres);
  showContent(foores);


  var url = URL.createObjectURL(bars);
  console.log(url);
  container.innerHTML += '<iframe src="' + url + '"></iframe>';
  var barsarr = new Uint8Array(barsres);
  barsarr[4] = '5'.charCodeAt();
  container.innerHTML +=  '<iframe src="' + url + '"></iframe>';
  url = URL.createObjectURL(bars);
  console.log(url);
  container.innerHTML += '<iframe src="' + url + '"></iframe>';
});

var container=document.getElementById（'container'）；
var getReaderPromise=函数（bl）{
var blReader=newfilereader（）；
返回新承诺（功能（解决、拒绝）{
blReader.onload=function（）{resolve（blReader.result）}；
blReader.readAsArrayBuffer（bl）；
});
}
var showContent=函数（arrbuf）{
log（String.fromCharCode.apply（null，新的Uint8Array（arrbuf）））；
}
var foo=new Blob（'abcdefghjklmnopqrstuvxyz'.split（''），{type:'text/plain'}）；
var promiseFoo=getReaderPromise（foo）；
var foores=未定义；
承诺书（功能）{
foores=res；
});
var bar1=食物切片（2,10）；
var promiseBar1=getReaderPromise（bar1）；
var bar1res=未定义；
承诺人1.然后（功能）{
bar1res=res；
});
var bar2=食物切片（12,20）；
var promiseBar2=getReaderPromise（bar2）；
var bar2res=未定义；
承诺人2.然后（功能）{
bar2res=res；
});
变量条=新的Blob（[bar1，bar2]）；
var promiseBars=getReaderPromise（条）；
var barsres=未定义；
promiseBars.然后（功能）{
barsres=res；
});
承诺。所有（[承诺书，承诺书1，承诺书2，承诺书]）然后（功能（）{
showContent（foores）；
showContent（bar1res）；
showContent（bar2res）；
展示内容（酒吧）；
var bar2arr=新的UINT8阵列（bar2res）；
bar2arr[4]=“2”。charCodeAt（）；
showContent（bar2res）；
展示内容（酒吧）；
showContent（foores）；
var url=url.createObjectURL（条）；
console.log（url）；
container.innerHTML+=''；
var barsarr=新的Uint8Array（barsres）；
barsarr[4]=“5”。charCodeAt（）；
container.innerHTML+=''；
url=url.createObjectURL（条）；
console.log（url）；
container.innerHTML+=''；
});

（）
您可以尝试在不同的浏览器中打开它，并会发现Blob在任何浏览器中都是不可变的。

---

所以切片和合并不能是O（1）。至少是O（n），但正如我在WebKit中看到的，它是O（blob.length）。

如果我没有弄错的话，这些是

Array.prototype.slice

的源代码。不适用于Blob。是的，抱歉，稍后将更新指向源文件的链接。如果不一样的话。啊，谢谢你的澄清。我希望slice是O（1），因为从另一个不可变数据创建不可变数据通常只能通过引用来完成，实际的读取在readAsArrayBuffer调用之前不会发生。为这样的不可变数组开发垃圾收集器是非常困难的。