0

我在两个用户之间有一系列消息，比如私人聊天。用户 A 可以与用户 B、C 和 D 进行 2-3 次聊天。

现在我必须拆分这个数组并获得一个长度为 3 的数组（AB、AC、AD 之间的消息）。为此，我使用以下代码：

var gloabal = [];
var myArray = [];      
function splitArray () {

    alert("Split");

    var oldArray = myArray;
    var newArray = [];

    var object = oldArray[0];
    var daUtente = object.get("daUtente");
    var aUtente = object.get("aUtente");            

    for (var i = 0; i < myArray.length; i++) {

        var obj = myArray[i];
        var newDaUtente = obj.get("daUtente");
        var newaUtente = obj.get("aUtente");

        if ((newDaUtente == daUtente) && (newaUtente == aUtente) || 
            (newDaUtente == aUtente) && (newaUtente == daUtente)) {
                newArray.push(obj);
                oldArray.splice(i, 1);
        }

        var lastObj = myArray[myArray.length - 1];

        if (obj == lastObj){
            gloabal.push(newArray);
            newArray = [];

            if(oldArray.length != 0) {
                myArray = oldArray;
                splitArray ();
            }
            else {
                myArray = gloabal;
                alert("end");       
            }   
        }       
    }
}

此逻辑适用于 iPhone 应用程序，但使用 Javascript 我有一些问题。我认为原因是我对 Javascript 的了解不足。你能帮我改正错误吗？我认为问题出在：

else {
    myArray = gloabal;
    alert("end");       
}

因为我没有看到“结束”警报！

示例：数组：

1 - user A - user B - message
2 - user B - user A - message
3 - user A - user B - message
4 - user A - user B - message
5 - user A - user C - message
6 - user C - user A - message
7 - user A - user D - message

我想要这个：数组 1

1 - user A - user B - message
2 - user B - user A - message
3 - user A - user B - message
4 - user A - user B - message

数组 2

1 - user A - user C - message
2 - user C - user A - message

数组 3

1 - user A - user D - message

newArray = [数组 1，数组 2，数组 3]

4

1 回答 1

0

我很难理解你的代码，但这就是我构建这样一个东西的方式。

首先，我有一个简单的函数，叫做getId：

function getId(to, from) {                                                                                                                                                                    
    // we use sort so that we get a consistent id; results in alphabetic sorting                                                                                                              
    return [to, from].sort().join("-");                                                                                                                                                       
}

假设您的用户名是唯一的，此函数构造一个标识符，该标识符对于每个对话配对都是唯一的。此外，此 id 对两者都是相同的A->B，B->A因为它按字母顺序对to和from值进行排序。

此函数用于使用Object消息值填充 an。这是我的实现splitArray：

function splitArray() {
    var intermediary = {};
    for(var i = 0; i < data.length; ++i) {
        var id = getId(data[i].to, data[i].from);
        if(intermediary.hasOwnProperty(id)) {
            intermediary[id].push(data[i]);
        } else {
            intermediary[id] = [data[i]];
        }
    }
    // xform from object to array
    result = [];
    var keys = Object.keys(intermediary);
    for(i = 0; i < keys.length; ++i) {
        result.push(intermediary[keys[i]]);
    }
}

我的数据是这样排列的：

var data = [                                                                                                                                                                                  
    {'to': "B", 'from': "A", 'msg': "message"},                                                                                                                                               
    {'to': "A", 'from': "B", 'msg': "message"},                                                                                                                                               
    {'to': "B", 'from': "A", 'msg': "message"},                                                                                                                                               
    {'to': "B", 'from': "A", 'msg': "message"},                                                                                                                                               
    {'to': "C", 'from': "A", 'msg': "message"},                                                                                                                                               
    {'to': "A", 'from': "C", 'msg': "message"},                                                                                                                                               
    {'to': "D", 'from': "A", 'msg': "message"}                                                                                                                                                
];

如果字段to和from存在，则该功能将起作用（并且这些字段可以很容易地在 中重命名splitArray）。

该函数通过构建用户对到消息的映射来工作，然后将其展平为二维数组。使用中介Object是因为即使扁平化在函数结束时会产生很小的处理开销，但它比重复搜索用户对以将它们输入适当的数组要快。这是我从中得到的结果结构：

[
    [
        {"to":"B","from":"A","msg":"message"},
        {"to":"A","from":"B","msg":"message"},
        {"to":"B","from":"A","msg":"message"},
        {"to":"B","from":"A","msg":"message"}
    ],
    [
        {"to":"C","from":"A","msg":"message"},
        {"to":"A","from":"C","msg":"message"}
    ],
    [
        {"to":"D","from":"A","msg":"message"}
    ]
]

希望能帮助到你 ：）

编辑：我使用了全局变量，因为这是您使用的，但是我强烈建议使用返回值的参数化函数，例如：

function splitArray(messages) {
    .....
    return results;
}

全局变量和函数易于编写，但难以维护。

于 2013-07-25T00:59:37.317 回答