Flutter高效JSON解析插件lazy_json的使用

Flutter高效JSON解析插件lazy_json的使用

Lazy JSON

提供了一种空安全实现，通过为Json对象（Map<String, dynamic>）和Json数组（List<dynamic>）添加扩展方法来简化Json数据处理。它简化了代码并提高了从Json中检索值的可读性。例如，将((json['response'] ?? {})['data'] ?? {})['id'] ?? ''简化为json.object('response').object('data').string('id')。在处理Json数组时也大大简化了代码。

开始使用

在pubspec.yaml文件中添加依赖：

dependencies:
  lazy_json: ^1.0.4

导入库

在你的.dart文件中导入库：

import 'package:lazy_json/lazy_json.dart';

现在你可以使用Map<String, dynamic>和List<dynamic>的数据类型扩展方法。

支持的数据类型

String

字符串类型的默认值为空字符串 ''。

使用方式：

// 在Json对象中，如果找不到'myKey'，则返回''
final myString = myJsonObject.string('myKey');

// 在Json对象中，如果找不到'myKey'，则返回'hello'作为默认值
final myString = myJsonObject.string('myKey', 'hello');

// 在Json数组中，获取索引为0的字符串值
final myString = myJsonArray.string(0);

// 在Json数组中，获取索引为3的字符串值，如果没有找到，则返回'hello world'作为默认值
final myString = myJsonArray.string(3, 'hello world');

Integer

整数类型的默认值为0。

使用方式：

// 在Json对象中，如果找不到'myKey'，则返回0
final myInteger = myJsonObject.integer('myKey');

// 在Json对象中，如果找不到'myKey'，则返回99作为默认值
final myInteger = myJsonObject.integer('myKey', 99);

// 在Json数组中，获取索引为0的整数值
final myInteger = myJsonArray.integer(0);

// 在Json数组中，获取索引为3的整数值，如果没有找到，则返回100作为默认值
final myInteger = myJsonArray.integer(3, 100);

Float / Double

浮点/双精度类型的默认值为0.0。

使用方式：

// 在Json对象中，如果找不到'myKey'，则返回0.0
final myFloat = myJsonObject.float('myKey');

// 在Json对象中，如果找不到'myKey'，则返回99.9作为默认值
final myFloat = myJsonObject.float('myKey', 99.9);

// 在Json数组中，获取索引为0的浮点/双精度值
final myFloat = myJsonArray.float(0);

// 在Json数组中，获取索引为3的浮点/双精度值，如果没有找到，则返回100.89作为默认值
final myFloat = myJsonArray.float(3, 100.89);

Boolean

布尔类型的默认值为false。

使用方式：

// 在Json对象中，如果找不到'myKey'，则返回false
final myBoolean = myJsonObject.boolean('myKey');

// 在Json对象中，如果找不到'myKey'，则返回true作为默认值
final myBoolean = myJsonObject.boolean('myKey', true);

// 在Json数组中，获取索引为0的布尔值
final myBoolean = myJsonArray.boolean(0);

// 在Json数组中，获取索引为3的布尔值，如果没有找到，则返回true作为默认值
final myBoolean = myJsonArray.boolean(3, true);

JSON Object

Map<String, dynamic>类型的默认值为{}（空对象）。

使用方式：

// 在Json对象中，如果找不到'myKey'，则返回空对象
final myObject = myJsonObject.object('myKey');

// 在Json对象中，如果找不到'myKey'，则返回JSON对象{'a' : 10}
final myObject = myJsonObject.object('myKey', {'a' : 10});

// 在Json数组中，获取索引为0的JSON对象
final myObject = myJsonArray.object(0);

// 在Json数组中，获取索引为3的JSON对象，如果没有找到，则返回{'b' : 'hello world'}作为默认值
final myObject = myJsonArray.object(3, {'b' : 'hello world'});

JSON Array

List<dynamic>类型的默认值为[]（空数组）。

使用方式：

// 在Json数组中，如果找不到'myKey'，则返回空数组
final myArray = myJsonObject.array('myKey');

// 在Json对象中，如果找不到'myKey'，则返回JSON数组['a', 'b']
final myArray = myJsonObject.array('myKey', ['a', 'b']);

// 在Json数组中，获取索引为0的JSON数组
final myArray = myJsonArray.array(0);

