javascript - tipos - Obtener el último elemento en una matriz

tipos de funciones en javascript

Question

Aquí está mi código JavaScript hasta ahora:

var linkElement = document.getElementById("BackButton");
var loc_array = document.location.href.split(''/'');
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2]))); 
linkElement.appendChild(newT);

Actualmente toma el segundo al último elemento de la matriz desde la URL. Sin embargo, quiero hacer una verificación para que el último elemento de la matriz sea "index.html" y, en caso afirmativo, seleccione el tercer al último elemento.

Answer 1

A continuación le indicamos cómo obtenerlo sin efecto en el ARRAY original.

a = [1,2,5,6,1,874,98,"abc"];
a.length; //returns 8 elements

Si usa pop (), modificará su matriz

a.pop();  // will return "abc" AND REMOVES IT from the array 
a.length; // returns 7

Pero puedes usar esto para que no tenga efecto en la matriz original:

a.slice(-1).pop(); // will return "abc" won''t do modify the array 
                   // because slice creates a new array object 
a.length;          // returns 8; no modification and you''ve got you last element 

Answer 2

Creo que la forma más fácil y súper ineficiente es:

var array = [''fenerbahce'',''arsenal'',''milan''];
var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]
console.log(reversed_array[0]) // result is "milan".

Answer 3

Creo que si solo quieres obtener el elemento sin eliminar, es más simple usar esto:

arr.slice(-1)

por cierto ... no verifiqué el rendimiento, pero creo que es más simple y limpio de escribir

Answer 4

Dos opciones son:

var last = arr[arr.length - 1]

o

var last = arr.slice(-1)[0]

El primero es más rápido, pero el segundo se ve mejor

http://jsperf.com/slice-vs-length-1-arr

Answer 5

Esta pregunta ha existido por mucho tiempo, por lo que me sorprende que nadie mencione simplemente volver a colocar el último elemento después de un pop() .

arr.pop() es exactamente tan eficiente como arr[arr.length-1] , y ambos tienen la misma velocidad que arr.push() .

Por lo tanto, puede salirse con la suya:

let thePop = arr.pop()
arr.push(thePop)

Que se puede reducir a esto (la misma velocidad):

arr.push(thePop = arr.pop())

Esto es dos veces más lento que arr[arr.length-1] , pero no tienes que rellenar con un índice. Eso vale oro en cualquier día.

De las soluciones que he probado, y en múltiplos de la Unidad de Tiempo de Ejecución (ETU) de arr[arr.length-1] :

[Método] .............. [ETUs 5 elems] ... [ETU 1 millón de elems]

arr[arr.length - 1]      ------> 1              -----> 1

let myPop = arr.pop()
arr.push(myPop)          ------> 2              -----> 2

arr.slice(-1).pop()      ------> 36             -----> 924  

arr.slice(-1)[0]         ------> 36             -----> 924  

[...arr].pop()           ------> 120            -----> ~21,000,000 :)

Las últimas tres opciones, ESPECIALMENTE [...arr].pop() , se ponen MUY peor a medida que aumenta el tamaño de la matriz. En una máquina sin las limitaciones de memoria de mi máquina, [...arr].pop() probablemente mantiene una proporción de 120: 1. Sin embargo, a nadie le gusta un cerdo de recursos.

Answer 6

Esto es limpio y eficiente:

let list = [ ''a'', ''b'', ''c'' ]

(xs => xs[xs.length - 1])(list)

Si instala un operador de tubería utilizando Babel, se convierte en:

list |> (xs => xs[xs.length - 1])

Answer 7

Generalmente uso underscorejs , con eso simplemente puedes hacer

if (_.last(loc_array) === ''index.html''){
  etc...
}

Para mí eso es más semántico que loc_array.slice(-1)[0]

Answer 8

La manera "más limpia" de ES6 (IMO) sería:

const foo = [1,2,3,4];
const bar = [...foo].pop();

Esto evita la mutación de foo , como lo .pop() , si no .pop() el operador de propagación.
Dicho esto, también me gusta la foo.slice(-1)[0] .

