A brief analysis of the principle of Javascript self-executing anonymous function (function() { })()

Function is the most flexible object in JavaScript. Here we only explain the use of its anonymous functions. Anonymous functions refer to functions that do not specify a function name or pointer. Self-executing anonymous functions are just one of them. This kind of function is called below: self-executing function

The following is the most common self-executing function:

// 传统匿名函数
(function() {
alert('hello');
})();

The execution effect of this code is that when the page is reloaded: "hello"

What prompts it to execute automatically? , look at the following code

// 在传统写法上去掉小括号，并在前面加上运算符 ~,!,+,-
~function(){
alert('hello');
}();
!function(){
alert('hello');
}();
+function(){
alert('hello');
}();
-function(){
alert('hello');
}();

There is no difference between these writing methods and the traditional way mentioned above.

I found that the common point of these writing methods is the operator. In fact, the traditional way The parentheses () are also a type of operation, appearing in: a=b*(c+d),

Operator + passed to self-generated parameters = function automatically executed? But some symbols are not supported, such as "=, *, /". The reason for its self-execution is still very mysterious, and I can't find a decent answer on the Internet

Then I discovered a magical phenomenon. These Operators can be stacked infinitely. . . . . .

// function前面是特定符号可以无限叠加...
~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~!+-~!+-+-!~~~~~~~~+-!!!!!!+function a(b) {
alert('hello');
}();

The program runs normally!!!!!!

However, there are two situations where an error will be reported

If three or more "+" or "-" appear in a row " symbol, an error will occur;

If two "+" or "-" symbols appear in succession and are followed by other symbols, an error will occur, such as "++~", "--+";

　Error message: Uncaught ReferenceError: Invalid left-hand side expression in prefix operation (meaning the left-hand side expression is wrong)

Then I used the same symbol to operate a variable and found that it was exactly the same. Perhaps it can be explained that the operation of JavaScript prompts the automatic execution of the function, and it can also be understood as calling this function through operation!

It is not that the function is executed by itself, but the function is called through calculation! , but only supports some calculation methods!

In addition, this self-executing function may not be an anonymous function! Looking at the code above, I defined the function name a in the function after the operator. There is no exception, but it is of no use - -!, this a still cannot be called by other methods, but I think many people call it There is something wrong with it being an anonymous function!

The above is a brief analysis of the principles of Javascript self-executing anonymous functions (function() { })() introduced by the editor. I hope it will be helpful to everyone!

For more relevant articles on the principles of Javascript self-executing anonymous functions (function() { })(), please pay attention to the PHP Chinese website!