CSV to JSON JavaScript — Converter + Code Examples

La plupart des données CSV que je rencontre arrivent sous forme de chaîne plate depuis un upload de fichier, un export de base de données, ou une API qui parle encore le format des années 1970. Pour convertir du CSV en JSON en JavaScript, tu as besoin de deux choses que le langage te offre gratuitement : le découpage de chaînes pour analyser les lignes et JSON.stringify() pour sérialiser le résultat. Aucun package npm requis pour les bases — ce guide couvre l\'intégralité du pipeline depuis un utilitaire csvToJson() réutilisable jusqu'à PapaParse et les entrées/sorties de fichiers Node.js. Pour des conversions rapides sans code, le convertisseur CSV vers JSON en ligne s'en charge instantanément. Tous les exemples ciblent Node.js 18+ et les navigateurs modernes.

Qu'est-ce que la conversion CSV vers JSON ?

La conversion CSV vers JSON transforme un format texte plat délimité par des virgules en un tableau structuré d'objets où chaque ligne devient un objet JavaScript dont les clés viennent des en-têtes de colonnes. Le format CSV n'a pas de types de données — tout est une chaîne. JSON ajoute une structure, de l'imbrication et des types explicites (nombres, booléens, null). Cette conversion est la première étape de presque chaque pipeline de données qui commence par un export de tableur, un dump de système legacy ou un fichier uploadé par l'utilisateur. Les données sous-jacentes restent les mêmes ; le format passe de colonnes positionnelles à des propriétés nommées.

name,email,role,active
Marie Dupont,mdupont@nexuslabs.io,Engineering Lead,true
Thomas Martin,tmartin@nexuslabs.io,Product Manager,true

[
  {
    "name": "Marie Dupont",
    "email": "mdupont@nexuslabs.io",
    "role": "Engineering Lead",
    "active": "true"
  },
  {
    "name": "Thomas Martin",
    "email": "tmartin@nexuslabs.io",
    "role": "Product Manager",
    "active": "true"
  }
]

csvToJson() — Construire une fonction de conversion réutilisable

Le pipeline complet CSV vers JSON en JavaScript se décompose en trois étapes : découper la chaîne CSV par saut de ligne pour obtenir les lignes, extraire les en-têtes de la première ligne avec split(','), puis mapper chaque ligne restante vers un objet JavaScript ordinaire dont les clés viennent des en-têtes et les valeurs des positions de colonnes correspondantes. L'appel final à JSON.stringify() convertit ce tableau d'objets en chaîne JSON. Voici une version minimale fonctionnelle :

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

  const rows = lines.slice(1)
    .filter(line => line.trim() !== '')
    .map(line => {
      const values = line.split(',')
      return Object.fromEntries(
        headers.map((header, i) => [header, values[i]?.trim()])
      )
    })

  return JSON.stringify(rows, null, 2)
}

const csv = `server,port,region,status
api-gateway,8080,eu-west-3,healthy
auth-service,8443,eu-west-1,degraded
payments-api,9090,ap-south-1,healthy`

console.log(csvToJson(csv))
// [
//   { "server": "api-gateway", "port": "8080", "region": "eu-west-3", "status": "healthy" },
//   { "server": "auth-service", "port": "8443", "region": "eu-west-1", "status": "degraded" },
//   { "server": "payments-api", "port": "9090", "region": "ap-south-1", "status": "healthy" }
// ]

Cette fonction gère les bases : les sauts de ligne en fin de chaîne, les lignes vides, les espaces autour des valeurs. Chaque champ CSV passe sous forme de chaîne. Remarque que port est "8080" (une chaîne), pas 8080 (un nombre). Si tu as besoin de types corrects dans la sortie JSON, tu dois les contraindre toi-même. Voici une version étendue avec détection de type :

function coerceValue(val) {
  if (val === undefined || val === '') return null
  if (val === 'true') return true
  if (val === 'false') return false
  if (val === 'null') return null
  const num = Number(val)
  if (!isNaN(num) && val.trim() !== '') return num
  return val
}

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

  const rows = lines.slice(1)
    .filter(line => line.trim() !== '')
    .map(line => {
      const values = line.split(',')
      return Object.fromEntries(
        headers.map((header, i) => [
          header,
          coerce ? coerceValue(values[i]?.trim()) : values[i]?.trim()
        ])
      )
    })

  return JSON.stringify(rows, null, 2)
}

const csv = `endpoint,port,max_connections,debug
/api/v2/orders,8443,500,true
/api/v2/health,8080,100,false`

console.log(csvToJson(csv, { coerce: true }))
// [
//   { "endpoint": "/api/v2/orders", "port": 8443, "max_connections": 500, "debug": true },
//   { "endpoint": "/api/v2/health", "port": 8080, "max_connections": 100, "debug": false }
// ]

L'indicateur coerce est opt-in car la détection automatique de types peut se retourner contre toi — un champ comme un code postal ("75001") perd son zéro initial quand il est converti en nombre. Garde la coercition désactivée par défaut et active-la seulement quand tu contrôles le schéma. Petit rappel : JSON.stringify() accepte un troisième argument space pour l'indentation. Passe 2 pour deux espaces, 4 pour quatre, ou "\t" pour des tabulations. Omets-le entièrement pour une sortie compacte sur une seule ligne — utile quand tu envoies la chaîne JSON comme corps d'une requête API où les espaces gaspillent simplement de la bande passante.

Gérer les Maps, Dates et objets personnalisés issus de données CSV

Toute conversion CSV ne se termine pas avec un tableau plat d'objets ordinaires. Parfois tu dois construire une Map depuis des paires en-tête/valeur, analyser des chaînes de dates en objets Date, ou attacher des propriétés calculées avant la sérialisation. JavaScript a un comportement particulier qui piège les gens : les instances Map ne se sérialisent pas avec JSON.stringify(). Tu obtiens un objet vide. La solution est Object.fromEntries() pour convertir la Map en objet ordinaire avant de la sérialiser.

La raison pour laquelle Map se sérialise en {} est que JSON.stringify() itère sur les propriétés énumérables propres d'un objet. Une Map stocke ses entrées dans un slot interne, pas en tant que propriétés énumérables sur l'objet lui-même, donc le sérialiseur voit un objet sans clés. Le prototype Map manque également d'une méthode toJSON(), qui est le point d'accroche que JSON.stringify() appelle en premier sur toute valeur avant de décider comment la sérialiser. Si une valeur a toJSON(), la valeur de retour de la méthode est ce qui est sérialisé — pas l'objet lui-même. C'est pourquoi les objets Date se sérialisent correctement : Date.prototype.toJSON retourne une chaîne ISO 8601, donc JSON.stringify(new Date()) produit un horodatage entre guillemets plutôt qu'un objet vide. Comprendre ce point d'accroche te permet de définir le même comportement sur tes propres classes — comme montré dans l'exemple EmployeeRecord ci-dessous — pour contrôler exactement quels champs issus du CSV apparaissent dans la sortie JSON finale.

Convertir une Map en JSON

// Construire une Map depuis des paires en-tête→valeur CSV
const headers = ['server', 'port', 'region']
const values = ['payments-api', '9090', 'ap-south-1']
const rowMap = new Map(headers.map((h, i) => [h, values[i]]))

// Map ne se sérialise PAS directement
console.log(JSON.stringify(rowMap))
// "{}"  — objet vide, données perdues !

// Convertir en objet ordinaire d'abord
const rowObj = Object.fromEntries(rowMap)
console.log(JSON.stringify(rowObj, null, 2))
// {
//   "server": "payments-api",
//   "port": "9090",
//   "region": "ap-south-1"
// }

Chaînes de dates et toJSON()

