javascript之原型与原型链、执行上下文与执行上下文栈

最新推荐文章于 2024-03-01 10:30:00 发布
最新推荐文章于 2024-03-01 10:30:00 发布
阅读量639 收藏 1
点赞数
分类专栏： javascript 
## 原型与原型链
* 所有函数都有一个特别的属性:
  * `prototype` : 显式原型属性
* 所有实例对象都有一个特别的属性:
  * `__proto__` : 隐式原型属性
* 显式原型与隐式原型的关系
  * 函数的prototype: 定义函数时被自动赋值, 值默认为{}, 即用为原型对象
  * 实例对象的__proto__: 在创建实例对象时被自动添加, 并赋值为构造函数的prototype值
  * 原型对象即为当前实例对象的父对象
* 原型链
  * 所有的实例对象都有__proto__属性, 它指向的就是原型对象
  * 这样通过__proto__属性就形成了一个链的结构---->原型链
  * 当查找对象内部的属性/方法时, js引擎自动沿着这个原型链查找
  * 当给对象属性赋值时不会使用原型链, 而只是在当前对象中进行操作

## 执行上下文与执行上下文栈
* 变量提升与函数提升
  * 变量提升: 在变量定义语句之前, 就可以访问到这个变量(undefined)
  * 函数提升: 在函数定义语句之前, 就执行该函数
  * 先有变量提升, 再有函数提升
* 理解
  * 执行上下文: 由js引擎自动创建的对象, 包含对应作用域中的所有变量属性
  * 执行上下文栈: 用来管理产生的多个执行上下文
* 分类:
  * 全局: window
  * 函数: 对程序员来说是透明的
* 生命周期
  * 全局 : 准备执行全局代码前产生, 当页面刷新/关闭页面时死亡
  * 函数 : 调用函数时产生, 函数执行完时死亡
* 包含哪些属性:
  * 全局 : 
    * 用var定义的全局变量  ==>undefined
    * 使用function声明的函数   ===>function
    * this   ===>window
  * 函数
    * 用var定义的局部变量  ==>undefined
    * 使用function声明的函数   ===>function
    * this   ===> 调用函数的对象, 如果没有指定就是window 
    * 形参变量   ===>对应实参值
    * arguments ===>实参列表的伪数组
* 执行上下文创建和初始化的过程
  * 全局:
    * 在全局代码执行前最先创建一个全局执行上下文(window)
    * 收集一些全局变量, 并初始化
    * 将这些变量设置为window的属性
  * 函数:
    * 在调用函数时, 在执行函数体之前先创建一个函数执行上下文
    * 收集一些局部变量, 并初始化
    * 将这些变量设置为执行上下文的属性

======================

原型：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>01_原型(prototype)</title>
</head>
<body>
<!--
1. 函数的prototype属性(图)
  * 每个函数都有一个prototype属性, 它默认指向一个Object空对象(即称为: 原型对象)
  * 原型对象中有一个属性constructor, 它指向函数对象
2. 给原型对象添加属性(一般都是方法)
  * 作用: 函数的所有实例对象自动拥有原型中的属性(方法)
-->
<script type="text/javascript">

  // 每个函数都有一个prototype属性, 它默认指向一个Object空对象(即称为: 原型对象)
  console.log(Date.prototype, typeof Date.prototype)
  function Fun () {//alt + shift +r(重命名rename)

  }
  console.log(Fun.prototype)  // 默认指向一个Object空对象(没有我们的属性)

  // 原型对象中有一个属性constructor, 它指向函数对象
  console.log(Date.prototype.constructor===Date)
  console.log(Fun.prototype.constructor===Fun)

  //给原型对象添加属性(一般是方法) ===>实例对象可以访问
  Fun.prototype.test = function () {
    console.log('test()')
  }
  var fun = new Fun()
  fun.test()





</script>
</body>
</html>

结果：
这里写图片描述

