字节 前端商业化 日常实习 一面 23-07-20

被吊打了，简历每个角落都要熟悉啊，了解的不能仅限于了解

1. 自我介绍
2. 看你这里也提到了掌握计算机网络基础，然后也了解像nodejs这些。嗯，就是了解的程度是什么样子，能简单说一下吗？
3. 宏任务和微任务是什么？任务是什么？为什么有任务？为什么有微任务？任务是什么作用，微任务是什么作用？
4. 看代码输出题。（没难度，建议看小米二面的代码输出题，能写出来就毕业了）
5. 看题目。（你不知道的javascript原题）

for(var i=1;i<=5;i++)
	setTimeout(()=>(console.log(i)))

6. 结果是什么，为什么是这个结果
7. 如果变动循环体，不修改timeout怎么做到正确输出
8. 如果修改不修改循环体，可以修改其他的，要怎么做到正确输出

===爆炸开始了===

9. 就是你平时跟他聊的时候，你不是说你也有写前端也有写后端嘛？是的，对，对吧？对，嗯，我想问一下，就是调试你一般写前端代码和后端代码的时候，你是怎么去调试的？
10. 然后这个时候一般调试不是都会基于就是，嗯，你要就 consolog 或者是基于浏览器的这些一些方便的一些能力去调试吗？你一般是用什么样的方法去调试的？
11. *就是说是 sourcemap 这个里面的一个映射的一个映射的一个方式，你清楚是什么样子的吗？就是为什么它可以就是把构建后的那个代码，然后和那个和你的那个原始代码然后关联起来。
12. **那个 source map 还有多种那个，嗯，不同类型的那种 source map，你了解它每一种不同类型那个 source map 那个差别吗？
13. 那个如果是后端就是比如说你调调就nodejs的相关的服务，那你调的方式一般是怎么样子的？是用，如果是用哪一种？
14. 这样子你觉得 vs code 那个内置的调试和那个？嗯，浏览器的那个就是用 Inspector 那个东西调，你觉得两者那个差别在哪里？你觉得哪种更方便一点？有体感吗？
15. *那你了解那个 NODE 里面，就是你加了那个 Inspector 那个命令，它为什么它就可以进入调试？你有了解过这里面那个原理吗？就是它是通过怎么样去监听的那个执行。
16. 首先第一点是 webpack 和那个 vite 那个差别，对，你他们两个差别在哪里你知道吗？
17. *首先你知道 vite 它是怎么去处理成可用的 ES module 这种方式吗？
18. *你刚才提到的生产环境和那个开发环境是不一样的，对吧？是的，那生产环境和开发产环境的那个是哪里不一样？
19. **esbuild和rollup构建流程的区别
20. 过程和产物一样吗？
21. **那我再多问个问题，那生产环境的 rollup 和 esbuild 有什么差别？
22. 那个 vite 里面具体有哪一些配置项，你清楚吗？然后知道每个配置项的那个含义。
23. 那个 vue3 的那个setup，它是在 vue 的哪个生命周期会执行？
24. *那个 vue 它是双向数据流吗？
25. 了解angular嘛
26. 其实这里 vue和react 其实是单向数据流。只是它提供了一个 v-model 的一个内置的工具指令而已，框架层面是单向。
27. *洋葱模型应该了解吧？
28. **nodejs 那个 event loop 机制，是什么？和浏览器的有什么区别
29. **NODE 如果说想要就是支持并发，它应该要怎么做？
30. **同一个时间点，有多条请求过来，然后需要并发去处理这些请求，你知道怎么做吗？
31. 算法，链表反转
32. 反问

#我的实习求职记录# #字节跳动# #字节跳动信息集散地# #面经# #我的实习日记#

=======记录======= 2023年7月21日 上午 0:08|1小时25分钟36秒

关键词: 浏览器、前端、后端、变量、指针、调试、链表、数据流、映射、性能、生产环境、任务队列、开发环境、生命周期、代码项目、调用工具、输出顺序、代码文件

文字记录: 说话人 1 00:04 你好，可以听得到。可以的。好的，我这边也可以的。

说话人 2 00:17 行，那要不我们就先开始？

说话人 1 00:20 好的，对，声音应该不太小吧？

说话人 2 00:24 还好。

说话人 1 00:25 还好，OK，OK，你好，我叫陈思雨，是 2025 届的软件工程大二学生，然后在校经历方面曾经担当过校团学会的网络技术部部长，负责学院和实验室云计算环境的部署和维护工作以及学院的官网建设。然后目前也是软件工程创业创新创业实验室的负责人，学校与合作企业对接懂车，安排十余名同学的学习进度和技术培训。然后在学术经历方面曾经发表过一篇关于机器学习的论文，被 EI 等工具检索。然后在拓展经历方面获得过第十四届篮球杯德沃博主全国一等奖、全国第四名和湖南省的特等奖，也就是一等奖的第一名。然后曾经在广州亚信科技实习过，负责区块链 ToB 端的部分页面研发，美国第四届字节跳动的新训营经历，以第二名的成绩完成前端低代码项目。然后目前的主要技术栈是 view 23 全家桶，注重前端标准化和Devops，上一个 element plus 和 TT 占用 user 开源建设，然后了解 Webpack 和 wait 打包工具的配置和优化，对单元测试的全量公式化有个了解以及实践，谢谢。好。

说话人 2 01:33 的，那等一下。嗯，就是我们正在开始面试的时候，我可能会就是记录一下相关的一些面试的问题和一些回答的一些情况，就先提前先跟你说一下。好的好的，对，就正常记录。嗯，好的，那我们就直接开始。哦，好，那我看你这边你的技术栈应该是。嗯，主要是 view 这一块，对吧？然后是的关于构建工具也比较了解，对吧？嗯， attack 和那个外层。

说话人 1 02:17 对，主要是了解一点。

说话人 2 02:21 噢，对外是比较了解一点。

说话人 1 02:24 嗯，是的。

说话人 2 02:24 噢，那个，嗯，我看你这里也提到了掌握计算机网络基础，然后也了解像load， GS 这些。嗯，就是了解的程度是什么样子，能简单说一下吗？

说话人 1 02:43 像是有提到说这个了解到的 GS 三个 PAP 和 spring boot 这一块，这个了解一个程度的话大概是就是 PK p 这一块的话是了解的比较深的，就是深圳 PAP 这一块，就是因为之前有做过 p a p 相关的一些程序，有像 discuss 和 word press 那一块的，然后这个 spring boot 这一块的话，是因为 PHP 前面，嗯在做PHP，然后后面那个 PHP 的这个热度可能就没那么高。然后所以说就是转就去玩 Java 这一边，作为后端的语言去学习了一下，就使用这个 spring boot 这一块去做了一些个人的一些网站，然后或者是跟学校去合作的一个网站，就是学校学院那边有一个企业跟学院那边是去合作去做一个那个图纸对比的一个工，就像那个就是工程，就是做那个土木工程，他们都是有图纸，那个图纸能不能做到像 Git 一样进行一个版本的管理。

