Question

我想解析该字符串：

[[abc.d.2,mcnv.3.we],[abec.d.2,mcnv.4.we],[abhc.d.2,mcnv.5.we]]

为了拥有键值（JSON）

{
"abc.d.2": "mcnv.3.we",
"abec.d.2: "mcnv.4.we",
"abhc.d.2": "mcnv.5.we"
}

首先，我想检查是否可以分析字符串以使其为键=>值。如何检查字符串是否包含对？

谢谢

Answer 1

您可以尝试以下操作：

方法1：

想法：

更新正则表达式以包含更多特定字符。就您而言，字母数字和句点。
从字符串中获取所有匹配的元素。
所有奇数都是键，偶数匹配都是值。
重叠匹配并创建一个对象。

const str = "[[abc.d.2,mcnv.3.we],[abec.d.2,mcnv.4.we],[abhc.d.2,mcnv.5.we]]";
const matches = str.match(/[\w\.\d]+/gi);

const output = {};

for(var i = 0; i< matches.length; i+=2) {
  output[matches[i]] = matches[i+1];
}

console.log(output)

方法2：

想法：

编写正则表达式以捕获每个单独的组：[...:...]
然后消除括号[和]。
使用逗号,分割字符串。
第一部分是您的钥匙。第二是您的价值。

const str = "[[abc.d.2,mcnv.3.we],[abec.d.2,mcnv.4.we],[abhc.d.2,mcnv.5.we]]";
const matches = str.match(/\[([\w\d\.,]*)\]/gi);
const output = matches.reduce((obj, match) => {
  const parts = match.substring(1, match.length - 1).split(',');
  obj[parts[0]] = parts[1];
  return obj;
}, {})

console.log(output)

在上述方法中，您还可以包含Map。最初可能会使迭代有些混乱，但是您可以尝试。

const str = "[[abc.d.2,mcnv.3.we],[abec.d.2,mcnv.4.we],[abhc.d.2,mcnv.5.we]]";
const matches = str.match(/\[([\w\d\.,]*)\]/gi);
const output = matches.reduce((obj, match) => {
  const parts = match.substring(1, match.length - 1).split(',');
  obj.set(...parts)
  return obj;
}, new Map())

for (const [k, v] of output.entries()) {
  console.log(`Key: ${k}, value: ${v}`)
}

Answer 2

将数组解析为JSON，在数组上进行迭代，然后将条目添加到目标对象，并注意重复的键：

let dict_target = {}; // The target dictionary, 
let src, arysrc, proceed = false;

try {
    src = "[[abc.d.2,mcnv.3.we],[abec.d.2,mcnv.4.we],[abhc.d.2,mcnv.5.we]]"
                  .replace(/,/g, '","')
                  .replace(/\]","\[/g, '"],["')
                  .replace(/^\[\[/, '[["')
                  .replace(/\]\]$/, '"]]')
             ;
    arysrc = JSON.parse(src);
    proceed = true; // Could parse the data, can carry on with processing the data
} catch (e) {
    console.log(`Source data unparseable, error '${e.message}'.`);
} 

if (proceed) {
    arysrc.forEach ( (a_item, n_idx) => {
        if (dict_target.hasOwnProperty(a_item[0])) {
           // add any tests and processing for duplicate keys/value pairs here  
           if (typeof dict_target[a_item[0]] === "string") {
               dict_target[a_item[0]] = [ dict_target[a_item[0]] ];
           }
           dict_target[a_item[0]].push(a_item[1]);
        }
        else {
           dict_target[a_item[0]] = a_item[1];
        }
    });
 } // if -- proceed

Answer 3

我的高尔夫编码解决方案...

const parse = (str) => {
    let obj = {};
    str.replace(
        /\[([^\[,]+),([^\],]+)\]/g,
        (m, k, v) => obj[k] = v
    );
    return obj;
};

优势：

更多允许任意字符
更能容忍缺失值
避免用于GC的一次性物品

缺点：

更多允许使用任意字符！
这不是正确的解析器...
没有上下文，只有[key，val]

我实际上想发布以下内容作为答案...但是我认为这会给我带来麻烦：P

const parse=(str,obj={})=>
!str.replace(/\[([^\[,]+),([^\],]+)\]/g,(m,k,v)=>obj[k]=v)||obj;

Answer 4

这是首先验证字符串并输出结果的代码。根本不是最优的，但是任务还可以。

var string = '[[abc.d.2,mcnv.3.we],[abec.d.2,mcnv.4.we],[abhc.d.2,mcnv.5.we]]';
var result = (/^\[(\[.*\..*\..*\,.*\..*\..*\]\,)*\[(.*\..*\..*\,.*\..*\..*)\]\]$/g).exec(string);
if (result) {
  var r1 = result[1].replace(/\[|\]/g, '').split(',');
  var r2 = result[2].split(',');
  var output = {};

  for (var i = 0; i < r1.length -1; i +=2) {
    output[r1[i]] = r1[i+1];
  }
  output[r2[0]] = r2[1];

  console.log(output);
} else {
  console.log('invalid string');
}

正则表达式在数组中查找对

4 个答案:

方法1：

方法2：