节点程序员通常使用这样的范例:

var callback = function(err, data) {
    if (err) { /* do something if there was an error */ }

    /* other logic here */

};

为什么不简化函数只接受一个参数,即错误或响应？

var callback = function(data) {
    if (isError(data)) { /* do something if there was an error */ }

    /* other logic here */

};

似乎更简单.我能看到的唯一缺点是函数不能将错误作为实际预期的返回值返回 - 但我相信这是一个非常微不足道的用例.

为什么错误优先模式被认为是标准的？

编辑:执行isError:

var isError = function(obj) {
    try { return obj instanceof Error; } catch(e) {}
    return false;
};

另一种编辑:我的备用方法是否有可能比节点约定更方便,因为只接受一个参数的回调更可能是非回调用例的可重用方法？

背景

我们正在使用Python3.4/Django1.8.4,我们正在目睹一个与我们的user模型有关的奇怪现象,特别timezone是这个模型的领域.

我们经常在进行迁移时,新的迁移文件将包含一个更改所述时区字段的操作,但操作中包含的所有属性都已设置为迁移尝试分配的相同值!

有3个这样的领域,它们是:

1)default- 值为"UTC"

2)max_length- 值为30和

3)choices- 包含时区名称/值的非常长的元组数组.

看起来像:

choices=[('Africa/Abidjan', 'Africa/Abidjan'), ('Africa/Accra', 'Africa/Accra'), ('Africa/Addis_Ababa', 'Africa/Addis_Ababa'), ... ]

迁移操作总是希望将timezone字段的这3个属性设置为完全相同的3个对应值,即使它们已经设置为这样的值!它本质上是一种冗余的,无用的操作.

有时当我们运行时makemigrations,应用程序将不会发生任何变化,除了这个愚蠢的领域!

问题

1)为什么会这样？

2)我们如何防止这种情况？令人讨厌的是,应用程序认为迁移是不必要的.

额外信息

虽然字段的相同3个属性始终设置为完全相同的值,但它们在操作中出现的顺序似乎是不确定的(可能是因为django使用无序dict实例来存储用于生成迁移文件的数据).

choices正如我们在模型中定义的那样,该字段是在最初运行应用程序时动态生成的.(煮沸的)代码如下所示:

class MyUser(models.Model):
    f_name = models.CharField(max_length=32398) # Gotta accomodate those crazy south-eastern names haha
    l_name = models.CharField(max_length=94823)

    # ...
    # more fields and stuff etc.
    # ...

    time_zone = models.CharField(default="UTC", choices=TIMEZONE_CHOICES, max_length=30) …

我正在尝试使用带有 babel 的异步生成器的简洁语法（我被节点 8 卡住了），我想知道如何将事件发射器干净地转换为异步生成器

