1. 概述

位操作是程序设计中对位模式按位或二进制数的一元和二元操作. 在许多古老的微处理器上, 位运算比加减运算略快, 通常位运算比乘除法运算要快很多. 在现代架构中, 情况并非如此:位运算的运算速度通常与加法运算相同（仍然快于乘法运算）。

2. 取反（NOT）~

3. 按位或（OR）|

4. 按位异或（XOR）^

5. 按位与（AND）&

6. 移位 >>, <<, >>>

• 移动: >>, <<
• 无符号右移： >>>
• 无符号左移是不存在的，因为左右在低位补位，而低位没有正负数的概念，因此不存在无符号左移

7. 其他位操作技巧P

7.1. n & (n - 1)

该位运算技巧可以直接将 n 的二进制表示的最低位 1 移除。

1. 不停的进行 n = n & (n - 1) 操作，直至n为0，可以计算二进制数的1的个数

环境：

• .NET 5
• ASP.NET Core MVC

1. .NET 5

作为一个资深.NET工程师，说句实话，.NET没落了，在国内更加的没落。之前做过8年node.js/前端，现如今又转回了.NET。也希望.NET能有更好的前景吧。个人觉得.NET还是有一定的市场的（当然，国内算小众了），有几点原因：

1. .NET5开始，真正做到的跨平台（之前叫.NET CORE)， 而且把那个’CORE’字也拿掉就，就叫.NET5， 可见微软的宏大目标；
2. 开发效率，.NET软件开发，不管是web还是winForm，效率确实高
3. 跨平台，从.net core开始，终于跨平台了….
4. 性能大大提升。 .NET core性能大幅提升，尤其是跑在Linux上的时候；
5. 有些已有的基于.NET的产品，还需要继续维护、开发，不会换个语言重写；
6. 微软、以及和微软紧密合作的公司，也提供了不少.NET的应用场景；

工欲善其事必先利其器，既然要接着用.NET，那么下文将列一下开发必备工具，供参考。

2. IDE

2.1. Visual Studio

这个没的说，而且要用最新版的VS!

2.2. Visual Studio Code

微软的开源软件，同时是当前最流行的Web前端开发IDE。

作为备选，支持C#开发，对于简单的代码，或者测试一些语法、看代码什么的，这个足够，而且占用资源很少。

推荐插件：

• Code Spell Checker, 检查代码中单词拼写错误。声明个变量，后来发现单词拼写错了，尴尬了，使用这个插件，即时提示拼写错误
• C#, 安装此插件支持C#项目
• GitLens，如果使用git，一定要装这个，方便查询提交历史，某一行上次代码的提交人、提交备注等；
• Markdown All in One, markdown文件的插件，很强大，自动生成目录、编号等等。

3. 代码比较

3.1. Beyond Compare

收费软件，但功能确实是强大。

3.2. WinDiff

免费版，将就着用；

4. 图片处理

4.1. paint.net

(这个也是基于.NET开发的哦，因为我们机器必然有.net framework,所以这是还是很小的)；
免费版，功能也很强大，占用资源很少。对于非专业的美工，足够用了！

5. 其他Web工具

5.1. node.js/npm

做前端web开发，不管是否用node.js，环境还是要有的；

5.2. API 测试 - Postman

方便测试API，免费版足够用了，支持账号同步，导入导出等等；

5.3. Color Pick

快速精确地从任何地方取色。

6. 其他工具

6.1. Linux客户端：MobaXterm

还在用putty? 试试MobaXterm吧，免费版支持保存20个session（节点、机器），足够用了；

1. 集成了sftp，直接拖拽上传、下载文件
2. 自带windows编辑器，不用vi了
3. 多窗口模式
4. 很好很强大… …

6.2. 远程连接： Remote Desktop Connection Manager

如果有大量的虚机、PC等需要远程连接使用，那这个工具就是很必要的。
微软的工具，虽说没什么更新了，但是很实用：

1. 分组管理、保存用户、密码，支持继承用户名、密码（实验室机器一般用户名、密码都是一样的吧）

ASP.NET Core MVC 入门到精通 - 3. 使用MediatR

环境：

• .NET 5
• ASP.NET Core MVC (project)

1. MediatR

MediatR .NET中的简单中介者模式实现，一种进程内消息传递机制（无其他外部依赖）。支持以同步或异步的形式进行请求/响应，命令，查询，通知和事件的消息传递，并通过C#泛型支持消息的智能调度。

Simple mediator implementation in .NET
In-process messaging with no dependencies.
Supports request/response, commands, queries, notifications and events, synchronous and async with intelligent dispatching via C# generic variance.

另：中介者模式 - 定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

2. 安装 & 配置