说话人 1 03:46 然后学校那边就有一个企业是做这一块的，然后我的话就是作为这个创业实验室的一个负责人，我就牵头去组织这个项目，作为组长去规划，去安排这些进度，然后还有同学这个学习上一个进度的安排，所以说就是那当时使用的是 spring boot 这一块作为一个后端，所以说这一块也是有去开发过，然后继续这个网络这一块的话就是说就是用到 bot 这一块了。然后的话就是实验室的话啊，有各个方案项的一个不同的小伙伴，也就有的小伙伴他是啊做前端，有些做后端，然后还有做云计算的，做网络，做安全、做渗透的。然后话我是这个实验室的负责人，就是他们有不会的就可能都会来问我，所以说我要去学习了一下这相关的，就云原生这一块的，然后我就是做这一块的话，就是说要先有这个环境，没这个环境的话就嗯可能就接触不到一个比较真实的一些东西，我只能在自己机器上跑一跑。

说话人 1 04:52 所以说我就来去自费购买几台服务器，就是需要搭建这个超融合的一个集群，然后就要在上面开序练习之后，然后跑Kubernetes，然后就在这一块的时候，对这个计算机的网络就稍微深入的了解了一下，就是搭建 Kubernetes 之后，然后还要上网关，上网关之后就又暴露到公网去，那暴露到公网就会有安全问题，然后就又有这个上网行为管理还有 WAF 还有态势感知蜜罐，然后就这些安全之类的一些产品就都在已经用上了。然后在这个部署的过程中，那还自己会涉及到就是基础网络的一个构建，就二层交换机、三层交换机，然后接入交换机和网管型交换机，然后还有汇聚交换机，这一层都是自己要来搭的。所以说就在这一个阶段，自己对这个网络的话就稍微有一个深入的一个了解。

说话人 2 05:45 那你这里提到 node g s，我看你有写吗？当时刚才你好像没有提到这一点，对吧？

说话人 1 05:51 噢， NODE js 刚刚应该是忘记错了， NODE js 这一块的话是有一个，那个就是有一个物联网竞赛，物联网竞赛的话就是跟其他同学一起，但是个物联网竞赛只有三个人，然后物联网的话因为它叫物联网，所以说偏向硬件的。但是他要求的那个结果就是说你要在 APP 或者是 Web 端对那个硬件去进行一个操作，那么就是我们学校就这样一个安排，就是说有两个同学做硬件，然后一个同学做前端和后端，那么我也是做实验室的一个负责人，那我需要去带动其他的一个组员去学习。

说话人 1 06:25 那么如果说我是有两种远前端用 GS 和will，然后端用 Java 那一块的话，就可能学起来就没那么快，因为他比赛是一年一届的，一年的话可能学下来的话可能就没有那么的深度，就是说想赶进度，想赶快一点，那么的话就前后端统一语言全部都用GS，所以说就使用了 load 作为这个后端去操作这个数据库。然后前端的话还是用Unapp，就作为一个 Web 和一个小程序。而 NODE 这一块的话，是啊，有的同学可能他想要做简单一点，他就用了 EX plus，就这一块就是我去教的。然后同时我也是在写嘛，我就写一个例子给他，或者是他来问我，然后的话我自己的话就有用到那个 next 点GS，然后也用 q a express 也用到过。

说话人 2 07:21 我们现在要不先问一下一些更。嗯，前端领域更具体的一些问题。好的，我应该大体有一些了解。嗯，那行，我们先问一下简单的一些语言基础呗。好吧。好。

说话人 1 07:34 的好的。

说话人 2 07:36 嗯，红任务和微任务这个东西你应该。

说话人 1 07:38 了解这个了解红任务和微任务的话，它这一个主要的区别就是说像微，像宏任务的话，它就是 set time out，然后还有就是定时器那一块的，然后听得到吗？

说话人 2 07:57 听得到，听得到。

说话人 1 07:59 然后还有这个所有的 i o 事件它都属于这一个红任务，然后 v 任务的话它就有province，然后还有就那个 next tick，对这一块都是属于一个微任务，然后他们的一个区别为什么会出现？为什么会出现 v 任务？就最浏览器最开始的时候它是只有红任务的，然后红任务的话它就是执行的时候，它有一个红任务的一个执行队列，然后每次等到它执行红任务的时候，它就相当于会对这个队列打开快照，就在红任务当中执行了一个红任务，它不会在当前这个循环里面执行完，它会放到下一次去执行新添加的一个红任务。

说话人 1 08:38 那么这个时候如果说需要在新添加的活动物之前做一个插队的一个操作，那要怎么办？那这个时候就做不到了，没办法做到那个时候，这个时候就出现了一个微任务，解决这个点就有这一个，就是做到一个任务的一个插队。然后微任务的话，它会在微任务过程中都会产生一些新的微任务，它会再继续执行这个新的微任务，直到这个微任务的这个队列为空，它还会执行，它还会切换任务队列。然后这个微任务的话，其实它解决了刚刚那个问题，它还解决一个回调地域的问题，就是它可以使用一个语法弹完 async 和 wait 的一个语法弹，然后去可以将那个异步的代码进行一个同步化。然后它也如果用点赞的话，它也不会像回调第一语言就回调里面又嵌一个回调，然后它可以把它扁平化，就全部都在一级一直点赞下去。

说话人 2 09:34 我现在简单考一段那个执行那个东西，让你看一下那个，对，你说一下那个就是你直接右侧不是可以打吗？你直接打一下他们那个输出顺序是样子好。

说话人 1 09:51 第一行 console LOG 1，这个是立即执行的，就可能打印出来了。然后第二行setup，那先打个草稿， on the wall，网络队列，微任务队列，然后这里执行结果，然后第一行的时候它是立即执行的，所以是会马上输出来。

说话人 1 10:18 然后执行到第二行的时候，宏任务队列里面就加了一个，然后执行到第三行的时候， promise 点对错误，这个也是立即执行的，然后他点赞的话，他就是会放到这个微任务的队列里面去，所以微露队里面就有个三，然后在下面一行和 miss resolve 右点这。然后这个时候话会放一个 set time out， come OUT 4。在 model 4 在微任务队列里面，然后再往下执行的话5。放在微任务队列里面 oh set time out 这个时候 6 放在宏任务队列里面，然后最后 7 立即打印出来，然后再执行宏任务，取出3，然后 3 time out 4，把 3 执行完了就拿走，然后执行 settime out 4 就放在黄龙队里面，这个时候 setup 4 执行完了，然后还剩下这个5。 30 个 5 的时候五执行完了，微任务队列空，然后执行红任务的话就 264 这个。

说话人 2 11:33 in other。行，我想想。好的，那我再多问你个问题，还是关于那个红任务和微任务的。嗯，也不能说是完全关于吧，你等一下我再打开那个给你看一下，就假设我们现在有一段这样的一个。

说话人 1 12:07 代码，这个太经典了，这个就是那个，你不知道 Javascript 里面的原题是吧？

说话人 2 12:15 没有你你就可以简单说一下嘛。没关系，我们深入进去聊一下。

说话人 1 12:22 这个白色的东西，他这我记得这个好像它是有一个名字的，应该就是循环闭包，应该是有这个名字。