到目前为止我得到的看起来像这样

    const { EventEmitter } = require('events')

    // defer fonction for resolving promises out of scope
    const Defer = () => {
      let resolve
      let reject
      let promise = new Promise((a, b) => {
        resolve = a
        reject = b
      })
      return {
        promise,
        reject,
        resolve
      }
    }


    // my iterator function
    function readEvents(emitter, channel) {
      const buffer = [Defer()]
      let subId = 0

      emitter.on(channel, x => {
        const promise = buffer[subId]
        subId++
        buffer.push(Defer())
        promise.resolve(x) …

背景

假设我有一个带有参数的url模式,它会将我链接到django中的视图:

url(
    r'^things/(?P<thing_name>\w+)/features/(?P<feature_name>\w+)$',
    views.thingFeature,
    name='thing_feature'
),

让我们说我有一个thing和一个feature:

thing = Thing.objects.get(.....)
feature = thing.feature_set.first()

t_name = thing.name
f_name = feature.name

现在Django给了我很棒的能力来获取一个网址,它将我带到一个专门针对特定事物的特定功能的页面.我可以这样做:

from django.core.urlresolvers import reverse
url = reverse('thing_feature', thing_name=t_name, feature_name=f_name)
# url == '/things/thing2/features/left-arm'

题

现在我偶然发现了一个我需要专门解决的问题.我不是在寻找解决方法 - 我正在寻找解决以下问题:

给定一个url name,如何获取kwarg反转该url所需的参数名称列表？

我正在寻找这个功能get_kwarg_names_for_url.它的行为如下:

url_kwarg_names = get_kwarg_names_for_url('thing_feature')
# url_kwarg_names == ['thing_name', 'feature_name']

url_kwarg_names现在是我需要提供给Django reverse函数的每个关键字的列表,以便反转命名的url "thing_feature".

任何帮助表示赞赏!

解

根据knbk的回答,我能够提出以下解决方案:

def get_kwarg_names_for_url(url_name):
    resolver = get_resolver(get_urlconf())
    reverse_data = resolver.reverse_dict[url_name]

    pattern_list = reverse_data[0]

    '''
    Need …

我正在寻找向填充有值的预先存在的表添加一个新列。新列将是NOT NULL，因此对于每个预先存在的行，它将需要一个值。

我正在寻找该列上的初始值，以在列创建时根据表中的其他值计算，并且仅在列创建时进行计算。

我有一个非常具体的用例，所以我不是在寻找解决方法。我将给出一个非常简单的例子来说明我正在寻找的内容：

说我有这个数据：

CREATE TABLE numbers (
  value1 INTEGER NOT NULL,
  value2 INTEGER NOT NULL
);

INSERT INTO numbers(value1, value2) VALUES (10, 20), (2, 5);

我希望value3在numbers表上创建一个新列，该列在创建时始终等于其对应列value1和value2列的总和。

例如：

ALTER TABLE numbers ADD COLUMN value3 INTEGER;

/* ... some more logic which calculates the initial values ... */

ALTER TABLE numbers
ALTER COLUMN value3 SET NOT NULL;

完成后，我想要以下数据：

-- The 3rd value will be the sum of the …

我最近开始更详细地探索 Javascript 以及它如何在浏览器中执行。具体来说就是setTimeout函数。

我的理解是调用setTimeout(foo,x) 将传递一个句柄到 foo 以在 x 毫秒后执行。这个时间安排的可靠性如何？显然，如果另一个长时间运行的脚本在 x 毫秒后仍在执行，那么浏览器将无法调用 foo，但我可以绝对确定该脚本setTimeout(foo,101)将始终在 x 毫秒后执行setTimeout(foo,100)吗？

Ηello!我希望这是一个可以接受的问题.

通过一些用于信号处理的代码,我发现了一个奇怪的功能:

let kInd = (k1, pow) => {

  let k2 = 0;
  let k3 = 0;

  for (let i = 0; i < pow; i++) {
    k3 = k1 >> 1;
    k2 = 2 * (k2 - k3) + k1;
    k1 = k3;
  }

  return k2;

};

在傅立叶变换计算结束时调用此函数以交换实数+虚数对数组中的索引:

let fft = samples => {

  let pow = Math.log2(samples.length); // `samples.length` is expected to be 2^int

  // ... a bunch of code to generate `rBuff` and `iBuff` arrays representing 
  // …

给定一个较大的正整数“权重”数组（例如[ 2145, 8371, 125, 10565, ... ]）和一个正整数“权重限制”例如15000，我要使用以下条件将权重划分为一个或多个较小的数组：

1. 我想最小化分区数。
2. 没有一个分区的总和不能超过重量限制。（请注意，单个重量不会超过此限制。）

我怀疑这个问题的复杂程度很高。作为答案，我感兴趣：

1. 最佳解决方案
2. 并非最佳选择，但运行速度很快（近似）的解决方案

当前的非最佳方法：（基本贪婪算法； JavaScript）

function minimizePartitions(weights, weightLimit) {
  let currentPartition = [];
  let currentSum = 0;
  let partitions = [ currentPartition ];
  
  for (let weight of weights) {
    if (currentSum + weight > weightLimit) {
      currentPartition = [];
      currentSum = 0;
      partitions.push(currentPartition);
    }
    
    currentPartition.push(weight);
    currentSum += weight;
  }
  
  return partitions;
}

let weights = [3242, 987, 1222, 7299, 400, 10542, 10678, 513, 3977];
console.log(minimizePartitions(weights, 15000));

我刚刚升级到 AWS SDK V3，我不知道如何使用它配置 retryDelayOptions 和 customBackoff。我在AWS自己的API参考或网上找不到任何示例代码。这就是我之前所做的：

retryDelayOptions: { customBackoff: (retryCount) => 2 ** (retryCount * 100) },
maxRetries: 2

我将上述内容作为选项传递给客户端构造函数。V3 的重试似乎发生了很大变化，如果没有任何示例，我无法理解 API。任何帮助深表感谢

问候，迪帕克

这是重复的吗？

我已经检查了,我不这么认为.关于异步mysql有很多问题,但我对一个特定的问题很感兴趣:

建立

在这种情况下我正在使用php和mysql.

假设我有这样的mysqli连接:

$link = new mysqli('localhost', 'root', 'password', 'A_Database');

我已经安装了mysqlnd来使用'MYSQL_ASYNC'参数执行异步mysql查询:

$link->query("INSERT INTO `A_Table` VALUES('stuff!')", MYSQLI_ASYNC);

目标

我只是想插入一条记录,我也不需要找回它,直到遥远的未来,所以我不担心需要多长时间异步查询完成了,我也不需要进行一些最后的当我知道查询完成时的操作.一旦我超出了插入查询发生的代码部分,我确实需要执行其他不相关的mysql查询.

问题

执行这样的查询将阻止脚本中的其他查询出现不同步错误.为了解决这个问题,我必须在每次异步查询后添加类似下面的代码:

$links = $errors = $reject = array($link);
if ($link->poll($links, $errors, $reject, 1)) {
    foreach ($links as $resultLink) {
        if ($result = $resultLink->reap_async_query()) {
            if (is_object($result)) {
                $result->free();
            }
        }
    }
}

这有效地阻止了不同步错误,我的代码工作正常.
但有两件事情仍困扰着我:

1)我不想打扰这个,因为我只是执行插入查询,当我知道插入完成时,我不关心我的代码中有一些响应.

2)轮询代码在我的服务器上运行得非常慢; 远比执行常规查询慢,并同步获取结果.

概括

我想运行带有两个要求的插入查询; 查询是非阻塞的(异步),我以后仍然可以执行其他mysql查询.我只想插入查询并"忘记它",然后继续我的代码.

有关最佳方法的建议是什么？