Question

您好我正在尝试通过其ID在localStorage中对某些数据进行排序。

数据格式如下： {“Brand”：“Acura”，“Model”：“选择你的模特”，“年龄”：“1998”，“KM”：“10”，“姓名”：“Harry”，“ContactInfo”：“123456677” }

我希望按KM值的最低到最高顺序进行排序。

我的本地存储密钥是注册的，这是我正在使用的代码：

function Qsort() {
    var mymain = JSON.parse(localStorage.getItem("register"));
    var result = quicksort(mymain, 0, mymain.length - 1);
    // the following line fo code shows the final result of the sorted numbers or strings
    console.log(mymain);
    console.log(quicksort(mymain, 0, mymain.length - 1));
    return result;
}

function quicksort(mymain, left, right) {
    var index;

    // checks if there are more than one numbers
    if (mymain.length > 1) {

    // partition will find a pivot then split leist in two either left of right. 
    // Left list contains everything that is smaller than the pivot and the right contians everythign larger than pivot
    index = partition(mymain, left, right);

    // will treat left side aas a new problem and will then run the sort
    if (left < index - 1){
        quicksort(mymain, left, index - 1)
    }

    // will treat right side as a new problem and will then run the sort
    if (index < right) {
        quicksort(mymain, index, right)
        }

    }
    return mymain
}

// Divides the whole function
function partition(mymain, left, right) {
    var pivot = mymain[Math.floor((right + left) / 2)],
        i     = left,
        j     = right;

    while (i <= j) {
        while (mymain[i] < pivot) {
            i++;
        }
        while (mymain[j] > pivot) {
            j--;
        }
        if (i <= j) {
            swap(mymain, i, j);
            i++;
            j--;
        }
    }
    return i;
}

// swaps the values based on how high or low the number is
function swap(mymain, firstIndex, secondIndex) {
    var temp = mymain[firstIndex];
    mymain[firstIndex] = mymain[secondIndex];
    mymain[secondIndex] = temp;
}

我应该如何处理var mymain部分，以便它只获取KM下定义的值。

Answer 1

假设"register"中localStorage的项目是一个数组，你可以简单地做...

var mymain = JSON.parse(localStorage.getItem("register"))
var justKMs = mymain.map(function(data){ return data.KM; });

但是这会返回一个只包含KM值的数组，因此您最终必须搜索mymain列表以获取其余数据，我认为这不是您想要的。< / p>

另一种方法是添加＆＃34;查找＆＃34;告诉quicksort的功能＆＃34;如何＆＃34;获取要用于排序的值。我们将查找函数签名定义为function lookup( item ) => value，其中item是当前正在排序的列表中的内容，value是要排序的值。

以下是来自computer-science-in-javascript的快速排序版本，其中添加了＆＃34;查找＆＃34;功能

// the swap function doesn't need to change
function swap(items, firstIndex, secondIndex) {
    var temp = items[firstIndex];
    items[firstIndex] = items[secondIndex];
    items[secondIndex] = temp;
}

// you will need to pass the lookup function into partition
function partition(items, left, right, lookup) {
    // here you need to use "lookup" to get the proper pivot value
    var pivot = lookup(items[Math.floor((right + left) / 2)]),
        i = left,
        j = right;

    while (i <= j) {
        // here is where you will do a lookup instead of just "items[i]"
        while (lookup(items[i]) < pivot) {
            i++;
        }
        // also use lookup here
        while (lookup(items[j]) > pivot) {
            j--;
        }

        if (i <= j) {
            swap(items, i, j);
            i++;
            j--;
        }
    }

    return i;
}

function quickSort(items, left, right, lookup) {
    var index;

    // performance - don't sort an array with zero or one items
    if (items.length > 1) {
        // fix left and right values - might not be provided
        left = typeof left != "number" ? 0 : left;
        right = typeof right != "number" ? items.length - 1 : right;

        // set a default lookup function just in case
        if (typeof lookup !== 'function') {
            // the default lookup function just returns the item passed in
            lookup = function (item) {
                return item;
            };
        }

        index = partition(items, left, right, lookup);

        if (left < index - 1) {
            quickSort(items, left, index - 1, lookup);
        }

        if (index < right) {
            quickSort(items, index, right, lookup);
        }
    }
    return items;
}

然后＆＃34;查找＆＃34;数据集的函数将是......

function kmLookup( data ) {
    return data.KM;
}

......高阶函数的力量

作为旁注，如果你真的没有和quicksort结婚，你可以选择懒人选项（或者根据你的观点选择智能选项）并在Array原型上使用sort方法...

var mymain = JSON.parse(localStorage.getItem("register"));

// the sort function sorts the array in place,
//  so after this next line mymain will be sorted
mymain.sort(function (a, b) {
    return a.KM - b.KM;
});

假设您没有使用非常大的数据集，这可能是最好的解决方案。 MDN Array.prototype.sort() docs

如何根据本地存储中的变量快速输入内容？

1 个答案: