AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2019-05-09 722
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 修改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后端
node.js后端
node.js工具
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
中文编程
目录
相关文章
游客moiomvrp3vyac2
|
3天前
|
Web App开发 JavaScript 前端开发
深入浅出Node.js: 打造高效后端服务
【10月更文挑战第39天】在数字化浪潮中，后端开发作为支撑现代Web应用的骨架，扮演着不可或缺的角色。Node.js，作为一种流行的服务器端JavaScript运行环境，因其非阻塞I/O和事件驱动的特性，被广泛应用于构建轻量且高效的后端服务。本文旨在通过浅显易懂的语言，结合生动的比喻和实际代码案例，带领读者深入理解Node.js的核心概念、架构设计及其在后端开发中的应用，进而掌握如何使用Node.js搭建稳定、可扩展的后端服务。无论你是初探后端开发的新手，还是寻求进阶的开发者，这篇文章都将为你提供有价值的指导和启示。
游客moiomvrp3vyac2
101 57
游客qf4jmczx4xu2y
|
7天前
|
Web App开发 JavaScript 前端开发
深入浅出Node.js后端框架
【10月更文挑战第34天】在数字化时代，后端开发如同一座桥梁，连接着用户界面与数据处理的两端。本文将通过Node.js这一轻量级、高效的平台，带领读者领略后端框架的魅力。我们将从基础概念出发，逐步深入到实战应用，最后探讨如何通过代码示例来巩固学习成果，使读者能够在理论与实践之间架起自己的桥梁。
游客qf4jmczx4xu2y
20 1
aliyun8599273441-30642
|
6天前
|
Web App开发 JavaScript 前端开发
深入浅出Node.js后端开发
【10月更文挑战第36天】本文将引导您探索Node.js的世界，通过实际案例揭示其背后的原理和实践方法。从基础的安装到高级的异步处理，我们将一起构建一个简单的后端服务，并讨论如何优化性能。无论您是新手还是有经验的开发者，这篇文章都将为您提供新的视角和深入的理解。
aliyun8599273441-30642
20 2
mrq4nk6ni2neg
|
9天前
|
Web App开发 JavaScript 前端开发
探索后端开发：Node.js与Express的完美结合
【10月更文挑战第33天】本文将带领读者深入了解Node.js和Express的强强联手，通过实际案例揭示它们如何简化后端开发流程，提升应用性能。我们将一起探索这两个技术的核心概念、优势以及它们如何共同作用于现代Web开发中。准备好，让我们一起开启这场技术之旅！
mrq4nk6ni2neg
23 0
肥猪肥猪-17824
|
9天前
|
Web App开发 JavaScript 前端开发
构建高效后端服务：Node.js与Express框架的实践
【10月更文挑战第33天】在数字化时代的浪潮中，后端服务的效率和可靠性成为企业竞争的关键。本文将深入探讨如何利用Node.js和Express框架构建高效且易于维护的后端服务。通过实践案例和代码示例，我们将揭示这一组合如何简化开发流程、优化性能，并提升用户体验。无论你是初学者还是有经验的开发者，这篇文章都将为你提供宝贵的见解和实用技巧。
肥猪肥猪-17824
20 0
技术混子
|
10天前
|
Web App开发 JavaScript 中间件
构建高效后端服务：Node.js与Express框架的融合之道
【10月更文挑战第31天】在追求快速、灵活和高效的后端开发领域，Node.js与Express框架的结合如同咖啡遇见了奶油——完美融合。本文将带你探索这一组合如何让后端服务搭建变得既轻松又充满乐趣，同时确保你的应用能够以光速运行。
技术混子
20 0
杀死一只知更鸟debug
|
2月前
|
JavaScript
NodeJs的安装
文章介绍了Node.js的安装步骤和如何创建第一个Node.js应用。包括从官网下载安装包、安装过程、验证安装是否成功，以及使用Node.js监听端口构建简单服务器的示例代码。
杀死一只知更鸟debug
84 1
NodeJs的安装
你都不懂
|
1月前
|
JavaScript 开发工具 git
已安装nodejs但是安装hexo报错
已安装nodejs但是安装hexo报错
你都不懂
26 2
杀死一只知更鸟debug
|
2月前
|
存储 JavaScript 前端开发
Node 版本控制工具 NVM 的安装和使用（Windows）
本文介绍了NVM（Node Version Manager）的Windows版本——NVM for Windows的安装和使用方法，包括如何安装Node.js的特定版本、列出已安装版本、切换使用不同版本的Node.js，以及其他常用命令，以实现在Windows系统上对Node.js版本的便捷管理。
杀死一只知更鸟debug
188 0
Node 版本控制工具 NVM 的安装和使用（Windows）
游客zi3qmblbcdexu
|
1月前
|
Web App开发 JavaScript 前端开发
JavaWeb 22.Node.js_简介和安装
JavaWeb 22.Node.js_简介和安装
游客zi3qmblbcdexu
18 0

热门文章

最新文章

  • 1
    YY游戏云的angular js实践总结
  • 2
    实时显示日期、时间、城市天气（HTML+JS）
  • 3
    JavaScript 图片切割效果
  • 4
    JavaScript值得注意的小知识点
  • 5
    HTML6 无 JavaScript 的单页应用引起一片哗然
  • 6
    js正则表达式语法
  • 7
    JS中document对象详解
  • 8
    开发者最容易犯的13个JavaScript错误
  • 9
    高性能Javascript--脚本的无阻塞加载策略
  • 10
    【转】Javascript关键字和保留字
  • 1
    LabVIEW使用VI服务器的调用节点将数据传递到另一个VI 使用调用节点（Invoke Node）与通过引用调用节点（Call by Reference）调用VI时有什么差别？
    162
  • 2
    nvm, node.js, npm, yarn 安装配置
    287
  • 3
    局域网监控软件的实时通知系统：利用Node.js和WebSocket实现即时消息推送
    180
  • 4
    深入剖析NPM： Node包管理器的介绍和使用指南
    82
  • 5
    搭建接口平台YApi详解（含搭建node环境）
    189
  • 6
    DOM 属性列表（命名节点图 Named Node Map）
    43
  • 7
    节点列表长度（Node List Length）
    38
  • 8
    Node.js爬虫在租房信息监测与分析中的应用
    91
  • 9
    节点列表长度（Node List Length）
    34
  • 10
    节点类型（Node Types）
    86

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

    更多
  • 如何快速创建插件agent
  • Html5和Webpack3：Webpack5的常见用法
  • Html5和Webpack2：Webpack5打包JS和样式表
  • 前端开发基础6：Node.js和LESS预编译工具
  • 搭建Node.js编程环境
    • 下一篇
    阿里云OSS设置跨域访问