Array.prototype.pop()

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

Доступ к элементам массива в рамках цикла

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

В ECMAScript6 был представлен способ прокрутки массива без использования индексов, а через новый цикл .

Цикл предназначен для прохода по элементам массива, не затрагивая при этом индекс элемента.

var ary = ;

for (let item of ary){
  console.log(item);
}
// "orange", "apple", "lychee"
Для сравнения: вывод индексов элементов в цикле for.
var ary = ;

for (var item = 0; item < ary.length; item++){
  console.log(item);
}
// 0, 1, 2

Работа с массивами в JS:

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

Важно:

В JavaScript индексация начинается с нуля.

JavaScript

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

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

JavaScript

Здесь всё крайне просто, в цикле мы выводим каждый элемент, самое интересное, это условие, при котором он должен работать, там мы используем метод , который возвращает количество данных.

То есть цикл будет работать, пока строга меньше трёх, в нашем случае.

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

Default

Вот что выведется:

Методы работы с массивами в JS:

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

• push() — Добавляет элемент в конец массива;
• pop() — Удаляет элемент в конце массива;
• unshift() — Добавляем элемент в начала массива;
• shift() — Удаляем из массива первый элемент;
• splice() — Заменяет или удаляет элементы
• concat() — Объединяет массивы;
• farEach() — Перебор массива;

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

JavaScript

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

Как видите вывод массива изменился, в конец добавилось слово, а в начала удалилось.

Вот этот пример покажет как происходит в JavaScript удаление элемента массива или его замена.

JavaScript

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

Ещё благодаря этому методу, можете заменять элементы.

JavaScript

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

Последнее что мы рассмотрим, это как в JavaScript перебрать массив и объединить его с другим массивом.

JavaScript

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

Дальше с помощью метода мы перебираем, внутри в качестве параметра используем функцию, которая принимает в себя ещё два параметра, это , значение элемента и , его индекс.

Выводим весь массив в консоль, вот что получилось.

Как видите, у нас вывелся объединённый массив, то есть, всё правильно работает.

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

Что такое ассоциативный массив?

Ассоциативный массив — это массив, у которого в качестве ключей используются строки.

Представить структуру данных ассоциативного массива можно как совокупность пар «ключ-значение». В ассоциативном массиве каждое значение связано с определённым ключом. Доступ к значению осуществляется по имени ключа.

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

Для того чтобы найти нужную коробочку в ящичке нужно знать её имя (ключ). Зная имя (ключ) коробочки можно получить её содержимое (значение).

Don’t compare arrays with ==

Arrays in JavaScript, unlike some other programming languages, shouldn’t be compared with operator .

This operator has no special treatment for arrays, it works with them as with any objects.

Let’s recall the rules:

• Two objects are equal only if they’re references to the same object.
• If one of arguments of is an object, and the other one is a primitive, then the object gets converted to primitive, as explained in the chapter Object to primitive conversion.
• …With an exception of and that equal each other and nothing else.

The strict comparison is even simpler, as it doesn’t convert types.

So, if we compare arrays with , they are never the same, unless we compare two variables that reference exactly the same array.

For example:

These arrays are technically different objects. So they aren’t equal. The operator doesn’t do item-by-item comparison.

Comparison with primitives may give seemingly strange results as well:

Here, in both cases, we compare a primitive with an array object. So the array gets converted to primitive for the purpose of comparison and becomes an empty string .

Then the comparison process goes on with the primitives, as described in the chapter Type Conversions:

So, how to compare arrays?

That’s simple: don’t use the operator. Instead, compare them item-by-item in a loop or using iteration methods explained in the next chapter.

Как распознать массив

Общий вопрос: как узнать, является ли переменная массивом?

Проблема в том, что JavaScript оператор возвращает
«»:

var fruits = ;
typeof fruits;    // возвращает объект

Оператор typeof возвращает объект, потому что массив JavaScript является объектом.

Решение 1:

