ArrayBuffer.transfer()

La méthode statique ArrayBuffer.transfer() renvoie un nouvel objet ArrayBuffer dont le contenu a été transféré depuis les données d'ancienBuffer et qui est soit tronqué soit complété avec des zéros pour que la longueur du nouvel objet soit égale à nouvelleLongueur. Si nouvelleLongueur vaut undefined, on utilisera la propriété byteLength de l'ancienBuffer. Cette opération fait que ancienBuffer sera dans un état détaché.

Syntaxe

ArrayBuffer.transfer(ancienBuffer [, nouvelleLongueur]);

Paramètres

ancienBuffer

Un objet ArrayBuffer à partir duquel on souhaite transférer des données.

nouvelleLongueur

La longueur, exprimée en octets, du nouvel objet ArrayBuffer.

Valeur de retour

Un nouvel objet ArrayBuffer.

Description

La méthode ArrayBuffer.transfer() permet d'agrandir et de détacher des objets ArrayBuffer. Le fait de pouvoir agrandir un ArrayBuffer sans effectuer de copie permet d'être beaucoup plus efficace sur les grands buffers (comme pour realloc). Le fait de pouvoir détacher un ArrayBuffer permet au développeur d'avoir un contrôle explicite sur la mémoire sous-jacente et sa libération. Cela permet d'éviter d'avoir à libérer toutes les références et d'attendre le travail du ramasse-miettes.

Exemples

var buf1 = new ArrayBuffer(40);
new Int32Array(buf1)[0] = 42;

var buf2 = ArrayBuffer.transfer(buf1, 80);
buf1.byteLength; // 0
buf2.byteLength; // 80
new Int32Array(buf2)[0]; // 42

var buf3 = ArrayBuffer.transfer(buf2, 0);
buf2.byteLength; // 0
buf3.byteLength; // 0

Prothèse d'émulation (polyfill)

Ce fragment de code permet d'obtenir la plupart des fonctionnalités de transfer() dans un environnement qui ne le prend pas en charge nativement. Attention, cela ne correspond pas exactement à l'API mais permet de transférer des données d'un ArrayBuffer vers un autre.

if(!ArrayBuffer.transfer) {
  ArrayBuffer.transfer = function (source, dest) {
    source = Object(source);
    dest = Object(dest);
    if(!(source instanceof ArrayBuffer) || !(dest instanceof ArrayBuffer)) {
      throw new TypeError("Source and destination must be ArrayBuffer instances");
    }
    if(dest.byteLength >= source.byteLength) {
      var nextOffset = 0;
      var leftBytes = source.byteLength;
      var wordSizes = [8, 4, 2, 1];
      wordSizes.forEach(function (_wordSize_) {
        if (leftBytes >= _wordSize_) {
          var done = transferWith(_wordSize_, source, dest, nextOffset, leftBytes);
          nextOffset = done.nextOffset;
          leftBytes = done.leftBytes;
        }
      });
    }

    function transferWith(wordSize, source, dest, nextOffset, leftBytes) {
      var ViewClass = Uint8Array;
      switch (wordSize)  {
        case 8:
        ViewClass = Float64Array;
        break;
        case 4:
        ViewClass = Float32Array;
        break;
        case 2:
        ViewClass = Uint16Array;
        break;
        case 1:
        ViewClass = Uint8Array;
        break;
        default:
        ViewClass = Uint8Array;
  break;
      }
      var view_source = new ViewClass(source, nextOffset, Math.trunc(leftBytes / wordSize));
      var view_dest = new ViewClass(dest, nextOffset, Math.trunc(leftBytes / wordSize));
      for(var i=0; i<view_dest.length; i++) {
        view_dest[i] = view_source[i];
      }
      return {
        nextOffset : view_source.byteOffset + view_source.byteLength,
        leftBytes : source.byteLength - (view_source.byteOffset + view_source.byteLength)
      }
    }
  };
}

Spécifications

À l'heure actuelle, cette méthode ne fait partie d'aucune spécification mais a été proposée pour une prochaine édition d'ECMA-262.

Compatibilité des navigateurs

Voir aussi

• Les tableaux typés en JavaScript