An efficient method for converting JSON to CSV involves utilizing the map function without relying on any external framework:

var json = json3.items
var fields = Object.keys(json[0])
var replacer = function(key, value) { return value === null ? '' : value } 
var csv = json.map(function(row){
  return fields.map(function(fieldName){
    return JSON.stringify(row[fieldName], replacer)
  }).join(',')
})
csv.unshift(fields.join(',')) // add header column
 csv = csv.join('\r\n');
console.log(csv)

Output:

title,description,link,timestamp,image,embed,language,user,user_image,user_link,user_id,geo,source,favicon,type,domain,id
"Apple iPhone 4S Sale Cancelled in Beijing Amid Chaos (Design You Trust)","Advertise here with BSA Apple cancelled its scheduled sale of iPhone 4S in one of its stores in China’s capital Beijing on January 13. Crowds outside the store in the Sanlitun district were waiting on queues overnight. There were incidents of scuffle between shoppers and the store’s security staff when shoppers, hundreds of them, were told that the sales [...]Source : Design You TrustExplore : iPhone, iPhone 4, Phone","http://wik.io/info/US/309201303","1326439500","","","","","","","","","wikio","http://wikio.com/favicon.ico","blogs","wik.io","2388575404943858468"
"Apple to halt sales of iPhone 4S in China (Fame Dubai Blog)","SHANGHAI – Apple Inc said on Friday it will stop selling its latest iPhone in its retail stores in Beijing and Shanghai to ensure the safety of its customers and employees. Go to SourceSource : Fame Dubai BlogExplore : iPhone, iPhone 4, Phone","http://wik.io/info/US/309198933","1326439320","","","","","","","","","wikio","http://wikio.com/favicon.ico","blogs","wik.io","16209851193593872066"

Update ES6 (2016)

This concise syntax enhances readability while ensuring strict data formatting by using JSON.stringify to properly quote strings but leave numbers unquoted:

const items = json3.items
const replacer = (key, value) => value === null ? '' : value // specify how you want to handle null values here
const header = Object.keys(items[0])
const csv = [
  header.join(','), // include header row as the first entry
  ...items.map(row => header.map(fieldName => JSON.stringify(row[fieldName], replacer)).join(','))
].join('\r\n')

console.log(csv)

Great solution provided by praneybehl, for those interested in saving data as a csv file using the blob method, here's a helpful guide:

function ConvertJSONToCSV(JSONData, Title, DisplayLabel) {

    //If JSONData is not an object, parse it into an Object
    var dataArray = typeof JSONData != 'object' ? JSON.parse(JSONData) : JSONData;
    var CSV = '';
    
    //Generating the Label/Header
    if (DisplayLabel) {
        var labelRow = "";
        
        //Extracting labels from the first index of the array
        for (var i in dataArray[0]) {
            //Converting each value to string and comma-separated
            labelRow += i + ',';
        }
        labelRow = labelRow.slice(0, -1);
        //Appending Label row with line break
        CSV += labelRow + '\r\n';
    }
    
    //Loop to extract each row
    for (var j = 0; j < dataArray.length; j++) {
        var dataRow = "";
        
        //Loop to extract each column and convert it to a comma-separated string
        for (var k in dataArray[j]) {
            dataRow += '"' + dataArray[j][k] + '",';
        }
        dataRow.slice(0, dataRow.length - 1);
        //Adding a line break after each row
        CSV += dataRow + '\r\n';
    }
    
    if (CSV == '') {
        alert("Invalid data");
        return;
    }

    //Creating a temporary "a" tag
    var link = document.createElement("a");
    link.id = "downloadLink";
    
    //Appending the anchor tag and removing it after automatic click
    document.body.appendChild(link);

    var csvData = CSV;
    blobData = new Blob([csvData], { type: 'text/csv' });
    var csvUrl = window.webkitURL.createObjectURL(blobData);
    var fileName = (Title || 'ExportedData') + '.csv';
    $("#downloadLink")
        .attr({
            'download': fileName,
            'href': csvUrl
        });

    $('#downloadLink')[0].click();
    document.body.removeChild(link);
}

If you're looking to easily convert an array of JSON objects into a CSV file for downloading, check out this handy function below:

