备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

修改V8和node.js建立中文后端开发工具

2019-05-09 700
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 修改V8编译器源码, 实现关键词的中文化. Modify source code of V8 JavaScript compiler to support keywords in Chinese.

本文github: https://github.com/swizl/zwnode

一. 修改V8

V8在一个文件里改就行了。

depsv8srcparsingscanner.cc

  1. 从llvm中下一个轮子过来的StringSwitch，当然要改一下。StringRef改成std::wstring, 多余的功能去掉。放在 scanner.cc 开头。

狗屎咖啡：为clang添加中文关键字​

template<typename T, typename R = T>
class StringSwitch {
  std::wstring Str;
  const T *Result;

public:
  //
  explicit StringSwitch(std::wstring S)
  : Str(S), Result(nullptr) { }

  // StringSwitch is not copyable.
  StringSwitch(const StringSwitch &) = delete;
  void operator=(const StringSwitch &) = delete;

  StringSwitch(StringSwitch &&other) {
    *this = std::move(other);
  }
  StringSwitch &operator=(StringSwitch &&other) {
    Str = other.Str;
    Result = other.Result;
    return *this;
  }

  ~StringSwitch() = default;

  // Case-sensitive case matchers
  template<unsigned N>
  StringSwitch& Case(const wchar_t (&S)[N], const T& Value) {
    assert(N);
    if (!Result && N-1 == Str.size() &&
        //(N == 1 || std::memcmp(S, Str.data(), (N-1)*sizeof(wchar_t)) == 0)) {
        (N == 1 || Str.compare(S) == 0)) {
      Result = &Value;
    }
    return *this;
  }

  R Default(const T &Value) const {
    if (Result)
      return *Result;
    return Value;
  }

  
  operator R() const {
    assert(Result && "Fell off the end of a string-switch");
    return *Result;
  }
};
  1. 加上中文的关键字和英文关键字一样对应, 可以根据自己的喜好随便改。