Les champs de date CSV arrivent sous forme de chaînes. Si tu les analyses en objets Date durant le traitement, ces Dates se sérialisent correctement car Date dispose d'une méthode toJSON() intégrée qui retourne une chaîne ISO 8601. Tu peux aussi définir un toJSON() personnalisé sur tes propres classes pour contrôler quelles colonnes CSV apparaissent dans la sortie sérialisée — par exemple, en omettant les champs de suivi internes comme _rowIndex.

class EmployeeRecord {
  constructor(csvRow) {
    this._rowIndex = csvRow._rowIndex  // interne, pas pour JSON
    this.employeeId = csvRow.employee_id
    this.name = csvRow.name
    this.hiredAt = new Date(csvRow.hired_date)
    this.salary = Number(csvRow.salary)
  }

  toJSON() {
    // N'exposer que les champs souhaités dans la sortie JSON
    return {
      employee_id: this.employeeId,
      name: this.name,
      hired_at: this.hiredAt,  // Date.toJSON() → chaîne ISO automatiquement
      salary: this.salary,
    }
  }
}

const csvRow = {
  _rowIndex: 42,
  employee_id: 'EMP-2847',
  name: 'Marie Dupont',
  hired_date: '2024-03-15',
  salary: '128000',
}

const record = new EmployeeRecord(csvRow)
console.log(JSON.stringify(record, null, 2))
// {
//   "employee_id": "EMP-2847",
//   "name": "Marie Dupont",
//   "hired_at": "2024-03-15T00:00:00.000Z",
//   "salary": 128000
// }
// Note : _rowIndex est exclu, salary est un nombre, la date est au format ISO

Reviver pour la désérialisation des dates

Après avoir écrit le JSON issu du CSV dans un fichier ou l'avoir envoyé sur le réseau, JSON.parse() te retourne des objets ordinaires — les objets Date redeviennent des chaînes. Utilise une fonction reviver pour reconvertir les chaînes ISO 8601 en objets Date lors de l'analyse :

const jsonString = '{"employee_id":"EMP-2847","name":"Marie Dupont","hired_at":"2024-03-15T00:00:00.000Z","salary":128000}'

const isoDatePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/

const parsed = JSON.parse(jsonString, (key, value) => {
  if (typeof value === 'string' && isoDatePattern.test(value)) {
    return new Date(value)
  }
  return value
})

console.log(parsed.hired_at instanceof Date)  // true
console.log(parsed.hired_at.getFullYear())    // 2024

Référence des paramètres de JSON.stringify()

La signature de la fonction est JSON.stringify(value, replacer?, space?). Les arguments replacer et space sont tous deux optionnels — passe null pour le replacer quand tu as seulement besoin d'indentation.

Paramètres de JSON.parse() :

JSON.parse() — Consommer la sortie JSON

Une fois que tu as une chaîne JSON depuis csvToJson(), l'étape suivante est généralement de la réanalyser en tableau JavaScript vivant pour filtrer, mapper ou alimenter une API. La différence entre une chaîne JSON (typeof === "string") et un objet JavaScript est importante. Tu ne peux pas appeler .filter() ni accéder à [0].name sur une chaîne — tu as besoin de JSON.parse() d'abord. Cet aller-retour (stringify puis parse) fonctionne aussi comme technique de validation : si ta conversion CSV produit quelque chose qui n'est pas du JSON valide, parse lèvera une erreur. L'argument optionnel reviver te permet de transformer chaque paire clé-valeur lors de l'analyse — utile pour restaurer des objets Date depuis des chaînes ISO ou renommer des clés sans passe supplémentaire.

const csv = `endpoint,method,avg_latency_ms,error_rate
/api/v2/orders,POST,342,0.02
/api/v2/health,GET,12,0.00
/api/v2/payments,POST,890,0.15
/api/v2/users,GET,45,0.01`

// Étape 1 : convertir le CSV en chaîne JSON
const jsonString = csvToJson(csv, { coerce: true })

// Étape 2 : réanalyser en tableau JavaScript
const endpoints = JSON.parse(jsonString)

// Vérifier que c'est un tableau
console.log(Array.isArray(endpoints))  // true

