TypeScript：如何为函数参数使用const断言？或通过新变量赋值bars as const实现？

Hey there! Let's break down your two questions about TypeScript's const assertions clearly:

1. How to apply const assertions directly to function parameters #

First off, you can’t add a const assertion directly to a function’s parameter definition (like function foo(bars: string[] as const) {} — that’s invalid syntax). Instead, you apply the assertion to the argument you pass into the function, and adjust the function’s parameter type to be compatible with readonly arrays (since const assertions make arrays read-only by default).

Here’s the proper approach:

// Update the function parameter to accept readonly arrays
function foo(bars: readonly string[]) {
  // Inside the function, bars retains the exact literal type from the const-asserted argument
  console.log(bars); // If passed ['apple', 'banana'] as const, bars is typed as readonly ["apple", "banana"]
}

// Apply const assertion to the argument when calling the function
foo(['apple', 'banana'] as const);

If you need the parameter to stay a mutable string[] (not readonly), you can still use the const assertion on the argument but will need a type assertion to convert it back — use this cautiously, as it bypasses TypeScript’s safety checks:

function foo(bars: string[]) {
  // ...
}

// Use const assertion then convert back to string[]
foo((['apple', 'banana'] as const) as string[]);

2. Does creating a new variable with bars as const work? #

Yes, but the outcome depends on the original type of the bars parameter:

• If bars is a generic type that captures literal array details (or you passed a const-asserted argument to a readonly string[] parameter), const constBars = bars as const will preserve the exact literal type:

  function foo<T extends readonly string[]>(bars: T) {
    const constBars = bars as const;
    // constBars inherits the literal type of T (e.g., readonly ["a", "b"] if passed ['a','b'] as const)
  }
  
  foo(['a', 'b'] as const);
  

• If bars is just a plain string[] (a broad, mutable array type), bars as const only converts it to readonly string[] — it won’t narrow it to a literal array type, because the original bars has no literal-specific information:

  function foo(bars: string[]) {
    const constBars = bars as const;
    // constBars is typed as readonly string[] (no specific literals)
  }
  
  foo(['a', 'b']); // Even with literal inputs, bars remains string[]
  

The key takeaway: const assertions work best when applied directly to literal values (like function arguments) rather than to already-broadened variables like a plain string[] parameter.

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