Как определить длину массива javascript и еще много функций работы с ними

Смотрите также

Операции с массивом

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

Выполнить код »
Скрыть результаты

Добавление нового элемента осуществляется точно так же, с помощью оператора квадратные скобки:

Выполнить код »
Скрыть результаты

В этом коде в массив arr добавляется значение в позиции 5, при этом длина становится равна 6 (5 + 1). Элементы с индексами от 1 до 4 не существуют, и при доступе к ним возвращается значение .

Если в массиве есть пропущенные индексы, как в примере выше, то при его выводе появляются «лишние» запятые.
Дело в том, что алгоритм вывода массива осуществляется от до arr.length и выводит всё через запятую. Отсутствующие значения дают несколько запятых подряд.

Удаление элементов массива осуществляется с помощью оператора :

Выполнить код »
Скрыть результаты

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

Массив (Array) – это упорядоченный набор пронумерованных значений. Каждое значение называется элементом массива, а номер элемента в массиве, называется его индексом. Так как JavaScript – это нетипизированный язык, элемент массива может иметь любой тип, причем разные элементы одного массива могут иметь разные типы. Элемент массива может быть даже объектом или другим массивом.

Объекты массивов могут создаваться путем присвоения переменным литеральных значений массивов либо при помощи оператора .

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

Другой способ создания массива состоит в вызове конструктора . Вызывать конструктор можно тремя разными способами:

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

Во втором – массив с заданным количеством элементов (каждый из которых имеет значение undefined) и устанавливает свойство массива равным указанному значению:

Третий способ очень похож на определение массива с помощью литерала – аналогично создается массив, заполненный указанными значениями. Свойство массива устанавливается равным количеству элементов, переданных конструктору:

Когда конструктор вызывается как функция (без оператора ), он ведет себя точно так же, как при вызове с оператором :

Array.isArray

Массивы не
образуют отдельный тип языка. Они основаны на объектах. Поэтому typeof не может
отличить простой объект от массива:

console.log(typeof {}); // object
console.log (typeof ); // тоже object

Но массивы
используются настолько часто, что для этого придумали специальный метод: Array.isArray(value). Он возвращает
true, если value массив, и false, если нет.

console.log(Array.isArray({})); // false
console.log(Array.isArray()); // true

Подведем итоги
по рассмотренным методам массивов. У нас получился следующий список:

Видео по теме

JavaScipt #1: что это такое, с чего начать, как внедрять и запускать

JavaScipt #2: способы объявления переменных и констант в стандарте ES6+

JavaScript #3: примитивные типы number, string, Infinity, NaN, boolean, null, undefined, Symbol

JavaScript #4: приведение типов, оператор присваивания, функции alert, prompt, confirm

JavaScript #5: арифметические операции: +, -, *, /, **, %, ++, —

JavaScript #6: условные операторы if и switch, сравнение строк, строгое сравнение

JavaScript #7: операторы циклов for, while, do while, операторы break и continue

JavaScript #8: объявление функций по Function Declaration, аргументы по умолчанию

JavaScript #9: функции по Function Expression, анонимные функции, callback-функции

JavaScript #10: анонимные и стрелочные функции, функциональное выражение

JavaScript #11: объекты, цикл for in

JavaScript #12: методы объектов, ключевое слово this

JavaScript #13: клонирование объектов, функции конструкторы

JavaScript #14: массивы (array), методы push, pop, shift, unshift, многомерные массивы

JavaScript #15: методы массивов: splice, slice, indexOf, find, filter, forEach, sort, split, join

JavaScript #16: числовые методы toString, floor, ceil, round, random, parseInt и другие

JavaScript #17: методы строк — length, toLowerCase, indexOf, includes, startsWith, slice, substring

JavaScript #18: коллекции Map и Set

JavaScript #19: деструктурирующее присваивание

JavaScript #20: рекурсивные функции, остаточные аргументы, оператор расширения

JavaScript #21: замыкания, лексическое окружение, вложенные функции

JavaScript #22: свойства name, length и методы call, apply, bind функций

JavaScript #23: создание функций (new Function), функции setTimeout, setInterval и clearInterval

