V8定义全局对象

最新推荐文章于 2022-06-13 19:51:09 发布
最新推荐文章于 2022-06-13 19:51:09 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： VC and C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdhongjun/article/details/52142349
版权

1.准备导出C++类

class Point
{
public:
    Point(int x, int y) : x_(x), y_(y) { }
    int x_, y_;
};

2.设置JS访问类成员函数

void GetPointX(Local<String> property,
               const PropertyCallbackInfo<Value>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    int value = static_cast<Point*>(ptr)->x_;
    info.GetReturnValue().Set(value);
}

void SetPointX(Local<String> property, Local<Value> value,
               const PropertyCallbackInfo<void>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    static_cast<Point*>(ptr)->x_ = value->Int32Value();
}

void GetPointY(Local<String> property,
               const PropertyCallbackInfo<Value>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    int value = static_cast<Point*>(ptr)->y_;
    info.GetReturnValue().Set(value);
}

void SetPointY(Local<String> property, Local<Value> value,
               const PropertyCallbackInfo<void>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    static_cast<Point*>(ptr)->y_ = value->Int32Value();
}

3.定义导出C++对象函数

void AddPointObj(Isolate *isolate, Handle<Context> &context)
{
    Handle<FunctionTemplate>    point_templ = FunctionTemplate::New();
    Handle<ObjectTemplate>      point_inst = point_templ->InstanceTemplate();
    point_inst->SetInternalFieldCount(1);;

    point_inst->SetAccessor(String::New("x"), GetPointX, SetPointX);
    point_inst->SetAccessor(String::New("y"), GetPointY, SetPointY);

    Handle<Function> point_ctor = point_templ->GetFunction();
    Local<Object> obj = point_ctor->NewInstance();

    Point *pt = new Point(15, 20);
    obj->SetInternalField(0, External::New(pt));

    context->Global()->Set(String::NewFromUtf8(isolate, "point"), obj);
}

4.调用导出对象函数

int main(int argc, char* argv[])
{
    V8::InitializeICU();
    //V8::SetFlagsFromCommandLine(&argc, argv, true);
    Isolate* isolate = Isolate::GetCurrent();
    run_shell = (argc == 1);
    int result;
    {
        HandleScope handle_scope(isolate);
        Handle<Context> context = CreateShellContext(isolate);
        if (context.IsEmpty())
        {
            fprintf(stderr, "Error creating context\n");
            return 1;
        }
        context->Enter();
        //调用导出对象函数
        AddPointObj(isolate, context);
        result = RunMain(isolate, argc, argv);
        if (run_shell) RunShell(context);
        context->Exit();
    }
    V8::Dispose();

    return 0;
}

5.完整代码

#include "v8/include/v8.h"
#include <assert.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#pragma comment(lib, "v8/lib/v8")

using namespace v8;

Handle<Context> CreateShellContext(Isolate* isolate);
void RunShell(Handle<Context> context);
int RunMain(Isolate* isolate, int argc, char* argv[]);
bool ExecuteString(Isolate* isolate,
                   Handle<String> source,
                   Handle<Value> name,
                   bool print_result,
                   bool report_exceptions);
void Print(const FunctionCallbackInfo<Value>& args);
void Read(const FunctionCallbackInfo<Value>& args);
void Load(const FunctionCallbackInfo<Value>& args);
void Quit(const FunctionCallbackInfo<Value>& args);
void Version(const FunctionCallbackInfo<Value>& args);
Handle<String> ReadFile(const char* name);
void ReportException(Isolate* isolate, TryCatch* handler);

void AddPointObj(Isolate *isolate, Handle<Context> &context);

static bool run_shell = false;

int main(int argc, char* argv[])
{
    V8::InitializeICU();
    //V8::SetFlagsFromCommandLine(&argc, argv, true);
    Isolate* isolate = Isolate::GetCurrent();
    run_shell = (argc == 1);
    int result;
    {
        HandleScope handle_scope(isolate);
        Handle<Context> context = CreateShellContext(isolate);
        if (context.IsEmpty())
        {
            fprintf(stderr, "Error creating context\n");
            return 1;
        }
        context->Enter();
        AddPointObj(isolate, context);
        result = RunMain(isolate, argc, argv);
        if (run_shell) RunShell(context);
        context->Exit();
    }
    V8::Dispose();

    return 0;
}

class Point
{
public:
    Point(int x, int y) : x_(x), y_(y) { }
    int x_, y_;
};

void GetPointX(Local<String> property,
               const PropertyCallbackInfo<Value>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    int value = static_cast<Point*>(ptr)->x_;
    info.GetReturnValue().Set(value);
}

