Convertidor CSV a JSON: Guia Completa con Ejemplos de Codigo

La conversion de CSV a JSON es una de las tareas de transformacion de datos mas comunes. Ya sea migrando datos entre sistemas, construyendo APIs o procesando hojas de calculo, convertir CSV a JSON eficientemente es esencial. Esta guia completa cubre herramientas de conversion, algoritmos de analisis, ejemplos de codigo en JavaScript, Python y Bash, y mejores practicas.

Prueba nuestra herramienta gratuita de conversion CSV a JSON en linea.

Que es CSV?

CSV significa Comma-Separated Values (valores separados por comas), un formato de texto plano definido por RFC 4180 para almacenar datos tabulares. Cada linea representa un registro, los valores se separan por comas u otros delimitadores. La primera fila sirve como encabezado.

El formato CSV se usa desde los inicios de la informatica y sigue siendo popular por su simplicidad. Cualquier editor de texto, hoja de calculo o lenguaje de programacion puede leer y escribir CSV. A pesar de su simplicidad, el analizador CSV debe manejar varios casos complicados.

Cuando usar CSV o JSON: CSV es ideal para datos tabulares planos como exportaciones de hojas de calculo. JSON es mejor para estructuras jerarquicas, respuestas de API y archivos de configuracion.

CSV vs JSON: Comparacion detallada

Entender las diferencias ayuda a elegir el formato correcto y comprender el proceso de conversion:

Como funciona la conversion CSV a JSON

El proceso del convertidor CSV a JSON incluye varios pasos:

Ejemplo: CSV name,age,active\nAlice,30,true produce [{"name":"Alice","age":30,"active":true}].

Ejemplos de codigo CSV a JSON

JavaScript: Conversion CSV a JSON

Varios enfoques para la conversion CSV a JSON en JavaScript: metodo nativo, Papa Parse y csv-parser para 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 a JSON

CSV a JSON en Python con el modulo csv, pandas o 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 / Linea de comandos: CSV a JSON

Conversion en linea de comandos con csvkit, miller, jq y 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 '.'

Herramientas CLI dedicadas: csvjson y miller

csvjson (csvkit) y miller (mlr) son herramientas especializadas para conversion de formatos:

# ===== 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 a CSV (proceso inverso)

El proceso inverso, JSON a CSV, implica aplanar datos JSON jerarquicos en una estructura tabular plana.

Aplanar objetos anidados: Los objetos anidados se aplanan con notacion de puntos o guiones bajos: user.name, user.address.city.

Ejemplos de conversion JSON a CSV en JavaScript y 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)

Manejo de casos limite en el analisis CSV

Un analizador CSV robusto debe manejar numerosos casos limite:

BOM UTF-8: Algunas aplicaciones agregan un BOM invisible al inicio. Su analizador debe eliminarlo.

Variaciones de delimitadores: Punto y coma en Europa, tabulacion para TSV. Un buen analizador detecta automaticamente.

Valores faltantes: Comas al final o campos vacios. El parser debe preservarlos como cadenas vacias o null.

Campos multilinea: RFC 4180 permite valores en multiples lineas entre comillas dobles.

Caracteres especiales: Comillas dobles en campos citados se escapan duplicandolas.

Longitudes de fila inconsistentes: Un analizador resiliente debe rellenar filas cortas o truncar largas.

// 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;
}

Mejores practicas CSV

Siga estas mejores practicas para maxima compatibilidad:

Siempre usar codificacion UTF-8: estandar universal para codificacion de texto.

Citar campos consistentemente: lo mas seguro es citar todos los campos.

Incluir fila de encabezado: siempre con nombres descriptivos y convenciones consistentes.

Usar delimitadores consistentes: un solo delimitador en todo el archivo.

Procesar archivos grandes en streaming: parsers en flujo para archivos que excedan la memoria.

Validar datos despues de la conversion: verificar cantidad de registros, tipos e integridad.

Preguntas frecuentes

Como convierto CSV a JSON?

Analice la fila de encabezado para obtener nombres de columnas, luego mapee cada fila a las claves correspondientes. Use bibliotecas como Papa Parse (JavaScript) o pandas (Python), o nuestra herramienta en linea gratuita.

Cual es la diferencia entre CSV y JSON?

CSV es un formato tabular plano donde todos los valores son cadenas. JSON es jerarquico con soporte para objetos anidados, arrays y multiples tipos. CSV es mas compacto, JSON mas expresivo.

Puede CSV manejar datos anidados?

No, CSV no soporta nativamente estructuras anidadas. Debe aplanar los datos con notacion de puntos, codificacion JSON en campos CSV o archivos CSV separados.

La conversion CSV a JSON es una habilidad fundamental para desarrolladores y analistas de datos. Use nuestra herramienta gratuita para conversiones instantaneas.

Convierte CSV a JSON y JSON a CSV instantaneamente con nuestra herramienta gratuita.