Javascript 将字符串数组排序为对象数组

好的，我一直在为我的应用程序开发一个排序函数，我被卡住了

为了简单解释，此代码以字符串数组

serials

和空数组

displaysserials

开头：

var serials = ["BHU-009", "BHU-008", "BHU-001", "BHU-010", "BHU-002", "TYU-970", "BHU-011", "TYU-969", "BHU-000"];
var displaySerials = [];

这些函数的目的是将

displayserias

输出为具有两个属性的对象数组：

beginSerial

和

endSerial

。其工作方式是，函数在数组中循环，并尝试将某个范围内的每个兼容字符串彼此设置，然后从该范围创建对象，其中

beginSerial

是范围内最低的序列号，

endSerial

是范围内最高的序列号

为了澄清，连续范围内的所有序列都将具有相同的前缀。一旦建立了前缀，字符串就会从前缀中分离出来，并进行比较和数字排序

因此，基于此，数组

序列的期望输出为：

displaySerials = [
    { beginSerial: "BHU-008", endSerial: "BHU-011" },
    { beginSerial: "BHU-000", endSerial: "BHU-002" },
    { beginSerial: "TYU-969", endSerial: "TYU-970" }
]

我的JSFIDLE大部分都在使用它，唯一的问题是该函数正在将一个重复的对象推送到数组中，我不确定它是如何通过我的检查的

任何帮助都将不胜感激。
我将使用下划线.js进行此操作

var bSerialExists = _.findWhere(displaySerials, { beginSerial: displaySettings.beginSerial });
var eSerialExists = _.findWhere(displaySerials, { endSerial: displaySettings.endSerial });

if (!bSerialExists && !eSerialExists)
    displaySerials.push(displaySettings);

这里有一个函数可以用普通JavaScript实现这一点


var序列=[“BHU-009”、“BHU-008”、“BHU-001”、“BHU-010”、“BHU-002”、“TYU-970”、“BHU-011”、“TYU-969”、“BHU-000”]；
函数转换序列（a）{
var result=[]；//存储结果的数组
var holder={}；//创建一个临时对象
//循环输入数组并按前缀分组
a、 forEach（函数（val）{
var parts=val.split（'-'）；
变量类型=零件[0]；
var int=parseInt（第[1]和第10部分）；
如果（！holder[类型]）
holder[type]={前缀：type，值：[]}；
holder[type].values.push（{name:val，value:int}）；
});
//在临时对象中交互并查找连续值
用于（固定器中的var类型）{
var last=null；
var groupHolder={}；
//按整数对值排序
var numbers=holder[type].values.sort（函数（a，b）{
返回parseInt（a.value，10）>parseInt（b.value，10）；
});
forEach（函数（值、索引）{
如果（！groupHolder.beginSerial）
groupHolder.beginSerial=value.name；
如果（！last | | value.value==last+1）{
last=value.value；
groupHolder.endSerial=value.name；
如果（索引===numbers.length-1）{
结果：推送（groupHolder）；
}
}
否则{
结果：推送（groupHolder）；
groupHolder={}；
last=null；
}
});
}
返回结果；
}
log（transformSerials（serials））
这里没有什么太复杂的东西，但它应该可以做到这一点。请注意，我正在从get go对数组进行排序，以便可靠地对其进行迭代

小提琴在这里：

var序列=[“BHU-009”、“BHU-008”、“BHU-001”、“BHU-010”、“BHU-002”、“TYU-970”、“BHU-011”、“TYU-969”、“BHU-000”]；
var myNewObjectArray=[]；
var sortedSerials=serials.sort（）；
//种子对象
var myObject={}；
var previous=分类序列[0]；
var previousPrefix=previous.split（“-”[0]；
var previousValue=上一个.split（“-”[1]；
myObject.beginSerial=以前的；
myObject.endSerial=上一个；
//迭代观察序列中的中断
对于（变量i=1；i
马克的解决方案是正确的，但我忍不住认为代码太多了。这是做完全相同的事情，从sort（）开始，然后使用reduce（）以获得更优雅的外观