convertJSONtoCSV = (filename, arrayOfJson) => {
  // Convert JSON to CSV
  const replacer = (key, value) => value === null ? '' : value;
  const header = Object.keys(arrayOfJson[0]);
  let csv = arrayOfJson.map(row => header.map(fieldName => 
    JSON.stringify(row[fieldName], replacer)).join(','));
  csv.unshift(header.join(','));
  csv = csv.join('\r\n');

  // Create link and trigger download
  var link = document.createElement('a');
  link.setAttribute('href', 'data:text/csv;charset=utf-8,%EF%BB%BF' + encodeURIComponent(csv));
  link.setAttribute('download', filename);
  link.style.visibility = 'hidden';
  document.body.appendChild(link);
  link.click();
  document.body.removeChild(link);
};

To use this function, simply call it like so:

this.convertJSONtoCSV(`customFileName.csv`, this.state.jsonArray)

For those looking to export JSON data to a CSV file and download it, I wanted to share some helpful code.

If you are working with a basic array, you can skip using $.getJSON to fetch data from an external source.

The following code snippet utilizes Christian Landgren's solution to generate the csv data:

$(document).ready(function() {
    var JSONData = $.getJSON("GetJsonData.php", function(data) {
        var items = data;
        const replacer = (key, value) => value === null ? '' : value; 
        const header = Object.keys(items[0]);
        let csv = items.map(row => header.map(fieldName => JSON.stringify(row[fieldName], replacer)).join(','));
        csv.unshift(header.join(','));
        csv = csv.join('\r\n');

        //Download the file as CSV
        var downloadLink = document.createElement("a");
        var blob = new Blob(["\ufeff", csv]);
        var url = URL.createObjectURL(blob);
        downloadLink.href = url;
        downloadLink.download = "DataDump.csv";  
        document.body.appendChild(downloadLink);
        downloadLink.click();
        document.body.removeChild(downloadLink);
    });
});

Additionally, keep in mind that JSON.stringify may escape quotes by adding \", causing issues in Excel. To resolve this, include .replace(/\\"/g, '""') at the end of

JSON.stringify(row[fieldName], replacer)

Complete line:

