Question

我有一个类似于以下'test：1; hello：five; just：23'的字符串。使用此字符串，我需要能够执行以下操作。

....
var test = MergeTokens('test:1;hello:five;just:23', 'yes:23;test:567');
...

最终结果应为'test：567; hello：five; just：23; yes：23'（注意令牌的确切顺序并不重要）。

只是想知道是否有人对如何解决这个问题有任何明智的想法。我正在考虑在右边的每个令牌上使用正则表达式替换，如果由于没有匹配而没有发生替换只是附加它。但也许有更好的方法。

干杯安东尼

编辑：右侧应覆盖左侧。左边是原来的，右边是新内容。另一种看待它的方法是，如果右侧不存在令牌，则只保留左侧的令牌，并将所有令牌保持在右侧。

@Ferdinand 谢谢回复。问题是您提出的解决方案的效率。我最初考虑类似的行，但由于合并的O（n * z）复杂性而打折扣（其中n和z分别是左右分别的数字标记），更不用说拆分和连接了。

因此，为什么我试图俯视正则表达式的路径。也许在幕后，正则表达式同样糟糕或更糟，但有一个正则表达式从右侧存在的左侧字符串中删除任何标记（右侧令牌总数为O（n））然后只需添加2个字符串在一起（即增值测试= test1 + test2）似乎更有效。谢谢

Answer 1

我会使用join()和split()创建一些实用程序函数来将令牌数据打包并解压缩到对象：

// Unpacks a token string into an object.
function splitTokens(str) {
    var data = {}, pairs = str.split(';');
    for (var i = 0; i < pairs.length; ++i) {
        var pair = pairs[i].split(':');
        data[pair[0]] = pair[1];
    }
    return data;
}

// Packs an object into a token string.
function joinTokens(data) {
    var pairs = [];
    for (var key in data) {
        pairs.push(key + ":" + data[key]);
    }
    return pairs.join(';');
}

使用这些，合并很容易：

// Merges all token strings (supports a variable number of arguments).
function mergeTokens() {
    var data = {};
    for (var i = 0; i < arguments.length; ++i) {
        var d = splitTokens(arguments[i]);
        for (var key in d) {
            data[key] = d[key];
        }
    }
    return joinTokens(data);
}

如果要提取某些键（例如“test”）和/或检查是否存在，实用程序功能也很有用：

var data = splitTokens(str);
if (data["test"] === undefined) {
    // Does not exist
} else {
    alert("Value of 'test': " + data["test"]);
}

Answer 2

以下是我最后的想法。你们有什么调查？

由于安东尼

function Tokenizer(input, tokenSpacer, tokenValueSpacer) {
    this.Tokenizer = {};
    this.TokenSpacer = tokenSpacer;
    this.TokenValueSpacer = tokenValueSpacer;
    if (input) {
        var TokenizerParts = input.split(this.TokenSpacer);
        var i, nv;
        for (i = 0; i < TokenizerParts.length; i++) {
            nv = TokenizerParts[i].split(this.TokenValueSpacer);
            this.Tokenizer[nv[0]] = nv[1];
        }
    }
}

Tokenizer.prototype.add = function(name, value) {
    if (arguments.length == 1 && arguments[0].constructor == Object) {
        this.addMany(arguments[0]);
        return;
    }
    this.Tokenizer[name] = value;
}

Tokenizer.prototype.addMany = function(newValues) {
    for (nv in newValues) {
        this.Tokenizer[nv] = newValues[nv];
    }
}

Tokenizer.prototype.remove = function(name) {
    if (arguments.length == 1 && arguments[0].constructor == Array) {
        this.removeMany(arguments[0]);
        return;
    }
    delete this.Tokenizer[name];
}

Tokenizer.prototype.removeMany = function(deleteNames) {
    var i;
    for (i = 0; i < deleteNames.length; i++) {
        delete this.Tokenizer[deleteNames[i]];
    }
}

Tokenizer.prototype.MergeTokenizers = function(newTokenizer) {
    this.addMany(newTokenizer.Tokenizer);
}

Tokenizer.prototype.getTokenString = function() {
    var nv, q = [];
    for (nv in this.Tokenizer) {
        q[q.length] = nv + this.TokenValueSpacer + this.Tokenizer[nv];
    }
    return q.join(this.TokenSpacer);
}

Tokenizer.prototype.toString = Tokenizer.prototype.getTokenString;

Answer 3

我迟到了几年，但我认为这就是你要找的东西：

function MergeTokens(input, replace){
 var replaceTokens = replace.split(";");
 for(i=0; i<replaceTokens.length; i++){
  var pair = replaceTokens[i].split(":");
  var result = input;
  regString = "\\b" + pair[0] + ":[\\w]*\\b";
  var reg = new RegExp(regString);
  if(reg.test(result)){
   result = result.replace(reg, replaceTokens[i]);
  }
  else{
   result = result + replaceTokens[i];
  }
 }
 return result;
}

Javascript标记替换/追加

3 个答案: