Как найти предпоследний элемент массива - Исправление недочетов и поиск решений вместе с Examum.ru

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

const arr  = [1, 2, 3, 4, 5, 6, 7];
// получаем индекс предпоследнего элемента в массиве
// это длина массива минус два,
// так как индексация элементов в массиве начинается с нуля
const index = arr.length - 2;
// получаем значение предпоследнего элемента
arr[index]; // 6

Также при использовании node.js версии 16 и выше можно воспользоваться встроенным методом at() указав смещение индекса относительно конца. В предыдущем примере видно, что смещение индекса будет равно -2. Пример будет выглядеть так:

const arr  = [1, 2, 3, 4, 5, 6, 7];
// получаем значение предпоследнего элемента используя смещение -2
arr.at(-2); // 6
// или использовать значение индекса по аналогии с предыдущим примером
const index = arr.length - 2;
arr.at(index); // 6

Источник

How can I get the last second item in an array?

For instance,

var fragment = '/news/article-1/'
var array_fragment = fragment.split('/');
var pg_url = $(array_fragment).last()[0];

This returns an empty value. But I want to get article-1

Thanks.

asked Jun 27, 2011 at 21:13

Not everything has to be done using jQuery.

In plain old javascript you can do:

var pg_url = array_fragment[array_fragment.length - 2]

Easier and faster

answered Jun 27, 2011 at 21:15

Pablo FernandezPablo Fernandez

103k56 gold badges192 silver badges231 bronze badges

Looks like you can also use Javascript’s slice method:

var path = 'a/b/c/d';
path.split('/').slice(-2, -1)[0]; // c

You can also think of «second to last element in the array» as «second element of the array reversed»:

var path = 'a/b/c/d';
path.split('/').reverse()[1]; // c

answered Jun 20, 2014 at 16:02

JJ GeewaxJJ Geewax

10.3k1 gold badge37 silver badges48 bronze badges

Step 1: Use split() Method to split the elements into an array.

var fragment_arr = fragment.split("/");

Step 2: Use slice(-2) Method to select last 2 element from array, the negative number to select from the end of an array.

var lastTwo = fragment_arr.slice(-2);

Step 3: lastTwo array contains last two elements of fragment_arr, now you can access like this

var element = lastTwo[0];
alert(element);

Short answer : you can combine step 2 and 3 like below

var element = fragment_arr.slice(-2)[0];
alert(element);

answered Feb 12, 2016 at 5:59

151291151291

3,2987 gold badges47 silver badges80 bronze badges

arr.at(-2); will do exaclty that — it returns last second item in an array.

const arr = [1,2,3,4];
arr.at(-2); // Returns 3

The at() method takes a positive or negative integer and returns the item at that index. Negative integers count back from the last item in the array.

It is fully supported by browsers.

Docs: Array/at

answered Mar 21, 2021 at 17:15

t_dom93t_dom93

9,8981 gold badge51 silver badges37 bronze badges

This can be covered by lodash _.nth:

var fragment = '/news/article-1/'
var array_fragment = _.split(fragment, '/');
var second_last = _.nth(array_fragment, -2);
console.log(second_last);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

answered Nov 22, 2018 at 6:49

Penny LiuPenny Liu

14.8k5 gold badges78 silver badges93 bronze badges

var pg_url = array_fragment[array_fragment.length -2]

array_fragment isn’t a jquery variable, it’s a plain old javascript variable so no need for $()

answered Jun 27, 2011 at 21:16

davedave

12.3k10 gold badges42 silver badges58 bronze badges

This question is old but still relevant. Slice with length-1 is the best bet, but as an alternative with underscore/lodash:

_.initial() gets all but the last

_.last() gets the last

So you could do

_.last(_.initial([1,2,3,4]))

or chained:

_.chain([1,2,3,4])
 .initial()
 .last()
 .value();

which gives you back 3.

Or in the original question:

var fragment = '/news/article-1/'
var array_fragment = fragment.split('/');
var pg_url = _.chain(array_fragment).initial().last().value();

answered Jun 14, 2018 at 20:44

If accessing arrays in reverse is something that is going to be often required, and not just the second to last index, a simple expansion to the prototype could be used.