#define KEYWORDS(KEYWORD_GROUP, KEYWORD, ZWKEYWORD)                    \
  KEYWORD_GROUP('a')                                        \
  KEYWORD("arguments", Token::ARGUMENTS)                    \
  ZWKEYWORD("诸参", Token::ARGUMENTS)                    \
  KEYWORD("as", Token::AS)                                  \
  ZWKEYWORD("以", Token::AS)                                  \
  KEYWORD("async", Token::ASYNC)                            \
  ZWKEYWORD("异", Token::ASYNC)                            \
  KEYWORD("await", Token::AWAIT)                            \
  ZWKEYWORD("等", Token::AWAIT)                            \
  KEYWORD("anonymous", Token::ANONYMOUS)                    \
  ZWKEYWORD("匿", Token::ANONYMOUS)                    \
  KEYWORD_GROUP('b')                                        \
  KEYWORD("break", Token::BREAK)                            \
  ZWKEYWORD("破", Token::BREAK)                            \
  KEYWORD_GROUP('c')                                        \
  KEYWORD("case", Token::CASE)                              \
  ZWKEYWORD("例", Token::CASE)                              \
  KEYWORD("catch", Token::CATCH)                            \
  ZWKEYWORD("捕", Token::CATCH)                            \
  KEYWORD("class", Token::CLASS)                            \
  ZWKEYWORD("类", Token::CLASS)                            \
  KEYWORD("const", Token::CONST)                            \
  ZWKEYWORD("常", Token::CONST)                            \
  KEYWORD("constructor", Token::CONSTRUCTOR)                \
  ZWKEYWORD("构造器", Token::CONSTRUCTOR)                \
  KEYWORD("continue", Token::CONTINUE)                      \
  ZWKEYWORD("继", Token::CONTINUE)                      \
  KEYWORD_GROUP('d')                                        \
  KEYWORD("debugger", Token::DEBUGGER)                      \
  ZWKEYWORD("调试器", Token::DEBUGGER)                      \
  KEYWORD("default", Token::DEFAULT)                        \
  ZWKEYWORD("默", Token::DEFAULT)                        \
  KEYWORD("delete", Token::DELETE)                          \
  ZWKEYWORD("删", Token::DELETE)                          \
  KEYWORD("do", Token::DO)                                  \
  ZWKEYWORD("行", Token::DO)                                  \
  KEYWORD_GROUP('e')                                        \
  KEYWORD("else", Token::ELSE)                              \
  ZWKEYWORD("另", Token::ELSE)                              \
  KEYWORD("enum", Token::ENUM)                              \
  ZWKEYWORD("举", Token::ENUM)                              \
  KEYWORD("eval", Token::EVAL)                              \
  ZWKEYWORD("估", Token::EVAL)                              \
  KEYWORD("export", Token::EXPORT)                          \
  ZWKEYWORD("导", Token::EXPORT)                          \
  KEYWORD("extends", Token::EXTENDS)                        \
  ZWKEYWORD("承", Token::EXTENDS)                        \
  KEYWORD_GROUP('f')                                        \
  KEYWORD("false", Token::FALSE_LITERAL)                    \
  ZWKEYWORD("假", Token::FALSE_LITERAL)                    \
  KEYWORD("finally", Token::FINALLY)                        \
  ZWKEYWORD("末", Token::FINALLY)                        \
  KEYWORD("for", Token::FOR)                                \
  ZWKEYWORD("于", Token::FOR)                                \
  KEYWORD("from", Token::FROM)                              \
  ZWKEYWORD("从", Token::FROM)                              \
  KEYWORD("function", Token::FUNCTION)                      \
  ZWKEYWORD("函数", Token::FUNCTION)                      \
  KEYWORD_GROUP('g')                                        \
  KEYWORD("get", Token::GET)                                \
  ZWKEYWORD("取", Token::GET)                                \
  KEYWORD_GROUP('i')                                        \
  KEYWORD("if", Token::IF)                                  \
  ZWKEYWORD("如", Token::IF)                                  \
  KEYWORD("implements", Token::FUTURE_STRICT_RESERVED_WORD) \
  ZWKEYWORD("成", Token::FUTURE_STRICT_RESERVED_WORD) \
  KEYWORD("import", Token::IMPORT)                          \
  ZWKEYWORD("引", Token::IMPORT)                          \
  KEYWORD("in", Token::IN)                                  \
  ZWKEYWORD("在", Token::IN)                                  \
  KEYWORD("instanceof", Token::INSTANCEOF)                  \
  ZWKEYWORD("是为", Token::INSTANCEOF)                  \
  KEYWORD("interface", Token::FUTURE_STRICT_RESERVED_WORD)  \
  ZWKEYWORD("接", Token::FUTURE_STRICT_RESERVED_WORD)  \
  KEYWORD_GROUP('l')                                        \
  KEYWORD("let", Token::LET)                                \
  ZWKEYWORD("让", Token::LET)                                \
  KEYWORD_GROUP('m')                                        \
  KEYWORD("meta", Token::META)                              \
  ZWKEYWORD("元", Token::META)                                \
  KEYWORD_GROUP('n')                                        \
  KEYWORD("name", Token::NAME)                              \
  ZWKEYWORD("名", Token::NAME)                              \
  KEYWORD("new", Token::NEW)                                \
  ZWKEYWORD("新", Token::NEW)                                \
  KEYWORD("null", Token::NULL_LITERAL)                      \
  ZWKEYWORD("无", Token::NULL_LITERAL)                      \
  KEYWORD_GROUP('o')                                        \
  KEYWORD("of", Token::OF)                                  \
  ZWKEYWORD("之", Token::OF)                                  \
  KEYWORD_GROUP('p')                                        \
  KEYWORD("package", Token::FUTURE_STRICT_RESERVED_WORD)    \
  ZWKEYWORD("包", Token::FUTURE_STRICT_RESERVED_WORD)    \
  KEYWORD("private", Token::FUTURE_STRICT_RESERVED_WORD)    \
  ZWKEYWORD("私", Token::FUTURE_STRICT_RESERVED_WORD)    \
  KEYWORD("protected", Token::FUTURE_STRICT_RESERVED_WORD)  \
  ZWKEYWORD("保", Token::FUTURE_STRICT_RESERVED_WORD)  \
  KEYWORD("prototype", Token::PROTOTYPE)                    \
  ZWKEYWORD("原型", Token::PROTOTYPE)                    \
  KEYWORD("public", Token::FUTURE_STRICT_RESERVED_WORD)     \
  ZWKEYWORD("公", Token::FUTURE_STRICT_RESERVED_WORD)     \
  KEYWORD_GROUP('r')                                        \
  KEYWORD("return", Token::RETURN)                          \
  ZWKEYWORD("返", Token::RETURN)                          \
  KEYWORD_GROUP('s')                                        \
  KEYWORD("set", Token::SET)                                \
  ZWKEYWORD("设", Token::SET)                                \
  KEYWORD("static", Token::STATIC)                          \
  ZWKEYWORD("固", Token::STATIC)                          \
  KEYWORD("super", Token::SUPER)                            \
  ZWKEYWORD("超", Token::SUPER)                            \
  KEYWORD("switch", Token::SWITCH)                          \
  ZWKEYWORD("切", Token::SWITCH)                          \
  KEYWORD_GROUP('t')                                        \
  KEYWORD("target", Token::TARGET)                          \
  ZWKEYWORD("标", Token::TARGET)                          \
  KEYWORD("this", Token::THIS)                              \
  ZWKEYWORD("此", Token::THIS)                              \
  KEYWORD("throw", Token::THROW)                            \
  ZWKEYWORD("抛", Token::THROW)                            \
  KEYWORD("true", Token::TRUE_LITERAL)                      \
  ZWKEYWORD("真", Token::TRUE_LITERAL)                      \
  KEYWORD("try", Token::TRY)                                \
  ZWKEYWORD("试", Token::TRY)                                \
  KEYWORD("typeof", Token::TYPEOF)                          \
  ZWKEYWORD("之型", Token::TYPEOF)                          \
  KEYWORD_GROUP('u')                                        \
  KEYWORD("undefined", Token::UNDEFINED)                    \
  ZWKEYWORD("未定", Token::UNDEFINED)                    \
  KEYWORD_GROUP('v')                                        \
  KEYWORD("var", Token::VAR)                                \
  ZWKEYWORD("变", Token::VAR)                                \
  KEYWORD("void", Token::VOID)                              \
  ZWKEYWORD("空", Token::VOID)                              \
  KEYWORD_GROUP('w')                                        \
  KEYWORD("while", Token::WHILE)                            \
  ZWKEYWORD("当", Token::WHILE)                            \
  KEYWORD("with", Token::WITH)                              \
  ZWKEYWORD("为之", Token::WITH)                              \
  KEYWORD_GROUP('y')                                        \
  KEYWORD("yield", Token::YIELD)                            \
  ZWKEYWORD("降", Token::YIELD)                            \
  KEYWORD_GROUP('_')                                        \
  KEYWORD("__proto__", Token::PROTO_UNDERSCORED)            \
  ZWKEYWORD("__原__", Token::PROTO_UNDERSCORED)              \
  KEYWORD_GROUP('#')                                        \
  KEYWORD("#constructor", Token::PRIVATE_CONSTRUCTOR)        \
  ZWKEYWORD("#构造器", Token::PRIVATE_CONSTRUCTOR)