void SetPointX(Local<String> property, Local<Value> value,
               const PropertyCallbackInfo<void>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    static_cast<Point*>(ptr)->x_ = value->Int32Value();
}

void GetPointY(Local<String> property,
               const PropertyCallbackInfo<Value>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    int value = static_cast<Point*>(ptr)->y_;
    info.GetReturnValue().Set(value);
}

void SetPointY(Local<String> property, Local<Value> value,
               const PropertyCallbackInfo<void>& info)
{
    Local<Object> self = info.Holder();
    Local<External> wrap = Local<External>::Cast(self->GetInternalField(0));
    void* ptr = wrap->Value();
    static_cast<Point*>(ptr)->y_ = value->Int32Value();
}

void AddPointObj(Isolate *isolate, Handle<Context> &context)
{
    Handle<FunctionTemplate>    point_templ = FunctionTemplate::New();
    Handle<ObjectTemplate>      point_inst = point_templ->InstanceTemplate();
    point_inst->SetInternalFieldCount(1);;

    point_inst->SetAccessor(String::New("x"), GetPointX, SetPointX);
    point_inst->SetAccessor(String::New("y"), GetPointY, SetPointY);

    Handle<Function> point_ctor = point_templ->GetFunction();
    Local<Object> obj = point_ctor->NewInstance();

    Point *pt = new Point(15, 20);
    obj->SetInternalField(0, External::New(pt));

    context->Global()->Set(String::NewFromUtf8(isolate, "point"), obj);
}

// Extracts a C string from a V8 Utf8Value.
const char* ToCString(const String::Utf8Value& value)
{
    return *value ? *value : "<string conversion failed>";
}


// Creates a new execution environment containing the built-in
// functions.
Handle<Context> CreateShellContext(Isolate* isolate)
{
    // Create a template for the global object.
    Handle<ObjectTemplate> global = ObjectTemplate::New();
    // Bind the global 'print' function to the C++ Print callback.
    global->Set(String::New("print"), FunctionTemplate::New(Print));
    // Bind the global 'read' function to the C++ Read callback.
    global->Set(String::New("read"), FunctionTemplate::New(Read));
    // Bind the global 'load' function to the C++ Load callback.
    global->Set(String::New("load"), FunctionTemplate::New(Load));
    // Bind the 'quit' function
    global->Set(String::New("quit"), FunctionTemplate::New(Quit));
    // Bind the 'version' function
    global->Set(String::New("version"), FunctionTemplate::New(Version));

    return Context::New(isolate, NULL, global);
}


// The callback that is invoked by v8 whenever the JavaScript 'print'
// function is called.  Prints its arguments on stdout separated by
// spaces and ending with a newline.
void Print(const FunctionCallbackInfo<Value>& args)
{
    bool first = true;
    for (int i = 0; i < args.Length(); i++)
    {
        HandleScope handle_scope(args.GetIsolate());
        if (first)
        {
            first = false;
        }
        else
        {
            printf(" ");
        }
        String::Utf8Value str(args[i]);
        const char* cstr = ToCString(str);
        printf("%s", cstr);
    }
    printf("\n");
    fflush(stdout);
}


// The callback that is invoked by v8 whenever the JavaScript 'read'
// function is called.  This function loads the content of the file named in
// the argument into a JavaScript string.
void Read(const FunctionCallbackInfo<Value>& args)
{
    if (args.Length() != 1)
    {
        ThrowException(String::New("Bad parameters"));
        return;
    }
    String::Utf8Value file(args[0]);
    if (*file == NULL)
    {
        ThrowException(String::New("Error loading file"));
        return;
    }
    Handle<String> source = ReadFile(*file);
    if (source.IsEmpty())
    {
        ThrowException(String::New("Error loading file"));
        return;
    }
    args.GetReturnValue().Set(source);
}


// The callback that is invoked by v8 whenever the JavaScript 'load'
// function is called.  Loads, compiles and executes its argument
// JavaScript file.
void Load(const FunctionCallbackInfo<Value>& args)
{
    for (int i = 0; i < args.Length(); i++)
    {
        HandleScope handle_scope(args.GetIsolate());
        String::Utf8Value file(args[i]);
        if (*file == NULL)
        {
            ThrowException(String::New("Error loading file"));
            return;
        }
        Handle<String> source = ReadFile(*file);
        if (source.IsEmpty())
        {
            ThrowException(String::New("Error loading file"));
            return;
        }
        if (!ExecuteString(args.GetIsolate(),
                           source,
                           String::New(*file),
                           false,
                           false))
        {
            ThrowException(String::New("Error executing file"));
            return;
        }
    }
}