Для решения этой проблемы ECMAScript 5 определяет новый метод :

Array.isArray(fruits);   // возвращает true

Проблема с этим решением заключается в том, что ECMAScript 5 не поддерживается в старых браузерах.

Решение 2:

Чтобы решить эту проблему, вы можете создать свою собственную функцию :

function isArray(x) {  return x.constructor.toString().indexOf(«Array») > -1;}

Функция выше всегда возвращает true, если аргумент является массивом.

Или точнее: он возвращает true, если в прототипе объекта содержится слово «Array».

Решение 3:

Оператор возвращает true, если объект создан данным конструктором:

var fruits = ;fruits instanceof Array;   // возвращает true

❮ Prev
Next ❯

Пожалуйста, включите JavaScript для просмотра комментариев, предоставленных Disqus.

Loops

One of the oldest ways to cycle array items is the loop over indexes:

But for arrays there is another form of loop, :

The doesn’t give access to the number of the current element, just its value, but in most cases that’s enough. And it’s shorter.

Technically, because arrays are objects, it is also possible to use :

But that’s actually a bad idea. There are potential problems with it:

1. The loop iterates over all properties, not only the numeric ones.

   There are so-called “array-like” objects in the browser and in other environments, that look like arrays. That is, they have and indexes properties, but they may also have other non-numeric properties and methods, which we usually don’t need. The loop will list them though. So if we need to work with array-like objects, then these “extra” properties can become a problem.

2. The loop is optimized for generic objects, not arrays, and thus is 10-100 times slower. Of course, it’s still very fast. The speedup may only matter in bottlenecks. But still we should be aware of the difference.

Generally, we shouldn’t use for arrays.

Методы, которые можно заменить

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

push

При работе с массивами этот метод используется довольно часто. Фактически он добавляет один элемент в конец массива. Метод также иногда используется для создания нового массива на основе уже существующего.

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

А если нужно будет добавить новый элемент в конец массива, кроме  можно использовать spread-оператор:

splice

Метод используется в тех случаях, когда нужно удалить элемент где-то в середине массива. Хотя тоже самое можно сделать и с помощью :

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

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

JS Учебник

JS СтартJS ВведениеJS УстановкаJS ВыводJS ОбъявленияJS СинтаксисJS КомментарииJS ПеременныеJS ОператорыJS АрифметическиеJS ПрисваиваниеJS Типы данныхJS ФункцииJS ОбъектыJS СобытияJS СтрокиJS Методы строкиJS ЧислаJS Методы числаJS МассивыJS Методы массиваJS Сортировка массиваJS Итерация массиваJS ДатыJS Форматы датJS Методы получения датJS Методы установки датJS МатематическиеJS РандомныеJS БулевыJS СравненияJS УсловияJS SwitchJS Цикл ForJS Цикл WhileJS ПрерываниеJS Преобразование типовJS ПобитовыеJS Регулярные выраженияJS ОшибкиJS Область действияJS ПодъёмJS Строгий режимJS Ключевое слово thisJS Ключевое слово LetJS Ключевое слово ConstJS Функции стрелокJS КлассыJS ОтладкаJS Гид по стилюJS Лучшие практикиJS ОшибкиJS ПроизводительностьJS Зарезервированные словаJS ВерсииJS Версия ES5JS Версия ES6JS JSON

Основа основ

Есть 4 вещи, которые вы должны знать при работе с массивами — это , , и spread-оператор. Они являются мощным базисом.

map

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

Метод принимает всего один параметр — функцию, которая вызывается при каждой итерации по массиву. Метод возвращает новый массив, а не изменяет существующий.

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

Поэтому, если нужно поэлементно трансформировать массив в новый — используйте .

filter

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

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

• — элемент остаётся в новом массиве,
• — элемент не остаётся в новом массиве.

После этого вы получаете отфильтрованный массив с нужными вам элементами.

Full Stack Web Developer (Middle+)

Tproger, Москва, От 70 000 до 200 000 ₽

