标签: let

在RSPEC中，Let的行为是在单个示例中进行记忆（它阻止），但是在某些情况下，就时序而言，这可能会导致一些潜在的讨厌的副作用。

我注意到，如果您设法尝试创建任何被认为昂贵的东西，例如大型模拟，则将在调用它的每个示例中重复整个对象的创建过程。

解决此问题的第一步是将模拟数据缩小到一定大小，这将大部分运行时间从〜30秒减少到〜.08秒。给出的结果是，通过将一个被调用了3次且没有任何形式突变的let变量传递给实例，速度可以提高得更多（在这种情况下，从-0.02到-0.04）。

通常，可以认为延迟评估是可取的，并且在某些情况下，这样做是安全的代价。在大型测试套件（3000多个测试）的情况下，甚至0.01-0.02秒的差异通常足以导致20-30秒的膨胀。当然，在某些情况下，这是任意编号，但是您可以看到为什么这是不希望的，并产生复合问题。

我的问题是：

• 在什么情况下不再可行？
• 有什么办法可以在块上下文而不是示例上下文中扩展其记忆吗？...或者这是一个可怕的想法？
• 是否有有效的方法来生成大量的模拟数据，而这些模拟数据的加载时间可能不会超过7秒？我看到过模糊的提及《工厂女郎》，但在该笔记上有足够的争论，我不知道在当前情况下该怎么想。

感谢您的时间！

请考虑以下有效的Haskell代码

module Main where

main :: IO ()
main = do
  let x = f
  print x

f :: Maybe (Int, Int)
f =
  Just 3 >>= (\a ->
    Just 5 >>= (\b ->
      return (a, b)))

其中函数f可以用这样的do-notation等效地重写

f :: Maybe (Int, Int)
f = do
  a <- Just 3
  b <- Just 5
  return (a, b)

什么让我烦恼的是,当我把f内联的内容放进去的时候,这个符号是行不通的.以下代码甚至不解析:

main :: IO ()
main = do
  let x = do
    a <- Just 3
    b <- Just …

应该使用什么来在 Swift 中创建类的实例，为什么？

请解释在 Swift 中创建实例过程中 let 和 var 的用法

以下是代码：-

class ConstantTest{
    let constant: String
    init(constant: String) {
        self.constant = constant
    }
    func printConstant() {
        print(constant)
    }
}

let constanttest = ConstantTest(constant: "Hello")
constanttest.printConstant()

var test = ConstantTest(constant: "Hie")
test.printConstant()

我正在尝试理解F#中的异步工作流程,但我发现有一部分我真的不明白,希望有人可以帮助我.

以下代码工作正常:

let asynWorkflow = async{
    let! result = Stream.TryOpenAsync(partition) |> Async.AwaitTask 
    return result
    } 

let stream = Async.RunSynchronously asynWorkflow
             |> fun openResult -> if openResult.Found then openResult.Stream else Stream(partition)

我定义了一个异步工作流,其中TryOpenAsync返回一个Task类型.我用Async.AwaitTask将它转换为Async.(副任务:"等待"任务？它不等待它只是转换它,是吗？我认为它与Task.Wait或await关键字无关).让我"等待"它!并返回它.要启动工作流,我使用RunSynchronously,它应该启动工作流并返回结果(绑定它).在结果上,我检查是否找不到流.

但现在是我的第一个问题.为什么我必须在另一个异步计算中包装TryOpenAsync调用并让它!("等待")吗？例如,以下代码不起作用:

let asynWorkflow =  Stream.TryOpenAsync(partition) |> Async.AwaitTask  

let stream = Async.RunSynchronously asynWorkflow
             |> fun openResult -> if openResult.Found then openResult.Stream else Stream(partition)

我认为AwaitTask使它成为Async和RunSynchronously应该启动它.然后使用结果.我错过了什么？

我的第二个问题是为什么有"Async.Let!" 功能可用？也许是因为它不起作用或更好,为什么它不适用于以下代码？

let ``let!`` task = async{
    let! result = task |> Async.AwaitTask 
   return result
   } 

let stream = Async.RunSynchronously ( ``let!`` (Stream.TryOpenAsync(partition))  )
         |> fun …

是否可以let取消定义一个定义的变量，以便我可以重新定义它？使用var，我可以一遍又一遍地重新定义同一个变量。使用let，再次尝试定义变量时遇到错误。

