我正在使用 Yup.js 来验证一些表单字段。

我有两个整数字段，Year Built& Year Renovated。

Year Built是必填字段，Year Renovated不是。

翻新年份可以留空，但是如果有一个值，它应该大于建造年份（因为翻新肯定是在建造日期之后发生的）。

我相信我需要使用 yupref()和 yup 的when()功能。我尝试了以下方法：

让 currentYear = new Date().getFullYear();

yup.object().shape({
  yearBuilt     : yup.number().integer().min(1700).max(currentYear+1).required(),
  yearRenovated : yup.number().integer().when(
                    '$yearRenovated', (yearRenovated, schema)=>{
                        return yearRenovated > 0 ? 
                            schema.min(yup.ref('yearBuilt')).max(currentYear+1) :
                            schema.transform(emptyStringToNull).nullable()
                    }
                )
})

* 转换函数，emptyStringToNull简单地检查是否value === ''，如果是则返回 null。

以上确实允许空值，以及正确检查整数。但是它没有正确评估yearRenovated > yearBuilt. 如何正确检查 ifyearRenovated不为空，是否大于yearBuilt？

非常感谢大家的帮助。

我什至不确定该问题的标题是什么-我不确定到底出了什么问题。

我正在编写一个简单地遍历二叉树的函数。假设我们有一棵简单的树，例如：

testTree = { 
  data: 5,
  left: { 
    data: 10, 
    left: undefined, 
    right: undefined 
  },
  right: { 
    data: 2, 
    left: undefined, 
    right: undefined 
  } 
}

我们正在尝试从最左边的路径开始从中收集数据。这是向左搜索功能：

function searchLeft(node, path){
  if(typeof node.left == 'undefined'){
    console.log(path);
    return path;
  }
  node = JSON.parse(JSON.stringify(node.left));
  path.push(node.data);
  searchLeft(node,path);
}

当我运行它时，内部console.log（path）显示正确的值：

[10]

但是如果我

console.log(searchLeft(testTree,[]));

我懂了

未定义

为什么函数不能正确返回[10]？

谢谢！

语境

我正在研究 PostgreSQL 的lateral连接，特别是在 group by/limit 上执行连接。

当我查找单个记录时，该查询工作得非常好，但当我们查询多个记录时，性能很快就会下降。这是有道理的，因为我们有多个子查询运行单独的收集、过滤聚合、排序。问题是，我们应该考虑什么 Postgres 策略，或者我们如何重构下面的查询以使其在规模上具有性能？

询问

我们有三个主表，其中两个表之间有一个连接表：

|经理| >- |商店| >- |商店_产品| -< 产品

我们拥有给定商店记录的所有历史经理，并且我们拥有商店的完整产品目录（产品可能由多个商店销售）。

目标：给定一个商店 ID，查询最近的经理和最近销售的产品。

这是从商店到经理和产品的内部联接。Manager & Product 必须按日期 desc 排序并限制为 1（至少我相信这是获取最新日期的方法）。

SELECT 
    store.id as store_id,
    manager.id as manager_id,
    *
FROM 
    Stores as store,
    LATERAL (
        SELECT 
            * 
        FROM 
            Products as product 
        INNER JOIN Stores_Products store_product on store_product.product_id = product.id
        WHERE 
            store_product.store_id = store.id
        ORDER BY 
            store.date desc
        LIMIT 1
    ) p,
    LATERAL (
        SELECT 
            * …

我试图对深度强化学习有一个直观的理解。在深度 Q 网络（DQN）中，我们将所有动作/环境/奖励存储在内存数组中，并在剧集结束时通过我们的神经网络“重播”它们。这是有道理的，因为我们正在尝试构建我们的奖励矩阵，看看我们的情节是否以奖励结束，然后通过我们的矩阵缩减奖励。

我认为导致奖励状态的动作序列是需要捕获的重要内容 - 这个动作序列（而不是独立的动作）是导致我们进入奖励状态的原因。

在Mnih 的 Atari-DQN 论文和许多教程中，我们看到了从内存阵列中随机采样和训练的实践。所以如果我们有这样的记忆：

（动作a，状态1）-->（动作b，状态2）-->（动作c，状态3）-->（动作d，状态4）-->奖励！

我们可以训练一小批：

[（动作c状态3），（动作b，状态2），奖励！]

给出的理由是：

其次，由于样本之间的相关性很强，直接从连续样本中学习效率很低；随机化样本会破坏这些相关性，从而减少更新的方差。

或者来自这个pytorch 教程：

通过随机采样，构建批次的转换是去相关的。事实证明，这极大地稳定并改进了 DQN 训练过程。

我的直觉告诉我，序列是强化学习中最重要的。大多数剧集都有延迟奖励，因此大多数行动/状态没有奖励（并且没有“强化”）。将部分奖励带到这些先前状态的唯一方法是追溯地将奖励分解到整个序列中（通过奖励 + 奖励 *learning_rate(future_reward)的 Q 算法中的 future_reward ）

内存库的随机采样打破了我们的序列，当您尝试回填 Q（奖励）矩阵时，这有什么帮助？

也许这更类似于马尔可夫模型，每个状态都应该被认为是独立的？我的直觉哪里出了问题？

谢谢你！