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 :

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

Spécification État Commentaires
ECMAScript 2015 (6th Edition, ECMA-262)
La définition de '%TypedArray%.from' dans cette spécification.
Standard Définition initiale.
ECMAScript 2017 Draft (ECMA-262)
La définition de '%TypedArray%.from' dans cette spécification.
Projet  

Compatibilité des navigateurs

Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
Support simple 45.0 38 (38) Pas de support Pas de support 10
Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Support simple Pas de support Pas de support 38.0 (38) Pas de support Pas de support 10

Voir aussi

Étiquettes et contributeurs liés au document

 Contributeurs à cette page : SphinxKnight, cdr
 Dernière mise à jour par : SphinxKnight,