Question

我有一个像这样的json：

{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"}]}}

...，然后动态获取值并创建一个变量：

var existingParams = [
"name",
"updated"].filter(field => getBody.search[field]);

var sqlVal = existingParams.map(field => {
 if (field === 'name') {
     function getValues(item, index) {
       var getVal = [item.tag];
       return "%" + getVal + "%";
     }
     console.log(name.map(getValues));
     return name.map(getValues);

   } else {
     return getBody.search[field];
   }
 })

对于上面的示例，我得到了sqlVal：

console.log(sqlVal);         

[ [ '%Peter%' ], '2018-11-07' ]

...很好。

但是，如果我有两个值：

{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"}]}}

...我正在得到这个结构：

[ [ '%Peter%', '%Jack%' ], '2018-11-07' ]

...但是我需要的是……

[ '%Peter%', '%Jack%', '2018-11-07' ]

...或：

[ ['%Peter%'], ['%Jack%'], '2018-11-07' ]

还有进一步的情况3个名字：

{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"},{"tag":"Maria"}]}}

...我需要……

[ '%Peter%', '%Jack%', '%Maria%', '2018-11-07' ]

...或：

[ ['%Peter%'], ['%Jack%'], ['%Maria%'], '2018-11-07' ]

...等等

我需要如何调整上面的查询来获取此信息？

Answer 1

如果我正确理解了您的问题，则可以通过Array#reduce()方法解决此问题。

此方法的总体思路是将输入对象转换为数组-使用减少操作name上的嵌套值的特殊情况规则，可以使用reduce操作来完成此操作进入最终结果：

var input = {"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"}]}}

var result = Object
.entries(input.search)
.reduce(function(result, entry) {

  const key = entry[0]
  const value = entry[1]
  
  if(key === 'name') {

    // When the 'name' key is encountered, handle the value
    // differently, by addting the items of this value array
    // to the result
    value.forEach(function(item) { 
      result.push('%' + item.tag + '%')
    })
  }
  else {
  
    // Append values for other keys directly to the result
    result.push(value)
  }
  
  return result
  
}, [])

console.log(result )

Answer 2

您可以简单地使用Object.values + reduce这样的内容：

const json = { "search": { "updated": "2018-11-07", "name": [{ "tag": "Peter" }, { "tag": "Jack" }, { "tag": "Maria" }] } } 

const result = Object.values(json.search).reduce((r,c) => 
  (Array.isArray(c) ? r.push(...c.map(({tag}) => `%${tag}%`)) : r.push(c), r),[])

console.log(result)

如果顺序很重要（首先是姓名，然后是日期），则可以使用reverse：

const json = { "search": { "updated": "2018-11-07", "name": [{ "tag": "Peter" }, { "tag": "Jack" }, { "tag": "Maria" }] } } 

const result = Object.values(json.search).reverse().reduce((r,c) => 
  (Array.isArray(c) ? r.push(...c.map(({tag}) => `%${tag}%`)) : r.push(c), r),[])

console.log(result)

Answer 3

首先，您没有提供Minimal, Complete, and Verifiable example，因此，我很难弄清您遇到了什么问题。例如，您引用的是existingParam，但它们的定义都没有。这是理解问题的关键，因为您发布的所有代码都大量投入了该值的值和格式。

第二，您如何解析JSON？使用标准的JSON#parse函数，您将获得与提供的JSON具有相同结构的对象。但是，您要么不使用它，要么在将对象解析为新格式后对其进行突变。无论哪种方式，JSON#parse为提供的JSON返回的对象都不是数组，因此您不能在其上使用Array#map。

为了提高工作效率，我将尝试解释如何做事情。

JSON：

let data1 = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"}]}}',
    data2 = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"}]}} ',
    data3 = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"},{"tag":"Maria"}]}}';

现在我们有了JSON数据，我们需要对其进行解析并将其存储为JSON对象。为此，我将创建一个函数；这样，可以将数据传递到相同的函数并以相同的方式处理，但是实现将保持不变。另外，由于我们仅查看search属性中的值，因此我们将继续并直接进入其中。

解析JSON：

function parseResponse (response) {
    let parsedResponse = JSON.parse(response);
        parsedResponse = parsedResponse['search'];
}