Число

Числовой тип данных () представляет как целочисленные значения, так и числа с плавающей точкой.

Существует множество операций для чисел, например, умножение , деление , сложение , вычитание и так далее.

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

• представляет собой математическую ∞. Это особое значение, которое больше любого числа.

  Мы можем получить его в результате деления на ноль:

  Или задать его явно:

• означает вычислительную ошибку. Это результат неправильной или неопределённой математической операции, например:

  Значение «прилипчиво». Любая операция с возвращает :

  Если где-то в математическом выражении есть , то результатом вычислений с его участием будет .

Математические операции – безопасны

Математические операции в JavaScript «безопасны». Мы можем делать что угодно: делить на ноль, обращаться с нечисловыми строками как с числами и т.д.

Скрипт никогда не остановится с фатальной ошибкой (не «умрёт»). В худшем случае мы получим как результат выполнения.

Специальные числовые значения относятся к типу «число». Конечно, это не числа в привычном значении этого слова.

Подробнее о работе с числами мы поговорим в главе Числа.

Несколько полезных заметок

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

Помимо этих средств, существует интересный текстовый формат json, который был создан на основе JavaScript и служит для передачи данных между сервером и клиентом. Подробнее о нем я рассказывал в статье, связанной как раз с преобразованием массивов в строки.

На этом окончу свое повествование. Вступайте в группу моих подписчиков и приглашайте друзей. А я вам желаю терпения и удачи в обучении!

Пока-пока!

Прочитано: 243 раз

Фото презентаций на компьютере

Метод splice

Метод Array.splice() — это универсальный метод для работы с массивами. Он изменяет массив на месте, а не возвращает новый измененный массив, как это делают методы slice() и concat(). Метод splice может удалять элементы из массива, вставлять новые элементы, заменять элементы — по очереди и одновременно. Он возвращает массив, состоящий из удаленных элементов, если ни один из элементов не был удален, вернет пустой массив.

Синтаксис метода:

имя_массива.splice(index , кол-во, elem1, ..., elemN);

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

var fruits = ;

var deleted = fruits.splice(2,2);  //возвращает 
document.write(deleted);
			
var arr = ;

arr.splice(4);    //Возвращает ; массив стал: 
arr.splice(1,2);  //Возвращает ; массив стал: 
arr.splice(1,1);  //Возвращает ; массив стал: 

Попробовать »

Первые два аргумента метода splice() задают элементы массива, подлежащие удалению. За этими двумя аргументами может следовать любое количество дополнительных аргументов, задающих элементы, которые будут вставлены в массив, начиная с позиции, заданной первым аргументом.

var fruits = ;

fruits.splice(2,0, "арбузы");  //возвращает []
document.write(fruits);  //стало 
			
var arr = ;

arr.splice(2,0,'a','b'); //Возвращает []; стало 
arr.splice(2,2,);   //Возвращает ; стало ,3,4,5]

Попробовать »

Стоит обратить внимание, что в отличие от concat(), метод splice() не разбивает на отдельные элементы массивы, передаваемые в качестве аргументов. То есть, если методу передается массив для вставки, он вставляет сам массив, а не элементы этого массива

Подборка: 7 Chrome-расширений для обхода блокировок

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

В JavaScript создание массива делается так: пишется имя массива, ставится знак «=»
а затем в квадратных скобках перечисляются элементы.

имя массива =

Создадим массив, с которым далее будем работать.

+

var mas = ;

Созданный массив можно вывести на страницу:

document.write(mas);

Чтобы обратиться к элементу массива, нужно написать имя массива и в квадратных скобках указать номер
элемента. Нумерация элементов начинается не с 1, а с 0. Почти всё, что может быть пронумеровано в
JavaScript, начинается с нуля, а не с единицы. Этот принцип применяется
в большинствеязыков программирования.

Номера элементов называются индексы.

Для примера выведем на страницу значение элемента 0, а элементу 1 присвоим новое значение и тоже выведем
на страницу:

document.write('<br>');
document.write(mas);
mas = 80;
document.write('<br>');
document.write(mas);