tproger.ru

Вакансии на tproger.ru

К примеру, сохраним только нечётные числа в массиве:

Или же можно удалять строго определённые элементы массива:

reduce

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

Метод предназначен для комбинации значений массива в одно значение. Метод принимает два параметра. Первый из них — callback-функция (), второй — первичное значение, которое является необязательным и по-умолчанию является первым элементом массива. Callback-функция принимает 4 аргумента:

• accumulator (он хранит в себе промежуточный результат итераций),
• текущее значение массива,
• текущий ,
• сам массив.

В большинстве случаев вам достаточно будет первых двух аргументов: промежуточного результата и текущего значения.

Поначалу это может звучать сложно, но на примерах всё разъяснится. Вот самый простой из них:

При первой итерации переменная (промежуточный результат) принимает значение 37. Возвращаемое значение равно , где n равняется 12, т. е. значение равно 49. При второй итерации промежуточный результат равен 49 и к нему прибавляется 28. Теперь равен 77. И так далее.

Метод настолько хорош, что с его помощью можно создавать остальные методы массива, например или :

В случае запускается функция, результат которой добавляется в конец accumulator’а с помощью spread-оператора. В почти то же самое, за исключением того, что на каждом элементе запускается filter-функция. Если эта функция возвращает , то возвращается предыдущий массив (промежуточное значение), иначе элемент добавляется в конец массива.

Вот более сложный пример: функция, которая «сглаживает» массив рода в одномерный массив .

Принцип работы схож с , только с щепоткой рекурсии.

Spread оператор (стандарт ES2015)

Несмотря на то что оператор не является методом, с его помощью можно добиться многого при работе с массивами. Например, можно делать копии массивов или же объединять несколько массивов в один.

Обратите внимание, что этот оператор создаёт поверхностную копию исходного массива. Но что значит?. При поверхностном копировании элементы массива дублируются минимальным образом

Если, скажем, массив состоит только из примитивов (числа, строки, булевы значения), то это не вызовет никаких проблем. Но нельзя сказать то же самое о массиве объектов. При поверхностном копировании объектов в массиве созданные (продублированные) элементы ссылаются на оригиналы. Следовательно, если вы попытаетесь изменить объект в массиве, то изменения будут отражаться и на всех продублированных с него объектах (так же и в обратную сторону)

При поверхностном копировании элементы массива дублируются минимальным образом. Если, скажем, массив состоит только из примитивов (числа, строки, булевы значения), то это не вызовет никаких проблем. Но нельзя сказать то же самое о массиве объектов. При поверхностном копировании объектов в массиве созданные (продублированные) элементы ссылаются на оригиналы. Следовательно, если вы попытаетесь изменить объект в массиве, то изменения будут отражаться и на всех продублированных с него объектах (так же и в обратную сторону).

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

Метод sort

Метод Array.sort() на месте сортирует элементы массива и возвращает отсортированный массив. Если метод sort() вызывается без аргумента, то он сортирует элементы массива в алфавитном порядке (временно преобразует их в строки для выполнения сравнения). В качестве аргумента метод sort() может принимать функцию сравнения, которая определяет порядок сортировки элементов.

var a = ;
a.sort();
var s = a.join(", ");  //Апельсины, Груши, Киви 
document.write(s);

//пример с числами
var myArr = ;
myArr.sort();
	 
document.write(myArr);  //1,10,2

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

Наверное от сортировки чисел вы ожидали увидеть немного другой результат. Такая сортировка произошла потому, что метод sort() сортирует элементы, преобразуя их в строки. Поэтому и порядок у них получается строковой — ведь «10»

Для сортировки в каком-либо ином порядке, отличном от алфавитного, можно передать методу sort() в качестве аргумента функцию сравнения. Следует однако учесть, что функцию сравнения придется писать самим. Эта функция должна иметь два параметра, так как она устанавливает, какой из двух ее аргументов должен присутствовать раньше в отсортированном списке. Чтобы было легче разобраться и написать такую функцию, есть несколько правил, по которым будет определяться порядок элементов:

