Перебрать массив в JavaScript - PullRequest
2802 голосов
/ 10 июня 2010

В Java вы можете использовать цикл for для обхода объектов в массиве следующим образом:

String[] myStringArray = {"Hello", "World"};
for (String s : myStringArray)
{
    // Do something
}

Можете ли вы сделать то же самое в JavaScript?

Ответы [ 39 ]

3462 голосов
/ 10 июня 2010

У вас есть несколько вариантов:

1. Последовательный for цикл:

var myStringArray = ["Hello","World"];
var arrayLength = myStringArray.length;
for (var i = 0; i < arrayLength; i++) {
    console.log(myStringArray[i]);
    //Do something
}

1012 * Pros *

  • Работает в любой среде
  • Вы можете использовать break и continue операторы управления потоком

Минусы

2. Array.prototype.forEach

Спецификация ES5. представил множество очень полезных методов массива, один из них, Array.prototype.forEach, и это дает нам очень короткий способ перебора массива:

const array = ["one", "two", "three"]
array.forEach(function (item, index) {
  console.log(item, index);
});

Прошло почти 9 лет с момента написания спецификации ES5. был выпущен (декабрь 2009 г.), он был реализован практически всеми современными движками в настольных, серверных и мобильных средах, поэтому их безопасно использовать.

А с помощью синтаксиса функции стрелки ES6 это еще более кратко:

array.forEach(item => console.log(item));

Функции со стрелками также широко применяются, если вы не планируете поддерживать очень старые платформы (например, IE11), вы также можете безопасно работать.

Плюсы

  • Очень коротко и лаконично.
  • декларативного

Против

  • Невозможно использовать break / continue

Обычно вы можете заменить необходимость break из обязательных циклов, отфильтровывая элементы массива перед их повторением, например:

array.filter(item => item.condition < 10)
     .forEach(item => console.log(item))

Имейте в виду, что если вы итерируете массив для создания другого массива из него , вам следует использовать map, я видел этот анти-шаблон много раз.

Анти-шаблон:

const numbers = [1,2,3,4,5], doubled = [];

numbers.forEach((n, i) => { doubled[i] = n * 2 });

Правильный вариант использования map :

const numbers = [1,2,3,4,5];
const doubled = numbers.map(n => n * 2);

console.log(doubled);

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

антипаттерн:

const numbers = [1,2,3,4,5];
const sum = 0;
numbers.forEach(num => { total += num });

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

const numbers = [1,2,3,4,5];
const sum = numbers.reduce((total, n) => total + n, 0);

console.log(sum);

3. ES6 for-of заявление

Стандарт ES6 вводит концепцию итерируемых объектов и определяет новую конструкцию для обхода данных, оператор for...of.

Этот оператор работает для любого итеративного объекта, а также для генераторов.

Объекты массива по определению являются встроенными итераторами в ES6, поэтому вы можете использовать для них следующий оператор:

let colors = ['red', 'green', 'blue'];
for (const color of colors){
  console.log(color);
}

Плюсы

  • Может выполнять итерацию по большому количеству объектов.
  • Может использовать обычные операторы управления потоком (break / continue).
  • Полезно для последовательной итерации асинхронных значений.

Против

Не использовать for...in

@ zipcodeman предлагает использовать оператор for...in, но для итерации массивов for-in следует избегать, этот оператор предназначен для перечисления свойств объекта.

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

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

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

Например:

Array.prototype.foo = "foo!";
    var array = ['a', 'b', 'c'];
    
    for (var i in array) {
      console.log(array[i]);
    }

Приведенный выше код будет утешать "a", "b", "c" и "foo!".

Это будет особенно проблематично, если вы используете какую-то библиотеку, которая сильно зависит от расширения собственных прототипов (например, MooTools).

Оператор for-in, как я уже говорил, предназначен для перечисления свойств объекта, например:

var obj = {
      "a": 1,
      "b": 2,
      "c": 3
    };

    for (var prop in obj) {
      if (obj.hasOwnProperty(prop)) { 
      // or if (Object.prototype.hasOwnProperty.call(obj,prop)) for safety...
        console.log("prop: " + prop + " value: " + obj[prop])
      }
    }

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

Я бы порекомендовал вам прочитать следующую статью:

1061 голосов
/ 16 апреля 2012

Да, при условии, что ваша реализация включает в себя функцию for ... of, представленную в ECMAScript 2015 (выпуск "Гармония") ... который довольно хорошбезопасное предположение в наши дни.

Работает так:

// REQUIRES ECMASCRIPT 2015+
var s, myStringArray = ["Hello", "World"];
for (s of myStringArray) {
  // ... do something with s ...
}

