External module "array/base/arraylike2object/docs/types/index.d"

Export assignment arraylike2object

• arraylike2object(x: Float64Array): Float64AccessorObject
• arraylike2object(x: Float32Array): Float32AccessorObject
• arraylike2object(x: Int32Array): Int32AccessorObject
• arraylike2object(x: Int16Array): Int16AccessorObject
• arraylike2object(x: Int8Array): Int8AccessorObject
• arraylike2object(x: Uint32Array): Uint32AccessorObject
• arraylike2object(x: Uint16Array): Uint16AccessorObject
• arraylike2object(x: Uint8Array): Uint8AccessorObject
• arraylike2object(x: Uint8ClampedArray): Uint8cAccessorObject
• arraylike2object(x: Complex128Array): Complex128AccessorObject
• arraylike2object(x: Complex64Array): Complex64AccessorObject
• arraylike2object<T>(x: AccessorArrayLike<T>): GetSetAccessorObject<T>
• arraylike2object<T>(x: Array<T>): GenericAccessorObject<T>
• arraylike2object<T>(x: Collection<T>): IndexedAccessorObject<T>

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Float64Array

    input array

  Returns Float64AccessorObject

  object containing array data

  Example

  var Float64Array = require( '@stdlib/array/float64' );
  
  var x = new Float64Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Float32Array

    input array

  Returns Float32AccessorObject

  object containing array data

  Example

  var Float32Array = require( '@stdlib/array/float32' );
  
  var x = new Float32Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Int32Array

    input array

  Returns Int32AccessorObject

  object containing array data

  Example

  var Int32Array = require( '@stdlib/array/int32' );
  
  var x = new Int32Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Int16Array

    input array

  Returns Int16AccessorObject

  object containing array data

  Example

  var Int16Array = require( '@stdlib/array/int16' );
  
  var x = new Int16Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Int8Array

    input array

  Returns Int8AccessorObject

  object containing array data

  Example

  var Int8Array = require( '@stdlib/array/int8' );
  
  var x = new Int8Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Uint32Array

    input array

  Returns Uint32AccessorObject

  object containing array data

  Example

  var Uint32Array = require( '@stdlib/array/uint32' );
  
  var x = new Uint32Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Uint16Array

    input array

  Returns Uint16AccessorObject

  object containing array data

  Example

  var Uint16Array = require( '@stdlib/array/uint16' );
  
  var x = new Uint16Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Uint8Array

    input array

  Returns Uint8AccessorObject

  object containing array data

  Example

  var Uint8Array = require( '@stdlib/array/uint8' );
  
  var x = new Uint8Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Uint8ClampedArray

    input array

  Returns Uint8cAccessorObject

  object containing array data

  Example

  var Uint8ClampedArray = require( '@stdlib/array/uint8c' );
  
  var x = new Uint8ClampedArray( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Complex128Array

    input array

  Returns Complex128AccessorObject

  object containing array data

  Example

  var Complex128Array = require( '@stdlib/array/complex128' );
  
  var x = new Complex128Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns true
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x, 1 );
  // returns <Complex128>

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Parameters

  • x: Complex64Array

    input array

  Returns Complex64AccessorObject

  object containing array data

  Example

  var Complex64Array = require( '@stdlib/array/complex64' );
  
  var x = new Complex64Array( [ 1, 2, 3, 4 ] );
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns true
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x, 1 );
  // returns <Complex64>

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Type parameters

  • T

  Parameters

  • x: AccessorArrayLike<T>

    input array

  Returns GetSetAccessorObject < T >

  object containing array data

  Example

  var x = [ 1, 2, 3, 4 ];
  
  function get( idx ) {
      return x[ idx ];
  }
  
  function set( value, idx ) {
      x[ idx ] = value;
  }
  
  x.get = get;
  x.set = set;
  
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns true
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Type parameters

  • T

  Parameters

  • x: Array<T>

    input array

  Returns GenericAccessorObject < T >

  object containing array data

  Example

  var x = [ 1, 2, 3, 4 ];
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3

• Converts a one-dimensional array-like object to an object likely to have the same "shape".

  Notes

  • This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding array data to ensure that internal functions operating on arrays are provided consistent argument "shapes".

  Type parameters

  • T

  Parameters

  • x: Collection<T>

    input array

  Returns IndexedAccessorObject < T >

  object containing array data

  Example

  var x = {
      '0': 1,
      '1': 2,
      '2': 3,
      '4': 4,
      'length': 4
  };
  var obj = arraylike2object( x );
  // returns {...}
  
  var bool = obj.accessorProtocol;
  // returns false
  
  var fcns = obj.accessors;
  // returns [ <Function>, <Function> ]
  
  var v = fcns[ 0 ]( x.data, 2 );
  // returns 3