Учебник по Electron.js

Класс Int16Array

Класс Int16Array описывает типизированный массив, содержащий значения в диапазоне от -32 768 до 32 767:

let arr = new Int16Array([1, 2, -32768, 32767, 32768, -32769]);
console.log(arr);
// Int16Array(6) [1, 2, -32768, 32767, -32768, 32767]
console.log(Int16Array.BYTES_PER_ELEMENT); // 2
console.log(Int16Array.name);              // Int16Array

Создание объекта

Создать массив позволяют следующие конструкторы:

<Массив> = new Int16Array();
<Массив> = new Int16Array(<Количество элементов>);
<Массив> = new Int16Array(<Типизированный массив>);
<Массив> = new Int16Array(<Объект, поддерживающий итерации>);
<Массив> = new Int16Array(<ArrayBuffer>[, <byteOffset>[, <length>]]);

Первый конструктор создает массив нулевого размера:

let arr = new Int16Array();
console.log(arr.length); // 0

Второй конструктор позволяет указать количество элементов. Все элементы получат значение 0:

let arr = new Int16Array(5);
console.log(arr); // Int16Array(5) [0, 0, 0, 0, 0]

Третий конструктор создает массив на основе другого типизированного массива:

let arr1 = new Int16Array([1, 2, 3]);
let arr2 = new Int16Array(arr1);
arr2[0] = 0;
console.log(arr1); // Int16Array(3) [1, 2, 3]
console.log(arr2); // Int16Array(3) [0, 2, 3]

Четвертый конструктор в качестве параметра принимает объект, поддерживающий итерации. Можно указать, например, обычный массив или множество:

let arr1 = new Int16Array([1, 2, 3]);
console.log(arr1); // Int16Array(3) [1, 2, 3]
let arr2 = new Int16Array(new Set([1, 2, 2]));
console.log(arr2); // Int16Array(2) [1, 2]

Пятый конструктор создает массив на основе объекта ArrayBuffer:

let buf = new ArrayBuffer(6);
let arr1 = new Int16Array(buf);
console.log(arr1);        // Int16Array(3) [0, 0, 0]
let arr2 = new Int16Array(buf, 2, 2);
console.log(arr2.length); // 2

Обратите внимание: данные не копируются. Два объекта будут ссылаться на один и тот же фрагмент памяти:

let arr1 = new Int16Array([1, 2, 3]);
let arr2 = new Int16Array(arr1.buffer, arr1.byteOffset,
               arr1.byteLength / Int16Array.BYTES_PER_ELEMENT);
arr2[0] = 5;
console.log( arr1 ); // Int16Array(3) [5, 2, 3]
console.log( arr2 ); // Int16Array(3) [5, 2, 3]

Изменились оба массива!

В этом примере мы воспользовались следующими свойствами:

Для создания массива можно также использовать статический метод from():

<Массив> = Int16Array.from(<Объект>[, <Функция>[, <this>]]);

В первом параметре указывается объект, поддерживающий итерации:

let arr1 = Int16Array.from([1, 2, 3]);
console.log(arr1);        // Int16Array(3) [1, 2, 3]
let arr2 = Int16Array.from('123');
console.log(arr2);        // Int16Array(3) [1, 2, 3]

Во втором параметре можно указать ссылку на функцию, которая будет вызвана для каждого элемента. Функция имеет следующий формат:

function name(value, index, array) {
   return value;
}

Значение, возвращаемое функцией, станет новым значением элемента массива:

let arr = Int16Array.from([1, 2, 3], (value) => {
   return value * 2;
});
console.log(arr);        // Int16Array(3) [2, 4, 6]

Создать массив на основе списка значений позволяет статический метод of(). Значения указываются через запятую:

let arr = Int16Array.of(1, 2, 3);
console.log(arr);        // Int16Array(3) [1, 2, 3]

Определение числа элементов массива

Получить количество элементов массива позволяет свойство length:

let arr = Int16Array.of(1, 2, 3);
console.log(arr.length); // 3