// Filtrer les endpoints à latence élevée
const slow = endpoints.filter(ep => ep.avg_latency_ms > 200)
console.log(slow.map(ep => ep.endpoint))
// ["/api/v2/orders", "/api/v2/payments"]

// Déstructurer la première ligne
const [first, ...rest] = endpoints
console.log(first.endpoint)  // "/api/v2/orders"
console.log(rest.length)     // 3

Un wrapper sécurisé pour JSON.parse() est utile pour valider la sortie de conversion avant un traitement en aval. Si la conversion CSV produit du JSON malformé pour une raison quelconque (entrée tronquée, erreurs d'encodage), cela le capture sans faire planter le programme :

function safeParse(jsonString) {
  try {
    return { data: JSON.parse(jsonString), error: null }
  } catch (err) {
    return { data: null, error: err.message }
  }
}

// Sortie valide
const result = safeParse(csvToJson(csv))
if (result.error) {
  console.error('La conversion CSV a produit du JSON invalide :', result.error)
} else {
  console.log(`${result.data.length} lignes analysées`)
}

// Passer du CSV brut à JSON.parse — cela échoue
const bad = safeParse('name,email\nMarie,mdupont@nexuslabs.io')
console.log(bad.error)  // "Unexpected token 'a', "name,email"... is not valid JSON"

Reviver pour le renommage de clés et la validation

La fonction reviver reçoit chaque paire clé-valeur lors de l'analyse, des propriétés les plus internes vers l'extérieur. Retourner undefined pour une clé la supprime entièrement du résultat ; retourner une valeur différente la remplace. Le reviver est utile pour renommer les en-têtes (camelCase vers snake_case), supprimer des champs internes, ou vérifier que les colonnes requises existent. Il est appelé avec la valeur racine en dernier (clé chaîne vide), ce qui est l'endroit où tu lèves une erreur si le résultat n'est pas un tableau.

const jsonString = csvToJson(`employeeId,firstName,hiredDate
EMP-2847,Marie,2024-03-15
EMP-3012,Thomas,2023-11-01`, { coerce: false })

const camelToSnake = str => str.replace(/[A-Z]/g, c => '_' + c.toLowerCase())

const employees = JSON.parse(jsonString, function(key, value) {
  // Valeur racine — valider la forme
  if (key === '') {
    if (!Array.isArray(value)) throw new Error('Expected JSON array from CSV')
    return value
  }
  // Renommer les clés d'en-tête camelCase en snake_case
  if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
    return Object.fromEntries(
      Object.entries(value).map(([k, v]) => [camelToSnake(k), v])
    )
  }
  return value
})

console.log(employees[0])
// { employee_id: 'EMP-2847', first_name: 'Marie', hired_date: '2024-03-15' }

Convertir du CSV depuis un fichier et une réponse API

Les deux endroits d'où proviennent réellement les données CSV en production : les fichiers sur disque et les réponses HTTP. Les deux scénarios nécessitent une gestion d'erreurs car l'entrée est externe et non contrôlée.

Lire un fichier CSV, convertir, écrire en JSON

import { readFileSync, writeFileSync } from 'node:fs'

function csvToJsonFromFile(inputPath, outputPath) {
  let csvText
  try {
    csvText = readFileSync(inputPath, 'utf8')
  } catch (err) {
    throw new Error(`Échec de lecture de ${inputPath} : ${err.message}`)
  }

  const lines = csvText.trim().split('\n')
  if (lines.length < 2) {
    throw new Error(`${inputPath} n'a pas de lignes de données (seulement ${lines.length} ligne)`)
  }

  const headers = lines[0].split(',').map(h => h.trim())
  const rows = lines.slice(1)
    .filter(line => line.trim() !== '')
    .map(line => {
      const values = line.split(',')
      return Object.fromEntries(headers.map((h, i) => [h, values[i]?.trim()]))
    })

  const jsonOutput = JSON.stringify(rows, null, 2)
  writeFileSync(outputPath, jsonOutput, 'utf8')
  console.log(`${rows.length} lignes converties → ${outputPath}`)
  return rows
}

