If you want to create an array of JSON objects, you can follow this approach:

const data = new Array(
  { 'a1': 'a2' },
  { 'b1': 'b2' },
  { 'c1': 'c2' }
);

console.log( data[0] );

You should see the following result in the console:

{
a1: "a2"
}

I hope this information is useful to you.

Comments have highlighted the fact that your input JSON format deviates from standard JSON requirements, necessitating a custom parsing solution. Below is an excerpt hastily adapted from Haxe's haxe.format.JsonParser:

var Std = function() { };
Std.parseInt = function(x) {
    if(x != null) {
        var _g = 0;
        var _g1 = x.length;
        while(_g < _g1) {
            var i = _g++;
            var c = x.charCodeAt(i);
            if(c <= 8 || c >= 14 && c != 32 && c != 45) {
                var nc = x.charCodeAt(i + 1);
                var v = parseInt(x,nc == 120 || nc == 88 ? 16 : 10);
                if(isNaN(v)) {
                    return null;
                } else {
                    return v;
                }
            }
        }
    }
    return null;
};
var StringBuf = function() {
    this.b = "";
};
var JsonParser = function(str) {
    this.str = str;
    this.pos = 0;
};
JsonParser.prototype = {
    doParse: function() {
        var result = this.parseRec();
        var c;
        while(true) {
            c = this.str.charCodeAt(this.pos++);
            if(!(c == c)) {
                break;
            }
            switch(c) {
            case 9:case 10:case 13:case 32:
                break;
            default:
                this.invalidChar();
            }
        }
        return result;
    }
    ,parseRec: function() {
        while(true) switch(this.str.charCodeAt(this.pos++)) {
        case 9:case 10:case 13:case 32:
            break;
        case 34:
            return this.parseString();
        case 123:
            var arr = [];
            var comma = null;
            while(true) switch(this.str.charCodeAt(this.pos++)) {
            case 9:case 10:case 13:case 32:
                break;
            case 44:
                if(comma) {
                    comma = false;
                } else {
                    this.invalidChar();
                }
                break;
            case 125:
                if(comma == false) {
                    this.invalidChar();
                }
                return arr;
            default:
                if(comma) {
                    this.invalidChar();
                }
                this.pos--;
                arr.push(this.parseRec());
                comma = true;
            }
            break;
        default:
            this.invalidChar();
        }
    }
    ,parseString: function() {
        var start = this.pos;
        var buf = null;
        var prev = -1;
        while(true) {
            var c = this.str.charCodeAt(this.pos++);
            if(c == 34) {
                break;
            }
            if(c == 92) {
                if(buf == null) {
                    buf = new StringBuf();
                }
                var s = this.str;
                var len = this.pos - start - 1;
                buf.b += len == null ? s.substr(start) : s.substr(start,len);
                c = this.str.charCodeAt(this.pos++);
                if(c != 117 && prev != -1) {
                    buf.b += String.fromCodePoint(65533);
                    prev = -1;
                }
                switch(c) {
                case 34:case 47:case 92:
                    buf.b += String.fromCodePoint(c);
                    break;
                case 98:
                    buf.b += String.fromCodePoint(8);
                    break;
                case 102:
                    buf.b += String.fromCodePoint(12);
                    break;
                case 110:
                    buf.b += String.fromCodePoint(10);
                    break;
                case 114:
                    buf.b += String.fromCodePoint(13);
                    break;
                case 116:
                    buf.b += String.fromCodePoint(9);
                    break;
                case 117:
                    var uc = Std.parseInt("0x" + this.str.substr(this.pos,4));
                    this.pos += 4;
                    if(prev != -1) {
                        if(uc < 56320 || uc > 57343) {
                            buf.b += String.fromCodePoint(65533);
                            prev = -1;
                        } else {
                            buf.b += String.fromCodePoint(((prev - 55296 << 10) + (uc - 56320) + 65536));
                            prev = -1;
                        }
                    } else if(uc >= 55296 && uc <= 56319) {
                        prev = uc;
                    } else {
                        buf.b += String.fromCodePoint(uc);
                    }
                    break;
                default:
                    throw new ("Invalid escape sequence \\" + String.fromCodePoint(c) + " at position " + (this.pos - 1));
                }
                start = this.pos;
            } else if(c != c) {
                throw new ("Unclosed string");
            }
        }
        if(prev != -1) {
            buf.b += String.fromCodePoint(65533);
            prev = -1;
        }
        if(buf == null) {
            return this.str.substr(start,this.pos - start - 1);
        } else {
            var s1 = this.str;
            var len1 = this.pos - start - 1;
            buf.b += len1 == null ? s1.substr(start) : s1.substr(start,len1);
            return buf.b;
        }
    }
    ,invalidChar: function() {
        this.pos--;
        throw "Invalid char " + this.str.charCodeAt(this.pos) + " at position " + this.pos;
    }
};
JsonParser.parse = function(s) {
    return new JsonParser(s).doParse();
}

If you receive this information from someone, it is important to kindly let them know that the data provided is not valid.

I prefer not having to work with faulty data. Let's address the issue at its source rather than finding ways to work around it repeatedly.