显示原型与隐式原型：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>02_显式原型与隐式原型</title>
</head>
<body>
<!--
1. 每个函数function都有一个prototype，即显式原型(属性)
2. 每个实例对象都有一个__proto__，可称为隐式原型(属性)
3. 对象的隐式原型的值为其对应构造函数的显式原型的值
4. 内存结构(图)
5. 总结:
  * 函数的prototype属性: 在定义函数时自动添加的, 默认值是一个空Object对象
  * 对象的__proto__属性: 创建对象时自动添加的, 默认值为构造函数的prototype属性值
  * 程序员能直接操作显式原型, 但不能直接操作隐式原型(ES6之前)
-->
<script type="text/javascript">
  //定义构造函数
  function Fn() {   // 内部语句: this.prototype = {}

  }
  // 1. 每个函数function都有一个prototype，即显式原型属性, 默认指向一个空的Object对象
  console.log(Fn.prototype)
  // 2. 每个实例对象都有一个__proto__，可称为隐式原型
  //创建实例对象
  var fn = new Fn()  // 内部语句: this.__proto__ = Fn.prototype
  console.log(fn.__proto__)
  // 3. 对象的隐式原型的值为其对应构造函数的显式原型的值
  console.log(Fn.prototype===fn.__proto__) // true
  //给原型添加方法
  Fn.prototype.test = function () {
    console.log('test()')
  }
  //通过实例调用原型的方法
  fn.test()



</script>
</body>
</html>

结果：
这里写图片描述
显式原型与隐式原型分析：
这里写图片描述

原型链：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>03_原型链</title>
</head>
<body>
<!--
1. 原型链(图解)
  * 访问一个对象的属性时，
    * 先在自身属性中查找，找到返回
    * 如果没有, 再沿着__proto__这条链向上查找, 找到返回
    * 如果最终没找到, 返回undefined
  * 别名: 隐式原型链
  * 作用: 查找对象的属性(方法)
2. 构造函数/原型/实体对象的关系(图解)
3. 构造函数/原型/实体对象的关系2(图解)
-->
<script type="text/javascript">
  // console.log(Object)
  //console.log(Object.prototype)
  console.log(Object.prototype.__proto__)
  function Fn() {
    this.test1 = function () {
      console.log('test1()')
    }
  }
  console.log(Fn.prototype)
  Fn.prototype.test2 = function () {
    console.log('test2()')
  }

  var fn = new Fn()

  fn.test1()
  fn.test2()
  console.log(fn.toString())
  console.log(fn.test3)
  // fn.test3()


  /*
  1. 函数的显示原型指向的对象默认是空Object实例对象(但Object不满足)
   */
  console.log(Fn.prototype instanceof Object) // true
  console.log(Object.prototype instanceof Object) // false
  console.log(Function.prototype instanceof Object) // true
  /*
  2. 所有函数都是Function的实例(包含Function)
  */
  console.log(Function.__proto__===Function.prototype)
  /*
  3. Object的原型对象是原型链尽头
   */
  console.log(Object.prototype.__proto__) // null

</script>
</body>
</html>

结果：
这里写图片描述
原型链分析：
这里写图片描述

构造函数、原型、实例对象的关系：
var o1 = new Object();
var o2 = {};
图解：
这里写图片描述

function Foo(){ }
图解：
这里写图片描述

原型链属性问题：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>04_原型链_属性问题</title>
</head>
<body>
<!--
1. 读取对象的属性值时: 会自动到原型链中查找
2. 设置对象的属性值时: 不会查找原型链, 如果当前对象中没有此属性, 直接添加此属性并设置其值
3. 方法一般定义在原型中, 属性一般通过构造函数定义在对象本身上
-->
<script type="text/javascript">

  function Fn() {

  }
  Fn.prototype.a = 'xxx'
  var fn1 = new Fn()
  console.log(fn1.a, fn1)

  var fn2 = new Fn()
  fn2.a = 'yyy'
  console.log(fn1.a, fn2.a, fn2)

  function Person(name, age) {
    this.name = name
    this.age = age
  }
  Person.prototype.setName = function (name) {
    this.name = name
  }
  var p1 = new Person('Tom', 12)
  p1.setName('Bob')
  console.log(p1)

  var p2 = new Person('Jack', 12)
  p2.setName('Cat')
  console.log(p2)
  console.log(p1.__proto__===p2.__proto__) // true



