相关疑难解决方法(0)

嘿,我在这里遇到小问题.

问题:如何为函数创建唯一变量,因此当多次调用时,变量将保持它们应该的(不交换)

请记住,我必须保持异步,因为循环将很大而不运行它async会很难达到性能

我有一个在画布上绘制项目的功能.然后我在for循环中运行这个函数,根据数组中的一些数据绘制一些画布.

如此简化的版本:

function renderCanvas(canvas, dID) {
    var mName, bName, sName, tName;
    this.layerCounter = mainData[dID]['layerCount'];
    console.debug(designID + " has " + layerCounter + " layers");
    /* that gives 2 layers for first item and 3 for second)*/

    tctx2.clearRect(0, 0, tc2.width, tc2.height);
    var imgPath = sName;
    imgObj = new Image();
    imgObj.src = "img/" + imgPath;
    imgObj.onload = function () {

        tctx2.drawImage(imgObj, 0, 0, w, h, 0, 0, dw, dh);
        layerCounter--;
        console.debug(designID + " has " + layerCounter + " …

当执行以下代码时，我在第一个循环完成时得到了我所期望的结果（从 0 到 9 的序列）。但是当第二个循环完成时，结果不是我所期望的（我期望与第一个循环中的结果相同，但它只打印“10”）：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)

        go func(j int) {
            defer wg.Done()

            fmt.Println(j)
        }(i)
    }

    wg.Wait()

    fmt.Println("done first")

    for i := 0; i < 10; i++ {
        wg.Add(1)

        go func() {
            defer wg.Done()

            fmt.Println(i)
        }()
    }

    wg.Wait()

    fmt.Println("done second")
}

输出：

0
1
2
3
4
5
6
7
8
9
done first
10
10
10
10
10 …

我需要创建一个函数生成器,迭代无限序列,如斐波那契序列.它应该在调用时返回序列中的下一个值.我得到了一个函数原型:

function genfib() {
  return function fib() {
  }
}

它应该像这样使用:

var fib = genfib();
fib(); // -> returns 0
fib(); // -> returns 1
fib(); // -> returns 1
fib(); // -> returns 2

我很困惑每次打电话时都在执行什么fib().我试着做点什么

