Dart 颤振：读取一个文件，解析为JSON，然后转换为一个对象以使用点符号

我试图找到一种方法来读取以特定格式保存数据的文件，将其解析为JSON，然后将其转换为对象，以便使用点表示法。 这里的问题是使用点表示法，因为它只返回null

CoreData.dart

import 'dart:convert';
import 'dart:io';
import 'dart:async';
import 'package:path_provider/path_provider.dart';

@proxy
class CoreObject {
  Map _data;

  CoreObject([String source]) {
    Map json = (source == null) ? new Map() : JSON.decode(source);
    _data = new Map.from(json);
    json.forEach((k, v) {
      print(k);
      _data[k] = v;
    });
  }

  static encode(List<CoreObject> list) {
    String result = "";
    for (CoreObject item in list) {
      result += "${item.toString()};";
    }
    return result;
  }

  @override toString() {
    print(this._data);
    return JSON.encode(this._data);
  }

  @override
  noSuchMethod(Invocation invocation) {
    var name = invocation.memberName.toString().replaceFirst('Symbol(\"', "");
    print("_data.keys ${_data.keys}");
    print("_data.values ${_data.values}");
    if (invocation.isGetter) {
      print("name ${name.replaceAll("\")", "")}");
      var ret = _data[name.replaceAll("\")", "")];
      print("ret $ret");
      print(ret.toString());
      return ret;
    }
    if (invocation.isSetter) {
      _data[name.replaceAll("=\")", "")] = invocation.positionalArguments.first;
    } else {
      super.noSuchMethod(invocation);
    }
  }
}

class Person extends CoreObject {
  Person([source]): super(source);
  @override noSuchMethod(Invocation invocation) {
    super.noSuchMethod(invocation);
  }
}

class CoreContainer {
  String _object;
  var returnNew;
  var path;

  _map(String source) {
    var result = [];
    for (var line in source.split(";")) {
      // print("line $line");
      if (line != "") result.add(returnNew(line));
    }
    print("result $result");
    return result;
  }

  encode(List<CoreObject> list) {
    // print("list $list");
    String result = "";
    list.forEach((CoreObject item) {
      // print("item ${item.toString()}");
      result += "${item};";
    });
    // print("result $result");
    return result;
  }

  CoreContainer(this._object, this.returnNew);

  Future<File> _getFile() async {
    String dir = path ?? (await getApplicationDocumentsDirectory()).path;
    this.path = dir;
    return new File('$dir/$_object.txt');
  }

  Future<List<CoreObject>> getAll() async {
    return _getFile().then((File file) {
      String contents = file.readAsStringSync();
      print("contents $contents");
      return this._map(contents);
    })
    .catchError((Error error) {
      print('error: $error');
      _getFile().then((File file) {
        file.writeAsStringSync("");
      });

      return [];
    });
  }

  save(List<CoreObject> data) async {
    _getFile().then((file) {
      try {
        file.writeAsStringSync(this.encode(data));
      }
      catch (error) {
        print("error: $error");
      }
    }).catchError((Error error) {
      print("error: $error");
    });
  }

  clear() async {
    return _getFile().then((file) {
      file.writeAsStringSync("");
    }).catchError((Error error) {
      print("error: $error");
    });
  }

  Future<List<CoreObject>> get(query) async {
    return this.getAll().then((List data) {
      data.retainWhere(query);
      return data;
    }).catchError((error) {
      print("error: $error");
    });    
  }

  Future<List<CoreObject>> remove(query) async {
    return this.getAll().then((List data) {
      // print(data);
      data.removeWhere(query);
      save(data);
      return data;
    }).catchError((error) {
      print("error: $error");
    });
  }

  Future<List<CoreObject>> add(obj) async {
    return this.getAll().then((data) {
      data.add(obj);
      return save(data).then(() {
        return data;
      })
      .catchError((Error error) {
        throw error;
      });
    }).catchError((Error error) {
      print("error: $error");
    });
  }

}