说话人 2 12:32 您首先这一段代码它执行完以后，这个空手出来的东西是什么？你知道吗？嗯，你能猜得到吗？这个能猜到。

说话人 1 12:40 这个话可以，我可以先就这样理解一下，就是说这个哇的话，它是存在一个变量提升的问题吗？然后而且它那个如果说是在 b 包里面的话，它就是不会像。 net 一样，它不是，它没有那个快作用域的概念，所以说它只有权益作用域和函数作用域。然后在这他说他们 out 这么多里面，其实它引用的是一个，如果它是一个 let 的话，它又产生一个快递作用语，它产生了快递作用欲的话，每次迭代都是产生一个新的i，然后像这样的话全局作用域的话他每次拿到都是一个i，所以最后输出来的结果就是 i 等于5， i 加最后输出结果就是 1000 个6，不对，就是 5 个等等 0012345 就是 6 个6。

说话人 2 13:30 行，okay，如果要把它改成就是说预期的就是从那个 0 开始输入输出的话，其实你刚才应该提到了。噢，那你要不直接改一下。

说话人 1 13:45 let，或者是里面加个，再加个闭包给它高个函数包起来，就不用let，用 one 一样的，就是里面是 time what？包个 function 就行。

说话人 2 13:54 OK，好的，行，先那个语法技术，要不就简单先考到这里。那个我们，嗯，那个我想问一下，噢，就是你平时跟他聊的时候，你不是说你也有写前端也有写后端嘛？是的，对，对吧？对，嗯，我想问一下，就是调试你一般写前端代码和后端代码的时候，你是怎么去调试的？

说话人 1 14:25 一般是这样就可以假设一个场景，就是说假设咱们有个新项目要开始写了，那么需求文档，那些设计稿、 UI 稿都已经出来了，那么这个时候照着照这种传统的写法，就是前就前端写 html 写静态的，然后再给到后端，再放到它的什么 live 或者是一些其他语言的这个模板引擎里面去去筛这个数据。以前就这样子的，然后现在的话就是说也有两种，就是一种。嗯， API first，就是 API 先行，就是先写接口文档，然后话还有一种以前的话就是说后端写好了，前端写页面写静态的，那先不调接口，因为接口调不了，然后等后端把接口写好之后前面再调接口。这个时候就有两个问题，就是说这个项目的一个推进就比较缓慢，要等后端写好了前端才能来调调页面，那这个时候就不能并行执行。那么后面一种方法的话就 API first，前后端加测试，就 API first，然后加 test first，加测试先行和 API 先行。

说话人 1 15:29 那这两个一起来的话，就是说在最开始的时候咱们就一起定好接口，如果没有必要的话就不需要不要去改动，那么前端的话它有这个文档了，它可以进行一个mock，可以调接口，是吧？然后后端的话它就正常的像以前一样调接口。

说话人 2 15:48 对对，我们要不再稍微搜一下，就是我们先不说协同的一个东西，就假设比如说你写一个前端项目的时候，你不是肯定也会涉及到前端那些代码的调试，对。

说话人 1 16:00 不对？

说话人 2 16:02 对。然后这个时候一般调试不是都会基于就是，嗯，你要就 consolog 或者是基于浏览器的这些一些方便的一些能力去调试吗？你一般是用什么样的方法去调试的？

说话人 1 16:15 不至于，不至于，看 solo 就是最开始线上出问题的话肯定是不可说 log 的，因为代码不是跑自己电脑上的，一般会有个全局的一个链路，会有个啊，Skywalk，在那里面可以看到全局链路在服务中的一个调用。然后通过那个先简单的看一下是在哪个环节卡住了，然后再去前是看前端的问题还是后端的问题，如果是前端的问题话，就可能加上自己的一个 source map，去调一下报错在哪里，调到定位在哪一行，然后在本地复现一下，然后因为可以拿到整个全局的一个 request ID records ID 在网关肯定有流量重发的一个功能，让它重发到一个测试环境来，然后再调前后端就可以了。

说话人 2 17:00 那这里我有一个问题，刚才你提到了就是，嗯，你一般纯调前端的 GS 代码，里面提到的就是会用浏览器的那个 source 那个东西去打断，你去调嘛，对吧？对，是的，那你就但是我其实我们正常构建工具，你构建完了以后，其实你实际上请求的那个相关的代码文件其实都是经过 agency 这种之后的，对吧？刚刚其实就是 minify 加 ugly 之后的。对，但是你在 source map 里面，你去不是，你在那个 source 里面去打那个断点的时候，基本上你看的都是那些源码嘛，对。

说话人 1 17:41 不对？刚刚其实我也说到啊，其实你也说漏嘴了，就是说是 map 嘛？

说话人 2 17:46 对，对，就是说是 map 这个里面的一个映射的一个映射的一个方式，你清楚是什么样子的吗？就是为什么它可以就是把构建后的那个代码，然后和那个和你的那个原始代码然后关联起来。

说话人 1 18:05 就是它这个 source map 里面它会记录这个函和列，然后根据这个函和列的一个映射去映射到源码文件里面。它这个 sort map 其实就是一个编译后的那个文件和一个源文件的一个行列之间的一个映射。

说话人 2 18:22 那个 source map 还有多种那个，嗯，不同类型的那种 source map，你了解它每一种不同类型那个 source map 那个差别吗？

说话人 1 18:32 这个可能就不太清楚了，因为我好像就是自己有去看过这个，说什么 f 就是他我看到的那一种的话就只是一个含和列的一个映射。其他的 social map 的话好像我没有去特意关注过。

说话人 2 18:51 oh okay，好的。那个如果是后端就是比如说你调调就 no no， no GS 的相关的服务，那你调的方式一般是怎么样子的？是用，如果是用哪一种？

说话人 1 19:12 如果是在本地的话，嗯，可以用那个，就是那个浏览器，它有个控制台，它可以加上那个inspect，就是写命令的时候 NODE 杠杠inspect，然后它就会出一个端口，然后那个 com 的控制台去连这个端口就可以用空母调试。然后有时候也会用 console log。 consolilog 应该用的感觉用的多一点。

说话人 2 19:40 主要还是调后端的时候还是用 consullog 比较多一点，对吧？

说话人 1 19:45 对，但是有时候比较复杂的话，比如说在一个循环里面，那 consolog 就不太合适。那我一般就会选择用控制台去加个debug，然后。嗯，起命令的时候加个 inspect 就可以打断点在那个科目的控制台调，或者是在 vscode 里面调，或是在 Webstorm 里面都可以看，但是 Webstorm 那个好像有点卡，我感觉我还是喜欢用那个 comm 自带的控制台。

说话人 2 20:11 这样子你觉得 vs code 那个内置的调试和那个？嗯，浏览器的那个就是用 Inspector 那个东西调，你觉得两者那个差别在哪里？你觉得哪种更方便一点？有体感吗？

说话人 1 20:27 两种差别话，其实 vs code 本身我就用的不多，用的是 Web 任务，但是这个一个感觉的话就是 vs code 它那个各种一个体制会更加强一点。但是 Chrome 的话那个自带的其实也不差，就是你断点断到那里的话，它其实上下文都有的，它一个调用站也在那里，所以说就是调前端用那个空空才用的比较多，所以说可能用起来更熟练一些。 where is code 的那个就用的比较少，而且 where code 本来就用的比较少。

