Comment puis-je fusionner TypedArrays en JavaScript?

J'aimerais fusionner plusieurs arraybuffers pour créer un Blob. cependant, comme vous le savez,
TypedArray marche pas "pousser" ou de méthodes utiles...

E. g.:

var a = new Int8Array( [ 1, 2, 3 ] );
var b = new Int8Array( [ 4, 5, 6 ] );

En conséquence, je voudrais obtenir [ 1, 2, 3, 4, 5, 6 ].

  • Il n'y a pas push parce qu'ils ont une carte à mémoire natif 1:1.
  • ohhh, j'ai compris. TypedArray n'est pas seulement un tableau de droite? merci pour vos commentaires
InformationsquelleAutor yomotsu | 2012-12-28
  1. 59

    Utiliser le set méthode. Mais notez, que vous avez maintenant besoin de deux fois plus de mémoire!

    var a = new Int8Array( [ 1, 2, 3 ] );
var b = new Int8Array( [ 4, 5, 6 ] );

var c = new Int8Array(a.length + b.length);
c.set(a);
c.set(b, a.length);

console.log(a);
console.log(b);
console.log(c);
    • je vous remercie pour votre réponse. je pouvais comprendre. J'ai besoin de créer un nouveau fusionné un aint I.
    • oui, vous devez en créer un nouveau. Si vous savez C, un TypedArray est similaire à l'utilisation malloc (sans la nécessité de free). Mais il n'y a rien comme realloc.
    • Il y a un paquet NPM pour cette (npmjs.com/package/concat-typed-array). Il m'a fallu un certain temps, mais j'ai finalement compris que sa sortie correspond à la vôtre. codesandbox.io/s/... Ce qui s'est déclenché moi, c'est que j'ai besoin de comparer les sorties après l'utilisation de .toString().
    • parce que sinon, vous êtes en comparant les références, qui sont différentes (c'est un nouveau tableau, un nouveau pointeur vers un emplacement de la mémoire). Pour comparer la matrice de contenu que vous avez toujours besoin de comparer élément par élément. [1] === [1] est faux.
    • Yep. C'était un cerveau-sauter.
    InformationsquelleAutor Prinzhorn
  2. 6

    J'ai toujours utiliser cette fonction:

    function mergeTypedArrays(a, b) {
    //Checks for truthy values on both arrays
    if(!a && !b) throw 'Please specify valid arguments for parameters a and b.';  

    //Checks for truthy values or empty arrays on each argument
    //to avoid the unnecessary construction of a new array and
    //the type comparison
    if(!b || b.length === 0) return a;
    if(!a || a.length === 0) return b;

    //Make sure that both typed arrays are of the same type
    if(Object.prototype.toString.call(a) !== Object.prototype.toString.call(b))
        throw 'The types of the two arguments passed for parameters a and b do not match.';

    var c = new a.constructor(a.length + b.length);
    c.set(a);
    c.set(b, a.length);

    return c;
}

    La fonction d'origine sans vérifier la valeur null ou types

    function mergeTypedArraysUnsafe(a, b) {
    var c = new a.constructor(a.length + b.length);
    c.set(a);
    c.set(b, a.length);

    return c;
}
    • Pas de null contrôles, == au lieu de ===, et c'est en gros une copie de Prinzhorn réponse, enveloppé dans une fonction.
    • Encore une fois, juste une fonction que j'aime utiliser, pensé que peut-être quelqu'un d'autre pourrait l'utiliser comme bien n'hésitez pas à corriger toutes les erreurs que vous pourriez trouver.
    • On n'a pas l'habitude de corriger les erreurs dans la réponse du code. C'est à la personne qui a répondu à la question, d'où le commentaire.
    • Eh bien je n'ai jamais vu la nécessité de faire une comparaison stricte, ni nulle vérifier dans mon cas d'utilisation, mais si elle n'influence pas négativement les performances, il serait de rendre la fonction plus étoffé.
    InformationsquelleAutor
  3. 0

    Comme un one-liner, ce qui aura un nombre arbitraire de tableaux (myArrays ici) et de différents types, aussi longtemps que le type de résultat prend tous (Int8Array ici):

    let combined = Int8Array.from(Array.prototype.concat(...myArrays.map(a => Array.from(a))));
    InformationsquelleAutor randomsock
  4. 0

    J'aime @prinzhorn de la réponse, mais je voulais quelque chose d'un peu plus flexible et compact:

    var a = new Uint8Array( [ 1, 2, 3 ] );
var b = new Float32Array( [ 4.5, 5.5, 6.5 ] );

const merge = (tArrs, type = Uint8Array) => {
  const ret = new (type)(tArrs.reduce((acc, tArr) => acc + tArr.byteLength, 0))
  let off = 0
  tArrs.forEach((tArr, i) => {
    ret.set(tArr, off)
    off += tArr.byteLength
  })
  return ret
}

merge([a, b], Float32Array)
    InformationsquelleAutor mattdlockyer