// The callback that is invoked by v8 whenever the JavaScript 'quit'
// function is called.  Quits.
void Quit(const FunctionCallbackInfo<Value>& args)
{
    // If not arguments are given args[0] will yield undefined which
    // converts to the integer value 0.
    int exit_code = args[0]->Int32Value();
    fflush(stdout);
    fflush(stderr);
    exit(exit_code);
}


void Version(const FunctionCallbackInfo<Value>& args)
{
    args.GetReturnValue().Set(String::New(V8::GetVersion()));
}


// Reads a file into a v8 string.
Handle<String> ReadFile(const char* name)
{
    FILE* file = fopen(name, "rb");
    if (file == NULL) return Handle<String>();

    fseek(file, 0, SEEK_END);
    int size = ftell(file);
    rewind(file);

    char* chars = new char[size + 1];
    chars[size] = '\0';
    for (int i = 0; i < size;)
    {
        int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
        i += read;
    }
    fclose(file);
    Handle<String> result = String::New(chars, size);
    delete[] chars;
    return result;
}


// Process remaining command line arguments and execute files
int RunMain(Isolate* isolate, int argc, char* argv[])
{
    for (int i = 1; i < argc; i++)
    {
        const char* str = argv[i];
        if (strcmp(str, "--shell") == 0)
        {
            run_shell = true;
        }
        else if (strcmp(str, "-f") == 0)
        {
            // Ignore any -f flags for compatibility with the other stand-
            // alone JavaScript engines.
            continue;
        }
        else if (strncmp(str, "--", 2) == 0)
        {
            fprintf(stderr,
                    "Warning: unknown flag %s.\nTry --help for options\n", str);
        }
        else if (strcmp(str, "-e") == 0 && i + 1 < argc)
        {
            // Execute argument given to -e option directly.
            Handle<String> file_name = String::New("unnamed");
            Handle<String> source = String::New(argv[++i]);
            if (!ExecuteString(isolate, source, file_name, false, true)) return 1;
        }
        else
        {
            // Use all other arguments as names of files to load and run.
            Handle<String> file_name = String::New(str);
            Handle<String> source = ReadFile(str);
            if (source.IsEmpty())
            {
                fprintf(stderr, "Error reading '%s'\n", str);
                continue;
            }
            if (!ExecuteString(isolate, source, file_name, false, true)) return 1;
        }
    }
    return 0;
}


// The read-eval-execute loop of the shell.
void RunShell(Handle<Context> context)
{
    fprintf(stderr, "V8 version %s [sample shell]\n", V8::GetVersion());
    static const int kBufferSize = 256;
    // Enter the execution environment before evaluating any code.
    Context::Scope context_scope(context);
    Local<String> name(String::New("(shell)"));
    while (true)
    {
        char buffer[kBufferSize];
        fprintf(stderr, "> ");
        char* str = fgets(buffer, kBufferSize, stdin);
        if (str == NULL) break;
        HandleScope handle_scope(context->GetIsolate());
        ExecuteString(context->GetIsolate(),
                      String::New(str),
                      name,
                      true,
                      true);
    }
    fprintf(stderr, "\n");
}


// Executes a string within the current v8 context.
bool ExecuteString(Isolate* isolate,
                   Handle<String> source,
                   Handle<Value> name,
                   bool print_result,
                   bool report_exceptions)
{
    HandleScope handle_scope(isolate);
    TryCatch try_catch;
    Handle<Script> script = Script::Compile(source, name);
    if (script.IsEmpty())
    {
        // Print errors that happened during compilation.
        if (report_exceptions)
            ReportException(isolate, &try_catch);
        return false;
    }
    else
    {
        Handle<Value> result = script->Run();
        if (result.IsEmpty())
        {
            assert(try_catch.HasCaught());
            // Print errors that happened during execution.
            if (report_exceptions)
                ReportException(isolate, &try_catch);
            return false;
        }
        else
        {
            assert(!try_catch.HasCaught());
            if (print_result && !result->IsUndefined())
            {
                // If all went well and the result wasn't undefined then print
                // the returned value.
                String::Utf8Value str(result);
                const char* cstr = ToCString(str);
                printf("%s\n", cstr);
            }
            return true;
        }
    }
}