Answer 9

No estoy seguro si hay un inconveniente, pero esto parece bastante conciso:

arr.slice(-1)[0] 

o

arr.slice(-1).pop()

Ambos volverán undefined si la matriz está vacía.

Answer 10

Obtener el último elemento de una matriz se puede lograr utilizando el método de división con valores negativos.

Puedes leer más sobre esto here en la parte inferior.

var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
  //your code...
}

Usar pop () cambiará tu matriz, lo que no siempre es una buena idea.

Answer 11

Otra opción única de ES6 sería utilizar Array.find(item, index)=> {...}) siguiente manera:

const arr = [1, 2, 3];
const last = arr.find((item, index) => index === arr.length - 1);

poco valor práctico, publicado para mostrar que el índice también está disponible para su lógica de filtrado.

Answer 12

Para aquellos que no tengan miedo de sobrecargar el prototipo Array (y con el enmascaramiento de enumeración no debería serlo):

Object.defineProperty( Array.prototype, "getLast", {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        return this[ this.length - 1 ];
    }
} );

Answer 13

Personalmente me gustaría votar por kuporific / kritzikratzi. El método array [array.length-1] se vuelve muy feo si estás trabajando con matrices anidadas.

var array = [[1,2,3], [4,5,6], [7,8,9]]
​
array.slice(-1)[0]
​
//instead of 
​
array[array.length-1]
​
//Much easier to read with nested arrays
​
array.slice(-1)[0].slice(-1)[0]
​
//instead of
​
array[array.length-1][array[array.length-1].length-1]

Answer 14

Prefiero usar array.pop() que los índices.

while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));

de esta manera, siempre obtiene el elemento anterior a index.html (siempre que su matriz tenga index.html aislado como un elemento). Nota: aunque perderás los últimos elementos de la matriz.

Answer 15

Puede agregar un nuevo captador de propiedades al prototipo de Array para que sea accesible a través de todas las instancias de Array .

Getters le permite acceder al valor de retorno de una función como si fuera el valor de una propiedad. El valor de retorno de la función, por supuesto, es el último valor de la matriz ( this[this.length - 1] ).

Finalmente, lo envuelve en una condición que verifica si la last propiedad aún undefined está undefined (no está definida por otra secuencia de comandos que pueda depender de ella).

if(typeof Array.prototype.last === ''undefined'') {
    Object.defineProperty(Array.prototype, ''last'', {
        get : function() {
            return this[this.length - 1];
        }
    });
}

// Now you can access it like
[1, 2, 3].last;            // => 3
// or
var test = [50, 1000];
alert(test.last);          // Says ''1000''

No funciona en IE ≤ 8.

Answer 16

Puede agregar una función last() al prototipo Array .

Array.prototype.last = function () {
    return this[this.length - 1];
};

Answer 17

Puede lograr este problema también sin extraer una matriz de la url

Esta es mi alternativa

var hasIndex = (document.location.href.search(''index.html'') === -1) ? doSomething() : doSomethingElse();

!Saludos

Answer 18

Puedes usar este patrón ...

let [last] = arr.slice(-1);

Si bien se lee bastante bien, tenga en cuenta que crea una nueva matriz por lo que es menos eficiente que otras soluciones, pero casi nunca será el cuello de botella en el rendimiento de su aplicación.

Answer 19

Si uno quiere obtener el último elemento de una sola vez, puede usar Array#splice() :

lastElement = document.location.href.split(''/'').splice(-1,1);

Aquí, no es necesario almacenar los elementos divididos en una matriz y luego llegar al último elemento. Si obtener el último elemento es el único objetivo, este debe ser usado.

Nota: Esto cambia la matriz original al eliminar su último elemento. Piense en el splice(-1,1) como una función pop() que muestra el último elemento.

Answer 20

Sugeriré crear una función auxiliar y reutilizarla cada vez, la necesitarás. Permite que la función sea más general para poder obtener no solo el último elemento, sino también el segundo del último y así sucesivamente.

