我就是我的博客

什么是事件委托，有什么好处？

2020-01-12T00:00:00+00:00

什么是事件委托，有什么好处？

事件委托：利用事件冒泡的原理，让自己的所触发的事件，让他的父元素代替执行！支持为同一个DOM元素注册多个同类型事件。

说到事件冒泡，那么就要说一下事件捕获了。

事件捕获当一个事件触发后,从Window对象触发,不断经过下级节点,直到目标节点。在事件到达目标节点之前的过程就是捕获阶段。所有经过的节点,都会触发对应的事件
事件冒泡当事件到达目标节点后，会沿着捕获阶段的路线原路返回。同样，所有经过的节点,都会触发对应的事件

当用户触发一个事件时，浏览器的所有详细信息都存在一个叫event的对象上。我们把他叫事件对象，所有事件在绑定方法的时候，天生自带一个参数就叫event。

document.onclick=function(e){
        var e=e||window.event
    }

正常情况下，如果不加限制，事件都是进行事件冒泡机制的.

如下，先打印div1，后打印body。

<body>
    <div id="div1">11</div>
</body>

<script>
	window.onload = function(){
    let body = document.querySelector('body');
    let div1 = document.getElementById('div1');

	body.onclick = function(){
        console.log('打印body')
    }
    div1.onclick = function(){
         console.log('打印div1')
    }
}
//打印div1
// 打印body
</script>

要是想要进行事件捕获怎么办呢？

<div id="div1">11</div>

window.onload = function(){
    let div1 = document.getElementById('div1');
    div1.onclick = function(){
        console.log('打印第一次')
    }
    div1.onclick = function(){
        console.log('打印第二次')
    }
}
//只打印第二次

标准浏览器用addEventListener(type,listener,useCapture)实现
- type: 必须,String类型,事件类型
- listener: 必须,函数体或者JS方法
- useCapture: 可选,boolean类型。指定事件是否发生在捕获阶段。默认为false,事件发生在冒泡阶段
- 以往注册事件的方法,如果存在多个事件,后注册的事件会覆盖先注册的事件

<div id="div1">11</div>

window.onload = function(){
    let div1 = document.getElementById('div1');
    div1.addEventListener('click',function(){
        console.log('打印第一次')
    })
    div1.addEventListener('click',function(){
        console.log('打印第二次')
    })
}
//打印第一次
//打印第二次

这样后面的就不会覆盖前面的了。

如下所示：把useCapture的值设为true，就会进行事件捕获了。这样body就会先输出。

<body>
    <div id="div1"></div>
</body>

window.onload = function(){
    let body = document.querySelector('body');
    let div1 = document.getElementById('div1');
    body.addEventListener('click',function(){
        console.log('打印body')
    },true)
    div1.addEventListener('click',function(){
        console.log('打印div1')
    })
}
//打印body
//打印div1

那什么样的事件可以用事件委托，什么样的事件不可以用呢？

适合用事件委托的事件：click，mousedown，mouseup，keydown，keyup，keypress。
值得注意的是，mouseover 和 mouseout 虽然也有事件冒泡，但是处理它们的时候需要特别的注意，因为需要经常计算它们的位置，处理起来不太容易。
不适合的就有很多了，举个例子，mousemove，每次都要计算它的位置，非常不好把控，在不如说 focus，blur 之类的，本身就没用冒泡的特性，自然就不用事件委托了。

事件委托的优点:

提高性能:每一个函数都会占用内存空间，只需添加一个事件处理程序代理所有事件,所占用的内存空间更少。
动态监听:使用事件委托可以自动绑定动态添加的元素,即新增的节点不需要主动添加也可以一样具有和其他元素一样的事件。例子解析:

target 事件属性可返回事件的目标节点（触发该事件的节点），如生成事件的元素、文档或窗口。

<ul>
  <li>苹果</li>
  <li>香蕉</li>
  <li>凤梨</li>
</ul>

// good
document.querySelector('ul').onclick = (event) => {
  let target = event.target
  if (target.nodeName === 'LI') {
    console.log(target.innerHTML)
  }
}

// bad
document.querySelectorAll('li').forEach((e) => {
  e.onclick = function() {
    console.log(this.innerHTML)
  }
})

就这样父级绑定了点击事件,点击子元素后冒泡上去的时候,执行父级的事件。