var serials = ["BHU-009", "BHU-008", "BHU-001", "BHU-010", "BHU-002", "TYU-970", "BHU-011", "TYU-969", "BHU-000"]

serials.sort()
var first = serials.shift()
var ranges = [{begin: first, end: first}]
serials.reduce(mergeRange, ranges[0])
console.log(ranges) // the expected result

// and this is the reduce callback:

function mergeRange(lastRange, s)
{
    var parts = s.split(/-/)
    var lastParts = lastRange.end.split(/-/)

    if (parts[0] === lastParts[0] && parts[1]-1 === +lastParts[1]) {
        lastRange.end = s
        return lastRange
    } else {
        var newRange = {begin: s, end: s}
        ranges.push(newRange)
        return newRange
    }
}

我有一种感觉，不需要排序就可以做到这一点，方法是递归地合并在数组小部分上获得的结果（将元素两个两个地比较，然后两个两个地合并结果，依此类推，直到得到一个结果数组）。代码看起来不太好，但它可以更好地扩展，并且可以并行完成。
我最终解决了自己的问题，因为我比我想象的要近得多。我包含了一个最终排序，以在初始排序完成后消除重复对象

var serials = ["BHU-009", "BHU-008", "BHU-001", "BHU-010", "BHU-002", "TYU-970", "BHU-011", "TYU-969", "BHU-000"];

var displaySerials = [];


var mapSerialsForDisplay = function () {
    var tempArray = serials;

    displaySerials = [];

    for (var i = 0; i < tempArray.length; i++) {
        // compare current member to all other members for similarity
        var currentSerial = tempArray[i];
        var range = [currentSerial];

        var displaySettings = {
            beginSerial: currentSerial,
            endSerial: ""
        }

        for (var j = 0; j < tempArray.length; j++) {
            if (i === j) {
                continue;
            } else {
                var stringInCommon = "";
                var comparingSerial = tempArray[j];

                for (var n = 0; n < currentSerial.length; n++) {
                    if (currentSerial[n] === comparingSerial[n]) {
                        stringInCommon += currentSerial[n];
                        continue;
                    } else {
                        var currentRemaining = currentSerial.replace(stringInCommon, "");
                        var comparingRemaining = comparingSerial.replace(stringInCommon, "");

                        if (!isNaN(currentRemaining) && !isNaN(comparingRemaining) && stringInCommon !== "") {
                            range = compareAndAddToRange(comparingSerial, stringInCommon, range);
                            displaySettings.beginSerial = range[0];
                            displaySettings.endSerial = range[range.length - 1];

                            var existsAlready = false;

                            for (var l = 0; l < displaySerials.length; l++) {


                                if (displaySerials[l].beginSerial == displaySettings.beginSerial || displaySerials[l].endSerial == displaySettings.endSerial) {
                                    existsAlready = true;
                                }
                            }

                            if (!existsAlready) {
                                displaySerials.push(displaySettings);
                            }
                        }
                    }
                }
            }
        }
    }

    for (var i = 0; i < displaySerials.length; i++) {
        for (var j = 0; j < displaySerials.length; j++) {
            if (i === j) {
                continue;
            } else {
                if (displaySerials[i].beginSerial === displaySerials[j].beginSerial && displaySerials[i].endSerial === displaySerials[j].endSerial) {
                    displaySerials.splice(j, 1);
                }
            }
        }
    }

    return displaySerials;
}

var compareAndAddToRange = function (candidate, commonString, arr) {
    var tempArray = [];

    for (var i = 0; i < arr.length; i++) {
        tempArray.push({
            value: arr[i],
            number: parseInt(arr[i].replace(commonString, ""))
        });
    }

    tempArray.sort(function(a, b) { 
        return (a.number > b.number) ? 1 : ((b.number > a.number) ? -1 : 0); 
    });

    var newSerial = {
        value: candidate,
        number: candidate.replace(commonString, "")
    }

    if (tempArray.indexOf(newSerial) === -1) {
        if (tempArray[0].number - newSerial.number === 1) {
            tempArray.unshift(newSerial)
        } else if (newSerial.number - tempArray[tempArray.length - 1].number === 1) {
            tempArray.push(newSerial);
        }
    }

    for (var i = 0; i < tempArray.length; i++) {
        arr[i] = tempArray[i].value;
    }

    arr.sort();

    return arr;
}