// Utilisation
const data = csvToJsonFromFile('inventory.csv', 'inventory.json')
console.log(data[0])
// { sku: "WDG-2847", warehouse: "eu-west-3", quantity: "150", ... }

Récupérer du CSV depuis un endpoint API

async function fetchCsvAsJson(url) {
  const response = await fetch(url)
  if (!response.ok) {
    throw new Error(`HTTP ${response.status} : ${response.statusText}`)
  }

  const contentType = response.headers.get('content-type') || ''
  if (!contentType.includes('text/csv') && !contentType.includes('text/plain')) {
    console.warn(`Content-type inattendu : ${contentType}`)
  }

  const csvText = await response.text()
  const lines = csvText.trim().split('\n')
  const headers = lines[0].split(',').map(h => h.trim())
  const rows = lines.slice(1)
    .filter(line => line.trim() !== '')
    .map(line => {
      const values = line.split(',')
      return Object.fromEntries(headers.map((h, i) => [h, values[i]?.trim()]))
    })

  return rows
}

// Exemple : récupérer un CSV de taux de change depuis un fournisseur de données
try {
  const rates = await fetchCsvAsJson('https://data.ecb.internal/rates/daily.csv')
  console.log(JSON.stringify(rates.slice(0, 3), null, 2))
  // Envoyer en JSON au service en aval
  await fetch('https://api.internal/v2/rates', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ data: rates }),
  })
} catch (err) {
  console.error('Synchronisation des taux échouée :', err.message)
}

Conversion CSV vers JSON en ligne de commande

Node.js peut exécuter des scripts en ligne, et il existe des outils CLI dédiés qui gèrent la conversion CSV vers JSON sans écrire de script.

# Piper du CSV vers un script Node.js en ligne
cat servers.csv | node -e "
  const lines = require('fs').readFileSync('/dev/stdin','utf8').trim().split('\n');
  const h = lines[0].split(',');
  const rows = lines.slice(1).map(l => Object.fromEntries(h.map((k,i) => [k.trim(), l.split(',')[i]?.trim()])));
  console.log(JSON.stringify(rows, null, 2));
"

# Miller est un couteau suisse pour les données structurées
# Installation : brew install miller (macOS) ou apt install miller (Debian/Ubuntu)
mlr --icsv --ojson cat inventory.csv

# Filtrer les lignes lors de la conversion
mlr --icsv --ojson filter '$quantity > 100' inventory.csv

# Sélectionner des colonnes spécifiques
mlr --icsv --ojson cut -f sku,warehouse,quantity inventory.csv

# Installation globale
npm install -g csvtojson

# Convertir un fichier
csvtojson servers.csv > servers.json

# Piper depuis stdin
cat exports/q1-metrics.csv | csvtojson > q1-metrics.json

Pour les gros fichiers, Miller est généralement le meilleur choix par rapport à csvtojson. Miller est implémenté en C et traite le CSV en flux sans charger le fichier entier en mémoire, ce qui lui permet de gérer des exports de plusieurs gigaoctets avec une utilisation mémoire constante. Il supporte aussi les opérations au niveau des champs en place — renommer des colonnes, contraindre les types, filtrer les lignes — avant que les données ne deviennent du JSON, évitant ainsi un pipeline d'analyse-puis-transformation en deux étapes. csvtojson, en revanche, tourne dans Node.js et est plus pratique quand le reste de ta chaîne d'outils est en JavaScript : tu peux piper sa sortie directement dans les streams Node, l'importer comme bibliothèque, ou utiliser son API colParser pour la coercition de type par colonne dans le code. Préfère Miller pour le débit brut et les pipelines shell ; préfère csvtojson quand tu as besoin d'une intégration étroite avec une application Node.js.

Alternative haute performance — PapaParse

