Теоретическая часть вопроса
По сути нам нужно сравнить Наборы (Set) элементов двух Массивов(Array). Я специально создам массивы с повторяющимися значениями. Зачем? Потому что в реальной жизни скорее всего будут дубли элементов в пределах одного массива.
В решении этой задачи нас будут интересовать только САМИ ЗНАЧЕНИЯ, а не их последовательности. Сравнивать мы будем содержимое.
var massiv1 =
var massiv2 =
Наборы(Set) оставят нам уникальные значения в массивах, чтобы мы не повторяли процедуру переборов по несколько раз для одинаковых элементов массивов. Их может быть десятки тысяч в реальных проектах. Это нагрузка на систему.
var set1 = Array.from(new Set(massiv1))
var set2 = Array.from(new Set(massiv2))
Набор возвращает объект, а нам нужен массив. Конвертируем наборы в массивы:
Наборы из Массивов и обратно — JavaScript
Логика такая! Если значение из первого массива встречается во втором массиве, тогда идём дальше на следующий элемент. Если элементы совпадают — значит это не «РАЗЛИЧИЯ», а «ОДИНАКОВОСТИ».
Мы должны отобрать все различия и вернуть их в качестве отдельного массива. Эта операция похожа на «вычитание массивов» — элементы одного массива вычитаются из другого массива. Жаль, что для вычитания не придумали встроенного в язык метода, ходя для сложения он есть.
Использование методов Array.prototype.filter() и Array.prototype.indexOf()
Основная стратегия здесь состоит в том, чтобы выполнить итерацию массива и проверить, совпадает ли индекс элемента, который мы проверяем, с индексом элемента в .
Так-как возвращает первый индекс, который он находит для данного значения, если это не дублирующее значение, тогда индекс для этого элемента должен быть таким же!
Обратите внимание, что этот метод не самый эффективный: он выполняется за квадратичное время. Поэтому, если проверяемые массивы очень большие, вы можете использовать другой метод
Стоит отметить еще одну вещь, это то, что мы можем использовать тот же метод, чтобы возвращать только дубликаты значений, инвертируя сравнение:
Улучшение № 2 — отбрасывание элементов, которые нельзя привести к числу
Среди строк может оказаться такая, которую нельзя будет привести к числу. Их нужно пропускать.
Допишем нашу функцию
Array.prototype.sum = function(){
var s = ;
for (i = ; i < this.length; i++){
if ( isNaN(this) == true) {continue}
else { s += Number(this) }
}
return s
}
Пример работы:
Функция sum пропускает строки с буквами — JavaScript
У Глобального Объекта (Global Object) JavaScript есть свои функциональные свойства:
- eval ( x )
- isFinite ( number )
- isNaN ( number )
- parseFloat ( string )
- parseInt ( string, radix )
- Функции обработки URI
Функция isNaN ( number ) — это внутренний объект %isNaN%. Когда функция isNaN вызывается с одним аргументом number, выполняются следующие шаги:
1. Пусть num будет ? (number). 2. Если num является NaN, вернуть true. 3. В противном случае вернуть false.
«This is Not a Number?» — расшифровка названия функции. На русском будет звучать так: «Это является Не Числом?«. Под «this/это» подразумевается то, что мы передаём в функцию.
То есть когда мы передадим в функцию isNaN() строку с буквами или прочими символами, тогда абстрактная операция ToNumber (перевод строки в число) вернёт нам NaN — и если это так, то функция isNaN() вернёт true. Условно можно сказать, что попытка отбросить кавычки не сделала из строки число.
Пример работы isNaN — true и false — JavaScript
Ещё важно учитывать, что один NaN всегда НЕ равен другому NaN, потому что по сути под любым NaN скрывается какое-то уникальное значение с типом данных Number. NaN всегда не равен NaN — JavaScript
NaN всегда не равен NaN — JavaScript
Index of an Array
Every element of an array has its index. We access any element of an array using its index.
Pictorial view of the above mentioned array is:
| element | 2 | 3 | 15 | 8 | 48 | 13 |
| index | 1 | 2 | 3 | 4 | 5 |
0, 1, 2, 3, 4 and 5 are indices. It is like they are identity of 6 different elements of an array. Index always starts from 0. So, the first element of an array has a index of 0.
Index of an array starts with 0.
We access any element of an array using its index and the syntax to do so is:
For example, if the name of an array is ‘n’, then to access the first element (which is at 0 index), we write .
Here,
n is 2
n is 3
n is 15
n is 8
n is 48
n is 13
, , etc. are like any other variables we were using till now i.e., we can set there value as like we do with any other variables (, , etc.).
Assigning Values to Array
By writing , we are declaring and assigning values to the array at the same time, thus initializing it.
But when we declare an array like , we need to assign values to it separately. Because ‘int n;’ will definitely allocate space of 3 integers in memory but there are no integers in that space.
To initialize it, assign a value to each of the elements of the array.
It is just like we are declaring some variables and then assigning values to them.
Thus, the first way of assigning values to the elements of an array is by doing so at the time of its declaration.
int n={ 2,4,8 };
And the second method is declaring the array first and then assigning values to its elements.
int n;
n = 2;
n = 4;
n = 8;
You can understand this by treating , and as similar to different variables you used before.
Just like variable, array can be of any other data type also.
Here, ‘f’ is an array of floats.
First, let’s see the example to calculate the average of the marks of 3 students. Here, represents the marks of the first student, represents marks of the second and represents marks of the third student.
#include <stdio.h>
int main()
{
int marks3];
float average;
printf("Enter marks of first student\n");
scanf(" %d" , &marks]);
printf("Enter marks of second student\n");
scanf(" %d" , &marks1]);
printf("Enter marks of third student\n");
scanf(" %d" , &marks2]);
average = (marks + marks1 + marks2]) 3.0;
printf ("Average marks : %f\n" , average);
return ;
}
Output
Enter marks of first student
23
Enter marks of second student
25
Enter marks of third student
30
Average marks : 26.000000
Here you just saw a working example of array, we treated elements of the array in an exactly similar way as we had treated normal variables. &marks, &marks and &marks represent the addresses of marks, marks and marks respectively.
In the above example, two points should be kept in mind.
The average value should be of type ‘float’ because the average of integers can be float also.
Secondly, while taking out the average, the sum of the numbers should be divided by 3.0 and not 3, otherwise you will get the average value as an integer and not float.
We can also use loop as done in the next example.
#include <stdio.h>
int main()
{
int n10]; /* declaring n as an array of 10 integers */
int i,j;
/* initializing elements of array n */
for (i = ; i<10; i++)
{
printf("Enter value of n",i);
scanf("%d",&ni]);
}
/* printing the values of elements of array */
for (j = ; j < 10; j++)
{
printf("n = %d\n", j, nj]);
}
return ;
}
Output
Enter value of n12
Enter value of n34
Enter value of n23
Enter value of n78
Enter value of n32
Enter value of n21
Enter value of n4
Enter value of n23
Enter value of n46
Enter value of n24
n = 12
n = 34
n = 23
n = 78
n = 32
n = 21
n = 4
n = 23
n = 46
n = 24
The above code was just to make you familiar with using loops with an array because you will be doing this many times later.
The code is simple, ‘i’ and ‘j’ start from 0 because the index of an array starts from 0 and goes up to 9 (for 10 elements). So, ‘i’ and ‘j’ goes up to 9 and not 10 ( i<10 and j<10 ). So, in the code will be n, n, …., n and things will go accordingly.
If we have declared an array with some array size and assigned values to only some elements of that array, then the values of other elements are automatically assigned zero.
Suppose we declare and initialize an array as
int n = { 12, 13, 5 };
This means that n=12, n=13 and n=5 and rest all elements are zero i.e. n=0 and n=0.
Similarly,
int n;
n = 12;
n = 13;
n = 5;
In the above code, n, n and n are initialized to 12, 13 and 5 respectively. Therefore, n and n are both 0.
Array allocates contiguous memory. Thus if the address of the first element of an array of integers is 223698688 then the address of the second element will be 223698692( 223698688+4 (4 is the size of one integer) ) and third will be 223698696 and so on. This means that the memories of all elements of an array are allocated together and are continuous.
indexOf
const alligator = ;
alligator.indexOf("rounded snout"); // будет возвращено 3
Как и , метод использует строгое сравнение, а не функцию, как мы это видели рассматривая особенности использования метода . Но, в отличие от метода , он возвращает индекс элемента, а не логическое значение. Также вы можете указать, с какого индекса в массиве начинать поиск.
Лично я считаю, что метод может оказаться весьма полезен. Он позволяет легко определить местоположение искомого элемент в массиве, а также проверить присутствует ли в нем элемент с указанным значением. Как же нам понять существует ли указанный элемент в массиве или нет? По сути, мы можем легко определить это, то есть в случае его наличия метод вернет положительное число, и если нет — то , что указывает на его отсутствие.
alligator.indexOf("soft and fluffy"); // вернет -1
alligator.indexOf(80); // вернет 1
alligator.indexOf(80, 2); // вернет -1
И, как вы можете видеть, хотя мы могли бы получить методы . или , чтобы предоставить нам ту же информацию, писать это намного меньше. Нам не нужно выписывать функцию для сравнения, так как она уже есть в методе .
Теперь мы знаем что, метод возвращает индекс первого элемента, соответствующего нашему критерию. Тем не менее JavaScript предоставляет нам альтернативный метод поиска элемента в массиве: . Как вы можете догадаться, он делает то же самое, что и метод , но начинает поиск с последнего элемента массива в обратном направлении. У этого метода вы также можете указать второй параметр, но помните, что порядок индексов массива остается прежним, не смотря на обратное направление его перебора.
const alligator = ; alligator.indexOf(80); // вернет 1 alligator.lastIndexOf(80); // вернет 4 alligator.indexOf(80, 2); // вернет 4 alligator.lastIndexOf(80, 4); // вернет 4 alligator.lastIndexOf(80, 3); // вернет 1
Манипуляции с формой
Как уже говорилось, у массива есть форма (shape), определяемая числом элементов вдоль каждой оси:
>>> a
array(,
],
,
]])
>>> a.shape
(2, 2, 3)
Форма массива может быть изменена с помощью различных команд:
>>> a.ravel() # Делает массив плоским
array()
>>> a.shape = (6, 2) # Изменение формы
>>> a
array(,
,
,
,
,
])
>>> a.transpose() # Транспонирование
array(,
])
>>> a.reshape((3, 4)) # Изменение формы
array(,
,
])
Порядок элементов в массиве в результате функции ravel() соответствует обычному «C-стилю», то есть, чем правее индекс, тем он «быстрее изменяется»: за элементом a следует a. Если одна форма массива была изменена на другую, массив переформировывается также в «C-стиле». Функции ravel() и reshape() также могут работать (при использовании дополнительного аргумента) в FORTRAN-стиле, в котором быстрее изменяется более левый индекс.
>>> a
array(,
,
,
,
,
])
>>> a.reshape((3, 4), order='F')
array(,
,
])
Метод reshape() возвращает ее аргумент с измененной формой, в то время как метод resize() изменяет сам массив:
>>> a.resize((2, 6))
>>> a
array(,
])
Если при операции такой перестройки один из аргументов задается как -1, то он автоматически рассчитывается в соответствии с остальными заданными:
Улучшение № 1 — попытка приведения строки к числу
Может оказаться так, что внутри массива будут строки, которые по факту хранят в себе только цифры и знак минус — (символизирует отрицательное число)
В этом случае нужно попытаться привести строку к числу, а потом сравнить является ли приведённое значение типом Number. Функция будет доработана.
Array.prototype.sum = function(){
var s = ;
for (i = ; i < this.length; i++){
s += Number(this)
}
return s
}
Результат работы:
Метод sum с приведением строки к числу — JavaScript
Альтернатива (нерабочее условие — можно не читать)
Array.prototype.sum = function(){
var s = ;
for (i = ; i < this.length; i++){
if ( Number(this) == NaN) {continue} // это условие бесполезно, читай ниже "почему?".
else { s += Number(this) }
}
return s
}
Результат работы:
Метод sum обучен переводить строки в числа — JavaScript
Использование методов Array.prototype.reduce() и Array.prototype.includes()
Здесь стратегия состоит в том, чтобы сохранить список уникальных элементов в нашей функции «аккумулятора» (unique). Для каждого элемента мы проверяем, включает ли аккумулятор рассматриваемый элемент.
- Если он содержит элемент, возвращает аккумулятор без внесения каких-либо изменений, фактически пропустив этот элемент.
- Если он не содержит элемент, распределяет значения в аккумуляторе в новый массив и добавляет рассматриваемый элемент.
возвращает логическое значение — если значение найдено в массиве, если нет. Данное логическое значение управляет нашим условием, определяя, что делать с каждым значением.
Я считаю этот подход менее интуитивным и трудным для чтения, но он работает работает хорошо.
Также обратите внимание, что пустой массив, который передается после функции, является начальным значением для аккумулятора, поэтому первый проход через , является пустым массивом
Собственный метод для объектов-прототипов Array
Ещё можно расширить набор методов для прототипов Array:
Array.prototype.sum = function(){
var s = ;
for (i = ; i < this.length; i++){
s += this
}
return s
}
Таким образом мы сможем вызывать наш собственный метод на любом массиве. Но нужно понимать, что в таком виде функция хорошо отрабатывает только тип данных — Number.
.sum() 111 // результат сложения значений элементов массива
.sum() 30 // результат суммирования значений элементов массива
Метод sum для прототипов Array — JavaScript
Если в такую функцию передать числа и строки, то получится плохой результат:
.sum()
Первые два числа в массиве сложатся и мы увидим 6, но как только появится строка, то оператор «+» начнёт конкатенировать все остальные элементы и превращать их в строковые значения. То есть символы начнут слипаться в одну строку. В этом случае результат НЕ будет числом, а это ошибка. Нужно дорабатывать алгоритм и ставить проверку типа данных.
Пример плохой работы функции сложения элементов массива — JavaScript
Using Arrays
- Elements of an array are accessed by specifying the index ( offset ) of the desired element within square brackets after the array name.
- Array subscripts must be of integer type. ( int, long int, char, etc. )
- VERY IMPORTANT: Array indices start at zero in C, and go to one less than the size of the array. For example, a five element array will have indices zero through four. This is because the index in C is actually an offset from the beginning of the array. ( The first element is at the beginning of the array, and hence has zero offset. )
- Landmine: The most common mistake when working with arrays in C is forgetting that indices start at zero and stop one less than the array size.
- Arrays are commonly used in conjunction with loops, in order to perform the same calculations on all ( or some part ) of the data items in the array.
find
Чем же метод отличается от ? Так если бы мы в нашем примере выше изменили название метода «include» на «find», то получили бы следующую ошибку:
Uncaught TypeError: thick scales is not a function
Это произошло потому, что метод требует передачи в качестве параметра функцию. Метод использует не просто оператор сравнения, он передает каждый элемент массива в функцию, передаваемую ему в качестве параметра, и проверяет, возвращает ли она значение или .
Таким образом, и хотя следующая инструкция будет работать корректно: , но вы, вероятно, захотите добавить в качестве функции-аргумента свой собственный оператор сравнения для того, чтобы он возвращал что-то нужное нам.
const alligator = ; alligator.find(el => el.length < 12); // вернет '4 foot tail'
Эта простая функция, передаваемая нашему методу , проверяет каждый элемент массива, доступный по присваиваемому псевдониму . Перебор элементов прекращается, когда находится первое совпадение. В нашем случае возвращается для такого элемента массива, у которого есть свойство , и его значение менее 12 (напомним, что числа не имеют свойства ). Конечно же, вы можете сделать эту функцию настолько сложной, насколько вам это необходимо, и возвращаемое ей значение соответствовало вашим требованиям.
Заметьте, что результат выполнения нашего кода, из примера выше, не возвращает , как это было ранее. Это происходит потому, что метод не возвращает логическое значение, а возвращает первый элемент, который соответствует критерию, определенному в функции. Если соответствующего элемента, который соответствует критериям, определенным в вашей функции, то метод вернет
Также обратите внимание, что он возвращает только первый элемент, соответствующий критерию. Таким образом если в массиве более одного элемента, соответствующего критерию в функции, то все равно будет возвращаться только первый, соответствующий критерию в функции
В нашем примере, если бы после элемента со значением , был другой со значением, в виде строки длиной менее 12 символов, то это ни как не изменило бы наш результат.
В нашем примере мы по сути использовали функцию обратного вызова, но только с одним параметром. При вызове метода вы можете использовать еще один параметр у функции: ссылку на индекс текущего элемента нашего массива. Еще одним параметром может быть ссылка на наш массив, но я нахожу, что его использование может пригодиться в очень редких случаях. Вот пример использования ссылки на индекс нашего обрабатываемого массива:
alligator.find((el, idx) => typeof el === "string" && idx === 2); // вернет '4 foot tall'
И так в нашем массиве три различных элемента, которые удовлетворяют условию (). Если бы это было наше единственное условие, то наш скрипт вернул бы первый элемент массива: . Но дело в том, что только у одного из элементов нашего массива индекс равен 2 и это элемент со значением .
Говоря об индексах элементов, схожим методом перебора элементов массива является . Этот метод тоже в качестве параметра принимает функцию, но, как вы уже можете догадаться, он возвращает индекс соответствующего ее критерию элемента, а не его значение.
Example
#include<iostream>
using namespace std;
void Combi(char a[], int reqLen, int s, int currLen, bool check[], int l)
{
if(currLen > reqLen)
return;
else if (currLen == reqLen) {
cout<<"\t";
for (int i = 0; i < l; i++) {
if (check == true) {
cout<<a<<" ";
}
}
cout<<"\n";
return;
}
if (s == l) {
return;
}
check = true;
Combi(a, reqLen, s + 1, currLen + 1, check, l);
check = false;
Combi(a, reqLen, s + 1, currLen, check, l);
}
int main() {
int i,n;
bool check;
cout<<"Enter the number of element array have: ";
cin>>n;
char a;
cout<<"\n";
for(i = 0; i < n; i++) {
cout<<"Enter "<<i+1<<" element: ";
cin>>a;
check = false;
}
for(i = 1; i <= n; i++) {
cout<<"\nThe all possible combination of length "<<i<<" for the given array set:\n";
Combi(a, i, 0, 0, check, n);
}
return 0;
}
Базовые операции
Математические операции над массивами выполняются поэлементно. Создается новый массив, который заполняется результатами действия оператора.
>>> import numpy as np >>> a = np.array() >>> b = np.arange(4) >>> a + b array() >>> a - b array() >>> a * b array() >>> a b # При делении на 0 возвращается inf (бесконечность) array() <string>:1: RuntimeWarning: divide by zero encountered in true_divide >>> a ** b array() >>> a % b # При взятии остатка от деления на 0 возвращается 0 <string>:1: RuntimeWarning: divide by zero encountered in remainder array()
Для этого, естественно, массивы должны быть одинаковых размеров.
>>> c = np.array(, 4, 5, 6]]) >>> d = np.array(, 3, 4], 5, 6]]) >>> c + d Traceback (most recent call last): File "<input>", line 1, in <module> ValueError: operands could not be broadcast together with shapes (2,3) (3,2)
Также можно производить математические операции между массивом и числом. В этом случае к каждому элементу прибавляется (или что вы там делаете) это число.
>>> a + 1 array() >>> a ** 3 array() >>> a < 35 # И фильтрацию можно проводить array(, dtype=bool)
NumPy также предоставляет множество математических операций для обработки массивов:
>>> np.cos(a) array() >>> np.arctan(a) array() >>> np.sinh(a) array()
Полный список можно посмотреть здесь.
Многие унарные операции, такие как, например, вычисление суммы всех элементов массива, представлены также и в виде методов класса ndarray.
>>> a = np.array(, 4, 5, 6]]) >>> np.sum(a) 21 >>> a.sum() 21 >>> a.min() 1 >>> a.max() 6
По умолчанию, эти операции применяются к массиву, как если бы он был списком чисел, независимо от его формы. Однако, указав параметр axis, можно применить операцию для указанной оси массива:
Копии и представления
При работе с массивами, их данные иногда необходимо копировать в другой массив, а иногда нет. Это часто является источником путаницы. Возможно 3 случая:
Вообще никаких копий
Простое присваивание не создает ни копии массива, ни копии его данных:
>>> a = np.arange(12) >>> b = a # Нового объекта создано не было >>> b is a # a и b это два имени для одного и того же объекта ndarray True >>> b.shape = (3,4) # изменит форму a >>> a.shape (3, 4)
Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий.
Представление или поверхностная копия
Разные объекты массивов могут использовать одни и те же данные. Метод view() создает новый объект массива, являющийся представлением тех же данных.
>>> c = a.view()
>>> c is a
False
>>> c.base is a # c это представление данных, принадлежащих a
True
>>> c.flags.owndata
False
>>>
>>> c.shape = (2,6) # форма а не поменяется
>>> a.shape
(3, 4)
>>> c,4 = 1234 # данные а изменятся
>>> a
array(,
,
])
Срез массива это представление:
>>> s = a = 10
>>> a
array(,
,
])
Глубокая копия
Метод copy() создаст настоящую копию массива и его данных:
>>> d = a.copy() # создается новый объект массива с новыми данными
>>> d is a
False
>>> d.base is a # d не имеет ничего общего с а
False
>>> d, = 9999
>>> a
array(,
,
])
Простой способ — Через итератор массивов
На массиве вызываем метод объекта-прототипа entries():
massiv.entries()
Итератор массива — JavaScript
В ответ нам прилетает прототип итератора массива.
Итератор массива — это объект, который представляет собой конкретную итерацию над некоторым конкретным объектом экземпляра массива. Для объектов Array Iterator не существует именованного конструктора. Вместо этого объекты итератора массива создаются путем вызова определенных методов объектов экземпляра массива.
Итератор массива имеет всего одно свойство — next().
Если сейчас мы передадим этот итератор массива в метод from() конструктора Array, то в ответ мы получим массив такой же длины, у которого элементами будут массивы с парами «ключ/значение». Причём ключ будет иметь числовой тип данных — это нам и нужно.
Array.from(massiv.entries())
Создание массива из итератора массива — JavaScript
Теперь нам нужно отфильтровать данный массив методом объекта-прототипа filter()
Array.from(massiv.entries()).filter(i => i == "as")
Фильтруем массив из итератора — JavaScript
Вытаскиваем ключи из вложенных массивов методом объектов-прототипов map()
Array.from(massiv.entries()).filter(i => i == "as").map(i => i[])
Извлечение индексов с одинаковыми элементами as — JavaScript
Задача решена. Список получен.
6 ответов
Лучший ответ
Вы можете использовать в сочетании с и оператор распространения {{X2} } в одну строку.
Map возвращает массив со всеми именами, которые идут в инициализатор набора, а затем все значения набора возвращаются в массив.
Для фильтрации и возврата только уникальных имен вы можете использовать с {{X1 } }.
30
Nina Scholz
7 Окт 2016 в 07:31
С кодом, который вы упомянули, вы можете попробовать:
Или вы можете иметь универсальную функцию, чтобы она работала и для других массивов объектов:
А затем просто используйте
1
Cezar Augusto
6 Окт 2016 в 18:28
Я просто подумал о 2 простых способах для пользователей Lodash
Учитывая этот массив:
1 . Найти дубликаты:
2 Найдите, есть ли дубликаты, для проверки:
3
Simon Dragsbæk
14 Фев 2019 в 10:23
Решение
Сохраните вхождения , внешние по отношению к циклу, в объекте и отфильтруйте их, если они были в прошлом.
Вы также можете обобщить это решение на функцию
И использовать его как
Объяснение
Не сравнивайте объекты, используя , который использует только оператор между объектами. Причина, по которой ваш текущий ответ не работает, заключается в том, что в JS не сравнивает объекты глубоко, а сравнивает ссылки. Что я имею в виду под этим, вы можете увидеть в следующем коде:
Равенство сообщит вам, нашли ли вы такой же точный объект, но не найдете ли вы объект с таким же содержимым.
В этом случае вы можете сравнить свой объект с , поскольку он должен быть уникальным ключом. Так что вместо . Более того, другая проблема с вашим кодом, который влияет на время его выполнения, а не на его функцию, заключается в том, что вы используете внутри своего . — это , что усложняет ваш алгоритм . Таким образом, лучше использовать объект, который имеет поиск.
14
m0meni
30 Янв 2018 в 14:47
Это будет работать нормально.
5
Divyanshu Rawat
13 Сен 2019 в 11:09
Я бы, наверное, создал какой-то объект. Поскольку вы сказали ECMAScript 6, у вас есть доступ к , но, поскольку вы хотите сравнивать значения ваших объектов, потребуется немного больше работы, чем это.
Пример может выглядеть примерно так (удаленный шаблон пространства имен для ясности):
Используйте это так:
Объяснение: вам нужно извлечь значение из каждого объекта по мере его добавления и решить, было ли оно уже добавлено, основываясь на полученном вами значении. Это требует получения значения, которое является функцией, которая предоставляет элемент, возвращает значение (). Затем вы добавляете только те элементы, значения которых еще не были видны.
Реализация класса:
Dave Cousineau
6 Окт 2016 в 02:06
Способ №1 — через конструктор Object
Для начала создадим массив средствами конструктора Object, а именно свойством entries().
Object.entries(massiv)
Аргументом функции был наш массив. Эта команда вернёт нам новый массив, в котором элементами будут пары-массивы «ключ/значение» начального массива. Давайте смотреть. Проще один раз увидеть как это будет выглядеть.
Новый массив где элементы — это пары ключ-значение — JavaScript
Object.entries(massiv).filter(i => i == "as")
Работа фильтра — JavaScript
Object.entries(massiv).filter(i => i == "as").map(i => i[])
Получение индексов в виде строк
Преобразовываем строки в числа
Object.entries(massiv).filter(i => i == "as").map(i => Number(i[]))
Преобразовываем строки в числа — JavaScript
Мы получили нужные индексы одинаковых значений в массиве.
