Convertisseur CSV vers JSON : Guide Complet avec Exemples de Code

La conversion CSV vers JSON est l'une des taches de transformation de donnees les plus courantes. Que vous migriez des donnees entre systemes, construisiez des API ou traitiez des feuilles de calcul, savoir convertir CSV en JSON efficacement est essentiel. Ce guide complet couvre les outils de conversion, les algorithmes d'analyse, les exemples de code en JavaScript, Python et Bash, ainsi que les bonnes pratiques.

Essayez notre outil gratuit de conversion CSV vers JSON en ligne.

Qu'est-ce que le CSV ?

CSV signifie Comma-Separated Values (valeurs separees par des virgules), un format texte defini par RFC 4180 pour stocker des donnees tabulaires. Chaque ligne represente un enregistrement, les valeurs sont separees par des virgules ou d'autres delimiteurs. La premiere ligne sert generalement d'en-tete.

Le format CSV est utilise depuis les debuts de l'informatique et reste populaire grace a sa simplicite. Tout editeur de texte, tableur ou langage de programmation peut lire et ecrire du CSV. Malgre sa simplicite, l'analyseur CSV doit gerer plusieurs cas delicats : champs entre guillemets, guillemets echappes, valeurs multilignes et delimiteurs variables.

Quand utiliser CSV ou JSON : CSV excelle pour les donnees tabulaires plates comme les exports de tableurs et les dumps de bases de donnees. JSON est preferable pour les structures hierarchiques, les reponses API et les fichiers de configuration.

CSV vs JSON : Comparaison detaillee

Comprendre les differences entre CSV et JSON aide a choisir le bon format et a comprendre le processus de conversion :

Comment fonctionne la conversion CSV vers JSON

Le processus de conversion CSV vers JSON comprend plusieurs etapes :

Exemple : Le CSV name,age,active\nAlice,30,true produit [{"name":"Alice","age":30,"active":true}].

Exemples de code CSV vers JSON

JavaScript : Conversion CSV vers JSON

Plusieurs approches pour la conversion CSV vers JSON en JavaScript : methode native, Papa Parse pour le navigateur, et csv-parser pour Node.js :

// ===== Native JavaScript: CSV to JSON =====

function csvToJson(csv) {
  const lines = csv.trim().split('\n');
  const headers = lines[0].split(',').map(h => h.trim());
  const result = [];

  for (let i = 1; i < lines.length; i++) {
    const values = lines[i].split(',');
    const obj = {};
    headers.forEach((header, index) => {
      let val = values[index]?.trim() || '';
      // Auto-detect types
      if (val === 'true') val = true;
      else if (val === 'false') val = false;
      else if (val === 'null' || val === '') val = null;
      else if (!isNaN(val) && val !== '') val = Number(val);
      obj[header] = val;
    });
    result.push(obj);
  }
  return result;
}

const csv = `name,age,city,active
Alice,30,New York,true
Bob,25,London,false
Charlie,35,Tokyo,true`;

console.log(JSON.stringify(csvToJson(csv), null, 2));
// [
//   { "name": "Alice", "age": 30, "city": "New York", "active": true },
//   { "name": "Bob", "age": 25, "city": "London", "active": false },
//   { "name": "Charlie", "age": 35, "city": "Tokyo", "active": true }
// ]

// ===== Papa Parse (Browser & Node.js) =====
// npm install papaparse

import Papa from 'papaparse';

// Parse CSV string
const result = Papa.parse(csvString, {
  header: true,         // Use first row as keys
  dynamicTyping: true,  // Auto-detect numbers and booleans
  skipEmptyLines: true, // Ignore blank lines
});

console.log(result.data);   // Array of JSON objects
console.log(result.errors); // Any parsing errors
console.log(result.meta);   // Metadata (delimiter, fields, etc.)

// Parse CSV file (browser)
const fileInput = document.querySelector('input[type="file"]');
fileInput.addEventListener('change', (e) => {
  Papa.parse(e.target.files[0], {
    header: true,
    dynamicTyping: true,
    complete: (results) => {
      console.log(results.data); // JSON array
    },
  });
});

