Javascript 过滤对象的经济方式'；s结果

我有一个JSON文件，我只需要检索得分最高的十项：

我的数据：

{
    "movies" : {
        "eraserhead" : {
               "full_title" : "Eraserhead",
               "votes": 50
         },
        "psycho" : {
               "full_title" : "Psycho",
               "votes" : 90  
         }
    }
}

等等，等等，大约50-100人的名单

我知道我可以迭代并构建一个列表，但我很好奇是否有处理器密集度较低的方法根据该属性过滤这些结果（

movies[title].voces

）

---

非常感谢您的帮助。

最简单的方法是制作一个数组，对数组进行排序并获取前10个元素

var myArray = [];
for (var key in movies) {
    var movie = movies[key];
    movie.title = key; 
    myArray.push(movie);
}
var tenFirst = myArray.sort(function(a,b){return b.votes-a.votes}).slice(0,10);

---

最简单的方法是创建一个数组，对数组进行排序，并获取前10个元素

var myArray = [];
for (var key in movies) {
    var movie = movies[key];
    movie.title = key; 
    myArray.push(movie);
}
var tenFirst = myArray.sort(function(a,b){return b.votes-a.votes}).slice(0,10);

---

分拣费用昂贵。既然您表示希望它高效，请执行以下操作：

var result = [],
    len, o;

for (var key in data.movies) {
    o = data.movies[key];
    len = result.length
    if (!len) {
        result.push(o);
    } else if (len < 10) {
        if (o.votes < result[0].votes) {
            result.unshift(o);
        } else {
            while (len--) {
                if (o.votes > result[len].votes) {
                    result.splice(len + 1, 0, o);
                    break;
                }
            }
        }
    } else if (o.votes > result[0].votes) {
        result.shift();
        if (o.votes < result[0].votes) {
            result.unshift(o);
            continue;
        }
        len--;
        while (len--) {
            if (o.votes > result[len].votes) {
                result.splice(len + 1, 0, o);
                break;
            }
        }
    }
}

var result=[]，
蓝，o；
for（data.movies中的var键）{
o=数据。电影[键]；
len=结果长度
如果（！len）{
结果：推（o）；
}否则，如果（长度<10）{
如果（o.票数<结果[0]。票数）{
结果：反移位（o）；
}否则{
而(len--){
如果（o.投票>结果[len]。投票）{
结果：拼接（len+1,0,o）；
打破
}
}
}
}否则如果（o.Voces>结果[0]。投票）{
result.shift（）；
如果（o.票数<结果[0]。票数）{
结果：反移位（o）；
继续；
}
蓝--；
而(len--){
如果（o.投票>结果[len]。投票）{
结果：拼接（len+1,0,o）；
打破
}
}
}
}

---

分拣费用昂贵。既然您表示希望它高效，请执行以下操作：

var result = [],
    len, o;

for (var key in data.movies) {
    o = data.movies[key];
    len = result.length
    if (!len) {
        result.push(o);
    } else if (len < 10) {
        if (o.votes < result[0].votes) {
            result.unshift(o);
        } else {
            while (len--) {
                if (o.votes > result[len].votes) {
                    result.splice(len + 1, 0, o);
                    break;
                }
            }
        }
    } else if (o.votes > result[0].votes) {
        result.shift();
        if (o.votes < result[0].votes) {
            result.unshift(o);
            continue;
        }
        len--;
        while (len--) {
            if (o.votes > result[len].votes) {
                result.splice(len + 1, 0, o);
                break;
            }
        }
    }
}

var result=[]，
蓝，o；
for（data.movies中的var键）{
o=数据。电影[键]；
len=结果长度
如果（！len）{
结果：推（o）；
}否则，如果（长度<10）{
如果（o.票数<结果[0]。票数）{
结果：反移位（o）；
}否则{
而(len--){
如果（o.投票>结果[len]。投票）{
结果：拼接（len+1,0,o）；
打破
}
}
}
}否则如果（o.Voces>结果[0]。投票）{
result.shift（）；
如果（o.票数<结果[0]。票数）{
结果：反移位（o）；
继续；
}
蓝--；
而(len--){
如果（o.投票>结果[len]。投票）{
结果：拼接（len+1,0,o）；
打破
}
}
}
}

---

除非您对列表进行排序，否则迭代和构建列表是必要的，而且非常简单。当你达到总数时，只要打破循环就行了……你的标题是“经济”，但你的问题是“更容易”。你想要哪一个？我想的处理器密集度比我现在的要低-答案回答了这个问题。我更改了文本以澄清这一点。我在上一版本中有一个错误，但请查看我的答案。除非您对列表进行排序，否则迭代和构建列表是必要的，而且非常简单。当你达到总数时，只要打破循环就行了……你的标题是“经济”，但你的问题是“更容易”。你想要哪一个？我想的处理器密集度比我现在的要低-答案回答了这个问题。我更改了文本以澄清这一点。我在以前的版本中有一个错误，但请查看我的答案。如果它是从JSON解析的，则不需要hasOwnProperty。@我不知道这一点。谢谢你让我知道如果它是从JSON解析的，不需要hasOwnProperty。@我不知道。谢谢你让我知道谢谢你的帮助，这正是我想要的。谢谢你的帮助，这正是我想要的。