说话人 2 20:58 那你了解那个 NODE 里面，就是你加了那个 Inspector 那个命令，它为什么它就可以进入调试？你有了解过这里面那个原理吗？就是它是通过怎么样去监听的那个执行。

说话人 1 21:13 这个我了解，没有去了解过，但是应该能够。嗯，大概的能够知道它的一个大概的一个流程，就是它断在这里的话，就像 C + + 它为什么要断这里？它就是保存了那个计算器里面的值，它就能够断在这里。然后但是 logo g s 的话，它在这里断点，他就是他这断点的一个原理应该也差不多。然后他建立这个端口的话，就是起了一个服务，写了一个这个服务，他才能建立一个网络上的一个端口，然后，嗯，打断点的话其实应该跟 C + + 差不多，就是只就是不保存了这个 CPO 的这个一个那个叫啥？就是那个，对，寄存器，对，就那个寄存器里面指的是战损了下来，然后如果再跑的话会把这个计算器的持续覆盖掉，那就能完全够还原当时的一个状态了。好的。

说话人 2 22:19 然后我们刚刚有提到，就是那个，你简历里有写嘛？就是你对工程这一块也比较了解，对吧？就 wepeg 和那个BYTE，是的，你是对外者更了解，对吧？对。

说话人 1 22:33 是的。

说话人 2 22:35 那你能不能简单的说一下，就是首先第一点是 BYTE 和那个 Web pack 那个差别，对，你他们两个差别在哪里你知道吗？

说话人 1 22:46 一个主要的差别就是当时这个 meet 出来的时候他就说快嘛？快的很了，然后他就是用了一个什么车型，主要的一个差别就是说这个 wait 他打包之后他只是说去转了一些，转移了一些育发糖，或者是说加了一些垫片而已。但是他并没有去修改那个 ES modio 的一个特性，就是这个 ES module 的一个引入，它是没有做修改，就是它浏览器，新版的浏览器它默认就是支持这个 ES module 这种导入，但是 Web pack 的话它就是对它进行了，它就是去掉这些，它进行了一个降级，相当于是它降级到了一个ES5，因为 ES5 是没有这些东西的，所以说他就要寻找每一个文献去进行一个用微博简写到AST，然后再根据这个逻辑这个语法的一个逻辑再还原到 ES 5 区。所以说它这里面就会稍微耗时一点。

说话人 1 23:41 而 wait 这边的话，因为不需要这些操作，它直接启动的话，它就直接秒期就起来了，它不需要去对这个文件进行转换，它转化是在什么时候？就是说在浏览器打开的时候，他去请求浏览器请求哪个文件，然后他再去找到对应的文件，然后再进行一个解析，然后浏览器那边拿到这个之后，去根据这个 ES modio 的一个导入，然后再去找到其他的文件。

说话人 1 24:08 但是这个就也有一些弊端，就是说如果我项目就小项目还好，小项目几千个文件还好，但是有好几千上万的一个文件，那个浏览器的话它的请求就会很多，那随便打开一个项目的话请求就几千个，搞的那个浏览器的话它也会很卡，因为它一个域名下面一个，一个域下面它只能并发 64- 6 个。如果说太多了的话，浏览器的这个执行也会是稍微有点卡顿。

说话人 1 24:34 那我要派克那边也有劣势，就是说然后它编好了之后就要继续访问，它当时是很快的，但是如果说热更新的话，它的整个券可是一起更新的，所以你快就稍微要逊色 wait 这边一点。其实微头这边我觉得体验上、开发体验上就是快也没，相对来说就总体而言其实也没快多少，感觉两边差不多，就是说为他那边为什么说没快多少？就是说他热更新是很快，那个 GS 马上就加了一块，但是他还有一些问题，就是说如果我开发的时候那个全局变量，我第一次修改的时候污染的全局变量，我第二次的话它全局变是不会还原过来的，所以说我还得是刷新一次，然后又刷新一次的话，我又等几千个文件的加载，其实也很慢的。

说话人 2 25:23 你刚才提到里面我想多问两个点，就第一个的话是，嗯，首先你知道 wise 它是怎么去处理成可用的 ES model 这种方式吗？

说话人 1 25:36 搭载的这里，它在开发模式下的话，我记得是用 yes build 去进行一个处理的，因为 ES build 的话，它那个官方宣称性能是非常快的，但是它的一个缺点就是说没有 Web pack 那么多插件，没有那么多生态，它不支持 AST 的一个语法解析，它使用的就是纯字符串的一个匹配。所以说它这一块再加上它一个语言特性上的一个知识，用的 native 的这种方式的一种语言，它就说这边这方面就快很多。然后它这个 wait 在生产环境下的话，就是用的 low up 这一块的话，就比 yes build 要稍微好一点，它支持这种语法一个解析，它也有一些插件，但是并没有 will pack 那边的生态那么全。

说话人 2 26:24 你刚才提到的生产环境和那个开发环境是不一样的，对吧？是的，那生产环境和开发产环境的那个是哪里不一样？

说话人 1 26:36 具体的就是它这个处理文件的这一个引擎是不一样的，就是生产环境下是 ES build，然后开发不，那个开发环境是 ES build，生产环境是ROP，然后它这个主要的一个考量的话就是 ES build 更快。我在开发环境下因为我浏览器能提供更多的一个兼容性的支持，因为我自己开发了，我可以控制我自己浏览器一个版本，但生产环境下的话就要做到更多的一个兼容，所以说就可能需要用到耳机，所以就要从 AST 进行一个预发解析，然后去降级一些不必要的东西。

说话人 2 27:11 我多问一下，那他们的那个构建过程一样吗？

说话人 1 27:16 构建过程的话可以构建。

说话人 2 27:19 过程和产物一样吗？

说话人 1 27:23 产物不一样的产物就是生产环境下打包出来就是一个静态的页面，然后开发环境的话，它就是说就请求一个 GS 过去，就是在浏览器控台可以看得到，就是它每找到一个需要引入的文件，它就会发送这一个请求，然后发送到 wait 那边，然后再调用 ES build 去进行。啊，这个转换完了之后再发回这个 GS 去，然后他就是没有落盘，就是说这个文件没有落盘。

说话人 2 27:54 那我再多问个问题，那生产环境的 low up 和 weipad 有什么差别？ them up。

说话人 1 28:07 这个的话，这个话就是Web。

说话人 2 28:14 pack，从产物，对。

说话人 1 28:17 你说从产物就是我，我刚才想到的其实就是 Wifi 和那边就是一切这个模块，就是它就只能在 h t m l 和那个GS，那么其他东西的话它需要进行一个需要 load 去进行一个转换，然后在模块他才可以去进行一个打包。如果 up 那边的话，然后不那边就可能不太清楚，没有去太仔细了解过，就是说去了解过它的一些option，一些选项的一个配置。

说话人 2 28:51 我另外再多问一下，那个 BYTE 里面具体有哪一些配置项，你清楚吗？然后知道每个配置项的那个含义。

