需要指导将excel修改为JSON javascript代码，以便为每组数据输出一个JSON

我没有编程背景，但我有一个要求，我需要能够将excel数据转换为JSON格式

我已经找到了下面的包，这正是我所需要的，因为我可以从标题名而不是每个字段的硬代码控制对象类型。它还允许我对数据进行列定向，即A列中的标题

该软件包可以在此处找到-->

输出如下所示：

 [
  {
    "firstName": "Jihad",
    "lastName": "",
    "address": {
      "street": "12 Beaver Court",
      "city": "",
      "state": "CO",
      "zip": "81615"
    },
    "isEmployee": true,
    "phones": [
      {
        "type": "home",
        "number": "123.456.7890"
      },
      {
        "type": "work",
        "number": "098.765.4321"
      }
    ],
    "aliases": [
      "stormagedden",
      "bob"
    ]
  },
  {
    "firstName": "Marcus",
    "lastName": "Rivapoli",
    "address": {
      "street": "16 Vail Rd",
      "city": "Vail",
      "state": "CO",
      "zip": "75850"
    },
    "isEmployee": false,
    "phones": [
      {
        "type": "home",
        "number": "123.456.7891"
      },
      {
        "type": "work",
        "number": "098.765.4322"
      }
    ],
    "aliases": [
      "mac",
      "markie"
    ]
  }
]

我需要做的和我正在挣扎的有两个方面：

我需要删除生成的JSON开头和结尾的方括号

我需要能够为每列数据生成多个JSON，即一个JSON。因此，如果我在B列和C列中有数据，我需要它生成两个不同名称的JSON文件（理想情况下使用特定属性值的名称）

代码是：