事件委托怎么取索引？

  <ul id="ul">
        <li>aaaaaaaa</li>
        <li>事件委托了 点击当前，如何获取 这个点击的下标</li>
        <li>cccccccc</li>
    </ul>
    <script>
        window.onload = function () {
            var oUl = document.getElementById("ul");
            var aLi = oUl.getElementsByTagName("li");
            oUl.onclick = function (ev) {
                var ev = ev || window.event;
                var target = ev.target || ev.srcElement;
                if (target.nodeName.toLowerCase() == "li") {
                    var that = target;
                    var index;
                    for (var i = 0; i < aLi.length; i++)
                        if (aLi[i] === target) index = i;
                    if (index >= 0) alert('我的下标是第' + index + '个');
                    target.style.background = "red";
                }
            }
        }
    </script>

require 与 import 的区别

2020-01-10T00:00:00+00:00

require 与 import 的区别

第一、两者的加载方式不同

require 是在运行时加载，所以require理论上可以运用在代码的任何地方。
而 import 是在编译时加载，所以必须放在文件开头。

require(‘./a’)(); // a 模块是一个函数，立即执行 a 模块函数

var data = require(‘./a’).data; // a 模块导出的是一个对象

var a = require(‘./a’)[0]; // a 模块导出的是一个数组 ======> 哪都行

import $ from ‘jquery’;

import * as _ from ‘_’;

import {a,b,c} from ‘./a’;

import {default as alias, a as a_a, b, c} from ‘./a’; ======>用在开头

第二、规范不同

require 是 CommonJS/AMD 规范
import 是 ESMAScript6+规范
import是es6的一个语法标准，如果要兼容浏览器的话必须转化成es5的语法

第三、require 特点：社区方案，提供了服务器/浏览器的模块加载方案。非语言层面的标准。只能在运行时确定模块的依赖关系及输入/输出的变量，无法进行静态优化。

import 特点：语言规格层面支持模块功能。支持编译时静态分析，便于 JS 引入宏和类型检验。动态绑定。

本质

require是赋值过程，其实require的结果就是对象、数字、字符串、函数等，再把require的结果赋值给某个变量

import是解构过程，但是目前所有的引擎都还没有实现import，我们在node中使用babel支持ES6，也仅仅是将ES6转码为ES5再执行，import语法会被转码为require

require时代的模块

node编程中最重要的思想之一就是模块，而正是这个思想，让JavaScript的大规模工程成为可能。模块化编程在js界流行，也是基于此，随后在浏览器端，requirejs和seajs之类的工具包也出现了，可以说在对应规范下，require统治了ES6之前的所有模块化编程，即使现在，在ES6 module被完全实现之前，还是这样。

详细用法可以查看：

https://www.cnblogs.com/ranyonsue/p/10861276.html

https://www.cnblogs.com/myfirstboke/p/10563597.html

javaScript 中如何检测一个变量是一个 String 类型？

2020-01-08T00:00:00+00:00

javaScript 中如何检测一个变量是一个 String 类型？

答案：三种方法（typeof、constructor、Object.prototype.toString.call()）

你可以使用 typeof 操作符来检测变量的数据类型。

typeof运算符的返回类型为字符串，值包括如下几种：
- ‘undefined’ –未定义的变量或值
- ‘boolean’ –布尔类型的变量或值
- ‘string’ –字符串类型的变量或值
- ‘number’ –数字类型的变量或值
- ‘object’ –对象类型的变量或值，或者null(这个是js历史遗留问题，将null作为object类型处理)
- ‘function’ –函数类型的变量或值
typeof是一个运算符，有2种使用方式：typeof(表达式)和typeof 变量名，第一种是对表达式做运算，第二种是对变量做运算。

typeof('123') === "string" // true

typeof '123' === "string" // true

constructor 属性返回对创建此对象的数组函数的引用。

<script type="text/javascript">
   
var test=new Array();
   
if (test.constructor==Array)
{
document.write("This is an Array");
}
if (test.constructor==Boolean)
{
document.write("This is a Boolean");
}
if (test.constructor==Date)
{
document.write("This is a Date");
}
if (test.constructor==String)
{
document.write("This is a String");
}
   
</script>

'123'.constructor === String // true

3.Object.prototype.toString.call()

Object.prototype.toString.call('123') === '[object String]' // true

在JavaScript里使用typeof判断数据类型，只能区分基本类型，即：number、string、undefined、boolean、object。对于null、array、function、object来说，使用typeof都会统一返回object字符串。要想区分对象、数组、函数、单纯使用typeof是不行的。在JS中，可以通过Object.prototype.toString方法，判断某个对象之属于哪种内置类型。分为null、string、boolean、number、undefined、array、function、object、date、math。

