For loop 如何从带有for循环的sqflite数据库中计算总数，并用未来的生成器打印出来

我是dart和Flatter的新手，我正在其中编写一个方法，它是一个for循环，用于添加从sqflite数据库获取的数据，但返回的数据始终为空，请任何人帮助我更正代码

声明和我在initstate中调用了该方法

Future<int> mainTotal;
  int total = 0;
  int multiple;

  @override
  void initState() {
    selectedItems = [];
    super.initState();
    calculateTotal();
  }

；
int-total=0；
整数倍；
@凌驾
void initState（）{
selectedItems=[]；
super.initState（）；
计算总数（）；
}

这是返回future int的函数

void calculateTotal() async {
    final dao = Provider.of<ItemListDao>(context);
    List<ItemList> itemLists = await dao.getAllItemLists(widget.checkListId);

    for (int i = 0; i < itemLists.length; i++) {
      int noOfItems = itemLists[i].noOfItems as int;
      int unitPrice = itemLists[i].unitPrice as int;
      multiple = noOfItems * unitPrice;
      total += multiple;
    }

    mainTotal = total as Future<int>;
  }

void calculateTotal（）异步{
final dao=Provider.of（上下文）；
List itemLists=wait dao.getAllItemList（widget.checkListId）；
对于（int i=0；i

试图使用未来的生成器获取数据

Center(
          child: FutureBuilder(
            future: mainTotal, // a previously-obtained Future<String> or null
            builder: (BuildContext context, AsyncSnapshot snapshot) {
              switch (snapshot.connectionState) {
                case ConnectionState.none:
                case ConnectionState.active:
                case ConnectionState.waiting:
                  return Text('Awaiting result...');
                case ConnectionState.done:
                  if (snapshot.hasError) return Text('Error: ${snapshot.error}');
                  return Text('Total: ${snapshot.data}');
              }
              return null; // unreachable
            },
          ),
        ),

中心(
孩子：未来建设者(
future:mainTotal，//以前获得的future或null
生成器：（BuildContext上下文，异步快照）{
交换机（快照.连接状态）{
案例连接状态。无：
案例连接状态.active：
案例连接状态。正在等待：
返回文本（'等待结果…'）；
案例连接状态。完成：
if（snapshot.hasError）返回文本（'Error:${snapshot.Error}'）；
返回文本（'Total:${snapshot.data}'）；
}
返回null；//不可访问
},
),
),

在initState（）上，您需要返回future并将其分配给maintottal变量，如下所示：

mainTotal = calculateTotal();

否则，该变量将为null，并且当您稍后将该值放入该变量时，FutureBuilder将无法实现

下面是一个与您的代码类似的示例，以了解问题：

Future<int> mainTotal;
int total = 0;
int multiple;

@override
void initState() {
  super.initState();
  print("before calculateTotal() mainTotal: $mainTotal");
  mainTotal = calculateTotal();
  print("after calculateTotal() mainTotal: $mainTotal");
}

Future<int> calculateTotal() async {
  print("calculateTotal() starting...");
  await Future.delayed(Duration(seconds: 3));
  List<List<int>> itemLists = [
    [1, 2, 3, 4],
    [1, 2, 3, 4],
    [1, 4]
  ];

  for (int i = 0; i < itemLists.length; i++) {
    int noOfItems = itemLists[i].length;
    int unitPrice = itemLists[i].length;
    multiple = noOfItems * unitPrice;
    total += multiple;
  }

  print("calculateTotal() finished");
  return total;
}

@override
Widget build(BuildContext context) {
  return Scaffold(
    floatingActionButton: FloatingActionButton(
      onPressed: () {
        setState(() {});
      },
    ),
    body: Center(
      child: FutureBuilder(
        future: mainTotal, // a previously-obtained Future<String> or null
        builder: (BuildContext context, AsyncSnapshot snapshot) {
          switch (snapshot.connectionState) {
            case ConnectionState.none:
              print("connectionState: none");
              return Text('Awaiting result...');
            case ConnectionState.active:
              print("connectionState: active");
              return Text('Awaiting result...');
            case ConnectionState.waiting:
              print("connectionState: waiting");
              return Text('Awaiting result...');
            case ConnectionState.done:
              print("connectionState: done");
              if (snapshot.hasError) return Text('Error: ${snapshot.error}');
              return Text('Total: ${snapshot.data}');
          }
          return null; // unreachable
        },
      ),
    ),
  );
}

---

所以我重新构建了我的逻辑，这对我来说很有效

Widget _printTotal() {
final dao = Provider.of<ItemListDao>(context);
return FutureBuilder(
  future: dao.getAllItemLists(
      widget.checkListId), // a previously-obtained Future<String> or null
  builder: (BuildContext context, AsyncSnapshot snapshot) {
    List<ItemList> itemList = snapshot.data ?? List();
    switch (snapshot.connectionState) {
      case ConnectionState.none:
      case ConnectionState.active:
      case ConnectionState.waiting:
      // return Center(child: Text('Awaiting result...'));
      case ConnectionState.done:
        if (snapshot.hasError) {
          return Text('Error: ${snapshot.error}');
        } else {
          return Center(
            child: Text(
              "Total: " + _getTotal(itemList).toString(),
              textAlign: TextAlign.center,
              style: TextStyle(
                fontSize: 25,
                fontWeight: FontWeight.bold,
              ),
            ),
          );
        }
    }
    return null; // unreachable
  },
);
}

Widget\u printotal（）{
final dao=Provider.of（上下文）；
回归未来建设者(
future:dao.getAllItemList(
widget.checkListId），//以前获得的Future或null
生成器：（BuildContext上下文，异步快照）{
List itemList=snapshot.data？？List（）；
交换机（快照.连接状态）{
案例连接状态。无：
案例连接状态.active：
案例连接状态。正在等待：
//返回中心（子项：文本（'等待结果…'）；
案例连接状态。完成：
if（snapshot.hasError）{
返回文本（'Error:${snapshot.Error}'）；
}否则{
返回中心(
子：文本(
“总计：”+_getTotal（itemList）.toString（），
textAlign:textAlign.center，
样式：TextStyle(
尺寸：25，
fontWeight:fontWeight.bold，
),
),
);
}
}
返回null；//不可访问
},
);
}

这是_getTotal函数

int _getTotal(List<ItemList> itemLists) {
int total = 0;
for (int i = 0; i < itemLists.length; i++) {
  var noOfItems = int.parse(itemLists[i].noOfItems);
  var unitPrice = int.parse(itemLists[i].unitPrice);
  multiple = noOfItems * unitPrice;
  total += multiple;
}
return total;
}

int\u getTotal（列表项列表）{
int-total=0；
对于（int i=0；i

您遇到的错误是什么？您看到的是“等待结果…”还是“总计：null”？等待结果问题似乎出在dao.getAllItemList（）方法中，您能发布该实现吗？

Widget _printTotal() {
final dao = Provider.of<ItemListDao>(context);
return FutureBuilder(
  future: dao.getAllItemLists(
      widget.checkListId), // a previously-obtained Future<String> or null
  builder: (BuildContext context, AsyncSnapshot snapshot) {
    List<ItemList> itemList = snapshot.data ?? List();
    switch (snapshot.connectionState) {
      case ConnectionState.none:
      case ConnectionState.active:
      case ConnectionState.waiting:
      // return Center(child: Text('Awaiting result...'));
      case ConnectionState.done:
        if (snapshot.hasError) {
          return Text('Error: ${snapshot.error}');
        } else {
          return Center(
            child: Text(
              "Total: " + _getTotal(itemList).toString(),
              textAlign: TextAlign.center,
              style: TextStyle(
                fontSize: 25,
                fontWeight: FontWeight.bold,
              ),
            ),
          );
        }
    }
    return null; // unreachable
  },
);
}

int _getTotal(List<ItemList> itemLists) {
int total = 0;
for (int i = 0; i < itemLists.length; i++) {
  var noOfItems = int.parse(itemLists[i].noOfItems);
  var unitPrice = int.parse(itemLists[i].unitPrice);
  multiple = noOfItems * unitPrice;
  total += multiple;
}
return total;
}