// ===== Node.js: csv-parser (streaming) =====
// npm install csv-parser

const csvParser = require('csv-parser');
const fs = require('fs');

const results = [];
fs.createReadStream('data.csv')
  .pipe(csvParser())
  .on('data', (row) => results.push(row))
  .on('end', () => {
    console.log(JSON.stringify(results, null, 2));
  });

Python : Conversion CSV vers JSON

La conversion CSV vers JSON en Python avec le module csv, pandas, ou json.dumps :

# ===== Python csv module =====
import csv
import json

# CSV string to JSON
csv_string = """name,age,city,active
Alice,30,New York,true
Bob,25,London,false"""

reader = csv.DictReader(csv_string.strip().splitlines())
data = list(reader)
json_output = json.dumps(data, indent=2)
print(json_output)

# CSV file to JSON file
with open('input.csv', 'r', encoding='utf-8') as csv_file:
    reader = csv.DictReader(csv_file)
    data = list(reader)

with open('output.json', 'w', encoding='utf-8') as json_file:
    json.dump(data, json_file, indent=2, ensure_ascii=False)

# ===== pandas (recommended for large datasets) =====
import pandas as pd

# CSV to JSON with pandas
df = pd.read_csv('data.csv')

# Different JSON orientations
print(df.to_json(orient='records', indent=2))  # Array of objects
print(df.to_json(orient='columns', indent=2))  # Object of arrays
print(df.to_json(orient='index', indent=2))     # Object keyed by index

# With type conversion
df['age'] = pd.to_numeric(df['age'], errors='coerce')
df['active'] = df['active'].map({'true': True, 'false': False})

# Save to file
df.to_json('output.json', orient='records', indent=2, force_ascii=False)

# ===== Streaming large CSV files =====
import csv
import json

