After considering the responses provided, I have developed a function that has been successfully tested on IE 11, Chrome 36, and Firefox 29.

function generateCsvFile(fileName, dataRows) {
    var processRow = function (row) {
        var finalValue = '';
        for (var j = 0; j < row.length; j++) {
            var innerVal = row[j] === null ? '' : row[j].toString();
            if (row[j] instanceof Date) {
                innerVal = row[j].toLocaleString();
            };
            var result = innerVal.replace(/"/g, '""');
            if (result.search(/("|,|\n)/g) >= 0)
                result = '"' + result + '"';
            if (j > 0)
                finalValue += ',';
            finalValue += result;
        }
        return finalValue + '\n';
    };

    var csvContent = '';
    for (var i = 0; i < dataRows.length; i++) {
        csvContent += processRow(dataRows[i]);
    }

    var fileBlob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
    if (navigator.msSaveBlob) { // For IE 10+
        navigator.msSaveBlob(fileBlob, fileName);
    } else {
        var linkElement = document.createElement("a");
        if (linkElement.download !== undefined) { // Checking for support of HTML5 download attribute
            var url = URL.createObjectURL(fileBlob);
            linkElement.setAttribute("href", url);
            linkElement.setAttribute("download", fileName);
            linkElement.style.visibility = 'hidden';
            document.body.appendChild(linkElement);
            linkElement.click();
            document.body.removeChild(linkElement);
        }
    }
}

See an example of how it works here: https://jsfiddle.net/jossef/m3rrLzk0/

An elegant solution that is both simple and full-featured :)

/** Function to convert a 2D array into a CSV string
 */
function arrayToCsv(data){
  return data.map(row =>
    row
    .map(String)  // converting each value to String
    .map(v => v.replaceAll('"', '""'))  // escaping double quotes
    .map(v => `"${v}"`)  // adding quotes to each value
    .join(',')  // separating values with commas
  ).join('\r\n');  // starting new rows on new lines
}

Example:

let csv = arrayToCsv([
  [1, '2', '"3"'],
  [true, null, undefined],
]);

Result:

"1","2","""3"""
"true","null","undefined"

Now you can easily download it as a file:

/** Function to download content as a file
 * Source: https://stackoverflow.com/questions/14964035/how-to-export-javascript-array-info-to-csv-on-client-side
 */
function downloadBlob(content, filename, contentType) {
  // Creating a blob
  var blob = new Blob([content], { type: contentType });
  var url = URL.createObjectURL(blob);

  // Generating a download link
  var pom = document.createElement('a');
  pom.href = url;
  pom.setAttribute('download', filename);
  pom.click();
}

Download your CSV file now:

downloadBlob(csv, 'export.csv', 'text/csv;charset=utf-8;')

https://i.stack.imgur.com/HVLeJ.png

https://i.stack.imgur.com/bBbhM.png

This method is compatible with Internet Explorer 10+, Edge, as well as various versions of Chrome, FireFox, Safari, and more

However, the suggested solution may not function properly on IE and Safari browsers.

// This code snippet demonstrates how to download mock data as a CSV file
var data = [
  ['name1', 'city1', 'some other info'],
  ['name2', 'city2', 'more info']
];

var csvContent = '';
data.forEach(function(infoArray, index) {
  var dataString = infoArray.join(';');
  csvContent += index < data.length ? dataString + '\n' : dataString;
});

var download = function(content, fileName, mimeType) {
  var a = document.createElement('a');
  mimeType = mimeType || 'application/octet-stream';

  if (navigator.msSaveBlob) { // For Internet Explorer
    navigator.msSaveBlob(new Blob([content], {
      type: mimeType
    }), fileName);
  } else if (URL && 'download' in a) { // HTML5 A[download]
    a.href = URL.createObjectURL(new Blob([content], {
      type: mimeType
    }));
    a.setAttribute('download', fileName);
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
  } else {
    location.href = 'data:application/octet-stream,' + encodeURIComponent(content); // Only this mime type is supported universally
  }
}

download(csvContent, 'download.csv', 'text/csv;encoding:utf-8');

After running the code snippet, the mock data will be downloaded as a CSV file.

Credit goes to dandavis for the original answer:

Individuals are attempting to generate their own csv string, encountering challenges with special characters and edge cases. Is there a known solution for this?

papaparse - recommended for JSON to CSV conversion. Utilize Papa.unparse().

import Papa from "papaparse";

const downloadCSV = (args) => {  

  let filename = args.filename || 'export.csv';
  let columns = args.columns || null;

  let csv = Papa.unparse({ data: args.data, fields: columns})
  if (csv == null) return;

  var blob = new Blob([csv]);
  if (window.navigator.msSaveOrOpenBlob)  
      window.navigator.msSaveBlob(blob, args.filename);
  else
  {
      var a = window.document.createElement("a");
      a.href = window.URL.createObjectURL(blob, {type: "text/plain"});
      a.download = filename;
      document.body.appendChild(a);
      a.click();  
      document.body.removeChild(a);
  }

}

Example usage

downloadCSV({ 
  filename: "filename.csv",
  data: [{"a": "1", "b": "2"}],
  columns: ["a","b"]
});

https://github.com/mholt/PapaParse/issues/175 - Refer to this comment for discussion on browser support.

After the Chrome 35 update, there were notable changes to the download attribute behavior.

https://code.google.com/p/chromium/issues/detail?id=373182

To enable this feature in Chrome, follow these steps:

var pom = document.createElement('a');
var csvContent=csv; // Load CSV data here
var blob = new Blob([csvContent],{type: 'text/csv;charset=utf-8;'});
var url = URL.createObjectURL(blob);
pom.href = url;
pom.setAttribute('download', 'foo.csv');
pom.click();

After searching for a solution that met RFC 4180 compliance, I couldn't find one and decided to create my own (albeit possibly inefficient) implementation to suit my needs. I wanted to share it with others here.

var content = [['1st title', '2nd title', '3rd title', 'another title'], ['a a a', 'bb\nb', 'cc,c', 'dd"d'], ['www', 'xxx', 'yyy', 'zzz']];

var finalVal = '';

for (var i = 0; i < content.length; i++) {
    var value = content[i];

    for (var j = 0; j < value.length; j++) {
        var innerValue =  value[j]===null?'':value[j].toString();
        var result = innerValue.replace(/"/g, '""');
        if (result.search(/("|,|\n)/g) >= 0)
            result = '"' + result + '"';
        if (j > 0)
            finalVal += ',';
        finalVal += result;
    }

    finalVal += '\n';
}

console.log(finalVal);

var download = document.getElementById('download');
download.setAttribute('href', 'data:text/csv;charset=utf-8,' + encodeURIComponent(finalVal));
download.setAttribute('download', 'test.csv');

I hope this code proves useful for someone in the future. It offers both CSV encoding and file downloading capabilities. You can test it out on jsfiddle, where you'll be able to download the file or view the output in the console.

UPDATE:

It seems Chrome has lost the ability to name the downloaded file properly. The issue persists even on jsfiddle where the file is now consistently named download.csv.

Thanks to @Default's solution, everything is running smoothly on Chrome! However, I encountered an issue with IE.

If you're facing problems with IE10, here's a workaround:

var csvContent=data; //loading our csv data
var blob = new Blob([csvContent],{
    type: "text/csv;charset=utf-8;"
});

navigator.msSaveBlob(blob, "filename.csv")

A Solution for Multi-Language Support

        function generateCsvFile(fileName, dataRows) {
        var csvContent = '';
        for (var i = 0; i < dataRows.length; i++) {
            var row = dataRows[i];
            for (var j = 0; j < row.length; j++) {
                var value = row[j] === null ? '' : row[j].toString();
                value = value.replace(/\t/gi, " ");
                if (j > 0)
                    csvContent += '\t';
                csvContent += value;
            }
            csvContent += '\n';
        }

        // Encoding the file in UTF-16
        var charCode, byteArray = [];
        byteArray.push(255, 254);
        for (var i = 0; i < csvContent.length; ++i) {
            charCode = csvContent.charCodeAt(i);
            byteArray.push(charCode & 0xff);
            byteArray.push(charCode / 256 >>> 0);
        }

        var blobData = new Blob([new Uint8Array(byteArray)], { type: 'text/csv;charset=UTF-16LE;' });
        if (navigator.msSaveBlob) {
            navigator.msSaveBlob(blobData, fileName);
        } else {
            var downloadLink = document.createElement("a");
            if (downloadLink.download !== undefined) {
                var url = window.URL.createObjectURL(blobData);
                downloadLink.setAttribute("href", url);
                downloadLink.setAttribute("download", fileName);
                downloadLink.style.visibility = 'hidden';
                document.body.appendChild(downloadLink);
                downloadLink.click();
                document.body.removeChild(downloadLink);
                window.URL.revokeObjectURL(url);
            }
        }
    }



    generateCsvFile('multilanguage_data.csv', [
        ['Order', 'Language'],
        ['1', 'English'],
        ['2', 'Español'],
        ['3', 'Français'],
        ['4', 'Português'],
        ['5', 'čeština'],
        ['6', 'Slovenščina'],
        ['7', 'Tiếng Việt'],
        ['8', 'Türkçe'],
        ['9', 'Norsk bokmål'],
        ['10', 'Ελληνικά'],
        ['11', 'беларускі'],
        ['12', 'русский'],
        ['13', 'Українська'],
        ['14', 'հայերեն'],
        ['15', 'עִברִית'],
        ['16', 'اردو'],
        ['17', 'नेपाली'],
        ['18', 'हिंदी'],
        ['19', 'ไทย'],
        ['20', 'ქართული'],
        ['21', '中国'],
        ['22', '한국어'],
        ['23', '日本語'],
    ])

If you need to export an array to a CSV file using Javascript, the following code snippet can help with that task.

This code also addresses special characters in the array.

var arrayContent = [["Séjour 1, é,í,ú,ü,ű"],["Séjour 2, é,í,ú,ü,ű"]];
var csvContent = arrayContent.join("\n");
var link = window.document.createElement("a");
link.setAttribute("href", "data:text/csv;charset=utf-8,%EF%BB%BF" + encodeURI(csvContent));
link.setAttribute("download", "upload_data.csv");
link.click(); 

Here is a link to a working jsfiddle example for reference.

Looking for a quick and simple solution to an old question with multiple answers? One option involves utilizing two popular libraries to achieve the desired result. While some responses suggest using Papa Parse but then creating their own custom download function, combining Papa Parse with FileSaver.js can be an effective approach:

const dataString = Papa.unparse(data, config);
const blob = new Blob([dataString], { type: 'text/csv;charset=utf-8' });
FileSaver.saveAs(blob, 'myfile.csv');

For more information on the available config options for the unparse function, refer to the documentation here.

Here is the code snippet for downloading CSV file:

<!doctype html>  
<html>  
<head></head>  
<body>
<a href='#' onclick='downloadCSV({ filename: "stock-data.csv" });'>Download CSV</a>

<script type="text/javascript">  
    var stockData = [
        {
            Symbol: "AAPL",
            Company: "Apple Inc.",
            Price: "132.54"
        },
        {
            Symbol: "INTC",
            Company: "Intel Corporation",
            Price: "33.45"
        },
        {
            Symbol: "GOOG",
            Company: "Google Inc",
            Price: "554.52"
        },
    ];

    function convertArrayOfObjectsToCSV(args) {
        var result, ctr, keys, columnDelimiter, lineDelimiter, data;

        data = args.data || null;
        if (data == null || !data.length) {
            return null;
        }

        columnDelimiter = args.columnDelimiter || ',';
        lineDelimiter = args.lineDelimiter || '\n';

        keys = Object.keys(data[0]);

        result = '';
        result += keys.join(columnDelimiter);
        result += lineDelimiter;

        data.forEach(function(item) {
            ctr = 0;
            keys.forEach(function(key) {
                if (ctr > 0) result += columnDelimiter;

                result += item[key];
                ctr++;
            });
            result += lineDelimiter;
        });

        return result;
    }

    window.downloadCSV = function(args) {
        var data, filename, link;

        var csv = convertArrayOfObjectsToCSV({
            data: stockData
        });
        if (csv == null) return;

        filename = args.filename || 'export.csv';

        if (!csv.match(/^data:text\/csv/i)) {
            csv = 'data:text/csv;charset=utf-8,' + csv;
        }
        data = encodeURI(csv);

        link = document.createElement('a');
        link.setAttribute('href', data);
        link.setAttribute('download', filename);
        document.body.appendChild(link);
        link.click();
        document.body.removeChild(link);
       }
</script>  
</body>  
</html>  

//This solution is compatible with both Chrome and IE browsers. I did a thorough review of various answers before implementing and testing it in both browsers.

var link = document.createElement("a");

if (link.download !== undefined) { // Checking for support
    // For browsers that support the HTML5 download attribute
    var blob = new Blob([CSV], { type: 'text/csv;charset=utf-8;' });
    var url = URL.createObjectURL(blob);            
    link.setAttribute("href", url);
    link.setAttribute("download", fileName);
    link.style = "visibility:hidden";
}

if (navigator.msSaveBlob) { // For Internet Explorer 10+
   link.addEventListener("click", function (event) {
     var blob = new Blob([CSV], {
       "type": "text/csv;charset=utf-8;"
     });
   navigator.msSaveBlob(blob, fileName);
  }, false);
}

document.body.appendChild(link);
link.click();
document.body.removeChild(link);

//Best regards

A single arrow function using ES6 :

const convertDataToCsvURI = (data) => encodeURI(
`data:text/csv;charset=utf-8,${data.map((row, index) =>  row.join(',')).join(`\n`)}`
);

Next :

window.open(
  convertDataToCsvURI(
   [["name1", "city_name1"/*, ...*/], ["name2", "city_name2"/*, ...*/]]
  )
);

If anyone is looking for a solution in reactjs, consider checking out react-csv

Below is a solution using native JavaScript.

function convertToCSV() {
  let data = "";
  const tableData = [];
  const rows = [
    ['111', '222', '333'],
    ['aaa', 'bbb', 'ccc'],
    ['AAA', 'BBB', 'CCC']
  ];
  for (const row of rows) {
    const rowData = [];
    for (const column of row) {
      rowData.push(column);
    }
    tableData.push(rowData.join(","));
  }
  data += tableData.join("\n");
  const a = document.createElement("a");
  a.href = URL.createObjectURL(new Blob([data], { type: "text/csv" }));
  a.setAttribute("download", "data.csv");
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
}

<button onclick="convertToCSV()">Export array to CSV file</button>

There are numerous DIY solutions available for converting data to CSV format, but most of them come with limitations when it comes to properly formatting different types of data without causing issues in programs like Excel.

Instead of experimenting with unreliable options, why not opt for a trusted solution like Papa Parse

Papa.unparse(data[, config])

You can then easily integrate this with a local download feature such as the one offered by @ArneHB.

Here we have a couple of inquiries:

1. How can we transform an array into a csv string?
2. How do we store that string in a file?

Most solutions provided for the first question (except Milimetric's) appear to be overly complex. Milimetric's answer, on the other hand, lacks coverage of alternative requirements such as wrapping strings with quotes or handling arrays of objects.

Below are my approaches to this problem:

For a straightforward csv conversion, using map() and join() is sufficient:

var test_array = [["name1", 2, 3], ["name2", 4, 5], ["name3", 6, 7], ["name4", 8, 9], ["name5", 10, 11]];
var csv = test_array.map(function(d){
    return d.join();
}).join('\n');

/* Results in 
name1,2,3
name2,4,5
name3,6,7
name4,8,9
name5,10,11

This method also allows you to specify a different column separator within the join function, like a tab: d.join('\t')

Alternatively, for a more thorough approach involving enclosing strings in quotes "", JSON magic comes in handy:

var csv = test_array.map(function(d){
   return JSON.stringify(d);
})
.join('\n') 
.replace(/(^\[)|(\]$)/mg, ''); // remove opening [ and closing ]
                               // brackets from each line 

/* would produce
"name1",2,3
"name2",4,5
"name3",6,7
"name4",8,9
"name5",10,11

If dealing with an array of objects like :

var data = [
{"title": "Book title 1", "author": "Name1 Surname1"},
{"title": "Book title 2", "author": "Name2 Surname2"},
{"title": "Book title 3", "author": "Name3 Surname3"},
{"title": "Book title 4", "author": "Name4 Surname4"}
];

// utilize
var csv = data.map(function(d){
    return JSON.stringify(Object.values(d));
})
.join('\n') 
.replace(/(^\[)|(\]$)/mg, '');

Generate a blob using the csv data, for example:

var blob = new Blob([data], type:"text/csv");

If the browser has the capability to save blobs, like

if window.navigator.mSaveOrOpenBlob)===true

window.navigator.msSaveBlob(blob, 'filename.csv')

If the browser does not support saving and opening blobs, then save the csv data as follows:

var downloadLink = document.createElement('<a></a>');
downloadLink.attr('href', window.URL.createObjectURL(blob));
downloadLink.attr('download', filename);
downloadLink.attr('target', '_blank');
document.body.append(downloadLink);

Complete Code snippet:

var filename = 'data_'+(new Date()).getTime()+'.csv';
var charset = "utf-8";
var blob = new Blob([data], {
     type: "text/csv;charset="+ charset + ";"
});
if (window.navigator.msSaveOrOpenBlob) {
     window.navigator.msSaveBlob(blob, filename);
} else {
    var downloadLink = document.element('<a></a>');
    downloadLink.attr('href', window.URL.createObjectURL(blob));
    downloadLink.attr('download', filename);
    downloadLink.attr('target', '_blank');  
    document.body.append(downloadLink); 
    downloadLink[0].click(); 
}

Found this code snippet in the source code for react-admin:

function downloadCsv(csvData, fileName) {
    const hiddenLink = document.createElement('a');
    hiddenLink.style.display = 'none';
    document.body.appendChild(hiddenLink);
    const blob = new Blob([csvData], { type: 'text/csv' });
    if (window.navigator && window.navigator.msSaveOrOpenBlob) {
        // Supporting IE11+ & Edge
        window.navigator.msSaveOrOpenBlob(blob, `${fileName}.csv`);
    } else {
        hiddenLink.setAttribute('href', URL.createObjectURL(blob));
        hiddenLink.setAttribute('download', `${fileName}.csv`);
        hiddenLink.click();
    }
};

downloadCsv('Hello World', 'any-file-name.csv');

If you're looking to effortlessly download CSV files directly from the client side of your Java GWT application, then this solution is for you. Huge credits go out to Xavier John for his clever approach. This method has been extensively tested and proven to work smoothly on FF 24.6.0, IE 11.0.20, and Chrome 45.0.2454.99 (64-bit). Hopefully, this handy code snippet will save someone precious time:

public class ExportFile 
{

    private static final String CRLF = "\r\n";

    public static void exportAsCsv(String filename, List<List<String>> data) 
    {
        StringBuilder sb = new StringBuilder();
        for(List<String> row : data) 
        {
            for(int i=0; i<row.size(); i++)
            {
                if(i>0) sb.append(",");
                sb.append(row.get(i));
            }
            sb.append(CRLF);
        }

        generateCsv(filename, sb.toString());
    }

    private static native void generateCsv(String filename, String text)
    /*-{
        var blob = new Blob([text], { type: 'text/csv;charset=utf-8;' });

        if (navigator.msSaveBlob) // IE 10+
        { 
            navigator.msSaveBlob(blob, filename);
        } 
        else 
        {
            var link = document.createElement("a");
            if (link.download !== undefined) // feature detection
            { 
                // Browsers that support HTML5 download attribute
                var url = URL.createObjectURL(blob);
                link.setAttribute("href", url);
                link.setAttribute("download", filename);
                link.style.visibility = 'hidden';
                document.body.appendChild(link);
                link.click();
                document.body.removeChild(link);
            }
        }
    }-*/;
}

Give this a shot, many responses here are not equipped to handle unicode characters and data containing commas (e.g., dates).

function downloadUnicodeCSV(filename, datasource) {
    var content = '', newLine = '\r\n';
    for (var _i = 0, datasource_1 = datasource; _i < datasource_1.length; _i++) {
        var line = datasource_1[_i];
        var i = 0;
        for (var _a = 0, line_1 = line; _a < line_1.length; _a++) {
            var item = line_1[_a];
            var it = item.replace(/"/g, '""');
            if (it.search(/("|,|\n)/g) >= 0) {
                it = '"' + it + '"';
            }
            content += (i > 0 ? ',' : '') + it;
            ++i;
        }
        content += newLine;
    }
    var link = document.createElement('a');
    link.setAttribute('href', 'data:text/csv;charset=utf-8,%EF%BB%BF' + encodeURIComponent(content));
    link.setAttribute('download', filename);
    link.style.visibility = 'hidden';
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
};

Check out this updated code snippet for Angular:

  constructor(private location: Location, private renderer: Renderer2) {}

  saveFile(content, fileName, mimeType) {

    const link = this.renderer.createElement('a');

    mimeType = mimeType || 'application/octet-stream';

    if (navigator.msSaveBlob) {

      navigator.msSaveBlob(new Blob([content], {
        type: mimeType
      }), fileName);
    }
    else if (URL && 'download' in link) {

      const id = generateUniqueID();

      this.renderer.setAttribute(link, 'id', id);
      this.renderer.setAttribute(link, 'href', URL.createObjectURL(new Blob([content], {
        type: mimeType
      })));

      this.renderer.setAttribute(link, 'download', fileName);

      this.renderer.appendChild(document.body, link);

      const anchorElement = this.renderer.selectRootElement(`#${id}`);

      anchorElement.click();

      this.renderer.removeChild(document.body, link);
    }
    else {
      this.location.go(`data:application/octet-stream,${encodeURIComponent(content)}`);
    }
  };

It's worth noting that when opening a file in .xls format, the columns may be separated by '\t' instead of ','. In my experience, the solution provided in worked perfectly for me. All I had to do was use .join('\t') on the arrays instead of .join(',').

I have developed a handy function that converts a two-dimensional array of strings into a CSV file. The function automatically quotes any cell that contains special characters such as double quotes, commas, or white spaces (excluding blanks):

/**
 * Takes an array of arrays and returns a `,` sparated csv file.
 * @param {string[][]} table
 * @returns {string}
 */
function toCSV(table) {
    return table
        .map(function(row) {
            return row
                .map(function(cell) {
                    // We remove blanks and check if the column contains
                    // other whitespace,`,` or `"`.
                    // In that case, we need to quote the column.
                    if (cell.replace(/ /g, '').match(/[\s,"]/)) {
                        return '"' + cell.replace(/"/g, '""') + '"';
                    }
                    return cell;
                })
                .join(',');
        })
        .join('\n'); // or '\r\n' for windows

}

Note: This function may not be compatible with Internet Explorer versions prior to 11 unless map is polyfilled.

Note: If the cells contain numbers, you can add cell=''+cell before if (cell.replace... to convert numbers to strings.

You can also condense the code using ES6 syntax into a single line:

t.map(r=>r.map(c=>c.replace(/ /g, '').match(/[\s,"]/)?'"'+c.replace(/"/g,'""')+'"':c).join(',')).join('\n')

Generate CSV File

  let csvData = "data:text/csv;charset=utf-8,";
  rows.forEach(function (row) {
    for (var j = 0, limit = row.length; j < limit; j++) {
      if (typeof (row[j]) == 'string')
        row[j] = row[j].replace(/<(?:.|\n)*?>/gm, '');
      row[j] = row[j].replace(/,/g, '');
    }

    let rowData = row.join(",");
    csvData += rowData + "\r\n"; // include carriage return
  });
  var encodedUriCsv = encodeURI(csvData);
  var downloadLink = document.createElement("a");
  downloadLink.setAttribute("href", encodedUriCsv);
  downloadLink.setAttribute("download", "outputFile.csv");
  document.body.appendChild(downloadLink);
  downloadLink.click();

If you need a quick and easy solution, consider trying out this handy library that can help you create and download CSV files effortlessly: https://github.com/mbrn/filefy

Using it is straightforward:

import { CsvBuilder } from 'filefy';

var csvBuilder = new CsvBuilder("user_list.csv")
  .setColumns(["name", "surname"])
  .addRow(["Eve", "Holt"])
  .addRows([
    ["Charles", "Morris"],
    ["Tracey", "Ramos"]
  ])
  .exportFile();

If you're looking to implement this functionality in Knockout JS, the proposed solution should work smoothly:

Here's how to set it up:

<a data-bind="attr: {download: filename, href: csvContent}">Download</a>

And here's the view model code:

// for the download link
this.filename = ko.computed(function () {
    return ko.unwrap(this.id) + '.csv';
}, this);
this.csvContent = ko.computed(function () {
    if (!this.csvLink) {
        var data = ko.unwrap(this.data),
            ret = 'data:text/csv;charset=utf-8,';

        ret += data.map(function (row) {
            return row.join(',');
        }).join('\n');

        return encodeURI(ret);
    }
}, this);

Xavier Johns function has been enhanced to now include field headers if necessary, utilizing jQuery. However, the $.each portion will require modification for a native JavaScript loop implementation.

function exportToCsv(filename, rows, headers = false) {
    var processRow = function (row) {
        row = $.map(row, function(value, index) {
            return [value];
        });
        var finalVal = '';
        for (var j = 0; j < row.length; j++) {
            //Header Handling
            if(i == 0 && j == 0 && headers == true){
                var ii = 0;
                $.each(rows[i], function( index, value ) {
                    var fieldName = index === null ? '' : index.toString();
                    var fieldResult = fieldName.replace(/"/g, '""');
                    if (fieldResult.search(/("|,|\n)/g) >= 0){
                        fieldResult = '"' + fieldResult + '"';
                    }
                    if (ii > 0){
                        finalVal += ',';
                        finalVal += fieldResult;
                    }else{
                        finalVal += fieldResult;
                    }
                    ii++;
                });
                finalVal += '\n';
            }
            
            var innerValue = row[j] === null ? '' : row[j].toString();
            if (row[j] instanceof Date) {
                innerValue = row[j].toLocaleString();
            };
            var result = innerValue.replace(/"/g, '""');
            if (result.search(/("|,|\n)/g) >= 0){
                result = '"' + result + '"';
            }
            if (j > 0){
                finalVal += ',';
                finalVal += result;
            }else{
                finalVal += result;
            }
        }
        return finalVal + '\n';
    };
    
    var csvFile = '';
    for (var i = 0; i < rows.length; i++) {
        csvFile += processRow(rows[i]);
    }
    
    var blob = new Blob([csvFile], { type: 'text/csv;charset=utf-8;' });
    
    // Save CSV File
    if (navigator.msSaveBlob) { // IE 10+
        navigator.msSaveBlob(blob, filename);
    }else{
        var link = document.createElement("a");
        if (link.download !== undefined) { // feature detection
            // Browsers that support HTML5 download attribute
            var url = URL.createObjectURL(blob);
            link.setAttribute("href", url);
            link.setAttribute("download", filename);
            link.style.visibility = 'hidden';
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }
    }
}

This is an updated solution inspired by the approved response, focusing on extracting data from a JSON source.

            JSON Data Output:
             0: {emails: "SAMPLE Co., <a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="8dfde8f9e8ffcdfeece0fde1e8eee2e0fdece3f4a3eee2e0">[email protected]</a>"}, 
             1: {emails: "Another CO., <a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="83f1ecede2efe7c3e2edecf7ebe6f1ade0ecee">[email protected]</a>"}


            JS:
            $.getJSON('yourlink_goes_here', { if_you_have_parameters }, function(data) {
                var csvContent = "data:text/csv;charset=utf-8;";
                var dataString = '';
                $.each(data, function(k, v) {
                    dataString += v.emails + "\n";
                });

                csvContent += dataString;

                var encodedUri = encodeURI(csvContent);
                var link = document.createElement("a");
                
                link.setAttribute("href", encodedUri);
                link.setAttribute("download", "your_filename.csv");
                
                document.body.appendChild(link); // Required for FF

                link.click();
            });

This amazing tool has been incredibly helpful: https://www.npmjs.com/package/json-to-csv-in-browser

It simplifies the process of converting an array of jsons to a csv file and even includes a convenient download feature for easy access by web users. With minimal code, this library works smoothly and efficiently.

import { JsonArray, download } from 'json-to-csv-in-browser'

const arr = [
    {name : ` vader`, age : 53},
    {name : "what", age : 38},
    {name : "ever", age : 22}
]
const jsonArray = new JsonArray(arr);
const str = jsonArray.convertToCSVstring();
download("my.csv", str);

Cheers!

UPDATE: After further testing, it appears that the tool may struggle with values containing commas.