var list = [
    { date: '12/1/2011', reading: 3, id: 20055 },
    { date: '13/1/2011', reading: 5, id: 20053 },
    { date: '14/1/2011', reading: 6, id: 45652 }
];

and then access it:

alert(list[1].date);

Here is a small example that I think might help you. This creates objs with dynamic names and values and adds them to an array.

var myArray = [];
for (var i = 0; i < 3; i++) {
  var myObj = {};
  for (var x = 0; x < 3; x++) {
    myObj["Field" + x] = "val" + x;
  }
  myArray.push(myObj);
}
console.log(myArray)

Edit after Op's edit

Here is another example after your update. If I understood you then I think you really only need 1 function that is essentially an update to the array. Your JSON was a bit off too I think. In the example below The ID will reference an object that has a fields array where your "list" will be stored.

var myArray = [];
var testObj = {};
testObj.id = 1;
testObj.fields = [];
myArray.push(testObj)

// add myValue to the already existing obj with ID 1
addValue(1, "myValue");
// add myValue2 to the non-existent id 2 obj (it will be dynamically created)
addValue(2, "myValue2");

function addValue(id, val){
  var foundID = false;
  myArray.forEach(function(obj){
   if(obj.id === id){
     var newObj = {};
     newObj["Field" + id] = val;
     obj.fields.push(newObj);
     foundID = true;
   }
  });
  // if we did not find an obj with the passed in ID
  // then create and initialize it
  if(!foundID){
    var newIDObj = {};
    newIDObj.id = id;
    var fieldsArray = [];
    var newFieldsObj = {};
    newFieldsObj["Field" + id] = val;
    fieldsArray.push(newFieldsObj);
    newIDObj.fields = fieldsArray;
    myArray.push(newIDObj);
  }
}
console.log(myArray);

// How to access a value knowing the ID and the fieldName
var result = getValue(1, "Field1");

// If no result is found, undefined will be returned
// This assumes Field Names are all unique!
function getValue(id, fieldName) {
  var result;
  myArray.forEach(function(currentObj) {
    if (currentObj.id === id) {
      currentObj.fields.forEach(function(currentField) {
        if (typeof currentField[fieldName] !== "undefined") {
          result = currentField[fieldName];
        }
      });
    }
  });
  
  console.log("The value with ID: " + id + " and field name: " + fieldName + " is: " + result)
  return result;
}

You can create an array of random objects and values using the following code below. First, create an array using where 12 is the length and then the object.

const data = Array.from({
    length: 12
}, () => ({
    id: Math.floor(Math.random() * (100 - 1)) + 1,
    name: Math.random().toString(36).substr(2, 10)
}))

console.log(data)

Pretty straight forward approach to creating an array of objects.

var employees = [];

for (var i = 0; i < 10; i++) {
    employees.push({
        Column1: 'column 1 of emp' + i,
        Column2: 'column 1 of emp' + i
    });
}

To create the structure you mention you can write it in JSON like this:

{
  "assignToMap": {
    "123": [1, 2, 3, 4],
    "345": [1, 2, 3, 4],
    "678": [1, 2, 3, 4]
  }
}

Although I'm not entirely sure if that's what you're asking here!

This will depend on your content and how you prepare it, but I'd suggest a very generic solution that'll work for any level of nested points. Now, arbitrary nesting doesn't appear to be required in your case, but, hey, nice to have.

Suppose your JSON content is structured like so:

var points = [
    {title: "Point", children: [
        {title: "Point"},
        {title: "Point"},
        {title: "Point"},
        {title: "Point", children: [
            {title: "Point"},
            {title: "Point"},
            {title: "Point", children: [
              // more...?
            ]}
        ]}
    ]}
]

You'll note that you can just keep nesting the points indefinitely.

To render this as HTML, you can use a recursive function. Like this:

function buildList(parentElement, items) {
    var i, l, list, li;
    if( !items || !items.length ) { return; } // return here if there are no items to render
    list = $("<ul></ul>").appendTo(parentElement); // create a list element within the parent element
    for(i = 0, l = items.length ; i < l ; i++) {
        li = $("<li></li>").text(items[i].title);  // make a list item element
        buildList(li, items[i].children);          // add its subpoints
        list.append(li);
    }
}

And call it like so:

buildList($("#pageContent").empty(), points);

The point is that since the structure is recursive, it can nest to any depth, but the code is simpler.

Here's a jsfiddle. This is quite a different approach, and Daniel Cook's answer is probably more immediately applicable to you current code, but I thought it worth to point out.

You could also extend it to add the "1", "1.1", "1.2" (and so on) numbers to the titles.

If you only need a flat array (i.e. not multi-dimensional and no arrays within the array), then you can do the following in plain JavaScript:

