Come ottenere il primo elemento di un array?

Come si ottiene il primo elemento da un array come questo:

var ary = ['first', 'second', 'third', 'fourth', 'fifth'];

Ho provato questo:

alert($(ary).first());

Ma sarebbe tornato [object Object]. Quindi ho bisogno di ottenere il primo elemento dall'array che dovrebbe essere l'elemento 'first'.

come questo

alert(ary[0])

Perché stai jQuery-ifying un array JavaScript vaniglia? Usa JavaScript standard!

var ary = ['first', 'second', 'third', 'fourth', 'fifth'];
alert(ary[0]);

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array

Anche,

Fonte , per gentile concessione di Bobince

Alcuni dei modi seguenti per diverse circostanze.

Nella maggior parte dei casi normali, è il modo più semplice per accedere al primo elemento

yourArray[0]

ma questo richiede di verificare se [0] esiste realmente.

Ci sono casi del mondo reale in cui non ti interessa l'array originale e non vuoi controllare se esiste un indice, vuoi solo ottenere il primo elemento o non definito in linea.

In questo caso, puoi usare il metodo shift () per ottenere il primo elemento, ma fai attenzione che questo metodo modifica l'array originale (rimuove il primo elemento e lo restituisce). Pertanto la lunghezza di un array è ridotta di uno. Questo metodo può essere utilizzato nei casi inline in cui è sufficiente ottenere il primo elemento, ma non ti interessa l'array originale.

yourArray.shift()

La cosa importante da sapere è che i due precedenti sono solo un'opzione se l'array inizia con un indice [0].

Ci sono casi in cui il primo elemento è stato eliminato, ad esempio, elimina yourArray [0] lasciando l'array con "buchi". Ora l'elemento in [0] è semplicemente indefinito, ma vuoi ottenere il primo elemento "esistente". Ho visto molti casi reali di questo.

Quindi, supponendo che non abbiamo conoscenza dell'array e della prima chiave (o sappiamo che ci sono buchi), possiamo ancora ottenere il primo elemento.

Puoi usare find () per ottenere il primo elemento.

Il vantaggio di find () è la sua efficienza quando esce dal loop quando viene raggiunto il primo valore che soddisfa la condizione (maggiori informazioni su questo sotto). (È possibile personalizzare la condizione per escludere anche valori null o altri valori vuoti)

var firstItem = yourArray.find(x=>x!==undefined);

Vorrei anche includere filter () qui come opzione per prima "riparare" l'array nella copia e quindi ottenere il primo elemento mantenendo intatto l'array originale (non modificato).

Un altro motivo per includere filter () qui è che esisteva prima di find () e molti programmatori lo hanno già usato (è ES5 contro find () essendo ES6).

var firstItem = yourArray.filter(x => typeof x!==undefined).shift();

Avviso che filter () non è in realtà un modo efficiente (filter () scorre attraverso tutti gli elementi) e crea un altro array. Va bene usare su array di piccole dimensioni poiché l'impatto sulle prestazioni sarebbe marginale, più vicino all'uso di ForEach, ad esempio.

