先看看最常见的一个问题：

<!DOCTYPE html>

<html>

	<head>

		<meta charset="UTF-8">

		<title></title>

		<script type="text/javascript">

			window.onload = function() {

				var a = document.getElementsByTagName('li');

				for(var i = 0; i < a.length; i++) {

					(function(i,j,k) {

						a[i].onclick = function() {

							console.log(i++,j,k);

						}

					})(i,'sb','db')

				}

			}

		</script>

	</head>

	<body>

		<li>A</li>

		<li>B</li>

		<li>C</li>

		<li>D</li>

		<li>E</li>

	</body>

</html>

A 点击6次，E点击1次

　　

<!DOCTYPE html>

<html>

	<head>

		<meta charset="UTF-8">

		<title></title>

		<script src="js/jquery-3.1.1.js"></script>

		<style type="text/css">

			span{

				color: red;

				margin-left: 25px;

			}

		</style>

		<script type="text/javascript">

			window.onload = function() {

				var json = [{

					"SB": "A",

					"url": "https://www.baidu.com/"

				}, {

					"SB": "B",

					"url": "http://www.cnblogs.com/"

				}, {

					"SB": "C",

					"url": "https://wx.qq.com/"

				}, {

					"SB": "D",

					"url": "https://www.ttpod.com/"

				}, ];

				for(var i = 0; i < json.length; i++) {

					var html = $("<li>" + json[i].SB + "</li>");

					(function(i) {

						html.click(function() {

							$(this).append('<span>' + json[i].url + '</span>');

						})

					})(i);

					$("body").append(html);

				}

			}

		</script>

	</head>

	<body>

	</body>

</html>

　　

依次点击上面的A,B,C,D;

<!DOCTYPE html>

<html>

	<head>

		<meta charset="UTF-8">

		<title></title>

		<script src="js/jquery-3.1.1.js"></script>

		<style type="text/css">

			span {

				color: red;

				margin-left: 25px;

			}

			.red {

				width: 100px;

				height: 100px;

				background: red;

			}

			.green {

				width: 100px;

				height: 100px;

				background: green;

			}

		</style>

		<script type="text/javascript">

			window.onload = function() {

				var json = [{

					"SB": "A",

					"url": "https://www.baidu.com/"

				}, {

					"SB": "B",

					"url": "http://www.cnblogs.com/"

				}, {

					"SB": "C",

					"url": "https://wx.qq.com/"

				}, {

					"SB": "D",

					"url": "https://www.ttpod.com/"

				}, ];

				for(var i = 0; i < json.length; i++) {

					var html = $("<li>" + json[i].SB + "</li>");

					(function(i) {

						html.click(function() {

							$(this).append('<span>' + json[i].url + '</span>');

						})

					})(i);

					$("body").append(html);

				}

			}

			$(function() { //这是第一种写法

				(function(i, j, k) {

					$(".red").click(function() {

						console.log(i++, j++, k++);

					})

				})(1, 2, 3)

			});

			$(function() { //这是第二种写法

				$(".green").click((function(i, j, k) {

					return function() {

						console.log(i++, j++, k++);

					}

				})(10, 11, 12));

			});

		</script>

	</head>

	<body>

		<div class="red"></div>

		<div class="green"></div>

	</body>

</html>

　　

红色的点击5次，绿色的点击5次

一、什么是闭包 ：

有权访问另一个函数作用域内变量的函数都是闭包。

官方”的解释是：闭包是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。
相信很少有人能直接看懂这句话，因为他描述的太学术。其实这句话通俗的来说就是：JavaScript中所有的function都是一个闭包。不过一般来说，嵌套的function所产生的闭包更为强大，也是大部分时候我们所谓的“闭包”。看下面这段代码：

function a() { 
 var i = 0; 
 function b() { alert(++i); } 
 return b;
}
var c = a();
c();

这段代码有两个特点：

1、函数b嵌套在函数a内部；

2、函数a返回函数b。

引用关系如图：

　　这样在执行完var c=a()后，变量c实际上是指向了函数b，再执行c()后就会弹出一个窗口显示i的值(第一次为1)。这段代码其实就创建了一个闭包，为什么？因为函数a外的变量c引用了函数a内的函数b，就是说：

　　当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。