void ReportException(Isolate* isolate, TryCatch* try_catch)
{
    HandleScope handle_scope(isolate);
    String::Utf8Value exception(try_catch->Exception());
    const char* exception_string = ToCString(exception);
    Handle<Message> message = try_catch->Message();
    if (message.IsEmpty())
    {
        // V8 didn't provide any extra information about this error; just
        // print the exception.
        fprintf(stderr, "%s\n", exception_string);
    }
    else
    {
        // Print (filename):(line number): (message).
        String::Utf8Value filename(message->GetScriptResourceName());
        const char* filename_string = ToCString(filename);
        int linenum = message->GetLineNumber();
        fprintf(stderr, "%s:%i: %s\n", filename_string, linenum, exception_string);
        // Print line of source code.
        String::Utf8Value sourceline(message->GetSourceLine());
        const char* sourceline_string = ToCString(sourceline);
        fprintf(stderr, "%s\n", sourceline_string);
        // Print wavy underline (GetUnderline is deprecated).
        int start = message->GetStartColumn();
        for (int i = 0; i < start; i++)
        {
            fprintf(stderr, " ");
        }
        int end = message->GetEndColumn();
        for (int i = start; i < end; i++)
        {
            fprintf(stderr, "^");
        }
        fprintf(stderr, "\n");
        String::Utf8Value stack_trace(try_catch->StackTrace());
        if (stack_trace.length() > 0)
        {
            const char* stack_trace_string = ToCString(stack_trace);
            fprintf(stderr, "%s\n", stack_trace_string);
        }
    }
}

代码下载

文件源代码
注意：源代码使用CodeBlocks建立的工程使用VS2005/VS2008编译环境进行编译，如需要VS工程请手动生成。

参考文献

Using V8 - Google’s Chrome JavaScript Virtual Machine
使用 Google V8 引擎开发可定制的应用程序
GoogleV8Tutorials
V8Demo