Или еще лучше, поскольку ECMAScript 2015 также предоставляет переменные в блоке через let и const:

// REQUIRES ECMASCRIPT 2015+
const myStringArray = ["Hello", "World"];
for (const s of myStringArray) {
  // ... do something with s ...
}
// s is no longer defined here

Примечание к разреженным массивам: массив в JavaScript может на самом деле не хранить столько элементов, сколько указано в его length;это сообщаемое число просто на единицу больше, чем самый высокий индекс, при котором хранится значение.Если массив содержит меньше элементов, чем указано его длиной, он называется sparse .Например, вполне допустимо иметь массив с элементами только по индексам 3, 12 и 247;length такого массива сообщается как 248, хотя на самом деле он хранит только 3 значения.Если вы попытаетесь получить доступ к элементу по любому другому индексу, у массива появится значение undefined.Поэтому, когда вы хотите «пройтись» по массиву, у вас возникает вопрос: хотите ли вы пройтись по всему диапазону, указанному его длиной и обработать undefined s для любых отсутствующих элементов, или вы хотите обрабатывать толькоэлементы действительно присутствуют?Существует множество приложений для обоих подходов;это зависит только от того, для чего вы используете массив.

Если вы перебираете массив с for .. of, тело цикла выполняется length раз, и циклУправляющая переменная установлена ​​на undefined для любых элементов, фактически не представленных в массиве.В зависимости от деталей вашего кода «сделай что-нибудь», такое поведение может быть тем, что вы хотите, но если это не то, что вам нужно, вы должны использовать другой подход.

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

Пока ваша реализация JavaScript совместимас предыдущей редакцией спецификации ECMAScript (которая исключает, например, версии Internet Explorer до 9), вы можете использовать метод итератора Array#forEach вместо цикла,В этом случае вы передаете функцию, которая будет вызываться для каждого элемента в массиве:

var myStringArray = [ "Hello", "World" ];
myStringArray.forEach( function(s) { 
     // ... do something with s ...
} );

В отличие от for ... of, .forEach вызывает функцию только для элементов, которые на самом деле содержатценности.Если передать наш гипотетический массив с тремя элементами и длиной 248, он будет вызывать функцию только три раза, а не 248 раз.Он также различает отсутствующие элементы и элементы, которые фактически установлены на undefined;для последнего он по-прежнему будет вызывать функцию, передавая undefined в качестве аргумента.Если именно так вы хотите обрабатывать разреженные массивы, .forEach может быть подходящим вариантом, даже если ваш интерпретатор поддерживает for ... of.

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

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  s = myStringArray[i];
  // ... do something with s ...
}

Одним из преимуществ этого подхода является то, что вы можете выбрать способ обработки разреженных массивов;Приведенный выше код будет выполнять тело цикла полностью length раз, с s, установленным на undefined для любых отсутствующих элементов, точно так же как for .. of.Если вместо этого вы хотите обрабатывать только реально существующие элементы разреженного массива, например .forEach, вы можете добавить простой in тест для индекса:

var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length;
for (i=0; i<len; ++i) {
  if (i in myStringArray) {
    s = myStringArray[i];
    // ... do something with s ...
  }
}

Назначение значения длины длялокальная переменная (в отличие от включения полного выражения myStringArray.length в условие цикла) может существенно повлиять на производительность, поскольку каждый раз пропускает поиск свойства;при использовании Rhino на моей машине ускорение составляет 43%.

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

