Kod Javascript do analizy danych CSV [duplikat]

I think I can enough beatKirtan ' s answer

Enter jQuery-CSV

Jest to wtyczka jquery zaprojektowana do pracy jako kompleksowe rozwiązanie do parsowania CSV do danych Javascript. Obsługuje każdy pojedynczy przypadek krawędzi przedstawiony w RFC 4180, a także niektóre, które pojawiają się dla eksportu Excel/Google Spreadsheed (tj. głównie z wartościami null), których brakuje w specyfikacji.

przykład:

Utwór,wykonawca,album,rok

Dangerous, "Busta Rhymes", "When Disaster Strikes", 1997]}

// calling this
music = $.csv.toArrays(csv)

// outputs...
[
  ["track","artist","album","year"],
  ["Dangerous","Busta Rhymes","When Disaster Strikes","1997"]
]

console.log(music[1][2]) // outputs: 'When Disaster Strikes'

Update:

music = $.csv.toArrays(csv, {
  delimiter:"'", // sets a custom value delimiter character
  separator:';', // sets a custom field separator character
});

Aktualizacja 2:

Teraz działa z jQuery na Node.js też. Masz więc możliwość parsowania po stronie klienta lub serwera za pomocą tej samej biblioteki lib.

Aktualizacja 3:

Odkąd Google Code shutdown, jquery-csv został przeniesiony do GitHub .

Zastrzeżenie: jestem również autorem jQuery-CSV.

Mam implementację w ramach projektu arkusza kalkulacyjnego.

Ten kod nie jest jeszcze dokładnie testowany, ale każdy może z niego korzystać.

Jak zauważono w niektórych odpowiedziach, twoja implementacja może być znacznie prostsza, jeśli Masz plik DSVlub TSV, ponieważ nie pozwalają one na użycie separatorów rekordów i pól w wartościach. CSV, z drugiej strony, może mieć przecinki i nowe linie wewnątrz pola, które łamie większość wyrażeń regularnych i podzielonych zbliża się.