(Vedo alcune persone suggerire di usare for ... in loop per ottenere il primo elemento, ma sconsiglio questo metodo per ... in non dovrebbe essere usato per iterare su una matrice in cui l'ordine dell'indice è importante perché non lo fa ' garantiamo l'ordine anche se puoi sostenere che i browser rispettano principalmente l'ordine. A proposito, ogni soluzione non risolve il problema come molti suggeriscono perché non puoi romperlo e scorrerà tutti gli elementi. Sarebbe meglio usare un semplice per loop e controllando chiave / valore

Find () e filter () garantiscono l'ordine degli elementi, quindi sono sicuri da usare come sopra.

Utilizzo della destrutturazione ES6

let [first] = [1,2,3];

Che è lo stesso di

let first = [1,2,3][0];

L'elemento dell'indice 0 potrebbe non esistere se il primo elemento è stato eliminato:

let a = ['a', 'b', 'c'];
delete a[0];

for (let i in a) {
  console.log(i + ' ' + a[i]);
}

Modo migliore per ottenere il primo elemento senza jQuery:

function first(p) {
  for (let i in p) return p[i];
}

console.log( first(['a', 'b', 'c']) );

Se si desidera preservare la leggibilità, è sempre possibile aggiungere una prima funzione a Array.protoype:

Array.prototype.first = function () {
    return this[0];
};

A allora potresti facilmente recuperare il primo elemento:

[1, 2, 3].first();
> 1

Puoi semplicemente usare find():

let first = array.find(Boolean);

O se vuoi il primo elemento anche se è falso :

let first = array.find(e => true);

Andare il miglio supplementare:

Se vi preoccupate per la leggibilità, ma non si vuole fare affidamento su incidenze numerici si potrebbe aggiungere un first()-funzione per Array.protoypedefinendo con Object​.define​Property()che mitiga le insidie di modificare il built-in Array oggetto prototipo direttamente ( spiegate qui ).

Le prestazioni sono piuttosto buone (si find()fermano dopo il primo elemento) ma non sono perfette o universalmente accessibili (solo ES6). Per ulteriori informazioni leggi la risposta @Selays .

Object.defineProperty(Array.prototype, 'first', {
  value() {
    return this.find(e => true);     // or this.find(Boolean)
  }
});

Quindi per recuperare il primo elemento puoi fare:

let array = ['a', 'b', 'c'];
array.first();

> 'a'

Snippet per vederlo in azione:

Object.defineProperty(Array.prototype, 'first', {
  value() {
    return this.find(Boolean);
  }
});

console.log( ['a', 'b', 'c'].first() );

Se non si garantisce che l'array sia popolato dall'indice zero, è possibile utilizzare Array.prototype.find():

var elements = []
elements[1] = 'foo'
elements[2] = 'bar'

var first = function(element) { return !!element }    
var gotcha = elements.find(first)

console.log(a[0]) // undefined
console.log(gotcha) // 'foo'

array.find(e => !!e);  // return the first element 

poiché "trova" restituisce il primo elemento corrispondente al filtro && !!e corrisponde a qualsiasi elemento.

Nota Questo funziona solo quando il primo elemento non è un "Falsy": null, false, NaN, "", 0,undefined

Prova alert(ary[0]);.

Solo nel caso in cui stai usando underscore.js ( http://underscorejs.org/ ) puoi fare:

_.first(your_array);

Conosco persone che provengono da altre lingue su JavaScript e cercano qualcosa di simile head()ofirst() ottengono il primo elemento di un array, ma come puoi farlo?

Immagina di avere l'array di seguito:

const arr = [1, 2, 3, 4, 5];

In JavaScript, puoi semplicemente fare:

const first = arr[0];

o più ordinato, il modo più recente è:

const [first] = arr;

Ma puoi anche semplicemente scrivere una funzione come ...

function first(arr) {
   if(!Array.isArray(arr)) return;
   return arr[0];
}

Se si utilizza il trattino basso, ci sono un elenco di funzioni che fanno la stessa cosa che stai cercando:

_.first 

_.head

_.take

Metodo che funziona con le matrici e funziona anche con gli oggetti (attenzione, gli oggetti non hanno un ordine garantito!).

Preferisco di più questo metodo, perché l'array originale non viene modificato.

// In case of array
var arr = [];
arr[3] = 'first';
arr[7] = 'last';
var firstElement;
for(var i in arr){
    firstElement = arr[i];
    break;
}
console.log(firstElement);  // "first"

// In case of object
var obj = {
    first: 'first',
    last: 'last',
};

var firstElement;

for(var i in obj){
    firstElement = obj[i];
    break;
}

console.log(firstElement) // First;

In ES2015 e versioni successive, utilizzando la distruzione dell'array:

const arr = [42, 555, 666, 777]
const [first] = arr
console.log(first)

Un altro per quelli che si occupano solo di elementi sinceri

ary.find(Boolean);

Trova il primo elemento in un array usando un filtro:

In dattiloscritto:

function first<T>(arr: T[], filter: (v: T) => boolean): T {
    let result: T;
    return arr.some(v => { result = v; return filter(v); }) ? result : undefined;
}

In javascript semplice:

function first(arr, filter) {
    var result;
    return arr.some(function (v) { result = v; return filter(v); }) ? result : undefined;
}

E allo stesso modo, indexOf:

In dattiloscritto:

function indexOf<T>(arr: T[], filter: (v: T) => boolean): number {
    let result: number;
    return arr.some((v, i) => { result = i; return filter(v); }) ? result : undefined;
}

In javascript semplice:

function indexOf(arr, filter) {
    var result;
    return arr.some(function (v, i) { result = i; return filter(v); }) ? result : undefined;
}

Quando ci sono più corrispondenze, il .first () di JQuery viene usato per recuperare il primo elemento DOM che corrispondeva al selettore css dato a jquery.

Non è necessario jQuery per manipolare le matrici JavaScript.

Perché non tenere conto delle volte in cui l'array potrebbe essere vuoto?

var ary = ['first', 'second', 'third', 'fourth', 'fifth'];
first = (array) => array.length ? array[0] : 'no items';
first(ary)
// output: first

var ary = [];
first(ary)
// output: no items

Basta usare ary.slice(0,1).pop();

Nel

var ary = ['first', 'second', 'third', 'fourth', 'fifth'];

console.log("1º "+ary.slice(0,1).pop());
console.log("2º "+ary.slice(0,2).pop());
console.log("3º "+ary.slice(0,3).pop());
console.log("4º "+ary.slice(0,4).pop());
console.log("5º "+ary.slice(0,5).pop());
console.log("Last "+ary.slice(-1).pop());

array.slice (START, END) .pop ();

Puoi anche usare .get (0):

alert($(ary).first().get(0));

Per ottenere il primo elemento dell'array.

Usa questo per dividere il personaggio in javascript.

var str = "boy, girl, dog, cat";
var arr = str.split(",");
var fst = arr.splice(0,1).join("");
var rest = arr.join(",");

Gli esempi precedenti funzionano bene quando l'indice dell'array inizia da zero. La risposta di Thomax non si basava sull'indice a partire da zero, ma si basava su Array.prototype.findcui non avevo accesso. La seguente soluzione che utilizza jQuery $ .each ha funzionato bene nel mio caso.

let haystack = {100: 'first', 150: 'second'},
    found = null;

$.each(haystack, function( index, value ) {
    found = value;  // Save the first array element for later.
    return false;  // Immediately stop the $.each loop after the first array element.
});

console.log(found); // Prints 'first'.

Puoi farlo da lodash _.head così facilmente.

var arr = ['first', 'second', 'third', 'fourth', 'fifth'];
console.log(_.head(arr));

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

@NicoLwk Dovresti rimuovere gli elementi con giunzione, che sposteranno indietro l'array. Così:

var a=['a','b','c'];
a.splice(0,1);
for(var i in a){console.log(i+' '+a[i]);}

Dichiarare un prototipo per ottenere il primo elemento dell'array come:

Array.prototype.first = function () {
   return this[0];
};

Quindi usalo come:

var array = [0, 1, 2, 3];
var first = array.first();
var _first = [0, 1, 2, 3].first();

O semplicemente (:

first = array[0];

Se si sta concatenando una vista funzioni all'array, ad es

array.map(i => i+1).filter(i => i > 3)

E vuoi il primo elemento dopo queste funzioni puoi semplicemente aggiungere un .shift()che non modifica l'originale array, quindi è un modo migliorearray.map(i => i+1).filter(=> i > 3)[0]

Se si desidera il primo elemento di un array senza modificare l'originale, è possibile utilizzare array[0]o array.map(n=>n).shift()(senza la mappa si modificherà l'originale. In questo caso, suggerirei la ..[0]versione.

var ary = ['first', 'second', 'third', 'fourth', 'fifth'];

console.log(Object.keys(ary)[0]);

Crea qualsiasi array di oggetti ( req), quindi semplicemente Object.keys(req)[0]seleziona la prima chiave dell'array di oggetti.

La risposta di @thomax è abbastanza buona, ma fallirà se il primo elemento dell'array è false o false-y (0, stringa vuota, ecc.). Meglio restituire true per qualsiasi cosa diversa da undefined:

const arr = [];
arr[1] = '';
arr[2] = 'foo';

const first = arr.find((v) => { return (typeof v !== 'undefined'); });
console.log(first); // ''

ES6 facile:

let a = []
a[7] = 'A'
a[10] = 'B'

let firstValue = a.find(v => v)
let firstIndex = a.findIndex(v => v)