从零开始学习JavaScript:轻松掌握编程语言的核心技能⑤

从零开始学习JavaScript:轻松掌握编程语言的核心技能⑤

  • 1. JavaScript 函数定义
  • 2. JavaScript 函数参数
    • 2.1 函数显式参数(Parameters)与隐式参数(Arguments)
      • 2.1.1 显式参数(Parameters)
      • 2.1.2 隐式参数(Arguments)
    • 2.2 arguments 对象
  • 3. JavaScript 函数调用
    • 3.1 this 关键字
    • 3.2 全局对象
  • 4. 使用构造函数调用函数
  • 5. JavaScript 闭包

️️个人简介:以山河作礼。
️️:Python领域新星创作者,CSDN实力新星认证,阿里云社区专家博主
:Web全栈开发专栏:《Web全栈开发》免费专栏,欢迎阅读!



从零开始学习JavaScript:轻松掌握编程语言的核心技能⑤_第1张图片

1. JavaScript 函数定义

在 JavaScript 中,函数可以通过 function 关键字来定义
函数定义的一般语法如下:

function functionName(parameters) {
  // 函数体
  return returnValue; // 可选
}

其中,functionName 是函数的名称,parameters
是函数的参数列表,可以是多个参数,用逗号分隔。函数体是函数执行的代码块,可以包含任意数量的语句。returnValue
是函数的返回值,可以省略。

以下是一个简单的例子,定义了一个接收两个参数并返回它们之和的函数:

function add(num1, num2) {
  return num1 + num2;
}

可以通过以下方式调用该函数:

var sum = add(2, 3); // sum 的值为 5

函数也可以使用匿名函数的形式定义,例如:

var add = function(num1, num2) {
  return num1 + num2;
}

这种方式定义的函数可以通过变量名来调用,例如:

var sum = add(2, 3); // sum 的值为 5

2. JavaScript 函数参数

2.1 函数显式参数(Parameters)与隐式参数(Arguments)

在 JavaScript 中,函数的参数有两种类型:显式参数和隐式参数

2.1.1 显式参数(Parameters)

显式参数是在函数定义时声明的参数,它们的值在函数调用时通过传递实参来确定。
例如:

function add(x, y) {
  return x + y;
}

add(2, 3); // 5

在上面的例子中,x 和 y 就是函数 add 的显式参数。在函数调用时,实参 2 和 3 会分别赋值给 x 和 y。

2.1.2 隐式参数(Arguments)

隐式参数是在函数内部自动创建的一个对象,它包含了所有传递给函数的实参。它是一个类数组对象,可以通过下标访问其中的元素。
例如:

function sum() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

sum(1, 2, 3, 4); // 10

arguments 就是函数 sum 的隐式参数。在函数调用时,实参 1、2、3 和 4 会被存储在 arguments
对象中,然后通过循环遍历 arguments 对象来计算它们的总和。

隐式参数 arguments 是一个类数组对象,它没有数组的所有方法,如果需要使用数组方法,需要将其转换成真正的数组。
例如:

function toArray() {
  return Array.prototype.slice.call(arguments);
}

toArray(1, 2, 3); // [1, 2, 3]

在上面的例子中,使Array.prototype.slice.call(arguments) 将 arguments
对象转换成了一个真正的数组,然后返回该数组。

2.2 arguments 对象

在 JavaScript 中,每个函数都有一个内部对象 arguments,它表示函数的实参集合。arguments 对象是一个类数组对象,可以通过下标访问其中的元素。

例如,下面的函数可以计算任意数量的实参的总和:

function sum() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

sum(1, 2, 3, 4); // 10

arguments 对象包含了所有传递给函数 sum 的实参,通过循环遍历 arguments 对象,可以计算出它们的总和。

arguments 对象不是一个真正的数组,它没有数组的所有方法,如果需要使用数组方法,需要将其转换成真正的数组。
例如:

function toArray() {
  return Array.prototype.slice.call(arguments);
}

toArray(1, 2, 3); // [1, 2, 3]

使用 Array.prototype.slice.call(arguments) 将 arguments
对象转换成了一个真正的数组,然后返回该数组。

3. JavaScript 函数调用

3.1 this 关键字

在 JavaScript 中,关键字 this 通常用于引用当前函数所属的对象。this 的值在函数调用时确定,并且取决于调用函数的方式
下面是一些常见的 this 使用方式:

全局环境中的 this:在全局环境中,this 指向全局对象(在浏览器中是 window 对象)。
例如:

console.log(this); // 输出 window 对象

对象方法中的 this:在对象方法中,this 指向调用该方法的对象。
例如:

let person = {
  name: 'Tom',
  sayHi: function() {
    console.log('Hi, my name is ' + this.name);
  }
};

person.sayHi(); // 输出 Hi, my name is Tom