let csv = items.map(row => header.map(fieldName => (JSON.stringify(row[fieldName], replacer).replace(/\\"/g, '""'))).join(','));

One of the options available for utilizing existing robust libraries that adhere to standards is by leveraging them effectively.

If you are using D3 in your project, you can easily utilize:

    d3.csv.format or d3.csv.formatRows functions to convert an array of objects into a csv string.

    d3.csv.formatRows gives more flexibility in selecting properties that are converted to csv format.

    For detailed information, please visit d3.csv.format and d3.csv.formatRows wiki pages.

In addition to these, there are other useful libraries like jquery-csv and PapaParse. Papa Parse, in particular, does not rely on any dependencies such as jQuery.

For plugins based on jquery, you can explore more options by visiting this link.

Check out these Examples

Example 1:

JsonArray = [{
    "ID": "001",
    "Name": "John",
    "Role": "Admin",
    "Location": "NYC"

}, {
    "ID": "002",
    "Name": "Jane",
    "Role": "Manager",
    "Location": "LA"
}]

JsonFields = ["ID", "Name", "Role", "Location"]

function JsonToCSV(){
    var csvStr = JsonFields.join(",") + "\n";

    JsonArray.forEach(element => {
        ID = element.ID;
        Name = element.Name;
        Role = element.Role
        Location = element.Location

        csvStr += ID + ',' + Name + ','  + Role + ',' + Location + "\n";
        })
        return csvStr;
}

Example2 :

JsonArray = [{
    "ID": "003",
    "Name": "Mike",
    "Team": [{
        "Role": "Developer",
        "Location": "Seattle"
    },
    {
        "Role": "Designer",
        "Location": "SF"
    }]
}]
  
JsonFields = ["ID", "Name", "Role", "Location"]

function JsonToCSV() {
    var csvStr = JsonFields.join(",") + "\n";

    JsonArray.forEach(element => {
        ID = element.ID;
        Name = element.Name;
        
        element.Team.forEach(teamELe => {
            Role = teamELe.Role
            Location = teamELe.Location
            csvStr += ID + ',' + Name + ',' + Role + ',' + Location + "\n";
        })
    })
    return csvStr;
}

You have the option to download the CSV file using this code :

function downloadCSV(csvStr) {

    var hiddenElement = document.createElement('a');
    hiddenElement.href = 'data:text/csv;charset=utf-8,' + encodeURI(csvStr);
    hiddenElement.target = '_blank';
    hiddenElement.download = 'output.csv';
    hiddenElement.click();
}

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Convert JSON to CSV</title>
    <script src="http://code.jquery.com/jquery-1.7.1.js" type="text/javascript"></script>
</head>
<body>
    <h1>This page serves the purpose of converting JSON data to CSV format.</h1>

    <script type="text/javascript">
        var json3 = {
          "count": 2,
          "items": [{
              "title": "Apple iPhone 4S Sale Cancelled in Beijing Amid Chaos (Design You Trust)",
              "description": "Advertise here with BSA Apple cancelled its scheduled sale of iPhone 4S in one of its stores in China’s capital Beijing on January 13. Crowds outside the store in the Sanlitun district were waiting on queues overnight. There were incidents of scuffle between shoppers and the store’s security staff when shoppers, hundreds of them, were told that the sales [...]Source : Design You TrustExplore : iPhone, iPhone 4, Phone",
              "link": "http://wik.io/info/US/309201303",
              "timestamp": 1326439500,
              "image": null,
              "embed": null,
              "language": null,
              "user": null,
              "user_image": null,
              "user_link": null,
              "user_id": null,
              "geo": null,
              "source": "wikio",
              "favicon": "http://wikio.com/favicon.ico",
              "type": "blogs",
              "domain": "wik.io",
              "id": "2388575404943858468"
            },
            {
              "title": "Apple to halt sales of iPhone 4S in China (Fame Dubai Blog)",
              "description": "SHANGHAI – Apple Inc said on Friday it will stop selling its latest iPhone in its retail stores in Beijing and Shanghai to ensure the safety of its customers and employees. Go to SourceSource : Fame Dubai BlogExplore : iPhone, iPhone 4, Phone",
              "link": "http://wik.io/info/US/309198933",
              "timestamp": 1326439320,
              "image": null,
              "embed": null,
              "language": null,
              "user": null,
              "user_image": null,
              "user_link": null,
              "user_id": null,
              "geo": null,
              "source": "wikio",
              "favicon": "http://wikio.com/favicon.ico",
              "type": "blogs",
              "domain": "wik.io",
              "id": "16209851193593872066"
            }
          ]
        };

        const items = json3.items
        const replacer = (key, value) => value === null ? '' : value // specify how you want to handle null values here
        const header = Object.keys(items[0])
        let csv = items.map(row => header.map(fieldName => JSON.stringify(row[fieldName], replacer)).join(','))
        csv.unshift(header.join(','))
        csv = csv.join('\r\n')

        var link = document.createElement("a");    
        link.id="lnkDwnldLnk";
        document.body.appendChild(link);
        blob = new Blob([csv], { type: 'text/csv' }); 
        var csvUrl = window.webkitURL.createObjectURL(blob);
        var filename = 'ExportedData.csv';
        jQuery("#lnkDwnldLnk")
        .attr({
            'download': filename,
            'href': csvUrl
        });
        jQuery('#lnkDwnldLnk')[0].click();
        document.body.removeChild(link);
    </script>
</body>
</html>

A sophisticated method for converting an object array to CSV:

const convertToCsv = (arr) => {
    const keys = Object.keys(arr[0]);
    const replacer = (_key, value) => value === null ? '' : value;
    const processRow = row => keys.map(key => JSON.stringify(row[key], replacer)).join(',');
    return [ keys.join(','), ...arr.map(processRow) ].join('\r\n');
};

To easily download it as a file:

const downloadFile = (fileName, data) => {
    var link = document.createElement('a');
    link.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(data));
    link.setAttribute('download', fileName);
    link.style.display = 'none';
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
};

The solution provided as the accepted answer was incredibly helpful, but I required a modified version to accommodate unstructured JSON objects.

I have adapted the accepted answer to function with an array of unstructured objects that vary in size and schema.

Here is the input:

[
  {
    "name": "Item 1",
    "color": "Green",
    "sizerange": {
      "max": "X-Large",
      "min": "X-Small"
    }
  },
  {
    "name": "Item 2",
    "color": "Green",
    "size": "X-Large",
    "owner": {
      "name":"Bill",
      "address": {
        "line1": "1 test st",
        "suburb": "testville"
      }
    }
  },
  {
    "name": "Item 3",
    "color": "Green",
    "sizes": [
      "X-Large",
      "Large",
      "Small"
    ]
  }
]

And here is the output:

"name","color","sizerange.max","sizerange.min","size","owner.name","owner.address.line1","owner.address.suburb","sizes.0","sizes.1","sizes.2"
"Item 1","Green","X-Large","X-Small","","","","","","",""
"Item 2","Green","","","X-Large","Bill","1 test st","testville","","",""
"Item 3","Green","","","","","","", "X-Large","Large","Small"

// JSON to CSV Converter

//https://www.codegrepper.com/code-examples/javascript/javascript+array+to+csv+string
function objectToCSVRow(dataObject) {
  var dataArray = [];
  for (var o in dataObject) {
    var innerValue = typeof dataObject[o] == 'undefined' ? '' : dataObject[o].toString();
    var result = innerValue.replace(/"/g, '""');
    result = '"' + result + '"';
    dataArray.push(result);
  }
  return dataArray.join(',') + '\r\n';
}

//https://stackoverflow.com/a/6491621
function findbystring(o, s) {
  s = s.replace(/\[(\w+)\]/g, '.$1'); // convert indexes to properties
  s = s.replace(/^\./, ''); // strip a leading dot
  var a = s.split('.');
  for (var i = 0, n = a.length; i < n; ++i) {
    var k = a[i];
    if (k in o) {
      o = o[k];
    } else {
      return;
    }
  }
  return o;
}


function pushUnique(arr, item) {
  if (item != "" && !arr.includes(item))
    arr.push(item);
}


function getLabels(name, item, labels) {
  if (typeof item == 'object') {
    for (var index in item) {
      thisname = ""
      if (name != "") thisname = name + ".";
      thisname += index;
      getLabels(thisname, item[index], labels);
    }
  } else {
    pushUnique(labels, name);
  }
}

function ConvertToCSV(objArray) {
  var array = typeof objArray != 'object' ? JSON.parse(objArray) : objArray;
  var str = '';

  var labels = [];

  for (var i = 0; i < array.length; i++) {
    getLabels("", array[i], labels);

  }

  str += objectToCSVRow(labels);
  
  for (var i = 0; i < array.length; i++) {

    var line = [];
    for (var label in labels) {

      line.push(findbystring(array[i], labels[label]));

    }

    str += objectToCSVRow(line);
  }

  return str;
}

// Example
$(document).ready(function() {

  // Create Object
  var items = [{
      name: "Item 1",
      color: "Green",
      sizerange: {
        max: "X-Large",
        min: "X-Small"
      }
    },
    {
      name: "Item 2",
      color: "Green",
      size: "X-Large",
      owner: {
        name: "Bill",
        address: {
          line1: "1 test st",
          suburb: "testville"
        }
      }
    },
    {
      name: "Item 3",
      color: "Green",
      sizes: ["X-Large", "Large", "Small"]
    }
  ];

  // Convert Object to JSON
  var jsonObject = JSON.stringify(items, null, 2);

  // Display JSON
  $('#json').text(jsonObject);

  // Convert JSON to CSV & Display CSV
  $('#csv').text(ConvertToCSV(jsonObject));
});

<html>

<head>
  <title>Demo - Covnert JSON to CSV</title>
  <script type="text/javascript" src="http://code.jquery.com/jquery-latest.js"></script>
  <script type="text/javascript" src="https://github.com/douglascrockford/JSON-js/raw/master/json2.js"></script>

  <script type="text/javascript">
  </script>
</head>

<body>
  <h1>
    JSON</h1>
  <pre id="json"></pre>
  <h1>
    CSV</h1>
  <pre id="csv"></pre>
</body>

</html>

There are instances where objects vary in lengths, presenting a challenge similar to what Kyle Pennell encountered. Rather than sorting the array, I opted to iterate over it and select the longest item. This approach reduces the time complexity to O(n), as opposed to O(n log(n)) when employing sorting initially.

I began with Christian Landgren's updated ES6 (2016) version of the code.

json2csv(json) {
    // You may skip this step if your input is already a proper array:
    const simpleArray = JSON.parse(json)
    // Find the object in the array with the most keys to use as headers
    const header = simpleArray.map((x) => Object.keys(x))
      .reduce((acc, cur) => (acc.length > cur.length ? acc : cur), []);

    // Specify how to handle null values here
    const replacer = (key, value) => (
      value === undefined || value === null ? '' : value);
    let csv = simpleArray.map((row) => header.map(
      (fieldName) => JSON.stringify(row[fieldName], replacer)).join(','));
    csv = [header.join(','), ...csv];
    return csv.join('\r\n');
}

Based on an idea from praneybehl in their response, this script has been modified to handle nested objects and tab separation.

function ConvertToCSV(objArray) {
  let array = typeof objArray != 'object' ? JSON.parse(objArray) : objArray;
  if(!Array.isArray(array))
      array = [array];

  let str = '';

  for (let i = 0; i < array.length; i++) {
    let line = '';
    for (let index in array[i]) {
      if (line != '') line += ','

      const item = array[i][index];
      line += (typeof item === 'object' && item !== null ? ConvertToCSV(item) : item);
    }
    str += line + '\r\n';
  }

  do{
      str = str.replace(',','\t').replace('\t\t', '\t');
  }while(str.includes(',') || str.includes('\t\t'));

  return str.replace(/(\r\n|\n|\r)/gm, ""); //removing line breaks: https://stackoverflow.com/a/10805198/4508758
}

Check out the latest answer showcasing a wonderfully optimized and convenient CSV plugin: (Feel free to try this code in your project after verifying, as it may not work on stackoverflow)

Utilizing jquery along with the efficient jquery.csv library (Skillfully escapes all characters) https://github.com/typeiii/jquery-csv

// Array of objects creation
const data = [
    { name: "Item 1", color: "Green", size: "X-Large" },
    { name: "Item 2", color: "Green", size: "X-Large" },
    { name: "Item 3", color: "Green", size: "X-Large" }
];

// Conversion to csv
const csv = $.csv.fromObjects(data);

// Function to download file as csv
const downloadBlobAsFile = function(csv, filename){
    var downloadLink = document.createElement("a");
    var blob = new Blob([csv], { type: 'text/csv' });
    var url = URL.createObjectURL(blob);
    downloadLink.href = url;
    downloadLink.download = filename;
    document.body.appendChild(downloadLink);
    downloadLink.click();
    document.body.removeChild(downloadLink);
}

// Download csv file
downloadBlobAsFile(csv, 'filename.csv');

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
<script src="https://cdn.tutorialjinni.com/jquery-csv/1.0.11/jquery.csv.min.js"></script>

Here's a method for handling deeply nested objects in a more object-oriented manner using newer JavaScript versions. You may need to adjust the separator type after the region.

function convertToCSV(objArray) {
    let rows = typeof objArray !== "object" ? JSON.parse(objArray) : objArray;
    let header = "";
    Object.keys(rows[0]).map(property => (header += property + ";"));

    let csvString = "";
    rows.forEach(row => {
        let line = "";
        let columns =
            typeof row !== "object" ? JSON.parse(row) : Object.values(row);
        columns.forEach(column => {
            if (line !== "") {
                line += ";";
            }
            if (typeof column === "object") {
                line += JSON.stringify(column);
            }  else {
                line += column;
            }
        });
        csvString += line + "\r\n";
    });
    return header + "\r\n" + csvString;
}

Personally, I prefer utilizing the d3-dsv library for this task. There's no need to reinvent the wheel, right?

import { csvFormat } from 'd3-dsv';
/**
 * Convert input data into a CSV formatted string
 * @param (Array) columnsToBeIncluded array of column names (strings)
 *                that should be included in the formatted CSV
 * @param {Array} input array of objects to be transformed into a string
 */
export function convertDataToCSVFormatString(input, columnsToBeIncluded = []) {
  if (columnsToBeIncluded.length === 0) {
    return csvFormat(input);
  }
  return csvFormat(input, columnsToBeIncluded);
}

By using tree-shaking, you can easily import just the specific function needed from the d3-dsv library.

Inspired by @Christian Landgren's response, I encountered an issue with my CSV file containing only 3 columns/headers. This was due to the fact that the initial JSON element had only 3 keys. Therefore, it is important to exercise caution with the

const header = Object.keys(json[0])

To address this, I implemented an array.sort, which organizes the JSON based on the number of keys present. By doing so, the resulting CSV will have the maximum number of columns possible.

This inclusive a method can be seamlessly integrated into your code. Simply provide it with the JSON dataset!

function convertJSONtocsv(json) {
    if (json.length === 0) {
        return;
    }

    json.sort(function(a, b){ 
       return Object.keys(b).length - Object.keys(a).length;
    });

    const replacer = (key, value) => value === null ? '' : value // define handling for null values
    const header = Object.keys(json[0])
    let csv = json.map(row => header.map(fieldName => JSON.stringify(row[fieldName], replacer)).join(','))
    csv.unshift(header.join(','))
    csv = csv.join('\r\n')

    fs.writeFileSync('awesome.csv', csv)
}

Below is a straightforward method I use to convert an array of objects into CSV format, assuming all objects in the array have the same attributes:

let csvData = []
if (dataArray.length) {
  let keysArray = Object.keys(dataArray[0])
  csvData.push(keysArray.join(','))
  dataArray.forEach(obj => {
    let valuesArray = keysArray.map(key => obj[key] || '')
    csvData.push(valuesArray.join(','))
  })
}

csvData = csvData.join('\n')

function generateCSV(data, name = "output.csv") {
    /*  *This function takes data in JSON format and converts it to CSV before downloading
    *The input data should be an array of objects with the same structure  
    *If no filename is provided, the default name will be used.
    */

    /* Convert JSON data to CSV format*/
    let jsonData = data;
    let headers = Object.keys(jsonData[0]);
    let replacerFunction = function (key, value) { return value === null ? '' : value }
    let csvData = jsonData.map(function (row) {
        return headers.map(function (headerName) {
            return JSON.stringify(row[headerName], replacerFunction)
        }).join(',')
    })
    csvData.unshift(headers.join(','))
    csvData = csvData.join('\r\n');

    /* Download the CSV file */
    let downloadLinkElement = document.createElement("a");
    let blobData = new Blob(["\ufeff", csvData]);
    let urlLink = URL.createObjectURL(blobData);
    downloadLinkElement.href = urlLink;
    downloadLinkElement.download = name;
    document.body.appendChild(downloadLinkElement);
    downloadLinkElement.click();
    document.body.removeChild(downloadLinkElement);
}

This custom function was crafted based on previous explanations.

Export data to CSV format.

function writeToCsv(dataToWrite, callback) {
    var dataToWrite;
    var fs = require('fs');
    dataToWrite = convertToCSV(dataToWrite);
    fs.writeFile('assets/distanceInfo.csv', dataToWrite, 'utf8', function (err) {
      if (err) {
        console.log('An error occurred - the file may not have been saved or a corrupted file was saved.');
      } else{
        console.log('Data successfully saved to CSV file!');
      }
      callback("data_saved | assets/distanceInfo.csv")
    });
}

function convertToCSV(objArray) {
    var array = typeof objArray != 'object' ? JSON.parse(objArray) : objArray;
    var str = '';
    for (var i = 0; i < array.length; i++) {
        var line = '';
        for (var index in array[i]) {
            if (line != '') line += ','

            line += array[i][index];
        }
        str += line + '\r\n';
    }
    return str;
}

Looking for a solution that actually works? Look no further! Check out my structured JSON response to a related question, complete with a demo snippet. JSON To CSV conversion (JavaScript) : How to properly format CSV conversion Don't settle for just one type of converter. Explore similar tools on my Github profile for analyzing unknown JSON structures. I take pride in being the author of the code provided in this response, as well as most of the projects on my Github page (excluding a few that were originally forks or translations).

A straightforward method for transforming nested JavaScript objects (excluding arrays) into CSV format while maintaining an organized structure.

const ConvertToCsv = (data, level = 0) => (
  Object.keys(data).reduce((prevValue, currValue) => {
    if (typeof data[currValue] === 'object' && !Array.isArray(data[currValue])) {
      // handle nested object
      const formattedObjProp = `${prevValue}${','.repeat(level)}${currValue}\r\n`;
      level++;
      const formattedObj = `${formattedObjProp}${ConvertToCsv(data[currValue], level)}`;
      level--;
      return formattedObj;
    }
    return `${prevValue}${','.repeat(level)}${currValue},${data[currValue]}\r\n`
  }, '')
)

const obj = {
  baz: {
    foo: {
      bar: 5
    }
  };
  
console.log(ConvertToCsv(obj))

My approach to converting an array of JSON objects into a CSV file involves following certain guidelines inspired by RFC 4180 and MIME standards:

1. Each record should have the same number of comma-separated fields.
2. Fields can be quoted with double quotes.
3. If double-quotes are used, then a double-quote in a field must be escaped as two double-quote characters.
4. Include some type of carriage return or line feed.

Although there may be more efficient methods available, I've created a function that is easy to read and understand while enforcing these constraints.

The function operates in two passes:

1. Iterate through each array entry to collect all key names on the first pass.
2. Create a header using the collected key names.
3. In the second pass, populate the table with values corresponding to the keys.

For handling different data types:

• If a value is undefined, it is replaced with an empty string.
• If a value is not a string, it is converted to a string using JSON.stringify.
• Replace any interior double quotes with two double quotes for proper formatting.
• Wrap each entry in double quotes separated by commas without spaces.
• Ensure there is a new line between each row.

The resulting CSV string should be easily viewable in most spreadsheet applications.

function makeCSVFromJSON(myJSON) {
    // Function logic...
}

function convertJsonToCsv(data) {
  return (
    Object.keys(data[0]).join(",") +
    "\n" +
    data.map((d) => Object.values(d).join(",")).join("\n")
  );
}

This method is designed to handle simple json arrays and convert them into csv format. For nested json arrays, it is recommended to first simplify the structure before using this function.

Typescript function made simple considering the following:

• ✅ Keys/Values can contain "
• ✅ Keys/Values can contain ,
• ✅ Values can be an array or object

Playground Link

https://i.sstatic.net/RQ4M1.png

const arrayToCSV = (myJSON: any[]) => {
  const escapeValue = (value: any) => {
    const content = (() => {
      if (!value) {
        return "";
      }
      if (typeof value === "object") {
        return JSON.stringify(value).replace(/"/g, '""')
      }
      return value.toString();
    })()
    return `"${content}"`
  };
  
  const fieldNamesArray: string[] = [...new Set(
    myJSON.reduce((acc, arrayEntry) => {
      return [...acc, ...Object.keys(arrayEntry)];
    }, [])
  )] as any[];

  const header = fieldNamesArray.map(escapeValue).join(',');

  const rows = myJSON.map(arrayEntry => {
    return fieldNamesArray.map((field) => {
      return escapeValue(arrayEntry[field]);
    }).join(',');
  }).join('\n');

  return `${header}\n${rows}`;
};

Hopefully this explanation is useful :)

Transforming data with Python:

import pandas as pd

data = pd.read_json("./dataset.json")
data.to_csv("./dataset.csv")

My approach is unique because it supports dynamic columns unlike other solutions that rely on the first row to determine the columns:

function convertToCsv(data, replacer = (_, v) => v) {
    let csvArray = [[]]

    for (const record of data) {
        let row = []
        for (const key in record) {
            let columnIndex = csvArray[0].indexOf(key)

            if (columnIndex === -1) {
                columnIndex = csvArray[0].length
                csvArray[0].push(key)
            }

            row[columnIndex] = replacer(key, record[key])
        }
        csvArray.push(row.join(","))
    }

    csvArray[0] = csvArray[0].join(",")

    return csvArray.join("\r\n")
}

If needed, you can provide a custom replacer function to manipulate specific column values.

While not an exact match for the original request, this solution could prove to be beneficial. Within my personal ~/.zshrc file, I have implemented a function that pulls JSON data from a URL and converts it into a CSV format using jq. To utilize this function, you may need to install jq by running the command brew install jq

json_to_csv() {
  url=$1
  filename=$2

curl -s "$url" | jq -r '(.data[0] | keys_unsorted) as $headers | $headers, (.data[] | [.[$headers[]]]) | @csv' > "$filename"
}

# Usage: json_to_csv <url> <filename>
# If your URL includes a '?' query parameter, remember to enclose the entire URL in single or double quotes.