Float64Array: примеры (JAVASCRIPT)

Базовые примеры использования

Пример 1: Создание массива заданной длины

let arr1 = new Float64Array(3);
console.log(arr1);

Float64Array(3) [ 0, 0, 0 ]

Пример 2: Создание из обычного массива

let arr2 = new Float64Array([1.5, 2.7, 3.9]);
console.log(arr2);
console.log(arr2[1]);

Float64Array(3) [ 1.5, 2.7, 3.9 ]
2.7

Пример 3: Работа с ArrayBuffer

let buffer = new ArrayBuffer(32);
let arr3 = new Float64Array(buffer, 8, 2); // Смещение 8 байт, 2 элемента
arr3[0] = 42.1;
console.log(arr3);

Float64Array(2) [ 42.1, 0 ]

Пример 4: Использование итератора

let set = new Set([10.1, 20.2, 30.3]);
let arr4 = new Float64Array(set);
console.log(arr4.length);
console.log(...arr4);

3
10.1 20.2 30.3

Другие типизированные массивы в JavaScript

Float64Array является частью семейства типизированных массивов:

• Float32Array — 32-битные числа с плавающей точкой одинарной точности. Занимает меньше памяти, но имеет меньшую точность. Используется в графике и WebGL.
• Int32Array, Uint32Array — целочисленные массивы. Подходят для работы с дискретными значениями без дробной части.
• Int8Array, Uint8Array, Int16Array, Uint16Array — массивы меньшей разрядности. Экономят память при работе с ограниченными диапазонами значений.
• BigInt64Array, BigUint64Array — для работы с 64-битными целыми числами большой точности.

Выбор зависит от требований к точности, диапазону значений и экономии памяти. Float64Array обеспечивает максимальную точность для дробных чисел, но занимает больше памяти.

Распространенные ошибки

Ошибка 1: Попытка передачи нечисловых значений

try {
    let arr = new Float64Array([1.1, 'text', 3.3]);
} catch (e) {
    console.log(e.message);
}

Invalid typed array length: undefined

Строка преобразуется в NaN, что может привести к неожиданным результатам.

Ошибка 2: Выход за пределы диапазона значений

let arr = new Float64Array(2);
arr[0] = 1e400; // Переполнение
console.log(arr[0]);

Infinity

Значения за пределами диапазона преобразуются в Infinity или -Infinity.

Ошибка 3: Неправильное использование буфера

let buffer = new ArrayBuffer(8);
let arr1 = new Float64Array(buffer);
let arr2 = new Float64Array(buffer, 2); // Неверное смещение
console.log(arr2.length);

RangeError: start offset of Float64Array should be a multiple of 8

Смещение должно быть кратно размеру элемента (8 байт).

История изменений

Float64Array был добавлен в спецификацию ECMAScript 6 (ES2015) и стал стандартной частью JavaScript. С тех пор существенных изменений в API не происходило. В более поздних версиях ECMAScript были добавлены:

• Методы .from() и .of() в ES2015 для создания массивов из итерируемых объектов.
• Поддержка итераторов и методов массива (map, filter, reduce) в ES2015.
• Методы .set() и .subarray() для копирования данных и создания подмассивов.

Все современные браузеры и Node.js поддерживают Float64Array полностью.

Продвинутые примеры применения

Пример 1: Математические вычисления с высокой точностью

let values = new Float64Array([0.1, 0.2]);
let sum = values.reduce((acc, val) => acc + val, 0);
console.log('Сумма:', sum);
console.log('Сравнение с 0.3:', sum === 0.3);

Сумма: 0.30000000000000004
Сравнение с 0.3: false

Пример демонстрирует особенность двоичной арифметики с плавающей точкой.

Пример 2: Обработка бинарных данных из файла

// Предположим, у нас есть ArrayBuffer из файла
let buffer = new ArrayBuffer(24);
let view = new DataView(buffer);
view.setFloat64(0, 123.456, true); // Запись с little-endian порядком

let arr = new Float64Array(buffer, 0, 3);
console.log('Первое значение:', arr[0]);

Первое значение: 123.456

Пример 3: Взаимодействие с Web Workers для параллельных вычислений

// Основной поток
let data = new Float64Array(1000000).map((_, i) => Math.random());
let worker = new Worker('compute.js');
worker.postMessage(data.buffer, [data.buffer]); // Передача владения буфером

// В compute.js:
// onmessage = (e) => {
//     let arr = new Float64Array(e.data);
//     // Обработка данных...
// };

Пример 4: Использование с WebGL для передачи вершинных данных

let vertices = new Float64Array([
    0.0, 0.0, 0.0,
    1.0, 0.0, 0.0,
    0.0, 1.0, 0.0
]);
// В реальном WebGL обычно используют Float32Array для экономии памяти
// но для высокоточных вычислений может потребоваться Float64Array

Пример 5: Создание пользовательской матрицы преобразований

class Matrix4x4 {
    constructor() {
        this.data = new Float64Array(16);
        this.identity();
    }
    
    identity() {
        this.data.fill(0);
        this.data[0] = this.data[5] = this.data[10] = this.data[15] = 1.0;
        return this;
    }
    
    multiplyScalar(scalar) {
        for (let i = 0; i < 16; i++) {
            this.data[i] *= scalar;
        }
        return this;
    }
}

let mat = new Matrix4x4();
mat.multiplyScalar(2.5);
console.log('Элемент [0,0]:', mat.data[0]);

Элемент [0,0]: 2.5

Аналоги в других языках программирования

Python (NumPy):

import numpy as np
arr = np.array([1.1, 2.2, 3.3], dtype=np.float64)
print(arr)
print(arr.dtype)

[1.1 2.2 3.3]
float64

NumPy предоставляет более богатый функционал для математических операций с массивами.

C/C++:

double arr[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
// Элементы хранятся непрерывно в памяти как 64-битные значения

В отличие от JavaScript, в C/C++ размер массива фиксирован и управление памятью ручное.

PHP:

$arr = [1.1, 2.2, 3.3];
// PHP использует единый тип array, без специализации по типам чисел

PHP не имеет встроенных типизированных массивов как в JavaScript.

MySQL:

CREATE TABLE example (values DOUBLE);
INSERT INTO example VALUES (1.1), (2.2), (3.3);

Тип DOUBLE соответствует 64-битным числам с плавающей точкой, но используется для хранения в БД.