redux
**redux**是状态管理的js库，可以单独使用

redux的工作流程

 - redux 是一个应用数据流框架，主要是解决了组件间状态共享的问题，原理是集中式管理，主要有三个核心方法，action，store，reducer
 
 - 工作流程是view 调用 store 的 dispatch 接收 action 传入 store，reducer 进行 state 操作，view通过 store 提供的 getState 获取最新的数据，flux 也是用来进行数据操作的，有四个组成部分action，dispatch，view，store
 
 - 工作流程是 view 发出一个 action，派发器接收 action，让 store 进行数据更新，更新完成以后 store 发出 change，view 接受 change 更新视图。
 
 - Redux 和 Flux很像。主要区别在于 Flux 有多个可以改变应用状态的 store，在 Flux 中 dispatcher 被用来传递数据到注册的回调事件，但是在 redux 中只能定义一个可更新状态的 store，redux 把 store 和 Dispatcher 合并,结构更加简单清晰


redux三大设计原则
- 只读state
state不能直接修改，必须要通过提交action（描述修改状态的对象）下跪啊state状态

- 纯函数修改状态
纯函数：参数相同结果相同，不使用外部状态
通过提交action修改state，通过reducer（必须是函数）来描述具体如何修改。

- 单一数据源
整个项目的状态都在有个大的对象内。

react-redux 连接组件和仓库
Provider提供仓库
connect高阶组件

mapStatetoProps  把仓库state映射到组件props上
mapDispatchtoProps  把仓库的dispatch映射到组件的props上  

以上两个参数都是函数，必须要有返回值，返回值的数据类型是对象，和组件的props合并  connect(mapStatetoProps , mapDispatchtoProps  )(链接的组件)

redux使用的步骤
1.下载 redux 和 react-redux
npm i redux react-redux  或
yarn add redux react-redux

2.创建仓库
store
	index.js	（ *整个仓库的入口* ）
	actions		（ *所有action的状态* ）
	reduces	（ *拆分开的 reducer* ）
	actionTypes		（  type声明文件 ）

3.provider提供仓库
4.connect 连接组件和仓库
bindActionCreators:作用：可以在拆分的action内使用dispatch

action有同步action和异步action，同步action直接返回对象，异步的需要返回函数

redux-thunk作用解决异步action

redux核心
1. 内容回顾
2. 学习目标
3. redux概念
4. 学习内容
4.1 为什么使用Redux
4.2 核心概念
(1). state对象
* 纯函数
(2). action对象
(3). Store对象  (负责存储的仓库)
4.3 redux  三大原则
4.4 redux 基本应用
1). 安装
2). 引入
3). 创建一个仓库，在仓库中对状态进行管理，参数为一个纯函数
4). reducer 纯函数
方法1. getState 获取状态
方法2. dispatch 修改
(1). 修改1次后
(2). 修改2次后
(3). 修改3次后，且有一次新增（所有对数据的操作都用dispatch，包括修改、新增）
方法3. subscribe 监听状态
方法4. replaceReducer
5. reducer 优化合并

1. 内容回顾

react-router

2. 学习目标

掌握 redux 三大原则
掌握 redux 基本应用
掌握 react-redux 使用
掌握 react-thunk 使用

3. redux概念

Redux 是一个独立的JavaScript 状态管理库， 非React内容之一
链接: https://www.redux.org.cn/.

4. 学习内容
4.1 为什么使用Redux

Redux 本身是 MVVM渐进式框架， M(数据模型) - V(视图) - VM(虚拟模型)


4.2 核心概念
理解Redux 几个核心概念与它们之间的关系

state ：存储当前页面自身数据；只读 (所以修改需要用到reducer)
reducer：管理数据，类似仓库管理员，统一存储所有数据
store ：仓库，存所有state
action：修改state的新的状态

(1). state对象

通常我们会把应用中的 数据存储 到一个对象树中进行统一管理，我们把这个位置称为： state


state 是只读的：