3.仿照KeywordOrIdentifierToken写一个ZWKeywordOrIdentifierToken

static Token::Value KeywordOrIdentifierToken(const uint8_t* input,
                                             int input_length) {
  DCHECK_GE(input_length, 1);
  const int kMinLength = 2;
  const int kMaxLength = 12;
  if (input_length < kMinLength || input_length > kMaxLength) {
    return Token::IDENTIFIER;
  }
  switch (input[0]) {
    default:
#define ZWKEYWORD(keyword, token)
#define KEYWORD_GROUP_CASE(ch)                                \
      break;                                                  \
    case ch:
#define KEYWORD(keyword, token)                                           \
  {                                                                       \
    /* 'keyword' is a char array, so sizeof(keyword) is */                \
    /* strlen(keyword) plus 1 for the NUL char. */                        \
    const int keyword_length = sizeof(keyword) - 1;                       \
    STATIC_ASSERT(keyword_length >= kMinLength);                          \
    STATIC_ASSERT(keyword_length <= kMaxLength);                          \
    DCHECK_EQ(input[0], keyword[0]);                                      \
    DCHECK(token == Token::FUTURE_STRICT_RESERVED_WORD ||                 \
           0 == strncmp(keyword, Token::String(token), sizeof(keyword))); \
    if (input_length == keyword_length && input[1] == keyword[1] &&       \
        (keyword_length <= 2 || input[2] == keyword[2]) &&                \
        (keyword_length <= 3 || input[3] == keyword[3]) &&                \
        (keyword_length <= 4 || input[4] == keyword[4]) &&                \
        (keyword_length <= 5 || input[5] == keyword[5]) &&                \
        (keyword_length <= 6 || input[6] == keyword[6]) &&                \
        (keyword_length <= 7 || input[7] == keyword[7]) &&                \
        (keyword_length <= 8 || input[8] == keyword[8]) &&                \
        (keyword_length <= 9 || input[9] == keyword[9]) &&                \
        (keyword_length <= 10 || input[10] == keyword[10])) {             \
      return token;                                                       \
    }                                                                     \
  }
      KEYWORDS(KEYWORD_GROUP_CASE, KEYWORD, ZWKEYWORD)
  }
  return Token::IDENTIFIER;
//#undef KEYWORDS
#undef KEYWORD
#undef KEYWORD_GROUP_CASE
#undef ZWKEYWORD
}