Object.prototype.toString.call(``null``); ``// "[object Null]"
Object.prototype.toString.call(undefined); ``// "[object Undefined]"
Object.prototype.toString.call(“abc”);``// "[object String]"
Object.prototype.toString.call(123);``// "[object Number]"
Object.prototype.toString.call(``true``);``// "[object Boolean]"

js中var，let，const的区别

2020-01-07T00:00:00+00:00

js中var，let，const的区别

ES2015(ES6) 新增加了两个重要的 JavaScript 关键字: let 和 const。

let 声明的变量只在 let 命令所在的代码块{} 内有效，在 {} 之外不能访问。

const 声明一个只读的常量，一旦声明，常量的值就不能改变。

在 ES6 之前，JavaScript 只有两种作用域： 全局变量 与 函数内的局部变量。

全局变量

在函数外声明的变量作用域是全局的
全局变量在 JavaScript 程序的任何地方都可以访问。

局部变量

在函数内声明的变量作用域是局部的（函数内）
函数内使用 var 声明的变量只能在函数内容访问，如果不使用 var 则是全局变量。

let 和 var

使用 var 关键字重新声明变量可能会带来问题。

在块中重新声明变量也会重新声明块外的变量

var x = 10;
// 这里输出 x 为 10
{ 
    var x = 2;
    // 这里输出 x 为 2
}
// 这里输出 x 为 2

let 关键字就可以解决这个问题，因为它只在 let 命令所在的代码块 {} 内有效。

var x = 10;
// 这里输出 x 为 10
{ 
    let x = 2;
    // 这里输出 x 为 2
}
// 这里输出 x 为 10

循环作用域

使用 var 关键字：

var i = 5;
for (var i = 0; i < 10; i++) {
    // 一些代码...
}
// 这里输出 i 为 10

使用 let 关键字：

var i = 5;
for (let i = 0; i < 10; i++) {
    // 一些代码...
}
// 这里输出 i 为 5

在第一个实例中，使用了 var 关键字，它声明的变量是全局的，包括循环体内与循环体外。

在第二个实例中，使用 let 关键字，它声明的变量作用域只在循环体内，循环体外的变量不受影响。

const

const 用于声明一个或多个常量，声明时必须进行初始化，且初始化后值不可再修改：

const PI = 3.141592653589793;
PI = 3.14;      // 报错
PI = PI + 10;   // 报错

const定义常量与使用let 定义的变量相似：

二者都是块级作用域
都不能和它所在作用域内的其他变量或函数拥有相同的名称

两者还有以下两点区别：

const声明的常量必须初始化，而let声明的变量不用
const 定义常量的值不能通过再赋值修改，也不能再次声明。而 let 定义的变量值可以修改。

const 的本质: const 定义的变量并非常量，并非不可变，它定义了一个常量引用一个值。使用 const 定义的对象或者数组，其实是可变的。下面的代码并不会报错：

// 创建常量对象
const car = {type:"Fiat", model:"500", color:"white"};
 
// 修改属性:
car.color = "red";
 
// 添加属性
car.owner = "Johnson";

但是我们不能对常量对象重新赋值：

const car = {type:"Fiat", model:"500", color:"white"};
car = {type:"Volvo", model:"EX60", color:"red"};    // 错误

解决浏览器端引用less跨域问题

2020-01-06T00:00:00+00:00

解决本地引用less跨域问题

Less 是一门 CSS 预处理语言，它扩展了 CSS 语言，增加了变量、Mixin、函数等特性，使 CSS 更易维护和扩展。

Less 可以运行在 Node 或浏览器端。

在 Node.js 环境中使用 Less ：

npm install -g less

对于less在node环境中怎么使用less中文网上已经很明确了，可以自行学习。

下面主要说一下less怎么在浏览器端使用。

在浏览器端

1.去中文网下载最新的less,或者引入有效的CDN也可以，但是这样会有跨域问题。在本地是不行的。

2.所以就需要在本地配到服务器端，这样就可以避免跨域问题。
- 在本地IIS里面新建一个网站，首页就是index.html文件
- 然后指定一个端口号，在本地localhost：端口号访问就行了。
还有一个方法更简单。就是直接把less写到html里面

<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<title></title>	
	<style type="text/less">
        .ccc{
            height: 60px;
            background-color: #ccc;
            .left{
                color: green;
            }
            .right{
                color: red;
            }
        }
    </style>