// Generated by CoffeeScript 2.2.4
(function() {
  // Create a list of json objects; 1 object per excel sheet row

  // Assume: Excel spreadsheet is a rectangle of data, where the first row is
  // object keys and remaining rows are object values and the desired json 
  // is a list of objects. Alternatively, data may be column oriented with
  // col 0 containing key names.

  // Dotted notation: Key row (0) containing firstName, lastName, address.street, 
  // address.city, address.state, address.zip would produce, per row, a doc with 
  // first and last names and an embedded doc named address, with the address.

  // Arrays: may be indexed (phones[0].number) or flat (aliases[]). Indexed
  // arrays imply a list of objects. Flat arrays imply a semicolon delimited list.

  // USE:
  //  From a shell
  //    coffee src/excel-as-json.coffee

  var BOOLTEXT, BOOLVALS, _DEFAULT_OPTIONS, _validateOptions, assign, convert, convertValue, convertValueList, excel, fs, isArray, parseKeyName, path, processFile, transpose, write,
    indexOf = [].indexOf;

  fs = require('fs');

  path = require('path');

  excel = require('excel');

  BOOLTEXT = ['true', 'false'];

  BOOLVALS = {
    'true': true,
    'false': false
  };

  isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  };

  // Extract key name and array index from names[1] or names[]
  // return [keyIsList, keyName, index]
  // for names[1] return [true,  keyName,  index]
  // for names[]  return [true,  keyName,  undefined]
  // for names    return [false, keyName,  undefined]
  parseKeyName = function(key) {
    var index;
    index = key.match(/\[(\d+)\]$/);
    switch (false) {
      case !index:
        return [true, key.split('[')[0], Number(index[1])];
      case key.slice(-2) !== '[]':
        return [true, key.slice(0, -2), void 0];
      default:
        return [false, key, void 0];
    }
  };

  // Convert a list of values to a list of more native forms
  convertValueList = function(list, options) {
    var item, j, len, results;
    results = [];
    for (j = 0, len = list.length; j < len; j++) {
      item = list[j];
      results.push(convertValue(item, options));
    }
    return results;
  };

  // Convert values to native types
  // Note: all values from the excel module are text
  convertValue = function(value, options) {
    var testVal;
    // isFinite returns true for empty or blank strings, check for those first
    if (value.length === 0 || !/\S/.test(value)) {
      return value;
    } else if (isFinite(value)) {
      if (options.convertTextToNumber) {
        return Number(value);
      } else {
        return value;
      }
    } else {
      testVal = value.toLowerCase();
      if (indexOf.call(BOOLTEXT, testVal) >= 0) {
        return BOOLVALS[testVal];
      } else {
        return value;
      }
    }
  };

  // Assign a value to a dotted property key - set values on sub-objects
  assign = function(obj, key, value, options) {
    var i, index, j, keyIsList, keyName, ref, ref1;
    if (typeof key !== 'object') {
      // On first call, a key is a string. Recursed calls, a key is an array
      key = key.split('.');
    }
    // Array element accessors look like phones[0].type or aliases[]
    [keyIsList, keyName, index] = parseKeyName(key.shift());
    if (key.length) {
      if (keyIsList) {
        // if our object is already an array, ensure an object exists for this index
        if (isArray(obj[keyName])) {
          if (!obj[keyName][index]) {
            for (i = j = ref = obj[keyName].length, ref1 = index; (ref <= ref1 ? j <= ref1 : j >= ref1); i = ref <= ref1 ? ++j : --j) {
              obj[keyName].push({});
            }
          }
        } else {
          // else set this value to an array large enough to contain this index
          obj[keyName] = (function() {
            var k, ref2, results;
            results = [];
            for (i = k = 0, ref2 = index; (0 <= ref2 ? k <= ref2 : k >= ref2); i = 0 <= ref2 ? ++k : --k) {
              results.push({});
            }
            return results;
          })();
        }
        return assign(obj[keyName][index], key, value, options);
      } else {
        if (obj[keyName] == null) {
          obj[keyName] = {};
        }
        return assign(obj[keyName], key, value, options);
      }
    } else {
      if (keyIsList && (index != null)) {
        console.error(`WARNING: Unexpected key path terminal containing an indexed list for <${keyName}>`);
        console.error("WARNING: Indexed arrays indicate a list of objects and should not be the last element in a key path");
        console.error("WARNING: The last element of a key path should be a key name or flat array. E.g. alias, aliases[]");
      }
      if (keyIsList && (index == null)) {
        if (value !== '') {
          return obj[keyName] = convertValueList(value.split(';'), options);
        } else if (!options.omitEmptyFields) {
          return obj[keyName] = [];
        }
      } else {
        if (!(options.omitEmptyFields && value === '')) {
          return obj[keyName] = convertValue(value, options);
        }
      }
    }
  };

  // Transpose a 2D array
  transpose = function(matrix) {
    var i, j, ref, results, t;
    results = [];
    for (i = j = 0, ref = matrix[0].length; (0 <= ref ? j < ref : j > ref); i = 0 <= ref ? ++j : --j) {
      results.push((function() {
        var k, len, results1;
        results1 = [];
        for (k = 0, len = matrix.length; k < len; k++) {
          t = matrix[k];
          results1.push(t[i]);
        }
        return results1;
      })());
    }
    return results;
  };

  // Convert 2D array to nested objects. If row oriented data, row 0 is dotted key names.
  // Column oriented data is transposed
  convert = function(data, options) {
    var index, item, j, k, keys, len, len1, result, row, rows, value;
    if (options.isColOriented) {
      data = transpose(data);
    }
    keys = data[0];
    rows = data.slice(1);
    result = [];
    for (j = 0, len = rows.length; j < len; j++) {
      row = rows[j];
      item = [];
      for (index = k = 0, len1 = row.length; k < len1; index = ++k) {
        value = row[index];
        assign(item, keys[index], value, options);
      }
      result.push(item);
    }
    return result;
  };

  // Write JSON encoded data to file
  // call back is callback(err)
  write = function(data, dst, callback) {
    var dir;
    // Create the target directory if it does not exist
    dir = path.dirname(dst);
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir);
    }
    return fs.writeFile(dst, JSON.stringify(data, null, 2), function(err) {
      if (err) {
        return callback(`Error writing file ${dst}: ${err}`);
      } else {
        return callback(void 0);
      }
    });
  };

  // src: xlsx file that we will read sheet 0 of
  // dst: file path to write json to. If null, simply return the result
  // options: see below
  // callback(err, data): callback for completion notification

  // options:
  //   sheet:              string;  1:     numeric, 1-based index of target sheet
  //   isColOriented:      boolean: false; are objects stored in excel columns; key names in col A
  //   omitEmptyFields:    boolean: false: do not include keys with empty values in json output. empty values are stored as ''
  //                                       TODO: this is probably better named omitKeysWithEmptyValues
  //   convertTextToNumber boolean: true;  if text looks like a number, convert it to a number

  // convertExcel(src, dst) <br/>
  //   will write a row oriented xlsx sheet 1 to `dst` as JSON with no notification
  // convertExcel(src, dst, {isColOriented: true}) <br/>
  //   will write a col oriented xlsx sheet 1 to file with no notification
  // convertExcel(src, dst, {isColOriented: true}, callback) <br/>
  //   will write a col oriented xlsx to file and notify with errors and parsed data
  // convertExcel(src, null, null, callback) <br/>
  //   will parse a row oriented xslx using default options and return errors and the parsed data in the callback

  _DEFAULT_OPTIONS = {
    sheet: '1',
    isColOriented: false,
    omitEmptyFields: false,
    convertTextToNumber: false
  };

  // Ensure options sane, provide defaults as appropriate
  _validateOptions = function(options) {
    if (!options) {
      options = _DEFAULT_OPTIONS;
    } else {
      if (!options.hasOwnProperty('sheet')) {
        options.sheet = '1';
      } else {
        if (!isNaN(parseFloat(options.sheet)) && isFinite(options.sheet)) {
          if (options.sheet < 1) {
            options.sheet = '1';
          } else {
            // could be 3 or '3'; force to be '3'
            options.sheet = '' + options.sheet;
          }
        } else {
          // something bizarre like true, [Function: isNaN], etc
          options.sheet = '1';
        }
      }
      if (!options.hasOwnProperty('isColOriented')) {
        options.isColOriented = false;
      }
      if (!options.hasOwnProperty('omitEmptyFields')) {
        options.omitEmptyFields = false;
      }
      if (!options.hasOwnProperty('convertTextToNumber')) {
        options.convertTextToNumber = false;
      }
    }
    return options;
  };

  processFile = function(src, dst, options = _DEFAULT_OPTIONS, callback = void 0) {
    options = _validateOptions(options);
    if (!callback) {
      callback = function(err, data) {};
    }
    // NOTE: 'excel' does not properly bubble file not found and prints
    //       an ugly error we can't trap, so look for this common error first
    if (!fs.existsSync(src)) {
      return callback(`Cannot find src file ${src}`);
    } else {
      return excel(src, options.sheet, function(err, data) {
        var result;
        if (err) {
          return callback(`Error reading ${src}: ${err}`);
        } else {
          result = convert(data, options);
          if (dst) {
            return write(result, dst, function(err) {
              if (err) {
                return callback(err);
              } else {
                return callback(void 0, result);
              }
            });
          } else {
            return callback(void 0, result);
          }
        }
      });
    }
  };

  // This is the single expected module entry point
  exports.processFile = processFile;

  // Unsupported use
  // Exposing remaining functionality for unexpected use cases, testing, etc.
  exports.assign = assign;

  exports.convert = convert;

  exports.convertValue = convertValue;

  exports.parseKeyName = parseKeyName;

  exports._validateOptions = _validateOptions;

  exports.transpose = transpose;

}).call(this);