Размер типизированного массива является фиксированным. Изменить размер после создания объекта нельзя.

Получение и изменение элементов массива

Получить значение элемента массива можно, указав его индекс в квадратных скобках. Нумерация элементов массива начинается с нуля:

let arr = Int16Array.of(1, 2, 3);
console.log( arr[0] ); // 1
console.log( arr[1] ); // 2
console.log( arr[2] ); // 3

Если элемент с указанным индексом не существует, то будет возвращено значение undefined:

console.log( arr[3] ); // undefined

При желании можно изменить значение существующего элемента:

arr[0] = 5;
arr[1] = 6;
console.log( arr[0] ); // 5
console.log( arr[1] ); // 6

Если указано число меньше минимального значения или больше максимального значения, то произойдет усечение числа:

arr[0] = -32769;
arr[1] = 32768;
console.log( arr[0] ); // 32767
console.log( arr[1] ); // -32768

С помощью метода fill() можно заполнить весь массив или только диапазон одинаковым значением. Формат метода:

fill(<Значение>[, <Начало>[, <Конец>]])

В первом параметре указывается вставляемое значение, которое заполнит весь массив или только указанный фрагмент:

let arr = new Int16Array(5);
console.log(arr); // Int16Array(5) [0, 0, 0, 0, 0]
arr.fill(1);
console.log(arr); // Int16Array(5) [1, 1, 1, 1, 1]

В параметре <Начало> можно указать начальный индекс диапазона (значение по умолчанию: 0), а в параметре <Конец> — конечный индекс (значение по умолчанию: число элементов массива). Метод fill() возвращает ссылку на массив, поэтому можно строить цепочки из вызовов:

let arr = new Int16Array(5);
arr.fill(1, 1, 4);
console.log(arr); // Int16Array(5) [0, 1, 1, 1, 0]

С помощью метода set(<Массив>[, <Смещение>]) можно скопировать данные из обычного массива или типизированного массива:

let arr = new Int16Array(5);
arr.set( [1, 2, 3] );
console.log( arr ); // Int16Array(5) [1, 2, 3, 0, 0]
arr.set( [4, 5], 3 );
console.log( arr ); // Int16Array(5) [1, 2, 3, 4, 5]
arr.set( Int16Array.of(6, 7, 8) );
console.log( arr ); // Int16Array(5) [6, 7, 8, 4, 5]

Для сохранения значений элементов массива в переменных можно использовать операцию распаковки массива. В этом случае массив указывается справа от оператора =, а переменные внутри квадратных скобок — слева от оператора =:

let arr = Int16Array.of(1, 2);
let [a, b] = arr;
console.log( a + ' ' + b );   // 1 2

Количество элементов массива может не совпадать с количеством переменных внутри квадратных скобок. Кроме того, если элемент не нужен, то достаточно указать переменные только в нужных позициях:

let arr = Int16Array.of(1, 2, 3, 4, 5);
let a = 0, b = 0;
[a, , b] = arr;
console.log( a + ' ' + b );   // 1 3

Значения отдельных элементов массива можно сохранить в переменных, а оставшиеся элементы добавить в массив, указав перед ним оператор три точки:

let arr = Int16Array.of(1, 2, 3, 4, 5);
let [a, b, ...other] = arr;
console.log( a + ' ' + b );   // 1 2
console.log( other );         // [ 3, 4, 5 ]

Создание копии массива

Следует учитывать, что операция присваивания сохраняет в переменной ссылку на массив, а не все его значения. Например, если попробовать сделать так, то изменение arr2 затронет arr1:

let arr1, arr2;
arr1 = Int16Array.of(1, 2, 3, 4);
arr2 = arr1;          // Присваивается ссылка на массив!!!
arr2[0] = 88;
console.log(arr1);    // Int16Array(4) [88, 2, 3, 4]
console.log(arr2);    // Int16Array(4) [88, 2, 3, 4]