对于.NET5 (.net core), 使用nuget 安装MediatR.Extensions.Microsoft.DependencyInjection.

配置：

1
2
3
4
5

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddMediatR(typeof(Startup));
}

3. MediatR消息类型

3.1. Notifications 通知模式

Notifications 通知模式用于生产者发送通知，消费者（可以多个）接收到通知后，进行后续处理。
例：一个APS.NET 页面，访问时，发送Notifications通知；消费者简单记录收到通知的时间。

3.1.1. 定义基于INotification的通知类

1

public class Ping : INotification { }

3.1.2. 定义消费者（关注通知的处理方法）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Pong1 : INotificationHandler<Ping>
{
    public Task Handle(Ping notification, CancellationToken cancellationToken)
    {
        Debug.WriteLine($"Pong1, {DateTime.Now}");
        return Task.CompletedTask;
    }
}

public class Pong2 : INotificationHandler<Ping>
{
    public Task Handle(Ping notification, CancellationToken cancellationToken)
    {
        Debug.WriteLine($"Pong2, {DateTime.Now}");
        return Task.CompletedTask;
    }
}

3.1.3. 发送消息通知

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// 基于dotnet core的依赖注入，注入IMediator对象
private readonly IMediator _mediator;
public HomeController(ILogger<HomeController> logger, IMediator mediator)
{
    _logger = logger;
    _mediator = mediator;
}


public async Task<IActionResult> IndexAsync()
{
    // e.g. 访问首页时，发送通知
    await _mediator.Publish(new Ping());
    return View();
}

3.1.4. 输出

1
2
3

Pong1, 5/27/2021 4:37:18 PM
Pong2, 5/27/2021 4:37:18 PM

3.2. Request/Response 请求响应模式

request/response用于命令和查询的场景。

3.2.1. 创建请求类：

1
2
3

public class RequestModel: IRequest<string>
{
}

3.2.2. 创建请求处理类

不同于通知模式，request/response只能有一个请求处理。

1
2
3
4
5
6
7

public class RequestHandeler : IRequestHandler<RequestModel, string>
{
    public Task<string> Handle(RequestModel request, CancellationToken cancellationToken)
    {
        return Task.FromResult($"Pong {DateTime.Now}"); // 测试，返回内容给request
    }
}

3.2.3. 页面中发送请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

private readonly ILogger<HomeController> _logger;
private readonly IMediator _mediator;

public HomeController(ILogger<HomeController> logger, IMediator mediator)
{
    _logger = logger;
    _mediator = mediator;
}

public async Task<IActionResult> IndexAsync()
{
    // send request, and show Response
    var response = await _mediator.Send(new RequestModel());
    Debug.WriteLine("Got response in controller: " +response);

    return View();
}

3.2.4. 输出

1

Got response in controller: Pong 5/28/2021 2:04:26 PM

4. 总结

• MediatR是一种进程内消息传递机制。
• 支持以同步或异步的形式进行请求/响应，命令，查询(CQRS)，通知和事件的消息传递，并通过C#泛型支持消息的智能调度。
• 其核心是消息的解耦。
• 应用场景: 实现CQRS、EventBus等。

5. 参考 & 代码

• 参考: https://github.com/jbogard/MediatR
• 代码: https://github.com/jackniu81/dotnet/tree/main/MediatR-Demo

ASP.NET Core MVC 入门到精通 - 3. 使用MediatR

算法 - 计算汉明距离

1. 题目

给出两个整数 x 和 y，计算它们之间的汉明距离。

汉明距离是使用在数据传输差错控制编码里面的，汉明距离是一个概念，它表示两个（相同长度）字对应位不同的数量，我们以d（x,y）表示两个字x,y之间的汉明距离。对两个字符串进行异或运算，并统计结果为1的个数，那么这个数就是汉明距离。
示例:

• 输入: x = 1, y = 8
• 输出: 2
• 解释:

  1 2 3

  1 (0 0 0 1) 8 (1 0 0 0) ↑ ↑

  上面的箭头指出了对应二进制位不同的位置。

2. 代码

2.1. C#

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Solution {
    public int HammingDistance(int x, int y) {
        var n = x ^ y;

        // 计算1的个数
        var counter = 0;
        while(n>0){
            n = n & (n-1);
            counter ++;
        }
        return counter;
    }
}

2.2. Javascript

1
2
3
4
5
6
7
8
9

var hammingDistance = function(x, y) {
    let n = x^y;
    let counter = 0;
    while(n){
        counter ++;
        n = n & (n-1);
    }
    return counter;
};

3. 另：计算二进制数字中1的个数

一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0。
因此，一个整数的二进制有多少个1，就可以进行多少次这样的操作。

1
2
3
4
5

let counter = 0;
while(n){
    counter ++;
    n = n & (n-1);
}