When extending something as large and used as the Array prototype ensure that you are not going to affect any other part of its use. This is done by making sure that the property is not enumerable so that for in will not choke anywhere else (some people and libraries use for in to iterate arrays).

Object.defineProperty(Array.prototype, 'rev', {
  enumerable: false,
  value: function(index){
    return this[this.length - 1 - index];
  }
});

document.write([1,2,3,4,5,6].rev(1));

And now you can use zero based indexing in reverse.

answered Oct 12, 2015 at 21:27

Travis JTravis J

80.8k41 gold badges202 silver badges272 bronze badges

var a = [1,2,3,4];
var b = a.slice(-2,-1);
console.log(b);

The answer is [3].You just have to mention the start and end for slice.

answered May 4, 2020 at 6:43

IpsitaIpsita

1112 silver badges5 bronze badges

The following works for a string with nth ‘url’ parts.

var fragment = '/t/e/s/t/i/n/g/';
var fragment = '/t/';

If the fragment is of variable length, you need a solution that works for various fragment sizes.

var fragment = '/news/article-1/';
var array_fragment = fragment.split('/');

Split separates the fragment string where it finds ‘/’s. Split takes the value before and after the split character. In this case there is nothing before the first slash or after the last slash. The empty values are added to the array_fragment in the first and last array positions.

jQuery
var pg_url = $(array_fragment)[$(array_fragment).length - 2];

javascript
var pg_url = array_fragment[array_fragment.length - 2];

As you can see, jQuery is not needed for this solution.

Array_fragment.length — 2 is counting the length of the array_fragment, and selecting the second item from the end. The last value is «» due to Split(‘/’) adding an empty value to the end of the array_fragment array.

Simplified and all put together:

var f = '/t/e/s/t/i/n/g/'.split('/');
f[f.length - 2]

answered Nov 28, 2017 at 15:47

mbunchmbunch

5507 silver badges21 bronze badges

const myArray: Array<string> = ['first', 'second', 'third'];

Split myArray by second last item.

const twoItemsFromEnd = myArray.slice(-2); //Outputs: ['second', 'third']

Then

const secondLast = twoItemsFromEnd[0];

Or:

const secondLast = (params.slice(-2))[0];

answered Jan 8, 2018 at 9:51

Источник

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

В этой статье мы разберем 15 встроенных методов объекта Array.prototype:

forEach()
find()
findIndex()
some()
every()
includes()
reverse()
map()
filter()
reduce()
sort()
concat()
fill()
flat()
flatMap()

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

// вместо такого кода
myAwesomeArray.some(test => {
  if (test === "d") {
    return test
  }
})

// мы будем использовать такой
myAwesomeArray.some(test => test === "d")

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

forEach()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: undefined

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

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
]

myAwesomeArray.forEach(element => console.log(element.name))
// john
// Ali
// Mass

find()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: первый подходящий элемент массива или undefined

Функции-коллбэк должна вернуть true, если элемент соответствует определенным критериями, или false, если не соответствует. Если вернулся результат true, итерация прекращается. Результатом работы метода становится найденный элемент.

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
]

myAwesomeArray.find(element => element.id === 3) // {id: 3, name: "Mass"}
myAwesomeArray.find(element => element.id === 7) // undefined

findIndex()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: индекс первого подходящего элемента массива или -1

Работает аналогично методу find, но возвращает не сам элемент, а его индекс в исходном массиве.

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
]

myAwesomeArray.findIndex(element => element.id === 3) // 2
myAwesomeArray.findIndex(element => element.id === 7) // -1

some()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: true или false

Этот метод используется, чтобы найти в массиве хотя бы один элемент, который соответствует определенному условию. Если функция-коллбэк вернет true, то итерация по элементам остановится и весь метод вернет true. Если для всех элементов вернулось false, то весь метод вернет false.

const myAwesomeArray = ["a", "b", "c", "d", "e"]
myAwesomeArray.some(test => test === "d") // true

every()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: true или false

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

const myAwesomeArray = ["a", "b", "c", "d", "e"]
myAwesomeArray.every(test => test === "d") // false