def csv_to_json_stream(csv_path, json_path, chunk_size=1000):
    """Convert large CSV to JSON using streaming."""
    with open(json_path, 'w') as out:
        out.write('[\n')
        with open(csv_path, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            first = True
            for row in reader:
                if not first:
                    out.write(',\n')
                json.dump(row, out, ensure_ascii=False)
                first = False
        out.write('\n]')

csv_to_json_stream('large_file.csv', 'output.json')

Bash / Ligne de commande : CSV vers JSON

Conversion en ligne de commande avec csvkit, miller, jq et awk :

# ===== csvkit: csvjson command =====
# pip install csvkit

# Basic CSV to JSON conversion
csvjson data.csv > output.json

# Indent output for readability
csvjson --indent 2 data.csv > output.json

# Specify a key column (creates object instead of array)
csvjson --key id data.csv > output.json

# ===== miller (mlr): powerful data processing =====
# brew install miller (macOS) or apt install miller (Linux)

# CSV to JSON
mlr --icsv --ojson cat data.csv > output.json

# CSV to JSON with filtering
mlr --icsv --ojson filter '$age > 25' data.csv

# CSV to JSON with field selection
mlr --icsv --ojson cut -f name,city data.csv

# ===== jq + awk: lightweight approach =====
# Convert simple CSV to JSON with awk
awk -F',' 'NR==1{split($0,h);next}
{printf "{";for(i=1;i<=NF;i++)
printf "%s\"%s\":\"%s\"",
(i>1?",":""),h[i],$i;print "}"}' data.csv | jq -s '.'

# ===== Using sed + jq for quick conversion =====
# Convert CSV to JSON (simple, no quoted fields)
head -1 data.csv | tr ',' '\n' > /tmp/headers.txt
tail -n +2 data.csv | while IFS=',' read -r col1 col2 col3; do
  jq -n --arg a "$col1" --arg b "$col2" --arg c "$col3" \
    '{name:$a, age:($b|tonumber), city:$c}'
done | jq -s '.'

Outils CLI dedies : csvjson et miller

csvjson (csvkit) et miller (mlr) sont des outils specialises pour la conversion de formats de donnees :

# ===== csvkit: full suite of CSV tools =====
# pip install csvkit

# View CSV statistics
csvstat data.csv

# Convert CSV to JSON
csvjson data.csv

# Convert Excel to CSV first, then to JSON
in2csv data.xlsx | csvjson > output.json

# Query CSV with SQL syntax, output as JSON
csvsql --query "SELECT name, age FROM data WHERE age > 25" data.csv | csvjson

# ===== miller (mlr): Swiss Army knife for data =====

# CSV to JSON (pretty-printed)
mlr --icsv --ojson --jflatsep '.' cat data.csv

# CSV to JSON with data transformation
mlr --icsv --ojson put '$full_name = $first . " " . $last' data.csv

# CSV to NDJSON (newline-delimited JSON, one object per line)
mlr --icsv --ojsonl cat data.csv

# Convert between any formats
mlr --icsv --ojson cat data.csv       # CSV -> JSON
mlr --ijson --ocsv cat data.json      # JSON -> CSV
mlr --icsv --otsv cat data.csv        # CSV -> TSV
mlr --itsv --ojson cat data.tsv       # TSV -> JSON

Conversion JSON vers CSV (processus inverse)

Le processus inverse, JSON vers CSV, implique l'aplatissement de donnees JSON hierarchiques en structure tabulaire plate.

Aplatissement des objets imbriques : Les objets imbriques sont aplatis avec une notation par points ou des tirets bas : user.name, user.address.city.

Exemples de conversion JSON vers CSV en JavaScript et Python :

// ===== JavaScript: JSON to CSV =====

function jsonToCsv(jsonArray) {
  if (!jsonArray.length) return '';

  // Flatten nested objects
  function flatten(obj, prefix = '') {
    return Object.keys(obj).reduce((acc, key) => {
      const fullKey = prefix ? prefix + '.' + key : key;
      if (typeof obj[key] === 'object' && obj[key] !== null && !Array.isArray(obj[key])) {
        Object.assign(acc, flatten(obj[key], fullKey));
      } else if (Array.isArray(obj[key])) {
        acc[fullKey] = obj[key].join('|'); // Join arrays with pipe
      } else {
        acc[fullKey] = obj[key];
      }
      return acc;
    }, {});
  }

  const flatData = jsonArray.map(item => flatten(item));
  const headers = [...new Set(flatData.flatMap(Object.keys))];

  const csvRows = [headers.join(',')];
  for (const row of flatData) {
    const values = headers.map(h => {
      const val = row[h] ?? '';
      // Quote values containing commas, quotes, or newlines
      const str = String(val);
      return str.includes(',') || str.includes('"') || str.includes('\n')
        ? '"' + str.replace(/"/g, '""') + '"'
        : str;
    });
    csvRows.push(values.join(','));
  }
  return csvRows.join('\n');
}

// Example with nested JSON
const data = [
  { name: "Alice", address: { city: "NYC", zip: "10001" }, tags: ["dev", "admin"] },
  { name: "Bob", address: { city: "London", zip: "EC1A" }, tags: ["user"] },
];
console.log(jsonToCsv(data));
// name,address.city,address.zip,tags
// Alice,NYC,10001,dev|admin
// Bob,London,EC1A,user

# ===== Python: JSON to CSV =====
import json
import csv
import pandas as pd

# Method 1: pandas (easiest)
with open('data.json') as f:
    data = json.load(f)

df = pd.json_normalize(data, sep='.')  # Flatten nested objects
df.to_csv('output.csv', index=False)

# Method 2: csv module (manual control)
def json_to_csv(json_data, csv_path):
    """Convert JSON array to CSV, handling nested objects."""
    flat_data = [flatten_dict(item) for item in json_data]
    fieldnames = list(dict.fromkeys(
        key for item in flat_data for key in item.keys()
    ))

    with open(csv_path, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(flat_data)

def flatten_dict(d, parent_key='', sep='.'):
    items = []
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_dict(v, new_key, sep).items())
        elif isinstance(v, list):
            items.append((new_key, '|'.join(str(i) for i in v)))
        else:
            items.append((new_key, v))
    return dict(items)

Gestion des cas limites dans l'analyse CSV

Un analyseur CSV robuste doit gerer de nombreux cas limites :

BOM UTF-8 : Certaines applications ajoutent un BOM invisible au debut du fichier. Votre analyseur doit le supprimer.

Variations de delimiteurs : Point-virgule en Europe, tabulation pour TSV. Un bon analyseur detecte automatiquement le delimiteur.

Valeurs manquantes : Virgules en fin de ligne ou champs vides au milieu. Le parseur doit les preserver comme chaines vides ou null.

Champs multilignes : RFC 4180 autorise les valeurs sur plusieurs lignes entre guillemets doubles.

Caracteres speciaux : Les guillemets doubles dans un champ cite sont echappes par doublement : "Il a dit ""bonjour""".

Longueurs de lignes inconsistantes : Un analyseur resilient doit combler les lignes courtes ou tronquer les longues.

// Robust CSV parser handling all edge cases
function parseCSV(text, delimiter = ',') {
  // Strip UTF-8 BOM if present
  if (text.charCodeAt(0) === 0xFEFF) {
    text = text.slice(1);
  }

  const rows = [];
  let row = [];
  let field = '';
  let inQuotes = false;

  for (let i = 0; i < text.length; i++) {
    const char = text[i];
    const next = text[i + 1];

    if (inQuotes) {
      if (char === '"' && next === '"') {
        field += '"'; // Escaped quote
        i++;          // Skip next quote
      } else if (char === '"') {
        inQuotes = false; // End of quoted field
      } else {
        field += char; // Regular char inside quotes
      }
    } else {
      if (char === '"') {
        inQuotes = true; // Start quoted field
      } else if (char === delimiter) {
        row.push(field);
        field = '';
      } else if (char === '\n' || (char === '\r' && next === '\n')) {
        row.push(field);
        rows.push(row);
        row = [];
        field = '';
        if (char === '\r') i++; // Skip \n in \r\n
      } else {
        field += char;
      }
    }
  }

  // Push last field and row
  if (field || row.length) {
    row.push(field);
    rows.push(row);
  }

  return rows;
}

Bonnes pratiques CSV

Suivez ces bonnes pratiques pour une compatibilite maximale :

Toujours utiliser l'encodage UTF-8 : standard universel pour l'encodage de texte.

Citer les champs de maniere coherente : l'approche la plus sure est de citer tous les champs.

Inclure une ligne d'en-tete : toujours avec des noms descriptifs et des conventions de nommage coherentes.

Utiliser des delimiteurs coherents : un seul delimiteur dans tout le fichier.

Traiter les gros fichiers en streaming : utiliser des analyseurs en flux pour les fichiers depassant la memoire.

Valider les donnees apres conversion : verifier le nombre d'enregistrements, les types et l'integrite.

Questions frequemment posees

Comment convertir CSV en JSON ?

Analysez la ligne d'en-tete pour obtenir les noms de colonnes, puis mappez chaque ligne a ses cles correspondantes. Utilisez des bibliotheques comme Papa Parse (JavaScript) ou pandas (Python), ou notre outil en ligne gratuit.

Quelle est la difference entre CSV et JSON ?

CSV est un format tabulaire plat ou toutes les valeurs sont des chaines. JSON est hierarchique avec support des objets imbriques, tableaux et types multiples. CSV est plus compact, JSON plus expressif.

Le CSV peut-il gerer des donnees imbriquees ?

Non, CSV ne supporte pas nativement les structures imbriquees. Il faut aplatir les donnees avec des techniques comme la notation par points ou l'encodage JSON dans les champs CSV.

La conversion CSV vers JSON est une competence fondamentale pour les developpeurs et analystes de donnees. Utilisez notre outil gratuit pour des conversions instantanees.

Convertissez CSV en JSON et JSON en CSV instantanement avec notre outil gratuit.