Javascript Jeton remplacer / append

Question

J'ai une chaîne qui ressemble à quelque chose comme ce qui suit « essai: 1, bonjour: cinq, il suffit de: 23 ». Avec cette chaîne, je dois pouvoir faire ce qui suit.

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

Le résultat final devrait être 'test: 567, bonjour: cinq, il suffit de: 23, oui: 23'. (Note ne fait pas si important que cela l'ordre exact des jetons)

Je me demandais si quelqu'un a des idées intelligentes de la façon d'aller à ce sujet. Je pensais remplacer une expression régulière sur chacun des jetons à droite et si un remplacement ne se produit pas, car il n'y avait pas correspondre juste appose. Mais peut-être il y a une meilleure façon.

Vive Anthony

Edit: Le côté droit devrait l'emporter sur la gauche. La gauche étant ce qui était là à l'origine et le côté droit étant le nouveau contenu. Une autre façon de regarder, est que vous ne gardez que les jetons sur la gauche si elles n'existent pas sur le droit et vous conservez tous les jetons sur la droite.

@Ferdinand Merci pour la réponse. Le problème est l'efficacité avec laquelle la solution que vous proposez. Je pensais d'abord vers le bas des lignes similaires, mais il réduit en raison de l'O (n * z) la complexité de la fusion (où n et z est le nombre de jetons à gauche et à droite respectivement) et encore moins la scission et se joindre.

Dès lors, pourquoi je tentais de regarder sur le chemin d'une expression régulière. Peut-être que dans les coulisses, regex est tout aussi mauvais ou pire, mais ayant une expression régulière qui élimine (pour le montant total de jeton sur la droite O (n)) tout jeton de la chaîne gauche qui existe sur la droite, puis il suffit d'ajouter la 2 cordes ensemble (ie test de cuve = test1 + test2) semble plus efficace. merci

Answer 1

Ce qui suit est ce que je fini par penser. Qu'est-ce que vous les gars recon?

Merci Anthony

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 2

J'utiliser join() et split() pour créer des fonctions utilitaires pour compresser et décompresser vos données jeton à un objet:

// 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(';');
}

En utilisant ces derniers, la fusion est facile:

// 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);
}

Les fonctions utilitaires sont également utiles si vous voulez extraire des clés (par exemple, « test ») et / ou vérifier l'existence:

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

Answer 3

Je suis quelques années de retard, mais je pense que c'est ce que vous cherchez:

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;
}