const myAwesomeArray2 = ["a", "a", "a", "a", "a"]
myAwesomeArray2.every(test => test === "a") // true

includes()

Параметры метода: значение для сравнения, индекс, с которого нужно начинать поиск (необязательный, по умолчанию — 0)

Результат: true или false

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

const myAwesomeArray = [1, 2, 3, 4, 5]

myAwesomeArray.includes(3) // true
myAwesomeArray.includes(8) // false
myAwesomeArray.includes('3') // false

reverse()

Результат: «перевернутый массив»

Мутация исходного массива: да, «переворот» массива происходит «на месте», без создания копии

Метод обращает порядок следования элементов массива — «переворачивает» его. Последний элемент становится первый, предпоследний — вторым и т. д.

const myAwesomeArray = ["e", "d", "c", "b", "a"]
myAwesomeArray.reverse() // ['a', 'b', 'c', 'd', 'e']

map()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

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

Мутация исходного массива: нет

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

const myAwesomeArray = [5, 4, 3, 2, 1]
myAwesomeArray.map(x => x * x) // [25, 16, 9, 4, 1]

filter()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: новый массив, состоящий только отобранных элементов исходного

Мутация исходного массива: нет

Функция-коллбэк должна «фильтровать» элементы исходного массива, возвращая для них true (элемент удовлетворяет условию и должен быть в результирующем массиве) или false (элемент не удовлетворяет условию).

const myAwesomeArray = [
  { id: 1, name: "john" },
  { id: 2, name: "Ali" },
  { id: 3, name: "Mass" },
  { id: 4, name: "Mass" },
]

myAwesomeArray.filter(element => element.name === "Mass")
// [ {id: 3, name: "Mass"}, {id: 4, name: "Mass"} ]

reduce()

Параметры метода: функция-коллбэк, начальное значение аккумулятора

Параметры функции-коллбэка: текущее накопленное значение, текущий элемент массива, его индекс в исходном массиве, сам массив

Результат: «накопленное значение» аккумулятора

Коллбэк этого метода при итерации по массиву получает не только текущий элемент, но и «накопленное значение» — accumulator. Функция может изменять его в зависимости от значения элемента и обязательно должна вернуть новое «накопленное значение». Результатом работы всего метода является именно аккумулятор, измененный во всех коллбэках.

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

const myAwesomeArray = [1, 2, 3, 4, 5]

myAwesomeArray.reduce((accumulator, value) => accumulator * value)
// 1 * 2 * 3 * 4 * 5 = 120

sort()

Параметры метода: функция-компаратор для сравнения двух значений

Результат: отсортированный массив

Мутация исходного массива: да, сортировка происходит «на месте» без создания копии массива

Функция-компаратор получает элементы исходного массива попарно (порядок сравнения зависит от используемого алгоритма сортировки). Если первый элемент условно «меньше» второго, то есть должен идти в отсортированном массиве перед ним, компаратор должен вернуть любое отрицательное число. Если первый элемент «больше» второго, то нужно вернуть положительное число. Если же элементы условно «равны», то есть их порядок в отсортированном массиве не важен, функция должна вернуть 0.

const myAwesomeArray = [5, 4, 3, 2, 1]

// Сортировка по возрастанию
myAwesomeArray.sort((a, b) => a - b) // [1, 2, 3, 4, 5]

// Сортировка по убыванию
myAwesomeArray.sort((a, b) => b - a) // [5, 4, 3, 2, 1]

concat()

Параметры метода: массивы для объединения с исходным (количество параметров не ограничено)

Результат: новый массив, состоящий из элементов всех полученных массивов

Мутация исходного массива: нет

Метод просто объединяет несколько массивов в один

const myAwesomeArray = [1, 2, 3, 4, 5]
const myAwesomeArray2 = [10, 20, 30, 40, 50]

myAwesomeArray.concat(myAwesomeArray2) // [1, 2, 3, 4, 5, 10, 20, 30, 40, 50]

fill()

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

Результат: Массив с измененными значениями.

Мутация исходного массива: да

Этот метод заменяет текущие элементы массива на указанное значение — «заполняет» массив указанным значением.