说话人 1 28:58 吗？这个的话一般是说在需要时候就会去看这个文档去哪里去配，那一般需要用到的话其实就是一个 low APP option，然后还有这个具体的个件名可能不太记得，就是他那个打包的时候还有一些，比如说我可以分包，然后就传一个函数进去，可以拿到那个代码的文本，然后还可以拿这个路径然后返回值，就是一个宿主可以去自己去手动分包。然后还有一些就是一些插件的一些配置，然后还有这个压缩方式，还有其他的一些，就在那个 index HGM 里面，你还可以配置一些里面的一些 Meta 标签这些的。

说话人 2 29:49 嗯，好的，那我们要问下一个问题呗，要不就我再问一个简单的 view 的问题？好， U3 你用过？应该用。

说话人 1 30:05 过用过。

说话人 2 30:08 那个 view 3 的那个setup，它是在 view 的哪个生命周期会执行？它。

说话人 1 30:14 是合并了 view other before create 和 create 的这两个生命周期都统一到 setup 里面去了，就是 setup 一执行的话就说明已经科瑞 at 的完了。然后 view 三的话就是除了这个生命周期，除了这一个地方有变动的话，还有一个地方的变动就是它在销毁组件的时候把那个钩子的名字改了，之前是 before destroy 和 destroy 的，然后 view 3 的话就变成了 before i mount 和unmounted，换成这两个。

说话人 2 30:49 那个 view 它是双向数据流吗？是的，对，是的，他是双向数据聊。嗯，就是，那你了解就是说那个，比如说我们 60 不是会有内置一些属性，对吧？比如说像是噢，有一些指令，比如像 v game model 这种指令，对吧？对，那这种指令它的那个具体那个实现方式是什么样子的你清楚吗？

说话人 1 31:21 我知道，就是说如果说是像百年的表单的话，就不需要自己处理了吗？如果说绑定到一个自己的一个组件，那要怎么办？就是在 Vue 二里面的话，它子传父，不是父传子就很简单了，父传子，微干部的话，父变了子肯定会变，那么子变的话负要怎么变？就是说用那个这次点 init input，然后第二个参数的话，就是你需要的值就通过这个事件去触发，然后触发到这个 input 这个事件的话，上面这个值就会改变，然后但是在嗯 view 3 的话，我记得是也是用Emit，只不过这个名字变了，就是你可以绑定成其他的一个变，就是 Emit 的话就是 or just update。这应该是update，然后就可以去触发这个子改变，然后父也改变，就子改变的话，你需要去触发这个父改变的话，你就需要去 emeet 一下这个事件，然后附改变的话子这边是肯定会改变的，就通过这个节奏通过这个事件去触发的。

说话人 2 32:32 所以刚刚你说的那个 V 杠 model 那个原理就是，我是不是可以简单理解概括线，你刚刚的表达是，你的意思是你通过绑定 Vegan model 以后，相当于是把那个属性就是父传子，对吧？然后传到子组件里面，然后去用了这个词，然后当子组件的这个词改变的时候，然后通过 amit 发了一个事件出去，然后去改原来在负容器里面那个变量，我这么理解对。

说话人 1 33:06 不对？是的。

说话人 2 33:08 哦，明白，好的。嘶，那你觉得它是单向数据流还是双向数据流？bill。

说话人 1 33:17 就是说他框架层面是帮用户，帮开发者已经处理好了，所以说他就是做用户的话，就是可以在表面上可以看到它是一个双向的一个数据流。就是最简单一个例子，为怎么证明它的双向数据，也就是把那个表单那么 GS 里面的值变了，那表单 html 里面直接变了，就 DOM 里面只变的话， GS 里面只变了绑定标。

说话人 2 33:44 表单是指用 V 杠 model 去绑定，对吧？

说话人 1 33:47 是的。

说话人 2 33:51 那我再多问一个问题，你了解 Angel 了吗？

说话人 1 33:58 我是知道 Anchor 的，它的话写法很像后端它下面都要加的，一般加个注解 at Controller at 什么的。

说话人 2 34:08 行，其实这里 view 其实是单个数据多。对，只是它提供了一个 Bigan model 的一个内置的工具指令而已，框架层面是单向。

说话人 1 34:21 数据流，那单向的话要怎么理解这个单子。

说话人 2 34:26 是一样。

说话人 1 34:27 那怎么理解这个单线呢？

说话人 2 34:31 就是它。其实你在你假设你抛弃掉 big model 的时候，你实际上是需要通过自己去改事件，自己去发送事件，然后去修改外面的某个具体的值的。这一层是需要自己就是开发者去做的。如果你了解那个 Angel 的话，你就会知道就是那个才是真正的双向数据流。那我们不展开了，我们继续往下。好的好的，OK， no 的了解，对吧？你刚刚说过用过QA，那 QA 的那核心的那个洋葱模型应该了解吧？

说话人 1 35:11 Zoom 的主要是express，然后 QA 的话它就是有个洋葱模型。 SKOA 还是一个 press 来的？是，应该是有个染色模型。对，它就是有个中间件，它中间件就是通过这个来的，就是进去的话会按照这个顺序去执行这个中间件。然后要不。

说话人 2 35:33 具体一点描述，就是就描述更细节一点，比如说一条请求留经过a、b、 c 三个中间件，对吧？对，然后他，对，那他是怎么？他是怎么一个洋葱模型的？一个数据留了一个流向你可以。嗯，说的更具体、更详细。

说话人 1 35:54 一点，就是他请求进来的话，就是说 ABC 进来之后他就倒着出去，就是像一圈一圈包着的，就最里面的话是c，进了 c 的话那肯定要先出这个 c 才行。就是进去的话这 ABC 出来的话就是CBA，然后就每一层的话都可以拿到它的一个request，还有response，好了可以在中间键里面去对它进行一个修改拦截。

说话人 2 36:21 好的，那个，这个那我就不细问了，刚才其实你也说你主要用的一个是 express 啊，那个，嗯，这里多问一个问题。就 NODE 那个 event loop 那个机制，你应该。

说话人 1 36:35 了解，那个 event loop 的话，它那个其实版本不一样的话，其实它还有点稍微不同，然后它跟浏览器有一点点差，有一点差别。其实。

说话人 2 36:48 可以简单展开讲一下。

说话人 1 36:51 吗？这个，哈哈，浏览器的这个 YouTube 它就是个就是NODE。

说话人 2 37:00 电路的。

说话人 1 37:01 对， load 的这个英文路虎，就是说像游戏也差不多，就是它的 IO 视野流那些什么的，也是全部都发到红任务里面去的，然后他就是做了一个 process next tick，然后有这个事的话它属于微任务里面的。然后其他一些差别的话主要就是在于刚刚，其实有些就是就怎么说？就是在 set time out 里面它又出来新的 set out， set time out，然后同时又添加了这个微任务，然后它不同那个版本执行顺序会有一点不一样。但是我记得是最新的 load 的话，应该是改成跟浏览器是一致的，就是说红任务里面产生红任务，它是不会去执行这个新的红任务的。微任务产生微任务它是会执行完这个微任务队列的。

说话人 2 37:59 那行，我们要不先这个就也先不展开了，我就最后问一个那个 NODE 相关的一些问题，就是。

