There is no "error" if you use more than one key with the same name, but in JSON, the last key with the same name is the one that is going to be used.

In your case, the key "name" would be better to contain an array as it's value, instead of having a number of keys "name". It doesn't make much sense the same object or "thing" to have two names, or two of the same properties that are in conflict.

E.g.:

{
  "name" : [ "JOHN", "JACK", "...", ... ]
}

You can use reduce() and concat() methods for this.

const data = [{"meine_frage":"hier kommt die antwort","ne_andere_frage":"ne andere antwort","was_willst_du":"alles","mehr_zur_auswahl":["einiges","vieles und","gär nix"]},{"meine_frage":"tom & jerry","ne_andere_frage":"mickey maus","was_willst_du":"oder","mehr_zur_auswahl":["manches","einiges","vieles und","gär nix"]},{"meine_frage":"dick und doof","ne_andere_frage":"minnie muas","was_willst_du":"nichts","mehr_zur_auswahl":["gär nix"]}]

// Use the `reduce` method to accumulate results into a single object.
const result = data.reduce(function(r, e) {
  // Iterate over each key in the current object.
  return Object.keys(e).forEach(function(k) {
    // Check if the key exists in the result object.
    if(!r[k]) r[k] = [].concat(e[k]) // If the key doesn't exist, initialize it as an array containing the value from the current object.       
    else r[k] = r[k].concat(e[k]) // If the key does exist, concatenate the existing array with the value from the current object.
  }), r // Return the updated result object for the next iteration.
}, {}) // Start with an empty object `{}` as the initial value of `result`.

console.log(result)

{ "dates & times":
    {
        "dates": [ "date01", "date02", "date03" ],
        "times": [ "150", "165", "180" ]
    }
}

No, don't do that. You take an explicit relationship in one data structure and make it implicit between two data structures. Instead, do:

{ "dates & times": [
    { "date": "2014-08-24", "time": "150" },
    { "date": "2014-08-24", "time": "165" },
    { "date": "2014-08-24", "time": "180" },
] }

Now the relationship is explicit, and you can iterate over the array more simply and safely than iterating over the keys. (Safely because, if a property is added to Object.prototype, it will show up as a key.)

for (var key in myObj){
    if (key == selUser){
        for (var date in myObj[key]["dates & times"]){
            console.log("Date: " + date + "; " + "weight: " + myObj[key]["dates & times"][date]);
            var dtTag = "<dt class=\"date\"><span>Date: </span>" + date + " </dt>";
            var ddTag = "<dd class=\"value\"><span>Time: </span>" + myObj[key]["dates & times"][date] + "</dd>";
            output.innerHTML += dtTag;
            output.innerHTML += ddTag;
        }
    } // if 
} // loop

This has a bit more going on than is totally necessary. The outer loop is superfluous, since we only actually do something for one key. The inner loop changes with our new data structure. Also, we can do a bit of reorganization to help performance a bit. We will also change the if statement into a guard clause to clarify the code path.