#define IS_WCHAR_EQ_U16() (sizeof(wchar_t) == sizeof(uint16_t))
static Token::Value ZWKeywordOrIdentifierToken(const uint16_t* input,
                                             int input_length) {

#define ZWKEYWORD(keyword, token) .Case(L##keyword, token)
#define KEYWORD_GROUP_CASE(ch)
#define KEYWORD(keyword, token)
        std::wstring temp_input;
        if (IS_WCHAR_EQ_U16())
            temp_input.append((const wchar_t *)input, input_length);
        else for (int i = 0; i < input_length; ++i)
            temp_input.push_back((wchar_t)input[i]);
        return StringSwitch<Token::Value>(temp_input)
        KEYWORDS(KEYWORD_GROUP_CASE, KEYWORD, ZWKEYWORD)
            .Default(Token::IDENTIFIER);
#undef KEYWORD
#undef KEYWORD_GROUP_CASE
#undef ZWKEYWORD
#undef KEYWORDS
}
  1. 在 ScanIdentifierOrKeywordInner 或 ScanIdentifierOrKeyword 中添加中文关键字返回token的逻辑，

node.js的稳点版，改点在ScanIdentifierOrKeyword中：

  if (next_.literal_chars->is_one_byte()) {
    Vector<const uint8_t> chars = next_.literal_chars->one_byte_literal();
    Token::Value token =
        KeywordOrIdentifierToken(chars.start(), chars.length());
    if (token == Token::IDENTIFIER ||
        token == Token::FUTURE_STRICT_RESERVED_WORD ||
        Token::IsContextualKeyword(token))
      literal.Complete();
    return token;
  }  else {
    Vector<const uint16_t> chars = next_.literal_chars->two_byte_literal();
    Token::Value token =
        ZWKeywordOrIdentifierToken(chars.start(), chars.length());
    if (token == Token::IDENTIFIER ||
        token == Token::FUTURE_STRICT_RESERVED_WORD ||
        Token::IsContextualKeyword(token))
      literal.Complete();
    return token;
  }

node.js在github上的master，改点在ScanIdentifierOrKeywordInner中：

if (next_.literal_chars->is_one_byte()) {
    Vector<const uint8_t> chars = next_.literal_chars->one_byte_literal();
    Token::Value token =
        KeywordOrIdentifierToken(chars.start(), chars.length());
    /* TODO(adamk): YIELD should be handled specially. */
    if (token == Token::FUTURE_STRICT_RESERVED_WORD) {
      literal->Complete();
      if (escaped) return Token::ESCAPED_STRICT_RESERVED_WORD;
      return token;
    }
    if (token == Token::IDENTIFIER || Token::IsContextualKeyword(token)) {
      literal->Complete();
      return token;
    }

    if (!escaped) return token;

    literal->Complete();
    if (token == Token::LET || token == Token::STATIC) {
      return Token::ESCAPED_STRICT_RESERVED_WORD;
    }
    return Token::ESCAPED_KEYWORD;
  } else {
    Vector<const uint8_t> chars = next_.literal_chars->two_byte_literal();
    Token::Value token =
        ZWKeywordOrIdentifierToken(chars.start(), chars.length());
    /* TODO(adamk): YIELD should be handled specially. */
    if (token == Token::FUTURE_STRICT_RESERVED_WORD) {
      literal->Complete();
      if (escaped) return Token::ESCAPED_STRICT_RESERVED_WORD;
      return token;
    }
    if (token == Token::IDENTIFIER || Token::IsContextualKeyword(token)) {
      literal->Complete();
      return token;
    }

    if (!escaped) return token;

    literal->Complete();
    if (token == Token::LET || token == Token::STATIC) {
      return Token::ESCAPED_STRICT_RESERVED_WORD;
    }
    return Token::ESCAPED_KEYWORD;
  }

