lua之诡异的tonumber

最新推荐文章于 2024-03-04 16:23:42 发布
最新推荐文章于 2024-03-04 16:23:42 发布
阅读量1.6w 收藏 2
点赞数 2
分类专栏： lua 文章标签： lua tonumber 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19079937/article/details/51906159
版权 
昨晚翻看lua源码的时候，发现在luaO_str2num有特殊处理，确切来说是在l_str2int(字符串转换成整形),lstr2d(字符串转换成double类型)
size_t luaO_str2num (const char *s, TValue *o) {
  lua_Integer i; lua_Number n;
  const char *e;
  if ((e = l_str2int(s, &i)) != NULL) {  /* try as an integer */
    setivalue(o, i);
  }
  else if ((e = l_str2d(s, &n)) != NULL) {  /* else try as a float */
    setfltvalue(o, n);
  }
  else
    return 0;  /* conversion failed */
  return (e - s) + 1;  /* success; return string size */
}

我们以l_str2int为例，看看有哪些特殊的处理：

static const char *l_str2int (const char *s, lua_Integer *result) {
  lua_Unsigned a = 0;
  int empty = 1;
  int neg;
  while (lisspace(cast_uchar(*s))) s++;  /* 跳过‘空格’ */
  neg = isneg(&s);
  if (s[0] == '0' &&
      (s[1] == 'x' || s[1] == 'X')) {  /* 十六进制处理 */
    s += 2;  /* skip '0x' */
    for (; lisxdigit(cast_uchar(*s)); s++) {
      a = a * 16 + luaO_hexavalue(*s);
      empty = 0;
    }
  }
  else {  /* 十进制处理 */
    for (; lisdigit(cast_uchar(*s)); s++) {
      a = a * 10 + *s - '0';
      empty = 0;
    }
  }
  while (lisspace(cast_uchar(*s))) s++;  /*跳过尾部‘空格’*/
  if (empty || *s != '\0') return NULL;  /* empty为真，或者跳过‘空格’后没有到达字符串末尾，则转换失败 */
  else {
    *result = l_castU2S((neg) ? 0u - a : a);
    return s;
  }
}
上面在空格加了单引号，此空格非真的‘ ’空格。我们来看看lisspace的实现就知道真相了： 

#define ALPHABIT	0
#define DIGITBIT	1
#define PRINTBIT	2
#define SPACEBIT	3
#define XDIGITBIT	4 


#define MASK(B)		(1 << (B))

#define testprop(c,p)	(luai_ctype_[(c)+1] & (p))

#define lislalpha(c)	testprop(c, MASK(ALPHABIT))
#define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
#define lisdigit(c)	testprop(c, MASK(DIGITBIT))
#define lisspace(c)	testprop(c, MASK(SPACEBIT))
#define lisprint(c)	testprop(c, MASK(PRINTBIT))
#define lisxdigit(c)	testprop(c, MASK(XDIGITBIT)) 

const lu_byte luai_ctype_[UCHAR_MAX + 2];

luai_ctype是一个258的uchar数组，其luai_ctype[1:256]分表对应ascii值。通过MASK宏位移后，‘空格’表示8(1<<3)，那么luai_ctype中的值&8不为0，就表示是空格。红色部分已经标出是空格部分。分别对应ASCII表中的\t,\n,\v,\f,\r,空格(ascii为32，真正空格)。 

const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
  0x00,  /* EOZ */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
  0x00,  <span style="color:#ff0000;">0x08,  0x08,  0x08,  0x08,  0x08</span>,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  <span style="color:#ff0000;">0x0c</span>,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */
  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */
  0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */
  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */
  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,
  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */
  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */
  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
};
从上面分析可知，在tonumber这样的函数中，会跳过‘空格’。验证如下：


这只是代码中的一部分，校验的部分没有写出来。我准备通读lua代码，有问题欢迎讨论。QQ群：570924676

