JavaScript function syntax explained

// 1. Function Definition
function printHello_1$_(name_0) 
{
    //execution
    console.log("Hello World!" + name_0);
}
console.log(typeof printHello_1$_);
// 2. Function Invocation
printHello_1$_(); 
// 3. Function Naming
// 4. Function Parameters
// 5. Function Return

// 6. The function can also have no name and be created directly like this.
let him = function(){
    console.log("him");
}
him() // This shows that the name is actually a variable name.
// 8. The function name itself does not support value transfer, but variables can.
// him = printHello_1(); // Error (similar to the fact that values ​​cannot be assigned after an array is defined?)
let add = him;
add();
// 7. This variable can still be assigned other contents.
him = 6;
console.log(him) // Output the number 6

if (false)
{
    const add = (a, b) => a + b; // Similar to creating a function directly and calling it by assigning it to a variable.
    console.log(add(1,3)); // No return value is written, and the calculated value is implicitly returned}
if (false)
{
    let add = (a, b) => a + b;
    console.log(add(1,3)); // print 4
    const add_0 = add; // You can replace it with normal variable assignment add = 5; // It can be seen that the essence is still a variable. If the definition uses a variable type, you can change it console.log(add); // Print 5
    console.log(add_0(2, 4)); // prints 6
}
if (false)
{
    console.log(add_0(10, 4)); // const variable types cannot cross scopes}

if (false)
{
    const add = (a, b) => 
    {
        return a + b;
    }
    console.log(add(1,3)); // There is a return value, which means that if curly braces are used, it can indicate a line break but there will be no implicit return. A single row will always have an implicit return.
}

// Example 1
if (false)
{
    const book = new Object({title : "1984", author : "George Orwell"}) // Create JSON object console.log("\n ---------")
    console.log(typeof book) // Check the type, it is indeed an object console.log(book) // Can print normally}
// Example 2 (Detailed explanation in the next section, knowledge points about objects)
if (false)
{
    const book = ({title : "1984", author : "George Orwell"}) // Even without adding the keyword Object, the same effect can be achieved.
    console.log("\n ---------")
    console.log(typeof book)
    console.log(book)
}
// Example 3
if (false)
{
    const book = [
        {title : "1984", author : "George Orwella"},
        {title : "1985", author : "George Orwellb"},
        {title : "1986", author : "George Orwellc"},
        {title : "1987", author : "George Orwell"}
    ]
    console.log("\n ---------")
    console.log(typeof book) // The print type is still object, but it is actually an array console.log(book)
}

if (false)
{
    const book = ({title : "1984", author : "George Orwell"}) // Even without adding the keyword Object, the same effect can be achieved.
    console.log("\n ---------")
    let bookJSON = JSON.stringify(book); // Keep the object in its original format and convert it to a string, where the key name becomes a string (that is, double quotes are added)? Convenient for saving in text?
    console.log(typeof bookJSON) // Come to think of it, isn't JSON also the parameter file I used when I wrote the ROS project before? The text files of Baidu Feijiang are also in this format.
    console.log(bookJSON)
}
/* The output is as follows:
 ---------
string
{"title":"1984","author":"George Orwell"}
*/
// You can find that the key value is still the original string, but the key name has been changed to a string

if (false)
{
    const book = ([1,23,3,"156"]) 
    console.log("\n ---------")
    console.log(typeof book) // The type is still object
    let bookJSON = JSON.stringify(book); // Can still be called without error.
    console.log(typeof bookJSON) // The result is a string that is exactly the same as the original result.
    console.log(bookJSON)
}
/* The output is as follows:
 ---------
object
string
[1,23,3,"156"]
*/
// It can be found that the function does not seem to work. It will not work and no error will be reported if the format does not meet the JSON requirements.

if (false)
{
    let data_0 = "[1,2,3]";
    let data = "{\"title\" : \"1984\", \"author\" : \"George Orwell\"}"; // Note that in JSON string format, both keys and values ​​must be enclosed in double quotes to create a string-like format. If there is anything wrong the conversion will fail.
    let parsed = JSON.parse(data); // Reverse operation, convert the string back to object type. Will parse whether it conforms to the format.
    console.log("\n -----")
    console.log(parsed); // 
    console.log(typeof parsed) 
    console.log(typeof data) 
}
/* The output is as follows:
 -----
{ title: '1984', author: 'George Orwell' }
object
string
*/
// Note that the slash in the string is more troublesome

if (false)
{
    let data_0 = "[1,2,3]";
    let data = "{\"title\" : \"1984\", \"author\" : \"George Orwell\"}"; // Note that in JSON string format, both keys and values ​​must be enclosed in double quotes to create a string-like format. If there is anything wrong the conversion will fail.
    let parsed = JSON.parse(data); // Reverse operation, convert the string back to object type. Will parse whether it conforms to the format.
    console.log("\n -----")
    console.log(parsed); // 
    console.log(typeof parsed) 
    console.log(typeof data) 
}
/* The output is as follows:
 -----
{ title: '1984', author: 'George Orwell' }
object
string
*/
// Note that the slash in the string is more troublesome

// 2. Another way to create an object, using a constructor if (false)
{
    const book = new Object();
    console.log(book); // The initial creation is empty console.log(typeof book); //The type is object
    book.title = "1984";
    book.author = "George Orwell";
    book.isAvailable = false; // Add attribute book.checkIn = function(){
        this.isAvailable = true; // Add method };
    book.checkOut = function(){
        this.isAvailable = false; 
    };
     console.log(book); // Print normally console.log(typeof book);
    // 3. Methods for accessing elements within an object:
    console.log(book.title); // Access similar to a structure console.log(book["title"]); // Access similar to a dictionary, the output result is the same. Note that when accessing in this way, the key name must be enclosed in double quotes and treated as a string console.log(book.checkIn); // If it is an access function, if no brackets are added, an object will be returned. Print similar characters: [Function (anonymous)]
    console.log(book.checkIn()); // If you add brackets, it is equivalent to calling execution. (The return value is empty because there is no return value in the function)
    console.log(book["checkIn"]); // You can also access it in dictionary form, with the same result console.log(book["checkIn"]()); // This bracket is outside the square brackets.
}

if (false)
{
    const bookObj = { // Create an object checkIn : function(){ // Add an attribute return this; // This attribute is a method and has a return value, returning the object itself}
    }
    function anotherCheckIn(){ // Create a function return this; // Return a function itself}
    console.log(bookObj.checkIn() == bookObj); // The return value is the object itself, correct console.log(bookObj.checkIn() == globalThis); // The return value is a function, wrong console.log(anotherCheckIn() == globalThis); // The return value is a function, correct }

// The Promise object is used to represent the final completion (or failure) of an asynchronous operation and its result value.
if (true)
{
    function promiseTimeout(ms){ // Create a function return new Promise((resolve, reject) => { // Return a Promise object, the input parameter is an anonymous function, where the anonymous function has 2 parameters, one is the content to be executed on success, and the other is the content to be executed on failure setTimeout(resolve, ms); // js internal function, delay the second parameter ms before executing the content of the first parameter
        });
    }
    promiseTimeout(2000) //Call the function and pass in the parameter 2000ms;
        .then(() => { // Built-in method of the returned Promise object; if successful, it will be called. This built-in method also has a parameter, which is an anonymous function console.log('Done!!'); // This anonymous function has no parameters, and its internal function is only printing return promiseTimeout(1000); // Call the function again and return another variable }).then(() => { // Because the above returns another variable, it can be called in a chain,
            console.log('Also done!!'); // Delay 1000ms, and then call return after successful operation Promise.resolve(42); // Return another object, infinite nesting dolls }).then((result_0) => { // Pass in parameters, the name of this parameter is arbitrary, I can still achieve the effect after modifying it. The ide automatically marks it in red, so you should know that it is a variable, not a grammatical keyword console.log(result_0); // Print parameters })
        .catch(() => { // Same as above, but calls console.log('Error!') when it fails;
        })
    // Because the Promise.prototype.then and Promise.prototype.catch methods return promises, they can be chained.
}
/*
The running results are:
Wait a moment and print a line:
Done!
After a short wait, two lines are printed simultaneously:
Also done!
42
*/

// Async:Await
function promiseTimeout(ms){
    return new Promise((resolve, reject) => {
        setTimeout(resolve, ms);
    });
}
async function longRunningOperation(){
    return 42;
}
async function run() {
    console.log('Start!');
    await promiseTimeout(2000); // Add the await keyword, the result is similar to synchronous operation. Originally, using Promise will cause printing first and then delay. If A/A is added, it will delay first and then print in order.
    const response = await longRunningOperation();
    console.log(response); // Logically, it should return 42 and print it directly. In fact, if the await keyword is not added, a Promise object will be returned immediately instead of 42.
    console.log('Stop!!');
}
run();
/*
The running results are:
First print a line:
Start!
After a short wait, two lines are printed simultaneously:
42
Stop!
*/