node解释执行js的过程分析-js教程-PHP中文网

首页

web前端

js教程

node解释执行js的过程分析

不言

Apr 03, 2018 pm 02:41 PM

javascriptnode分析

本篇文章给大家分享的内容是node解释执行js的过程分析，有兴趣的朋友可以看一看，有需要的朋友也可以参考一下

说明：node是单线程，非阻塞，事件驱动（类似内核中udev事件，可以参考监听-回调机制）

以node-v8.10.0为对象，主要是src/node_main.cc和src/node.cc这两个文件。

入口
   node-v8.10.0/src/node_main.cc --> 90 int main(int argc, char *argv[])
   调用node::Start(argc, argv);
   node-v8.10.0/src/node.cc --> 4863 int Start(int argc, char** argv)
      a: 4864   atexit([] () { uv_tty_reset_mode(); });
          # 在执行完*.js后执行匿名函数，实际上就是执行uv_tty_reset_mode()
      b: 4865   PlatformInit();
          # 执行内联函数PlatformInit(), 信号量处理函数注册
      c: 4866   node::performance::performance_node_start = PERFORMANCE_NOW();
          封装uv_hrtime函数：src/node_perf_common.h:13:#define PERFORMANCE_NOW() uv_hrtime()
          导出定义：deps/uv/include/uv.h:1457:UV_EXTERN uint64_t uv_hrtime(void);
          实现：deps/uv/src/unix/core.c:111:uint64_t uv_hrtime(void)
          uv_hrtime调用uv__hrtime
          定义：deps/uv/src/unix/internal.h:252:uint64_t uv__hrtime(uv_clocktype_t type);
          实现：deps/uv/src/unix/linux-core.c:442:uint64_t uv__hrtime(uv_clocktype_t type) {
          总之：记录node执行*.js脚本的开始运行时间点，类似的，记录v8的开始运行时间点：
           4903   node::performance::performance_v8_start = PERFORMANCE_NOW();
      d: 4868   CHECK_GT(argc, 0);
          src/util.h:129:#define CHECK_GT(a, b) CHECK((a) > (b))
      e: 4871   argv = uv_setup_args(argc, argv);
          定义：deps/uv/include/uv.h:1051:UV_EXTERN char** uv_setup_args(int argc, char** argv);
          实现：
      f: 4877   Init(&argc, const_cast(argv), &exec_argc, &exec_argv);
          4542 void Init(int* argc,
          4543           const char** argv,
          4544           int* exec_argc,
          4545           const char*** exec_argv) {
          4617   ProcessArgv(argc, argv, exec_argc, exec_argv);
          4502   ParseArgs(argc, argv, exec_argc, exec_argv, &v8_argc, &v8_argv, is_env);
           4015 static void ParseArgs(int* argc,
           解析参数
      g: openssl相关配置
      h: 4895   v8_platform.Initialize(v8_thread_pool_size, uv_default_loop());
      i: 4902   V8::Initialize();
          v8初始化
      j: 4905   const int exit_code =
          4906       Start(uv_default_loop(), argc, argv, exec_argc, exec_argv);
      k: 退出
          4908     v8_platform.StopTracingAgent();
          4910   v8_initialized = false;
          4911   V8::Dispose();
          4919   v8_platform.Dispose();
          4921   delete[] exec_argv;
          4922   exec_argv = nullptr;
          4924   return exit_code;
2. 分析1中的j部分
      a: 4814 inline int Start(uv_loop_t* event_loop,
          4815                  int argc, const char* const* argv,
          4816                  int exec_argc, const char* const* exec_argv) {
      b: 4824   Isolate* const isolate = Isolate::New(params);
          4828   isolate->AddMessageListener(OnMessage);
          4829   isolate->SetAbortOnUncaughtExceptionCallback(ShouldAbortOnUncaughtException);
          4830   isolate->SetAutorunMicrotasks(false);
          4831   isolate->SetFatalErrorHandler(OnFatalError);
           new Isolate对象，并设置相关参数。
      c: 4843   int exit_code;
          4844   {
          4845     Locker locker(isolate);
          4846     Isolate::Scope isolate_scope(isolate);
          4847     HandleScope handle_scope(isolate);
          4848     IsolateData isolate_data(isolate, event_loop, allocator.zero_fill_field());
          4849     exit_code = Start(isolate, &isolate_data, argc, argv, exec_argc, exec_argv);
          4850   }
           准备开始执行的参数，isolate对象。
      d: 4745 inline int Start(Isolate* isolate, IsolateData* isolate_data,
          4746                  int argc, const char* const* argv,
          4747                  int exec_argc, const char* const* exec_argv) {
      e: 环境准备
           4748   HandleScope handle_scope(isolate);
           4749   Local context = Context::New(isolate);
           4750   Context::Scope context_scope(context);
           4751   Environment env(isolate_data, context);
           4754   env.Start(argc, argv, exec_argc, exec_argv, v8_is_profiling);
           执行代码 src/env.cc:18:void Environment::Start(int argc,
           4771     LoadEnvironment(&env);
           加载env
      f: 在d中的函数里面进行eventloop，没有event的时候，就会退出node

3. 分析核心部分
       4777   {
       4778     SealHandleScope seal(isolate);
       4779     bool more;
       4780     PERFORMANCE_MARK(&env, LOOP_START);
       4781     do {
       4782       uv_run(env.event_loop(), UV_RUN_DEFAULT);
       4783
       4784       v8_platform.DrainVMTasks();
       4785
       4786       more = uv_loop_alive(env.event_loop());
       4787       if (more)
       4788         continue;
       4789
       4790       EmitBeforeExit(&env);
       4791
       4792       // Emit `beforeExit` if the loop became alive either after emitting
       4793       // event, or after running some callbacks.
       4794       more = uv_loop_alive(env.event_loop()); // 再次去判断是否有event没有处理，可能一些异步操作会有回调函数。
       4795     } while (more == true);
       4796     PERFORMANCE_MARK(&env, LOOP_EXIT); // 没有事件处理，就退出。
       4797   }
      a: 处理event的核心函数uv_run
       声明：deps/uv/include/uv.h:281:UV_EXTERN int uv_run(uv_loop_t*, uv_run_mode mode);
       实现：deps/uv/src/unix/core.c:348:int uv_run(uv_loop_t* loop, uv_run_mode mode) {
      b: 判断loop是否时alive状态：是否有handle、request-signal且handle没有关闭。
       343 int uv_loop_alive(const uv_loop_t* loop) {
       344     return uv__loop_alive(loop);
       345 }
       336 static int uv__loop_alive(const uv_loop_t* loop) {
       337   return uv__has_active_handles(loop) ||
       338          uv__has_active_reqs(loop) ||
       339          loop->closing_handles != NULL;
       340 }
      c: uv__has_active_handles(loop):
          deps/uv/src/uv-common.h:145:#define uv__has_active_handles(loop)                                          \
          145 #define uv__has_active_handles(loop)                                          \
          146   ((loop)->active_handles > 0)
      d: uv__has_active_reqs(loop):
          129 #define uv__has_active_reqs(loop)                                             \
          130   (QUEUE_EMPTY(&(loop)->active_reqs) == 0)

以上是node解释执行js的过程分析的详细内容。更多信息请关注PHP中文网其他相关文章！

声明

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

JavaScript和Web：核心功能和用例Apr 18, 2025 am 12:19 AM

JavaScript在Web开发中的主要用途包括客户端交互、表单验证和异步通信。1)通过DOM操作实现动态内容更新和用户交互；2)在用户提交数据前进行客户端验证，提高用户体验；3)通过AJAX技术实现与服务器的无刷新通信。

了解JavaScript引擎：实施详细信息Apr 17, 2025 am 12:05 AM

理解JavaScript引擎内部工作原理对开发者重要，因为它能帮助编写更高效的代码并理解性能瓶颈和优化策略。1)引擎的工作流程包括解析、编译和执行三个阶段；2)执行过程中，引擎会进行动态优化，如内联缓存和隐藏类；3)最佳实践包括避免全局变量、优化循环、使用const和let，以及避免过度使用闭包。

Python vs. JavaScript：学习曲线和易用性Apr 16, 2025 am 12:12 AM

Python更适合初学者，学习曲线平缓，语法简洁；JavaScript适合前端开发，学习曲线较陡，语法灵活。1.Python语法直观，适用于数据科学和后端开发。2.JavaScript灵活，广泛用于前端和服务器端编程。

Python vs. JavaScript：社区，图书馆和资源Apr 15, 2025 am 12:16 AM

Python和JavaScript在社区、库和资源方面的对比各有优劣。1)Python社区友好，适合初学者，但前端开发资源不如JavaScript丰富。2)Python在数据科学和机器学习库方面强大，JavaScript则在前端开发库和框架上更胜一筹。3)两者的学习资源都丰富，但Python适合从官方文档开始，JavaScript则以MDNWebDocs为佳。选择应基于项目需求和个人兴趣。

从C/C到JavaScript：所有工作方式Apr 14, 2025 am 12:05 AM

从C/C 转向JavaScript需要适应动态类型、垃圾回收和异步编程等特点。1）C/C 是静态类型语言，需手动管理内存，而JavaScript是动态类型，垃圾回收自动处理。2）C/C 需编译成机器码，JavaScript则为解释型语言。3）JavaScript引入闭包、原型链和Promise等概念，增强了灵活性和异步编程能力。

JavaScript引擎：比较实施Apr 13, 2025 am 12:05 AM

不同JavaScript引擎在解析和执行JavaScript代码时，效果会有所不同，因为每个引擎的实现原理和优化策略各有差异。1.词法分析：将源码转换为词法单元。2.语法分析：生成抽象语法树。3.优化和编译：通过JIT编译器生成机器码。4.执行：运行机器码。V8引擎通过即时编译和隐藏类优化，SpiderMonkey使用类型推断系统，导致在相同代码上的性能表现不同。