用生命写代码--码农的命
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用 xls_to_lua.lua 把 xls 解析成 lua table
10-01
解析文件使用 lua 编写，把 *.xls 解析成 lua table，双击 run.bat 文件值行解析，支持多子表解析，键值对 k/v 解析。 例子说明：https://blog.csdn.net/qq_26117171/article/details/127131168 支持解析的数据类型： number、int、double、float、short、string、table、object、array、bool、boolean 文件夹说明： excel xls 表文件夹（第一行说明，第二行类型，第三行字段名） output 输出文件夹 rule 解析规则文件夹 zip 包里有例子，有 lua 环境安装包，例子.png图片
lua-resty-worker-events:Nginx在Pure Lua中的跨工作者事件
05-22
lua-resty-worker-事件 Nginx工作进程的进程间事件 目录 register_weak 取消注册 安装 错误和补丁 作者 版权和许可 历史 也可以看看 地位 该库已准备就绪。 概要 http { lua_package_path "/path/to/lua-resty-worker-events/lib/?.lua;;" ; # the size depends on the number of event to handle: lua_shared_dict process_events 1m ; init_worker_by_lua_block { local ev = require "resty.worker.events" local handler = function(data, eve
黑马点评 attempt to compare nil with number
最新发布
weixin_51510703的博客
03-04 275
黑马点评p70运行lua脚本报错
lua-resty-upstream-healthcheck:Pure Lua中Nginx上游服务器的运行状况检查器
05-13
名称 lua-resty-upstream-healthcheck-Nginx上游服务器的运行状况检查器 目录 作者 版权和许可 也可以看看 地位 该库仍在早期开发中，但已经可以投入生产了。 概要 http { lua_package_path "/path/to/lua-resty-upstream-healthcheck/lib/?.lua;;" ; # sample upstream block: upstream foo.com { server 127.0.0.1:12354; server 127.0.0.1:12355; server 127.0.0.1:12356 backup; } # the size depends on the number of servers in up
Lua 错误处理
01-03
Lua 错误处理 程序运行中错误处理是必要的，在我们进行文件操作，数据转移及web service 调用过程中都会出现不可预期的错误。如果不注重错误信息的处理，就会造成信息泄露，程序无法运行等情况。 任何程序语言中，都需要错误处理。错误类型有： 语法错误 运行错误 语法错误 语法错误通常是由于对程序的组件（如运算符、表达式）使用不当引起的。一个简单的实例如下： -- test.lua 文件 a == 2 以上代码执行结果为： lua: test.lua:2: syntax error near '==' 正如你所看到的，以上出现了语法错误，一个 “=” 号跟两个 “=” 号是有区别
Enum.lua：Lua可用的枚举
02-12
枚举 Lua的不可变枚举类型。 用法 local Enum = require " enum " -- Enums can be created like so: local Number = Enum ( " Zero " , " One " , " Two " , " Three " ) -- To control the starting value of an enum, the first value can be set. local States = Enum ({ [ " Paused " ] = - 1 , -- Our enum will now start at -1 instead of 0. " Active " , -- > 0 " Win " , -- > 1 " Lose " ,
lua tonumber
weixin_30471065的博客
04-10 6628
【1】应用tonumber函数 1 local function test(telnum) 2 local isLen = string.len(telnum) > 0 and string.len(telnum) < 7 and string.len(telnum) ~= 4 3 local value = tonumber(string.sub(t...
lua 把string变量转换为整数
servepeople的博客
09-19 877
请注意，如果字符串包含非数字字符，或者是浮点数表示（带有小数点），则转换可能会失败，返回。如果字符串可以成功转换为整数，它将返回整数值，否则返回。进行转换之前，最好确保字符串中只包含有效的整数表示。函数将一个字符串变量转换为整数。在 Lua 中，你可以使用。在上面的示例中，我们使用。
Lua基础语法之 —— tonumber和tostring
qq_57693806的博客
05-25 932
另外，把数字和空字符串连接起来，也可以达到。把字符串转换为数字，而。则把数字转换为字符串。
lua基础函数 type,tonumber,tostring,pcall,print
热门推荐
戴磊的博客
05-11 3万+
原文地址http://www.daileinote.com/computer/lua/10type(v) 用来判断v的类型 返回字符串"nil", "number", "string", "boolean", "table", "function", "thread", "userdata" tonumber(e [,base]) 把e(必须为数字或者是可以转成数字的字符串)转成10进...
lua基本库函数总结
Learn and live
12-11 2128
lua库函数 lua5.2官网手册：Lua 5.2 Reference Manual：http://www.lua.org/manual/5.2/（基本函数参考第6章节） lua所有文档：lua Documentation :http://www.lua.org/docs.html assert (v [, message]) 功能：相当于C的断言，
LuaUnicode icu-lua
08-23
来源： http://lua-users.org/wiki/LuaUnicode 目录： | LuaUnicode.url | +---0.13A | ICU4Lua-0.13A-src.zip | ICU4Lua-0.13A-win32-dll.zip | \---0.2B ICU4Lua-0.2B-docs.zip ICU4Lua-0.2B-src.zip ICU4Lua-0.2B-win32dll.zip 下面的来源于： http://lua-users.org/wiki/LuaUnicode This is an attempt to answer the LuaFaq : Can I use unicode strings? or Does Lua support unicode? In short, yes and no. Lua gives you the bare bones support and enough rope and not much else. Unicode is a large and complex standard and questions like "does lua support unicode" are extremely vague. Some of the issues are: Can I store and retrieve Unicode strings? Can my Lua programs be written in Unicode? Can I compare Unicode strings for equality? Sorting strings. Pattern matching. Can I determine the length of a Unicode string? Support for bracket matching, bidirectional printing, arbitrary composition of characters, and other issues that arise in high quality typesetting. Lua strings are fully 8-bit clean, so simple uses are supported (like storing and retrieving), but there's no built in support for more sophisticated uses. For a fuller story, see below. Unicode strings and Lua strings A Lua string is an aribitrary sequence of values which have at least 8 bits (octets); they map directly into the char type of the C compiler. (This may be wider than eight bits, but eight bits are guaranteed.) Lua does not reserve any value, including NUL. That means that you can store a UTF-8 string in Lua without problems. Note that UTF-8 is just one option for storing Unicode strings. There are many other encoding schemes, including UTF-16 and UTF-32 and their various big-endian/little-endian variants. However, all of these are simply sequences of octets and can be stored in a Lua string without problems. Input and output of strings in Lua (using the io library) uses C's stdio library. ANSI C does not require the stdio library to handle arbitrary octet sequences unless the file is opened in binary mode; furthermore, in non-binary mode, some octet sequences are converted into other ones (in order to deal with varying end-of-line markers on different platforms). This may affect your ability to do non-binary file input and output of Unicode strings in formats other than UTF-8. UTF-8 strings will probably be safe because UTF-8 does not use control characters such as \n and \r as part of multi-octet encodings. However, there are no guarantees; if you need to be certain, you must use binary mode input and output. (If you do so, line-endings will not be converted.) Unix file IO has been 8-bit clean for a long while. If you are not concerned with portability and are only using Unix and Unix-like operating systems, you can almost certainly not worry about the above. If your use of Unicode is restricted to passing the strings to external libraries which support Unicode, you should be OK. For example, you should be able to extract a Unicode string from a database and pass it to a Unicode-aware graphics library. But see the sections below on pattern matching and string equality. Unicode Lua programs Literal Unicode strings can appear in your lua programs. Either a UTF-8 encoded string can appear directly with 8-bit characters or you can use the \ddd syntax (note that ddd is a decimal number, unlike some other languages). However, there is no facility for encoding multi-octet sequences (such as \U+20B4); you would need to either manually encode them to UTF-8, or insert individual octets in the correct big-endian/little-endian order (for UTF-16 or UTF-32). Unless you are using an operating system in which a char is more than eight bits wide, you will not be able to use arbitrary Unicode characters in Lua identifers (for the names of variables and so on). You may be able to use eight-bit characters outside of the ANSI range. Lua uses the C functions isalpha and isalnum to identify valid characters in identifiers, so it will depend on the current locale. To be honest, using characters outside of the ANSI range in Lua identifiers is not a good idea, since your programs will not compile in the standard C locale. Comparison and Sorting Lua string comparison (using the == operator) is done byte-by-byte. That means that == can only be used to compare Unicode strings for equality if the strings have been normalized in one of the four Unicode normalizations. (See the [Unicode FAQ on normalization] for details.) The standard Lua library does not provide any facility for normalizing Unicode strings. Consequently, non-normalized Unicode strings cannot be reliably used as table keys. If you want to use the Unicode notion of string equality, or use Unicode strings as table keys, and you cannot guarantee that your strings are normalized, then you'll have to write or find a normalization function and use that; this is non-trivial exercise! The Lua comparison operators on strings (< and <=) use the C function strcoll which is locale dependent. This means that two strings can compare in different ways according to what the current locale is. For example, strings will compare differently when using Spanish Traditional sorting to that when using Welsh sorting. It may be that your operating system has a locale that implements the sorting algorithm that you want, in which case you can just use that, otherwise you will have to write a function to sort Unicode strings. This is an even more non-trivial exercise. UTF-8 was designed so that a naive octet-by-octet string comparison of an octet sequence would produce the same result if a naive octet-by-octet string comparison were done on the UTF-8 encoding of the octet sequence. This is also true of UTF-32BE but I do not know of any system which uses that encoding. Unfortunately, naive octet-by-octet comparison is not the collation order used by any language. (Note: sometimes people use the terms UCS-2 and UCS-4 for "two-byte" and four-byte encodings. These are not Unicode standards; they come from the closely corresponding ISO standard ISO/IEC 10646-1:2000 and currently differ in that they allow codes outside of the Unicode range, which runs from 0x0 to 0x10FFFF.) Pattern Matching Lua's pattern matching facilities work character by character. In general, this will not work for Unicode pattern matching, although some things will work as you want. For example, "%u" will not match all Unicode upper case letters. You can match individual Unicode characters in a normalized Unicode string, but you might want to worry about combining character sequences. If there are no following combining characters, "a" will match only the letter a in a UTF-8 string. In UTF-16LE you could match "a%z". (Remember that you cannot use \0 in a Lua pattern.) Length and string indexing If you want to know the length of a Unicode string there are different answers you might want according to the circumstances. If you just want to know how many bytes the string occupies, so that you can make space for copying it into a buffer for example, then the existing Lua function string.len will work. You might want to know how many Unicode characters are in a string. Depending on the encoding used, a single Unicode character may occupy up to four bytes. Only UTF-32LE and UTF-32BE are constant length encodings (four bytes per character); UTF-32 is mostly a constant length encoding but the first element in a UTF-32 sequence should be a "Byte Order Mark", which does not count as a character. (UTF-32 and variants are part of Unicode with the latest version, Unicode 4.0.) Some implementations of UTF-16 assume that all characters are two bytes long, but this has not been true since Unicode version 3.0. Happily UTF-8 is designed so that it is relatively easy to count the number of unicode symbols in a string: simply count the number of octets that are in the ranges 0x00 to 0x7f (inclusive) or 0xC2 to 0xF4 (inclusive). (In decimal, 0-127 and 194-244.) These are the codes which can start a UTF-8 character code. Octets 0xC0, 0xC1 and 0xF5 to 0xFF (192, 193 and 245-255) cannot appear in a conforming UTF-8 sequence; octets in the range 0x80 to 0xBF (128-191) can only appear in the second and subsequent octets of a multi-octet encoding. Remember that you cannot use \0 in a Lua pattern. For example, you could use the following code snippet to count UTF-8 characters in a string you knew to be conforming (it will incorrectly count some invalid characters): local _, count = string.gsub(unicode_string, "[^\128-\193]", "") If you want to know how many printing columns a Unicode string will occupy when you print it out using a fixed-width font (imagine you are writing something like the Unix ls program that formats its output into several columns), then that is a different answer again. That's because some Unicode characters do not have a printing width, while others are double-width characters. Combining characters are used to add accents to other letters, and generally they do not take up any extra space when printed. So that's at least 3 different notions of length that you might want at different times. Lua provides one of them (string.len) the others you'll need to write functions for. There's a similar issue with indexing the characters of a string by position. string.sub(s, -3) will return the last 3 bytes of the string which is not necessarily the same as the last three characters of the string, and may or may not be a complete code. You could use the following code snippet to iterate over UTF-8 sequences (this will simply skip over most invalid codes): for uchar in string.gfind(ustring, "([%z\1-\127\194-\244][\128-\191]*)") do -- something end More sophisticated issues As you might have guessed by now, Lua provides no support for things like bidirectional printing or the proper formatting of Thai accents. Normally such things will be taken care of by a graphics or typography library. It would of course be possible to interface to such a library that did these things if you had access to one. There is a little string-like package [slnunicode] with upper/lower, len/sub and pattern matching for UTF-8. See ValidateUnicodeString for a smaller library. [ICU4Lua] is a Lua binding to ICU (International Components for Unicode [1]), an open-source library originally developed by IBM. See UnicodeIdentifers for platform independent Unicode Lua programs.
wrong number of arguments for function call
binqiang2wang
03-04 1082
运行代码的时候，遇到了这个问题： /home/user2/torch/install/bin/luajit: /home/user2/torch/install/share/lua/5.1/nn/THNN.lua:110: wrong number of arguments for function call stack traceback: [C]: in function ‘v’ /home/...
LuaJIT 常量数组（constant array）
七妹的博客
03-17 639
Lua source中出现的常量依次是131072、262144、1310721、131072，它们均为const number，所以在解析时将131072放在了索引0处，262144放在了索引1处，1310721放在了索引2处，解析到第二个131072时，发现该常量已经出现过且在索引0处，此时只需要将0放在操作数D上即可（中Node结构体，val和上面说过的TValue数组的索引对应，作为常量表slot，key则是常量值或字符串的sid，next存放下一个元素的地址。HashTable节点类型的定义是。
go语言+lua5.1语言同步到es中遇到大数字导致精度丢失问题
csdn,码农
05-07 919
lua5.3之前都会有这个问题。但是目前我们使用的go嵌入lua使用的解释器只有5.1所以这个只能靠自己转换解决。目前是用在go+lua同步es的工具上。 解决方式分这几个步骤： 1.go将传递给lua的14-20位的数字转换为字符串 2.lua调用go往es中塞数据时再次逆转为数字，便可以保证es中 本地数据库中都是数字了，而且不丢失精度。 比较简单。以下给部分代码demo go往lua中传值类型的处理 func paddingTable(l *lua.LState, table..
Lua 数据类型
类人_猿的博客
10-23 559
Lua 数据类型 Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。 Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。 数据类型 描述 nil 这个最简单，只有值nil术语该类，表示一个无效值（在条件表达式中相当于fals...
lua浮点型取整型
FightIngWork的博客
04-13 1万+
LUA 浮点型转整型 lua脚本语言不像C语言一样，整型除以整型结果为整型。lua得出的结果是浮点型，有时会用到整型，所以必须进行取整。直接上代码： function FloatToInt(s)–输入参数为浮点型，整型都可 local i local j local q local temp i = tostring(s) j= string.find(i,"%.",1) if j~=nil an...
【Lua基础系列】之类型与值（nil，number，boolean）详细版--Lua类型转换，取整，产生随机数
Lampard的博客
04-10 6183
【Lua基础系列】之类型与值详细版 大家好，我是Lampard~~ 为了方便自己的学习以及分享学到的内容，所以我即将要开设Lua基础系列的博客 PS：本博客知识参考资料为：《Lua程序设计第四版》，该书由Lua的创始人2018年所编著，所以大家可以放心去吸收知识 话不多说，开始第一讲的...
lua 取字符串中的数字
m0_66743375的博客
10-28 1233
lua 取字符串中的数字
lua脚本 tonumber
08-26
在Lua脚本中，tonumber函数用于将一个值转换为对应的数值类型。根据引用[1]所述，Lua中的tonumber函数可以将一个数字转换为适当的类型。具体来说，该函数可以将字符串转换为其对应的数值表示，并返回转换后的结果。如果转换失败，函数则返回nil。因此，通过使用Lua脚本中的tonumber函数，你可以将字符串转换为数值类型。<span class="em">1</span> #### 引用[.reference_title] - *1* [script-engine:Lua 中的脚本引擎](https://download.csdn.net/download/weixin_42101164/20351452)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值