算法 - 计算汉明距离

内插字符串

类似于string.Format方法，但使用简单，方便，e.g.

1

string str = $"Hello {name}, NumTimes is: {DateTime.Now}";

NuGet

NuGet 常用命令

1. Install-Package XXXX

   常用包

2. EF Core: Microsoft.EntityFrameworkCore.SqlServer

1. ASP.NET Core MVC 概述

ASP.NET Core MVC 框架是轻量级、开源、高度可测试的演示框架，并针对 ASP.NET Core 进行了优化。

2. ASP.NET Core MVC路由

ASP.NET Core MVC 建立在 ASP.NET Core 的路由之上，是一个功能强大的 URL 映射组件，可用于生成具有易于理解和可搜索 URL 的应用程序。

MVC 中的路由包含下面2中方式

1. 基于约定的路由
2. 属性路由

2.1. 注册

所有 ASP.NET Core 模板都包括生成的代码中的路由。 路由在 Startup.Configure 中的中间件管道中进行注册。

1
2
3
4

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseRouting();
}

2.2. 基于约定的路由

基于约定的路由，可以全局定义应用程序接受的 URL 格式，并说明每种格式如何映射到给定控制器上的特定操作方法。 接收传入请求时，路由引擎分析 URL 并将其匹配到定义的 URL 格式之一，然后调用关联的控制器操作方法。

Configre 方法中，定义约定路由：

1
2
3
4
5
6

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
});

{controller=Home}/{action=Index}/{id?}, 含义是默认Controller是Home，默认action为Controller中的Index方法（Action）。

2.3. 属性路由

属性路由，可以通过用定义应用程序路由的属性修饰控制器和操作来指定路由信息。 这意味着路由定义位于与之相关联的控制器和操作旁。

1
2
3
4
5
6
7
8
9

[Route("api/[controller]")]
public class ProductsController : Controller
{
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id)
    {
      // url等同于 api/Products/{id}
    }
}

浏览器（Cache）的缓存逻辑（HTTP条件请求）

1. 浏览器缓存

一般来说，一个GET请求在目标资源存在的情况下会返回一个状态码为“200 OK”的响应，目标资源的内容将直接存放在响应报文的主体部分。如果资源的内容不会轻易改变，那么我们希望客户端（如浏览器）在本地缓存获取的资源。对于针对同一资源的后续请求来说，如果资源内容不曾改变，那么资源内容就无须再次作为网络荷载予以响应。

确定资源是否发生变化可以采用两种策略。第一种就是让资源的提供者记录最后一次更新资源的时间，资源的荷载内容（Payload）和这个时间戳将一并作为响应提供给作为请求发送者的客户端。客户端在缓存资源内容时也会保存这个时间戳。等到下次需要针对同一资源发送请求时，它会将这个时间戳一并发送出去，此时服务端就可以根据这个时间戳判断目标资源在上次响应之后是否被修改过，然后做出针对性的响应。第二种是针对资源的内容生成一个“标签”，标签的一致性体现了资源内容的一致性，在HTTP规范中将这个标签称为ETag（Entity Tag）。

2. If-Modified-Since与If-None-Match

对于HTTP请求来说，缓存资源携带的最后修改时间戳和ETag分别保存在名为If-Modified-Since与If-None-Match的报头中。报头名称体现的含义如下：只有目标资源在指定的时间之后被修改（If-Modified-Since）或者目前资源的状态与提供的ETag不匹配（If-None-Match）的情况下才会返回资源的荷载内容。

以Chrome为例， 当服务端接收到针对某个资源的GET请求时，如果请求不具有上述这两个报头或者根据这两个报头携带的信息判断资源已经发生改变，那么它返回一个状态码为“200 OK”的响应。除了将资源内容作为响应主体，如果能够获取到该资源最后一次修改的时间（一般精确到秒），那么格式化的时间戳还会通过一个名为Last-Modified的响应报头提供给客户端。针对资源自身内容生成的标签，则会以ETag响应报头的形式提供给客户端。反之，如果做出相反的判断，服务端就会返回一个状态码为“304 Not Modified”的响应，这个响应不包含主体内容。一般来说，这样的响应也会携带Last-Modified报头和ETag报头。

3. Chrome

从Chrome的Network请求中可以看到，

1. 发送的请求的Header中包含了If-Modified-Since与If-None-Match；
2. 返回的内容，同样会包含Modified-Since与ETag；
3. 对于没有内容更改的请求，Status Code为304 - Not Modified
4. 对于304返回，Modified-Since与ETag 必然与请求的If-Modified-Since与If-None-Match分别一致；

4. 总结