说话人 1 38:07 好的。

说话人 2 38:09 就是NODE，对吧？我们平时不都说是 NODE 是因为用的是那个浏览器，那个就是用的都是 GS 引擎，对吧？它是一个单线程的。对，是的，但是对，那但是 NODE 在企业级的一些框架里面，它们是它是可以支持那种，就是多进程，然后可以支持一个并发的。

说话人 1 38:38 对吧？对，是的，有。

说话人 2 38:40 了解度，就是 NODE 如果说想要就是支持并发，它应该要怎么做？

说话人 1 38:46 它其实它单线程它没关系，它其实那个 IO 事件它放到最里面去，其实就相当于是个携程，跟 go 的携程是一样的，其实它性能还更高一点，就是说它对 HTTP 这个服务的话，它其实它这个性能。是啊，我记得是排在非常靠前的一个性能，它为什么是这样的？就是因为它的一个异步的一个机制。像 Java 那些的话，它其实有时就异步的框架，那它默认的话都是一个多线程的，每打一个，不是说每打一个就是每接一个请求，就像PA。

说话人 2 39:22 啊，你刚刚说是 NODE 卷子是个多线程的，是吧？

说话人 1 39:27 没有，我说 Java 和PHP，像 PHP 的那个，他那个 PHP f f 的那个啥来着，就是 PHP 他那一块的话就是通过 NGX 来转发， NGX 收到一个请求之后转发到PAP，然后他又再。

说话人 2 39:42 搜一下。我不说其他的，说其他，我们就说NODE， NODE 如果说想要支持一个并发他，他应该是怎么做？

说话人 1 39:50 他用的就是一个异步的一个这个功能，然后它这个一大概一个实现的话，其实就是类似一个，就是一个携程的一个效果，就是它这一块如果说一个 IO 来了，它执行完了之后， IO 它还会有一个时间等待，它会先放到一边，放到那个队列里面去，然后的然后就切换到其他的地方去执行。就相当于是如果方如果有。

说话人 2 40:21 同一个时间点，有多条请求过来，然后需要并发去处理这些请求，你知道怎么做吗？

说话人 1 40:28 并发去注意这个请求的话，就是如果说要并发处理的话，那就是开一个worker。

说话人 2 40:38 开一个涡格。

说话人 1 40:40 对，就是隔开四个话，就是相当于是四个线程。

说话人 2 40:48 所以说通过开新的进程的方式实现并发，对吧？

说话人 1 40:53 对，但一般是不需要的，因为这个一个这个携程的一个机制就应该能够很好支持这个，这个QPS，这个并发了一个新的了。

说话人 2 41:08 行，那我们也这个也先不展开了。好的，行，那我们就做到笔试题呗，时间我看也差不多了。好的好的，好好的，稍等一下，你能看到。

说话人 1 41:43 吗？可以看到。

说话人 2 41:46 对，就我们要不就简单做一下，就一个单向链表的一个倒转。

说话人 1 41:53 列表反转。嗯，好的，这个的话还需要自己定义这个数据结构，这上面有诶 d 当下的列表，把这个也拿出，先构建一下车测试用例，12345，先构下这个图节点。

说话人 1 43:41 12345，这还要需要？嗯，不行，这个还需要递归的去。

说话人 2 44:16 如果说能用递归的算法去写这个最好。对，可以尝试一下，先用递归的思路去。

说话人 1 44:23 写。就是，我是说这个构建，这个就是测试用力，我不知道。

说话人 2 44:34 你也可以不用去构建那个设置用例，因为最后其实也不需要你代码，直接就是执行出来，因为你要推荐支持用你，我怕你时间来不及。

说话人 1 44:47 好的好的。输入个链表头节点，反转干链表，并输出打算后的头节点，然后这是个头的话，这个就是一个尾巴，那么的话，马老头节点拿到头节点，我把下一节断了。下一阶段的话，就先定到外面。 there was，如果这个头缺点没有的话，那么大眼前的这个节点就是一个，不行，现在这个头就加，不能这样。最后一个，就这里选定一个 there what is the moment。然后，然后如果单写了这个值收到的话， thats the ticket，next。

说话人 1 46:44 不，不能这样反转，其实其实再简单一点，我可以把它放到数组里面，然后再给它反转一下就行。

说话人 1 47:08 as list can add the next。

说话人 1 47:25 肚子里口红的话，就继续 push 进去。

说话人 1 47:48 对，找到所谓的词，找到，找完所有之后再反转一下就可以了，然后根据这个来构建。

说话人 1 48:43 那UL，如果这个头些天，没有的话，那么当前就是第一个 just when yours， not a loader to a new installed I。如是空的话，那么，然后continue。欧洲的话，这个大家请求这个LOGO，就是下面的这个， certain unicorn，好像还有点问题很大，这里的话应该要一直往下走，然后应该还有那个current，current， no parents retention the head。然后这里部署完了之后还要往下走吗？

说话人 1 50:10 current， you must have a day next， i can。

说话人 1 50:23 如果原来是，如果头节点是空的，那么等于当前节点，然后单元情节点类等于头节点。对，然后当前节点的 next 等于这个写一点，再往下走。但 JS 不能像 c 那 C + + 那样。这里如果是按如果是 n u，l， l 的话，那就不行了。所以说， then next the enoter 这个应该是可以的。点 current x 等于NODE，这是个对象。对，这个是个对象，那么 current 这里， can you count the next， i go。

说话人 1 51:35 构建当前的节点，如果抽节点是空的话，节点是没有问题的，然后当前节点也是 reverse header，然后继续，然后如果头节点有了的话， attention next to musical node，然后继续执行。然后单线节点的下一个，单选节点等于单元节点下一个单元节点下一个的话，这个 NODE 是个 n u l l，下一个执行的话就算复制上去了。不对，那个，发现这个词等于i，单纯的词等于 i 的话， mention the next has a， on you and all。对对，是这样的，但是这里就不对了，这里的话， current is seed。

说话人 1 54:16 这样是可以的。对的，是可以的。那你好看还看得到吗？

说话人 2 54:27 OK，写完了吗？嗯，好的，仔细看一下。

说话人 1 54:38 就是其实都是用的一个就是最前一段的方法，就把它拿出来之后再反转一个数组，然后再去构建那个反转之后的一个链表，这里应该还要跳出一下。

说话人 1 55:32 to go ahead of their own。

说话人 1 55:39 其实不用了。对，这里已经跳出了。是的，已经跳出了 now next cold so，那就不会继续递过了。

说话人 2 55:50 但是你这样子写，你是不是改变了原引用？你相当于是重新的，你把值先取出来存起来，然后再用每一个值重新的构建那个链表，对吧？

说话人 1 56:03 是的是的。

说话人 2 56:05 能简单点吗？就是我感觉可以不这么复杂，你能就简单的直接不改变原有的引用，因为原来的那个方式，其实链表结构其实都给你了。就是你是NODE，就是每一个节点的那个，你其实可以直接的改成点next，点 next 不改值。

说话人 1 56:29 我不改值就改它那个 next 的那个引用。

说话人 2 56:33 对，是的，改它 next 那个指向。

