JS学习 - 函数与作用域

1. 函数定义与调用

在C#中，函数通常定义在类中，并且可以指定返回类型和参数类型。

class Program
{
    static void Main()
    {
        DisplayMessage("Hello, World!");
    }

    static void DisplayMessage(string message)
    {
        Console.WriteLine(message);
    }
}

在 JavaScript 中，函数可以定义为函数声明或函数表达式，并且不需要指定参数类型或返回类型。

function displayMessage(message) {
    console.log(message);
}

displayMessage("Hello, World!");

对比：

• C# 中函数定义需要指定返回类型，而 JavaScript 中不需要。
• JavaScript 允许函数表达式和箭头函数等更灵活的定义方式。

2. 参数传递与返回值

C# 支持按值传递和按引用传递（通过 ref 和 out 关键字）。

class Program
{
    static void Main()
    {
        int number = 10;
        AddFive(ref number);
        Console.WriteLine(number); // 输出 15
    }

    static void AddFive(ref int num)
    {
        num += 5;
    }
}

JavaScript 中的参数传递是按值传递，但对象和数组作为引用类型传递。

function addFive(num) {
    num += 5;
    return num;
}

let number = 10;
number = addFive(number);
console.log(number); // 输出 15

对比：

• C# 可以明确选择按值传递或按引用传递。
• JavaScript 默认按值传递，但对象和数组是按引用传递。

3. 变量作用域

C# 中的变量作用域依赖于变量声明的位置，如局部变量、类变量等。

class Program
{
    static int classVariable = 10; // 类变量/静态变量

    static void Main()
    {
        int localVariable = 5; // 局部变量
        Console.WriteLine(localVariable);
    }
}

JavaScript 的变量作用域可以是全局的、函数级的或块级的（使用 let 或 const）。

let globalVariable = 10; // 全局变量

function testScope() {
    let localVariable = 5; // 函数级变量
    console.log(localVariable);
}

testScope();
console.log(globalVariable);

4. 闭包

C# 支持闭包，通常通过匿名函数或 lambda 表达式实现。

class Program
{
    static void Main()
    {
        int outsideVariable = 10;
        Action action = () => {
            Console.WriteLine(outsideVariable);
        };
        action();
    }
}

JavaScript 中的闭包允许函数访问其外部函数作用域中的变量。

实际上，在JavaScript中，所有的函数都能访问它们上一层的作用域。这就意味着，在函数1内定义函数2，那么函数1的变量就可以被函数2访问到

闭包通常通过函数的嵌套来实现

function outer() {
    let outerVar = "I am from outer";

    // inner 是闭包
    function inner() {
        console.log(outerVar); // inner 函数可以访问 outer 函数的变量
    }

    return inner; // 返回内函数
}

const closure = outer(); // 调用 outer 函数
closure(); // 输出: I am from outer ，返回的inner函数不仅记住了自己的作用域，还记住了outer的作用域，即outerVar

作用：

        1.数据隐藏：闭包可以用于封装数据，使得只有特定的函数可以进行访问和修改

function createCounter() {
    let count = 0; // count 是私有变量

    return {
        increment: function() {
            count++;
            console.log(count);
        },
        decrement: function() {
            count--;
            console.log(count);
        },
        getCount: function() {
            return count;
        }
    };
}

const counter = createCounter();
counter.increment(); // 输出 1
counter.increment(); // 输出 2
console.log(counter.getCount()); // 输出 2

        2.维持状态：闭包允许你在多个函数调用之间保留状态。它是js里实现事件处理的基础，如回调函数使用

function fetchData(url) {
    let status = "loading";

    setTimeout(function() {
        status = "done"; // 闭包可以访问并修改外部的 status 变量
        console.log("Data fetched from", url);
    }, 1000);

    console.log(status); // 输出 "loading"
}

fetchData("https://example.com");

原文地址：https://blog.csdn.net/weixin_50600749/article/details/143944402

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！