1. 客户端（浏览器）如果有缓存内容，发送请求时会在Header中包含If-Modified-Since与If-None-Match
2. 当服务器内容没有修改时，服务器端会发送304给客户端，这是body内容可能为空；

1. 题目： 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

e.g
输入：l1 = [1,2,5], l2 = [1,3,4]
输出：[1,1,2,3,4,5]

2. 思路 （迭代）

我们可以用迭代的方法来实现上述算法。当 l1 和 l2 都不是空链表时，判断 l1 和 l2 哪一个链表的头节点的值更小，将较小值的节点添加到结果里，当一个节点被添加到结果里之后，将对应链表中的节点向后移一位。

3. 代码

3.1. C#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int val=0, ListNode next=null) {
 *         this.val = val;
 *         this.next = next;
 *     }
 * }
 */
public ListNode MergeTwoLists(ListNode l1, ListNode l2) {
    ListNode preHead = new ListNode(-1);
    ListNode pre = preHead;
    while (l1 != null && l2 != null){
        if(l1.val > l2.val){
            pre.next = l2;
            l2 = l2.next;
        }else{
            pre.next = l1;
            l1 = l1.next;
        }
        pre = pre.next;
    }
    pre.next = l1==null? l2:l1;
    return preHead.next;
}

3.2. Javascript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
var mergeTwoLists = function(l1, l2) {
    if(l1 === null) return l2;
    if(l2 === null) return l1;

    let preHead = new ListNode();
    let last = preHead;
    let cur ;
    while(l1 !=null && l2!= null){
        if(l1.val > l2.val){
            cur = l2;
            l2 = l2.next;
        }else{
            cur = l1;
            l1 = l1.next;
        }
        last.next = cur;
        last = cur;

    }
    last.next = l1 === null? l2:l1;

    return preHead.next;
};

• CLR：公共语言运行库(Common Language Runtime)
• CIL：通用中间语言（Common Intermediate Language，简称CIL，亦称IL）
• CTS：通用类型系统(Common Type System)
• CLS：公共语言规范 (Common Language Specification)
• FCL：框架类库（Framework Class Library）
• BCL：基础类库（Base Class Library）
• DLL：Dynamic Link Library，动态链接库，也称为元件，CLR与BCL都是由元件构成。
• Assembly： 程序集，由编译器得到，供CLR进一步编译执行中间产物MSIL，一般表现为.DLL,或者.EXE格式，必须依靠CLR才能顺利执行。
• CoreFX： 是经过完全重写的BCL，除了自身就具有跨平台执行的能力之外，其提供的API也不再是统一定义在少数几个单一的程序集中，而是经过有效分组之后被定义在各自独立的模块中。
• PCL: 可移植类库 Portable Class Library (PCL)
• .NET Standard: 我们可以将.NET Standard称为新一代的PCL，PCL提供的可移植能力仅仅限于创建时就确定下来的几种目标平台，但是.NET Standard做得更加彻底，因为它在设计的时候就已经考虑针对三大分支的复用。
• POCO: Plain Old Class Object，也就是最基本的CLR Class

• 1. React 基本问题
  • 1.1. React有什么特点
  • 1.2. React的主要优点。
  • 1.3. React有哪些限制
  • 1.4. Virtual DOM 的工作原理。
  • 1.5. react diff 原理
  • 1.6. React 项目用过什么脚手架
  • 1.7. 如果进行三次setState会发生什么，循环执行setState组件会一直重新渲染吗
  • 1.8. 调用 setState 之后发生了什么？
  • 1.9. 什么是JSX
  • 1.10. 浏览器是否可以直接读取读取JSX？
  • 1.11. vue和react适用的场景
• 2. React 组件
  • 2.1. 为什么说在React中，一切都是组件
  • 2.2. React 中 render() 的目的。
  • 2.3. React组件生命周期的阶段是什么？
  • 2.4. react 生命周期函数
  • 2.5. 在生命周期中的哪一步你应该发起 AJAX 请求？
  • 2.6. 展示组件(Presentational component)和容器组件(Container component)之间有何不同
  • 2.7. 调用 super(props) 的目的是什么
  • 2.8. 除了在构造函数中绑定 this，还有其它方式吗
  • 2.9. 什么是 Props?
  • 2.10. 什么是状态（State)？
  • 2.11. 类组件(Class component)和函数式组件(Functional component)之间有何不同
  • 2.12. 如何更新组件的状态？
  • 2.13. React中的事件是什么？
  • 2.14. React中的合成事件是什么？
  • 2.15. 何为受控组件(controlled component)
  • 2.16. React 的 refs 有什么作用？
  • 2.17. 列出一些应该使用 Refs 的情况
  • 2.18. shouldComponentUpdate 是做什么的，（react 性能优化是哪个周期函数？）
  • 2.19. 什么是高阶组件（HOC - higher order component）？
  • 2.20. 你能用HOC做什么？
  • 2.21. 什么是纯组件（Pure Component）？
  • 2.22. React 中 key 的重要性是什么？