这里需要注意的是，为了保证数据状态的可维护性和测试，不推荐直接修改state中的原数据


需要通过纯函数修改 state

* 纯函数
a. 什么是纯函数？纯函数  – 函数式编程的一种概念：

相同的输入永远返回相同的输出
不修改函数的输入值
不依赖外部环境状态
无任何副作用 (例如：异步请求以及定时器造成的问题)

b. 使用纯函数的好处：

便于测试
有利于重构

(2). action对象


我们对state 的修改是通过reducer 纯函数来进行的，同时通过传入的 action 来执行具体的操作


action 是一个对象


type 属性： 表示要进行操作的动作类型，  增删改查。。。。


payload属性： 操作 state 的同时传入的数据


但是这里需要注意的是，我们不直接去调用Reducer函数,而是通过Store对象提供的dispatch方法来调用


(3). Store对象  (负责存储的仓库)

为了对 steta, reducer, action,进行统一的管理和维护，我们需要创建一个Store对象(仓库)


4.3 redux  三大原则


单一数据源： 整个应用的state 被储存在一棵 obeject tree中，并且这个object tree 只存在于 唯一的store 中


State 是只读的，唯一改变state的方法就是触发 action，action是一个用于描述已发生事件的普通对象


使用纯函数来进行修改



4.4 redux 基本应用
1). 安装

npm i redux

2). 引入
import { createStore } from 'redux'

3). 创建一个仓库，在仓库中对状态进行管理，参数为一个纯函数
let store = createStore(reducer);

4). reducer 纯函数


因为 state 是只读的，所以需要一个纯函数去修改内部的值


reducer 代表仓库管理员


state 后面可以加默认值，也可以不加


reducer 也是我们自己起的名字，符合见名知意即可


格式：
function reducer(state=默认值,action){ return state; }

参数1：state 的初始值，可以是外界传进来的值，也可以是默认值
参数2：action -- 修改值



function reducer(state={
    name:"电影院",
    age:20
},action){
    return state;
}

let store = createStore(reducer); //传函数体进去，不是传函数调用
console.log(store);

在控制台输出仓库，可以看到一个对象，其中包含几个方法：


方法1. getState 获取状态
getState: ƒ getState()   -- 获取状态

代码示例：
console.log(store.getState());

浏览器输出：


方法2. dispatch 修改
dispatch: ƒ dispatch(action)   -- 发起一次修改 （同步方法，立即执行！！！）

	action:{
        type:"做了什么修改"  -- 必填！下面修改时注意相应的type与这里对应准确~
    }

代码示例：
(1). 修改1次后
import React from 'react';
import {createStore} from 'redux'

function reducer(state={
    name:"电影院",
    age:20
},action){
  	switch(action.type){
    	case 'edit_name':
		    return{
	        	...state,
	        	name:action.name
	      	}
  	}
    return state;
}


let store = createStore(reducer); //传函数体进去，不是传函数调用

store.dispatch({
    type:"edit_name",
    name:"游泳馆"
});

console.log(store.getState()); //获取状态


function App() {
  return (
    <div>哈哈</div>
  );
}
export default App;

浏览器输出：


(2). 修改2次后
import React from 'react';
import {createStore} from 'redux'

function reducer(state={
    name:"电影院",
    age:20
},action){
  	switch(action.type){
    	case 'edit_name':
		    return{
	        	...state,
	        	name:action.name
	      	}
      
    	case 'edit_age':
      		return{
        		...state,
        		age:action.age
      		}
  	}
    return state;
}


let store = createStore(reducer); //传函数体进去，不是传函数调用

store.dispatch({
    type:"edit_name",
    name:"游泳馆"
});
store.dispatch({
    type:"edit_age",
    age:21
});

console.log(store.getState()); //获取状态

...

浏览器输出：


(3). 修改3次后，且有一次新增（所有对数据的操作都用dispatch，包括修改、新增）
已有的属性，覆盖；没有的去新增创建新的属性