导入'dart:convert'；
导入“dart:io”；
导入“dart:async”；
导入“package:path_provider/path_provider.dart”；
@代理
类核心对象{
地图数据；
CoreObject（[字符串源]）{
Map json=（source==null）？new Map（）：json.decode（source）；
_data=newmap.from（json）；
forEach（（k，v）{
印刷品（k）；
_数据[k]=v；
});
}
静态编码（列表）{
字符串结果=”；
用于（列表中的CoreObject项）{
结果+=“${item.toString（）}；”；
}
返回结果；
}
@重写toString（）{
打印（此._数据）；
返回JSON.encode（此._数据）；
}
@凌驾
noSuchMethod（调用调用）{
var name=invocation.memberName.toString（）.replaceFirst（'Symbol（\“，”）；
打印（“\u data.keys${\u data.keys}”）；
打印（“\u data.values${\u data.values}”）；
if（invocation.isGetter）{
打印（“name${name.replaceAll（“\”，“）}”）；
var ret=\u数据[name.replaceAll（“\”，“）]；
打印（“ret$ret”）；
打印（ret.toString（））；
返回ret；
}
if（invocation.isSetter）{
_数据[name.replaceAll（“=\”，“）]=invocation.positionArguments.first；
}否则{
super.noSuchMethod（调用）；
}
}
}
类Person扩展了CoreObject{
人员（[来源]）：超级（来源）；
@重写noSuchMethod（调用）{
super.noSuchMethod（调用）；
}
}
类核心容器{
字符串对象；
新的；
var路径；
_映射（字符串源）{
var结果=[]；
for（source.split（“；”）中的变量行）{
//打印（“行$line”）；
如果（行！=“”）结果。添加（返回新（行））；
}
打印（“结果$result”）；
返回结果；
}
编码（列表）{
//打印（“列表$列表”）；
字符串结果=”；
list.forEach（（核心对象项）{
//打印（“item${item.toString（）}”）；
结果+=“${item}；”；
});
//打印（“结果$result”）；
返回结果；
}
CoreContainer（this.\u对象，this.returnNew）；
Future\u getFile（）异步{
String dir=path？？？（等待getApplicationDocumentsDirectory（））.path；
this.path=dir；
返回新文件（“$dir/$\u object.txt”）；
}
Future getAll（）异步{
返回_getFile（）。然后（（文件）{
String contents=file.readAsStringSync（）；
打印（“内容$contents”）；
返回此._地图（内容）；
})
.catchError（（错误）{
打印（'error:$error'）；
_getFile（）。然后（（文件）{
文件。writeAsStringSync（“”）；
});
返回[]；
});
}
异步保存（列表数据）{
_getFile（）。然后（（文件）{
试一试{
file.writeAsStringSync（this.encode（data））；
}
捕获（错误）{
打印（“错误：$error”）；
}
}).catchError（（错误）{
打印（“错误：$error”）；
});
}
clear（）异步{
返回_getFile（）。然后（（文件）{
文件。writeAsStringSync（“”）；
}).catchError（（错误）{
打印（“错误：$error”）；
});
}
未来获取（查询）异步{
返回此.getAll（）.then（（列表数据）{
数据保留位置（查询）；
返回数据；
}).catchError（（错误）{
打印（“错误：$error”）；
});    
}
未来删除（查询）异步{
返回此.getAll（）.then（（列表数据）{
//打印（数据）；
data.removehere（查询）；
保存（数据）；
返回数据；
}).catchError（（错误）{
打印（“错误：$error”）；
});
}
未来添加（obj）异步{
返回此.getAll（）。然后（（数据）{
添加数据（obj）；
返回save（数据），然后（）{
返回数据；
})
.catchError（（错误）{
投掷误差；
});
}).catchError（（错误）{
打印（“错误：$error”）；
});
}
}

使用它：

CoreContainer corePerson = new CoreContainer("Person", (source) => new Person(source));

corePerson.getAll().then((List<CoreObject> array) {
  var tempItems = [];
  var i = 0;
  print("array $array");
  while (i < array.length) {
    Person person = array[i];
    print(person); //{"name":"<whatever 'i' is>"}
    print(person.name); //null
    tempItems.add(new ListTile(
      title: new Text("$i"),
      subtitle: new Text("${person.name}"),
    ));
    i++;
  }
  print(tempItems.length);
  count = tempItems.length;
  setState(() {
    items = tempItems;
  });
}).catchError((Error error) {
  print("error: $error, ${error.stackTrace}");
});

CoreContainer-corePerson=newcorecontainer（“Person”，（source）=>newperson（source））；
corePerson.getAll（）.then（（列表数组）{
var tempItems=[]；
var i=0；
打印（“数组$array”）；
while（i

由于大量的

打印

调试，代码很难阅读

但我想您需要一种将JSON数据转换为Dart类的方法

您应该使用类似于jaguar_serializer的库来完成这项工作

---

Dart不像动态语言（Python、JavaScript）那样使用

dot

符号。例如，在Python和JavaScript中，每个对象实际上在内部都是一个HashMap，

实际上是属性名的哈希查找：

a.bar // Loosely the same as a.lookup('bar')

Python/JS虚拟机可以“看到”

a.bar

像类对象

a

上的属性一样使用，并对其进行优化以使用真正的属性/字段访问-这是JIT（即时编译器）的“优化”阶段的一部分

正是这样的特性使得提前编译Python或JS几乎不可能——它们需要运行时配置文件信息来生成快速代码。Dart（特别是Dart 2.0）正在实现一个声音类型系统，其中

a.bar

，当

a

已知时，始终是一个属性访问器，而不是散列查找

这意味着在运行时，您不能使用任意哈希映射并强制它像对象一样工作，这就是为什么您的代码看起来很笨拙的原因。如果您需要一个带有

符号的类型化对象，或者