В нашем примере все элементы являются числами. Но массив может содержать данные любых типов. Элементом
массива может быть
другой массив. Один массив может иметь элементы разных типов. Пример:

var dif = ;

Существует ещё один способ создания массива в JavaScript. Он сложнее, поэтому используется редко. При
этом используется ключевое слово new и указывается, что создаётся массив.

new Array (элемент0, элемент1, элемент2)

Для примера создадим ещё один массив:

var nmas = new Array (2, 15);

Добавление и удаление элементов массива

Мы уже видели, что самый простой способ добавить элементы в массив заключается в том, чтобы присвоить значения новым индексам. Для добавления одного или более элементов в конец массива можно также использовать метод push():

Добавить элемент в конец массива можно также, присвоив значение элементу arr. Для вставки элемента в начало массива можно использовать метод unshift(), при этом существующие элементы в массиве смещаются в позиции с более высокими индексами.

Удалять элементы массива можно с помощью оператора delete, как обычные свойства объектов:

Удаление элемента напоминает (но несколько отличается) присваивание значения undefined этому элементу

Обратите внимание, что применение оператора delete к элементу массива не изменяет значение свойства length и не сдвигает вниз элементы с более высокими индексами, чтобы заполнить пустоту, оставшуюся после удаления элемента

Кроме того имеется возможность удалять элементы в конце массива простым присваиванием нового значения свойству length. Массивы имеют метод pop() (противоположный методу push()), который уменьшает длину массива на 1 и возвращает значение удаленного элемента. Также имеется метод shift() (противоположный методу unshift()), который удаляет элемент в начале массива. В отличие от оператора delete, метод shift() сдвигает все элементы вниз на позицию ниже их текущих индексов.

Наконец существует многоцелевой метод splice(), позволяющий вставлять, удалять и замещать элементы массивов. Он изменяет значение свойства length и сдвигает элементы массива с более низкими или высокими индексами по мере необходимости. Все эти методы мы разберем чуть позже.

Что с олеофобным покрытием делают защитные стёкла

Копирование массива в JavaScript

slice()

В JS копирование массива бывает поверхностным либо неглубоким (shallow copy) а также deep copy, то есть глубоким.

В первом случае мы присваиваем переменной значение другой переменной, хранящей массив:

    var users = "Tom", "Bob", "Bill"];
console.log(users);     //  
var people = users;     //  shallow copy

people1 = "John";     //  меняем 2-й элемент
console.log(users);     //  

В нашем случае переменная people после неглубокого копирования станет указывать на тот же массив, что и переменная users. Именно поэтому в случае изменения элементов в people, поменяются элементы и в users, ведь по факту это один и тот же массив.

Вышеописанное поведение не всегда желательно. К примеру, нам надо, чтобы после копирования переменные указывали на отдельные массивы. Тогда подойдёт глубокое копирование посредством метода slice():

    var users = "Tom", "Bob", "Bill"];
console.log(users);             //  
var people = users.slice();     //  deep copy

people1 = "John";             //  меняем 2-й элемент
console.log(users);             //  
console.log(people);            //  

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

Кроме того, функция slice() даёт возможность копировать часть массива:

    var users = "Tom", "Bob", "Bill", "Alice", "Kate"];
var people = users.slice(1, 4);
console.log(people);        // 

В функцию slice() мы передаём начальный и конечный индексы, используемые для выборки значений из нашего массива. В таком случае выборка в новый массив начнётся с первого индекса по индекс № 4, не включая его. И, так как индексация массивов в JavaScript начинается с нуля, в новом массиве будут 2-й, 3-й и 4-й элементы.

push()

Функция push() добавит элемент в конец нашего массива:

    var fruit = [];
fruit.push("груши");
fruit.push("яблоки");
fruit.push("сливы");
fruit.push("вишни","абрикосы");

document.write("В массиве fruit " + fruit.length + " элемента: <br/>");
document.write(fruit); // груши,яблоки,сливы,вишни,абрикосы

pop()

Такая функция, как pop(), удалит последний элемент из JavaScript-массива:

    var fruit = "груши", "яблоки", "сливы"];