var i, len, myStringArray = [ "Hello", "World" ];
for (len = myStringArray.length, i=0; i<len; ++i) {

Синтаксис for ... in, упомянутый другими, предназначен для зацикливания свойств объекта; так как Array в JavaScript - это просто объект с числовыми именами свойств (и автоматически обновляемым свойством length), вы можете теоретически зациклить Array с ним. Но проблема заключается в том, что он не ограничивается числовыми значениями свойств (помните, что даже методы на самом деле являются просто свойствами, значение которых является замыканием), и при этом не гарантируется, что они будут повторяться в числовом порядке. Поэтому синтаксис for ... in должен , а не использоваться для циклического перемещения по массивам.

427 голосов
/ 10 июня 2010

Вы можете использовать map, метод функционального программирования, который также доступен на других языках, таких как Python и Haskell .

[1,2,3,4].map( function(item) {
     alert(item);
})

Общеесинтаксис:

array.map(func)

В общем случае func будет принимать один параметр, который является элементом массива.Но в случае JavaScript он может принимать второй параметр, который является индексом элемента, и третий параметр, который является самим массивом.

Возвращаемое значение array.map - это другой массив, так что вы можете использоватьэто выглядит так:

var x = [1,2,3,4].map( function(item) {return item * 10;});

А теперь x равно [10,20,30,40].

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

var item_processor = function(item) {
      // Do something complicated to an item
}

new_list = my_list.map(item_processor);

, которая будет примерно эквивалентна:

 for (item in my_list) {item_processor(item);}

За исключением того, что вы не получите new_list.

111 голосов
/ 07 декабря 2010

В JavaScript не рекомендуется циклически проходить по массиву с циклом for-in, но лучше использовать цикл for, например:

for(var i=0, len=myArray.length; i < len; i++){}

Это также оптимизировано ("кэширование" длины массива). Если вы хотите узнать больше, прочитайте мой пост на эту тему .

105 голосов
/ 11 августа 2013

для (переменная myStringArray) {

(Непосредственно отвечая на ваш вопрос: теперь вы можете!)

Большинство других ответов верны, но они не упоминают (на момент написания статьи), что ECMA Script 6 2015 приносит новый механизм для выполнения итерация, цикл for..of.

Этот новый синтаксис является наиболее элегантным способом итерации массива в javascript (если вам не нужен индекс итерации), но он пока еще широко не поддерживается браузерами.

В настоящее время он работает с Firefox 13+, Chrome 37+ и изначально не работает с другими браузерами (см. Совместимость браузера ниже). К счастью, у нас есть JS-компиляторы (такие как Babel ), которые позволяют нам сегодня использовать функции следующего поколения.

Он также работает на узле (я тестировал его на версии 0.12.0).

Итерация массива

// You could also use "let" instead of "var" for block scope.
for (var letter of ["a", "b", "c"]) { 
   console.log(letter); 
}

Итерация массива объектов

var band = [
  {firstName : 'John', lastName: 'Lennon'}, 
  {firstName : 'Paul', lastName: 'McCartney'}
];

for(var member of band){
  console.log(member.firstName + ' ' + member.lastName); 
}

Итерация генератора:

(пример извлечен из https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of)

function* fibonacci() { // a generator function
  let [prev, curr] = [1, 1];
  while (true) {
    [prev, curr] = [curr, prev + curr];
    yield curr;
  }
}

for (let n of fibonacci()) {
  console.log(n);
  // truncate the sequence at 1000
  if (n >= 1000) {
    break;
  }
}

Таблица совместимости: http://kangax.github.io/es5-compat-table/es6/#For..of петли

Спецификация: http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}

87 голосов
/ 10 июня 2010

Opera, Safari, Firefox и Chrome теперь все совместно используют набор улучшенных методов Array для оптимизации многих общих циклов.

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

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

filter returnмассив элементов, которые удовлетворяют некоторому условию или тесту.

каждые возвращает значение true, если каждый член массива проходит тест.

некоторые возвращает значение true, еслипри любом прохождении теста.

forEach запускает функцию для каждого элемента массива и ничего не возвращает.

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

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

Игнорируйте ее, пока она вам не понадобится.

indexOf и lastIndexOf найдите соответствующую позицию первого или последнего элементаэто точно соответствует его аргументу.

(function(){
    var p, ap= Array.prototype, p2={
        filter: function(fun, scope){
            var L= this.length, A= [], i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        val= this[i];
                        if(fun.call(scope, val, i, this)){
                            A[A.length]= val;
                        }
                    }
                    ++i;
                }
            }
            return A;
        },
        every: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && !fun.call(scope, this[i], i, this))
                        return false;
                    ++i;
                }
                return true;
            }
            return null;
        },
        forEach: function(fun, scope){
            var L= this.length, i= 0;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
            }
            return this;
        },
        indexOf: function(what, i){
            i= i || 0;
            var L= this.length;
            while(i< L){
                if(this[i]=== what)
                    return i;
                ++i;
            }
            return -1;
        },
        lastIndexOf: function(what, i){
            var L= this.length;
            i= i || L-1;
            if(isNaN(i) || i>= L)
                i= L-1;
            else
                if(i< 0) i += L;
            while(i> -1){
                if(this[i]=== what)
                    return i;
                --i;
            }
            return -1;
        },
        map: function(fun, scope){
            var L= this.length, A= Array(this.length), i= 0, val;
            if(typeof fun== 'function'){
                while(i< L){
                    if(i in this){
                        A[i]= fun.call(scope, this[i], i, this);
                    }
                    ++i;
                }
                return A;
            }
        },
        some: function(fun, scope){
            var i= 0, L= this.length;
            if(typeof fun== 'function'){
                while(i<L){
                    if(i in this && fun.call(scope, this[i], i, this))
                        return true;
                    ++i;
                }
                return false;
            }
        }
    }
    for(p in p2){
        if(!ap[p])
            ap[p]= p2[p];
    }
    return true;
})();
63 голосов
/ 05 января 2012