• 3. Redux
  • 3.1. 什么是Flux
  • 3.2. 什么是Redux？
  • 3.3. Redux遵循的三个原则是什么？
  • 3.4. “单一事实来源”有什么理解？
  • 3.5. 列出 Redux 的组件
  • 3.6. Redux与Flux的区别
  • 3.7. Redux 有哪些优点？
• 4. React Router
  • 4.1. 为什么需要 React 中的路由？
  • 4.2. 什么是React 路由？
  • 4.3. React Router 的优点。

1. React 基本问题

1.1. React有什么特点

1. 它使用虚拟DOM而不是真正的DOM。
2. 它可以用服务器端渲染。
3. 它遵循单向数据流或数据绑定。

1.2. React的主要优点。

1. 它提高了应用的性能
2. 可以方便地在客户端和服务器端使用
3. 由于 JSX，代码的可读性很好
4. React 很容易与 Meteor，Angular 等其他框架集成
5. 使用React，编写UI测试用例变得非常容易

1.3. React有哪些限制

1. React 只是一个库，而不是一个完整的框架
2. 它的库非常庞大，需要时间来理解
3. 新手程序员可能很难理解
4. 编码变得复杂，因为它使用内联模板和 JSX

1.4. Virtual DOM 的工作原理。

Virtual DOM 是一个轻量级的 JavaScript 对象，它最初只是 real DOM 的副本。它是一个节点树，它将元素、它们的属性和内容作为对象及其属性。 React 的渲染函数从 React 组件中创建一个节点树。然后它响应数据模型中的变化来更新该树，该变化是由用户或系统完成的各种动作引起的。

Virtual DOM 工作过程有三个简单的步骤。

1. 每当底层数据发生改变时，整个 UI 都将在 Virtual DOM 描述中重新渲染。
2. 然后计算之前 DOM 表示与新表示的之间的差异。
3. 完成计算后，将只用实际更改的内容更新 real DOM。

1.5. react diff 原理

1. 把树形结构按照层级分解，只比较同级元素。
2. 给列表结构的每个单元添加唯一的 key 属性，方便比较。
3. React 只会匹配相同 class 的 component（这里面的 class 指的是组件的名字）
   合并操作，调用 component 的 setState 方法的时候, React 将其标记为 dirty.到每一个事件循环结束, React 检查所有标记 dirty 的 component 重新绘制.
4. 选择性子树渲染。开发人员可以重写 shouldComponentUpdate 提高 diff 的性能。

1.6. React 项目用过什么脚手架

creat-react-app， Yeoman， umi 等

1.7. 如果进行三次setState会发生什么，循环执行setState组件会一直重新渲染吗

setState这个方法是用来告诉react组件数据有更新，有可能需要重新渲染。它是异步的，react通常会集齐一批需要更新的组件，然后一次性更新来保证渲染的性能，所以进行三次只有一次的效果，并不会导致多次渲染。

此外再使用setState改变状态之后，立刻使用this.state去拿最新的状态往往是拿不到的，如果需要最新的state做业务的话，可以在componentDidUpdate或者setState的回调函数里获取。

1.8. 调用 setState 之后发生了什么？

在代码中调用setState函数之后，React 会将传入的参数对象与组件当前的状态合并，然后触发所谓的调和过程（Reconciliation）。经过调和过程，React 会以相对高效的方式根据新的状态构建 React 元素树并且着手重新渲染整个UI界面。在 React 得到元素树之后，React 会自动计算出新的树与老树的节点差异，然后根据差异对界面进行最小化重渲染。在差异计算算法中，React 能够相对精确地知道哪些位置发生了改变以及应该如何改变，这就保证了按需更新，而不是全部重新渲染。

1.9. 什么是JSX

JSX 是JavaScript XML 的简写。是 React 使用的一种文件，它利用 JavaScript 的表现力和类似 HTML 的模板语法。这使得 HTML 文件非常容易理解。此文件能使应用非常可靠，并能够提高其性能。

1.10. 浏览器是否可以直接读取读取JSX？

浏览器只能处理 JavaScript 对象，而不能读取常规 JavaScript 对象中的 JSX。所以为了使浏览器能够读取 JSX，首先，需要用像 Babel 这样的 JSX 转换器将 JSX 文件转换为 JavaScript 对象，然后再将其传给浏览器。

1.11. vue和react适用的场景