L'approche manuelle avec split(',') échoue sur les fichiers CSV du monde réel. Les champs entre guillemets contenant des virgules, les sauts de ligne intégrés, les guillemets doubles échappés — tout cela casse un découpeur naïf. PapaParse est la bibliothèque vers laquelle je me tourne quand le CSV provient d'une source inconnue. Elle gère chaque cas limite RFC 4180, détecte automatiquement les délimiteurs, et fonctionne aussi bien dans Node.js que dans les navigateurs.

npm install papaparse

import Papa from 'papaparse'

const csv = `product,description,price,in_stock
"Widget, Large","A premium widget with ""extra"" features",29.99,true
Bolt Assembly,Standard M8 bolt kit,4.50,true
"Gasket Set","Includes gasket, seal, and O-ring",12.75,false`

const { data, errors, meta } = Papa.parse(csv, {
  header: true,
  dynamicTyping: true,     // convertit automatiquement les nombres et booléens
  skipEmptyLines: true,
  transformHeader: h => h.trim().toLowerCase().replace(/\s+/g, '_'),
})

if (errors.length > 0) {
  console.error('Erreurs d'analyse :', errors)
}

console.log(JSON.stringify(data, null, 2))
// [
//   {
//     "product": "Widget, Large",
//     "description": "A premium widget with \"extra\" features",
//     "price": 29.99,
//     "in_stock": true
//   },
//   ...
// ]
console.log(`${data.length} lignes analysées, délimiteur : "${meta.delimiter}"`)

L'option dynamicTyping de PapaParse effectue la coercition de type automatiquement — les nombres deviennent des nombres, "true"/"false" deviennent des booléens. Le callback transformHeader normalise les noms de colonnes en snake_case, ce qui évite de traiter des en-têtes incohérents venant de différents exports CSV. Pour des conversions rapides sans écrire de code d'analyse, le convertisseur CSV vers JSON gère tout cela dans le navigateur.

Sortie terminal avec coloration syntaxique

Afficher un grand tableau JSON dans le terminal fait rapidement fatiguer les yeux. Ajouter de la coloration syntaxique à la sortie la rend lisible lors du débogage et du développement. Le package cli-highlight colorise la sortie JSON dans les terminaux Node.js.

npm install cli-highlight

import { highlight } from 'cli-highlight'

// Après la conversion du CSV en tableau JSON
const jsonOutput = JSON.stringify(rows, null, 2)

// Afficher avec coloration syntaxique
console.log(highlight(jsonOutput, { language: 'json' }))
// Clés, chaînes, nombres et booléens ont chacun une couleur distincte

La sortie colorisée mérite son utilité quand tu inspectes un grand résultat de conversion de manière interactive. Les clés JSON, les valeurs de chaînes, les nombres et les booléens ont chacun des couleurs ANSI distinctes, ce qui facilite l'identification d'un champ dont le type est incorrect — par exemple, un numéro de port qui devrait être 8080 mais qui est surligné comme une chaîne parce que la coercition était désactivée. C'est particulièrement utile lors du débogage de fichiers CSV exportés depuis des tableurs où les types de colonnes sont incohérents d'une ligne à l'autre. Sans couleur, analyser 50 lignes de JSON pour trouver un seul champ mal typé signifie lire chaque valeur individuellement. Avec la couleur, un nombre colorié en chaîne saute aux yeux immédiatement.

Travailler avec de gros fichiers CSV

Charger un fichier CSV de 500 Mo dans une chaîne avec readFileSync() va consommer de la mémoire et potentiellement faire planter ton processus. Pour les gros fichiers, traite le CSV ligne par ligne en flux et émets les objets JSON au fur et à mesure. Le package csv-parse (faisant partie de l'écosystème csv sur npm) fournit un analyseur en flux qui fonctionne avec les streams Node.js.

Streaming CSV vers NDJSON avec csv-parse

NDJSON (JSON délimité par des sauts de ligne) est un format où chaque ligne du fichier de sortie est un objet JSON autonome. Contrairement à un seul grand tableau JSON — qui nécessite que le fichier entier soit en mémoire avant de pouvoir commencer à le lire — les fichiers NDJSON peuvent être traités ligne par ligne. Cela rend NDJSON idéal pour les grands ensembles de données qui seront consommés par des processeurs de logs, des pipelines de flux, ou des bases de données avec des API d'import en masse. Le package csv-parse émet un objet JavaScript par ligne CSV en mode objet, tu peux donc le piper directement dans un stream de transformation qui ajoute \n après chaque JSON.stringify(row).

import { createReadStream, createWriteStream } from 'node:fs'
import { parse } from 'csv-parse'
import { Transform } from 'node:stream'
import { pipeline } from 'node:stream/promises'

// Transformer chaque objet ligne CSV en ligne JSON
const toNdjson = new Transform({
  objectMode: true,
  transform(record, encoding, callback) {
    callback(null, JSON.stringify(record) + '\n')
  },
})

await pipeline(
  createReadStream('telemetry-2026-03.csv'),
  parse({
    columns: true,       // utiliser la première ligne comme en-têtes
    skip_empty_lines: true,
    trim: true,
    cast: true,          // convertir automatiquement les nombres et booléens
  }),
  toNdjson,
  createWriteStream('telemetry-2026-03.ndjson')
)

console.log('Conversion en flux terminée')
// Chaque ligne du fichier de sortie est un objet JSON :
// {"timestamp":"2026-03-15T08:22:00Z","service":"gateway","latency_ms":42,"status":200}
// {"timestamp":"2026-03-15T08:22:01Z","service":"auth","latency_ms":156,"status":401}
// ...

Streaming PapaParse pour navigateur et Node.js

Le mode streaming de PapaParse utilise un callback step qui se déclenche une fois par ligne plutôt que de collecter toutes les lignes en mémoire. Tu lui passes un ReadStream Node.js (dans Node.js) ou un objet File (dans le navigateur) et PapaParse gère le découpage en chunks en interne. Aucun pipeline de stream à câbler — juste un callback. Utilise-le quand tu as besoin de la conformité RFC 4180 sans intégrer csv-parse.

import Papa from 'papaparse'
import { createReadStream } from 'node:fs'

let rowCount = 0
const errors = []

const fileStream = createReadStream('warehouse-inventory.csv')

Papa.parse(fileStream, {
  header: true,
  dynamicTyping: true,
  step(result) {
    // Traiter une ligne à la fois — mémoire constante
    rowCount++
    if (result.data.quantity === 0) {
      errors.push(`Ligne ${rowCount} : ${result.data.sku} est en rupture de stock`)
    }
  },
  complete() {
    console.log(`${rowCount} lignes traitées`)
    if (errors.length > 0) {
      console.log(`Problèmes trouvés : ${errors.length}`)
      errors.forEach(e => console.log(`  ${e}`))
    }
  },
  error(err) {
    console.error('Analyse échouée :', err.message)
  },
})

Erreurs courantes

const csv = 'name,email\nMarie Dupont,mdupont@nexuslabs.io'
const data = JSON.parse(csv)
// SyntaxError: Unexpected token 'a'

const csv = 'name,email\nMarie Dupont,mdupont@nexuslabs.io'
const lines = csv.trim().split('\n')
const headers = lines[0].split(',')
const rows = lines.slice(1).map(line =>
  Object.fromEntries(headers.map((h, i) => [h, line.split(',')[i]]))
)
const json = JSON.stringify(rows, null, 2)  // chaîne JSON valide

const row = { server: 'api-gateway', port: 8080 }
const output = row.toString()
// "[object Object]"  — les données sont perdues

const row = { server: 'api-gateway', port: 8080 }
const output = JSON.stringify(row, null, 2)
// '{"server":"api-gateway","port":8080}'

const line = '"Widget, Large","Premium quality",29.99'
const values = line.split(',')
// ["\"Widget", " Large\"", "\"Premium quality\"", "29.99"]
// 4 valeurs au lieu de 3 — premier champ découpé incorrectement

import Papa from 'papaparse'
const { data } = Papa.parse('"Widget, Large","Premium quality",29.99')
// data[0] = ["Widget, Large", "Premium quality", "29.99"]
// 3 valeurs, correctement analysées

const row = { port: '8443', debug: 'true', workers: '4' }
JSON.stringify(row)
// {"port":"8443","debug":"true","workers":"4"}  — tout est chaîne

const row = {
  port: Number('8443'),           // 8443
  debug: 'true' === 'true',      // true
  workers: Number('4'),           // 4
}
JSON.stringify(row)
// {"port":8443,"debug":true,"workers":4}  — types corrects

Analyse manuelle vs bibliothèques — Comparaison rapide

Pour les scripts rapides où tu contrôles le format CSV et sais qu'il n'y a pas de champs entre guillemets, l'approche intégrée split() + JSON.stringify() fonctionne et ne requiert aucune dépendance. Pour les systèmes de production traitant des fichiers CSV uploadés par des utilisateurs, utilise PapaParse dans le navigateur ou csv-parse dans Node.js — les deux gèrent RFC 4180 correctement et supportent le streaming. Le package csvtojson est le seul à produire du JSON directement, gérant à la fois l'analyse et la sérialisation en un seul appel. Quand tu as besoin du chemin le plus rapide du collé au résultat, le convertisseur CSV vers JSON gère tout cela dans le navigateur sans aucune configuration.

Questions fréquentes

const csv = `name,email,department
Marie Dupont,mdupont@nexuslabs.io,Engineering
Thomas Martin,tmartin@nexuslabs.io,Product`

const lines = csv.trim().split('\n')
const headers = lines[0].split(',')
const rows = lines.slice(1).map(line => {
  const values = line.split(',')
  return Object.fromEntries(headers.map((h, i) => [h.trim(), values[i]?.trim()]))
})

console.log(JSON.stringify(rows, null, 2))
// [
//   { "name": "Marie Dupont", "email": "mdupont@nexuslabs.io", "department": "Engineering" },
//   { "name": "Thomas Martin", "email": "tmartin@nexuslabs.io", "department": "Product" }
// ]

const row = { name: 'Marie Dupont', role: 'Engineer' }

console.log(row.toString())       // "[object Object]"
console.log(JSON.stringify(row))   // '{"name":"Marie Dupont","role":"Engineer"}'

// PapaParse gère RFC 4180 correctement
import Papa from 'papaparse'

const csv = `product,description,price
"Widget, Large","A big ""widget""",29.99
Bolt,Standard bolt,1.50`

const { data } = Papa.parse(csv, { header: true })
console.log(JSON.stringify(data, null, 2))
// description field correctly contains: A big "widget"

// Navigateur : l'utilisateur uploade un fichier CSV
const fileInput = document.querySelector('input[type="file"]')
fileInput.addEventListener('change', async (event) => {
  const file = event.target.files[0]
  const text = await file.text()
  const lines = text.trim().split('\n')
  const headers = lines[0].split(',')
  const rows = lines.slice(1).map(line =>
    Object.fromEntries(headers.map((h, i) => [h.trim(), line.split(',')[i]?.trim()]))
  )
  console.log(JSON.stringify(rows, null, 2))
})

function coerceValue(val) {
  if (val === '') return null
  if (val === 'true') return true
  if (val === 'false') return false
  const num = Number(val)
  if (!isNaN(num) && val.trim() !== '') return num
  return val
}

// Appliqué lors du mapping CSV vers objet
const row = { port: coerceValue('8443'), debug: coerceValue('true'), host: coerceValue('api.internal') }
// { port: 8443, debug: true, host: "api.internal" }

import { writeFileSync, readFileSync } from 'node:fs'

// Écriture
const jsonOutput = JSON.stringify(rows, null, 2)
writeFileSync('employees.json', jsonOutput, 'utf8')

// Lecture en retour
const parsed = JSON.parse(readFileSync('employees.json', 'utf8'))
console.log(Array.isArray(parsed))  // true
console.log(parsed[0].name)         // "Marie Dupont"

Outils associés