function genfib() {
  var count = 1;
  if (count === 1) {
    count++;
    yield 0;
  }
  else if (count === 2) {
    count++;
    yield 1;
  }
  var a = 0;
  var b = 1;
  return function fib() {
    while(1) {
      count = …

我看到这么多功能:

form.prototype.smokerDisabled = function(){
  return function(age) {
    return age>=15 ? 'disabled="disabled"' : '';
  };
};

将实际代码保存在另一个函数中并使其恢复的用途是什么.相反它本来写的:

form.prototype.smokerDisabled = function(age){
  return age>=15 ? 'disabled="disabled"' : '';
};

请告诉我第一种方法的区别和用法.谢谢.

我在谷歌的帮助下做了一个关闭功能.该功能可以正常工作.但是,我不确定它是如何工作的.

function ShowQuestion(i) {
  console.log(i); // here 1 to 10 are logged immediately.
  return function() {
    console.log(i); // here the number are only logged when I mouse over on any li.
  }
}

setTimeout(function() {    
  for (i = 0; i < document.getElementById('Previousli').getElementsByTagName('ul')[0].children.length; i++) {
    document.getElementById('Previousli').getElementsByTagName('ul')[0].children[i].onmouseover = ShowQuestion(i);
  }    
}, 10000);

首先,我想知道为什么第一个console.log(i)在10秒超时后立即记录1到10,但是第二个console.log(i)只有当我鼠标悬停在li上时才记录"index" ？

我这里有一些代码：http : //bitbucket.org/natim/lo53_tp1/src/tip/part3/camions/medias/js/tracking.js

我用来绘制一些关于卡车方向的信息。

问题来自在 for 循环中定义的函数，如下所示：

...

for(i = 0; i < nb_trucks; i++)
{
    ...

    contentString = '<div id="content">'+ trucks[i]['name'] + '</div>';

    current_window = new google.maps.InfoWindow({
        content: contentString
    });            

    infosWindow.push(current_window);

    current_marker = new google.maps.Marker({
        map: map,
        position: new google.maps.LatLng(trucks[i]['end']['lat'], trucks[i]['end']['lon']),
        draggable: false,
        title: trucks[i]['name']
    });
    markers.push(current_marker);

    google.maps.event.addListener(current_marker, 'click', function() {
        current_window.open(map, current_marker);
    });
}

在这段代码中，您可以看到最后一个块

    google.maps.event.addListener(current_marker, 'click', function() {
        current_window.open(map, current_marker);
    });

我的问题是 addListener 参数中的 current_marker 与函数内部的不同。

函数内的 current_window 和 current_marker 在每次循环时都会被覆盖。

我怎样才能做对？

谢谢

在下面的代码中,为什么返回列出了两个方法(增量和打印)？为什么你不能使用return counter++？还有,返回一个是什么意思console.log？

function create() {
  var counter = 0;
  return {
    increment: function() {
      counter++;
    },
    print: function() {
      console.log(counter);
    }
  }
}

谢谢!

介绍:

我知道"这段代码是如何工作的？" 类型问题是不受欢迎的,我会看起来像读"太阳报"那样聪明地问这样一个问题,但是......这里就是这样.

我试图理解JavaScript中的原型,现在这不是问题,我理解原型结构的基础知识,你编写一个函数,然后通过使用原型扩展该函数的参数.

(是的,在我得到火焰之前,我已经通过社区维基阅读了关于这个特定主题的帖子,所以不要只是告诉他们,以及我已经通过John Reisg关于这个主题的说明也帮助了很多.(最令人困惑的方面是理解this及其DOM引用方法.))

但事情就是这样:

我为SO API写了一个简单的API解析器,它可以提取各种数据,我自己和我第一次冒险进入JS我在SO JS Chatroom中发布了一个链接,看看他们是否认为这可以更有效地完成,并且@ IvoWetzel建议我更改为原型包装器来创建API URL查询,所以我调查了它,并根据我的帖子发布了这个示例代码:

//API Handling for asynchronicity
function API(site, key, ...) {
    this.site = site;
    this.key = key;
    this.schedule = new Scheduler(this);
}

API.prototype = {
    lookup: function(resource, callback) {
        // build the url etc here
        this.request(url, callback);
    },

    request: function(url, callback) {
        // build a request here and send it
        request.on('finished', function() {
            callback();
        });
    }
};

function Scheduler(api) {
    return function(method, options, interval) {
        var id …

我一直在更具体地阅读编程的闭包概念,尤其是与Javascript有关的概念.我还没有完全理解它与我多年来一直在写的Javascript代码有什么不同.我也理解递归的概念,但我想知道,闭包和递归是如何相似的？我是否正确理解递归本身就是一种闭包？

关闭:

function init() {
    var name = "Stack Overflow";
    function displayName() {
        alert(name);
    }
    displayName();
}
init();

递归:

function factorial(num) {
    if(num < 0)
        return -1;

    else if(num == 0)
        return 1;

    else
        return (num * factorial(num - 1));
}

alert(factorial(8));

我想我已经开始明白闭包只不过是在函数中有一个函数,内部函数可以通过作用域访问外部函数.可能会有递归闭包吗？我的意思是,虽然我的递归示例也不是关闭的例子,但它至少会发生吗？我试图理解递归和闭包是如何相似,不同,或者它们是否可以被所有人比较.有没有例子可以描述这个？

我的函数运行正常但我希望它重复运行:

$('button').click( function(){

    setInterval(magicWords(7,3), 1000); 

});

我尝试在函数本身中硬连接参数并运行参数 -但是它仍然是一个不行......？