TypedArray.from()

La méthode TypedArray.from() crée un nouvel objet TypedArray à partir d'un objet itérable ou d'un objet semblable à un tableau. Cette méthode est similaire à Array.from().

Syntaxe

TypedArray.from(source[, mapFn[, thisArg]])

où TypedArray est l'un de :

Int8Array
Uint8Array
Uint8ClampedArray
Int16Array
Uint16Array
Int32Array
Uint32Array
Float32Array
Float64Array

Paramètres

source

Un objet semblable à un tableau ou un objet itérable, et à partir duquel on souhaite créer un tableau typé.

fonctionMap

Argument optionnel, une fonction à appliquer à chacun des éléments du tableau.

thisArg

Argument optionnel. La valeur à utiliser pour this lors de l'exécution de la fonction fonctionMap.

Valeur de retour

Une nouvelle instance de TypedArray.

Description

TypedArray.from() permet de créer des tableaux typés à partir :

• d'objets semblables à des tableaux (qui disposent d'une propriété length et d'éléments indexés) ou
• d'objets itérables (par exemple des objets Map ou Set).

Array.from possède un paramètre optionnel fonctionMap, qui permet d'exécuter une fonction map sur chacun des éléments du tableau typé (ou de l'instance de la classe fille) qui est créé. Autrement dit TypedArray.from(obj, fonctionMap, thisArg) correspond exactement à TypedArray.from(obj).map(fonctionMap, thisArg).

Il existe de légères différences entre Array.from() et TypedArray.from() :

• Si la valeur de this passée à TypedArray.from n'est pas un constructeur, TypedArray.from lèvera une exception TypeError, tandis que Array.from créera un nouvel objet Array.
• TypedArray.from utilise [[Set]] tandis que Array.from utilise [[DefineProperty]]. Ainsi par exemple lorsque des objets Proxy sont manipulés la première méthode appellera handler.set pour créer les nouveaux éléments et la seconde appellera handler.defineProperty.
• Lorsque source est un itérable, TypedArray.from va dans un premier temps récupérer toutes ses valeurs, puis initialiser une instance de this à l'aide de leur nombre, et enfin ajouter ces valeurs à l'instance. Array.from ajoute les valeurs au nouvel objet lors du parcours de l'itérateur et ne définit la taille de l'objet qu'en dernière étape.
• Si Array.from reçoit un objet semblable à un tableau qui n'est pas un itérable, les valeurs non définies sont conservées. TypedArray.from construit un objet dense en éliminant ces valeurs.

Exemples

// Set (objet itérable)
var s = new Set([1, 2, 3]);
Uint8Array.from(s);
// Uint8Array [ 1, 2, 3 ]


// String
Int16Array.from("123");                      
// Int16Array [ 1, 2, 3 ]


// En utilisant un fonction fléchée en tant que 
// fonctionMap pour manipuler les éléments
Float32Array.from([1, 2, 3], x => x + x);      
// Float32Array [ 2, 4, 6 ]


// Pour construire une séquence de nombres
Uint8Array.from({length: 5}, (v, k) => k);    
// Uint8Array [ 0, 1, 2, 3, 4 ]

Prothèse d'émulation (polyfill)

On peut utiliser certaines des fonctionnalités de from en utilisant le code suivant (ici appliqué pour le type Int8Array) :

if(!Int8Array.__proto__.from) {
  (function () {
    Int8Array.__proto__.from = function (obj, func, thisObj) {

      var typedArrayClass = Int8Array.__proto__;
      if(typeof this !== "function") {
        throw new TypeError("# is not a constructor");
      }
      if(this.__proto__ !== typedArrayClass) {
        throw new TypeError("this is not a typed array.");
      }
      ,
      func = func || function (elem) {
        return elem;
      };

      if (typeof func !== "function") {
        throw new TypeError("specified argument is not a function");
      }

      obj = Object(obj);
      if(!obj["length"]) {
        return new this(0);
      }
      var copy_data = [];
      for(var i=0; i<obj.length; i++) {
        copy_data.push(obj[i]);
      }

      copy_data = copy_data.map(func, thisObj);

      var typed_array = new this(copy_data.length);
      for(var i=0; i<typed_array.length; i++) {
        typed_array[i] = copy_data[i];
      }
      return typed_array;
    }
  })();
}

Spécifications

Compatibilité des navigateurs

Voir aussi

• TypedArray.of()
• Array.from()
• Array.prototype.map()