INI to JSON Converter

Tool Overview: INI to JSON Converter Tool

INI and JSON are both commonly used configuration file formats. INI format is simple and readable, suitable for manual editing; JSON format is highly structured, suitable for program processing. This tool provides bidirectional conversion between the two formats, helping developers choose the appropriate configuration format for different scenarios.

What Is INI to JSON Converter Tool?

INI to JSON Converter Tool converts INI to JSON and produces output ready to use.

How to Use

1. Paste INI content or enter parameters.
2. Choose JSON output and set options.
3. Review the result and copy or download.

Common Use Cases

• INI↔JSON format migration
• Use INI data in JSON workflows or code generation
• Validate conversion results against specs

❓ FAQ

Q1: Conversion failed or empty?
A: Check that the INI input is valid and complete.

Q2: Output looks different?
A: Formatting may change to match JSON rules.

Q3: How to batch process?
A: Process in smaller chunks for stability.

✨ Key Features

• 🔄 Bidirectional Conversion: Support INI to JSON and JSON to INI conversion
• ✅ Syntax Validation: Automatically detect format errors with detailed hints
• 🎨 Format Beautification: Automatically format output for better readability
• 📋 One-Click Copy: Conversion results can be directly copied for use
• 🔧 Smart Parsing: Support comments, sections, and type conversion

📖 Usage Examples

INI to JSON Example

Input INI:

# Application Configuration
[app]
name = ToolMi
version = 1.0.0
debug = true
port = 3000

[database]
host = localhost
port = 5432
username = admin
password = secret123
ssl = false

[features]
multi_language = true
seo_friendly = true
responsive_design = true

Output JSON:

{
  "app": {
    "name": "ToolMi",
    "version": "1.0.0",
    "debug": true,
    "port": 3000
  },
  "database": {
    "host": "localhost",
    "port": 5432,
    "username": "admin",
    "password": "secret123",
    "ssl": false
  },
  "features": {
    "multi_language": true,
    "seo_friendly": true,
    "responsive_design": true
  }
}

JSON to INI Example

Input JSON:

{
  "server": {
    "host": "0.0.0.0",
    "port": 8080,
    "ssl": true
  },
  "logging": {
    "level": "info",
    "file": "/var/log/app.log"
  }
}

Output INI:

[server]
host = 0.0.0.0
port = 8080
ssl = true

[logging]
level = info
file = /var/log/app.log

🎯 Application Scenarios

1. Configuration File Migration

// Configuration file migration tool
class ConfigMigrator {
  constructor() {
    this.supportedFormats = ['ini', 'json', 'yaml', 'toml'];
  }

  // Migrate from INI to JSON
  migrateFromINI(iniContent, targetFormat = 'json') {
    try {
      // Parse INI content
      const config = this.parseINI(iniContent);
      
      // Validate configuration structure
      this.validateConfig(config);
      
      // Convert to target format
      switch (targetFormat) {
        case 'json':
          return JSON.stringify(config, null, 2);
        case 'yaml':
          return this.toYAML(config);
        default:
          throw new Error(`Unsupported target format: ${targetFormat}`);
      }
    } catch (error) {
      throw new Error(`Configuration migration failed: ${error.message}`);
    }
  }

  // Batch migrate configuration files
  batchMigrate(configFiles, targetFormat) {
    const results = [];
    
    for (const file of configFiles) {
      try {
        const result = this.migrateFromINI(file.content, targetFormat);
        results.push({
          filename: file.name,
          status: 'success',
          content: result
        });
      } catch (error) {
        results.push({
          filename: file.name,
          status: 'error',
          error: error.message
        });
      }
    }
    
    return results;
  }
}

// Usage example
const migrator = new ConfigMigrator();
const iniConfig = `
[database]
host = localhost
port = 5432
name = myapp

[redis]
host = 127.0.0.1
port = 6379
`;

const jsonConfig = migrator.migrateFromINI(iniConfig, 'json');
console.log('Migrated JSON configuration:');
console.log(jsonConfig);

2. Environment Configuration Management

// Multi-environment configuration manager
class EnvironmentConfigManager {
  constructor() {
    this.environments = ['development', 'staging', 'production'];
    this.configCache = new Map();
  }

  // Load environment configuration
  loadEnvironmentConfig(env, format = 'ini') {
    const cacheKey = `${env}-${format}`;
    
    if (this.configCache.has(cacheKey)) {
      return this.configCache.get(cacheKey);
    }

    try {
      const configPath = `./config/${env}.${format}`;
      const configContent = this.readConfigFile(configPath);
      
      let parsedConfig;
      if (format === 'ini') {
        parsedConfig = this.parseINI(configContent);
      } else if (format === 'json') {
        parsedConfig = JSON.parse(configContent);
      }

      // Cache configuration
      this.configCache.set(cacheKey, parsedConfig);
      return parsedConfig;
    } catch (error) {
      throw new Error(`Failed to load ${env} environment config: ${error.message}`);
    }
  }

  // Merge configurations
  mergeConfigs(baseConfig, envConfig) {
    return {
      ...baseConfig,
      ...envConfig,
      // Deep merge nested objects
      database: {
        ...baseConfig.database,
        ...envConfig.database
      },
      features: {
        ...baseConfig.features,
        ...envConfig.features
      }
    };
  }

  // Export configuration in different formats
  exportConfig(config, format) {
    switch (format) {
      case 'ini':
        return this.toINI(config);
      case 'json':
        return JSON.stringify(config, null, 2);
      case 'env':
        return this.toEnvFile(config);
      default:
        throw new Error(`Unsupported export format: ${format}`);
    }
  }
}

// Usage example
const configManager = new EnvironmentConfigManager();

// Load base configuration and environment-specific configuration
const baseConfig = configManager.loadEnvironmentConfig('base', 'ini');
const prodConfig = configManager.loadEnvironmentConfig('production', 'json');

// Merge configurations
const finalConfig = configManager.mergeConfigs(baseConfig, prodConfig);

// Export in different formats
const iniOutput = configManager.exportConfig(finalConfig, 'ini');
const jsonOutput = configManager.exportConfig(finalConfig, 'json');

console.log('INI format configuration:', iniOutput);
console.log('JSON format configuration:', jsonOutput);

3. Configuration File Validation and Standardization

// Configuration file validator
class ConfigValidator {
  constructor() {
    this.schemas = {
      database: {
        required: ['host', 'port', 'username'],
        types: {
          host: 'string',
          port: 'number',
          username: 'string',
          password: 'string',
          ssl: 'boolean'
        }
      },
      app: {
        required: ['name', 'version'],
        types: {
          name: 'string',
          version: 'string',
          debug: 'boolean',
          port: 'number'
        }
      }
    };
  }

  // Validate configuration structure
  validateConfig(config) {
    const errors = [];

    for (const [section, sectionConfig] of Object.entries(config)) {
      const schema = this.schemas[section];
      if (!schema) {
        continue; // Skip undefined sections
      }

      // Check required fields
      for (const requiredField of schema.required) {
        if (!(requiredField in sectionConfig)) {
          errors.push(`Missing required field: ${section}.${requiredField}`);
        }
      }

      // Check field types
      for (const [field, value] of Object.entries(sectionConfig)) {
        const expectedType = schema.types[field];
        if (expectedType && typeof value !== expectedType) {
          errors.push(`Type error: ${section}.${field} should be ${expectedType}, got ${typeof value}`);
        }
      }
    }

    return {
      isValid: errors.length === 0,
      errors: errors
    };
  }

  // Normalize configuration
  normalizeConfig(config) {
    const normalized = {};

    for (const [section, sectionConfig] of Object.entries(config)) {
      normalized[section] = {};
      
      for (const [key, value] of Object.entries(sectionConfig)) {
        // Normalize key names (convert to lowercase, use underscores)
        const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, '_');
        
        // Normalize values
        let normalizedValue = value;
        if (typeof value === 'string') {
          // Try to convert boolean values
          if (value.toLowerCase() === 'true') {
            normalizedValue = true;
          } else if (value.toLowerCase() === 'false') {
            normalizedValue = false;
          }
          // Try to convert numbers
          else if (!isNaN(value) && !isNaN(parseFloat(value))) {
            normalizedValue = parseFloat(value);
          }
        }
        
        normalized[section][normalizedKey] = normalizedValue;
      }
    }

    return normalized;
  }
}

// Usage example
const validator = new ConfigValidator();

const config = {
  database: {
    host: "localhost",
    port: "5432", // String form of number
    username: "admin"
    // Missing password
  },
  app: {
    name: "MyApp",
    version: "1.0.0",
    debug: "true" // String form of boolean
  }
};

// Validate configuration
const validation = validator.validateConfig(config);
if (!validation.isValid) {
  console.log('Configuration validation failed:');
  validation.errors.forEach(error => console.log(`- ${error}`));
}

// Normalize configuration
const normalizedConfig = validator.normalizeConfig(config);
console.log('Normalized configuration:', normalizedConfig);

📐 Format Comparison

INI Format Features

• Simple and Readable: Human-friendly format, easy to edit manually
• Section Structure: Use [section] to organize configuration
• Key-Value Pairs: key = value format
• Comment Support: Support # and ; comments
• Type Limitations: Mainly supports strings, requires manual type conversion

JSON Format Features

• Structured: Strict data structure with nesting support
• Rich Types: Support strings, numbers, booleans, arrays, objects
• Standard Format: Wide programming language support
• Machine-Friendly: Easy for programs to parse and generate
• No Comments: Does not support comments (standard JSON)

🔧 Usage Tips

1. Type Conversion: Tool automatically recognizes and converts true/false and numbers
2. Comment Handling: Comments in INI are ignored when converting to JSON
3. Special Characters: Values containing spaces or equals signs are automatically quoted
4. Nested Structure: Nested objects in JSON are converted to multiple sections in INI
5. Validation Check: Format validation is performed before and after conversion

🎓 Learning Points

• Understand the characteristics and applicable scenarios of INI and JSON formats
• Master the design principles of configuration file structure
• Learn to choose the appropriate configuration format
• Understand configuration file version management and migration strategies

This INI to JSON converter tool is not just a format converter, but also a great helper for configuration file management and migration!