function reducer(state={
    name:"电影院",
    age:20
},action){
  	switch(action.type){
    	case 'edit_name':
		    return{
	        	...state,
	        	name:action.name
	      	}
      
    	case 'edit_age':
      		return{
        		...state,
        		age:action.age
      		}
      		
      	case 'edit_time':
	     	return{
	        	...state,
	        	time:action.time
	      	}
  	}
    return state;
}


let store = createStore(reducer); //传函数体进去，不是传函数调用

store.dispatch({
    type:"edit_name",
    name:"游泳馆"
});
store.dispatch({
    type:"edit_age",
    age:21
});
store.dispatch({
    type:"edit_time",
    time:"待定"
});

console.log(store.getState()); //获取状态

...

浏览器输出：


方法3. subscribe 监听状态
state发送改变时触发

参数是： 触发时执行的回调函数

subscribe: ƒ subscribe(listener)    -- 监听状态的修改

代码示例：
import React from 'react';
import {createStore} from 'redux'

function reducer(state={
    name:"电影院",
    age:20
},action){
  	switch(action.type){
    	case 'edit_name':
		    return{
	        	...state,
	        	name:action.name
	      	}
      
    	case 'edit_age':
      		return{
        		...state,
        		age:action.age
      		}
      		
      	case 'edit_time':
	     	return{
	        	...state,
	        	time:action.time
	      	}
  	}
    return state;
}


let store = createStore(reducer); 

// subscribe -- 监听状态的修改
// state发送改变时触发  参数是： 触发时执行的回调函数		
store.subscribe(()=>{
  console.log(store.getState());
});

store.dispatch({
    type:"edit_name",
    name:"游泳馆"
});
store.dispatch({
    type:"edit_age",
    age:21
});
store.dispatch({
    type:"edit_time",
    time:"待定"
});

// console.log(store.getState()); //获取状态

function App() {
  return (
    <div>哈哈</div>
  );
}

export default App;

浏览器输出：


方法4. replaceReducer
replaceReducer: ƒ replaceReducer(nextReducer)    -- 替换掉 reducer


5. reducer 优化合并
接下一篇博客：React-5.2 Redux – combineReducers优化合并reducer

小编做为一个多年资深搞仓库卫生，管理库存计划的打工人，由于工作需要，也接触了几种不同的计算平均值的方法，虽然现在系统是越来越强大了，很多数据，系统都能够直接计算出来的。但是，知其然才能知其所以然，了解下计算的原理，掌握最基本的原则还是很重要的。只有这样，我们才能更好的开展工作。今天，我们就以配件预算月需求这个实例来看看，几种不同的计算平均值方法，用excel表格，需要怎么计算。
1、计算算数平均值
科普下，一般对于使用有1年或以上的配件，默认是以前12个月的平均值来预测这个很简单了，就是12个月的数量相加，然后除于12个月求平均值，如果不用公式，可以如图这样。恩恩，硬核……
好了，不开玩笑，一个average函数能搞定的事，就不搞笑了
2、计算加权平均值
而对有半年以上而还未满一年的配件，一般我们就使用加权平均值来进行预测。概念：加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。如下图所示。
那么，我们就可以使用之前也有讲过sumproduct函数和sum函数来进行计算。相应公式就是类似=SUMPRODUCT(C2:H2,$C$7:$H$7)/SUM(C7:H7)，而又因为这里的各个数据的总权重为1，所以就可以将UM(C7:H7)省略，最终公式就是直接使用sumproduct即可。如动图所示，在O2单元输入公式=SUMPRODUCT(C2:H2,$C$7:$H$7)，注意权重部分的$C$7:$H$7需要使用绝对引用，这样在复制公式时，才不会因为权重部分引用错误而导致计算错误。
有关sumproduct函数，如果有不明白的，可以看回这篇文章了解
sumproduct函数——哪里需要去哪里，求和计数样样精通​mp.weixin.qq.com
当然，配件预测销售数量一般不可能有小数点，这里，再设置多一个取整函数就可以了，就不展开了。可以看这篇
眼见不一定为实，四舍五入取整函数来帮忙​mp.weixin.qq.com
3、根据指定条件求平均值
如动图，我们要计算总经办的平均工资，这里的条件，就是部门为总经办。我们来使用一个比average功能强大一点的兄弟，averageifs函数，先来了解下语法。作用：返回满足多个条件的所有单元格的平均值（算术平均值）。AVERAGEIFS(average_range,criteria_range1, criteria1, [criteria_range2, criteria2], ...)AVERAGEIFS函数语法具有下列参数：Average_range    必需。要计算平均值的一个或多个单元格，其中包含数字或包含数字的名称、数组或引用。Criteria_range1、criteria_range2等   Criteria_range1 是必需的，后续 criteria_range 是可选的。在其中计算关联条件的 1 至 127 个区域。Criteria1、criteria2等    Criteria1 是必需的，后续 criteria 是可选的。形式为数字、表达式、单元格引用或文本的 1 至 127 个条件，用来定义将计算平均值的单元格。例如，条件可以表示为 32、"32"、">32"、"苹果" 或 B4。语法这么长，其实简单理解，
就是AVERAGEIFS(求平均值区域，条件区域1，条件1，……),可以了。
在此例，我们在G3单元格输入公式=AVERAGEIFS(C3:C12,A3:A12,F3)，这里求平均值的区域，就是C3:C12；而条件区域就是A3:A12，相对应条件就是F3单元格的“总经办”。这样，我们的总经办平均工资就求出来了。
大脑：恩，看懂了~
手：你说啥？鼠标要点哪里？要怎么点击？
光看不练，上阵头晕，大家多多练习下，才能真正掌握哦~~
今天的分享就到这里，大家生活愉快~~
赞同、喜欢、收藏~~~都可以有的~~向我砸过来哈~~

