TypedArray.from()

The TypedArray.from() method creates a new typed array from an array-like or iterable object. This method is nearly the same as Array.from().

Syntax

<code>TypedArray.from(source[, mapFn[, thisArg]])
</code>
where TypedArray is one of:

Int8Array
Uint8Array
Uint8ClampedArray
Int16Array
Uint16Array
Int32Array
Uint32Array
Float32Array
Float64Array

Parameters

source

An array-like or iterable object to convert to a typed array.

mapFn

Optional. Map function to call on every element of the typed array.

thisArg

Optional. Value to use as this when executing mapFn.

Return value

A new TypedArray instance.

Description

TypedArray.from() lets you create typed arrays from:

• array-like objects (objects with a length property and indexed elements) or
• iterable objects (objects where you can get its elements, such as Map and Set).

TypedArray.from() has an optional parameter mapFn, which allows you to execute a map function on each element of the typed array (or subclass object) that is being created. More clearly, TypedArray.from(obj, mapFn, thisArg) is the same as TypedArray.from(Array.prototype.map.call(obj, mapFn, thisArg)).

The length property of the from() method is 1.

Some subtle dinstinctions between Array.from() and TypedArray.from():

• If the |this| value passed to TypedArray.from is not a constructor, TypedArray.from will throw a TypeError, where Array.from defaults to creating a new Array.
• TypedArray.from uses [[Put]] where Array.from uses [[DefineProperty]]. Hence, when working with Proxy objects, it calls handler.set to create new elements rather than handler.defineProperty.
• When from gets an iterator, the TypedArray version first collects all the values from the iterator, then creates an instance of |this| using the count, then sets the values on the instance. Array.from sets each value as it gets them from the iterator then sets the length at the end.
• When Array.from gets an array-like which isn't an iterator, it respects holes, where TypedArray.from will ensure the result is dense.

Examples

// Set (iterable object)
var s = new Set([1, 2, 3]);
Uint8Array.from(s);
// Uint8Array [ 1, 2, 3 ]


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


// Using an arrow function as the map function to
// manipulate the elements
Float32Array.from([1, 2, 3], x => x + x);      
// Float32Array [ 2, 4, 6 ]


// Generate a sequence of numbers
Uint8Array.from({length: 5}, (v, k) => k);    
// Uint8Array [ 0, 1, 2, 3, 4 ]

Polyfill

You can partially work around this by inserting the following code at the beginning of your scripts, allowing use of much of the functionality of from() in implementations that do not natively support it.

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;
        }
    })();
}

Specifications

Browser compatibility

See also

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