Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/from below:

TypedArray.from() - JavaScript | MDN

Baseline Widely available

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

const uint16 = Int16Array.from("12345");

console.log(uint16);
// Expected output: Int16Array [1, 2, 3, 4, 5]

arrayLike

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

mapFn Optional

A function to call on every element of the typed array. If provided, every value to be added to the array is first passed through this function, and mapFn's return value is added to the typed array instead. The function is called with the following arguments:

element

The current element being processed in the typed array.

index

The index of the current element being processed in the typed array.

thisArg Optional

Value to use as this when executing mapFn.

A new TypedArray instance.

See Array.from() for more details.

There are some subtle distinctions between Array.from() and TypedArray.from() (note: the this value mentioned below is the this value that TypedArray.from() was called with, not the thisArg argument used to invoke mapFn):

• If the this value of TypedArray.from() is not a constructor, TypedArray.from() will throw a TypeError, while Array.from() defaults to creating a new Array.
• The object constructed by this must be a TypedArray instance, while Array.from() allows its this value to be constructed to any object.
• When the source parameter is an iterator, TypedArray.from() first collects all the values from the iterator, then creates an instance of this using the count, and finally sets the values on the instance. Array.from() sets each value as it receives them from the iterator, then sets its length at the end.
• TypedArray.from() uses [[Set]] while Array.from() uses [[DefineOwnProperty]]. Hence, when working with Proxy objects, it calls handler.set() to create new elements rather than handler.defineProperty().
• When Array.from() gets an array-like which isn't an iterator, it respects holes. TypedArray.from() will ensure the result is dense.

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

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 ]

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

The this value of from() must be a constructor that returns a TypedArray instance.

function NotArray(len) {
  console.log("NotArray called with length", len);
}

Int8Array.from.call({}, []); // TypeError: #<Object> is not a constructor
Int8Array.from.call(NotArray, []);
// NotArray called with length 0
// TypeError: Method %TypedArray%.from called on incompatible receiver #<NotArray>

function NotArray2(len) {
  console.log("NotArray2 called with length", len);
  return new Uint8Array(len);
}
console.log(Int8Array.from.call(NotArray2, [1, 2, 3]));
// NotArray2 called with length 3
// Uint8Array(3) [ 1, 2, 3 ]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4