每日学习总结
2020-07-04
1. maven项目管理工具
1.1 依赖管理:
1.3 仓库分类
1.4 maven的三大生命周期：
1.5 jar包的依赖
1.6 解决jar包冲突的三个原则
1.7 统一jar包版本管理
1.8 工程和模块的区别
1.9 项目之间的依赖关系
2 Jdk1.8新特性
2.1jdk1.8使用红黑树的改进

2020-07-04
1. maven项目管理工具
1.1 依赖管理:
依赖管理就是对jar包的管理过程, 传统项目中直接放置jar包, maven工程真正的将jar包在仓库中配置, 项目中只用放置jar包的坐标,
###1.2 一键构建
使用maven集成的tomcate插件对项目进行构建, 测试 打包，安装，等操作。
1.3 仓库分类
分为三类： 本地仓库，远程仓库（私服），中央仓库。
本地仓库是我们运行项目第一步必须保证本地仓库有对应的jar包。如果本地没有默认会自动去中央仓库去下载，在公司中会先从远程仓库下载， 远程仓库没有的话， 会从中央仓库下载或本地上传。
1.4 maven的三大生命周期：
清理生命周期： clean。清理target下的class文件
默认生命周期：
compile（只编译src/main下面的代码），
test(既编译src/main下面的代码，又会编译src/test下面的代码)，
package（前两步都走了， 还会在target目录下打个包），
install（会把前面的步骤都走一遍，不但会在target目录下打个包，还会在本地仓库打个包），这几个命令，


1.5 jar包的依赖
直接依赖： A 项目中导入了B包， 我们可以说A直接依赖B。
传递依赖： A 项目中导入了B包，B包直接依赖于C吗，最终A项目中也可以使用C，那么我们就可以说A传递依赖于C。
1.6 解决jar包冲突的三个原则
第一声明优先原则：哪个jar包的坐标在靠上的位置， 哪个就是第一声明，最终进入项目的就是哪个包的依赖包。
路径优先原则：直接依赖路径比传递依赖路径近， 哪个依赖路径近， 进入项目的就是哪个包。
直接排除法：使用exclutions标签直接来排除某个包下的依赖包。
1.7 统一jar包版本管理
      <!-- 统一管理jar包版本 -->
        <properties>
          <spring.version>5.0.2.RELEASE</spring.version>
          <slf4j.version>1.6.6</slf4j.version>
          <log4j.version>1.2.12</log4j.version>
          <shiro.version>1.2.3</shiro.version>
          <mysql.version>5.1.6</mysql.version>
          <mybatis.version>3.4.5</mybatis.version>
          <spring.security.version>5.0.1.RELEASE</spring.security.version>
        </properties>