//由CoffeeScript 2.2.4生成
（功能（）{
//创建json对象列表；每个excel工作表行1个对象
//假设：Excel电子表格是一个矩形数据，其中第一行是
//对象键和剩余行是对象值和所需的json
//是对象列表。或者，数据可以使用
//包含键名称的列0。
//虚线表示法：包含firstName、lastName、address.street、，
//address.city、address.state、address.zip将在每行生成一个带有
//名字和姓氏以及名为address的嵌入式文档，以及地址。
//数组：可以索引（电话[0].number）或平面（别名[]）。索引
//数组表示对象列表。平面数组表示分号分隔的列表。
//使用：
//脱壳
//coffee src/excel-as-json.coffee
var BOOLTEXT、BOOLVALS、默认选项、验证选项、赋值、转换、convertValue、convertValueList、excel、fs、isArray、parseKeyName、路径、进程文件、转置、写入、，
indexOf=[].indexOf；
fs=要求（'fs'）；
路径=要求（“路径”）；
excel=需要（'excel'）；
BOOLTEXT=['true'，'false']；
布尔瓦尔={
"真":真,，
“假”：假
};
isArray=功能（obj）{
返回Object.prototype.toString.call（obj）='[objectarray]'；
};
//从名称[1]或名称[]中提取关键字名称和数组索引
//return[关键字列表、关键字名称、索引]
//对于名称[1]，返回[true，keyName，index]
//对于名称[]，返回[true，keyName，未定义]
//for names返回[false，keyName，未定义]
parseKeyName=函数（键）{
var指数；
index=key.match（/\[（\d+）\]$/）；
开关（假）{
案例索引：
返回[true，key.split（'['）[0]，Number（索引[1]）；
大小写键.slice（-2）！='[]'：
return[true，key.slice（0，-2），void 0]；
违约：
返回[false，key，void 0]；
}
};
//将值列表转换为更多本机形式的列表
convertValueList=函数（列表，选项）{
var项目，j，len，结果；
结果=[]；
对于（j=0，len=list.length；j=0）{
返回布尔值[testVal]；
}否则{
返回值；
}
}
};
//将值指定给虚线特性键-设置子对象上的值
分配=功能（对象、键、值、选项）{
变量i，索引，j，键列表，键名，参考，参考1；
if（键的类型！==“对象”）{
//第一次调用时，键是字符串。递归调用时，键是数组
key=key.split（'.'）；
}
//数组元素访问器看起来像电话[0]。键入或别名[]
[keyilist，keyName，index]=parseKeyName（key.shift（））；
if（键长）{
if（keyIsList）{
//如果我们的对象已经是数组，请确保此索引存在一个对象
if（isArray（obj[keyName]））{
如果（！obj[keyName][index]）{
对于（i=j=ref=obj[keyName].length，ref1=index；（ref这是未测试的，但应该可以让您接近

尝试将这样的函数添加到代码中（以及列出的其他函数，如
isArray
，
parseKeyName
，等等）。然后在processFile函数中的
行中，返回write（result，dst，function（err）{
，将
write
替换为
writeEach

请参阅代码中的注释，以了解其意图

writeEach = function(data, dst, callback){
  // Loops through columns, calling fs.writeFile for each one
  data.forEach(function(person){ // argument name determines the name by which we will refer to the current column
    var homePhoneDigits = person.phones[0]["number"].split(".").join(""); //removes `.` from phone number 
    var personDst = homePhoneDigits + ".json"; // uses digits of home phone as destination name

    // pattern copied from 'write' function, with variable names changed
    var dir;
    dir = path.dirname(personDst);
    if (!fs.existsSync(dir)) { fs.mkdirSync(dir); }
    fs.writeFile(personDst, JSON.stringify(person, null, 2); //writes the current column to a file

  });
  return callback(void 0); // currently ignores any write errors
};

“从生成的JSON的开头和结尾删除方括号”是什么意思？因此，如果您注意到上面的输出示例，在JSON的开头，有一个方形的开放背景，在结尾，有一个方形的闭合括号。在输出中，我不需要这些内容，并且我无法从代码中找出这些方括号的生成来源。输出是一个JavaScript
Array
representa有效的
JSON
（字符串格式）。如果不打开和关闭数组文字括号，则输出将不是有效的JavaScript数组或有效的
JSON
。您可以迭代普通对象数组，并为数组的每个元素执行任务。请参阅；；当然，我明白这一点，但我尝试做的不是生成数组输出（针对excel中的每个列）正如它目前所做的那样，就是为每一列创建一个单独的JSON。当然，如果能够实现这一点，则表示数组的方括号将不再适用