JavaScript将数组项移到前面

Question

我想检查一个数组是否包含"role"。如果是，我想将"role"移动到数组的前面。

var data= ["email","role","type","name"];
if ("role" in data) data.remove(data.indexOf("role")); data.unshift("role")
data;

在这里，我得到了结果：

["role", "email", "role", "type", "name"]

我该如何解决这个问题？

Answer 1

您可以对数组进行排序，并指定值"role"位于所有其他值之前，并且所有其他值都相等：

var first = "role";
data.sort(function(x,y){ return x == first ? -1 : y == first ? 1 : 0; });

演示：http://jsfiddle.net/Guffa/7ST24/

Answer 2

我的第一个想法是：

var data= ["email","role","type","name"];

// if it's not there, or is already the first element (of index 0)
// then there's no point going further:
if (data.indexOf('role') > 0) {
    // find the current index of 'role':
    var index = data.indexOf('role');
    // using splice to remove elements from the array, starting at
    // the identified index, and affecting 1 element(s):
    data.splice(index,1);
    // putting the 'role' string back in the array:
    data.unshift('role');
}

console.log(data);

修改并整理一下：

if (data.indexOf('role') > 0) {
    data.splice(data.indexOf('role'), 1);
    data.unshift('role');
}

参考文献：

• Array.indexOf()。
• Array.prototype.splice()。
• Array.unshift()。

Answer 3

我认为ES6中最干净的解决方案：

let data = ["email","role","type","name"];
data = data.filter(item => item !== "role");
data.unshift("role");

Answer 4

sample_rate_hertz

Answer 5

如果您不想更改现有阵列，可以使用ES6解构和过滤方法创建新副本，同时保持其他项目的顺序。

const data = ["email", "role", "type", "name"];
const newData = ['role', ...data.filter(item => item !== 'role')];

Answer 6

我会选择此ES6解决方案。它不会改变原始数组（考虑到它不是嵌套的），不会遍历该数组（过滤器），并且您不仅仅限于第0个用于移动数组项的索引。

const moveArrayItem = (array, fromIndex, toIndex) => {
    const arr = [...array];
    arr.splice(toIndex, 0, ...arr.splice(fromIndex, 1));
    return arr;
}


const arr = ["a", "b", "c", "d", "e", "f", "g"];
console.log(moveArrayItem(arr, 4, 0))
// [ 'e', 'a', 'b', 'c', 'd', 'f', 'g' ]

Answer 7

1. in运算符与属性有关，与数组中的项无关。请参阅How do I check if an array includes an object in JavaScript?了解其他用途。
2. 您在if-block
中的两个（！）语句周围缺少大括号
3. 我不确定您使用的.remove()功能是否会获取某个项目的索引。

Answer 8

类似于@Tandroid的答案，但更通用的解决方案：

const putItemsFirst = ({ findFunction, array }) => [
    ...array.filter(findFunction), 
    ...array.filter(signer => !findFunction(signer)),
]; 

可以这样使用

putItemsFirst({ 
    array: ["email","role","type","name"], 
    findFunction: item => item === 'role',
})

我最终使用的与此类似的东西

Answer 9

如果需要，这里是一个不变的解决方案：

      const newData = [
          data.find(item => item === 'role'),
          ...data.filter(item => item !== 'role'),
        ],

Answer 10

如果您有对象数组，则可以通过拼接和推动来移动起始索引。 Splice从所需的索引开始，用数组的一部分替换原始数组，并返回您删除的部分（索引之前的内容）。

refresh_token

Answer 11

可重用的 ES6/Typescript 解决方案：

const moveToStart = <T>(array: T[], predicate: (item: T) => boolean): T[] => {
  return array.sort((a, b) => {
    if (predicate(a)) return -1;
    if (predicate(b)) return 1;

    return 0;
  });
};

const data = ["email", "role", "type", "name"];
const result = moveToStart(data, (item) => item === "role"))

Answer 12

您可以将支票的差额放在期望值的顶部。

var data = ["email", "role", "type", "name"];

data.sort((a, b) => (b === 'role') - (a === 'role'));

console.log(data);

Answer 13

要检查数组中是否存在某项，应使用.includes()而不是in（如此处所述，in用于对象中的属性）。

此功能可满足您的需求： （将项目从其所在位置移走并读取 在前面）

   data = ["email","role","type","name"];
   moveToFirst("role", data)
    
   function moveToFirst(s, r){
      if (r.includes(s)){
        r.splice(r.indexOf(s),1);
        r.unshift(s);
      } 
    }
    
    console.log(data)

Answer 14

var data= ["email","role","type","name"];

data.splice(data.indexOf("role"), 1);
data.unshift('role');

Answer 15

使用lodash _.sortBy。如果项目是role，则将首先对其进行排序，否则将对其进行排序。如果没有role

，这也很好

var data = ["email", "role", "type", "name"];

var sorted = _.sortBy(data, function(item) {
  return item === 'role' ? 0 : 1;
});

console.log(sorted);

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

Answer 16

只想在这里说一下，因为根据其他评论，古法（Guffa）的答案似乎越来越受到关注，最后的高等教育-这是对该答案的负面评论之一是没有必要的。还使用箭头功能使它看起来更整洁。

此外，它很容易扩展以处理对象数组。

const first = "role";
data.sort((x, y) => first === x ? -1 : first === y)

我相信这也应该解决阵列其余部分受到影响的担忧。当sort函数返回的数字小于0（第一个=== x）时，元素将朝Array的开头移动；当它返回0（第一个=== y）时，将不移动，并且当a如果数字大于0（第一个=== y），则x将相对于x和y向数组的结尾移动。因此，当x或y都不等于所需的第一个元素（或在对对象进行排序时为标识符）时，两者将不会相对移动。

对于对象：

const unsorted = [{'id': 'test'}, {'id': 'something'}, {'id': 'else'}];
const first = 'something';
const sorted = unsorted.sort((x,y) => x['id'] === first ? -1 : y['id'] === first);

Answer 17

广义单行：

const data = ["a", "b", "c", "d", "e", "f"];
const [from, take] = [3, 2];

data.unshift(...data.splice(from, take));
// alternatively
data = [...data.splice(from, take), ...data];
// ["d", "e", "a", "b", "c", "f"]

Answer 18

var i = -1;
while (i < data.length) {
    if (data[i] === "role") {
        data.splice(i, 1);
        break;
    }
    i++;
}
data.unshift("role");

indexOf仅限于浏览器支持，IE7-8无法识别。因此，如果我是你，我也不会使用它，即使是以牺牲几行为代价。代码简洁明了。你还想在＆＃34; unshift＆＃34;的最后加一个分号。声明。 splice（）的第一个参数指定开始删除元素的索引，第二个参数指定要删除的参数的数量。

Answer 19

data.unshift(data.splice(data.indexOf('role'), 1)[0])

data.indexOf('role') 会在数组中找到 'role' 的索引，然后拼接原始数组以移除 'role' 元素，使用 unshift 将其添加到数组的开头

Answer 20

var data= ["email","role","type","name"];
if ("role" in data) data.splice(data.indexOf("role"),1); data.unshift("role");
data;