var lastFruit = fruit.pop(); // из массива извлекается последний элемент
document.write(lastFruit + "<br/>");
document.write("В массиве fruit " + fruit.length + " элемента: <br/>");
for(var i=; i <fruit.length; i++)
    document.write(fruiti + "<br/>");

Итоговый вывод:

сливы
В массиве fruit 2 элемента: 
груши
яблоки

shift()

Теперь рассмотрим функцию shift(). Она может извлекать и удалять 1-й элемент из массива:

    var fruit = "груши", "яблоки", "сливы"];

var firstFruit = fruit.shift();
document.write(firstFruit + "<br/>");
document.write("В массиве fruit " + fruit.length + " элемента: <br/>");
for(var i=; i <fruit.length; i++)
    document.write(fruiti + "<br/>");

Вывод следующий:

груши
В массиве fruit 2 элемента: 
яблоки
сливы

unshift()

Что касается функции unshift(), то она добавит новый элемент в самое начало массива:

    var fruit = "груши", "яблоки", "сливы"];
fruit.unshift("апельсины");
document.write(fruit);

Вывод браузера:

апельсины,груши,яблоки,сливы

infexOf и lastIndexOf

Данный метод
выполняет поиск подстроки substr, начиная с позиции pos:

str.indexOf(substr)

возвращает
позицию, на которой располагается совпадение, либо -1 если совпадений не
найдено.

let str = '<span class="clock">12:34</span>';
let indx1 = str.indexOf("clock");          // 13
let indx2 = str.indexOf("span", 2);        // 27
let indx3 = str.indexOf("div");            // -1
 
console.log(indx1, indx2, indx3);

Обратите
внимание, данный метод находит только одно первое совпадение, дальше поиск не
продолжается. Если нужно найти все совпадения, то можно реализовать такой
простой алгоритм:

let indx = -1;
 
while(true) {
    indx = str.indexOf("span", indx+1);
    if(indx == -1) break;
    console.log(indx);
}

Другой похожий метод

str.lastIndexOf(substr,
position)

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

let indx = str.lastIndexOf("span");
console.log(indx);

Нюансы сравнения строк

Если мы
проверяем строки на равенство, то никаких особых проблем в JavaScript это не
вызывает, например:

if("abc" == "abc") console.log( "строки равны" );
if("abc" != "ABC") console.log( "строки не равны" );

Но, когда мы
используем знаки больше/меньше, то строки сравниваются в лексикографическом
порядке. То есть:

1. Если код
текущего символа одной строки больше кода текущего символа другой строки, то
первая строка больше второй (остальные символы не имеют значения), например:

console.log( "z" > "Za" );        //true

2. Если код
текущего символа одной строки меньше кода текущего символа другой строки, то
первая строка меньше второй:

console.log( "B" < "a" );    //true

3. При равенстве
символов больше та строка, которая содержит больше символов:

console.log( "abc" < "abcd" ); //true

4. В остальных
случаях строки равны:

console.log( "abc" == "abc" ); //true

Но в этом
алгоритме есть один нюанс. Например, вот такое сравнение:

console.log( "Америка" > "Japan" );    //true

Дает значение true, так как
русская буква A имеет больший
код, чем латинская буква J. В этом легко убедиться,
воспользовавшись методом

str.codePointAt(pos)

который
возвращает код символа, стоящего в позиции pos:

console.log( "А".codePointAt(), "J".codePointAt() );

Сморите, у буквы
А код равен 1040, а у буквы J – 74. Напомню,
что строки в JavaScript хранятся в
кодировке UTF-16. К чему
может привести такой результат сравнения? Например, при сортировке мы получим
на первом месте страну «Japan», а потом «Америка». Возможно, это не
то, что нам бы хотелось? И здесь на помощь приходит специальный метод для
корректного сравнения таких строк:

str.localeCompare(compareStr)

он возвращает
отрицательное число, если str < compareStr, положительное
при str > compareStr и 0 если строки
равны. Например:

console.log( "Америка".localeCompare("Japan") );      // -1

возвращает -1
как и должно быть с учетом языкового сравнения. У этого метода есть два
дополнительных аргумента, которые указаны в документации JavaScript. Первый
позволяет указать язык (по умолчанию берётся из окружения) — от него зависит
порядок букв. Второй позволяет определять дополнительные правила, например, чувствительность
к регистру.

