IOC是容器，用来装Spring创建的Bean对象。
<!-- SpringBean的注入方式 -->
<!-- 手动装配 -->
<!-- == set方法注入 -->
<bean id="hello" class="com.dzqc.smbms.entity.SUser">
<property name="userCode" value="hello"></property>
<property name="userName" value="Spring"></property>
<property name="role">
<bean class="com.dzqc.smbms.entity.SRole">
<property name="roleCode" value="这里是注入的实例对象"></property>
<property name="roleName" value="这里是注入的实例对象的值"></property>
</bean>
</property>
<property name="role" ref="myRole"></property>
</bean>
<bean name="myRole" class="com.dzqc.smbms.entity.SRole">
<property name="roleName" value="管理员"></property>
<property name="roleCode" value="SMBMS_ADMIN"></property>
</bean>
<!-- == 带参构造器注入 -->
<bean name="constructor" class="com.dzqc.smbms.entity.SUser">
<constructor-arg name="userName" value="这是通过构造器注入的userName"></constructor-arg>
<constructor-arg name="userCode" value="这是通过构造器注入的userCode"></constructor-arg>
</bean>
<!-- 自动装配 -->
<!-- == 配置包扫描，并使用注解进行注入 -->
<context:component-scan base-package="com.dzqc.smbms">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
IOC和DI的区别：
IOC是什么：是控制反转，将new对象的权力由调用程序交给第三方IOC容器，控制权被转移给了IOC容器，在调用程序看来，new对象的动作由主动变成了被动，所以叫做控制反转。
DI是什么：依赖注入，将IOC容器中new出来的对象注入进调用程序。
IOC和ID的区别：IOC和DI是一体的，DI是IOC的另一种表现形式，是同一事件不同层面的解读。
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP是一种编程思想，基于面向对象编程思想（OOP）的补充。面向对象编程将程序抽象成了各个切面。
在开发过程中，存在某段多次重复的代码，以面向过程编程方式的话，我们会将这段代码抽象成一个方法，在需要的位置调用该方法。当这段代码需要修改时，我们就只需要改变这一个方法就够了。
但需求不是一成不变的，如果后期需要新增一个需求，又需要在多处进行修改，就需要再抽象一个方法，然后在需要的位置再分别调用这个方法。又或者，我们在业务过程中删除这个方法，我们就需要删除掉每一个地方的调用。
在这种情况之下，我们就可以通过使用AOP来解决。
首先我们要知道AOP的目的，AOP要达到在开发者不修改源代码的前提下，去为系统中的业务添加某种通用的功能。
AOP的实现方式大致可以分为两类：
*.class文件已经被修改，需要使用特定的编译方式进行编译。代表性的静态AOP实现方式如：AspectJ| 类别 | 机制 | 原理 |
|---|---|---|
| 静态AOP | 静态织入 | 在编译前，切面直接以字节码的形式编译入目标代码的字节码文件中，对性能无影响，但灵活性不够。 |
| 动态AOP | JDK动态代理 | 在运行期间，目标类加载之后为接口动态生成代理类，将切面织入到代理类中，相对于静态AOP更灵活一些。但切入点需要实现接口，对系统的性能有一定影响。 |
| 动态字节码生成 | CGlib | 在运行期间，目标类加载之后，动态生成目标类的子类，然后将切面的逻辑加入到子类中，相对于JDK动态代理的方式，CGlib不需要接口也可以实现织入，但是当扩展类的实例方法使用final修饰时无法进行织入。 |
AOP中的特性术语大致有一下几种：
SpringAOP在AOP的基础上又多出几个延伸概念：
AOP的框架有很多，实现方式各不相同，Spring的AOP则是通过动态代理进行实现的。下面简单对代理模式进行介绍。
Execution表达式：
声明具体方法的位置的表达式 ：返回值 包路径.类名.方法名(参数列表)
代理模式分为两种：
被代理类接口：
package com.dzqc.smbms.proxy;
/**
* 游戏接口
*/
public interface Game {
public void gameStart();
public void gameOver();
}
被代理类：
package com.dzqc.smbms.proxy;
public class Mario implements Game{
@Override
public void gameStart() {
System.out.println("超级马里奥，游戏开始！");
}
@Override
public void gameOver() {
System.out.println("够不着旗杆，游戏结束");
}
}
代理类：
package com.dzqc.smbms.proxy;
/**
* 本类为 静态代理 类
* 代理类 需要 持有 目标对象
*/
public class GameStaticProxy implements Game{
private Game targetGame;
public Game getProxy(Game targetGame){
this.targetGame = targetGame;
return this;
}
@Override
public void gameStart() {
System.out.println("游戏机启动");
System.out.println("游戏启动！");
targetGame.gameStart();
System.out.println("游戏进行中，mario他跳起来了");
}
@Override
public void gameOver() {
System.out.println("mario 打败了魔王，找到了旗杆，要爬旗杆。 ");
targetGame.gameOver();
System.out.println("真菜，不玩了，破游戏什么时候关服！");
}
}
测试类：
package com.dzqc.smbms.proxy;
import org.junit.Test;
import java.lang.reflect.Proxy;
public class ProxyTest {
@Test
public void staticProxy(){
Mario mario = new Mario();
GameStaticProxy gameStaticProxy = new GameStaticProxy();
Game marioProxy = gameStaticProxy.getProxy(mario);
marioProxy.gameStart();
marioProxy.gameOver();
}
}
测试结果：
游戏机启动
游戏启动！
超级马里奥，游戏开始！ //原始内容
游戏进行中，mario他跳起来了
mario 打败了魔王，找到了旗杆，要爬旗杆。
够不着旗杆，游戏结束 //原始内容
真菜，不玩了，破游戏什么时候关服！
JDK动态代理的实现逻辑大致如下：
接口与被代理类与上述一致。
代理类：
package com.dzqc.smbms.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* JDK代理类
*/
public class GameJDKProxy implements InvocationHandler {
private Game targetGame;
public GameJDKProxy(Game targetGame){
this.targetGame = targetGame;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String name = method.getName();
if (name.equals("gameStart")){
Object o = gameStart(method, args);
}else {
Object o = gameOver(method, args);
}
return null;
}
private Object gameStart(Method method , Object[] args) throws Throwable{
System.out.println("mario游戏启动了");
Object invoke = method.invoke(targetGame, args);
System.out.println("正在操作mario通水管");
return null;
}
private Object gameOver(Method method , Object[] args) throws Throwable{
System.out.println("水管打不通");
Object invoke = method.invoke(targetGame, args);
System.out.println("什么破游戏！");
return null;
}
}
测试类：
package com.dzqc.smbms.proxy;
import org.junit.Test;
import java.lang.reflect.Proxy;
public class ProxyTest {
@Test
public void jdkProxy(){
Mario mario = new Mario();
GameJDKProxy gameJDKProxy = new GameJDKProxy(mario);
// 使用JDK动态代理类获取代理对象
Game marioProxy = (Game) Proxy.newProxyInstance(
this.getClass().getClassLoader(), //类加载器
new Class[]{Game.class}, // 代理接口的字节码文件
gameJDKProxy// 自己的代理类，进行目标方法扩充
);
marioProxy.gameStart();
marioProxy.gameOver();
}
}
测试结果
mario游戏启动了
超级马里奥，游戏开始！ //原始内容
正在操作mario通水管
水管打不通
够不着旗杆，游戏结束 //原始内容
什么破游戏！
由上述代码不难看出，动态代理的实现需要以下几点：
bean，因为处理完附加功能外，需要执行原有bean中的方法，以实现代理的目的。代理类：
package com.dzqc.smbms.proxy;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class GameCglibProxy implements MethodInterceptor {
private Game targetGame;
public GameCglibProxy(Game targetGame){
this.targetGame = targetGame;
}
/**
* 获取代理对象
* @return
*/
public Game getProxy(){
// 获取cglib操作类
Enhancer enhancer = new Enhancer();
// 指定代理类 的 父类类型，要代理哪个类就使用哪个类做代理类的父类
enhancer.setSuperclass(Mario.class);
// 指定代理对象，把当前代理类作为代理对象
enhancer.setCallback(this);
// 创建并返回代理对象
return (Game) enhancer.create();
}
/**
* 代理增强的实际操作处
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
String name = method.getName();
if (name.equals("gameStart")){
gameStart(method , objects);
}else {
gameOver(method , objects);
}
return null;
}
private Object gameStart(Method method , Object[] args) throws Throwable{
System.out.println("魂斗罗启动！！！！");
Object invoke = method.invoke(targetGame, args);
System.out.println("正在操作Mario和魂斗罗兄弟决斗");
return null;
}
private Object gameOver(Method method , Object[] args) throws Throwable{
System.out.println("Mario挖了下水道，坑了魂斗罗兄弟");
Object invoke = method.invoke(targetGame, args);
System.out.println("不要串台！");
return null;
}
}
测试类：
package com.dzqc.smbms.proxy;
import org.junit.Test;
import java.lang.reflect.Proxy;
public class ProxyTest {
@Test
public void cglibProxy(){
Mario mario = new Mario();
GameCglibProxy gameCglibProxy = new GameCglibProxy(mario);
Game proxy = gameCglibProxy.getProxy();
proxy.gameStart();
proxy.gameOver();
}
}
测试结果：
魂斗罗启动！！！！
超级马里奥，游戏开始！ //原始内容
正在操作Mario和魂斗罗兄弟决斗
Mario挖了下水道，坑了魂斗罗兄弟
够不着旗杆，游戏结束 //原始内容
不要串台！
由上述代码不难看出，CGlib在进行动态代理的过程中，对被实现的类要求较少，而且更为灵活，使用者可以根据实际情况进行选择。
MVC是什么？MVC是设计模式，包含Model（模型）、View（视图）、Controller（控制器）。
SpringMVC就是基于MVC设计模式创建的一个控制层框架，用来简化视图与后台的数据交互工作，并且规范开发方式。SpringMVC是对Servlet的封装，可将SpringMVC的本质看作Servlet。
类需要使用@Controller注解，在类中声明一个Handler方法，在方法的参数列表中声明需要的参数，在Handler方法被调用时，就可以正确传入对应的参数。
在web.xml种配置 dispatcherServlet
<!-- 配置中央处理器，与Servlet一起初始化 -->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:spring-mvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 配置SpringIOC容器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
在Spring文件当中配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
">
<!-- 配置包扫描,扫描所有使用Controller注解的类 -->
<context:component-scan base-package="com.dzqc.smbms">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 处理器适配器 -->
<bean name="handlerAdapter"
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>
<!-- 处理器映射器 -->
<bean name="handlerMapping"
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>
<!-- 视图解析器 -->
<bean name="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/views/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<!-- 配置静态资源过滤器 -->
<mvc:default-servlet-handler/>
<mvc:resources location="/statics/" mapping="/static/*"></mvc:resources>
<!-- 文件上传解析器 -->
<bean name="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- 最大支持文件大小，此处配置50MB大小限制 -->
<property name="maxUploadSize" value="52428800"></property>
</bean>
</beans>
依赖：
<!-- 文件上传 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.4</version>
</dependency>
Rest注解：
准备工作：
/* 在SpringMVC首次刷新或重新加载时，会调用SpringMVC初始化策略 */ protected void onRefresh(ApplicationContext context) { this.initStrategies(context); } /** 初始化策略方法 */ protected void initStrategies(ApplicationContext context) { this.initMultipartResolver(context); // 初始化文件上传解析器 this.initLocaleResolver(context); // 初始化本地解析器 this.initThemeResolver(context); // 初始化中心解析器 this.initHandlerMappings(context); // 初始化处理器映射器 this.initHandlerAdapters(context); // 初始化处理器适配器 this.initHandlerExceptionResolvers(context); // 初始化处理器异常解析器 this.initRequestToViewNameTranslator(context); // 初始化 请求视图 翻译器 this.initViewResolvers(context); // 初始化视图解析器 this.initFlashMapManager(context); // 初始化 映射刷新管理器 }
2：请求处理流程
MyBatis是一款轻量级的ORM（对象关系映射）（持久化）框架，能够将JDBC相关的持久化代码通过配置文件的形式实现，提高开发效率。
手机工厂：MI，IPHONE，HUAWEI
工厂对象：
抽象实体：
具体实体：
抽象工厂：
抽象产品：
实体工厂：
实体产品：
MyBatis使用分为
<!-- 环境配置标签 default中引用的为默认使用的环境 -->
<environments default="development">
<!-- 环境标签 id 唯一，不可重复 -->
<environment id="development">
<!-- 事务管理器配置 -->
<transactionManager type="JDBC"/>
<!-- 数据源配置 type默认为POOLED（默认启用数据库连接池模式） ，UNPOOLED 不启用连接池 -->
<dataSource type="POOLED">
<!-- 属性标签，该处属性为数据源配置属性 -->
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/smbms_3"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<!-- 映射文件的地址，引用相对路径 -->
<mapper resource="mappers/SUserMapper.xml"></mapper>
</mappers>
<!-- MyBatis别名配置 只能配置实体类 -->
<typeAliases>
<!-- <typeAlias type="com.dzqc.smbms.entity.SUser" alias="u"></typeAlias>-->
<package name="com.dzqc.smbms.entity"/>
</typeAliases>
<settings>
<!-- 配置控制台日志组件 -->
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
获取资源：Resources.getResourceAsStream("MyBatis-config.xml");
SqlSessionFactoryBuilder：构建工厂的建筑队，需要给资源后，调用build方法才能构建工厂。
SqlSessionFactory：工厂建好后，调用openSession方法，产出SqlSession
SqlSession：产出的SqlSession可以通过Mapper接口的字节码（.class）来获取SqlSession中生产的代理对象，从而操作数据库。
<select id="唯一，不可重复" parameterType="参数类型" resultType="返回值类型" resultMap=""
>查询SQL</select>
<insert id="唯一，不可重复" parameterType="" keyColumn="" keyProperty="" useGeneritedKeys="true">插入语句</insert>
<update id="唯一，不可重复" parameterType="" >修改语句</update>
<delete id="唯一，不可重复" parameterType="" >删除语句</delete>
resultMap是MyBatis实现ORM特性的一个最重要的标签。
<association property="role" javaType="srole" column="u.userRole">
<id column="userRole" property="id"></id>
<result column="roleCode" property="roleCode"></result>
<result column="roleName" property="roleName"></result>
</association>
<association property="role" javaType="srole" column="userRole"
select="com.dzqc.smbms.mapper.SRoleMapper.selectById" >
</association>
property：实体类的属性名
column：外关联字段的字段名
javaType：property对应的实体类的类型。
select：外关联查询的方法
<collection property="roleUsers" column="id" javaType="list" ofType="suser"
select="com.dzqc.smbms.mapper.ISUserMapper.selectByRoleId">
</collection>
property：实体类的属性名
column：外关联字段的字段名
javaType：一对多关联集合类型。
ofType：一对多关联集合中存放的数据的类型。
select：外关联查询的方法
什么是事务：事务的本身其实就是一组业务逻辑，在业务逻辑当中包含有针对于数据库持久化的操作。在事务当中的所有业务逻辑被视为一个整体。
事务不隔离会产生的问题：
脏读：当前事务读到了其他事务未提交的数据
幻读（虚读）：当前事务重复读取同样的数据，读取到了其他事务新增的数据，导致短时间内两次读取的数据不一致。
不可重复读：当前事务读到了其他事务已提交的数据，在短时间，两次查询的结果不一致。
优点：对事务的操作精细，能够更加精确的对事务进行管理
缺点：对代码的侵入度高，在后期进行维护、功能变更时会提高维护难度。
事务传播机制一共有7种。
SPI接收数据左移一位问题目录SPI接收数据左移一位问题一、问题描述二、问题分析三、探究原理四、经验总结最近在工作在学习调试SPI的过程中遇到一个问题——接收数据整体向左移了一位（1bit）。SPI数据收发是数据交换，因此接收数据时从第二个字节开始才是有效数据，也就是数据整体向右移一个字节（1byte）。请教前辈之后也没有得到解决，通过在网上查阅前人经验终于解决问题，所以写一个避坑经验总结。实际背景：MCU与一款芯片使用spi通信，MCU作为主机，芯片作为从机。这款芯片采用的是它规定的六线SPI，多了两根线：RDY和INT，这样从机就可以主动请求主机给主机发送数据了。一、问题描述根据从机芯片手
项目介绍随着我国经济迅速发展,人们对手机的需求越来越大,各种手机软件也都在被广泛应用,但是对于手机进行数据信息管理,对于手机的各种软件也是备受用户的喜爱小学生兴趣延时班预约小程序的设计与开发被用户普遍使用,为方便用户能够可以随时进行小学生兴趣延时班预约小程序的设计与开发的数据信息管理,特开发了小程序的设计与开发的管理系统。小学生兴趣延时班预约小程序的设计与开发的开发利用现有的成熟技术参考,以源代码为模板,分析功能调整与小学生兴趣延时班预约小程序的设计与开发的实际需求相结合,讨论了小学生兴趣延时班预约小程序的设计与开发的使用。开发环境开发说明：前端使用微信微信小程序开发工具：后端使用ssm：VU
文章目录一、项目场景二、基本模块原理与调试方法分析——信源部分：三、信号处理部分和显示部分：四、基本的通信链路搭建：四、特殊模块：interpretedMATLABfunction：五、总结和坑点提醒一、项目场景 最近一个任务是使用simulink搭建一个MIMO串扰消除的链路，并用实际收到的数据进行测试，在搭建的过程中也遇到了不少的问题（当然这比vivado里面的debug好不知道多少倍）。准备趁着这个机会，先以一个很基本的通信链路对simulink基础和相关的debug方法进行总结。 在本篇中，主要记录simulink的基本原理和基本的SISO通信传输链路（QPSK方式），计划在下篇记
【动态规划】一、背包问题1.背包问题总结1）动规四部曲：2）递推公式总结：3）遍历顺序总结：2.01背包1）二维dp数组代码实现2）一维dp数组代码实现3.完全背包代码实现4.多重背包代码实现一、背包问题1.背包问题总结暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（DynamicPlanning）里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。1）动规四部曲：（1）确定dp数组及其下标的含义（2）确定递推公式（3）dp数组的初始化（4）确定遍历顺
1，Camera基本工作原理答案：光线通过镜头Lens进入摄像头内部，然后经过IRFilter过滤红外光，最后到达sensor（传感器），senor分为按照材质可以分为CMOS和CCD两种，可以将光学信号转换为电信号，再通过内部的ADC电路转换为数字信号，然后传输给DSP（如果有的话，如果没有则以DVP的方式传送数据到基带芯片baseband，此时的数据格式RawData，后面有讲进行加工）加工处理，转换成RGB、YUV等格式输出。数据流是如何从sensor到APP的？上述描述结束后，在ISP处理后面的阶段，数据会进行分流，分为capture,preview，video等以供后续动作使用。例如
📢博客主页：https://blog.csdn.net/dxt19980308📢欢迎点赞👍收藏⭐留言📝如有错误敬请指正！📢本文由肩匣与橘编写，首发于CSDN🙉📢生活依旧是美好而又温柔的，你也是✨目录🔴线性表1.1顺序表1.1.1顺序表定义1.1.2顺序表基本操作1.2单链表1.2.1单链表节点定义1.2.2单链表基本操作1.3双链表1.3.1双链表节点定义1.3.2双链表基本操作1.4静态链表🟠栈和队列2.1栈2.1.1顺序栈2.1.2链式栈2.2队列2.2.1顺序队列2.2.2链式队列2.3应用🟡串3.1串的定义与实现3.2串的模式匹配🟢树与二叉树4.1二叉树4.1.1二叉树的概念4.1.2
目录MyBatisPlusMP特点MP框架结构MP使用准备导入依赖springboot整合mybatisplus配置文件定义好实体类User后编辑mapper接口@Mapper与@MapperScan("包名")区别MP基本操作新增操作删除操作通过id删除用户通过map作为条件删除通过多个id实现删除更新用户通过id进行用户更新查询用户 根据id查询用户根据多个id查询用户根据map集合作为条件查询用户通用Service接口一些操作 查询总记录数批量添加数据MP常用注解雪花算法前言垂直分表水平分表条件构造器继承结构使用条件构造器实现查询操作查询所有用户根据构造器查询主键字段集合根据条件构造器查
本文总结了在以太坊智能合约中使用Solidity在合约内创建合约以及引用其他合约的方法，包括了如何使用mochai进行测试的方法。在这之前先明白一个比较：Contract{}相当于面向对象语言的类当部署后获得到address后，address相当于对象，address0x.......本身就类似指针地址然后我们讨论下Solidity代码中对合约类，合约对象的操作。Solidity首先区分下三种写法：import'ContractB.sol';ConractBB=newConractB(arg1,arg2...);ContractBB=ContractB(Baddress);functionse
智慧医院不良事件精细化管理平台——微信小程序总结一、实现的功能二、项目收获三、总结（经历分享）一、实现的功能到目前为止，微信小程序开发，到此就算是结束了，其中实现了不少功能，如下：1.1角色与权限（后端同学实现的，写这个方便介绍后面的功能）平台可以配置不同的用户角色并授予其不同的操作权限。每个用户在使用平台时都需要指定一个角色。1.2可视范围——根据角色绑定的权限菜单全体职工可以查看自己上报的事件（待审核、已通过、被驳回）。质控人员可以查看所有的事件（待审核、待评价、已通过、已驳回、已评价）。职能人员可以查看自己/自己部门负责的事件（待整改、待评价、已评价）。各科室医务人员可以查看本科室相关的
我得到了[objectObject]9778177结果，我尝试解析该值但都无济于事，出了点问题。letx=[{"total_count":7},{"total_count":9},{"total_count":778},{"total_count":177}]letsum=x.reduce((accum,obj)=>{returnaccum+obj.total_count})console.log(sum) 最佳答案 您可以添加一个起始值，因为第一次迭代从累加器的对象开始，而您没有所需的属性。letsum=x.reduce((acc