　　让我们说的更透彻一些。所谓“闭包”，就是在构造函数体内定义另外的函数作为目标对象的方法函数，而这个对象的方法函数反过来引用外层函数体中的临时变量。这使得只要目标 对象在生存期内始终能保持其方法，就能间接保持原构造函数体当时用到的临时变量值。尽管最开始的构造函数调用已经结束，临时变量的名称也都消失了，但在目 标对象的方法内却始终能引用到该变量的值，而且该值只能通这种方法来访问。即使再次调用相同的构造函数，但只会生成新对象和方法，新的临时变量只是对应新 的值，和上次那次调用的是各自独立的。

先看一道闭包的题：

<!doctype html>

<html lang="en">

	<head>

		<meta charset="UTF-8" />

		<meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no" />

		<title>Document</title>

		<script type="text/javascript" src="js/jquery-1.12.4.js"></script>

		<style type="text/css">

			.red {

				width: 100px;

				height: 100px;

				background: red;

			}

			.green {

				width: 100px;

				height: 100px;

				background: green;

			}

		</style>

		<script type="text/javascript">

			$(function() {       //闭包的常规用法

				var i = 0;

				function main() {

					return function() {

						console.log("我是：" + i++);

					}

				}

				var sbs = main();

				sbs();

				sbs();

				sbs();

				sbs();

			});

			$(function() {

				$(".red").click((function(a, b, c) {

					return function() {

						console.log(a++, b++, c++);

					}

				})(1, 2, 3));

			});

			$(function() {

				var haha = (function(a, b, c) {

					return function() {

						console.log(a++, b++, c++);

					}

				})(100, 200, 300)

				$(".green").click(haha);

			})

		</script>

	</head>

	<body>

		<div class="red"></div>

		<div class="green"></div>

	</body>

</html>

　　页面渲染：

　　猜一猜：

点击红色的输出什么？

		$(function() {

				$(".red").click((function(a, b, c) {

					return function() {

						console.log(a++, b++, c++);

					}

				})(1, 2, 3));

			});

上面的代码等价于：

	$(function() {

				(function(i, j, k) {

					$(".red").click(function() {

                      console.log(i++,j++,k++);

					})

				})(1, 2, 3)

			})

　　

点击绿色的输出什么？

红色的点三下，绿色的点三下，重复两次：

答案：

<!doctype html>

<html lang="en">

	<head>

		<meta charset="UTF-8" />

		<meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1,maximum-scale=1,user-scalable=no" />

		<title>Document</title>

		<script type="text/javascript" src="js/jquery-1.12.4.js"></script>

		<style type="text/css">

			.red {

				width: 100px;

				height: 100px;

				background: red;

			}

			.green {

				width: 100px;

				height: 100px;

				background: green;

			}

		</style>

		<script type="text/javascript">

			$(function() { //闭包的常规用法

				var i = 0;

				function main() {

					return function() {

						console.log("我是：" + i++);

					}

				}

				var sbs = main();

				sbs();   //0

				sbs();   //1

				sbs();   //2

				sbs();   //3

			});

			$(function() {

				var sb = (function(i, j) {

					return i + j;

				})(2, 3);

				console.log("sb：" + sb);    //5

			})

			$(function() {

				$(".red").click((function(a, b, c) {

					return function() {

						console.log(a++, b++, c++);

					}

				})(1, 2, 3));

			});

			//上面的原理

			$(function() {

				var haha = (function(a, b, c) {

					return function() {

						console.log(a++, b++, c++);

					}

				})(100, 200, 300)

				$(".green").click(haha);

			});

			//上面的为啥会闭包：一般匿名自执行函数里面return函数就是闭包

			//回调函数就是匿名自执行，里面return 就是闭包

			$(function() {

				var main = function() {

					console.log('sb');   //sb,sb,sb,sb....

				}

				var set = setInterval(main, 1000)

			})

		</script>

	</head>

	<body>

		<div class="red"></div>

		<div class="green"></div>

	</body>

</html>

　　

Javascript的匿名函数与自执行

 

函数是JavaScript中最灵活的一种对象，这里只是讲解其匿名函数的用途。匿名函数：就是没有函数名的函数。

函数的定义，大致可分为三种方式：

第一种：这也是最常规的一种

1
2
3
function double(x){   
    return 2 * x;      
}

第二种：这种方法使用了Function构造函数，把参数列表和函数体都作为字符串，很不方便，不建议使用。