二. 修改node.js的 js库，对内置对象和函数添加中文名称

修改实例：

添加 “控制台.日志” 等效 “console.log”

1.添加 “console” 中文名 “控制台”.

libinternalbootstrapnode.js // github master

libinternalbootstrap_node.js // web download

    Object.defineProperty(global, 'console', {
      configurable: true,
      enumerable: true,
      get() {
        return wrappedConsole;
        }
    });
    // 仿照添加 “控制台” 等效 “console”
    Object.defineProperty(global, '控制台', {
      configurable: true,
      enumerable: true,
      get() {
        return wrappedConsole;
       }
    });
  1. 添加 “log” 函数中文名 “日志”

libconsole.js:

Console.prototype.debug = Console.prototype.log;
// 仿照debug和info，添加一条“日志” 等效 “log”
Console.prototype.日志 = Console.prototype.log;

Console.prototype.info = Console.prototype.log;

三 编译

./configure
make all

四 运行实例：

hello.js //放在了 out/Release 中

函数 说1(词) {
    控制台.日志(词);
}
函数 执行(某函数, 值) {
    某函数(值);
}
变 你 = "你";
变 哈哈 = {
    哈1: '好',
     哈2: 12
}

执行(说1, 你);
控制台.日志(哈哈);

运行:

cd out/Release
./node hello.js

结果:

你
{ '哈1': '好', '哈2': 12 }

2018-09-19

文章标签：
日志服务
监控
JavaScript
开发工具
前端开发
C++
关键词：
node.js工具
JavaScript后端
js后端
node.js后端
node后端
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
中文编程
目录
相关文章
jerrywangsap
|
3月前
|
负载均衡 监控 JavaScript
pm2 工具在 Node.js 开发和部署中的重要作用
pm2 工具在 Node.js 开发和部署中的重要作用
jerrywangsap
48 0
IT从业者张某某
|
4月前
|
缓存 JavaScript 前端开发
猿如意中的【Node.js】工具详情介绍
猿如意中的【Node.js】工具详情介绍
IT从业者张某某
35 0
雪梅零落
|
6天前
|
域名解析 网络协议 JavaScript
【Node系列】node工具模块
Node.js有多个内置的工具模块，这些模块提供了用于执行各种任务的功能。
雪梅零落
18 2
游客nmbcre4jd7shs
|
30天前
|
JSON JavaScript 前端开发
Node.js：前端开发的后端利器
Node.js作为一种运行在服务器端的JavaScript环境，为前端开发者打开了后端开发的大门。它以其高效的事件驱动、非阻塞I/O模型以及强大的npm生态，使得前端开发者能够轻松构建服务器端应用，实现前后端的全栈开发。本文将探讨Node.js的核心优势、应用场景以及在前端开发中的重要性。
游客nmbcre4jd7shs
35 5
2019ab
|
1月前
uni-app 63egg.js后端用户上线和下线深度剖析
uni-app 63egg.js后端用户上线和下线深度剖析
2019ab
16 1
天下无贼001
|
1月前
|
Web App开发 JavaScript 前端开发
深入浅出：Node.js 在后端开发中的应用与实践
【2月更文挑战第13天】本文旨在探讨Node.js这一流行的后端技术如何在现代Web开发中被应用以及它背后的核心优势。通过深入分析Node.js的非阻塞I/O模型、事件驱动机制和单线程特性，我们将揭示其在处理高并发场景下的高效性能。同时，结合实际开发案例，本文将展示如何利用Node.js构建高性能、可扩展的后端服务，以及在实际项目中遇到的挑战和解决方案。此外，我们还将讨论Node.js生态系统中的重要工具和库，如Express.js、Koa.js等，它们如何帮助开发者快速搭建和部署应用。通过本文的探讨，读者将获得对Node.js在后端开发中应用的深入理解，以及如何有效利用这一技术来提升开发效率
天下无贼001
83 2
TechWJ
|
2月前
|
监控 JavaScript 前端开发
Node.js：JavaScript世界的全能工具
Node.js：JavaScript世界的全能工具
TechWJ
77 0
jerrywangsap
|
2月前
|
JavaScript 前端开发 API
Node.js 工具库 yeoman 的作用介绍
Node.js 工具库 yeoman 的作用介绍
jerrywangsap
32 0
jcLee95
|
3月前
|
JavaScript 前端开发 Unix
NodeJS文件系统遍历工具：fast-glob
NodeJS文件系统遍历工具：fast-glob
jcLee95
82 0
zrblue
|
3月前
|
JSON 前端开发 JavaScript
如何使用Mock.js来模拟后端接口
如何使用Mock.js来模拟后端接口
zrblue
40 0