mapSerialsForDisplay();
console.log(displaySerials);

var序列=[“BHU-009”、“BHU-008”、“BHU-001”、“BHU-010”、“BHU-002”、“TYU-970”、“BHU-011”、“TYU-969”、“BHU-000”]；
var displaySerials=[]；
var mapsSerialsfordisplay=函数（）{
var tempArray=serials；
displaySerials=[]；
对于（var i=0；ivar serials = ["BHU-009", "BHU-008", "BHU-001", "BHU-010", "BHU-002", "TYU-970", "BHU-011", "TYU-969", "BHU-000"];

var displaySerials = [];


var mapSerialsForDisplay = function () {
    var tempArray = serials;

    displaySerials = [];

    for (var i = 0; i < tempArray.length; i++) {
        // compare current member to all other members for similarity
        var currentSerial = tempArray[i];
        var range = [currentSerial];

        var displaySettings = {
            beginSerial: currentSerial,
            endSerial: ""
        }

        for (var j = 0; j < tempArray.length; j++) {
            if (i === j) {
                continue;
            } else {
                var stringInCommon = "";
                var comparingSerial = tempArray[j];

                for (var n = 0; n < currentSerial.length; n++) {
                    if (currentSerial[n] === comparingSerial[n]) {
                        stringInCommon += currentSerial[n];
                        continue;
                    } else {
                        var currentRemaining = currentSerial.replace(stringInCommon, "");
                        var comparingRemaining = comparingSerial.replace(stringInCommon, "");

                        if (!isNaN(currentRemaining) && !isNaN(comparingRemaining) && stringInCommon !== "") {
                            range = compareAndAddToRange(comparingSerial, stringInCommon, range);
                            displaySettings.beginSerial = range[0];
                            displaySettings.endSerial = range[range.length - 1];

                            var existsAlready = false;

                            for (var l = 0; l < displaySerials.length; l++) {


                                if (displaySerials[l].beginSerial == displaySettings.beginSerial || displaySerials[l].endSerial == displaySettings.endSerial) {
                                    existsAlready = true;
                                }
                            }

                            if (!existsAlready) {
                                displaySerials.push(displaySettings);
                            }
                        }
                    }
                }
            }
        }
    }

    for (var i = 0; i < displaySerials.length; i++) {
        for (var j = 0; j < displaySerials.length; j++) {
            if (i === j) {
                continue;
            } else {
                if (displaySerials[i].beginSerial === displaySerials[j].beginSerial && displaySerials[i].endSerial === displaySerials[j].endSerial) {
                    displaySerials.splice(j, 1);
                }
            }
        }
    }

    return displaySerials;
}

var compareAndAddToRange = function (candidate, commonString, arr) {
    var tempArray = [];

    for (var i = 0; i < arr.length; i++) {
        tempArray.push({
            value: arr[i],
            number: parseInt(arr[i].replace(commonString, ""))
        });
    }

    tempArray.sort(function(a, b) { 
        return (a.number > b.number) ? 1 : ((b.number > a.number) ? -1 : 0); 
    });

    var newSerial = {
        value: candidate,
        number: candidate.replace(commonString, "")
    }

    if (tempArray.indexOf(newSerial) === -1) {
        if (tempArray[0].number - newSerial.number === 1) {
            tempArray.unshift(newSerial)
        } else if (newSerial.number - tempArray[tempArray.length - 1].number === 1) {
            tempArray.push(newSerial);
        }
    }

    for (var i = 0; i < tempArray.length; i++) {
        arr[i] = tempArray[i].value;
    }

    arr.sort();

    return arr;
}

mapSerialsForDisplay();
console.log(displaySerials);