Для создания полной копии можно воспользоваться конструктором класса Int16Array или статическим методом from():

let arr1, arr2;
arr1 = Int16Array.of(1, 2, 3, 4);
arr2 = new Int16Array(arr1);
arr2[0] = 88;
console.log(arr1);    // Int16Array(4) [1, 2, 3, 4]
console.log(arr2);    // Int16Array(4) [88, 2, 3, 4]
arr2 = Int16Array.from(arr1);
arr2[0] = 88;
console.log(arr1);    // Int16Array(4) [1, 2, 3, 4]
console.log(arr2);    // Int16Array(4) [88, 2, 3, 4]

Скопировать фрагмент позволяет метод slice([<Начало>[, <Конец>]). Если параметры не указаны, то создается полная копия. В первом параметре можно указать начальный индекс, а во втором — конечный индекс (не включая элемент с этим индексом). Если второй параметр не задан, то копируется фрагмент, начиная с индекса <Начало> до конца массива:

let arr1, arr2;
arr1 = Int16Array.of(1, 2, 3, 4);
arr2 = arr1.slice();
arr2[0] = 88;
console.log(arr1);    // Int16Array(4) [1, 2, 3, 4]
console.log(arr2);    // Int16Array(4) [88, 2, 3, 4]
arr2 = arr1.slice(2);
console.log(arr2);    // Int16Array(2) [3, 4]
arr2 = arr1.slice(2, 3);
console.log(arr2);    // Int16Array [3]

Перебор элементов массива

Для перебора массивов удобно использовать цикл for. Умножим все элементы массива на 2:

let arr = Int16Array.of(1, 2, 3);
for (let i = 0; i < arr.length; i++) {
   arr[i] *= 2;
}
console.log(arr); // Int16Array(3) [2, 4, 6]

Перебрать элементы массива позволяет также цикл for...of, который на каждой итерации присваивает переменной копию значения элемента массива:

let arr = Int16Array.of(1, 2, 3);
for (const value of arr) {
   console.log(value);
}

Можно также воспользоваться методом forEach(). Формат метода:

forEach(<Функция>[, <this>])

В первом параметре указывается ссылка на функцию, которая будет вызвана для каждого элемента массива. Функция принимает три параметра. Через первый параметр доступно значение текущего элемента, через второй — его индекс, а через третий — ссылка на массив. Значение, указанное в параметре <this>, будет доступно через указатель this внутри функции:

let arr = Int16Array.of(1, 2, 3);
arr.forEach( function(value, index, array) {
   array[index] = value * 2;
});
console.log(arr); // Int16Array(3) [2, 4, 6]

Методы, возвращающие итераторы

Следующие методы возвращают специальный объект — итератор:

let arr = Int16Array.of(1, 2, 3, 4);
let iterator = arr.keys();
console.log(iterator); // Array Iterator {}
// Перебор всех элементов
for (const key of iterator) {
   console.log(`${key} `);
} // 0 1 2 3
// Преобразование в массив
let arrKeys = [...arr.keys()];
console.log(arrKeys);  // [0, 1, 2, 3]
let arr = Int16Array.of(5, 6, 7, 8);
let iterator = arr.values();
// Перебор всех элементов
for (const value of iterator) {
   console.log(value);
} // 5 6 7 8
console.log();
// Преобразование в массив
let arrValues = [...arr.values()];
console.log(arrValues);  // [5, 6, 7, 8]
arrValues = [...arr];
console.log(arrValues);  // [5, 6, 7, 8]
let arr = Int16Array.of(5, 6, 7);
let iterator = arr.entries();
// Перебор всех элементов
for (const [key, value] of iterator) {
   console.log(`${key} => ${value} `);
} // 0 => 5 1 => 6 2 => 7
// Преобразование в массив
let arrEntries = [...arr.entries()];
console.log(arrEntries); // [ [ 0, 5 ], [ 1, 6 ], [ 2, 7 ] ]

Фильтрация массива

Метод filter(<Функция>[, <this>]) позволяет выполнить фильтрацию массива. В первом параметре указывается ссылка на функцию, которая будет вызвана для каждого элемента массива. Функция принимает три параметра. Через первый параметр доступно значение текущего элемента, через второй — его индекс, а через третий — ссылка на массив. Функция должна вернуть значение true, если элемент соответствует условию, и false — в противном случае. Значение, указанное во втором параметре, будет доступно внутри функции через указатель this. Метод возвращает массив элементов, соответствующих условию (для которых функция вернула значение true). Исходный массив не изменяется. Пример:

let arr = Int16Array.of(1, 2, 3, 4, 5, 6);
let arr2 = arr.filter( function(value, index, ar) {
   return value < 4;
});
console.log(arr2);                  // Int16Array(3) [1, 2, 3]

С помощью метода map(<Функция>[, <this>]) можно применить пользовательскую функцию ко всем элементам массива. Внутри функции нужно вернуть новое значение элемента. Метод map() возвращает отфильтрованный массив. Пример умножения всех элементов массива на 2:

let arr = Int16Array.of(1, 2, 3, 4, 5, 6);
let arr2 = arr.map( function(value, index, ar) {
   return value * 2;
});
console.log(arr2);              // Int16Array(6) [2, 4, 6, 8, 10, 12]

Метод reduce(<Функция>[, <Начальное значение>]) применяет функцию к парам элементов и накапливает результат. В первом параметре указывается ссылка на функцию, которая будет вызвана для каждого элемента массива. Функция принимает четыре параметра. Через первый параметр доступен результат предыдущих вычислений или <Начальное значение> при первом вызове, через второй — значение текущего элемента, через третий — его индекс, а через четвертый — ссылка на массив. Внутри функции нужно вернуть результат текущих вычислений. Метод reduce() возвращает общий результат вычислений. Пример получения суммы всех элементов массива:

let arr = Int16Array.of(1, 2, 3);
let sum = arr.reduce( function(value1, value2, index, ar) {
   return value1 + value2;
}, 0);
console.log(sum);              // 6

Метод reduceRight() аналогичен методу reduce(), но перебирает элементы не слева направо, а справа налево:

let arr = Int16Array.of(1, 2, 3);
let sum = arr.reduceRight( function(value1, value2, index, ar) {
   return value1 + value2;
}, 0);
console.log(sum);              // 6

Переворачивание массива

Метод reverse() переворачивает массив. Элементы будут следовать в обратном порядке относительно исходного массива:

let arr = Int16Array.of(1, 2, 3);
arr.reverse();
console.log(arr);               // Int16Array(3) [3, 2, 1]

Получение части массива

Метод slice([<Начало>[, <Конец>]]) возвращает срез массива, начиная от индекса <Начало> и заканчивая индексом <Конец>, но не включает элемент с этим индексом. Если первый параметр не указан, то он будет иметь значение 0. Если второй параметр не указан, то возвращаются все элементы до конца массива:

let arr1, arr2;
arr1 = Int16Array.of(1, 2, 3, 4);
arr2 = arr1.slice();
arr2[0] = 88;
console.log(arr1);    // Int16Array(4) [1, 2, 3, 4]
console.log(arr2);    // Int16Array(4) [88, 2, 3, 4]
arr2 = arr1.slice(2);
console.log(arr2);    // Int16Array(2) [3, 4]
arr2 = arr1.slice(2, 3);
console.log(arr2);    // Int16Array [3]

Вместо метода slice() можно воспользоваться методом subarray([<Начало>[, <Конец>]]):

let arr1, arr2;
arr1 = Int16Array.of(1, 2, 3, 4);
arr2 = arr1.subarray();
arr2[0] = 88;
console.log(arr1);    // Int16Array(4) [88, 2, 3, 4] !!!
console.log(arr2);    // Int16Array(4) [88, 2, 3, 4]
arr2 = arr1.subarray(2);
console.log(arr2);    // Int16Array(2) [3, 4]
arr2 = arr1.subarray(2, 3);
console.log(arr2);    // Int16Array [3]
Обратите внимание

Метод subarray() не копируют элементы, а лишь создают ссылку на ту же самую область памяти. Изменение первого массива приведет к изменению второго массива.

Сортировка массива

Отсортировать массив позволяет метод sort([Функция сортировки]). Если функция сортировки не указана, будет выполнена обычная сортировка:

let arr = Int16Array.of(4, 1, 3, 2);
arr.sort();
console.log(arr); // Int16Array(4) [1, 2, 3, 4]

Если нужно изменить стандартный порядок сортировки, это можно сделать с помощью пользовательской функции сортировки. Функция принимает две переменные и должна возвращать:

Отсортируем массив в обратном и прямом порядке:

let arr = Int16Array.of(4, 1, 3, 2);
arr.sort( function(a, b) {
   if (a > b) return -1;
   if (a < b) return 1;
   return 0;
});
console.log(arr); // Int16Array(4) [4, 3, 2, 1]
arr.sort((a, b) => a - b);
console.log(arr); // Int16Array(4) [1, 2, 3, 4]

Проверка наличия значения в массиве

Выполнить поиск элемента в массиве позволяют следующие методы:

let arr = Int16Array.of(1, 2, 1, 2, 3);
console.log( arr.indexOf(2) );        // 1
console.log( arr.indexOf(2, 2) );     // 3
console.log( arr.indexOf(3) );        // 4
console.log( arr.indexOf(8) );        // -1
let arr = Int16Array.of(1, 2, 1, 2, 3);
console.log( arr.lastIndexOf(2) );    // 3
console.log( arr.lastIndexOf(2, 2) ); // 1
console.log( arr.lastIndexOf(3) );    // 4
console.log( arr.lastIndexOf(8) );    // -1
let arr = Int16Array.of(1, 2, 3);
console.log( arr.includes(1) );    // true
console.log( arr.includes(1, 1) ); // false
console.log( arr.includes(4) );    // false
function test(value, index, ar) {
   return value > 1;
}
let arr = Int16Array.of(2, 3), arr2 = Int16Array.of(1, 2, 0);
console.log( arr.every(test) );    // true
console.log( arr2.every(test) );   // false
function test(value, index, ar) {
   return value < 1;
}
let arr = Int16Array.of(2, 3), arr2 = Int16Array.of(1, 2, 0);
console.log( arr.some(test) );    // false
console.log( arr2.some(test) );   // true
function test(value, index, ar) {
   return value < 1;
}
let arr = Int16Array.of(2, 3), arr2 = Int16Array.of(1, 2, 0);
console.log( arr.find(test) );    // undefined
console.log( arr2.find(test) );   // 0
function test(value, index, ar) {
   return value < 1;
}
let arr = Int16Array.of(2, 3), arr2 = Int16Array.of(1, 2, 0);
console.log( arr.findIndex(test) );    // -1
console.log( arr2.findIndex(test) );   // 2

Преобразование массива в строку или другой объект

Преобразовать массив в строку позволяют следующие методы:

let arr = Int16Array.of(1, 2, 3);
let str = arr.join(' - ');
console.log(str); // 1 - 2 - 3

Если параметр не указан, то в качестве символа-разделителя будет использоваться запятая:

let arr = Int16Array.of(1, 2, 3);
let str = arr.join();
console.log(str); // 1,2,3
let arr = Int16Array.of(1, 2, 32767);
console.log( arr.toString() ); // 1,2,32767
console.log(arr + '');         // 1,2,32767
let arr = Int16Array.of(1, 2, 32767);
console.log( arr.toLocaleString('en-US') ); // 1,2,32,767
console.log( arr.toLocaleString('ru-RU') ); // 1,2,32 767

Для преобразования типизированного массива в обычный массив можно воспользоваться оператором SPREAD:

let arr = Int16Array.of(1, 2, 3);
let arr2 = [...arr];
console.log(arr2); // [1, 2, 3]