// Is this key in the object, and does it have the right property?
if(!myObj[selUser] || !myObj[selUser]["dates & times"]) { // return, throw error, whatever }

output.innerHTML += myObj[selUser]["dates & times"].map(function(el){
    console.log("Date: " + el.date + "; Time: " + el.time);
    var dtTag = "<dt class=\"date\"><span>Date: </span>" + el.date + "</dt>";
    var ddTag = "<dd class=\"value\"><span>Time: </span>" + el.time + "</dd>";

    return dtTag + ddTag;
}).join("");

This relies on a newer ES5 feature, so polyfill or replace with equivalent loops if you need to support older browsers (see below). Also, this code does not exactly give the output you specified, FYI.

Without Array#map:

// Is this key in the object, and does it have the right property?
if(!myObj[selUser] || !myObj[selUser]["dates & times"]) { // return, throw error, whatever }

var i, el, dtTag, ddTag;

var listItems = [];
var datesAndTimes = myObj[selUser]["dates & times"];
var datesAndTimesLength = datesAndTimes.length;

for(i = 0; i < datesAndTimesLength; i++) {
    el = datesAndTimes[i];
    console.log("Date: " + el.date + "; Time: " + el.time);
    dtTag = "<dt class=\"date\"><span>Date: </span>" + el.date + "</dt>";
    ddTag = "<dd class=\"value\"><span>Time: </span>" + el.time + "</dd>";

    listItems.push(dtTag + ddTag);
}

output.innerHTML += listItems.join("");

Multiplying two objects together will merge them. The following uses reduce to successively build up a new object by merging the existing objects one by one.

Two similar ways to do this:

1. Using -n and inputs with reduce:

   jq -n 'reduce inputs as $item ({}; . *= $item)' file
   

   This uses the inputs function, which returns the incoming objects one by one. This is combined with -n (--null-input) to disable the ordinary reading of inputs.

2. Using -s and .[] with reduce:

   jq -s 'reduce .[] as $item ({}; . *= $item)' file
   

   This reads the original data with -s (--slurp) into an array, and reduce is used to iterate over that array. Note that this is severely memory-inefficient and slow if the input is huge.

The result, given your data (and correcting it by removing a comma on the createat line):

{
  "daisy": {
    "dev": {
      "app_url": "example.com",
      "owner": "bob",
      "createat": "2022-06-17T15:31:58Z",
      "appname": "daisy",
      "flavor": [
        "nodejs"
      ],
      "file": "manifests/daisy.yml"
    }
  }
}

Note that if two or more objects share the same key and if that key refers to a scalar or array, then the later objects in the input will overwrite the value.

You can use map like this :

EDIT

For handling generic keys you can use Object.keys(d)[0] for first key Object.keys(d)[1] for second key

var sample = [

     {
      "label":"one",
      "value":1
     },

     {
      "label":"two",
      "value":2
     },
     {
      "label":"three",
      "value":3
     },
     { 
      "label":"four",
      "value":4
     },
     { 
      "label":"five",
      "value":5
      }

     ];
    var data = sample.map(function(d){
     return {label: Object.keys(d)[0], value: Object.keys(d)[1], newKeyValue:  Object.keys(d)[0] +"|" + Object.keys(d)[1]}
    }) 
    console.log(data)

Hope this helps!

This is a job for .reduce().

const objArr = [
  {name: 'Andrew', city: 'London'},
  {name: 'Edouard', city: 'Paris'},
  {name: 'Nathalie', city: 'London'},
  {name: 'Patrick', city: 'London'},
  {name: 'Mathieu', city: 'Paris'}
];

// Object of arrays
const result = objArr.reduce((acc, obj) => {
  return {...acc, [obj.city]: [...acc[obj.city] || [], obj]}
}, {})

// Array of arrays
const result2 = Object.values(result);

console.log(result2)

You can do:

const data = {data: [{name: 'A',description: {location: 'location1',floor: 'floor1',},},{name: 'A',description: {location: 'location2',floor: 'floor1',},},{name: 'B',description: {location: 'location3',floor: 'floor3',},},],}

const result = {
  data: data.data.reduce((a, { name, description }) => {
    const index = a.findIndex((d) => d.name === name)
    if (index >= 0) {
      let location = a[index].description.location
      location = Array.isArray(location) ? location : [location]
      a[index].description.location = [...location, description.location]
    } else {
      a.push({ name, description })
    }
    return a
  }, []),
}

console.log(result)

Use arrays:

{
    "number": ["1", "2", "3"],
    "alphabet": ["a", "b", "c"]
}

You can the access the different values from their position in the array. Counting starts at left of array at 0. myJsonObject["number"][0] == 1 or myJsonObject["alphabet"][2] == 'c'

Nope. In JSON all keys must be strings. The best you could do is:

{
  "key1,key2,key3": "valueA",
  "key4,key5,key6": "valueB"
}

(Or some other delimiter in place of ,.)

But then, of course, you'll need to do some processing after decoding the JSON to split them back up into multiple keys.

However, if your concern is with the cost of sending the data over HTTP, then just make sure your server has gzip compression enabled. It will do a great job of compressing those repeated values.

You can use getter method for this,

const obj = {
    key_a : [1, 2, 3, 4, 5],
    key_b : [2, 8, 4, 0, 9, 5],
    get key_c() { return this.key_a; }
}

Now if you console.log obj.key_c you will get the value of obj.key_a. So, now if you update key_a you don't have to update key_c as it is a getter. Whenever you try to get obj.key_c it will give you the latest obj.key_a.

You can use first Array.reduce() to group the companies by the module key on a Set. On a second step you can use array.Map() over the generated object .entries() to get the final desired result:

const data = [
   {module: "credit_cards", id: "1", company: "ABC", prod: "1"}, 
   {module: "credit_cards", id: "2", company: "XYZ", prod: "2"}, 
   {module: "credit_cards", id: "3", company: "EFG", prod: "2"}, 
   {module: "credit_cards", id: "2", company: "XYZ", prod: "2"}, 
   {module: "mortgages", id: "4", company: "EFG", prod: "3"}
];

let res = data.reduce((acc, {module, company}) =>
{
    acc[module] = acc[module] || new Set();
    acc[module].add(company);
    return acc;
}, {})

res = Object.entries(res).map(
    ([module, companies]) => ({module, company: [...companies]})
);

console.log(res);

.as-console {background-color:black !important; color:lime;}
.as-console-wrapper {max-height:100% !important; top:0;}

You need to use JSON.deserialiseUntyped and get the values from it:

Map<String,Object> jsonMap = (Map<String,Object>)JSON.deserializeUntyped('{"AccountId":"00128000009j45sAAA","email":"email1, email2, email3"}');
List<String> emailList = ((String)jsonMap.get('email')).split(',');
List<Contact> cons = new List<Contact>();
String accId = (String)jsonMap.get('AccountId');

for(String em : emailList) {
    cons.add(new Contact(AccountId=accId, Email=em.trim()));
}

System.debug('cons => '+cons);

Note: 0014000001aasdfAA mentioned in your JSON is not a valid Id. You need to check that.