花费28800秒，从源码的角度我终于知道了 typeof null 为 object 的原理

最新推荐文章于 2024-08-15 08:55:57 发布
最新推荐文章于 2024-08-15 08:55:57 发布
阅读量1.1k 收藏 27
点赞数 36
文章标签： javascript vscode 测试工具 node.js typescript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54631992/article/details/137807772
版权

1. 背景

我之前一直知道 typeof null 为 object ，但是一直没深究为什么？在查阅了相关的文档，汇总为以下文档

 

2. 汇总解释

我们先来看 《JavaScript高级程序设计》 里面是怎么说的吧？

Null 类型同样只有一个值，即特殊值 null。逻辑上讲，null 值表示一个空对象指针，这也是给 typeof 传一个 null 会返回 “object” 的原因

这里我们就可以解释通了，null 其实是一个 空对象指针，所以 typeof 会检测 null 为 object

在这里插入图片描述

 

如果单纯是这样必然是不对的，是 空对象指针 就一定会被检测为 object 吗？

这其实就是一句总结，里面肯定有更加深层的原因，我看了一眼 ECMAScript 的文档，发现没有说这一点（可能是我没找到），倒是在 MDN 发现了解释

在 JavaScript 最初的实现中，JavaScript 中的值是由一个表示类型的标签和实际数据值表示的。对象的类型标签是 0。由于 null 代表的是空指针（大多数平台下值为 0x00），因此，null 的类型标签是 0，typeof null 也因此返回 "object"

我来简单解释一遍，对象类型表示为 0，null 在大部分机器上面都是 0x00…000，所以 null 为 0，所以 null 在 typeof 下 会被检测为 object

 

3. 早期解释

这个解释已经能解答很多疑惑了，如果我们再往下面看一层呢？为什么对象类型为 0，null 为 0x00，typeof 底层分析类型是通过什么手段？以及这部分源码是什么样子的？

其实 JavaScript 的数据类型其实是通过 数据标签 + 数据值 的形式存在的，下面就是常见的数据标签

数据标签类型
000object
1int
010double
100string
110boolean

在32位机器中，int 的 标签为 1，占了一位，那么后续的值为 2 ^ 30 ~2 ^ 30 - 1（根据上图推算，现代JS早就改）；其中 object 的标签为 000

在这里插入图片描述

这就是 JavaScript 的数据类型如何去做处理和区分的，当然还有2个特殊的值

  • undefined 源码标记为 JSVAL_VOID
  • null 源码标记为 JSVAL_NULL ：是机器代码的 NULL指针。或者说，它是一个对象类型标记加上一个引用为零的组合，大部分机器都认定为 0x000

 

我们来看下面的 typeof 源码部分

  • 发现没有 显式的判断 null值 的标记，只有 undefined，object，number，string，boolean 的判断
  • 再加上 null 在很多的机器中默认是 0x000，那么就会走 JSVAl_IS_OBJECT(v) 的逻辑，被认定为 object 类型
// 这是一个宏，它指定了函数的返回类型为 JSType，并且声明该函数是一个公共API
JS_PUBLIC_API(JSType)
JS_TypeOfValue(JSContext *cx, jsval v) {
    JSType type = JSTYPE_VOID;
    JSObject *obj;
    JSObjectOps *ops;
    JSClass *clasp;
	
    // 这是一个宏，用于检查传入的 JSContext 是否有效
    CHECK_REQUEST(cx);
    
    if (JSVAL_IS_VOID(v)) { 
        type = JSTYPE_VOID;
    } else if (JSVAL_IS_OBJECT(v)) {
        // 如果 v 是对象类型，则检查它是否是函数对象，如果是函数对象则将 type 设置为 JSTYPE_FUNCTION
        // 否则将其设置为 JSTYPE_OBJECT
        obj = JSVAL_TO_OBJECT(v);
        if (obj && (ops = obj->map->ops, ops == &js_ObjectOps ? (clasp = OBJ_GET_CLASS(cx, obj), clasp->call || clasp == &js_FunctionClass) : ops->call != 0)) {  
            type = JSTYPE_FUNCTION;
        } else {
            type = JSTYPE_OBJECT;
        }
    } else if (JSVAL_IS_NUMBER(v)) {
        type = JSTYPE_NUMBER;
    } else if (JSVAL_IS_STRING(v)) {
        type = JSTYPE_STRING;
    } else if (JSVAL_IS_BOOLEAN(v)) {
        type = JSTYPE_BOOLEAN;
    }
    return type;
}