var CSV = {
parse: function(csv, reviver) {
    reviver = reviver || function(r, c, v) { return v; };
    var chars = csv.split(''), c = 0, cc = chars.length, start, end, table = [], row;
    while (c < cc) {
        table.push(row = []);
        while (c < cc && '\r' !== chars[c] && '\n' !== chars[c]) {
            start = end = c;
            if ('"' === chars[c]){
                start = end = ++c;
                while (c < cc) {
                    if ('"' === chars[c]) {
                        if ('"' !== chars[c+1]) { break; }
                        else { chars[++c] = ''; } // unescape ""
                    }
                    end = ++c;
                }
                if ('"' === chars[c]) { ++c; }
                while (c < cc && '\r' !== chars[c] && '\n' !== chars[c] && ',' !== chars[c]) { ++c; }
            } else {
                while (c < cc && '\r' !== chars[c] && '\n' !== chars[c] && ',' !== chars[c]) { end = ++c; }
            }
            row.push(reviver(table.length-1, row.length, chars.slice(start, end).join('')));
            if (',' === chars[c]) { ++c; }
        }
        if ('\r' === chars[c]) { ++c; }
        if ('\n' === chars[c]) { ++c; }
    }
    return table;
},

stringify: function(table, replacer) {
    replacer = replacer || function(r, c, v) { return v; };
    var csv = '', c, cc, r, rr = table.length, cell;
    for (r = 0; r < rr; ++r) {
        if (r) { csv += '\r\n'; }
        for (c = 0, cc = table[r].length; c < cc; ++c) {
            if (c) { csv += ','; }
            cell = replacer(r, c, table[r][c]);
            if (/[,\r\n"]/.test(cell)) { cell = '"' + cell.replace(/"/g, '""') + '"'; }
            csv += (cell || 0 === cell) ? cell : '';
        }
    }
    return csv;
}
};

Oto niezwykle prosty parser CSV, który obsługuje cytowane pola z przecinkami, nowymi liniami i podwójnymi cudzysłowami. Nie ma podziału ani wyrażenia regularnego. Skanuje łańcuch wejściowy 1-2 znaki na raz i buduje tablicę.

Przetestuj na http://jsfiddle.net/vHKYH/.

function parseCSV(str) {
    var arr = [];
    var quote = false;  // true means we're inside a quoted field

    // iterate over each character, keep track of current row and column (of the returned array)
    for (var row = col = c = 0; c < str.length; c++) {
        var cc = str[c], nc = str[c+1];        // current character, next character
        arr[row] = arr[row] || [];             // create a new row if necessary
        arr[row][col] = arr[row][col] || '';   // create a new column (start with empty string) if necessary

        // If the current character is a quotation mark, and we're inside a
        // quoted field, and the next character is also a quotation mark,
        // add a quotation mark to the current column and skip the next character
        if (cc == '"' && quote && nc == '"') { arr[row][col] += cc; ++c; continue; }  

        // If it's just one quotation mark, begin/end quoted field
        if (cc == '"') { quote = !quote; continue; }

        // If it's a comma and we're not in a quoted field, move on to the next column
        if (cc == ',' && !quote) { ++col; continue; }

        // If it's a newline (CRLF) and we're not in a quoted field, skip the next character
        // and move on to the next row and move to column 0 of that new row
        if (cc == '\r' && nc == '\n' && !quote) { ++row; col = 0; ++c; continue; }

        // If it's a newline (LF or CR) and we're not in a quoted field,
        // move on to the next row and move to column 0 of that new row
        if (cc == '\n' && !quote) { ++row; col = 0; continue; }
        if (cc == '\r' && !quote) { ++row; col = 0; continue; }

        // Otherwise, append the current character to the current column
        arr[row][col] += cc;
    }
    return arr;
}

Oto mój PEG(.js) gramatyka, która wydaje się działać dobrze w RFC 4180 (tzn. obsługuje przykłady w http://en.wikipedia.org/wiki/Comma-separated_values):

start
  = [\n\r]* first:line rest:([\n\r]+ data:line { return data; })* [\n\r]* { rest.unshift(first); return rest; }

line
  = first:field rest:("," text:field { return text; })*
    & { return !!first || rest.length; } // ignore blank lines
    { rest.unshift(first); return rest; }

field
  = '"' text:char* '"' { return text.join(''); }
  / text:[^\n\r,]* { return text.join(''); }

char
  = '"' '"' { return '"'; }
  / [^"]

Wypróbuj na http://jsfiddle.net/knvzk/10 lub http://pegjs.majda.cz/online. Pobierz wygenerowany parser na https://gist.github.com/3362830 .

CsvToArray v1. 3

Kompaktowa (645 bajtów), ale zgodna funkcja do konwersji ciągu CSV na tablicę 2D, zgodna ze standardem RFC4180.

Https://code.google.com/archive/p/csv-to-array/downloads

Common Usage: jQuery

 $.ajax({
        url: "test.csv",
        dataType: 'text',
        cache: false
 }).done(function(csvAsString){
        csvAsArray=csvAsString.csvToArray();
 });

Common usage: Javascript

csvAsArray = csvAsString.csvToArray();

Override field separator

csvAsArray = csvAsString.csvToArray("|");

Override separator rekordów

csvAsArray = csvAsString.csvToArray("", "#");

Override Skip Header

csvAsArray = csvAsString.csvToArray("", "", 1);

Override all

csvAsArray = csvAsString.csvToArray("|", "#", 1);

Nie jestem pewien, dlaczego nie mogłem kirtans ex. pracować dla mnie. Wydawało się, że zawodzi na pustych polach lub może polach z końcowymi przecinkami...

Nie napisałem kodu parsera, tylko owijkę wokół funkcji parsera, aby to działało dla pliku. zobacz przypisanie

    var Strings = {
        /**
         * Wrapped csv line parser
         * @param s string delimited csv string
         * @param sep separator override
         * @attribution : http://www.greywyvern.com/?post=258 (comments closed on blog :( )
         */
        parseCSV : function(s,sep) {
            // http://stackoverflow.com/questions/1155678/javascript-string-newline-character
            var universalNewline = /\r\n|\r|\n/g;
            var a = s.split(universalNewline);
            for(var i in a){
                for (var f = a[i].split(sep = sep || ","), x = f.length - 1, tl; x >= 0; x--) {
                    if (f[x].replace(/"\s+$/, '"').charAt(f[x].length - 1) == '"') {
                        if ((tl = f[x].replace(/^\s+"/, '"')).length > 1 && tl.charAt(0) == '"') {
                            f[x] = f[x].replace(/^\s*"|"\s*$/g, '').replace(/""/g, '"');
                          } else if (x) {
                        f.splice(x - 1, 2, [f[x - 1], f[x]].join(sep));
                      } else f = f.shift().split(sep).concat(f);
                    } else f[x].replace(/""/g, '"');
                  } a[i] = f;
        }
        return a;
        }
    }

Dlaczego po prostu nie używać .split(',') ?

Http://www.w3schools.com/jsref/jsref_split.asp

var str="How are you doing today?";
var n=str.split(" ");