<script src="less.js"></script>
	</head>
	<body>
		<div class="ccc">1111111111</div>
		111
	</body>
</html>

你要告诉它里面的是less就可以运行了，就是这么简单。

一看就会的vue 路由传参 params 与 query两种方式的区别

2019-12-28T00:00:00+00:00

一看就会的vue 路由传参 params 与 query两种方式的区别

这么说容易理解：query相当于get请求，页面跳转的时候，可以在地址栏看到？+传的值，而params相当于post请求，参数不会再地址栏中显示。

//query传参 这里路径用的是path
this.$router.push({
        path:'/xxx'
        query:{
          id:id
        }
      })
  
//query接收参数:
this.$route.query.id

//params传参 这里路径用的是name
this.$router.push({
        name:'xxx'
        params:{
          id:id
        }
      })
  
接收参数:
this.$route.params.id

`传参是this.$router,接收参数是this.$route,`

前端之节流和防抖

2019-12-17T00:00:00+00:00

前端之节流和防抖

在前端开发中，我们会遇到一些持续触发的事件，但是我们并不希望那样的去触发它，那么节流和防抖都是用来防止一些函数不必要的连续执行的。

在明白防抖和节流之前一定要先明白两个定时器的用法

setTimeout() 方法用于在指定的毫秒数后调用函数或计算表达式。
setTimeout(code,millisec) ：code是要调用的函数后要执行的 JavaScript 代码串。millisec是在执行代码前需等待的毫秒数。
setTimeout() 只执行 code 一次。如果要多次调用，请使用 setInterval() 或者让 code 自身再次调用 setTimeout()。

setInterval以指定时间为周期循环，会一直执行，直到 clearTimeout ()被调用

节流

首先来说节流是什么？

节流就是节省流量，一点一点的用流量，不要一下子全用完了，一段时间用一点。
当持续触发事件时，保证一定时间段内只调用一次事件处理函数。
坦白说就是当要连续触发一个事件的时候，一个事件执行完后，等待一段时间再继续执行它。
节流throttle代码（时间戳）：

var throttle = function(func, delay) {            
　　var prev = Date.now();            
　　return function() {                
　　　　var context = this;                
　　　　var args = arguments;                
　　　　var now = Date.now();                
　　　　if (now - prev >= delay) {                    
　　　　　　func.apply(context, args);                    
　　　　　　prev = Date.now();                
　　　　}            
　　}        
}        
function handle() {            
　　console.log(Math.random());        
}        
window.addEventListener('scroll', throttle(handle, 1000));

当高频事件触发时，第一次会立即执行（给scroll事件绑定函数与真正触发事件的间隔一般大于delay，如果你非要在网页加载1000毫秒以内就去滚动网页的话，我也没办法o(╥﹏╥)o），而后再怎么频繁地触发事件，也都是每delay时间才执行一次。而当最后一次事件触发完毕后，事件也不会再被执行了（最后一次触发事件与倒数第二次触发事件的间隔小于delay，为什么小于呢？因为大于就不叫高频了呀
节流throttle代码（定时器）：

// 节流throttle代码（定时器）：
var throttle = function(func, delay) {            
    var timer = null;            
    return function() {                
        var context = this;               
        var args = arguments;                
        if (!timer) {                    
            timer = setTimeout(function() {                        
                func.apply(context, args);                        
                timer = null;                    
            }, delay);                
        }            
    }        
}        
function handle() {            
    console.log(Math.random());        
}        
window.addEventListener('scroll', throttle(handle, 1000));

当触发事件的时候，我们设置一个定时器，再次触发事件的时候，如果定时器存在，就不执行，直到delay时间后，定时器执行执行函数，并且清空定时器，这样就可以设置下个定时器。当第一次触发事件时，不会立即执行函数，而是在delay秒后才执行。而后再怎么频繁触发事件，也都是每delay时间才执行一次。当最后一次停止触发后，由于定时器的delay延迟，可能还会执行一次函数。

节流中用时间戳或定时器都是可以的。更精确地，可以用时间戳+定时器，当第一次触发事件时马上执行事件处理函数，最后一次触发事件后也还会执行一次事件处理函数。
节流throttle代码（时间戳+定时器）：

// 节流throttle代码（时间戳+定时器）：
var throttle = function(func, delay) {     
    var timer = null;     
    var startTime = Date.now();     
    return function() {             
        var curTime = Date.now();             
        var remaining = delay - (curTime - startTime);             
        var context = this;             
        var args = arguments;             
        clearTimeout(timer);              
        if (remaining <= 0) {                    
            func.apply(context, args);                    
            startTime = Date.now();              
        } else {                    
            timer = setTimeout(func, remaining);              
        }      
    }
}
function handle() {      
    console.log(Math.random());
} 
window.addEventListener('scroll', throttle(handle, 1000));