var strs = [ "String 1", "String 2", "String 3" ];
var list = document.createElement("ul");
for (var i in strs) {
  var anchor = document.createElement("a");
  anchor.href = "#";
  anchor.innerText = strs[i];

  var elem = document.createElement("li");
  elem.appendChild(anchor);
  list.appendChild(elem);
}

Then append list to whichever parent element in the body you desire.

var arr = ["list", "items", "here"];
$("div").append("<ul></ul>");
for(var i in arr) {
    var li = "<li>";
    $("ul").append(li.concat(arr[i]))
}

I recommend putting the script at the end of the page, just before </body> The reason is that you'll want to have scripts run when the DOM is ready (i.e. all the elements are present and ready for JS manipulation).

<center> is a deprecated stylistic element. To center an element, set left and right margins to auto. For text, use text-align: center:

.centered-element {
  display: block;
  width: 250px; /* Your desired width */
  margin-left: auto;
  margin-right: auto;
}

.element-with-centered-text {
  text-align: center;
}

This way, you have separation of concerns. HTML deals with describing the structure, CSS deals with styling your HTML.

* {
    font-family: "Times New Roman", Times, serif;
}

This is unnecessary. Applying font-family to body should be enough to apply it to all elements. Font style is inherited by all descendants until an element overrides it (and styles its own descendants).

fieldset {...}

input[type=text] {...}

button {...}

ul {..}

li {...}

I don't recommend styling elements directly because it breaks expectations. If I add a <ul> in your app for whatever purpose, I expect it to have bullets. But since your CSS removes them, my list won't have bullets. I'd have to add them back when, by default, they should have had bullets.

Instead, use classes to target app-specific styling and leave element defaults alone. The only time I would style an element directly is if it's part of a globally-applied theme or a normalizer.

As for your JavaScript, you could abstract away your element creation with a function like the following. This way, you don't have to repeat element creation scripts everywhere and you can easily describe dynamic HTML in a nested manner, like HTML.

const e = (name, properties = {}, children = []) => {
  // Create the element
  const element = document.createElement(name)

  // Apply properties
  Object.keys(properties).forEach(property => {
    element.setAttribute(property, propertyes[property])
  })

  // Append children
  children.forEach(c => {
    if(!c) return
    const node = (typeof c === 'string') ? document.createTextNode(c) : c
    element.appendChild(node)
  })

  return element
}

// Usage
const root = e('div', {}, [
  e('p', {}, [
    e('span', {}, [
      'Hello, World!',
      'Lorem Ipsum'
    ])
  ])
])

root.appendChild(e('span', {}, ['another piece of text']))

If the syntax looks familiar, it's because this is the basic premise of how most VDOM libraries work under the hood. They're just nested calls of functions that either return an actual element, or objects that represent elements (which are turned to elements later).

From there, you can describe and build your "components" like:

const LoadForm = () => {
  e('div', {}, [
    e('input', { type: 'text', name: 'user_input', placeholder: 'Enter here...' }),
    e('br'),
    e('button', { name: 'add_list' }, ['Add To List']),
    e('button', { name: 'remove_list' }, ['Remove From List']),
  ])

document.getElementById('in').appendChild(LoadForm())

You can even encapsulate this in a class if you want so that you can also add some helper methods.

class LoadForm {
  onAdd () {
    // Do something on add
  }
  onRemove () {
    // Do something on remove
  }
  render() {
    return (
      e('div', {}, [
        e('input', { type: 'text', name: 'user_input', placeholder: 'Enter here...' }),
        e('br'),
        e('button', { name: 'add_list', onclick: this.onAdd }, [
          'Add To List'
        ]),
        e('button', { name: 'remove_list', onclick: this.onRemove }, [
          'Remove From List'
        ]),
      ])
    )
  }
}

document.getElementById('in').appendChild((new LoadForm()).render())

Lastly, JavaScript is written in camelCase, not snake_case.

You have to instantiate the object first. The simplest way is:

var lab =["1","2","3"];
var val = [42,55,51,22];
var data = [];
for(var i=0; i<4; i++)  {
    data.push({label: lab[i], value: val[i]});
}

Or an other, less concise way, but closer to your original code:

for(var i=0; i<4; i++)  {
   data[i] = {};              // creates a new object
   data[i].label = lab[i];
   data[i].value = val[i];    
}

array() will not create a new array (unless you defined that function). Either Array() or new Array() or just [].

I recommend to read the MDN JavaScript Guide.

Your code is valid as well, but it creates an object. If you want to use an actual array, it could look like this:

var result = [
         {'key1' : value1, 'key2' : value2 },
         {'key3' : value3, 'key4' : value4 }
    ];

Note the change from {} to [] for the outer brackets and the drop of the top-level keys.

Edit

To create such an array dynamically, you can use something like this:

var result = []; // init empty array

result.push( {'key1' : value1, 'key2' : value2 } ); // insert a value

for( var i=0; i<10; i++ ) {
  result.push( {'key1' : i, 'key2' : i } ); // insert some more values in a loop
}