热门文章

最新文章

  • 1
    JavaScript基础语法（codewhy版本）（一）
  • 2
    JavaScript的正则表达式实现邮箱校验
  • 3
    生成X-Bogus的js代码，通过python调用生成
  • 4
    使用Selenium执行JavaScript脚本：探索Web自动化的新领域
  • 5
    纯前端JS实现人脸识别眨眨眼张张嘴案例
  • 6
    详解《基于 javascript 的流程图编辑框架LogicFlow
  • 7
    在Blazor中使用Chart.js快速创建图表
  • 8
    js数组常用的方法汇总
  • 9
    设置WebStorm像VSCode一样每行代码结尾自动格式化加入“；”分号（JavaScript、TypeScript格式化）
  • 10
    16个重要的JavaScript代码
  • 1
    优化后端性能：提升Web应用响应速度的关键策略
    8
  • 2
    【后端面经】【数据库与MySQL】SQL优化：如何发现SQL中的问题？
    17
  • 3
    构建高性能微服务架构：后端开发的最佳实践
    98
  • 4
    【后端面经】【数据库与MySQL】为什么MySQL用B+树而不用B树？-02
    10
  • 5
    小程序全栈开发：前端与后端的完美结合
    22
  • 6
    旅游规划助手：结合Vue的交云性设计和Python的强大后端功能
    16
  • 7
    游戏开发入门：Python后端与Vue前端的协同工作方式
    20
  • 8
    使用Django和Vue实现电子商务网站的后端和前端
    12
  • 9
    从前端到后端：构建现代化Web应用的技术探索
    24
  • 10
    构建高效可靠的微服务架构：后端开发的新范式
    18

    • 相关课程

    更多
  • Node.js 入门与实战
  • JavaScript入门与实战
  • Node.js 入门教程文档
  • JavaScript 自学手册文档教程

    • 相关电子书

    更多
  • 探究 Node.js 的服务端之路
  • 个推微服务实践 基于OpenResty 和Node.js
  • 沪江基于Node.js大规模应用实践

    • 相关实验场景

    更多
  • Html5和Webpack2：Webpack5打包JS和样式表
  • 前端开发基础6：Node.js和LESS预编译工具
  • 搭建Node.js编程环境
    • 下一篇
    阿里云oss简介和使用流程
    为什么选择阿里云什么是云计算全球基础设施技术领先稳定可靠安全合规分析师报告
    产品和定价全部产品免费试用产品动态产品定价价格计算器云上成本管理
    解决方案技术解决方案
    文档与社区文档开发者社区天池大赛培训与认证
    权益中心免费试用高校计划企业扶持计划推荐返现计划
    支持与服务基础服务企业增值服务迁云服务官网公告健康看板信任中心
    关注阿里云
    关注阿里云公众号或下载阿里云APP，关注云资讯，随时随地运维管控云服务
    阿里云APP阿里云微信
    联系我们：4008013260
    法律声明Cookies政策廉正举报安全举报联系我们加入我们
    阿里巴巴集团淘宝网天猫全球速卖通阿里巴巴国际交易市场1688阿里妈妈飞猪阿里云计算AliOS万网高德UC友盟优酷钉钉支付宝达摩院淘宝海外阿里云盘饿了么
    © 2009-2024 Aliyun.com 版权所有 增值电信业务经营许可证： 浙B2-20080101 域名注册服务机构许可： 浙D3-20210002 京D3-20220015
    浙公网安备 33010602009975号浙B2-20080101-4