</script>
</body>
</html>

结果：
这里写图片描述

探索instanceof:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>05_探索instanceof</title>
</head>
<body>
<!--
1. instanceof是如何判断的?
  * 表达式: A instanceof B
  --A是实例对象，含有隐式原型属性，，沿着隐式原型链最终到达object原型对象；
  --B是构造函数，含有显示原型属性，默认指向一个空的Object实例对象。
  * 如果B函数的显式原型对象在A对象的原型链上, 返回true, 否则返回false
2. Function是通过new自己产生的实例
-->
<script type="text/javascript">

  /*
  案例1
   */
  function Foo() {  }
  var f1 = new Foo()
  console.log(f1 instanceof Foo) // true
  console.log(f1 instanceof Object) // true

  /*
  案例2
   */
  console.log(Object instanceof Function) // true
  console.log(Object instanceof Object) // true
  console.log(Function instanceof Function) // true  --Function是new自己产生的
  console.log(Function instanceof Object) // true

  function Foo() {}
  console.log(Object instanceof  Foo) // false
</script>
</body>
</html>

结果：
这里写图片描述
图解：
案例一：
这里写图片描述
案例二：
这里写图片描述

======================
面试题：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>06_面试题</title>
</head>
<body>

<script type="text/javascript">
  /*
  测试题1
   */
  function A () {

  }
  A.prototype.n = 1

  var b = new A()  //b可以看到n属性，是因为new A对象之后有一个隐式原型属性

  A.prototype = {  //A的原型属性指向一个新的对象
    n: 2,
    m: 3
  }

  var c = new A()
  console.log(b.n, b.m, c.n, c.m)


  /*
   测试题2
   */
  function F (){}
  Object.prototype.a = function(){
    console.log('a()')
  }
  Function.prototype.b = function(){
    console.log('b()')
  }

  var f = new F()
  f.a()
  // f.b()
  F.a()
  F.b()

  console.log(f)
  console.log(Object.prototype)
  console.log(Function.prototype)
  console.log(fn33())

  function fn33(){}

</script>
</body>
</html>

结果：
这里写图片描述

==========================

执行上下文与执行上下文栈：
变量提升与函数升：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>01_变量提升与函数提升</title>
</head>
<body>
<!--
1. 变量声明提升
  * 通过var定义(声明)的变量, 在定义语句之前就可以访问到
  * 值: undefined
2. 函数声明提升
  * 通过function声明的函数, 在之前就可以直接调用
  * 值: 函数定义(对象)
3. 问题: 变量提升和函数提升是如何产生的?
-->
<script type="text/javascript">
  console.log('-----')
  /*
  面试题 : 输出 undefined
   */
  var a = 3
  function fn () {
    console.log(a)
    var a = 4
  }
  fn()

  console.log(b) //undefined  变量提升
  fn2() //可调用  函数提升
  // fn3() //不能  变量提升

  var b = 3
  function fn2() {
    console.log('fn2()')
  }

  var fn3 = function () {
    console.log('fn3()')
  }
</script>
</body>
</html>

结果：
这里写图片描述

执行上下文：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>02_执行上下文</title>
</head>
<body>
<!--
1. 代码分类(位置)
  * 全局代码
  * 函数(局部)代码
2. 全局执行上下文
  * 在执行全局代码前将window确定为全局执行上下文
  * 对全局数据进行预处理
    * var定义的全局变量==>undefined, 添加为window的属性
    * function声明的全局函数==>赋值(fun), 添加为window的方法
    * this==>赋值(window)
  * 开始执行全局代码