Используйте цикл while ...

var i=0, item, items = ['one','two','three'];
while(item = items[i++]){
    console.log(item);
}

Журналы: «один», «два», «три»

А для обратного порядка - еще более эффективный цикл

var items = ['one','two','three'], i = items.length;
while(i--){
    console.log(items[i]);
}

журналы: «три», «два», «один»

или классические for петля

var items = ['one','two','three']
for(var i=0, l = items.length; i < l; i++){
    console.log(items[i]);
}

журналы: «один», 'два ',' три '

Ссылка: http://www.sitepoint.com/google-closure-how-not-to-write-javascript/

55 голосов
/ 29 февраля 2016

Введение

С тех пор, как я учился в колледже, я программировал на Java, JavaScript, Pascal, ABAP , PHP, Progress 4GL, C / C ++ и, возможно, на нескольких других языках, о которых я сейчас не могу думать. .

Хотя все они имеют свои собственные лингвистические особенности, каждый из этих языков имеет много общих базовых понятий. К таким понятиям относятся процедуры / функции, IF -условия, FOR -циклы и WHILE -циклы.


Традиционный for -петл

Традиционный цикл for состоит из трех компонентов:

  1. Инициализация: , выполненная до первого выполнения блока просмотра
  2. Условие: проверяет условие каждый раз перед выполнением блока цикла и выходит из цикла, если ложно
  3. Запоздалая мысль: выполняется каждый раз после выполнения цикла цикла

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

for (;;) {
    // Do stuff
}

Конечно, вам нужно будет включить if(condition === true) { break; } или if(condition === true) { return; } где-нибудь внутри этого for -петля, чтобы он прекратил работать.

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

for (var i = 0, length = 10; i < length; i++) {
    console.log(i);
}

Использование традиционного цикла for для обхода массива

Традиционный способ перебрать массив:

for (var i = 0, length = myArray.length; i < length; i++) {
    console.log(myArray[i]);
}

Или, если вы предпочитаете цикл в обратном направлении, вы делаете это:

for (var i = myArray.length - 1; i > -1; i--) {
    console.log(myArray[i]);
}

Однако возможны многие варианты, например, такие:

for (var key = 0, value = myArray[key], length = myArray.length; key < length; value = myArray[++key]) {
    console.log(value);
}

... или этот ...

var i = 0, length = myArray.length;
for (; i < length;) {
    console.log(myArray[i]);
    i++;
}

... или этот:

var key = 0, value;
for (; value = myArray[key++];){
    console.log(value);
}

То, что лучше всего работает, в значительной степени зависит как от личного вкуса, так и от конкретного варианта использования, который вы реализуете.

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


A while loop

Одной альтернативой циклу for является цикл while. Чтобы перебрать массив, вы можете сделать это:

var key = 0;
while(value = myArray[key++]){
    console.log(value);
}

Как и традиционные for петли, while петли поддерживаются даже в самых старых браузерах.

Также обратите внимание, что каждый цикл while можно переписать как цикл for. Например, цикл while, описанный выше, ведет себя точно так же, как этот for -loop:

for(var key = 0; value = myArray[key++];){
    console.log(value);
}

For...in и for...of

В JavaScript вы также можете сделать это:

for (i in myArray) {
    console.log(myArray[i]);
}

Это следует использовать с осторожностью, однако, поскольку оно не ведет себя так же, как традиционный цикл for во всех случаях, и существуют потенциальные побочные эффекты, которые необходимо учитывать. См. Почему использование «for ... in» с итерацией массива - плохая идея? для получения более подробной информации.

В качестве альтернативы for...in, теперь есть и для for...of. В следующем примере показана разница между циклом for...of и циклом for...in:

var myArray = [3, 5, 7];
myArray.foo = "hello";

for (var i in myArray) {
  console.log(i); // logs 0, 1, 2, "foo"
}

for (var i of myArray) {
  console.log(i); // logs 3, 5, 7
}

Кроме того, необходимо учитывать, что ни одна версия Internet Explorer не поддерживает for...of ( Edge 12 + поддерживает) и что для for...in требуется как минимум Internet Explorer 10.


Array.prototype.forEach()

Альтернативой for -loops является Array.prototype.forEach(), в котором используется следующий синтаксис:

myArray.forEach(function(value, key, myArray) {
    console.log(value);
});