• vue适合webapp，适合做用户交互多，各种动态效果变化丰富的应用。特别是PC、手机的网页版，商城等页面。因为vue实现逻辑复杂的功能比较简单。
• react适合oa系统，适合大批量的数据展示、适合做大型应用。特别适合公司的后台管理系统。因为react对那种比较复杂的交互，实现起来比较麻烦，没有vue方便。同时react的渲染原理是渲染整个组件树，所以，一方面是费性能，而且代码写起来逻辑复杂。但是react对批量数据操作很厉害。
• 总而言之，项目要求比较高的适合使用react，因为react的社区更活跃一些，尤其是各种UI框架比较稳定、系统，可以信赖。Vue的社区也很活跃，但相对而言各种组件五花八门，大多数不够完善，缺乏系统性和迭代性，对于项目的后期维护和新手入手都不太友好。
• 从应用上来看，react打出来的包会大一些，相对来说，vue的包小一些，如果项目场景对加载速度由要求，建议使用vue。

2. React 组件

2.1. 为什么说在React中，一切都是组件

组件是 React 应用 UI 的构建块。这些组件将整个 UI 分成小的独立并可重用的部分。每个组件彼此独立，而不会影响 UI 的其余部分。

2.2. React 中 render() 的目的。

每个React组件强制要求必须有一个 render()。它返回一个 React 元素，是原生 DOM 组件的表示。如果需要渲染多个 HTML 元素，则必须将它们组合在一个封闭标记内，例如 <form>、<group>、<div> 等。此函数必须保持纯净，即必须每次调用时都返回相同的结果。

2.3. React组件生命周期的阶段是什么？

React 组件的生命周期有三个不同的阶段：

1. 初始渲染阶段：这是组件即将开始其生命之旅并进入 DOM 的阶段。
2. 更新阶段：一旦组件被添加到 DOM，它只有在 prop 或状态发生变化时才可能更新和重新渲染。这些只发生在这个阶段。
3. 卸载阶段：这是组件生命周期的最后阶段，组件被销毁并从 DOM 中删除。

2.4. react 生命周期函数

1. 挂载
   当组件实例被创建并插入 DOM 中时，其生命周期调用顺序如下：

• constructor()
• getDerivedStateFromProps(): 当从父类接收到 props 并且在调用另一个渲染器之前调用。
• render()
• componentDidMount(): 仅在第一次渲染后在客户端执行。

2. 更新
   当组件的 props 或 state 发生变化时会触发更新。组件更新的生命周期调用顺序如下：

• getDerivedStateFromProps(): 当从父类接收到 props 并且在调用另一个渲染器之前调用。
• shouldComponentUpdate(): 根据特定条件返回 true 或 false。如果你希望更新组件，请返回true 否则返回 false。默认情况下，它返回 false。
• render()
• getSnapshotBeforeUpdate()
• componentDidUpdate(): 在渲染发生后立即调用

3. 卸载
   当组件从 DOM 中移除时会调用如下方法：

• componentWillUnmount(): 从 DOM 卸载组件后调用。用于清理内存空间。

2.5. 在生命周期中的哪一步你应该发起 AJAX 请求？

我们应当将AJAX 请求放到 componentDidMount 函数中执行，主要原因有下：

React 下一代调和算法 Fiber 会通过开始或停止渲染的方式优化应用性能，其会影响到 componentWillMount 的触发次数。对于 componentWillMount 这个生命周期函数的调用次数会变得不确定，React 可能会多次频繁调用 componentWillMount。如果我们将 AJAX 请求放到 componentWillMount 函数中，那么显而易见其会被触发多次，自然也就不是好的选择。 (新版本的React，已经拿掉了)

如果我们将 AJAX 请求放置在生命周期的其他函数中，我们并不能保证请求仅在组件挂载完毕后才会要求响应。如果我们的数据请求在组件挂载之前就完成，并且调用了setState函数将数据添加到组件状态中，对于未挂载的组件则会报错。而在 componentDidMount 函数中进行 AJAX 请求则能有效避免这个问题。

2.6. 展示组件(Presentational component)和容器组件(Container component)之间有何不同

• 展示组件关心组件看起来是什么。展示专门通过 props 接受数据和回调，并且几乎不会有自身的状态，但当展示组件拥有自身的状态时，通常也只关心 UI 状态而不是数据的状态。
• 容器组件则更关心组件是如何运作的。容器组件会为展示组件或者其它容器组件提供数据和行为(behavior)，它们会调用 Flux actions，并将其作为回调提供给展示组件。容器组件经常是有状态的，因为它们是(其它组件的)数据源。

2.7. 调用 super(props) 的目的是什么

在 super() 被调用之前，子类是不能使用 this 的，在 ES2015 中，子类必须在 constructor 中调用 super()。

传递 props 给 super() 的原因则是便于(在子类中)能在 constructor 访问 this.props。

2.8. 除了在构造函数中绑定 this，还有其它方式吗