3. 函数执行上下文
  * 在调用函数, 准备执行函数体之前, 创建对应的函数执行上下文对象(虚拟的, 存在于栈中)
  * 对局部数据进行预处理
    * 形参变量==>赋值(实参)==>添加为执行上下文的属性
    * arguments==>赋值(实参列表), 添加为执行上下文的属性
    * var定义的局部变量==>undefined, 添加为执行上下文的属性
    * function声明的函数 ==>赋值(fun), 添加为执行上下文的方法
    * this==>赋值(调用函数的对象)
  * 开始执行函数体代码
-->
<script type="text/javascript">
  console.log(a1, window.a1)
  window.a2()
  console.log(this)

  var a1 = 3
  function a2() {
    console.log('a2()')
  }
  console.log(a1)

</script>
</body>
</html>

结果：
这里写图片描述

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>03_执行上下文栈</title>
</head>
<body>
<!--
1. 在全局代码执行前, JS引擎就会创建一个栈来存储管理所有的执行上下文对象
2. 在全局执行上下文(window)确定后, 将其添加到栈中(压栈)  --栈：后进先出，进出口不一样；队列：先进先出，进口出口不一样
3. 在函数执行上下文创建后, 将其添加到栈中(压栈)
4. 在当前函数执行完后,将栈顶的对象移除(出栈)
5. 当所有的代码执行完后, 栈中只剩下window
-->
<script type="text/javascript">
  var a = 10
  var bar = function (x) {
    var b = 5
    foo(x + b)
  }
  var foo = function (y) {
    var c = 5
    console.log(a + c + y)
  }
  bar(10)
  // bar(10)
</script>

</body>
</html>

结果：
这里写图片描述

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>04_执行上下文栈2</title>
</head>
<body>
<!--
1. 依次输出什么?
  gb: undefined
  fb: 1
  fb: 2
  fb: 3
  fe: 3
  fe: 2
  fe: 1
  ge: 1
2. 整个过程中产生了几个执行上下文?  5
-->
<script type="text/javascript">
  console.log('gb: '+ i)
  var i = 1
  foo(1)
  function foo(i) {
    if (i == 4) {
      return
    }
    console.log('fb:' + i)
    foo(i + 1) //递归调用: 在函数内部调用自己
    console.log('fe:' + i)
  }
  console.log('ge: ' + i)
</script>
</body>
</html>

结果：
这里写图片描述
流程分析：
图一：
这里写图片描述
图二：
这里写图片描述
图三：
这里写图片描述

面试题：

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>05_面试题</title>
  <link rel="stylesheet" href="xxx.css">
  <style>

  </style>
</head>
<body>
<div style=""></div>
<script type="text/javascript">


  // 测试题1:  先执行变量提升, 再执行函数提升

  function a() {
  }
  var a
  console.log(typeof a) // 'function'



   //测试题2:

  if (!(b in window)) {
    var b = 1
  }
  console.log(b) // undefined


   //测试题3:

  var c = 1
  function c(c) {
    console.log(c)
    var c = 3
  }
  c(2) // 报错

</script>
</body>
</html>

结果：
这里写图片描述