sdhongjun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
v8学习---获取全局对象成员
headool的专栏
11-05 1102
参考：http://iammr.7.blog.163.com/blog/static/49102699201201565822189/ 获取全局对象成员 #include using namespace v8; int main() { Isolate* isolate = Isolate::GetCurrent(); HandleScope handleScope(isolate);
Node.js And C++__5.对象转换
nihaoweixiao的博客
07-17 546
5.对象转换 ​ 有很多底层的机制，将C++函数暴露给JavaScript程序。接下来我们看C++对象如果暴露给JavaScript。类(对象)服务于将数据和方法组织成单个编程单元的主要目的。类包含状态(成员变量)和可以对它们进行操作的方法(成员函数)。JavaScript当然也有类，但不幸的是，没有无缝的方法可以简单地使用现有的C++类/对象，并让JavaScript处理它。这意味着add...
图解 Google V8 # 07：作用域链：V8是如何查找变量的？
学习前端这门手艺，栈底到栈顶依次是：浏览器架构、Web 网络、事件循环机制、JavaScript 核心、V8 的内存管理、浏览器的渲染流程、Web 安全、CSS、React、Vue、Node、构建工具链等
06-13 461
图解 Google V8 学习笔记作用域就是存放变量和函数的地方，作用域链就是将一个个作用域串起来，实现变量查找的路径。例子1： 输出结果如下：name 的值为 foo，这个应该没什么疑问，但是 type 的值为 global，可能大家会有疑问，为什么不是 function，输出 global 的原因是什么 ？下面先了解一下作用域的工作原理。例子2： 我们在控制台输入上面代码，可以看到在 debugger 的时候，右侧的 Scope 项里有 Local，这个就是当前函数 kaimo_scope 的作用域。发
V8编程详解
顺其自然~专栏
02-06 1384
这里选用了官方文档的一个非常简洁的HelloWorld.cc，代码如下： #include <v8.h> using namespace v8; int main(int argc, char* argv[]) { // Create a stack-allocated handle scope. HandleScope handle_scope; // Create a new context. Persistent<Context> context
v8 知识点
hgl868的专栏
06-17 5420
1.Handle结构   (1)API Handle(v8::handle):含有一个T*对象指针，(实际上是相应内部对象指针的指针)   (2)内部Handle(v8::internal::handle):T**内部对象指针的指针 2.相互转换:   (1)API Handle->内部Handle          v8::internal::Handleinternal::To> U
js引擎v8源码分析之GlobalHandles（基于v8 0.1.5）
标子 的专栏
02-16 504
GlobalHandles是实现v8中持久句柄功能的类。GlobalHandles主要是维护一个链表，每个节点维护堆对象的状态。我们先看看节点的定义。 class GlobalHandles::Node : public Malloced { public: void Initialize(Object* object) { // 指向堆对象地址 object_ = obj...
V8定义全局对象文章代码
08-07
V8引擎以其快速的执行速度和高效的内存管理而著称，其中一个重要概念就是全局对象（Global Object）。这篇文章将深入探讨V8中的全局对象及其相关知识点。 全局对象在JavaScript中扮演着核心角色，它是所有全局变量...
定义全局对象文章代码
08-07
本文将深入探讨全局对象的定义、作用以及与V8引擎的关联。V8是Google开发的一款高性能的JavaScript和WebAssembly虚拟机，广泛应用于Chrome浏览器和Node.js环境中。 全局对象在JavaScript中的主要职责是作为全局变量...
V8调用例子 易语言
09-17
3. 创建V8上下文：在Isolate中创建Context，这代表了一个JavaScript全局对象的环境，每个Context可以有自己的全局变量和作用域。 4. 编译JavaScript代码：使用V8 API将字符串形式的JavaScript代码编译为可执行的...
google v8引擎 x64静态库
11-29
5. **Global Object**：JavaScript的全局对象，是所有全局变量和函数的容器。 为了在C++中使用V8，开发者需要初始化Isolate和Context，然后可以使用V8提供的API创建和执行JavaScript代码，处理数据交互。同时，V8还...
go-v8:Golang的v8 JavaScript引擎绑定
05-22
字符串，对象，数组，正则表达式，函数编译并运行JavaScript 保存并加载预编译的脚本数据使用全局对象模板创建JavaScript上下文在Go中操作JavaScript对象属性和数组元素使用属性访问器和拦截器在Go中定义JavaScript...
V8概念以及编程入门
啊渊的专栏
12-08 2158
v8 知识梳理以及编程入门 学习 v8 编程的好处就是能够知道 node 是如何通过写JavaScript 进行调用系统 API 的，如果你有 c/c++ 又或者是比较底层的语言的基础，研究明白 v8 是如何调用系统底层的，而系统是如何提供函数给 v8 调用的，那么我们对 node 的理解层度就会更上一层楼。 本节主要折腾的几个事情 如何通过 JS 调用 c/c++ 层 如何通过 c/c++ 层调用 JS 层 如何通过 JS 调用 c++ 的类 当我们实现以上的 JS-C/C++ 层的调用时.
v8学习---添加js全局函数
linuxheik的专栏
04-19 833
v8学习---添加js全局函数 标签： v8 2013-11-10 10:11 951人阅读 评论(0) 收藏 举报  分类： v8（12）  版权声明：本文为博主原创文章，未经博主允许不得转载。 [cpp] view plain copy #include    using namespace v
【Nodejs 】Nodejs 概述及常见的全局对象_01
青春木鱼的博客
04-28 3275
全局对象是什么？Node. js 有哪些全局对象？在浏览器JavaScript中，通常window是全局对象， 而Nodejs中的全局对象是global。在NodeJS里，是不可能在最外层定义一个变量，因为所有的用户代码都是当前模块的，只在当前模块里可用，但可以通过exports对象的使用将其传递给模块外部，所以，在NodeJS中，用var声明的变量并不属于全局的变量，只在当前模块生效。真正的全局对象：常见的全局对象有global、console、process、Buffer等等
V8嵌入指南
wenyu826的专栏
02-24 1916
中英文地址：https://github.com/Chunlin-Li/Chunlin-Li.github.io/blob/master/blogs/javascript/V8_Embedder's_Guide_CHS.md 如果你已经阅读了入门指南, 一定知道 V8 是一个独立运行的虚拟机, 其中有些关键性概念比如: handles, scopes 和 contexts. 本文将深入讨论这些概
从v8到C++的数据类型转换
魔阿持袄
03-23 1763
这里说的数据类型指的是基本数据类型（数值、字符、布尔），对象类型实际上也只是基本类型的结构化堆叠而已，对于数据类型的转换我们只要考虑基本类型就够了。而在V8中所有数据类型都继承于Value类的，我们只要知道Value实例如何转换成C++基本类型即可。　　Value类的成员函数中直接就提供了数值型和布尔型的转换函数，直接调用它就可以得到相应的值。但是对于字符串就麻烦了，由于有编码问题，没有在Valu...
chromium中绑定JavaScript层级中的顶层对象Window到v8中的入口
leeeryan
01-12 2475
<br />//chromium中绑定JavaScript 层级中的顶层对象Window到v8中的入口 bool V8DOMWindowShell::installDOMWindow(v8::Handle<v8::Context> context, DOMWindow* window) { //创建一个JS window对象 v8::Handle<v8::Function> windowConstructor = V8DOMWrapper::getConstructor(&V8DOM
JavaScript教程：详解窗口对象属性
窗口对象在JavaScript中扮演着重要角色，它是全局对象，几乎所有的JavaScript全局函数和变量都是窗口对象的一部分。以下详细讨论窗口对象的主要属性： 1. frames 属性：这个属性用于引用HTML文档中的帧（frameset）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sdhongjun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值