Javascript Vue js按块发送数据_Javascript_Vue.js_Asynchronous_Async Await

Javascript Vue js按块发送数据

javascript vue.js asynchronous

Javascript Vue js按块发送数据,javascript,vue.js,asynchronous,async-await,Javascript,Vue.js,Asynchronous,Async Await,我想分块发送数据现在我向服务器发送的内容如下所示对于循环-1、2、3 服务器接收的内容：3,1,2->异步。我需要同步发送它，以便服务器将作为我的for循环顺序接收：1、2、3 我怎么做 //52428800 const chunkSize = 1377628 let beginUpload = data; let component = this; let st

我想分块发送数据现在我向服务器发送的内容如下所示对于循环-1、2、3 服务器接收的内容：3,1,2->异步。我需要同步发送它，以便服务器将作为我的for循环顺序接收：1、2、3 我怎么做

//52428800
                const chunkSize = 1377628
                let beginUpload = data;
                let component = this;
                let start = 0;
                let startCount = 0;
                let callStoreCouunt = 0;
                
                for (start; start < zipedFile.length; start += chunkSize) {
                    const chunk = zipedFile.slice(start, start + chunkSize + 1)
                    startCount +=1;
                        // debugger
                        // var base64Image = new Buffer( zipedFile ).toString('base64');
                        var base64Image = new Buffer( chunk ).toString('base64');
                        console.log(chunk, startCount);

                    let uploadPackage: documentInterfaces.UploadPackage = {
                        transaction: {
                            documentId: {value: data.documentId.value},
                            transactionId: data.transactionId,
                            fileGuid: data.fileGuid
                        },
                        packageBuffer: base64Image
                    };
                    // debugger

                    


                    component.$store.dispatch('documents/uploadPackage', uploadPackage)
                    .then(({ data, status }: { data: documentInterfaces.ReciveAttachScene , status: number }) => {
                        // debugger
                        if(status !== 200){
                            component.$message({
                                message: data,
                                type: "error"
                            });
                            component.rejectUpload(beginUpload);
                        }
                        else{
                            callStoreCouunt+=1;
                            console.log(chunk, "res" + callStoreCouunt)
                            debugger
                            if(callStoreCouunt === startCount){
        
                                let commitPackage = {
                                    transaction: {
                                        documentId: {value: uploadPackage.transaction.documentId.value},
                                        transactionId: uploadPackage.transaction.transactionId,
                                        fileGuid: uploadPackage.transaction.fileGuid
                                    }
                                };
                              debugger
                                component.commitUpload(commitPackage);
                            }
                        }
                        });
                    }

/52428800
常量chunkSize=1377628
让beginUpload=数据；
让分量=这个；
让start=0；
让startCount=0；
让callstorecount=0；
for（开始；开始{
//调试器
如果（状态！==200）{
组件。$message({
信息：数据，
类型：“错误”
});
组件。拒绝上载（beginUpload）；
}
否则{
callstorecount+=1；
log（块，“res”+callstorecount）
调试器
if（callstorecount==startCount）{
让commitPackage={
交易：{
documentId:{value:uploadPackage.transaction.documentId.value}，
transactionId:uploadPackage.transaction.transactionId，
fileGuid:uploadPackage.transaction.fileGuid
}
};
调试器
组件。提交包（提交包）；
}
}
});
}

您无法控制哪些数据块首先到达服务器。如果途中某个地方出现网络问题，它可能会在到达服务器之前绕地球运行多次

即使第一个区块比第二个区块早发送

5ms

，第二个区块也可能更早到达服务器

但有几种方法可以解决这个问题：

方法1：在发送下一个区块之前，请等待服务器响应：

let state={
原因：错误
}
设sentChunks=0
让totalChunks=getTotalChunksAmount（）
让chunkToSend=。。。
设置间隔（（）=>{
如果（！isPaused&&sentChunks{
如果（响应===…）{
state.isPaused=false
}
})

方法2：如果不需要按顺序实时处理数据块，可以等待所有数据块到达服务器，然后在处理之前对其进行排序：

let chunks=[]
onChunkReceived（块）{
if（chunk.isLast）{
chunk.push（chunk）
chunks.sort（）
processChunks（）
}
否则{
chunk.push（chunk）
}
}

方法3：如果确实需要按顺序实时处理块，请为所有块指定一个id属性并按顺序处理它们，同时存储其他块供以后使用：

let chunksToProcess=[]
让lastProcessedChunkId=-1
onChunkReceived（块）{
如果（chunk.id==lastProcessedChunkId）{
processChunk（）
lastProcessedChunkId+=1
processStoredChunks（）
}
否则{
chunksToProcess.push（块）
}
}