JavaScript中Thunk与柯里化的区别？Thunk是否为柯里化特例？

Great question! Let's break down the differences between thunks and currying in JavaScript, then tackle whether thunks qualify as a special case of currying.

What is Currying? #

Currying is a functional programming technique that transforms a function with multiple arguments into a sequence of functions, each taking a single argument. Each step returns a new function that waits for the next argument, until all required arguments are collected—then the original function's logic runs.

Example of Currying #

Take this simple multiplication function:

function multiply(x, y){ return x * y; }
multiply(3, 5); // 15

Its curried version breaks the two arguments into two separate function calls:

function curriedMultiply(x) { 
  return function(y) { 
    return x * y; 
  } 
}
curriedMultiply(3)(5); // 15

Key traits of currying:

• No restrictions on argument types—you can curry functions with any kind of parameters (numbers, strings, objects, etc.)
• The goal is often parameter reuse, function composition, or creating more specialized functions from general ones.

What is a Thunk? #

In JavaScript (especially in Node.js asynchronous workflows), a thunk is a specific type of function that transforms an async function accepting a callback into two separate steps:

1. First, pass all non-callback arguments to the thunkified function.
2. It returns a new function that only accepts the callback, which then triggers the original async operation.

Example of a Thunk #

Using Node.js's fs.readFile (a classic async function with a callback):

let fs = require('fs')
fs.readFile(fileName, callback) // Original: pass filename + callback together

With thunkify (a utility to create thunks), we split this into two steps:

let thunkify = require('thunkify')
let read = thunkify(fs.readFile)
read(fileName)(callback) // First pass filename, then pass callback later

Key traits of thunks:

• It's specifically designed for functions that take a callback as their final argument.
• The primary goal is to separate the initiation of an async operation from handling its result, which is extremely useful for async flow control (like working with Generators or early async libraries like co).

Are Thunks a Special Case of Currying? #

Technically speaking, yes—thunks do fit the core definition of currying: they split a multi-argument function into a sequence of single-argument functions. However, thunks are a highly specialized subset of currying with strict constraints:

• Currying can split arguments in any order or into any number of steps (e.g., you could curry a 3-arg function into a 1+2 step, or 2+1 step). Thunks only split the function into "all non-callback arguments first, then callback last".
• Currying is a general functional programming technique applicable to any function. Thunks are exclusively for async functions that use callbacks.

So while thunks are technically a type of currying, their narrow use case and specific structure make them distinct enough that developers usually treat them as separate concepts in practice.

内容的提问来源于stack exchange，提问作者Chor