如何比较数组中的字符串：Javascript

我有一个数组，看起来像

var arr = ["a|c", "a|e", "x|z"];
for(var x in arr){
    var appsplit = x.split("|");
}

如果元素中的第一个值（例如：a）匹配，那么它应该组合这些值

Ex:output
王牌
xz

---

请建议如何使用这种方法。

你正在用这个谜语测试每个人的阅读理解能力

var pairs = {};

var arr = ["a|c", "a|e", "x|z"];
for(var x in arr)
{
    var appsplit = arr[x].split("|");
    if(pairs[appsplit[0]] !== "undefined")
    {
        pairs[appsplit[0]] = pairs[appsplit[0]] + appsplit[1];
    }
    else
    {
        pairs[appsplit[0]] = appsplit[1];
    }

}

var matches = [];

for(var x in pairs)
{
    matches.push(x + pairs[x]);
}

console.log(matches);

我们需要映射出这个名为

对的对象中的
arr
元素。拆分中的第一个值将是键，第二个值将被追加（如果它是键的第一个匹配项，则被指定为
）

分割
x
时出错，但只分割元素的索引，而不是元素的实际值
arr[x]
是实际值，其中
x
指定数组中的索引

检查完您的
arr
后，现在可以将键与值合并。您的输出包含在
matches
中，其中每一对中的密钥都在密钥对的值之前。
一些简单的代码可能会影响这里的技巧

var arr = ["a|c", "a|e", "x|z", "c|b", "z|e", "c|a"];
var resultObj = {};
arr.forEach(function(element, index){
     var array = element.split('|');
     if(array.length!==2){
        console.log("skipping, invalid input data", element);
     } else {
        var firstLetter = array[0];
        var secondLetter = array[1];
        if(resultObj[firstLetter]){
           resultObj[firstLetter].push(secondLetter);
        } else {
            resultObj[firstLetter]=[secondLetter];
        }
     }

});

Object.keys(resultObj).forEach(function(key){
    console.log(key + "," + resultObj[key]);
});

您可以使用
.reduce（）
，
设置
以不累积重复值，
.some（）
检查前一个数组是否在当前数组中包含值，
.map（）
，
数组。from（）
和
将数组转换为字符串


var arr=[“a | c”、“a | e”、“x | z”]；
var res=arr.reduce（函数（a，b）{
var curr=b.split（“|”）；
var集合=新集合；
为（当前道具）设置。添加（道具）；
如果（！a.长度）{
a、 推（套）
}否则{
为了（一个道具）{
如果（当前某些功能（el）{
返回道具has（el）
})) {
对于（当前的el）{
道具添加（el）
}
}否则{
为（当前道具）设置。添加（道具）；
a、 推（套）
}
}
}
归还
}，[]）.map（函数（m）{
返回数组.from（[…m]，函数（el）{
返回el
}).join（“”）
});
控制台日志（res）我觉得这可以做得更优雅，但我没有时间简化它。：）不过，下面的代码将执行您想要的操作：

var aStartArray = **ARRAY_VALUE_HERE**;
var aSplitResultStrings = [];

// step through each element in the array
for (var i = 0, iSALength = aStartArray.length; i < iSALength; i++) {

    // split the values for the current array element
    var aSplitVal = aStartArray[i].split("|");
    var bStringDoesNotExist = true;

    // loop through the "result strings" array
    for (var j = 0, iSRSLength = aSplitResultStrings.length; j < iSRSLength; j++) {

        // if the first letter from the array element = the first letter of the current "result string" . . .
        if (aSplitResultStrings[j].charAt(0) === aSplitVal[0]) {

            // append the second letter of the array value to the current result string
            aSplitResultStrings[j] = aSplitResultStrings[j] + aSplitVal[1];

            // indicate that a match has been found and exit the "result string" loop
            bStringDoesNotExist = false;
            break;
        }
    }

    // if there are no result strings that start with the first letter of the array value . . .
    if (bStringDoesNotExist) {

        // concatenate the two values in the current array value and add them as a new "result string"
        aSplitResultStrings.push(aSplitVal[0] + aSplitVal[1]);
    }
}

正如我所说的，这可能更优雅（例如，您可能可以使用
Map
来简化“结果字符串”的迭代），但这使步骤非常清晰，应该可以让您朝着最终解决方案的正确方向前进。
您的问题是什么？你试过什么吗？这是javascript还是java？java！=javascript@tnwOP显然尝试了
javascript
？期望的输出没有意义。他说，对于数组中所有以同一个字母开头的值，将唯一的字母组合起来，以便。因此，
[“a | b”、“a | c”、“a | d”、“a | e”]
，结果将是“abcde”，因为所有值都以“a”作为第一个值，并按顺序与所有第二个值组合。类似地，
[“a | b”、“a | c”、“x | y”、“x | z”]
将产生“abc”和“xyz”。太棒了。只需稍加修改，这个解决方案就成功了。+100注意：这种方法的一个缺点（这也是我在解决方案中使用数组的原因）是对象结构不能保证其内容的任何顺序。因此，当您对（var x in pairs）
执行
操作时，字符串可能按照创建顺序出现，也可能不按照创建顺序出现。但是，如果顺序不重要，那么这就行了。@talemyn是的，严格地说，这是真的。但解释说，大多数现代浏览器遵循顺序。唯一的例外（在Chrome中），我自己也经历过，就是当你有一个只包含数字的
键时。试着在你的Chrome开发控制台中粘贴
{“first”：1，“1one”：2，“2”：3}
，然后看着它先迭代
“2”
键。@Vic-是的，直到最近的一个项目中，我才最终遇到了我的第一个关于对象键顺序的问题。不幸的是，它最终有点大（验证规则的执行顺序）。我非常渴望开始深入研究
映射
，因为它似乎解决了
对象
的问题。
aStartArray = ["a|c", "a|e", "x|z"] //results in:
aSplitResultStrings = ["ace", "xz"]

aStartArray = ["a|b", "a|c", "a|d", "a|e", "x|y", "x|z"] //results in:
aSplitResultStrings = ["abcde", "xyz"]

aStartArray = ["a|b", "d|e", "d|f", "x|y", "g|h", "g|i", "m|n", "g|j", "a|c", "x|z"] //results in:
aSplitResultStrings = ["abc", "def", "xyz", "ghij", "mn"]