Array.prototype.forEach() поддерживается всеми современными браузерами, а также Internet Explorer 9 и более поздними версиями.


Библиотека

Наконец, многие служебные библиотеки также имеют свои собственные варианты foreach. AFAIK, три самых популярных из них:

jQuery.each(), в JQuery :

$.each(myArray, function(key, value) {
    console.log(value);
});

_.each(), в Underscore.js :

_.each(myArray, function(value, key, myArray) {
    console.log(value);
});

_.forEach(), в Lodash.js :

_.forEach(myArray, function(value, key) {
    console.log(value);
});
37 голосов
/ 04 июня 2012

Если вы хотите краткий способ написания быстрого цикла и , вы можете выполнить итерацию в обратном порядке:

for (var i=myArray.length;i--;){
  var item=myArray[i];
}

Преимущество заключается в кэшировании длины (аналогично for (var i=0, len=myArray.length; i<len; ++i)и в отличие от for (var i=0; i<myArray.length; ++i)) при наборе меньшего количества символов.

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

29 голосов
/ 23 февраля 2018

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

1.Просто переберите массив

const myArray = [{x:100}, {x:200}, {x:300}];

myArray.forEach((element, index, array) => {
    console.log(element.x); // 100, 200, 300
    console.log(index); // 0, 1, 2
    console.log(array); // same myArray object 3 times
});

Примечание: Array.prototype.forEach (), строго говоря, не является функциональным способом, так как функция, которую он принимает в качестве входного параметра, не должна возвращать значение, чтоне может рассматриваться как чистая функция.

2.Проверьте, проходит ли какой-либо из элементов массива тест

const people = [
    {name: 'John', age: 23}, 
    {name: 'Andrew', age: 3}, 
    {name: 'Peter', age: 8}, 
    {name: 'Hanna', age: 14}, 
    {name: 'Adam', age: 37}];

const anyAdult = people.some(person => person.age >= 18);
console.log(anyAdult); // true

3.Преобразование в новый массив

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => element.x);
console.log(newArray); // [100, 200, 300]

Примечание. Метод map () создает новый массив с результатами вызова предоставленной функции для каждого элемента в вызывающем массиве.

4.Подведите итог определенного свойства и рассчитайте его среднее значение

const myArray = [{x:100}, {x:200}, {x:300}];

const sum = myArray.map(element => element.x).reduce((a, b) => a + b, 0);
console.log(sum); // 600 = 0 + 100 + 200 + 300

const average = sum / myArray.length;
console.log(average); // 200

5.Создайте новый массив на основе оригинала, но не изменяя его

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray= myArray.map(element => {
    return {
        ...element,
        x: element.x * 2
    };
});

console.log(myArray); // [100, 200, 300]
console.log(newArray); // [200, 400, 600]

6.Подсчитайте количество каждой категории

const people = [
    {name: 'John', group: 'A'}, 
    {name: 'Andrew', group: 'C'}, 
    {name: 'Peter', group: 'A'}, 
    {name: 'James', group: 'B'}, 
    {name: 'Hanna', group: 'A'}, 
    {name: 'Adam', group: 'B'}];

const groupInfo = people.reduce((groups, person) => {
    const {A = 0, B = 0, C = 0} = groups;
    if (person.group === 'A') {
        return {...groups, A: A + 1};
    } else if (person.group === 'B') {
        return {...groups, B: B + 1};
    } else {
        return {...groups, C: C + 1};
    }
}, {});

console.log(groupInfo); // {A: 3, C: 1, B: 2}

7.Извлечь подмножество массива на основе определенных критериев

const myArray = [{x:100}, {x:200}, {x:300}];

const newArray = myArray.filter(element => element.x > 250);
console.log(newArray); // [{x:300}] 

Примечание. Метод filter () создает новый массив со всеми элементами, которые проходят тест, реализованный с помощью предоставленной функции.

8,Сортировать массив

const people = [
  { name: "John", age: 21 },
  { name: "Peter", age: 31 },
  { name: "Andrew", age: 29 },
  { name: "Thomas", age: 25 }
];

let sortByAge = people.sort(function (p1, p2) {
  return p1.age - p2.age;
});

console.log(sortByAge);

enter image description here

9.Найти элемент в массиве

const people = [ {name: "john", age:23},
                {name: "john", age:43},
                {name: "jim", age:101},
                {name: "bob", age:67} ];

const john = people.find(person => person.name === 'john');
console.log(john);

enter image description here

Метод Array.prototype.find () возвращает значение первого элемента в массиве, которыйудовлетворяет предоставленной функции тестирования.

Ссылки

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...