函数前的void、+、-、~、!运算符具体作用是什么？

Great question! Those unary operators you’re seeing are all clever ways to turn a function declaration into an immediately invoked function expression (IIFE). Let’s break down each one’s role:

• !function () { /* ... */ }();
  The logical NOT operator first runs the function expression, then inverts its return value to a boolean. The key here isn’t the negation itself—it’s that the ! tells the JS engine to treat the following function as an expression (not a declaration), which lets us immediately invoke it with (). We don’t usually care about the boolean result, but it’s a concise trick for making an IIFE.

• ~function () { /* ... */ }();
  The bitwise NOT operator works similarly: it executes the function first, then applies a bitwise flip to the return value. Again, the main goal is forcing the function to be parsed as an expression. The numeric result of the bitwise flip is rarely used, but the IIFE runs just fine regardless.

• -function () { /* ... */ }();
  The unary negation operator runs the function, then negates its return value (turning positive numbers negative, etc.). Like the others, its primary job is to convert the function into an expression so we can invoke it immediately. The sign change of the return value is a side effect, not the point.

• +function () { /* ... */ }();
  The unary plus operator executes the function, then attempts to convert its return value into a number. Same core purpose: making the function an expression instead of a declaration. The type conversion is a secondary effect that’s irrelevant if you don’t need the return value.

• void function () { /* ... */ }();
  This one’s a bit special. The void operator runs the function, then explicitly returns undefined—no matter what the function itself returns. It’s useful when you want to guarantee the IIFE doesn’t accidentally return a value that could leak into the surrounding scope. Like the others, it also forces the function to be treated as an expression.

Quick Recap #

All these operators share the same core goal: turning a function declaration into an expression so it can be immediately invoked. The more common way to do this is wrapping the function in parentheses ((function(){})()), but these unary operators are just shorter alternatives. The side effects (negation, bitwise flips, etc.) don’t affect the IIFE’s internal code execution—they only change what the IIFE returns (if you care about that).

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