function last(arr, i) {
    var i = i || 0;
    return arr[arr.length - (1 + i)];
}

El uso es simple

var arr = [1,2,3,4,5];
last(arr);    //5
last(arr, 1); //4
last(arr, 9); //undefined

Ahora, vamos a resolver el problema original.

Coge el segundo al último elemento de la matriz de formulario. Si el último elemento de la loc_array es "index.html", en su lugar, tome el tercer elemento.

La siguiente línea hace el trabajo

last(loc_array, last(loc_array) === ''index.html'' ? 2 : 1);

Por lo tanto, tendrás que volver a escribir

var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2]))); 

De este modo

var newT = document.createTextNode(unescape(capWords(last(loc_array, last(loc_array) === ''index.html'' ? 2 : 1)))); 

o usar una variable adicional para aumentar la legibilidad

var nodeName = last(loc_array, last(loc_array) === ''index.html'' ? 2 : 1);
var newT = document.createTextNode(unescape(capWords(nodeName)));

Answer 21

También hay un módulo npm, que agrega el last a Array.prototype

npm install array-prototype-last --save

uso

require(''array-prototype-last'');

[1, 2, 3].last; //=> 3 

[].last; //=> undefined 

Answer 22

Una versión más corta de lo que @chaiguy publicó:

Array.prototype.last = function() {
    return this[this.length - 1];
}

Leyendo el índice -1 ya undefined está undefined .

EDITAR:

En estos días, la preferencia parece estar usando módulos y evitar tocar el prototipo o usar un espacio de nombres global.

export function last(array) {
    return array[array.length - 1];
}

Answer 23

Usando el operador de propagación ES6 / ES2015 (...) puede hacer lo siguiente.

const data = [1, 2, 3, 4]
const [last] = [...data].reverse()
console.log(last)

Tenga en cuenta que al utilizar el operador de propagación y el reverso no mutamos la matriz original, esta es una forma pura de obtener un último elemento de la matriz.

Answer 24

Using lodash _.last Obtiene el último elemento de array.

data = [1,2,3]
last = _.last(data)
console.log(last)

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

Answer 25

Utilice Array.pop :

var lastItem = anArray.pop();

Importante : Esto devuelve el último elemento y lo elimina de la matriz

Answer 26

jQuery resuelve esto claramente:

> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined

Answer 27

En la Etapa 1 de la propuesta de ECMAScript hay una sugerencia para agregar una propiedad de matriz que devolverá el último elemento: proposal-array-last .

Sintaxis:

arr.lastItem // get last item
arr.lastItem = ''value'' // set last item

arr.lastIndex // get last index

Puede utilizar polyfill .

Autor de la propuesta: Keith Cirkel ( chai autor)

Answer 28

EDITADO:

Recientemente se me ocurrió una solución más que ahora creo que es la mejor para mis necesidades:

function w (anArray)
{ return (
  { last() {return anArray [anArray.length - 1]
  }
}        );

Con la definición anterior vigente ahora puedo decir:

let last = w ([1,2,3]).last();
console.log(last) ; // -> 3

El nombre "w" significa "envoltorio". Puede ver cómo podría agregar fácilmente más métodos además de ''last ()'' a este contenedor.

Digo "lo mejor para mis necesidades", porque esto me permite agregar fácilmente otros "métodos de ayuda" a cualquier tipo de JavaScript incorporado. Lo que viene a la mente son el auto () y cdr () de Lisp, por ejemplo.

Answer 29

const lastElement = myArray[myArray.length - 1];

Esta es la mejor opción desde el punto de vista del rendimiento (~ 1000 veces más rápido que arr.slice (-1)).

Answer 30

if(loc_array[loc_array.length-1] == ''index.html''){
 //do something
}else{
 //something else.
}

En el caso de que su servidor sirva el mismo archivo para "index.html" y "inDEX.htML", también puede usar: .toLowerCase() .

Sin embargo, es posible que desee considerar este lado del servidor si es posible: será más limpio y funcionará para las personas sin JS.