Методы pop/push и shift/unshift

Рассмотрим методы pop() и push(). Эти методы позволяют работать с массивами как со стеками. Стек — это структура данных, в которой доступ к элементам организован по принципу LIFO (англ. last in — first out, «последним пришёл — первым ушел»). Принцип работы стека можно сравнить со стопкой тарелок: чтобы взять вторую сверху, нужно снять верхнюю. Как это работает изображено на рисунке:

И так вернемся к рассмотрению методов push() и pop(). Метод push() добавляет один или несколько новых элементов в конец массива и возвращает его новую длину. Метод pop() — удаляет последний элемент массива, уменьшает длину массива и возвращает удаленное им значение

Стоит обратить внимание на то, что оба эти метода изменяют массив на месте, а не создают его модифицированную копию

var foo = [];    // foo: []
foo.push(1,2);   // foo:  Возвращает 2
foo.pop();       // foo:  Возвращает 2
foo.push(3);     // foo:  Возвращает 2
foo.pop();       // foo:  Возвращает 3
foo.push(); // foo: ] Возвращает 2
foo.pop()        // foo:  Возвращает 
foo.pop();       // foo: [] Возвращает 1

var fruits = ;
var picked = fruits.pop();
document.write("Вы сорвали мои " + picked);

Попробовать »

Методы shift() и unshift() ведут себя во многом также, как pop() и push(), за исключением того, что они вставляют и удаляют элементы в начале массива. Метод unshift() смещает существующие элементы в сторону больших индексов для освобождения места под новые элементы, добавляет один или несколько элементов в начало массива и возвращает новую длину массива. Метод shift() удаляет первый элемент массива и возвращает его значение, смещая все последующие элементы для занятия свободного места в начале массива.

var f = [];         // f:[]
f.unshift(1);       // f: Возвращает: 1
f.unshift(22);      // f: Возвращает: 2
f.shift();          // f: Возвращает: 22
f.unshift(3,); // f:,1] Возвращает: 3
f.shift();          // f:,1] Возвращает: 3
f.shift();          // f: Возвращает: 
f.shift();          // f:[] Возвращает: 1

Читайте также:

JavaScript

JS Array
concat()
constructor
copyWithin()
entries()
every()
fill()
filter()
find()
findIndex()
forEach()
from()
includes()
indexOf()
isArray()
join()
keys()
length
lastIndexOf()
map()
pop()
prototype
push()
reduce()
reduceRight()
reverse()
shift()
slice()
some()
sort()
splice()
toString()
unshift()
valueOf()

JS Boolean
constructor
prototype
toString()
valueOf()

JS Classes
constructor()
extends
static
super

JS Date
constructor
getDate()
getDay()
getFullYear()
getHours()
getMilliseconds()
getMinutes()
getMonth()
getSeconds()
getTime()
getTimezoneOffset()
getUTCDate()
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
now()
parse()
prototype
setDate()
setFullYear()
setHours()
setMilliseconds()
setMinutes()
setMonth()
setSeconds()
setTime()
setUTCDate()
setUTCFullYear()
setUTCHours()
setUTCMilliseconds()
setUTCMinutes()
setUTCMonth()
setUTCSeconds()
toDateString()
toISOString()
toJSON()
toLocaleDateString()
toLocaleTimeString()
toLocaleString()
toString()
toTimeString()
toUTCString()
UTC()
valueOf()

JS Error
name
message

JS Global
decodeURI()
decodeURIComponent()
encodeURI()
encodeURIComponent()
escape()
eval()
Infinity
isFinite()
isNaN()
NaN
Number()
parseFloat()
parseInt()
String()
undefined
unescape()

JS JSON
parse()
stringify()

JS Math
abs()
acos()
acosh()
asin()
asinh()
atan()
atan2()
atanh()
cbrt()
ceil()
clz32()
cos()
cosh()
E
exp()
expm1()
floor()
fround()
LN2
LN10
log()
log10()
log1p()
log2()
LOG2E
LOG10E
max()
min()
PI
pow()
random()
round()
sign()
sin()
sqrt()
SQRT1_2
SQRT2
tan()
tanh()
trunc()