说话人 1 56:39 其实这样的话拿到1，其实也可以，就是说把每一个那个 NODE 都拿出来传到数组里面，然后从数组的最后一项开始，把它的 next 全部都指向前一项，然后找到第，找到最开始那一项的时候，然后就把它 next 改成空就可以了。

说话人 2 57:08 你你你，你好像也不需要存到数组里面，你好像不需要有一个完整取到所有东西的一个过程，就是你中间你用一些，其实你本质上只是做一下那个翻转，就你你就其实它就是一个便利的一个过程，对吧？你在便利的过程中就直接把它翻转掉不就好了？

说话人 1 57:29 但是在便利的过程中，如果说对，其实也可以的，因为我可以连去拿两下，我拿到第一项的时候不动，我拿到第二项的时候，然后把第二项 next 值按前一下，这个时候我又拿到第三项的时候。那所以说昨天只要我保持我有这个头节点就可以了，不然的话我就会丢失。对，头。

说话人 2 57:48 节点已经作为行参输给你了吗？你要不再写一下行不行？ ah 可以，没事，你可以直接在这个方法下面另开一个，这个没关系。好，就你把那个对。

说话人 1 58:23 在现在拿到头接点点next，但是这样的话这个 head 就会丢失，所以说需要保留一下，都接着来下一下 the next industry 权限，现在就是一个下一项，头，对，等一下那个 2 或者 next 要指向一。是的，那这个时候我拿到了， next to the note，那么，这个时候这里会丢失了，应该继续。next，这一项必须要拿到，找到了之后让他再去改变下一项的一个指向，这里的话，继续。如果继续修改指向的话。

说话人 2 01:00:43 我给你一个建议，你把它当成是一个指针便利的一个方式，你可以定义成一个指针，然后这个指针然后一条一条的往后去定义，往后去遍历，然后在指针每到一个位置的时候，然后再把前后两项交换一下。没了就你用指针的想法去做，可能会更简单一点，因为你现在感觉好像想要直接交换会会缺少一些暂存的一些东西。

说话人 1 01:01:22 对，直接换的话就会有可能导致那个头节点没拿到，所以说就会断开。就是说这个用 C + + 的话其实会更好一点，但是 GS 里面的话就是说如果拿到那个值，不能拿指针，只能是传一个对象，传引，传那个复杂数据类型。

说话人 1 01:01:53 每次拿两项交换，那这个时候我可能要拿到第三项才行，不然的话这条链条就断了。

说话人 1 01:02:04 although you can have it in English？

说话人 1 01:02:08 对，就下一项的 next time 前一下。

说话人 2 01:02:12 你提前把第二个线记下来，不就不会断了吗？

说话人 1 01:02:16 所以这个记下来的话就是两次next，这个就是说后面那项就第三项，两项交换的话这个 next 就不会断了，这应该对，应该循环一下的，这样的话拿到了下一项和下线，我要交换下一项和单元前线。在交换完了之后，然后 next NODE。

说话人 1 01:03:49 消化完了的话，想一想就，这两个就要变了。这两个变量，看看这个能不能提 bug 一下，等于 next node。这里的 nice 的话，这个手势，那就3， Sunday if they send you when you went to English handle the next， other than next。指向单选， oh next notice a。

说话人 2 01:05:23 这样写字有问题，你下面直接把 next NODE 赋给了 next NODE。

说话人 1 01:05:31 这里应该是要取一个next，我没有改变。

说话人 2 01:05:34 你用关键。

说话人 1 01:05:36 对吧？对，这里直接赋值的话，它就丢失了那个引用的一个关系。

说话人 1 01:05:48 这里放了的话，这里，这个 next logo 是 i mean i player 这个header，让我看看这个header，有个是编辑的变量so， in the 边家的话。

说话人 2 01:06:15 我给你个提示，就是你，你直接用现在这种方式你去操作，就是 head 点next，然后 head 点 next 这种方式。这种方式是不好操作的，因为你这个链表这个关系，你在给它倒转之前你都是要保留的，但是你通过这样子的取值的话，你会直接改掉它对应的那个NODE，那个就是因为你取的都是next，你相当于这样子是直接去改它的那个 NODE 了。你知道，所以说你这个时候需要引入一个三番的变量，去按指针的方式去向，像指针递进的一种方式去记录，应该沿引用一个三判的变量去记录，比如说你当前遍历的第一个节点，然后在第一个节点的时候，然后完成交换以后，然后在这个指针向前进一位。

说话人 1 01:07:09 对，就是一个 current loader，然后还有一个 next loader，然后这个 current loader 的话就一直往下走。对。

说话人 2 01:07:33 你可以先把那个逻辑想清楚，不急着写。对，怎么交换。好。

说话人 1 01:07:40 先说这个，这家乡里面写过的， GS 里面可能很久没写的就不太记得了。看看。

说话人 2 01:07:47 C + + 和 GS 一样的，你要反转列表，你在 C + + 里面，你不调用工具函数，你也要这样子去给他翻转一样的。

说话人 1 01:08:13 然后到下一个节点和当前节点，然后我需要对下一个节点，下一个阶段的下一项 l 等于这个，下一个阶段下一项要等于大家想象，但是我还需要拿到下一个节点的下一项，那我需要把单选项进行修改才行。当前线，指向二，二指向3，我这边的话是，把 2 指向一了之后 2 的下一线就丢失了，所以说要把那个 3 先拿出来，把三根线拿出来的话，存到开发者乐子里面也不太行。

说话人 2 01:09:48 我再给你提示，再给你一个提示。嗯，你当前因为本质上链表翻转其实是一个三元的一个关系，对不对？有三个变量的一个关系，你要在某一个节点上完成翻转，你要把它的前一个节点和后一个节点，你应该要都能记录下来，嗯，你才能完成这个翻转。

说话人 1 01:10:17 对吧？对，不然就会丢失，那就把那个给丢了。

说话人 2 01:10:26 对，所以说你，所以理论上你用当前节点加上另一个变量，两个变量，然后去去做这个调换，应该是能调换的。

说话人 1 01:10:49 搜我试一下，下一项等于大前项，在大学校之后，下一项要等于下一项的下一项。

说话人 2 01:11:10 你下一线也行，你继续吧。

说话人 1 01:11:15 嗯，然后单选项的话就等于circle，然后我电话完成了之后，其实如果说扇一下没关系，其实这样也可以。 next Yin，当前线，然后 next NODE 已经调换完成， next NODE 没有用了，然后 next NODE 要等于新的，要等于它的子项，可能他的直线 ah 应该是这样，顺序有点问题。那交换完成了之后， next load 现在不能换，然后当前的 load 等于 next load，这里就是2，然后再按前就到 2 了，然后再下一项的话就换到3。

说话人 1 01:12:20 kind of the next letter， i show you this also， please i know。 my shadow。

说话人 1 01:12:55 这边的话是 next NODE 2 点 next 等于一，这个没错，等于2，然后 2 = 3，还有个 3 要等于43，还要往下走。

说话人 2 01:13:29 一遍一遍的这样写。你写循环的意义在哪里？