构造函数中的 this:在构造函数中,this 指向新创建的对象。
例如:

function Person(name) {
  this.name = name;
  this.sayHi = function() {
    console.log('Hi, my name is ' + this.name);
  }
}

let person1 = new Person('Tom');
let person2 = new Person('Jerry');

person1.sayHi(); // 输出 Hi, my name is Tom
person2.sayHi(); // 输出 Hi, my name is Jerry

apply 和 call 方法中的 this:在 apply 和 call 方法中,this 可以指向任意对象。
例如:

function sayHi() {
  console.log('Hi, my name is ' + this.name);
}

let person1 = {name: 'Tom'};
let person2 = {name: 'Jerry'};

sayHi.call(person1); // 输出 Hi, my name is Tom
sayHi.call(person2); // 输出 Hi, my name is Jerry
  • 当函数作为普通函数调用时,this 指向全局对象;
  • 当函数作为对象方法调用时,this 指向调用该方法的对象;
  • 当函数作为构造函数调用时,this 指向新创建的对象;
  • 当函数使用 apply 或 call 方法调用时,this 可以指向任意对象。

3.2 全局对象

  • 在 JavaScript 中,全局对象是一个特殊的对象,它是全局作用域中所有变量和函数的宿主对象。在浏览器中,全局对象是 window对象,它包含了所有浏览器窗口的全局变量和函数。在 Node.js 中,全局对象是 global 对象,它包含了所有 Node.js程序的全局变量和函数。
  • 全局对象可以通过 this 关键字来引用。在全局作用域中,this 指向全局对象本身。 例如,在浏览器中,可以通过window.alert() 来弹出一个对话框,也可以通过 this.alert() 来实现同样的效果。
  • 全局对象还包含了一些内置的属性和方法,例如在浏览器中,window 对象包含了document、consolesetTimeout、setInterval 等属性和方法,可以通过window.document、window.console、window.setTimeout、window.setInterval等来访问它们。

全局对象的属性和方法可以被程序中的任何代码访问,因此应该避免在全局作用域中定义过多的变量和函数,以免造成命名冲突和不必要的安全风险。

4. 使用构造函数调用函数

在 JavaScript 中,函数可以通过构造函数的方式调用,这种方式被称为构造函数调用。当使用 new 操作符调用一个函数时,该函数会被作为构造函数来使用,它将返回一个新创建的对象

下面是一个使用构造函数调用函数的示例:

function Person(name, age) {
  this.name = name;
  this.age = age;
}

let person1 = new Person('Tom', 18);
let person2 = new Person('Jerry', 20);

console.log(person1); // {name: "Tom", age: 18}
console.log(person2); // {name: "Jerry", age: 20}

Person 函数被作为构造函数来使用,通过 new 操作符创建了两个新的对象 person1 和 person2。在构造函数中,使用
this 关键字来指向新创建的对象,并将属性赋值给它们。最后,构造函数返回新创建的对象。

构造函数的名称通常以大写字母开头,这是一种约定俗成的写法,用来区分普通函数和构造函数。

另外,使用构造函数调用函数时,如果构造函数中没有显式地返回一个对象,则构造函数会默认返回新创建的对象。如果构造函数中显式地返回一个对象,则该对象将会被返回,而新创建的对象将被忽略。

5. JavaScript 闭包

在 JavaScript 中,闭包是指一个函数可以访问其词法作用域之外的变量。换句话说,闭包可以访问在函数定义时处于父级作用域中的变量,即使在函数调用时,这些变量已经不在父级作用域中了
下面是一个使用闭包的例子:

function outer() {
  var count = 0;

  function inner() {
    count++;
    console.log(count);
  }

  return inner;
}

var counter = outer();
counter(); // 输出 1
counter(); // 输出 2

outer 函数返回了一个内部函数 inner,该函数可以访问 outer 函数中的 count 变量。当 outer函数被调用时,它创建了一个新的词法作用域,并在其中定义了 count 变量和 inner 函数。然后,outer 函数返回 inner 函数,使其可以在外部作用域中被调用。

当 counter 函数被调用时,它会访问 outer 函数中的 count 变量,并将其递增。由于 inner 函数是一个闭包,它可以访问outer 函数中的 count 变量,即使 outer 函数已经执行完毕并且 count变量已经不在 outer 函数的作用域中了。

闭包在 JavaScript 中有广泛的应用,例如在模块化编程中、实现私有变量和方法、以及在异步编程中保存状态等。但是,由于闭包可以访问外部作用域中的变量,如果不妥善地使用闭包,可能会导致内存泄漏和性能问题。因此,在使用闭包时,需要谨慎考虑其影响,并避免滥用。

你可能感兴趣的:(Web全栈开发,javascript,学习,前端)