• Если первый аргумент должен предшествовать второму, функция сравнения возвращает отрицательное число (если a
• Если первый аргумент должен следовать за вторым, то функция сравнения возвращает положительное число (если a > b)
• Если два значения эквивалентны (т. е. порядок их расположения не важен), функция сравнения возвращает 0 (если a == b)

Для сравнения в качестве своих аргументов функция использует элементы массива:

function foo(a,b) {  //определяем функцию проверки
  if (a  b)  return 1;  
        
  return 0;  //если a == b  
}  
	
var a = ;
a.sort(foo);  //в качестве аргумента передается только имя функции
document.write(a.join(", "));

//тоже самое записать более коротко
var a = ;
a.sort(function(a,b) {  //используем анонимную функцию
  return a - b;         //функция возвращает значение  0
});

document.write(a);  //1,2,5,10

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

Первая запись в примере написана так, для того, чтобы было легче понять, как это работает

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

Примечание: Если в массиве есть неопределенные элементы (undefined), они переносятся в конец массива.

Methods pop/push, shift/unshift

A queue is one of the most common uses of an array. In computer science, this means an ordered collection of elements which supports two operations:

• appends an element to the end.
• get an element from the beginning, advancing the queue, so that the 2nd element becomes the 1st.

Arrays support both operations.

In practice we need it very often. For example, a queue of messages that need to be shown on-screen.

There’s another use case for arrays – the data structure named stack.

It supports two operations:

• adds an element to the end.
• takes an element from the end.

So new elements are added or taken always from the “end”.

A stack is usually illustrated as a pack of cards: new cards are added to the top or taken from the top:

For stacks, the latest pushed item is received first, that’s also called LIFO (Last-In-First-Out) principle. For queues, we have FIFO (First-In-First-Out).

Arrays in JavaScript can work both as a queue and as a stack. They allow you to add/remove elements both to/from the beginning or the end.

In computer science the data structure that allows this, is called deque.

Methods that work with the end of the array:

Extracts the last element of the array and returns it:

Append the element to the end of the array:

The call is equal to .

Methods that work with the beginning of the array:

Extracts the first element of the array and returns it:

Add the element to the beginning of the array:

Methods and can add multiple elements at once:

JavaScript объекты

Javascript — объектно-ориентированный язык. Это значит, что с некоторыми типами данных можно работать как с объектами, что позволяет применять к ним дополнительные функции для работы с объектами. К примеру, со строками можно работать и как с обычным типом данных и как с объектами:

// обычная строковая переменная myStr:
var myStr = "Текст";
 
// создание строкового объекта myStr:
var myStr = new String();

• Object(объекты)
• Number (обработка чисел)
• String (обработка строк)
• Array (массивы)
• Math (математические формулы, функции и константы)
• Date (работа с датами и временем)
• RegExp
• Global (его свойства Infinity, NaN, undefined)
• Function

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

Object — объект, который содержится во всех остальных объектах и обеспечивает их общую функциональность.

Объект function — функции являются объектами первого класса, т.е. могут присваиваться переменным, выступать аргументами других функций и быть результатом функций

Объявление новых объектов происходит одинаково, независимо от объекта (используется служебное слово new):

Как видно из примера, в javascript объявление массива происходит точно так же, как и у других объектов.

reduce/reduceRight

Метод «arr.reduce(callback)» используется для последовательной обработки каждого элемента массива с сохранением промежуточного результата.

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

Метод используется для вычисления на основе массива какого-либо единого значения, иначе говорят «для свёртки массива». Чуть далее мы разберём пример для вычисления суммы.

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

Аргументы функции :

• – последний результат вызова функции, он же «промежуточный результат».
• – текущий элемент массива, элементы перебираются по очереди слева-направо.
• – номер текущего элемента.
• – обрабатываемый массив.

Кроме , методу можно передать «начальное значение» – аргумент . Если он есть, то на первом вызове значение будет равно , а если у нет второго аргумента, то оно равно первому элементу массива, а перебор начинается со второго.

Проще всего понять работу метода на примере.

Например, в качестве «свёртки» мы хотим получить сумму всех элементов массива.

Вот решение в одну строку:

Разберём, что в нём происходит.

При первом запуске – исходное значение, с которого начинаются вычисления, равно нулю (второй аргумент ).

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

Поток вычислений получается такой

В виде таблицы где каждая строка – вызов функции на очередном элементе массива:

Как видно, результат предыдущего вызова передаётся в первый аргумент следующего.

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

Посмотрим, что будет, если не указать в вызове :

Результат – точно такой же! Это потому, что при отсутствии в качестве первого значения берётся первый элемент массива, а перебор стартует со второго.

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

Метод arr.reduceRight работает аналогично, но идёт по массиву справа-налево.

Значения параметров

JS Tutorial

JS HOMEJS IntroductionJS Where ToJS OutputJS StatementsJS SyntaxJS CommentsJS VariablesJS OperatorsJS ArithmeticJS AssignmentJS Data TypesJS FunctionsJS ObjectsJS EventsJS StringsJS String MethodsJS NumbersJS Number MethodsJS ArraysJS Array MethodsJS Array SortJS Array IterationJS DatesJS Date FormatsJS Date Get MethodsJS Date Set MethodsJS MathJS RandomJS BooleansJS ComparisonsJS ConditionsJS SwitchJS Loop ForJS Loop WhileJS BreakJS Type ConversionJS BitwiseJS RegExpJS ErrorsJS ScopeJS HoistingJS Strict ModeJS this KeywordJS LetJS ConstJS Arrow FunctionJS ClassesJS DebuggingJS Style GuideJS Best PracticesJS MistakesJS PerformanceJS Reserved WordsJS VersionsJS 2009 (ES5)JS 2015 (ES6)JS 2016JS 2017JS JSON

Slicing an Array

The method slices out a piece of an array into a new
array.

This example slices out a part of an array starting from array element 1
(«Orange»):

var fruits = ;
var citrus = fruits.slice(1);

The method creates a new array. It does not remove any elements from
the source array.

This example slices out a part of an array starting from array element 3
(«Apple»):

var fruits = ;
var citrus = fruits.slice(3);

The method can take two arguments like .

The method then selects elements from the start argument, and up to (but not
including) the end argument.

var fruits = ;
var citrus = fruits.slice(1, 3);

If the end argument is omitted, like in the first examples, the
method slices out the rest of the array.

Доступ к элементам массива

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

Индексы массива начинаются с нуля. Это означает, что первый элемент массива хранится с индексом 0, а не с 1, второй элемент хранится с индексом 1 и т.д. Индексы массива начинаются с 0 и доходят до значения количества элементов минус 1. Таким образом, массив из пяти элементов будет иметь индексы от 0 до 4.

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

var fruits = ;

document.write(fruits); // Результат: Apple
document.write(fruits); // Результат: Banana
document.write(fruits); // Результат: Mango
document.write(fruits); // Результат: Papaya

Sorting an Array

Метод join

Метод Array.join() используется для объединения элементов массива в одну строку. Методу можно передать необязательный строковой аргумент, который будет использоваться для разделения элементов в строке. Если разделитель не задан, то при вызове метода символом-разделителем по умолчанию будет запятая.

var a = ;
var myVar1 = a.join();      //"Ветер,Дождь,Огонь"
var myVar2 = a.join(", ");  //"Ветер, Дождь, Огонь"
var myVar3 = a.join(" + "); //"Ветер + Дождь + Огонь"

document.write(myVar1 + "<br>" + myVar2 + "<br>" + myVar3);

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

Метод Array.join() является обратным по отношению к методу String.split(), который создает массив путем разбиения строки на фрагменты.