说话人 1 01:13:34 去循环一就是一直一直让每个指针都往下走，然后走到最后那个 now 的时候就让它跳出就行了。但是现在的话，那你。

说话人 2 01:13:44 定制做法不对，那你现在一个一直在声明 next node 等于 next node。

说话人 1 01:13:52 这个的话好像是顺序有点问题，我看一下顺序应该是错了，就 next load 是作为这个调换的，这个应该是要放在哪里看一下？

说话人 1 01:15:17 这个 debug 一下，可能好像不能debug。

说话人 2 01:15:29 你在换那个 next NODE 的时候，你再把 next NODE 点 next 的那个节点，你要往下调的时候，你提前把它先记录下来不复制，然后你再把那个 currents 给它复制，你这样子不就不需要写什么 next NODE 了吗？

说话人 1 01:15:50 记录下来是需要记录 3 个变量的。

说话人 2 01:15:55 其实记录两个就够了。

说话人 1 01:15:58 输入两个的话就是 next the next 用。

说话人 2 01:16:03 看看你 current NODE 往前推一个的时候，不就等于 next NODE 了吗？ next NODE 就是。

说话人 1 01:16:12 how to logo，往前推一个的时候，就相当于。但是凯瑞斯这里往前吹了一变到 2 了， 2 它指向已经改了，所以说 2 的 next 就你在。

说话人 2 01:16:30 它改之前，你是不是就得先把它记录一下嘛？本来正常你不给他赋值的 next NODE 的 next 它应该是3，对不对？是的，你提前你改的原因是因为你的上面 cut NODE 你给它做了赋值，你在给它做父子之前你给它记下来，然后后面再把它给到，就是再把 current NODE 再往前推到那个 next NODE 那个位置，或者是推到那个 3 的那个位置就是你的 next NODE，那不就也行了嘛？

说话人 1 01:17:06 是这样的话，比如说这里的 next NODE 点next，这个你知道啥吗？这个应该，所以你交换了之后这里是 2 = 3，这个人也是不对的，是吧？就说这个。

说话人 2 01:17:44 你森林的临时变量给它存起来。

说话人 1 01:17:47 但是这里的话不是还是得多一个变量。

说话人 2 01:17:52 你，但是你得有一个给他存的一个变量，这没办法。

说话人 1 01:17:57 这所以说还是需要是声明三个变量的。

说话人 2 01:18:02 那是的，但是跟你上面那两个定义的不一样，你上面就没有必要定义你每一次这个就是一个临时的一个过渡变量。

说话人 1 01:18:11 所以就是两个调换一下。 next north budget next，对，只要当前日志，然后 type 指向next，然后当前的就指向下一项，然后这里的话如果是扣了的话，那就返回当前的投资证。应该这应该没毛病。

说话人 2 01:18:40 今天感觉时间也有点久了，要不我简单最后再问你两个问题，然后你看你有啥问题你也可以问一下我，好吧？

说话人 1 01:18:52 嗯，好的好的。

说话人 2 01:18:54 我这边看你其实是 25 年的那个毕业生，对吧？是的，我想问一下，就是那你们现在不，你不才大二吗？那这样子算对吧？那你能出来47。

说话人 1 01:19:07 吗？可以的，是这样子，就是因为近几年这个什么什么东西。

说话人 2 01:19:18 怎么。

说话人 1 01:19:19 了？我以为刚才好像听到些声音。没事，就是因为学院看到了，就是这几年那个就是我们学院每个学院都要报那个就业率，就是然后我们专业的话，这个就业率就可能近几年不是很好，所以说就把我们这两届，这三届、近三届的这个课全部都把大三的课都全部都往前调了，全部都调到大一和大二了。然后所以说大三的话，大三下就已经没有什么课了，然后大三上的课的话我已经先修了一门了，所以说这个咳嗽话，咳嗽压力上的话就可能压力就比较小，然后的话因为前面有两届也是在往前调了，所以说前两届也有一些学长他是在这个点就出来找实习的，然后这个时间上的话学院也会和学校那边去。嗯，沟通的，所以说这个时间上也是没有问题的。前面其实也有学展是这样子过来的。

说话人 2 01:20:18 我明白你说的意思了，那这样子到你毕业其实就相当于是有一年半了，对吧？我，哦，两年。

说话人 1 01:20:26 对，如果大三上先修了几门课的话，那差不多就是两年了。

说话人 2 01:20:34 那你自己呢？你自己觉得就是，比如说你实习，你后面不是要回去上课吗？那你现在7月，马上8月了，你是不是只能实习一个月，然后 9 月份你就要回去上课？

说话人 1 01:20:48 没，没有，刚刚其实有说到，就是说这个时间上的话是没有什么问题，就是学院会去跟学校那边去沟通，就是可以不用上课，自学就可以了。然后后面的话但是考试是要去考的，就是说后面只需要考试折回来考个试就行了。no。

说话人 2 01:21:14 阿拉尼，我看你这边简历是写是我们这边的岗位。是这样的，我们岗位是北京杭州都有，你这边应该不挑 base 地吧，对。

说话人 1 01:21:24 吧？但是我可能更希望在北京一些。

说话人 2 01:21:29 更希望在北京一点，是吧？行，能多问一下你那个想要去北京的那个原因是啥吗？

说话人 1 01:21:40 主要是因为北京市首足，可能更繁华一些。

说话人 2 01:21:48 这样子。是的。噢，行，那这个后面，嗯， HR 再给你再看这个，到时候，嗯，面完以后后面，嗯 HR 就应该会跟你说结果到时候你再看就好了。然后最后一个就是你有什么问题想问我的。

说话人 1 01:22:08 吗？我想问的话就是咱们这个组的话，从一个业务方向上是做哪一个角度的？可能然后从技术方向上的话，技术方案是一个怎么样的？

说话人 2 01:22:21 我们这边的话，嗯，业务上是做商业化，千川这个跟正常的那个就 ToC 的用户可能隔得比较远，还有更多是 ToB 的，就是你可以理解成电商广告相关的。然后我们组内的那个技术的话，就是全商业化，应该都是走的前端是view，然后我们会有对应的一层 NODE 层，然后后端是 go 的这个形式。然后在组里面有很多的相关的一些技术方向，一些东西，比如说什么性能、稳定性这些相关的东西都会有，然后每个领域会有一些自己的一些不同的一些东西。对，差不多简单描述一下。

说话人 1 01:23:07 对，那大概，如果说是做前端的话，大概是有多大的一个规模？有多少个人？

说话人 2 01:23:17 规模？六七十个人，总共。不，我是整个团队。那一般是前后一半，差不多是二三十个人有前段。

说话人 1 01:23:27 噢，那还是挺多人一起做这个的。

说话人 2 01:23:32 对，我们这边业务发展比较快。对，然后对整体的那个，对人员的一个挑战也会比较大。

说话人 1 01:23:43 了解了，那我这边也没有其他的问题了。

说话人 2 01:23:48 行，好的，那我们今天就先这样。好的，后面有什么消息还是阿辉跟你联系。

说话人 1 01:23:55 好。好的，谢谢。好的，好。

#我的实习求职记录##字节跳动##字节跳动信息集散地##面经##我的实习日记#