如何从这样的数组中获取第一个元素：
var ary = ['first', 'second', 'third', 'fourth', 'fifth'];
我试过了：
alert($(ary).first());
但它会返回[object Object]。所以我需要从数组中获取第一个元素，它应该是元素'first'。
【问题讨论】：
标签： javascript arrays
喜欢这个
alert(ary[0])
【讨论】：
var a = []; a[7] = 'foo'; alert(a[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
【讨论】：
下面的一些方法适用于不同的情况。
在大多数正常情况下，访问第一个元素的最简单方法是通过
yourArray[0]
但这需要您检查 [0] 是否确实存在。
在现实世界的情况下，您不关心原始数组，也不想检查索引是否存在，您只想获取第一个元素或未定义的内联。
在这种情况下，您可以使用shift() 方法来获取第一个元素，但请注意此方法会修改原始数组（删除第一项并返回它）。因此，数组的长度减一。 此方法可用于只需要获取第一个元素但不关心原始数组的内联情况。
yourArray.shift()
要知道的重要一点是，如果您的数组以 [0] 索引开头，则上述两个只是一个选项。
在某些情况下，第一个元素已被删除，例如，删除 yourArray[0] 会使您的数组留下“洞”。现在 [0] 处的元素只是未定义的，但您想获得第一个“现有”元素。我见过很多这样的真实案例。
所以，假设我们不知道数组和第一个键（或者我们知道有洞），我们仍然可以得到第一个元素。
您可以使用find() 来获取第一个元素。
find() 的优势在于它的效率，因为它在满足条件的第一个值到达时退出循环（下面将详细介绍）。 （您也可以自定义条件以排除 null 或其他空值）
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。
（我看到有些人建议使用 for...in 循环来获取第一个元素，但我建议不要使用这种方法for...in should not be used to iterate over an Array where the index order is important，因为它不能保证顺序，尽管您可以争辩浏览器大多尊重顺序。顺便说一句，forEach 并没有像许多人建议的那样解决问题，因为你不能打破它，它会贯穿所有元素。你最好使用一个简单的 for 循环并检查键/值
find() 和 filter() 都保证元素的顺序，因此可以安全地使用上面的方法。
【讨论】：
yourArray.map(n=>n).shift()，它将返回第一项而不修改原始项...不知道这是否是最好的方法，但如果您使用 .map().filter( ).some().shift() 没关系.. 否则我会使用yourArray[0]
使用 ES6 解构
let [first] = [1,2,3];
与此相同
let first = [1,2,3][0];
【讨论】：
[0] 索引开始。
[,'a','b','c'] 的数组。我认为它从索引 1 开始。
0 开始，但您插入了一个 undefined 值。 ?♂️
你可以使用find():
const first = array.find(Boolean)
或者如果你想要第一个元素即使如果它是falsy:
const first = array.find(e => true)
加倍努力：
如果您关心可读性但又不想依赖数字发生率，您可以通过使用Object.defineProperty() 定义它来添加first() 函数到Array.prototype，这可以减轻修改内置数组对象的缺陷直接原型 (explained here)。
性能非常好（find() 在第一个元素之后停止）但它并不完美或普遍可访问（仅限 ES6）。更多背景信息请阅读@Selays answer。
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() )【讨论】：
find()？ find() 长期以来一直是语言的一部分。这就是上述 sn-p 起作用的原因。
first()-method
如果第一个元素已被删除，则索引为 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']) );【讨论】：
如果您想保留可读性，您可以随时将第一个函数添加到Array.protoype：
Array.prototype.first = function () {
return this[0];
};
然后你可以很容易地检索到第一个元素：
[1, 2, 3].first();
> 1
【讨论】：
.first() 比输入[0] 更好吗？
1 开头。 first 在这种情况下是明确的。
Object.defineProperty()
如果您的数组不能保证从索引零开始填充，您可以使用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'
【讨论】：
!!element，因为它会跳过虚假值。我建议以这种方式使用find()：sparse.find((_, index, array) => index in array);
array.find(e => !!e); // return the first element
因为“查找”返回第一个匹配过滤器的元素 && !!e 匹配任何元素。
注意这仅在第一个元素不是“Falsy”时有效：null、false、NaN、""、0、undefined p>
【讨论】：
const example = [null, NaN, 0, undefined, {}, 3, 'a']; const firstTruthyElement = example.find(e => !!e); // 分配第 5 个元素，第一个非 falsy：{}
array.find(() => true); 怎么样？这也允许您执行[false].find(() => true)。
.find(value => true) 只是按预期工作......但老实说，如果你想要更简洁的代码并保持打字稿中的打字，请使用destructuring。
在ES2015及以上，使用数组解构：
const arr = [42, 555, 666, 777]
const [first] = arr
console.log(first)【讨论】：
只有在您使用 underscore.js (http://underscorejs.org/) 的情况下，您才能这样做：
_.first(your_array);
【讨论】：
我知道那些从其他语言转向 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
【讨论】：
试试alert(ary[0]);。
【讨论】：
适用于数组的方法，它也适用于对象（请注意，对象没有保证顺序！）。
我最喜欢这种方法，因为原始数组没有被修改。
// 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;
【讨论】：
另一个只关注真实元素的人
ary.find(Boolean);
【讨论】：
使用过滤器查找数组中的第一个元素：
在打字稿中：
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;
}
【讨论】：
ES6 扩展运算符 + .shift() 解决方案
使用myArray.shift()可以得到数组的第一个元素，但是.shift()会修改原始数组，所以为了避免这种情况，首先可以使用[...myArray]创建数组的副本，然后应用@ 987654324@此副本：
var myArray = ['first', 'second', 'third', 'fourth', 'fifth'];
var first = [...myArray].shift();
console.log(first);【讨论】：
只需使用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(START,END).pop();
【讨论】：
ary[0]？
ary[0] 的高度赞成的答案，所以如果按照您的建议回答，这将是重复的。使用 slice/pop 也使得抓取最后一个元素变得微不足道，即const last = ary.slice(-1).pop()。
pop-ing 在某种程度上更好地获取数组的第一个元素？
当有多个匹配项时，JQuery 的 .first() 用于获取与给定给 jquery 的 css 选择器匹配的第一个 DOM 元素。
您不需要 jQuery 来操作 javascript 数组。
【讨论】：
为什么不考虑数组可能为空的次数？
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
【讨论】：
你也可以使用 .get(0):
alert($(ary).first().get(0));
获取数组的第一个元素。
【讨论】：
声明一个原型以获取第一个数组元素为：
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];
【讨论】：
var ary = ['first', 'second', 'third', 'fourth', 'fifth'];
alert(Object.values(ary)[0]);【讨论】：
我更喜欢使用数组解构
const [first, second, third] = ["Laide", "Gabriel", "Jets"];
console.log(first); // Output: Laide
console.log(second); // Output: Gabriel
console.log(third); // Output: Jets
【讨论】：
如果您将视图函数链接到数组，例如
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] 版本。
【讨论】：
当数组索引从零开始时，前面的示例运行良好。 thomax's answer 不依赖从零开始的索引，而是依赖于我无法访问的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'.
【讨论】：
@NicoLwk 您应该使用拼接删除元素，这会将您的数组移回。所以：
var a=['a','b','c'];
a.splice(0,1);
for(var i in a){console.log(i+' '+a[i]);}
【讨论】：
使用它来分割 javascript 中的字符。
var str = "boy, girl, dog, cat";
var arr = str.split(",");
var fst = arr.splice(0,1).join("");
var rest = arr.join(",");
【讨论】：
var ary = ['first', 'second', 'third', 'fourth', 'fifth'];
console.log(Object.keys(ary)[0]);
创建任何 Object 数组 (req)，然后只需执行 Object.keys(req)[0] 即可选择 Object 数组中的第一个键。
【讨论】：