标签: anonymous-function

我看到很多这样的代码：

var myApp ={};
(function() {
    console.log("Hello");
    this.var1 = "mark";     //"this" is global, because it runs immediately on load.  Caller is global
    myApp.sayGoodbye = function() {
        console.log("Goodbye");
    };
})();

这会导致匿名函数立即执行。但与仅仅将代码内联相比，这样做有什么好处呢？

var myApp ={};
console.log("Hello");
var1 = "mark";     
myApp.sayGoodbye = function() {
    console.log("Goodbye");
};

显然这与函数的作用域有关，但由于该函数是匿名的并且由窗口调用，因此它的作用域（即this）是全局的，不是吗？

假设我有一个从 A1 开始并经过的日期列表...

1/3/2014 2/5/2014 5/5/2015 8/10/2016 ...

我想统计某个月份出现在这个范围内的次数。我当前的解决方案是它下面的行只包含=MONTH(x1)，其中x是列，然后我在该行上调用 COUNTIF 。

我不认为这是一个糟糕的解决方案，但它确实需要一大堆额外的单元格来计算电子表格中的月份，这对于其他任何事情来说并不是真正必要的。

所以基本上，有什么方法可以按照 =COUNTIF(MONTH(range),5) 的方式进行一些操作来计数，例如，五月发生某事的次数？

我正在尝试将元组与管道运算符|>一起使用，以及一个匿名函数，如

(1,2) |> (x,y) -> x^2 + y^2

但收到错误消息：

wrong number of arguments
while loading In[59], in expression starting on line 1

 in anonymous at In[59]:1
 in |> at operators.jl:178

显然，(1,2)元组没有映射到(x,y).

经过一些尝试后，我意识到我可以通过以下方式规避问题

(1,2) |> x -> x[1]^2 + x[2]^2

但在某些情况下，后者不如第一种方式优雅。如果我想以第一种方式映射(1,2)到(x,y)，语法应该是什么样的F#？

我只是在学习 Haskell 并尝试实现一个函数来获取包含前 N 个斐波那契数的列表：

fibonacci :: Integer -> [Integer]
fibonacci 1 = [0]
fibonacci 2 = fibonacci 1 ++ [1]
fibonacci n = appendSumOfLastTwo (fibonacci (n - 1))

appendSumOfLastTwo :: (Num a) => [a] -> [a]
appendSumOfLastTwo xs = xs ++ [addLastTwo xs]

addLastTwo :: (Num a) => [a] -> a
addLastTwo xs = last xs + (xs !! ((length xs) - 2))

这有效但不是很漂亮，因为它需要两个名称奇怪的辅助函数。在 Haskell 中，有这样一个单独使用的函数是常见的吗？

为了摆脱这些函数，我尝试了匿名函数：

fibonacci :: Integer -> [Integer]
fibonacci 1 = [0]
fibonacci 2 = …

我在编写一些代码时偶然发现了这一点：

var obj = {
  myFunc() {
    document.body.innerHTML = 'Hello World!';
  }
};

obj.myFunc();

我想输入的是：

var obj = {
  myFunc: function() { 
    // ...
  }
};

我没有注意到我不小心输入了第一个，直到我意识到我的代码没有在 IE11 中运行。

为什么第一个示例适用于 Chrome/Firefox，而不适用于 IE11？

另外，如果这是官方语言功能，这叫什么？

这个问题是关于 fun() 与 lambda 块定义和范围的问题。
我尝试用两种方式定义表达式。这是我尝试过的：

  val myFunction = fun(){
    println("i am in a function")
    }

//but i also tried doing this:

    val myFunction = {
    println("i am in a lambda")
    }

我的问题是我不知道它们是否等效且相同？

当传递回调函数时，尤其是传递参数化函数时，我知道应该使用钩子，useCallback因为使用匿名函数会对性能产生不利影响。

我说的匿名函数的例子就是这样的。

import React, { useState } from 'react';

const Component = () => {
  const [param, setParam] = useState('');
  ...

  return (
    ...
    <SomeComponent
      onClick={() => setParam('parameter')}
      {...others}
    />
  );
}

在转换匿名函数以使用此钩子的过程中，我遇到了一个错误，提示“渲染次数过多”或者它无法正常工作。但具体是在什么情况下、什么情况下我也不清楚。

我用useCallback如下。

import React, { useState, useCallback } from 'react';

const Component = () => {
  const [param, setParam] = useState('');

  const handleClick = useCallback((params) => {
    setParam(params);
  },[]);

  ...
  return (
    ...
    <SomeComponent
      onClick={handleClick('parameter')}
      {...others}
    />
  );
}

但是，当使用匿名函数在 内返回时useCallback …

不确定在标题中写什么，它们可能不都是匿名方法，但这里是：

假设我们有这个异步函数：

public async Task Delete(){  
  //something
}

我正在使用 Blazor 服务器端，我对以下四种调用函数的方式感到好奇。假设它们在 div 标签内。

1. onclick="@Delete"

2. onclick="@(() => Delete(id))"

3. onclick="@(async () => await Delete(id))"

4. onclick="@(e => Delete(person.Id))

我不确定 1 是否是 Blazor 的新手，但它是否理解该方法是异步的？

如果需要传入参数，将使用 2 和 3，但我以前从未使用过 async-part，只在较旧的帖子中看到过。还需要说"async () =>"吗？

在 Haskell 中，以下表达式：

 a \b -> c $ d

或者是

• 无效的

• (a (\b ->c)) d

• (a (\b -> (c d))

为什么？

我最近一直在读 Paul Graham 的 ANSI Common Lisp，他在其中提到

在 Common Lisp 中，您可以将函数表示为列表，但它们在内部表示为不同的函数对象。所以 lambda 不再是真正必要的。

在第 2 章中。但是，如果我省略 lambda 符号，我将无法编译正确的程序。

我尝试计算 Lisp 函数：(((x) x) 1 )而不是((lambda (x) x) 1 )，这应该与 ANSI Common Lisp 所说的相同。但是，没有 lambda 的代码无法编译。