// 在Json数组中，获取索引为3的JSON数组，如果没有找到，则返回[100, 200, {'b' : 'hello'}]作为默认值
final myArray = myJsonArray.array(3, [100, 200, {'b' : 'hello'}]);

简写方法

所有简写方法都是常规方法的第一个字母。

myJsonObject.s('myKey');  // 简写形式 for myJsonObject.string('myKey');
myJsonObject.i('myKey');  // 简写形式 for myJsonObject.integer('myKey');
myJsonObject.f('myKey');  // 简写形式 for myJsonObject.float('myKey');
myJsonObject.b('myKey');  // 简写形式 for myJsonObject.boolean('myKey');
myJsonObject.o('myKey');  // 简写形式 for myJsonObject.object('myKey');
myJsonObject.a('myKey');  // 简写形式 for myJsonObject.array('myKey');

myJsonArray.s(1);         // 简写形式 for myJsonArray.string(1);
myJsonArray.i(2);         // 简写形式 for myJsonArray.integer(2);
myJsonArray.f(3);         // 简写形式 for myJsonArray.float(3);
myJsonArray.b(4);         // 简写形式 for myJsonArray.boolean(4);
myJsonArray.o(5);         // 简写形式 for myJsonArray.object(5);
myJsonArray.a(6);         // 简写形式 for myJsonArray.array(6);

更多关于Flutter高效JSON解析插件lazy_json的使用的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter高效JSON解析插件lazy_json的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


lazy_json 是一个用于 Flutter 的高效 JSON 解析插件，它旨在简化 JSON 数据的解析和处理过程，特别是在处理大型 JSON 数据时，能够提高性能并减少内存占用。lazy_json 的核心思想是“懒加载”，即在需要时才解析 JSON 数据，从而避免一次性加载和解析整个 JSON 文件。

主要特点

  1. 懒加载：只有在访问特定字段时才解析该字段，减少内存占用。
  2. 高性能：通过延迟解析，减少一次性解析整个 JSON 的性能开销。
  3. 简洁的 API：提供简单易用的 API，方便开发者快速上手。
  4. 支持 JSON 路径：可以通过类似 jsonPath 的方式访问嵌套的 JSON 数据。
  5. 类型安全：支持自动转换为 Dart 的基本数据类型（如 int, double, String, bool 等）。

安装

在 pubspec.yaml 中添加 lazy_json 依赖：

dependencies:
  lazy_json: ^1.0.0

然后运行 flutter pub get 安装依赖。

使用示例

基本用法

import 'package:lazy_json/lazy_json.dart';

void main() {
  final jsonStr = '''
  {
    "name": "John Doe",
    "age": 30,
    "isStudent": false,
    "address": {
      "city": "New York",
      "zipCode": "10001"
    }
  }
  ''';

  final json = LazyJson(jsonStr);

  print(json['name'].asString); // 输出: John Doe
  print(json['age'].asInt);     // 输出: 30
  print(json['isStudent'].asBool); // 输出: false
  print(json['address']['city'].asString); // 输出: New York
}

处理嵌套 JSON

import 'package:lazy_json/lazy_json.dart';

void main() {
  final jsonStr = '''
  {
    "users": [
      {"name": "Alice", "age": 25},
      {"name": "Bob", "age": 30}
    ]
  }
  ''';

  final json = LazyJson(jsonStr);

  final users = json['users'].asList;
  for (var user in users) {
    print('Name: ${user['name'].asString}, Age: ${user['age'].asInt}');
  }
}

处理数组

import 'package:lazy_json/lazy_json.dart';

void main() {
  final jsonStr = '''
  {
    "numbers": [1, 2, 3, 4, 5]
  }
  ''';

  final json = LazyJson(jsonStr);

  final numbers = json['numbers'].asList;
  for (var number in numbers) {
    print(number.asInt);
  }
}

使用 JSON 路径

import 'package:lazy_json/lazy_json.dart';

void main() {
  final jsonStr = '''
  {
    "user": {
      "name": "John",
      "address": {
        "city": "San Francisco"
      }
    }
  }
  ''';

  final json = LazyJson(jsonStr);

  final city = json.get('user.address.city').asString;
  print(city); // 输出: San Francisco
}
回到顶部