1
var double = new Function('x', 'return 2 * x;');

第三种：

1
var double = function(x) { return 2* x; }

注意“=”右边的函数就是一个匿名函数，创造完毕函数后，又将该函数赋给了变量square。

匿名函数的创建

第一种方式：就是上面所讲的定义square函数，这也是最常用的方式之一。

第二种方式：

1
2
3
(function(x, y){  
    alert(x + y);    
})(2, 3);

这里创建了一个匿名函数(在第一个括号内)，第二个括号用于调用该匿名函数，并传入参数。括号是表达式，是表达式就有返回值，所以可以在后面加一对括号让它们执行.

自执行的匿名函数

1. 什么是自执行的匿名函数?
    它是指形如这样的函数: (function {// code})();

2. 疑问
    为什么(function {// code})();可以被执行, 而function {// code}();却会报错?

3. 分析
    (1). 首先, 要清楚两者的区别:
    (function {// code})是表达式, function {// code}是函数声明.
    (2). 其次, js"预编译"的特点:
    js在"预编译"阶段, 会解释函数声明, 但却会忽略表式.
    (3). 当js执行到function() {//code}();时, 由于function() {//code}在"预编译"阶段已经被解释过, js会跳过function(){//code}, 试图去执行();, 故会报错;
    当js执行到(function {// code})();时, 由于(function {// code})是表达式, js会去对它求解得到返回值, 由于返回值是一 个函数, 故而遇到();时, 便会被执行.

另外， 函数转换为表达式的方法并不一定要靠分组操作符()，我们还可以用void操作符，~操作符，!操作符……

如：

1
2
3
!function(){  
  alert("另类的匿名函数自执行");  
}();

匿名函数与闭包

闭包的英文单词是closure，这是JavaScript中非常重要的一部分知识，因为使用闭包可以大大减少我们的代码量，使我们的代码看上去更加清晰等等，总之功能十分强大。

闭包的含义：闭包说白了就是函数的嵌套，内层的函数可以使用外层函数的所有变量，即使外层函数已经执行完毕（这点涉及JavaScript作用域链）。

1
2
3
4
5
6
7
function checkClosure(){ 
    var str = 'rain-man'; 
    setTimeout( 
        function(){ alert(str); } //这是一个匿名函数 
    , 2000); 
} 
checkClosure();

这个例子看上去十分的简单，仔细分析下它的执行过程还是有许多知识点的：checkClosure函数的执行是瞬间的（也许用时只是0.00001毫秒），在checkClosure的函数体内创建了一个变量str，在checkClosure执行完毕之后str并没有被释放，这是因为setTimeout内的匿名函数存在这对str的引用。待到2秒后函数体内的匿名函数被执行完毕,str才被释放。

用闭包来优化代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function forTimeout(x, y){ 
    alert(x + y); 
} 
function delay(x , y  , time){ 
    setTimeout('forTimeout(' +  x + ',' +  y + ')' , time);     
} 
/** 
 * 上面的delay函数十分难以阅读，也不容易编写，但如果使用闭包就可以让代码更加清晰 
 * function delay(x , y , time){ 
 *     setTimeout( 
 *         function(){ 
 *             forTimeout(x , y)  
 *         }           
 *     , time);    
 * } 
 */

匿名函数最大的用途是创建闭包（这是JavaScript语言的特性之一），并且还可以构建命名空间，以减少全局变量的使用。

1
2
3
4
5
6
7
8
var oEvent = {}; 
(function(){  
    var addEvent = function(){ /*代码的实现省略了*/ }; 
    function removeEvent(){} 
     
    oEvent.addEvent = addEvent; 
    oEvent.removeEvent = removeEvent; 
})();

在这段代码中函数addEvent和removeEvent都是局部变量，但我们可以通过全局变量oEvent使用它，这就大大减少了全局变量的使用，增强了网页的安全性。 我们要想使用此段代码：oEvent.addEvent(document.getElementById('box') , 'click' , function(){});

1
2
3
4
5
6
7
8
var rainman = (function(x , y){ 
    return x + y; 
})(2 , 3); 
/** 
 * 也可以写成下面的形式，因为第一个括号只是帮助我们阅读，但是不推荐使用下面这种书写格式。 
 * var rainman = function(x , y){ 
 *    return x + y; 
 * }(2 , 3);

在这里我们创建了一个变量rainman，并通过直接调用匿名函数初始化为5，这种小技巧有时十分实用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var outer = null; 
     
(function(){ 
    var one = 1; 
    function inner (){ 
        one += 1; 
        alert(one); 
    } 
    outer = inner; 
})(); 
     
outer();    //2 
outer();    //3 
outer();    //4

这段代码中的变量one是一个局部变量（因为它被定义在一个函数之内），因此外部是不可以访问的。但是这里我们创建了inner函数，inner函数是可以访问变量one的；又将全局变量outer引用了inner，所以三次调用outer会弹出递增的结果。

注意

1 闭包允许内层函数引用父函数中的变量，但是该变量是最终值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/** 
 * <body> 
 * <ul> 
 *     <li>one</li> 
 *     <li>two</li> 
 *     <li>three</li> 
 *     <li>one</li> 
 * </ul> 
 */
     
var lists = document.getElementsByTagName('li'); 
for(var i = 0 , len = lists.length ; i < len ; i++){ 
    lists[ i ].onmouseover = function(){ 
        alert(i);     
    }; 
}

你会发现当鼠标移过每一个<li>元素时，总是弹出4，而不是我们期待的元素下标。这是为什么呢？注意事项里已经讲了（最终值）。显然这种解释过于简单，当mouseover事件调用监听函数时，首先在匿名函数（ function(){ alert(i); }）内部查找是否定义了 i，结果是没有定义；因此它会向上查找，查找结果是已经定义了，并且i的值是4（循环后的i值）；所以，最终每次弹出的都是4。

解决方法一：

1
2
3
4
5
6
7
8
var lists = document.getElementsByTagName('li'); 
for(var i = 0 , len = lists.length ; i < len ; i++){ 
    (function(index){ 
        lists[ index ].onmouseover = function(){ 
            alert(index);     
        };                     
    })(i); 
}

解决方法二：

1
2
3
4
5
6
7
var lists = document.getElementsByTagName('li'); 
for(var i = 0, len = lists.length; i < len; i++){ 
    lists[ i ].$$index = i;    //通过在Dom元素上绑定$$index属性记录下标 
    lists[ i ].onmouseover = function(){ 
        alert(this.$$index);     
    }; 
}

解决方法三：

1
2
3
4
5
6
7
8
9
function eventListener(list, index){ 
    list.onmouseover = function(){ 
        alert(index); 
    }; 
} 
var lists = document.getElementsByTagName('li'); 
for(var i = 0 , len = lists.length ; i < len ; i++){ 
    eventListener(lists[ i ] , i); 
}

2 内存泄露

使用闭包十分容易造成浏览器的内存泄露，严重情况下会是浏览器挂死.

闭包-无处不在 

在前端编程中，使用闭包是非常常见的，我们经常有意无意，直接或间接用到了闭包。闭包可以使传递数据更加灵活(比如处理一些点击事件)

!function() {      

  var localData = "localData here";    

     document.addEventListener('click',    //处理点击事件时用到了外部局部变量，比如这里的localData      

        function(){              

           console.log(localData);

    });

}();

又比如下面这个例子：（是不是很亲切~~）

!function() {      

  var localData = "localData here";      

  var url = "http://www.baidu.com/";      

  $.ajax({

     url : url,          

     success : function() {              

        // do sth...              

        console.log(localData);

        }

    });

}(); 

再来看一个例子~~这种情况就是我们通常所说的闭包

function outer() {  

  var localVal = 30;    

  return function(){      

    return localVal;    

  }

}

var func = outer();  

func(); // 30

这个例子中调用outer()返回匿名函数function()，这个匿名函数中可以访问outer()的局部变量localVal,在outer()调用结束后，再次调用func()的时候，仍然能访问到outer()的局部变量localVal

闭包的概念

闭包,不同于一般的函数,它允许一个函数在立即词法作用域外调用时,仍可访问非本地变量。 --维基百科

闭包就是能够读取其他函数内部变量的函数。 --阮一峰

由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成"定义在一个函数内部的函数"。

所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁

闭包的用途

这部分转自这篇博文

闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。

function f1(){

　　　　var n=999;

　　　　nAdd=function(){n+=1}

　　　　function f2(){

　　　　　　alert(n);

　　　　}

　　　　return f2;

　　}

　　var result=f1();

　　result(); // 999

　　nAdd();

　　result(); // 1000

在这段代码中，result实际上就是闭包f2函数。它一共运行了两次，第一次的值是999，第二次的值是1000。这证明了，函数f1中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除。

为什么会这样呢？原因就在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收。

这段代码中另一个值得注意的地方，就是"nAdd=function(){n+=1}"这一行，首先在nAdd前面没有使用var关键字，因此nAdd是一个全局变量，而不是局部变量。其次，nAdd的值是一个匿名函数（anonymous function），而这个匿名函数本身也是一个闭包，所以nAdd相当于是一个setter，可以在函数外部对函数内部的局部变量进行操作。

闭包-封装 

(function() {  

   var _userId = 23492;  

   var _typeId = 'item';    

   var export = {};

    

   function converter(userId) {          

     return +userId;

   }

    export.getUserId = function() {        

       return converter(_userId);    

   }

   export.getTypeId = function() {          

      return _typeId;

   }        

   window.export = export;   //通过此方式输出

}());

  export.getUserId(); // 23492

  export.getTypeId();  // item

  export._userId;    // undefined  

  export._typeId;    // undefined      

  export.converter; // undefined

利用闭包的特性能让我们封装一些复杂的函数逻辑，在这个例子中调用export上的方法（getUserId,getTypeId）间接访问函数里私有变量，但是直接调用export._userId是没法拿到_userId的。这也是Node里面常用到特性吧~

常见错误之循环闭包 

下面这个案例，我们添加3个div，值分别为aaa,bbb,ccc，我们想实现的是点击aaa输出1，点击bbb输出2，点击ccc输出3

document.body.innerHTML = "<div id=div1>aaa</div>" + "<div id=div2>bbb</div><div id=div3>ccc</div>";  

for (var i = 1; i < 4; i++) {      

  document.getElementById('div' + i).        

    addEventListener('click', function() {        

    alert(i); // all are 4!

    });  

}

结果点击aaa,bbb还是ccc都是alert(4)~~

产生这样的问题在于这个i的值在初始化完成的时候就已经是4了

要达到我们想要的点击aaa输出1，点击bbb输出2，点击ccc输出3，要用到闭包的技巧,在每次循环的时候，用立即执行的匿名函数把它包装起来，这样子做的话，每次alert(i)的值就取自闭包环境中的i，这个i来自每次循环的赋值i就能输出1，2，3了

document.body.innerHTML = "<div id=div1>aaa</div>" + "<div id=div2>bbb</div>" + "<div id=div3>ccc</div>";  

for (var i = 1; i < 4; i++) {

  !function(i){ //②再用这个参数i，到getElementById()中引用    

    document.getElementById('div' + i).      

      addEventListener('click', function() {        

      alert(i); // 1,2,3

     });  

  }(i);  //①把遍历的1，2，3的值传到匿名函数里面

} 

思考题

如果你能理解下面两段代码的运行结果，应该就算理解闭包的运行机制了。（来自阮老师）这题目总结得真秒~~

代码片段一。

　　var name = "The Window";

　　var object = {

　　　　name : "My Object",

　　　　getNameFunc : function(){

　　　　　　return function(){

　　　　　　　　return this.name;

　　　　　　};

　　　　}

　　};

　　alert(object.getNameFunc()());    //The Window

代码片段二。

　　var name = "The Window";

　　var object = {

　　　　name : "My Object",

　　　　getNameFunc : function(){

　　　　　　var that = this;

　　　　　　return function(){

　　　　　　　　return that.name;

　　　　　　};

　　　　}

　　};

　　alert(object.getNameFunc()());    //My Object

js匿名自执行函数中闭包的高级使用(---------------------------******-----------------------------)的更多相关文章

  1. js匿名自执行函数

    匿名自执行函数:没有方法名的函数闭包:闭包是指有权访问另一个函数作用域变量的函数: 通过一个实例来解释: 从网上找到了一个案例,使用了for循环.匿名自执行函数.setTimeout. 案例1: va ...

  2. js中的匿名函数和匿名自执行函数

    1.匿名函数的常见场景 js中的匿名函数是一种很常见的函数类型,比较常见的场景:   <input type="button" value="点击" id ...

  3. JavaScript匿名自执行函数~function(){}

    原博客:https://blog.csdn.net/yaojxing/article/details/72784774 1.匿名函数的常见场景 js中的匿名函数是一种很常见的函数类型,比较常见的场景: ...

  4. python函数中闭包的概念说明

    函数中闭包的概念说明 闭包: 内层函数对外层函数非全局变量的引用,就叫做闭包 判断闭包方法 ._closure_ : 执行后返回有效信息就是闭包,返回none就不是闭包 举例1: 是闭包 def wr ...

  5. JS 的立即执行函数

    JS 的立即执行函数 本文写于 2019 年 12 月 7 日 其实 ES6 之后有了之后,很多之前的用法都没必要了,立即执行函数就是其一. 今天看到一道面试题: 请「用自己的语言」简述 立即执行函数 ...

  6. addEventListener和attachEvent二者绑定的执行函数中的this不相同【转载】

    yuanwen http://www.jb51.net/article/32511.htm 写 addEventListener 和 attachEvent 区别的博文不少,不过大部分都把重点放置于前 ...

  7. JS函数(自调函数)与闭包【高级函数】

    JavaScript:BOM(浏览器对象)+DOM(文档对象)+ECMAScript javascript面向对象: * 概述: * 发展: * 互联网发展对浏览器页面性能或效果要求越来越高,HTML ...

  8. Javascript函数的基本概念+匿名立即执行函数

    函数声明.函数表达式.匿名函数 函数声明:function fnName () {…};使用function关键字声明一个函数,再指定一个函数名,叫函数声明. 函数表达式 var fnName = f ...

  9. setTimeout中所执行函数中的this，永远指向window

    注意是要延迟执行的函数中的this哦!! //片段一 setTimeout("alert(this)", 1); // [object Window] //片段二 var obj ...

随机推荐

  1. LeetCode 50 Pow(x, n) （实现幂运算）

    题目链接:https://leetcode.com/problems/powx-n/?tab=Description   Problem:实现幂运算即 pow(x,n)   设形式为pow(x,n)  ...

  2. mysql客户端工具

    MySQL 数据库不仅提供了数据库的服务器端应用程序,同时还提供了大量的客户端工具程序,如 mysql,mysqladmin,mysqldump 等等,都是大家所熟悉的.虽然有些人对这些工具的功能都已 ...

  3. C语言assert()函数用法总结

    assert宏的原型定义在<assert.h>中,其作用是如果它的条件返回错误,则终止程序执行,原型定义: #include <assert.h> void assert( i ...

  4. 【咸鱼教程】Egret实现摇一摇功能

    教程目录一 实现原理二 代码三 Demo下载 一 实现原理监听设备旋转角度的变化,来判断用户是否摇动手机. 参考:智能手机里陀螺仪和重力感应有何区别?HTML5实现摇一摇的功能Egret官方陀螺仪教程 ...

  5. cadence upf低功耗流程的仿真验证

    本文是记录项目过程中遇到的奇巧淫技,如有遗漏或者不足,请大家改正和补充,谢谢. 随着深亚微米技术的普及与发展,leakage功耗在整个功耗中的比重越来越大,比如45nm下,已经占到了60%以上,所以低 ...

  6. redis集群节点宕机

    redis集群是有很多个redis一起工作,那么就需要这个集群不是那么容易挂掉,所以呢,理论上就应该给集群中的每个节点至少一个备用的redis服务.这个备用的redis称为从节点(slave). 1. ...

  7. 51nod 1042数字0-9的数量

    1042 数字0-9的数量  基准时间限制:1 秒 空间限制:131072 KB 分值: 10 难度:2级算法题  收藏  关注 给出一段区间a-b,统计这个区间内0-9出现的次数. 比如 10-19 ...

  8. Linux中脚本

    编辑脚本要注意开头 和 修改脚本的权限 1.  开头 #!/bin/bash 如查看/etc路径下的文件,可以编辑 2.  修改权限 chmod 775 脚本文件.sh 如创建一个脚本(test.sh ...

  9. 使用IntelliJ IDEA进行Python远程调试的需求（未完）

    使用IntelliJ IDEA进行Python远程调试的需求(未完) 在研究深度学习Machlearning时,有时候需要借助ubuntu搭建的tensorflow环境,另外也有越来越多的运算程序只能 ...

  10. Oracle体系结构之OFM管理

    OMF:oracle management files 作用:不用指定文件的路径大小名字 OMF管理数据文件:db_create_file_dest 传统方式:SQL>create tables ...