现在，我们有了可以响应并进行解析的函数，然后我们就可以开始对其进行排序，以查找和隔离所需的部分。在这种情况下，我们将添加一些代码以遍历属性，并找到updated和name属性。

function parseResponse (response) {
    let parsedResponse = JSON.parse(response);
        parsedResponse = parsedResponse['search'];

    for (let prop in parsedResponse) {
        if (prop === 'updated') {
            // do stuff with 'updated'
        }

        if (prop === 'name') {
            // do stuff with 'name'
        }
    }
}

因为我们要返回结果，所以我们将添加变量updated和names，这些变量将保存我们从字符串中拉出的值，直到准备好返回它们为止。现在我们有了循环和临时变量，接下来可以将更新后的值从数据中提取出来并将其放在updated变量中。

function parseResponse (response) {
    let parsedResponse = JSON.parse(response),
        updated = '',
        names = [];
        parsedResponse = parsedResponse['search'];

    for (let prop in parsedResponse) {
        if (prop === 'updated') {
            updated = parsedResponse[prop];
        }

        if (prop === 'name') {
            // do stuff with 'name'
        }
    }
}

我们将updated的值平方掉，就可以进入我们的名字了。由于您首先列出了['%name%', '%name%', '%name%']格式，因此我将继续向您展示如何使用这种格式。在这里，我们将获取属性name，遍历名称，获取tag属性，然后添加% s，然后将其推入names临时变量

function parseResponse (response) {
    let parsedResponse = JSON.parse(response),
        updated = '',
        names = [];
        parsedResponse = parsedResponse['search'];

    for (let prop in parsedResponse) {
        if (prop === 'updated') {
            updated = parsedResponse[prop];
        }

        if (prop === 'name') {
            for (let i = 0; i < parsedResponse[prop].length; i++) {
                let name = parsedResponse[prop][i].tag;
                    name = '%' + name + '%';

                names.push(name);
            }
        }
    }
}

一切就绪后，剩下的就是组装结果。为此，我们将展平names的数组，将它们添加到数组中，然后在返回之前将updated值添加到末尾。为了使数组变平，我们将使用spread运算符。

function parseResponse (response) {
    let parsedResponse = JSON.parse(response),
        updated = '',
        names = [];
        parsedResponse = parsedResponse['search'];

    for (let prop in parsedResponse) {
        if (prop === 'updated') {
            updated = parsedResponse[prop];
        }

        if (prop === 'name') {
            for (let i = 0; i < parsedResponse[prop].length; i++) {
                let name = parsedResponse[prop][i].tag;
                    name = '%' + name + '%';

                names.push(name);
            }
        }
    }

    return [...names, updated];
}

在所有这些设置之后，我们可以继续使用parseResponse()，data1或data2呼叫data3，并返回如下响应：

let data1 = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"}]}}',
    data2 = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"}]}} ',
    data3 = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"},{"tag":"Maria"}]}}';

function parseResponse (response) {
    let parsedResponse = JSON.parse(response),
        updated = '',
        names = [];
        parsedResponse = parsedResponse['search'];

    for (let prop in parsedResponse) {
        if (prop === 'updated') {
            updated = parsedResponse[prop];
        }

        if (prop === 'name') {
            for (let i = 0; i < parsedResponse[prop].length; i++) {
                let name = parsedResponse[prop][i].tag;
                    name = '%' + name + '%';

                names.push(name);
            }
        }
    }

    return [...names, updated];
}

console.log(parseResponse(data1));
console.log(parseResponse(data2));
console.log(parseResponse(data3));

Answer 4

Spread运算符可用于将结果展平：

var obj = {"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"},{"tag":"Maria"}]}}

var arr = [...obj.search.name.map(n => `%${n.tag}%`), obj.search.updated]

console.log( arr )

另一种选择是在解析过程中提取：

var arr = [], json = '{"search":{"updated":"2018-11-07","name":[{"tag":"Peter"},{"tag":"Jack"},{"tag":"Maria"}]}}'

JSON.parse(json, (k, v) => v.trim && arr.push(k === 'tag' ? `%${v}%` : v))

console.log( arr )

Javascript-在多个数组或字符串中拆分并返回数组

4 个答案: