Dart Convert Library

Conversion Types

json.encode({'key': 'value'});
json.decode('{"key":"value"}');

utf8.encode('Hello World');
utf8.decode([72, 101, 108, 108, 111]);

base64.encode([1, 2, 3, 4]);
base64.decode('AQIDBA==');

Uri.encodeComponent('hello world');
Uri.decodeComponent('hello%20world');

🔹 JSON Operations

Working with JSON data - the most common data format:

import 'dart:convert';

void main() {
  // Encoding Dart objects to JSON
  Map person = {
    'name': 'John Doe',
    'age': 25,
    'isStudent': true,
    'hobbies': ['reading', 'coding', 'gaming'],
    'address': {
      'street': '123 Main St',
      'city': 'New York',
      'zipCode': '10001'
    }
  };
  
  String jsonString = json.encode(person);
  print('JSON String:');
  print(jsonString);
  
  // Pretty printing JSON
  JsonEncoder encoder = JsonEncoder.withIndent('  ');
  String prettyJson = encoder.convert(person);
  print('\nPretty JSON:');
  print(prettyJson);
  
  // Decoding JSON to Dart objects
  String jsonData = '{"name":"Alice","scores":[95,87,92],"active":true}';
  Map decoded = json.decode(jsonData);
  
  print('\nDecoded Data:');
  print('Name: ${decoded['name']}');
  print('Scores: ${decoded['scores']}');
  print('Active: ${decoded['active']}');
  print('First score: ${decoded['scores'][0]}');
}

🔹 UTF-8 Encoding

Converting between strings and bytes:

import 'dart:convert';

void main() {
  // String to bytes (UTF-8 encoding)
  String text = 'Hello, 世界! 🌍';
  List bytes = utf8.encode(text);
  
  print('Original text: $text');
  print('UTF-8 bytes: $bytes');
  print('Byte length: ${bytes.length}');
  print('String length: ${text.length}');
  
  // Bytes to string (UTF-8 decoding)
  String decoded = utf8.decode(bytes);
  print('Decoded text: $decoded');
  
  // Working with different encodings
  String englishText = 'Hello World';
  String chineseText = '你好世界';
  String emojiText = '😀🎉🚀';
  
  print('\nEncoding different texts:');
  print('English: ${utf8.encode(englishText).length} bytes');
  print('Chinese: ${utf8.encode(chineseText).length} bytes');
  print('Emoji: ${utf8.encode(emojiText).length} bytes');
  
  // Handling encoding errors
  List invalidBytes = [0xFF, 0xFE, 0xFD];
  try {
    String result = utf8.decode(invalidBytes);
    print('Decoded: $result');
  } catch (e) {
    print('Encoding error: $e');
    // Use allowMalformed to handle errors gracefully
    String result = utf8.decode(invalidBytes, allowMalformed: true);
    print('Decoded with allowMalformed: $result');
  }
}

🔹 Base64 Encoding

Encoding binary data as text:

import 'dart:convert';

void main() {
  // Basic Base64 encoding
  String text = 'Hello Dart!';
  List bytes = utf8.encode(text);
  String encoded = base64.encode(bytes);
  
  print('Original: $text');
  print('Base64: $encoded');
  
  // Base64 decoding
  List decodedBytes = base64.decode(encoded);
  String decoded = utf8.decode(decodedBytes);
  print('Decoded: $decoded');
  
  // URL-safe Base64
  List binaryData = [255, 254, 253, 252, 251, 250];
  String urlSafeEncoded = base64Url.encode(binaryData);
  String regularEncoded = base64.encode(binaryData);
  
  print('\nBinary data: $binaryData');
  print('Regular Base64: $regularEncoded');
  print('URL-safe Base64: $urlSafeEncoded');
  
  // Encoding images or files (simulated)
  List imageData = List.generate(20, (i) => i * 10);
  String imageBase64 = base64.encode(imageData);
  print('\nImage data (simulated): $imageData');
  print('Image as Base64: $imageBase64');
  
  // Creating data URLs
  String dataUrl = 'data:image/png;base64,$imageBase64';
  print('Data URL: $dataUrl');
  
  // Working with larger data
  List largeData = List.generate(100, (i) => i % 256);
  String largeEncoded = base64.encode(largeData);
  print('\nLarge data encoded length: ${largeEncoded.length}');
  print('Original data length: ${largeData.length}');
  print('Encoding overhead: ${((largeEncoded.length / largeData.length) * 100).toStringAsFixed(1)}%');
}

🔹 URL Encoding

Encoding URLs and query parameters:

import 'dart:convert';

void main() {
  // URL component encoding
  String searchQuery = 'hello world & special chars!';
  String encoded = Uri.encodeComponent(searchQuery);
  String decoded = Uri.decodeComponent(encoded);
  
  print('Original: $searchQuery');
  print('Encoded: $encoded');
  print('Decoded: $decoded');
  
  // Building URLs with parameters
  Map params = {
    'q': 'dart programming',
    'category': 'tutorials & guides',
    'sort': 'date',
    'filter': 'beginner friendly'
  };
  
  String baseUrl = 'https://example.com/search';
  List queryParts = [];
  
  params.forEach((key, value) {
    String encodedKey = Uri.encodeComponent(key);
    String encodedValue = Uri.encodeComponent(value);
    queryParts.add('$encodedKey=$encodedValue');
  });
  
  String fullUrl = '$baseUrl?${queryParts.join('&')}';
  print('\nBuilt URL:');
  print(fullUrl);
  
  // Using Uri class for URL building
  Uri uri = Uri.https('api.example.com', '/v1/search', {
    'query': 'flutter & dart',
    'limit': '10',
    'offset': '0'
  });
  
  print('\nUsing Uri class:');
  print('Full URI: $uri');
  print('Host: ${uri.host}');
  print('Path: ${uri.path}');
  print('Query: ${uri.query}');
  
  // Parsing URLs
  String urlString = 'https://example.com/path?name=John%20Doe&age=25';
  Uri parsedUri = Uri.parse(urlString);
  
  print('\nParsed URL:');
  print('Scheme: ${parsedUri.scheme}');
  print('Host: ${parsedUri.host}');
  print('Path: ${parsedUri.path}');
  print('Query parameters:');
  parsedUri.queryParameters.forEach((key, value) {
    print('  $key: $value');
  });
}

🔹 Custom Converters

Creating custom data converters:

import 'dart:convert';

// Custom class for demonstration
class Person {
  String name;
  int age;
  List hobbies;
  
  Person(this.name, this.age, this.hobbies);
  
  // Convert to JSON-serializable map
  Map toJson() {
    return {
      'name': name,
      'age': age,
      'hobbies': hobbies,
    };
  }
  
  // Create from JSON map
  factory Person.fromJson(Map json) {
    return Person(
      json['name'],
      json['age'],
      List.from(json['hobbies']),
    );
  }
  
  @override
  String toString() => 'Person(name: $name, age: $age, hobbies: $hobbies)';
}

void main() {
  // Create person objects
  List people = [
    Person('Alice', 25, ['reading', 'coding']),
    Person('Bob', 30, ['gaming', 'cooking', 'hiking']),
    Person('Charlie', 28, ['music', 'photography']),
  ];
  
  // Convert to JSON
  List> jsonList = people.map((p) => p.toJson()).toList();
  String jsonString = json.encode(jsonList);
  
  print('People as JSON:');
  print(JsonEncoder.withIndent('  ').convert(jsonList));
  
  // Convert back from JSON
  String jsonData = '''[
    {"name": "David", "age": 35, "hobbies": ["traveling", "writing"]},
    {"name": "Eve", "age": 22, "hobbies": ["dancing", "painting", "yoga"]}
  ]''';
  
  List decodedList = json.decode(jsonData);
  List parsedPeople = decodedList
      .map((json) => Person.fromJson(json))
      .toList();
  
  print('\nParsed people:');
  for (Person person in parsedPeople) {
    print(person);
  }
  
  // Custom converter for CSV-like format
  String csvData = 'Alice,25,reading|coding\nBob,30,gaming|cooking|hiking';
  List csvPeople = csvData.split('\n').map((line) {
    List parts = line.split(',');
    return Person(
      parts[0],
      int.parse(parts[1]),
      parts[2].split('|'),
    );
  }).toList();
  
  print('\nFrom CSV format:');
  for (Person person in csvPeople) {
    print(person);
  }
}