JS Number
constructor
isFinite()
isInteger()
isNaN()
isSafeInteger()
MAX_VALUE
MIN_VALUE
NEGATIVE_INFINITY
NaN
POSITIVE_INFINITY
prototype
toExponential()
toFixed()
toLocaleString()
toPrecision()
toString()
valueOf()

JS OperatorsJS RegExp
constructor
compile()
exec()
g
global
i
ignoreCase
lastIndex
m
multiline
n+
n*
n?
n{X}
n{X,Y}
n{X,}
n$
^n
?=n
?!n
source
test()
toString()

(x|y)
.
\w
\W
\d
\D
\s
\S
\b
\B
\0
\n
\f
\r
\t
\v
\xxx
\xdd
\uxxxx

JS Statements
break
class
continue
debugger
do…while
for
for…in
for…of
function
if…else
return
switch
throw
try…catch
var
while

JS String
charAt()
charCodeAt()
concat()
constructor
endsWith()
fromCharCode()
includes()
indexOf()
lastIndexOf()
length
localeCompare()
match()
prototype
repeat()
replace()
search()
slice()
split()
startsWith()
substr()
substring()
toLocaleLowerCase()
toLocaleUpperCase()
toLowerCase()
toString()
toUpperCase()
trim()
valueOf()

Несколько слов о популярности Ворда

Самым популярным текстовым редактором является Word, если не брать в расчёт «Блокнот», конечно же. Причина популярности кроется не только в функционале, простоте и стабильности работы. Не стоит забывать, что программа идёт в комплексе Microsoft Office, а уже это — лучшая реклама, для студентов и офисных работников. Широкая аудитория узнала об аналогичных редакторах, после повсеместного распространения смартфонов и планшетов, на других операционных системах.

Но, по правде говоря, возможности этих приложений существенно ограничены, по сравнению с обсуждаемым сегодня редактором.

Можно и дальше ругать Word, говоря о регулярных проблемах с форматированием и периодических сбоях. Но по факту, именно этой программой пользуется большая часть пользователей. Часть из них, к сожалению, даже не подозревает обо всех возможностях редактора, используя его не более чем на пять процентов.

Description

The value of the property is an integer with a positive sign and a value less than 2 to the 32nd power (232).

var namelistA = new Array(4294967296); //2 to the 32nd power = 4294967296 
var namelistC = new Array(-100) //negative sign

console.log(namelistA.length); //RangeError: Invalid array length 
console.log(namelistC.length); //RangeError: Invalid array length 



var namelistB = []; 
namelistB.length = Math.pow(2,32)-1; //set array length less than 2 to the 32nd power 
console.log(namelistB.length); 

//4294967295

You can set the property to truncate an array at any time. When you extend an array by changing its property, the number of actual elements increases; for example, if you set to 3 when it is currently 2, the array now contains 3 elements, which causes the third element to be a non-iterable empty slot.

const arr = ;
console.log(arr);
// 

arr.length = 5; // set array length to 5 while currently 2.
console.log(arr);
// 

arr.forEach(element => console.log(element));
// 1
// 2

As you can see, the property does not necessarily indicate the number of defined values in the array. See also .

• : If this attribute set to , the value of the property cannot be changed.
• : If this attribute set to , any attempts to delete the property or change its attributes (, , or ) will fail.
• : If this attribute set to , the property will be iterated over during for or for..in loops.

7 — Typed Arrays and length

When working with typed arrays the length property refers to the number of bit sized units the array is. For example if it is a Unit16Array and it has 3 elements the length of it is 3, and the byte length of it is 6.

12345678910111213

var a = ; 
var buff = Uint8Array.from(a); 
console.log(buff); 

console.log(buff.length); 

console.log(buff.byteLength); 
 
var buff = Uint16Array.from(a); 
console.log(buff); 

console.log(buff.length); 

console.log(buff.byteLength); 

The length of an array generally refers to the number of elements, or the highest index value plus one. It does not always refer to the the size of the array in terms of data.