你可以使用属性初始值设定项(property initializers)来正确绑定回调，create-react-app 也是默认支持的。

在回调中你可以使用箭头函数，但问题是每次组件渲染时都会创建一个新的回调。

2.9. 什么是 Props?

Props 是 React 中属性的简写。它们是只读组件，必须保持纯，即不可变。它们总是在整个应用中从父组件传递到子组件。子组件永远不能将 prop 送回父组件。这有助于维护单向数据流，通常用于呈现动态生成的数据。

2.10. 什么是状态（State)？

状态是 React 组件的核心，是数据的来源，必须尽可能简单。基本上状态是确定组件呈现和行为的对象。与props 不同，它们是可变的，并创建动态和交互式组件。可以通过 this.state 访问它们。

2.11. 类组件(Class component)和函数式组件(Functional component)之间有何不同

• 类组件不仅允许你使用更多额外的功能，如组件自身的状态和生命周期钩子，也能使组件直接访问 store 并维持状态 (React v16.8以后，可以使用hook使用state和部分生命周期钩子函数)
• 当组件仅是接收 props，并将组件自身渲染到页面时，该组件就是一个 ‘无状态组件(stateless component)’，可以使用一个纯函数来创建这样的组件。这种组件也被称为哑组件(dumb components)或展示组件

2.12. 如何更新组件的状态？

1. 可以用 this.setState()更新组件的状态
2. 更新时，可以只更新部分属性，保留其他属性值

##React 中的箭头函数有什么作用
箭头函数（=>）是用于编写函数表达式的简短语法。这些函数允许正确绑定组件的上下文（不改变this），因为在 ES6 中默认下不能使用自动绑定。使用高阶函数时，箭头函数非常有用。

2.13. React中的事件是什么？

在 React 中，事件是对鼠标悬停、鼠标单击、按键等特定操作的触发反应。处理这些事件类似于处理 DOM 元素中的事件。但是有一些语法差异，如：

1. 用驼峰命名法对事件命名而不是仅使用小写字母。
2. 事件作为函数而不是字符串传递。

事件参数重包含一组特定于事件的属性。每个事件类型都包含自己的属性和行为，只能通过其事件处理程序访问。

2.14. React中的合成事件是什么？

合成事件是围绕浏览器原生事件充当跨浏览器包装器的对象。它们将不同浏览器的行为合并为一个 API。这样做是为了确保事件在不同浏览器中显示一致的属性。

2.15. 何为受控组件(controlled component)

在 HTML 中，类似 <input>, <textarea> 和 <select> 这样的表单元素会维护自身的状态，并基于用户的输入来更新。当用户提交表单时，前面提到的元素的值将随表单一起被发送。但在 React 中会有些不同，包含表单元素的组件将会在 state 中追踪输入的值，并且每次调用回调函数时，如 onChange 会更新 state，重新渲染组件。一个输入表单元素，它的值通过 React 的这种方式来控制，这样的元素就被称为”受控元素”。

2.16. React 的 refs 有什么作用？

Refs 是 React 中引用的简写。它是一个有助于存储对特定的 React 元素或组件的引用的属性，它将由组件渲染配置函数返回。用于对 render() 返回的特定元素或组件的引用。当需要进行 DOM 测量或向组件添加方法时，它们会派上用场。

2.17. 列出一些应该使用 Refs 的情况

• 需要管理焦点、选择文本或媒体播放时
• 触发式动画
• 与第三方 DOM 库集成

2.18. shouldComponentUpdate 是做什么的，（react 性能优化是哪个周期函数？）

shouldComponentUpdate 这个方法用来判断是否需要调用 render 方法重新描绘 dom。因为 dom 的描绘非常消耗性能，如果我们能在 shouldComponentUpdate 方法中能够写出更优化的 dom diff 算法，可以极大的提高性能。

2.19. 什么是高阶组件（HOC - higher order component）？

高阶组件是重用组件逻辑的高级方法，是一种源于 React 的组件模式。 HOC 是自定义组件，在它之内包含另一个组件。它们可以接受子组件提供的任何动态，但不会修改或复制其输入组件中的任何行为。你可以认为 HOC 是“纯（Pure）”组件。

2.20. 你能用HOC做什么？

• 代码重用，逻辑和引导抽象
• 渲染劫持
• 状态抽象和控制
• Props 控制

2.21. 什么是纯组件（Pure Component）？

纯（Pure） 组件是可以编写的最简单、最快的组件。它们可以替换任何只有 render() 的组件。这些组件增强了代码的简单性和应用的性能。

2.22. React 中 key 的重要性是什么？