const myAwesomeArray = [1, 2, 3, 4, 5]

// Первый аргумент (0) - само значение для заполнения
// Второй аргумент (1) - индекс элемента, с которого нужно начать замену
// Третий аргумент (3) - индекс элемента, на котором нужно закончить замену
myAwesomeArray.fill(0, 1, 3) // [1, 0, 0, 4, 5]

flat()

Параметры метода: глубина разворачивания (по умолчанию 1)

Результат: новый массив, состоящий из элементов развернутых подмассивов

Мутация исходного массива: нет

Если в вашем исходном массиве есть вложенные массивы, то этот метод «развернет» их, уменьшив «мерность».

const myAwesomeArray = [[1, 2], [3, 4], 5]
myAwesomeArray.flat() // [1, 2, 3, 4, 5]

const myAwesomeArray2 = [[[1, 2], [3, 4]], 5]
myAwesomeArray2.flat(2) // [1, 2, 3, 4, 5]

flatMap()

Параметры метода: функция-коллбэк, значение this для коллбэка (необязательный)

Параметры функции-коллбэка: текущий элемент массива, его индекс в исходном массиве, сам массив

Комбинация методов flat() и map(). При этом сначала отрабатывает map — к каждому элементу применяется функция-коллбэк, которая должна вернуть его модифицированную версию. После этого отрабатывает flat с глубиной 1- мерность массива уменьшается.

const myAwesomeArray = [[1], [2], [3], [4], [5]]
myAwesomeArray.flatMap(arr => arr * 10) // [10, 20, 30, 40, 50]

// то же самое с flat() + map()
myAwesomeArray.map(arr => arr * 10).flat() // [10, 20, 30, 40, 50]

Больше информации о массивах:

Работа с массивами в JavaScript

Источник

0 / 0 / 0

Регистрация: 13.02.2014

Сообщений: 31

Вывести номер предпоследнего положительного элемента одномерного массива

03.03.2014, 15:35. Показов 2731. Ответов 1

Есть одномерный массив. Вывести номер предпоследнего положительного элемента.

Varsavia

4 / 4 / 8

Регистрация: 02.10.2013

Сообщений: 8

03.03.2014, 22:02

Сообщение было отмечено Mandarink-a как решение

Решение

Pascal

Program primer;
const i=5;
var a,b,c:integer;
m: array [1..i] of integer;
begin
c:=0;
Writeln('Это наш одномерный массив:');
for a:=1 to i do
begin
 m[a]:=random(5)-3;
 Writeln('m[',a,']=',m[a]);
 end;
for a:=i downto 1 do
 if (m[a]>=0) then 
 begin
 b:=a;
 if (c=1) then Writeln('Это номер предпоследнего положительного элемента массива: ',b);
 c:=c+1;
 end;
 if (c=1) then Writeln('Нет такого элемента')
 end.

Источник

const
    n = 10;
 
var
    m : Array[1..n] Of ShortInt;
    i, penID, maxID : Byte;
    state : Boolean = False;
    max : ShortInt;
 
procedure Swap(var x, y : ShortInt);
var
    z : ShortInt;
begin
    z := x;
    x := y;
    y := z;
end;
 
begin
    //заполнение и вывод начального массива
    Randomize;
    for i := 1 to n do
    begin
        m[i] := Random(19) - 9;
        Write(m[i]:3);
    end;
    WriteLn; WriteLn;
    //предпоследний отрицательный
    for i := n downto 1 do
    begin
        if (m[i] < 0) then
            if (state) then
            begin
                penID := i;
                break;
            end
            else
                state := True;
    end;
    //максимальный
    max := m[1]; maxID := 1;
    for i := 2 to n do
        if (max < m[i]) then
        begin
            max := m[i];
            maxID := i;
        end;
    WriteLn(penID, '   ', maxID);
    WriteLn;
    if (maxID > penID) then
    begin
        i := maxID;
        maxID := penID;
        penID := i;
    end;
    for i := 1 to (penID - maxID div 2) do
        Swap(m[maxID+i], m[penID-i]);
    //вывод
    for i := 1 to n do
        Write(m[i]:3);
    
end.

Источник