qq_34983808
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解JavaScript 中的执行上下文和执行栈
10-17
JavaScript 是一种解释型的、基于原型的编程语言，其运行机制是通过执行上下文和执行栈来管理代码的执行过程。执行上下文是JavaScript引擎在处理代码时的一个关键概念，它定义了代码执行的环境，包括变量、函数、...
JavaScript作用域、闭包、对象与原型链概念及用法实例总结
10-18
- **上下文对象（this）**：在JavaScript中，`this`指针在函数调用时指向调用者，它可以是全局对象、对象实例或通过`call`/`apply`方法显式设置的对象。 4. **原型链** - **原型**：每个JavaScript对象都有一个`_...
原型&&原型链&&执行上下文
YogaLin_qwq的博客
07-20 376
原型&&原型链 原型 ​ 1.函数的prototype属性 ​ |每个函数都有一个prototype属性，默认指向一个Object空对象（原型对象） ​ |原型对象中有一个constructor属性，指向函数对象 function Fun(){//ctrl+shift+L 重命名所有的Fun都被修改 } console.log(Fun.prototype) //object console.log(Fun.prototype.consructor===fun) //tru
JavaScript原型链、执行上下文
m0_63669414的博客
09-26 214
在全局代码执行前, JS引擎就会创建一个栈来存储管理所有的执行上下文对象，当全局执行上下文确定后就将其添加到栈中，在函数执行上下文创建后, 将其添加到栈中。在调用函数, 准备执行函数体之前, 创建对应的函数执行上下文对象(虚拟的, 存在于栈中)。在访问对象的属性（方法）时先在自身属性中查找，如果没有找到就沿着__proto__这条链往上查找，如果没有找到则返回undefined。表达式: A instanceof B，如果B函数的显式原型对象在A对象的原型链上, 返回true, 否则返回false。
上下文 及 执行上下文
weixin_30271335的博客
07-15 126
上下文是函数运行时的环境或者说是依赖资源的集合，它决定了函数运行时可以获取到哪些变量、函数。 执行上下文（EC）: 如果函数处于正在执行状态则该函数的上下文称为执行上下文, 与此同时如果函数处于非执行状态则为（普通）上下文。所以执行上下文只是上下文的不同状态，本质上它们没有区别。 转载于:https://www.cnblogs.com/lianghong881018/p/11188547....
javascript作用域、执行上下文、原型和原型链
weixin_34192732的博客
02-20 107
一、作用域js中作用域是指可访问变量，对象，函数的集合，也就是调用它们能生效的代码区块。在js中没有块级作用域，只有全局作用域和函数作用域 1、全局，函数作用域 var a = 10 function f1(){ var b = c = 20; console.log(a); //10 console.log(c); //20 ...
js - 什么是原型，执行上下文以及闭包
weixin_46022982的博客
06-04 141
二、函数高级 1、原型与原型链 1.1、prototype原型对象（显示原型对象） 每个函数都有一个prototype属性, 它默认指向一个拥有constructor属性对象，该对象被称为原型对象，也被称作为显式原型对象。 1.2、constructor(构造器) 原型对象中有一个属性constructor, 它指向函数对象 给原型对象添加属性(一般都是方法)，函数的所有实例对象自动拥有原型中的属性(方法) 1.2、__proto__（隐式原型对象） 每个实例对象都有一个__p
深入浅出理解javaScript原型链
12-01
3. 调用构造函数`Person`，将新对象`p`作为上下文，执行构造函数中的代码，初始化对象的属性。 在实际应用中，我们可以在构造函数的`prototype`上添加方法和属性，以便所有实例都可以访问。例如，`Person.prototype...
javascript原型链学习记录之继承实现方式分析
11-27
在这种方式中，`Parent.call(this)`使得父类的构造函数在子类的上下文中运行，将`name`属性添加到子类实例。然而，这种方式只复制了父类的实例属性，而没有继承其原型链上的属性。 2. **原型链继承**： 原型链...
深入理解javascript原型和闭包（18）——补充：上下文环境和作用域的关系
weixin_30765319的博客
09-29 334
本系列用了大量的篇幅讲解了上下文环境和作用域，有些人反映这两个是一回儿事。本文就用一个小例子来说明一下，作用域和上下文环境绝对不是一回事儿。 再说明之前，咱们先用简单的语言来概括一下这两个的区别。 00上下文环境： 可以理解为一个看不见摸不着的对象（有若干个属性），虽然看不见摸不着，但确实实实在在存在的，因为所有的变量都在里面存储着，要不然咱们定义的变量在哪里存？ 另外，...
执行上下文与执行上下文栈
JJ_Smilewang的博客
07-12 298
① 变量声明提升：通过var 定义（声明）的变量，在定义语句之前就可以访问到，值为undefined; ② 函数声明提升：通过function声明的函数，在之前就可以直接调用，值：函数定义（对象）那么问题来了：变量提升和函数提升是如何产生的呢？这就涉及到执行上下文的相关知识了...JS代码根据位置可以分为：全局代码 和 函数(局部)代码。从而执行上下文也就分为全局执行上下文和函数执行上下文。① 在执行全局代码前，将window确定为全局执行上下文 ② 对全局数据进行预处理（预解析）： 1）var定义的
高性能JavaScript---作用域链, 闭包, 原型, 原型链
翾的博客
08-31 2060
本篇博客为”高性能JavaScript”一书部分知识点学习笔记摘录.作用域链及和标识符解析每一个JavaScript函数都表示为一个对象, 要确切的说, 是Function对象的一个实例. Function对象同其他对象一样, 拥有可以编程访问的属性, 和一系列不能通过代码访问而仅供JavaScript引擎存取的内部属性. 其中有一个内部属性是[[Scope]].内部属性[[Scope]]包含了一
理解js作用域原型链和执行上下文
fhb19870610的专栏
02-27 1144
作用域跟函数紧密相关。每个函数就是一个作用域，同时包括一个全局的作用域。作用域有上下级关系，子作用域可以访问到父作用域的变量跟函数，但是父作用域无法访问到子作用域的变量跟函数（这里说的访问是直接访问，通过闭包是可以间接访问到的）。 js中一切都是对象，除了基本值类型之外。其他都是object。函数是一种特殊的对象，因为对象都是由函数生成的。 执行上下文，每执行一次函数便会产生一个新的执行上下文
对象，原型，上下文环境，作用域，闭包等问题深入理解
Oliver尹的博客
11-12 306
对象 对象是属性的集合，重点：是一个集合，意思是有一个个属性集成在了一起，组成了一个集合，这个集合叫做对象，另外，这个属性是以键值对的形式存在的，键是一个字符串，比如a，比如name等，值可以是任意类型，比如数组，function，字符串，数字 ---------------------------------------- prototype（原型） 每一个函数创建的时候，系统会自动给这...
Javascript原型链详解，一文带你彻底搞懂js原型、原型对象及原型链
最新发布
greatming666的博客
03-01 811
原型链是 JavaScript 中的一个重要特性，它是实现对象之间继承关系的机制。在 JavaScript 中，每个对象都有一个原型属性，指向另一个对象。当试图访问一个对象的属性或方法时，如果该对象本身没有这个属性或方法，JavaScript 引擎会沿着原型链向上查找，直到找到对应的属性或方法为止。
JavaScript重难点解析3（原型与原型链、执行上下文与执行上下文栈）
qq_41965041的博客
06-27 159
JavaScript重难点解析3（原型与原型链）原型与原型链原型（prototype）显示原型与隐式原型原型链instanceof是如何判断执行上下文与执行上下文栈变量提升与函数提升 原型与原型链 原型（prototype） 每个函数都有一个prototype属性, 它默认指向一个Object空对象(即称为: 原型对象) 原型对象中有一个属性constructor, 它指向函数对象 function A() { } console.log(A.prototype） // 打印一个空对象 console
js原型链以及上下文环境和作用域的关系
u014651643的博客
05-16 253
一个作用域下可能包含若干个上下文环境。有可能从来没有过上下文环境（函数从来就没有被调用过）；有可能有过，现在函数被调用完毕后，上下文环境被销毁了；有可能同时存在一个或多个（闭包）。
函数的上下文
ScutKevinYzy的博客
03-25 305
将函数 fn 的执行上下文改为 obj 对象 function speak(fn, obj) {     return fn.apply(obj,obj); }
原型和原型链的底层运行机制
zoepriselife316的博客
02-21 255
原型prototype和原型链__proto__： 每一个类（函数）都具备prototype，并且属性值是一个对象。 对象上天生具备一个属性：constructor，指向类本身。 每一个对象（普通对象、prototype、实例、函数等）都具备：proto，属性值是当前实例所属类额原型。 <!DOCTYPE html> <html lang="en"> <head&g...
探索JavaScript高级概念：预解析、作用域与原型链
"本篇文档聚焦于JavaScript的高级内容，涵盖了预解析、执行上下文、原型链与继承等核心概念。JavaScript高级是对基础语法的深化，它并非新技术，而是对ECMAScript标准的扩展和理解层面的提升。在学习过程中，虽然...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值