key 用于识别唯一的 Virtual DOM 元素及其驱动 UI 的相应数据。它们通过回收 DOM 中当前所有的元素来帮助 React 优化渲染。这些 key 必须是唯一的数字或字符串，React 只是重新排序元素而不是重新渲染它们。这可以提高应用程序的性能。

3. Redux

3.1. 什么是Flux

Flux 是一种强制单向数据流的架构模式。它控制派生数据，并使用具有所有数据权限的中心 store 实现多个组件之间的通信。整个应用中的数据更新必须只能在此处进行。 Flux 为应用提供稳定性并减少运行时的错误。

3.2. 什么是Redux？

Redux 是当今最热门的前端开发库之一。它是 JavaScript 程序的可预测状态容器，用于整个应用的状态管理。使用 Redux 开发的应用易于测试，可以在不同环境中运行，并显示一致的行为。

3.3. Redux遵循的三个原则是什么？

1. 单一事实来源：整个应用的状态存储在单个 store 中的对象/状态树里。单一状态树可以更容易地跟踪随时间的变化，并调试或检查应用程序。
2. 状态是只读的：改变状态的唯一方法是去触发一个动作。动作是描述变化的普通 JS 对象。就像 state 是数据的最小表示一样，该操作是对数据更改的最小表示。
3. 使用纯函数进行更改：为了指定状态树如何通过操作进行转换，你需要纯函数。纯函数是那些返回值仅取决于其参数值的函数。

3.4. “单一事实来源”有什么理解？

Redux 使用 “Store” 将程序的整个状态存储在同一个地方。因此所有组件的状态都存储在 Store 中，并且它们从 Store 本身接收更新。单一状态树可以更容易地跟踪随时间的变化，并调试或检查程序。

3.5. 列出 Redux 的组件

• Action – 这是一个用来描述发生了什么事情的对象。React 中的 Action 必须具有 type 属性，该属性指示正在执行的 ACTION 的类型。必须将它们定义为字符串常量，并且还可以向其添加更多的属性。在 Redux 中，action 被名为 Action Creators 的函数所创建。
• Reducer – 这是一个确定状态将如何变化的地方。Reducers 是纯函数，它规定应用程序的状态怎样因响应 ACTION 而改变。Reducers 通过接受先前的状态和 action 来工作，然后它返回一个新的状态。它根据操作的类型确定需要执行哪种更新，然后返回新的值。如果不需要完成任务，它会返回原来的状态。
• Store – 整个程序的状态/对象树保存在Store中。 Store 是一个 JavaScript 对象，它可以保存程序的状态，并提供一些方法来访问状态、调度操作和注册侦听器。
• View – 只显示 Store 提供的数据。

3.6. Redux与Flux的区别

3.7. Redux 有哪些优点？

• 结果的可预测性 - 由于总是存在一个真实来源，即 store ，因此不存在如何将当前状态与动作和应用的其他部分同步的问题。
• 可维护性 - 代码变得更容易维护，具有可预测的结果和严格的结构。
• 服务器端渲染 - 你只需将服务器上创建的 store 传到客户端即可。这对初始渲染非常有用，并且可以优化应用性能，从而提供更好的用户体验。
• 开发人员工具 - 从操作到状态更改，开发人员可以实时跟踪应用中发生的所有事情。
• 社区和生态系统 - Redux 背后有一个巨大的社区，这使得它更加迷人。一个由才华横溢的人组成的大型社区为库的改进做出了贡献，并开发了各种应用。
• 易于测试 - Redux 的代码主要是小巧、纯粹和独立的功能。这使代码可测试且独立。
• 组织 - Redux 准确地说明了代码的组织方式，这使得代码在团队使用时更加一致和简单。

4. React Router

4.1. 为什么需要 React 中的路由？

Router 用于定义多个路由，当用户定义特定的 URL 时，如果此 URL 与 Router 内定义的任何 “路由” 的路径匹配，则用户将重定向到该特定路由。所以基本上我们需要在自己的应用中添加一个 Router 库，允许创建多个路由，每个路由都会向我们提供一个独特的视图。

4.2. 什么是React 路由？

React 路由是一个构建在 React 之上的强大的路由库，它有助于向应用程序添加新的屏幕和流。这使 URL 与网页上显示的数据保持同步。它负责维护标准化的结构和行为，并用于开发单页 Web 应用。 React 路由有一个简单的API。

4.3. React Router 的优点。

• 就像 React 基于组件一样，在 React Router v4 中，API 是 ‘All About Components’。可以将 Router 可视化为单个根组件（），其中我们将特定的子路由（）包起来。
• 无需手动设置历史值：在 React Router v4 中，我们要做的就是将路由包装在 组件中。
• 包是分开的：共有三个包，分别用于 Web、Native 和 Core。这使我们应用更加紧凑。基于类似的编码风格很容易进行切换