这也是网上大部分的解释，因为在 JavaScript 设计初期，时间很短，所以导致一些地方没考虑到，那如今的JS引擎怎么做的

 

4. V8解释

在 V8 Blog 对于 typeof null 为 object 的解释。我来简单解释一下：V8 Blog 认为 null 表示 no object value，所以输出 object 没问题

当然这有一股王婆卖瓜，自卖自夸的感觉了，毕竟是 JavaScript 最初设计的问题

在这里插入图片描述

我们先下载 V8 的源码来看看：v8/v8.git - Git at Google (googlesource.com)，根据知乎大佬的提示，找到了下面的源码部分

在这里插入图片描述

我们来看下下面的整体流程：

  • 首先，创建了一个 TNode<String> 类型的函数 Typeof，它接受一个 TNode<Object> 类型的参数 value。

  • 创建了一些标签，这些标签用于控制程序执行流程。例如，return_number 表示如果是数字类型就返回数字类型的字符串，return_function 表示如果是函数类型就返回函数类型的字符串，以此类推。

  • 使用 GotoIf 语句检查 value 的类型，并根据类型跳转到相应的标签处进行处理。比如，如果 value 是一个 Smi（表示一个被标记为小整数的对象），那么就跳转到 return_number 标签处。

  • 如果 value 不是 Smi，那么获取其对应的 HeapObject，并加载其 Map 对象。

  • 根据 Map 对象判断 value 的类型，并跳转到相应的标签进行处理。例如，如果是一个奇怪的对象（Oddball），则跳转到 if_oddball 标签处。

  • 在各个标签处，根据对象的具体类型设置 result_var 的值为相应类型的字符串，并跳转到 return_result 标签处，返回 result_var 的值。

  • 最后，返回 result_var 的值。

可以发现 V8 其实对 null 做了提前的处理，可能是为了兼容早期 V8 做的吧

// 定义一个函数，用于模拟 JavaScript 的 typeof 操作符
TNode<String> CodeStubAssembler::Typeof(TNode<Object> value) {
  TVARIABLE(String, result_var);

  // 定义标签，用于控制程序流程
  Label return_number(this, Label::kDeferred), if_oddball(this),
      return_function(this), return_undefined(this), return_object(this),
      return_string(this), return_bigint(this), return_symbol(this),
      return_result(this);

  GotoIf(TaggedIsSmi(value), &return_number);
  TNode<HeapObject> value_heap_object = CAST(value);
  TNode<Map> map = LoadMap(value_heap_object);
  GotoIf(IsHeapNumberMap(map), &return_number);
  TNode<Uint16T> instance_type = LoadMapInstanceType(map);

  // 如果是oddball，则跳转到 if_oddball 标签处，V8 对 null提前做了判断
  GotoIf(InstanceTypeEqual(instance_type, ODDBALL_TYPE), &if_oddball);
  TNode<Int32T> callable_or_undetectable_mask =
      Word32And(LoadMapBitField(map),
                Int32Constant(Map::Bits1::IsCallableBit::kMask |
                              Map::Bits1::IsUndetectableBit::kMask));
  GotoIf(Word32Equal(callable_or_undetectable_mask,
                     Int32Constant(Map::Bits1::IsCallableBit::kMask)),
         &return_function);
  GotoIfNot(Word32Equal(callable_or_undetectable_mask, Int32Constant(0)),
            &return_undefined);
  GotoIf(IsJSReceiverInstanceType(instance_type), &return_object);
  GotoIf(IsStringInstanceType(instance_type), &return_string);
  GotoIf(IsBigIntInstanceType(instance_type), &return_bigint);
  GotoIf(IsSymbolInstanceType(instance_type), &return_symbol);

  // 如果类型未知，则终止程序执行
  Abort(AbortReason::kUnexpectedInstanceType);

  BIND(&return_number);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->number_string());
    Goto(&return_result);
  }

  BIND(&if_oddball);
  {
    TNode<String> type =
        CAST(LoadObjectField(value_heap_object, offsetof(Oddball, type_of_)));
    result_var = type;
    Goto(&return_result);
  }

  BIND(&return_function);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->function_string());
    Goto(&return_result);
  }

  BIND(&return_undefined);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->undefined_string());
    Goto(&return_result);
  }

  BIND(&return_object);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->object_string());
    Goto(&return_result);
  }

  BIND(&return_string);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->string_string());
    Goto(&return_result);
  }

  BIND(&return_bigint);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->bigint_string());
    Goto(&return_result);
  }

  BIND(&return_symbol);
  {
    result_var = HeapConstantNoHole(isolate()->factory()->symbol_string());
    Goto(&return_result);
  }

  BIND(&return_result);
  return result_var.value();
}

 