（你可能想知道我为什么要这样做，原因是我经常从我的浏览器控制台运行和重新运行小的单行和多行脚本，从别处复制粘贴或作为书签。如果那些小脚本使用 定义了一个变量let，然后重新运行脚本失败。var在这些情况下我可以继续使用，但我正在尝试接受新订单。无论您认为我的用例是否有效，问题成立。）

我已经尝试delete从window对象和其他一些黑客攻击，但无济于事。

出于性能目的，我想知道 ES6 JavaScript 之间的区别：

var list = [...];
let item; //let outside the loop
for (let i = 0; i < list.length; i++) {
    item = list[i];
}

和

var list = [...];
for (let i = 0; i < list.length; i++) {
    const item = list[i]; //const inside the loop
}

假设该item变量旨在在循环内保持不变。

有推荐吗？相对于性能而言，每种方法的优缺点是什么？GC 处理它们的方式不同吗？

请注意，这是微优化。此外，性能取决于所使用的 JS 引擎。（见答案）

我需要在 for 中分​​配两个变量。在 Angular 5+ 中是这样的

<div *ngFor="let a of apple, let b of ball">
  <a [routerLink]="['/ball',b]">
    {{a}}
  </a>
</div>

请问有什么建议吗？

提前感谢您的帮助。

最近，我经常嵌套几个返回多个值的函数。然而，与let允许将这些调用优雅地写成一个大语句的 不同，我总是以大量缩进结束。

我的问题是：有几个多值函数，例如

(defun return-1-and-2 ()
  (values 1 2))

(defun return-3-and-4 ()
  (values 3 4))

是否有可能达到与

(multiple-value-bind (one two)
    (return-1-and-2)
  (multiple-value-bind (three four)
      (return-3-and-4)
    (list one two three four)))

但写得更简洁 - 方式let，即，类似

(multiple-value-bind (one two)
    (return-1-and-2)
  (multiple-value-bind (three four)
      (return-3-and-4)
    (list one two three four)))

?

众所周知，要声明多个变量，可以使用如下格式：

let k = 0,
    j = 5 /*etc....*/

众所周知，要在一行中执行多个语句（这对箭头函数很有用，因此不必编写return关键字），还使用逗号“,”运算符，如下所示：

let k = 0,
    j = 5 /*etc....*/

不是最优雅的例子，但重点是你可以在一行中执行多个语句，用逗号“,”分隔，并返回最后一个值。

所以问题是：

你如何结合这两种技术？意思是，我们如何在一行中声明一个变量，然后在一个逗号之后，将该变量用于某事？

以下不起作用：

let k = 0, console.log(k), k += 8

说

未捕获的语法错误：意外的标记“。”

没有console.log，它认为我在重新声明k：

let k = 0, k += 8

给

Uncaught SyntaxError: Identifier 'k' has already been declared

并将整个内容放在括号中，如下所示：

(let k = 0, k += 8);

给

Uncaught SyntaxError: Unexpected identifier

指的是关键字“让”。但是，没有那个关键字，就没有问题：

(k = 0, k += 8);

除了 k 现在成为一个全局变量，这是不想要的。

这里有某种解决方法吗？

如何在 JavaScript 中将逗号运算符与局部变量声明一起使用？

编辑响应 VLAZ …

在许多函数式编程语言中，可以使用let表达式“重新定义”局部变量：

let example = 
    let a = 1 in
        let a = a+1 in
            a + 1

为此我找不到内置的 Prolog 谓词，因此我尝试以let这种方式定义表达式：

:- initialization(main).
:- set_prolog_flag(double_quotes, chars).

replace(Subterm0, Subterm, Term0, Term) :-
        (   Term0 == Subterm0 -> Term = Subterm
        ;   var(Term0) -> Term = Term0
        ;   Term0 =.. [F|Args0],
            maplist(replace(Subterm0,Subterm), Args0, Args),
            Term =.. [F|Args]
        ).

let(A,B) :-
    ((D,D1) = (A1 is B1,C is B1);
    (D,D1) = (A1=B1,C=B1)),
    subsumes_term(D,A),
    D=A,
    replace(A1,C,B,B2),
    call((D1,B2)).

main :- let(A = 1,( …