在节流函数内部使用开始时间startTime、当前时间curTime与delay来计算剩余时间remaining，当remaining<=0时表示该执行事件处理函数了（保证了第一次触发事件就能立即执行事件处理函数和每隔delay时间执行一次事件处理函数）。如果还没到时间的话就设定在remaining时间后再触发（保证了最后一次触发事件后还能再执行一次事件处理函数）。当然在remaining这段时间中如果又一次触发事件，那么会取消当前的计时器，并重新计算一个remaining来判断当前状态。

防抖

那么防抖有是什么？

防抖就是防止抖动，防止你持续的抖动触发事件，等抖完了再执行。
当持续触发事件时，一定时间段内没有再触发事件，事件处理函数才会执行一次。
如果设定的时间到来之前，又一次触发了事件，就重新开始延时。

/ 防抖
function debounce(fn, wait) {    
    var timeout = null;    
    return function() {        
        if(timeout !== null)   clearTimeout(timeout);        
        timeout = setTimeout(fn, wait);    
    }
}
// 处理函数
function handle() {    
    console.log(Math.random()); 
}
// 滚动事件
window.addEventListener('scroll', debounce(handle, 1000));

当持续触发scroll事件时，事件处理函数handle只在停止滚动1000毫秒之后才会调用一次，也就是说在持续触发scroll事件的过程中，事件处理函数handle一直没有执行。

应用场景

debounce（防抖）
- search搜索，用户在不断输入值时，用防抖来节约请求资源。
- window触发resize的时候，不断的调整浏览器窗口大小会不断的触发这个事件，用防抖来让其只触发一次
throttle （节流）
- 鼠标不断点击触发，mousedown(单位时间内只触发一次)
- 监听滚动事件，比如是否滑到底部自动加载更多，用throttle来判断

状态图和活动图的区别

2019-12-15T00:00:00+00:00

状态图和活动图的区别

状态图

状态图描述一个特定对象的所有可能状态以及由于各种事件的发生而引起的状态之间的转移。状态图侧重于从行为的结果来描述，只涉及一个特定的对象，常用于动态特性建模。
状态图的组成

（1）起点、终点

（2）状态

主要用来描述一个对象在生命周期内的一个时间段。状态包括：状态名、内部转移、进入/退出操作、子状态、延迟事件等状态的特征。

（3）转换

两个状态之间的关系，即当发生指定事件并满足指定条件时，第一个状态中的对象将执行某些操作进入第二个状态。

（4）事件

事件可以分为几种：信号事件、调用事件、改变事件、时间事件等。

活动图

活动图描述了一次行为活动的流程，主要强调了行为活动的顺序和条件控制
活动图的组成

（1）开始和结束状态

（2）活动：标示动作

（3）控制流：链接活动

（4）决策:条件判断

活动图和状态图的区别

描述对象不同

状态图描述对象状态及状态之间的转移

活动图描述到活动的控制流
使用场合不同

状态图描述对象在其生命期中的行为状态变化

活动图描述过程的流程变化
状态图侧重从行为的结果来描述（状态）

活动图侧重从行为的动作来描述（活动）
状态图重点在于描述对象的状态及其状态之间的转移

活动图描述的是对象活动的顺序关系所遵循的规则，它着重表现的是系统的行为，而非系统的处理过程。

活动图能够表示并发活动的情形，活动图是面向对象的。

UML类图:类之间的6种关系及表示方法

2019-12-14T00:00:00+00:00

UML类图:类之间的6种关系及表示方法

常见的关系有：继承，关联关系，聚合关系，复合关系，依赖关系,实现关系。

其中，聚合关系（Aggregation），组合关系（Composition）属于关联关系（Association）。

几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖。

虚线箭头指向依赖；
实线箭头指向关联；
虚线三角指向接口；
实线三角指向父类；
空心菱形能分离而独立存在，是聚合；
实心菱形精密关联不可分，是组合；

这些关系之间的表示方法如下图所示

继承（泛化）

一种继承关系，表示一般与特殊的关系，它指定了子类如何特化父类的特征和行为。
实现

一种类与接口之间的关系，表示类是接口所有特征和行为的实现
组合

整体与部分的关系，但部分不能离开整体而单独存在
聚合

