闭包的例子，不理解！

这应该是你想要的结果把
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>无标题文档</title>
</head>
<script type="text/javascript">
function buildList(list){
        var result = [];
var dd = "";
        for(var i = 0;i < list.length;i++)
        {
            var itemd = 'item' + list[i];

            var p = function()
            {
                alert(itemd + ' : ' + list[i]);
            };
            result.push(p());

        }

        return result;
    }

    function testList(){
        var fnlist = buildList([1,2,3]);

        for(var j = 0;j < fnlist.length; j++)
        {
            fnlist[j]();
        }

    }
testList();
</script>
</body>
</html>

二楼的这样写好理解，我对（）（）两个括号的很头痛。呵呵。所以我感觉这样写好理解<script type="text/javascript">

    function buildList(list){
        var result = [];
        for(var i = 0;i < list.length;i++)
        {
            var item = 'item' + list[i];

            //var p = function()
            //{
                alert(item + ' : ' + list[i]);//注意变量的作用域，如果放到函数里i是未定义的所以为undefiend
            //};
           // result.push(p);
        }
        return result;
    }
    var sdd = function testList(){
        var fnlist = buildList([1,2,3]);
        for(var j = 0;j < fnlist.length; j++)//length为3调用buildList
        {
            fnlist[j]();
        }
    };
/*
    (function testList(){
        var fnlist = buildList([1,2,3]);
        for(var j = 0;j < fnlist.length; j++)//length为3调用buildList
        {
            fnlist[j]();
        }
    })()
*/
sdd();
</script>

i是未定义的? i等于3 下标越界.一楼说得有点道理 list[i]怎么解释

呵呵，我晕 3星说的就有道理了？？？？
  <script type="text/javascript">
    function buildList(list){
        var result = [];
        alert(list.length)
        for(var i = 0;i < list.length;i++)
        {
            var item = 'item' + list[i];

            var p = function()
            {
alert("list[i]："+list[i]);//你看打印的是什么？你i定义在for里在函数里取不到
                alert(item + ' : ' + list[i]);
            };
            result.push(p);
        }
        return result;
    }

    (function testList(){
        var fnlist = buildList([1,2,3]);
        alert(fnlist.length)
        for(var j = 0;j < fnlist.length; j++)//length为3调用buildList
        {
            fnlist[j]();
        }
    } )()
    </script>

因为i=3 所以list[i] 为undefined 长度为3

这里闭包的大抵意思是那个function的实例，其实在那个上下文环境下i为3，list[3]是越界，你不妨试一下改成list[i-1]，应该是3

修正一下，我们知道变量声明都是只分配一次内存地址。function buildList(list){
        var result = [];
        for(var i = 0;i < list.length;i++) //最后一次判断i已经是3了
        {
            var item = 'item' + list[i]; //这里分配一次内存地址，保存变量'item',list[i]的内存地址,每次赋值都重新指向，在第三次赋值时，item指向'item3';
            var p = function()
            {
                alert(item + ' : ' + list[i]); //这里面三个匿名function也都保存了item,list和i的内存地址
            };
              result.push(p);
        }
        return result;
    }

    function testList(){
        var fnlist = buildList([1,2,3]);
        for(var j = 0;j < fnlist.length; j++)
        {
            fnlist[j]();    //这里执行打印的都是i=3的情况,且item指向'item3'
        }
    }

这种代码很令人费解，方法的执行期并不在创建的 for 循环中，这时想取当时的值，有点跨时空的味道，取变量变得扑朔迷离。
实在不明白什么场合下需要写这么费解的代码。完全可以改一改的。

5楼的说法感觉有些问题，js中根本没有语句作用域，因此在for循环中声明的变量与在开头声明的密友任何区别
，我认为造成这一现象的原因是：闭包中存储的变量是引用类型的指向原始数据，所以它的状态是原始数据的最新状态，通过下面的程序可以实验出来,必包中存储了list和i,之后list和i的值放生了变化结果最终显示的是
list和i的最终值，可见必包中存储的是对原始值得引用而不是当时的状态
function buildList(list){
        var result = [];
        for(var i = 0;i < list.length;i++)
        {
            var item = 'item' + list[i];

            var p = function()
            {
                alert(i);
                alert(item + ' : ' + list[i]);
            };
            result.push(p);
        }
        list.push("a");
        list.push("b");
        list.push("c");
        i=5;
        return result;
    }

    function testList(){
        var fnlist = buildList([1,2,3]);
        for(var j = 0;j < fnlist.length; j++)
        {
            fnlist[j]();
        }
    }
    testList();

那个函数感觉还是不能反映闭包的特点，下面这个感觉更好些
var a="abc";
function f1(){
    return function(){
        alert(a);
    };
}
var f2=f1();
f2();
a="bcd";
f2();

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
    <title>无标题页</title>
</head>
<body>
<script>
    function buildList(list){
        var result = [];
        for(var i = 0;i < list.length;i++)
        {
            var item = 'item' + list[i];

            var p =(function(x){alert(x)})(item);

            result.push(p);
        }
        return result;
    }

    function testList(){
        var fnlist = buildList([1,2,3]);
        for(var j = 0;j < fnlist.length; j++)
        {
            fnlist[j]();
        }
    }
    testList()
</script>
</body>
</html>不知道怎么样直接把函数给初始化了
不过有点问题朋友们帮我看看
他说24行有问题

function 的 scope是在其申明的时候决定的，这段代码调用的时候，i已经为3了，所以一直执行的是alert(item + ' : ' + list[3]);已经越界了，所以value是undefined

测试一下下边的代码。。
大概是这个意思  function buildList(list){
        var result = [];
        for(var i = 0;i < list.length;i++)
        {
            var item = 'item' + list[i];

            var p = function(nn)
            {
                alert(item + ' : ' + list[nn]);
            };
            result.push(p);
        }
        return result;
    }

    function testList(){
        var fnlist = buildList([1,2,3]);
        for(var j = 0;j < fnlist.length; j++)
        {
            fnlist[j](j);
        }
    }
    testList();

调试易

闭包的例子，不理解！

解决方案 »