如何获得数组的第一个元素?

像这样

alert(ary[0])

alert(ary[0]);试试。

为什么要对一个普通JavaScript数组进行jquery化?使用标准JavaScript!

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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

源，由bobince提供

当有多个匹配时，JQuery的.first()用于获取与css选择器匹配的第一个DOM元素。

你不需要jQuery来操作javascript数组。

如果你想保留readibility，你可以在Array.protoype中添加第一个函数:

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

A，那么你可以很容易地检索第一个元素:

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

如果第一个元素被删除，索引0的元素可能不存在:

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


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

更好的方法得到第一个元素没有jQuery:

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


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

@NicoLwk你应该用splice删除元素，这会把你的数组移回来。所以:

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

你也可以使用.get(0):

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

来获取数组的第一个元素。

只有在使用underscore.js (http://underscorejs.org/)的情况下，你可以这样做:

_.first(your_array);

以下是针对不同情况的一些方法。

在大多数正常情况下，访问第一个元素的最简单方法是通过

yourArray[0]

但这需要你检查[0]是否实际存在。

另一个常用的方法是转变()，但你应该避免为了访问第一个元素而使用它。

此外，这需要一个完整的[0]索引指针的完美数组，就像使用[0];

yourArray.shift()

需要知道的重要事情是，上面两个仅当数组以[0]索引开始时才是一个选项

在某些情况下，第一个元素已经被删除，例如delete yourArray[0]，将数组留下"holes"。现在[0]的元素是没有定义的，但是你想要得到第一个“存在的”;元素。我在现实世界中见过很多这样的例子。

所以，假设我们不知道数组和第一个键(或者我们知道有洞)，我们仍然可以得到第一个元素。

你可以使用find ()来获取第一个元素。

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

我还想在这里包括filter ()作为第一个“修复”的选项;副本中的数组，然后获取第一个元素，同时保持原始数组完整(未修改)。

这里包含filter()的另一个原因是，它在find()之前就存在了，许多程序员已经在使用它(它是ES5，而find()是ES6)。

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

警告filter()不是一个真正有效的方法(filter()运行在所有元素中)并创建另一个数组。在较小的数组上使用它是可以的，因为性能影响很小，例如，更接近于使用forEach()。

我在一些项目中看到的另一个方法是接头()，用于获取数组中的第一项，然后通过索引获取它:

var firstItem = yourArray.splice(0, 1)[0];

我不明白你为什么要那样做。这种方法不能解决数组(稀疏数组)中有洞的问题。它的代价很高，因为它将重新索引数组，并返回一个必须再次访问以获取值的数组。例如，如果删除前两个元素，则splice()将返回undefined，而不是数组中第一个定义的值。

find()和filter()都保证了元素的顺序，所以可以像上面那样安全地使用。

**(我看到有些人建议使用循环来获取第一个元素，但我反对这种方法。显然，你可以使用任何循环从数组中获取值，但为什么要这么做呢? 可读性，优化，不必要的代码块等。使用本机函数时，浏览器可以更好地优化代码。它甚至可能不适用于某些不能保证迭代顺序的循环

顺便说一下，forEach()并没有像许多人建议的那样解决这个问题，因为你不能打破它，它会贯穿所有元素。使用简单的for循环和检查键/值会更好，但为什么呢?**

使用这个来分割javascript中的字符。

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

声明一个原型以获得第一个数组< em > < / em >元素为:

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

然后把它用作:

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

或者简单地说(:

first = array[0];

使用过滤器查找数组中的第一个元素:

在打字稿:

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

在纯javascript中:

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

类似地，indexOf:

在打字稿:

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;
}

在纯javascript中:

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

如果你的数组不能保证从索引0开始填充，你可以使用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'

方法使用数组，它也使用对象(注意，对象没有保证顺序!)。

我最喜欢这个方法，因为原始数组没有被修改。

// 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;

如果你将一个视图函数链接到数组，例如。

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

想要在这些函数之后的第一个元素，你可以简单地添加一个.shift()，它不会修改原来的array，它比array.map(i => i+1).filter(=> i > 3)[0]更好

如果你想要数组的第一个元素而不修改原始元素，你可以使用array[0]或array.map(n=>n).shift()(没有映射，你将修改原始元素。在这种情况下，顺便说一句，我会建议..[0]版本。

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


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

创建任意对象数组(req)，然后简单地执行Object.keys(req)[0]来选择对象数组中的第一个键。

@thomax的答案很好，但如果数组中的第一个元素为false或false-y(0，空字符串等)，则会失败。除了undefined，最好返回true:

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


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

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

因为"find"返回第一个匹配过滤器的元素&&!!e匹配任何元素。

请注意仅当第一个元素不是“Falsy”时有效:null， false， NaN， ""， 0， undefined

当数组下标从0开始时，前面的示例工作得很好。thomax的回答不依赖于从0开始的索引，而是依赖于我没有访问权限的Array.prototype.find。下面使用jQuery . each美元的解决方案在我的情况下工作得很好。

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'.

ES6容易:

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


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

使用ES6解构

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

哪个是一样的

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

为什么不考虑数组可能为空的时间呢?

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

在ES2015及以上版本中，使用数组解构:

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

我知道从其他语言到JavaScript的人，寻找类似head()或first()的东西来获得数组的第一个元素，但你怎么做呢?

假设你有如下数组:

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

在JavaScript中，你可以简单地做:

const first = arr[0];

或者一种更整洁、更新的方式是:

const [first] = arr;

但是你也可以简单地写一个函数，像…

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

如果使用下划线，有一个函数列表做相同的事情，你正在寻找:

_.first


_.head


_.take

只需使用ary.slice(0,1).pop();即可

在

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(开始、结束).pop ();

一个香草的JS代码，没有jQuery，没有库，没有什么..: P . .如果数组下标不是从0开始，它也会工作。

var ary = ['first', 'second', 'third', 'fourth', 'fifth'];
console.log(Object.values(ary)[0]);

你可以只使用find():

const first = array.find(Boolean)

或如果你想要第一个元素甚至如果是假的:

const first = array.find(() => true)

或如果你想要第一个元素甚至如果它是假的，但如果它是空的或未定义 (更多的信息):

const first = array.find(e => typeof e !== 'undefined')

加倍努力:

如果你关心可读性，但不想依赖于数字出现，你可以通过用Object​.define​Property()定义__abc0 -函数来添加到Array.prototype，这减轻了直接修改内置Array对象原型的陷阱(这里介绍的)。

性能非常好(find()在第一个元素之后停止)，但它不是完美的或普遍可访问的(仅ES6)。更多背景信息请阅读@Selays回答。

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

要检索第一个元素，你现在可以这样做:

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


> 'a'

片段以查看它的运行情况:

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


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

另一个是给那些只关心真相的人的

ary.find(Boolean);

ES6扩展运算符+ .shift()解决方案

使用myArray.shift()你可以得到数组的第一个元素，但是.shift()会修改原始数组，所以为了避免这种情况，首先你可以用[...myArray]创建一个数组的副本，然后将.shift()应用到这个副本:

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


var first = [...myArray].shift();


console.log(first);

使用ES6。

let arr = [22,1,4,55,7,8,9,3,2,4];


let {0 : first ,[arr.length - 1] : last} = arr;
console.log(first, last);

或

let {0 : first ,length : l, [l - 1] : last} = [22,1,4,55,7,8,9,3,2,4];
console.log(first, last);

我更喜欢使用数组解构

const [first, second, third] = ["Laide", "Gabriel", "Jets"];
console.log(first);  // Output: Laide
console.log(second); // Output: Gabriel
console.log(third);  // Output: Jets

试一试

var array= ['first', 'second', 'third', 'fourth', 'fifth'];
firstElement = array[array.length - array.length];

< a href = " https://playcode。Io /908187" rel="nofollow noreferrer">https://playcode.io/908187 .

var ary = ["first", "second", "third", "fourth", "fifth"];
console.log(ary.shift());
//first
cosnole.log(ary);
// ["second", "third", "fourth", "fifth"]

其他答案的问题是，许多答案不能处理数组为空或未定义的情况，而能够处理这个问题的答案要么很难读取，要么需要使用库。

我能想到的最干净的纯JavaScript方法是使用可选的链接和三元操作符:

const first = array?.length ? array[0] : undefined

如果你需要支持旧的浏览器，你也可以在没有可选的链接的情况下这样做:

const first = array && array.length ? array[0] : undefined

这样做的另一个好处是，如果你需要返回一个undefined以外的值(例如在React组件中返回null)，你很容易更新代码来做到这一点。