锁定jar包版本
maven工程是可以分父子依赖关系的。

凡是依赖别的项目后，拿到的别的项目的依赖包，都属于传递依赖。

比如：当前A项目，被B项目依赖。那么我们A项目中所有jar包都会传递到B项目中。

B项目开发者，如果再在B项目中导入一套ssm框架的jar包，对于B项目是直接依赖。

那么直接依赖的jar包就会把我们A项目传递过去的jar包覆盖掉。

为了防止以上情况的出现。我们可以把A项目中主要jar包的坐标锁住，那么其他依赖该项目的项目中，

即便是有同名jar包直接依赖，也无法覆盖。

    <!-- 锁定jar包版本 -->
        <dependencyManagement>
          <dependencies>
            <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>${spring.version}</version>
            </dependency>
            <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-web</artifactId>
              <version>${spring.version}</version>
            </dependency>
            <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-webmvc</artifactId>
              <version>${spring.version}</version>
            </dependency>
            <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-tx</artifactId>
              <version>${spring.version}</version>
            </dependency>
            <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-test</artifactId>
              <version>${spring.version}</version>
            </dependency>
            <dependency>
              <groupId>org.mybatis</groupId>
              <artifactId>mybatis</artifactId>
              <version>${mybatis.version}</version>
            </dependency>
          </dependencies>
        </dependencyManagement>

1.8 工程和模块的区别
工程不等于完整的项目，模块也不等于完整的项目，一个完整的项目看的是代码，代码完整，就可以说这是一个完整的项目和此项目是工程和模块没有关系。
工程天生只能使用自己内部资源，工程天生是独立的。后天可以和其他工程或模块建立关联关系。模块天生不是独立的，模块天生是属于父工程的，模块一旦创建，所有父工程的资源都可以使用。
父子工程直接，子模块天生集成父工程，可以使用父工程所有资源。子模块之间天生是没有任何关系的。
父子工程直接不用建立关系，继承关系是先天的，不需要手动建立。平级直接的引用叫依赖，依赖不是先天的，依赖是需要后天建立的。




1.9 项目之间的依赖关系
举例:


2 Jdk1.8新特性
2.1jdk1.8使用红黑树的改进
在java jdk8中对HashMap的源码进行了优化，在jdk7中，HashMap处理“碰撞”的时候，都是采用链表来存储，当碰撞的结点很多时，查询时间是O（n）。

在jdk8中，HashMap处理“碰撞”增加了红黑树这种数据结构，当碰撞结点较少时，采用链表存储，当较大时（>8个），采用红黑树（特点是查询时间是O（logn））存储（有一个阀值控制，大于阀值(8个)，将链表存储转换成红黑树存储）


问题分析：
你可能还知道哈希碰撞会对hashMap的性能带来灾难性的影响。如果多个hashCode()的值落到同一个桶内的时候，这些值是存储到一个链表中的。最坏的情况下，所有的key都映射到同一个桶中，这样hashmap就退化成了一个链表——查找时间从O(1)到O(n)。
随着HashMap的大小的增长，get()方法的开销也越来越大。由于所有的记录都在同一个桶里的超长链表内，平均查询一条记录就需要遍历一半的列表。
JDK1.8HashMap的红黑树是这样解决的：
如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来替换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。
它是如何工作的？前面产生冲突的那些KEY对应的记录只是简单的追加到一个链表后面，这些记录只能通过遍历来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的那个会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照顺序来进行插入。这对HashMap的key来说并不是必须的，不过如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。