5. 总结

到这里继续深究下去已经没必要了，最初设计的缺陷导致的，当然这次的查询告诉我们对于高级语言的设计并不一定都是对的，如果想深究，也能看到 JavaScript 很多不合理的地方

 

参考文章

javascript - Why is typeof null “object”? - Stack Overflow

The story of a V8 performance cliff in React · V8

typeof - JavaScript | MDN (mozilla.org)

[The history of “typeof null” (2ality.com)](https://2ality.com/2013/10/typeof-null.html#:~:text=In JavaScript%2C typeof null is,it would break existing code)

typeof 与 Javascript 类型源码分析 - 知乎 (zhihu.com)

he history of “typeof null” (2ality.com)](https://2ality.com/2013/10/typeof-null.html#:~:text=In JavaScript%2C typeof null is,it would break existing code)

typeof 与 Javascript 类型源码分析 - 知乎 (zhihu.com)

村头一只鹅鹅
关注
  • 36
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
vue对象属性为null_『 Vue小Case 』- Vue Prop中的 null vs undefined
weixin_42627812的博客
01-14 1542
本文会同步发布在微信公众号『 Vue 小 Case 』- Vue Prop 中的 null vs undefined前言：本文将引入两个 Vue 中比较特殊的使用场景，带领大家熟悉一下null和undefined的区别，然后再分析一下 Vue 中是怎么对 Props 做校验的，最后给出大佬是怎么解释的。一直以来，笔者在使用 Vue 时，习惯于在需要表示 prop 属性未定义时，使用undefine...
Vue源码中要const _toStr = Object.prototype.toString的原因分析
01-19
众所周知，typeof在判断对象时不能正确判断Null，并且不能识别出Array，但在判断基础类型时是没问题的。所以尤大也写了： export function isPrimitive (value: any): boolean %checks { retu
JS typeof null 为什么是object
qq1195566313的博客
10-24 4484
我们从源码解析看这个问题 我们的JS 是 经过V8 引擎编译的 所以我们需要调试V8。在判断数据类型时，是根据机器码低位标识来判断的，而。切换到用户目录下面的.jsvu。根据生成的字节码得出的结论。安装工具 node版本要高。，而对象的机器码低位标识为。通过以下命令生成字节码。来看typeOf 源码。
【手撕源码】vue3响应式原理解析
热门推荐
编码世界
04-17 6万+
new Proxy(target,handler)表示生成一个Proxy实例，target参数表示所要拦截的目标对象，它可以是任意类型的对象，包括内置的数组，函数等，handler也是一个对象，用来定制拦截行为，当发生某些操作时触发该对象。
从源码理解 Vue-Router 实现原理
weixin_43299180的博客
03-17 1845
路由是前端构建单页面应用的关键技术，它的原理核心是：更新视图但不重新请求页面。 一、路由安装 install 在 src / install.js 文件是 Vue-Router 的安装程序。这里提供了一个 install 方法，使用 Vue.mixin 混入 beforeCreate 和 destroyed 钩子函数，并全局注册 router-view 和 router-link 组件。 import View from './components/view' import Link from './com
JavaScript中typeof，instanceof，Object.prototype.toString
yangyang的专栏
03-31 590
总结：typeof是一个用来检测变量数据类型的操作符，主要用来检测基本数据类型。为什么这么说呢？因为它可以判断一个变量是字符串、数值、布尔值还是undefined，有个例外null返回object，但是如果检测的变量是引用数据类型，返回object或者function，但不能细致地分出是array还是RegExp。 而 instanceof主要的目的就是检测引用类型,它可以判断出对象是Array还...
判断数据类型的方式有哪些（原理及优缺点）？（typeof / instanceof 核心原理 / constructor / Object.prototype.toString）
小草莓的博客
04-04 1165
1、typeof 操作符 2、instanceof 3、constructor构造器 4、Object.prototype.toString 5、判断一个对象是否为数组？ 6、通过对象的原型方法判断类型的应用
JS深入理解—详解Object.create(null)、new实现过程以及手写实现
LS.Yu.大前端
10-09 3164
前言 在阅读Vue框架源码的时候，会发现作者大量使用Object.create(null)来创建空对象。我们常常使用字面量{}的方式创建，他们之间有什么区别？为啥这么做呢？带着这些疑问，我们来探索其原因。其标准定义请看Object.create。 Object.create(null)与{}的区别 我们通过例子来直观的认识下两者： let obj = {}; let jbo = Object.cr...
源码解析 深入vue响应式原理
m0_52544128的博客
04-28 1551
深入响应式原理 大家应该都知道响应式原理的核心API是Object.defineProperty。如果不了解请点击： Object.defineProperty 去MDN了解下这个API的用途。 那这个API是如何做到响应式对象的呢。 接下来我们从源码的角度来进行分析： 我们知道在组件的data中定义的数据，最终都能响应式，看下Vue2.x的源码是如何初始化data的： export function initState (vm: Component) { vm._watchers = [] con
Threejs 源码解析 (Object3D)
七岁
09-10 1万+
版本95 本来想就这么用算了，可是发现好多都不理解，也就起了解析源码的心思，下苦功夫了，以前老版本的有人写过，不过threejs 更新太快，有些变动，并且他只是简单的注释，并未详细的解释，对于我这种刚开始接触的小白来说，数学就是一大硬伤，本来想做个原生的射线拾取，结果看的我一脸懵逼，跳的函数太多，刚开始容易迷路，所有就打算慢慢啃；方法都尽量解释，以便知道这样的方法为什么得这样的结果； 相关连的...
详解Vue源码中一些util函数
12-10
在Vue的源码中，`util`文件夹包含了一系列实用函数，这些函数是开发者为了处理JavaScript中的特定场景而编写的，因为它们不被ES规范直接涵盖，但对库的实现至关重要。在这里，我们将深入探讨一些关键的util函数，...
JS 使用 typeof 获取数据类型
06-08
需要注意的是，尽管`null`实际上是一个对象，但`typeof null`却返回`"object"`，这是JavaScript中的一个历史遗留问题。 当应用于函数时，`typeof`会返回`"function"`，这对于检测某个值是否为函数非常有用。例如： ...
instanceof 判断引用类型，typeof判断基本类型。
04-02
此外，`typeof`不能正确识别`null`，它总是返回`"object"`，这是JavaScript中的一个历史遗留问题。因此，在处理`null`时，我们需要额外的条件判断。 总结起来，`instanceof`和`typeof`是JavaScript中用于类型检查的...
ECMAScript性能优化技巧与陷阱：深入探索与实践
最新发布
Chujun123528的博客
08-15 620
ECMAScript性能优化是一个复杂而细致的过程，需要开发者从多个角度进行考虑和优化。通过合理利用现代JavaScript特性、优化DOM操作、选择合适的算法和数据结构、利用Web Workers等技术手段，可以显著提升JavaScript代码的执行效率。同时，开发者还需要关注全局变量、闭包、eval等性能陷阱，避免不必要的性能开销。此外，性能监控与分析、内存管理、网络层面的优化等也是不可忽视的重要方面。只有综合考虑这些因素，并持续进行性能优化工作，才能为用户提供更加流畅、高效的Web应用体验。
提升前端性能的JavaScript技巧
han2434的博客
08-14 688
一个快速响应、高效运行的Web页面不仅能提升用户体验，还能在一定程度上影响网站的SEO排名。本文汇总了一系列JavaScript技巧，以帮助开发者提升前端性能，并提供实际的代码示例。
playwright链接本地浏览器，实现自动登录。
qq_38880880的博客
08-12 150
【代码】playwright链接本地浏览器，实现自动登录。
【无标题】
weixin_42348009的博客
08-14 115
静态方法返回一个由给定对象自身的可枚举的字符串键属性名组成的数组。
Vue2 axios
qq_53374893的博客
08-14 85
说明一下， 当前服务器 有资源 就不会走代理服务器了，直接返回当前资源 而且只能代理一个服务器.
JsonUtility源码
05-27
JsonUtility是Unity内置的用于序列化和反序列化JSON数据的工具类，以下是它的部分源码： ```c# public static class JsonUtility { // 将一个对象序列化为JSON格式的字符串 public static string ToJson(object obj, bool prettyPrint = false) { if (obj == null) return "null"; var jsonWriter = new JsonWriter { prettyPrint = prettyPrint }; SerializeValue(obj, jsonWriter); return jsonWriter.ToString(); } // 将一个JSON格式的字符串反序列化为指定类型的对象 public static T FromJson<T>(string json) { if (string.IsNullOrEmpty(json)) return default(T); var reader = new JsonReader(json); return (T)DeserializeValue(reader, typeof(T)); } // 序列化对象 private static void SerializeValue(object value, JsonWriter writer) { if (value == null) { writer.Write(null); } else if (value is bool) { writer.Write((bool)value); } else if (value is string) { writer.Write((string)value); } else if (value is char) { writer.Write((char)value); } else if (value is Enum) { writer.Write((int)value); } else if (value is int) { writer.Write((int)value); } else if (value is uint) { writer.Write((uint)value); } else if (value is long) { writer.Write((long)value); } else if (value is ulong) { writer.Write((ulong)value); } else if (value is float) { writer.Write((float)value); } else if (value is double) { writer.Write((double)value); } else if (value is decimal) { writer.Write((decimal)value); } else if (value is Array) { SerializeArray((Array)value, writer); } else if (value is IList) { SerializeList((IList)value, writer); } else if (value is IDictionary) { SerializeDictionary((IDictionary)value, writer); } else if (value is UnityEngine.Object) { SerializeUnityObject((UnityEngine.Object)value, writer); } else { SerializeObject(value, writer); } } // 反序列化对象 private static object DeserializeValue(JsonReader reader, Type type) { if (type == typeof(bool)) { return reader.ReadBoolean(); } else if (type == typeof(string)) { return reader.ReadString(); } else if (type == typeof(char)) { return reader.ReadChar(); } else if (type.IsEnum) { return Enum.ToObject(type, reader.ReadInt32()); } else if (type == typeof(int)) { return reader.ReadInt32(); } else if (type == typeof(uint)) { return reader.ReadUInt32(); } else if (type == typeof(long)) { return reader.ReadInt64(); } else if (type == typeof(ulong)) { return reader.ReadUInt64(); } else if (type == typeof(float)) { return reader.ReadSingle(); } else if (type == typeof(double)) { return reader.ReadDouble(); } else if (type == typeof(decimal)) { return reader.ReadDecimal(); } else if (type.IsArray) { return DeserializeArray(reader, type.GetElementType()); } else if (typeof(IList).IsAssignableFrom(type)) { return DeserializeList(reader, type); } else if (typeof(IDictionary).IsAssignableFrom(type)) { return DeserializeDictionary(reader, type); } else if (typeof(UnityEngine.Object).IsAssignableFrom(type)) { return DeserializeUnityObject(reader, type); } else { return DeserializeObject(reader, type); } } // 序列化数组 private static void SerializeArray(Array array, JsonWriter writer) { writer.WriteArrayStart(); for (int i = 0; i < array.Length; i++) { SerializeValue(array.GetValue(i), writer); } writer.WriteArrayEnd(); } // 序列化列表 private static void SerializeList(IList list, JsonWriter writer) { writer.WriteArrayStart(); for (int i = 0; i < list.Count; i++) { SerializeValue(list[i], writer); } writer.WriteArrayEnd(); } // 序列化字典 private static void SerializeDictionary(IDictionary dictionary, JsonWriter writer) { writer.WriteObjectStart(); foreach (DictionaryEntry entry in dictionary) { writer.WritePropertyName(entry.Key.ToString()); SerializeValue(entry.Value, writer); } writer.WriteObjectEnd(); } // 序列化Unity对象 private static void SerializeUnityObject(UnityEngine.Object obj, JsonWriter writer) { writer.WriteObjectStart(); writer.WritePropertyName("instanceID"); writer.Write(obj.GetInstanceID()); writer.WriteObjectEnd(); } // 序列化普通对象 private static void SerializeObject(object obj, JsonWriter writer) { writer.WriteObjectStart(); var fields = obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (var field in fields) { if (field.IsNotSerialized) continue; writer.WritePropertyName(field.Name); SerializeValue(field.GetValue(obj), writer); } writer.WriteObjectEnd(); } // 反序列化数组 private static Array DeserializeArray(JsonReader reader, Type elementType) { var list = new List<object>(); reader.ReadArrayStart(); while (!reader.IsArrayEnd) { list.Add(DeserializeValue(reader, elementType)); } reader.ReadArrayEnd(); var array = Array.CreateInstance(elementType, list.Count); for (int i = 0; i < list.Count; i++) { array.SetValue(list[i], i); } return array; } // 反序列化列表 private static object DeserializeList(JsonReader reader, Type type) { var elementType = type.GetGenericArguments()[0]; var list = Activator.CreateInstance(type) as IList; reader.ReadArrayStart(); while (!reader.IsArrayEnd) { list.Add(DeserializeValue(reader, elementType)); } reader.ReadArrayEnd(); return list; } // 反序列化字典 private static object DeserializeDictionary(JsonReader reader, Type type) { var keyType = type.GetGenericArguments()[0]; var valueType = type.GetGenericArguments()[1]; var dictionary = Activator.CreateInstance(type) as IDictionary; reader.ReadObjectStart(); while (!reader.IsObjectEnd) { var key = DeserializeValue(reader, keyType); var value = DeserializeValue(reader, valueType); dictionary.Add(key, value); } reader.ReadObjectEnd(); return dictionary; } // 反序列化Unity对象 private static UnityEngine.Object DeserializeUnityObject(JsonReader reader, Type type) { var instanceID = 0; reader.ReadObjectStart(); while (!reader.IsObjectEnd) { var propertyName = reader.ReadPropertyName(); if (propertyName == "instanceID") { instanceID = reader.ReadInt32(); } else { reader.SkipValue(); } } reader.ReadObjectEnd(); return UnityEngine.Object.FindObjectFromInstanceID(instanceID); } // 反序列化普通对象 private static object DeserializeObject(JsonReader reader, Type type) { var obj = Activator.CreateInstance(type); reader.ReadObjectStart(); while (!reader.IsObjectEnd) { var propertyName = reader.ReadPropertyName(); var field = type.GetField(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (field != null) { field.SetValue(obj, DeserializeValue(reader, field.FieldType)); } else { reader.SkipValue(); } } reader.ReadObjectEnd(); return obj; } } ``` 以上是JsonUtility的部分源码，它主要包含了ToJson和FromJson两个方法，分别用于将一个对象序列化为JSON格式的字符串和将一个JSON格式的字符串反序列化为指定类型的对象。在序列化和反序列化时，JsonUtility会根据对象的类型选择不同的处理方式。例如，如果对象是一个数组，则会调用SerializeArray方法进行序列化；如果对象是一个Unity对象，则会调用SerializeUnityObject方法进行序列化。在反序列化时也是同样的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值