整体与部分的关系，部分可以离开整体而单独存在
关联

关联关系是类与类之间的联结

是一种拥有的关系，它使一个类知道另一个类的属性和方法

关联关系可以是单向也可以是双向，双向的关联关系两端没有箭头或两个箭头，单向的关联关系有一个箭头，而且箭头在被关联类方
依赖

依赖关系也是代表类与类的联结

是一种使用的关系，即一个类的实现需要另一个类的协助

依赖必须是单向的。

聚合和组合的区别

这两个比较难理解，重点说一下。聚合和组合的区别在于：聚合关系是“has-a”关系，组合关系是“contains-a”关系；聚合关系表示整体与部分的关系比较弱，而组合比较强；聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对象，同时也就删除了代表部分事物的对象。

关联和聚合的区别

关联和聚合的区别主要在语义上，关联的两个对象之间一般是平等的，例如你是我的朋友，聚合则一般不是平等的，例如一个公司包含了很多员工，其实现上是差不多的。

依赖于关联的区别

1.首先从关系程度上依赖没有关联程度强烈，对于两个类之间的依赖，只是保持在方法上，例如一个类的方法中引用了某个类的变量。

2.在关联中确实彼此把对方作为自己的一个属性，耦合度更高。保持的时间更长些，毕竟是作为一个属性存在，实例化我的时候，就会有你。而依赖只是单纯的用到对方方法时才存在

泛化与实现的区别

其实泛化与实现之间的关系只有一点，如实是实现的话，那么子类就不能够在扩充方法，如果是泛化的话，可以在父类基础上再次扩充自己的方法。

大学生期末考试应该怎么办？

2019-12-12T00:00:00+00:00

突然灵机一动

期末考试

下一周就要进行期末考试了，今天晚上我在进行复习的时候，脑子里突然闪出一个想法。

就是花大量的时间进行复习到底值不值得？

我是这么想的，经过三年大学期末考试的实践，其实大学的期末考试就靠最后那两天的突击。

最后复习课上认真听好老师给说的题型以及范围，再加上回去后努力一番，过60肯定没问题。

虽然都是最后几天复习突击，但是经过我的观察，最后突击也可以分成好几种

提前一周左右开始的

这种一般是平时上课认真听讲的同学
根据老师复习课讲的，拿着课本和课件自己复习
根据老师复习课讲的，拿着课本和课件几个人结伴复习
- 这时候在他们复习的时候，有一部分人还在宿舍打游戏、追剧，一点也不慌的样子

提前2-3天开始复习的

这种一般是平时上课稍微听讲的同学
他们会先问一下哪些提前一周就开始复习的同学
然后根据老师和提前一周开始复习的同学的总结，结合他们的想法开始复习
- 这时候还有人不慌，就是有心态好的人，及时潇洒及时行乐

明天考试开始复习的

这种基本上是平时上课不听讲的同学
他们根本不知道老师最后说的什么
只能问第一种和第二种同学，根据他们说的来复习

最后你会发现，哪些提前很久就开始复习的同学不一定就考高分，有的甚至不如明天考试今天才开始复习的同学考的高。这是什么原因呢？

上图是我总结的期末考试复习图

其实哪些越往后开始复习的人，他们越紧张，那时候离考试时间近，所以他们就比较投入，再加上，提前已经有人把复习资料整理出来了，所以他们的效率也就高一些。

从上图可以看出，基本上一开始你什么也不会的时候，吸收知识是很快的，可以很快的掌握大部分的知识点,而你复习时间很长也不一定就比人家多学了多少，只不过是在巩固，多学的那一点，考试要是再不考，就白学了

这就是为什么复习时间长还不一定考高分的原因

所以我才会产生一开始的那个疑问？

就是我是花一天时间突击一下，保证自己不挂科就行，还是多花点时间复习，在吸收大部分知识的基础上再慢慢吸收一些，争取考一个高分（考高分是有一定难度的，因为老师期末复习只给差不多80分左右的复习范围，剩下的就看你自己的积累了，所以越往后复习的就越缥缈）

如果是突击复习，节约下来的时间我可以学习其他的东西，可以敲敲代码什么的，但是可能导致我的成绩出来不理想，然后我会不是那么高兴，老师也会说我。要是花时间复习了，我又感觉复习时间那么长，却比哪些复习一会的人高不了几分，而白复习了。

~~所以我很矛盾~~

哎，不说说了，思考那么多也没有用，好好复习才是硬道理，我还是多多复习考一个高分吧！