React状态管理常见面试题目（一）

1. Redux 如何实现多个组件之间的通信?多个组件使用相同状态时如何进行管理?

Redux 实现组件通信

Redux 是一个集中式的状态管理工具，通过共享一个全局 store 来实现多个组件之间的通信。

  • 通信机制：
    1. 所有状态保存在 Redux 的全局 store 中。
    2. 使用 mapStateToProps 或 useSelector 获取状态。
    3. 通过 dispatch 分发动作更新状态。
    4. 状态变化后，所有订阅该状态的组件自动重新渲染。
示例
import React from 'react';
import { createStore } from 'redux';
import { Provider, useSelector, useDispatch } from 'react-redux';const initialState = { count: 0 };// Reducer
const counterReducer = (state = initialState, action) => {switch (action.type) {case 'INCREMENT':return { count: state.count + 1 };case 'DECREMENT':return { count: state.count - 1 };default:return state;}
};// Store
const store = createStore(counterReducer);// Component A (Increment)
function Increment() {const dispatch = useDispatch();return <button onClick={() => dispatch({ type: 'INCREMENT' })}>Increment</button>;
}// Component B (Display)
function Display() {const count = useSelector((state) => state.count);return <div>Count: {count}</div>;
}// App
function App() {return (<Provider store={store}><Increment /><Display /></Provider>);
}
  • 多个组件共享状态：
    • 所有组件从 store 中读取状态。
    • 当状态更新时，订阅了该状态的组件会自动重新渲染。

2. Redux 中间件的实现原理是什么?

中间件原理

Redux 中间件通过对 dispatch 方法进行拦截和增强，允许在动作分发（dispatch）和到达 Reducer 之间执行自定义逻辑。

  • Middleware 核心代码：
    const loggerMiddleware = (store) => (next) => (action) => {console.log('Action:', action);let result = next(action); // 执行下一个中间件或 Reducerconsole.log('New State:', store.getState());return result;
};
使用中间件的流程
  1. 创建中间件（如日志、异步操作）。
  2. 使用 applyMiddleware 将中间件添加到 store。
  3. 中间件在每次 dispatch 时被调用。
示例
import { createStore, applyMiddleware } from 'redux';const logger = (store) => (next) => (action) => {console.log('Dispatching:', action);let result = next(action);console.log('State after dispatch:', store.getState());return result;
};const store = createStore(counterReducer, applyMiddleware(logger));

3. 什么是 React 的状态提升?使用场景有哪些?

状态提升

状态提升是指将多个子组件需要共享的状态提升到它们的共同父组件中，父组件负责管理状态并通过 props 将状态和更新函数传递给子组件。

使用场景
  • 多个组件需要共享同一个状态。
  • 一个组件的状态变化会影响另一个组件。
  • 示例：表单输入同步、计数器共享。
示例代码
function Parent() {const [count, setCount] = React.useState(0);return (<div><ChildA count={count} /><ChildB increment={() => setCount(count + 1)} /></div>);
}function ChildA({ count }) {return <div>Count: {count}</div>;
}function ChildB({ increment }) {return <button onClick={increment}>Increment</button>;
}

4. Redux 中如何设置初始状态?

设置初始状态的两种方式

  1. 在 Reducer 中定义：

    const initialState = { count: 0 };const reducer = (state = initialState, action) => {switch (action.type) {case 'INCREMENT':return { count: state.count + 1 };default:return state;}
};

  2. 创建 Store 时传入：

    const preloadedState = { count: 5 };
const store = createStore(reducer, preloadedState);

5. React 组件间共享数据的方法有哪些?

  1. 通过 props 传递：

    • 适用于父子组件之间的数据共享。

  2. 通过 Context API：

    • 用于避免多层级的 props 传递。
    const MyContext = React.createContext();
<MyContext.Provider value={sharedValue}><Child />
</MyContext.Provider>;

  3. 通过 Redux：

    • 适合全局状态管理。

  4. 自定义 Hook：

    • 用于共享逻辑和状态。
    function useSharedState() {const [state, setState] = React.useState(initialValue);return [state, setState];
}

6. 请描述点击按钮触发到状态更改的数据流向

  1. 用户点击按钮。
  2. 触发事件处理函数，调用 dispatch。
  3. dispatch 将 action 传递给 Reducer。
  4. Reducer 根据 action 更新状态。
  5. Redux store 通知订阅的组件，重新渲染。

7. 什么是 Flux?它的设计思想是什么?有哪些应用场景?

Flux

Flux 是 Facebook 提出的单向数据流架构，解决复杂组件间的状态管理问题。

核心设计思想
  1. 单向数据流：
    • 数据流动方向为：Action -> Dispatcher -> Store -> View。
  2. 集中式状态管理：
    • 状态集中存储在 Store 中。
  3. 事件驱动：
    • Action 是状态变化的唯一来源。
应用场景
  • 单页面应用（SPA）。
  • 需要共享状态的复杂组件结构。
  • 比如，购物车、社交网络应用等。

8. React 状态管理器的核心精髓是什么?

  • 状态集中管理：

    • 使用全局 store 保存共享状态，组件从 store 获取状态。

  • 不可变性：

    • 状态是不可变的，任何更新都返回一个新状态。

  • 单向数据流：

    • 数据从 store 流向组件，组件通过 action 修改状态。

9. redux-saga 的实现原理是怎样的?

实现原理

redux-saga 是一个基于 Generator 函数的 Redux 中间件，用于处理复杂的异步逻辑。它通过 take, call, 和 put 等 Effect 来控制异步操作。

核心流程
  1. Saga 监听特定的 action（take）。
  2. 使用 call 执行异步任务。
  3. 使用 put 触发新的 action。
示例
import { call, put, takeEvery } from 'redux-saga/effects';
import axios from 'axios';function* fetchData(action) {try {const data = yield call(axios.get, '/api/data');yield put({ type: 'FETCH_SUCCESS', payload: data });} catch (e) {yield put({ type: 'FETCH_ERROR', message: e.message });}
}function* mySaga() {yield takeEvery('FETCH_REQUEST', fetchData);
}

10. React 状态管理 MobX 的设计思想是什么?

MobX 的设计思想

  1. 响应式编程：

    • 状态变化时，视图自动更新，无需手动监听。

  2. 基于观察者模式：

    • 数据（observable）被观察，组件（observer）监听其变化。

  3. 面向对象：

    • 状态可以封装在类中，符合传统的 OOP 编程习惯。

11. Redux 中如何处理异步请求?

Redux 不能直接处理异步请求，需要通过中间件（如 redux-thunk 或 redux-saga）。

使用 redux-thunk

redux-thunk 允许在 dispatch 函数中返回异步函数：

const fetchData = () => async (dispatch) => {dispatch({ type: 'FETCH_REQUEST' });try {const response = await fetch('/api/data');const data = await response.json();dispatch({ type: 'FETCH_SUCCESS', payload: data });} catch (error) {dispatch({ type: 'FETCH_ERROR', payload: error });}
};

以上是详细的回答和示例代码，希望对你理解这些概念有所帮助！

1. 当 React 的多个组件有自己的 state，同时需要维护一些公共状态时，该如何设计和管理这些状态?

当多个组件有自己的局部状态，同时需要共享公共状态，可以采用以下方法进行设计和管理：

1.1 Context API
  • 使用 React 的 Context API 维护公共状态，避免繁琐的 props 传递。
  • 局部状态仍然使用 useState 或 useReducer。

示例：

const CounterContext = React.createContext();function Parent() {const [count, setCount] = React.useState(0);return (<CounterContext.Provider value={{ count, setCount }}><ChildA /><ChildB /></CounterContext.Provider>);
}function ChildA() {const { count } = React.useContext(CounterContext);return <div>Count: {count}</div>;
}function ChildB() {const { setCount } = React.useContext(CounterContext);return <button onClick={() => setCount((prev) => prev + 1)}>Increment</button>;
}
1.2 使用 Redux
  • 适合管理复杂的共享状态。
  • 将公共状态存储在 Redux store 中，局部状态仍然独立管理。

示例：

const initialState = { count: 0 };
const reducer = (state = initialState, action) => {switch (action.type) {case 'INCREMENT':return { count: state.count + 1 };default:return state;}
};const store = createStore(reducer);
1.3 结合 Context 和局部状态
  • Context 提供共享状态，局部状态通过组件内的 useState 单独管理，避免全局状态过于复杂。

2. Redux 和 Flux 的区别是什么?

特性FluxRedux
数据流多个 Store，可多向通信单一 Store，单向数据流
状态管理状态分散在多个 Store 中状态集中管理在全局 Store 中
更新机制Dispatcher 广播 ActionReducer 根据 Action 返回新状态
设计复杂度需要自己实现 Dispatcher 和 StoreRedux 提供完整解决方案
易用性灵活但需手动管理API 简单，约束明确

3. MobX 和 Redux 状态管理有什么区别?

特性MobXRedux
核心理念响应式编程，基于观察者模式强制单向数据流
状态管理状态分布式管理状态集中式管理
学习曲线简单易学，语法自然需要理解 Redux 的核心概念
性能小范围状态更新整体状态更新（需要优化）
异步处理内置支持，直接写普通异步代码需通过中间件（如 Thunk/Saga）实现
复杂性灵活但容易失控明确但可能显得冗长

4. Redux 有哪些优缺点?

优点：
  1. 单向数据流：状态管理清晰，易于调试。
  2. 集中式管理：全局 Store 提供了统一的数据源，易于跟踪状态。
  3. 社区支持：丰富的生态系统和中间件支持。
  4. 可预测性：状态更新逻辑纯粹且可预测。
缺点：
  1. 样板代码多：需要编写 Action、Reducer 等，复杂场景下代码较多。
  2. 学习成本高：需掌握 Redux 的核心概念和中间件。
  3. 性能问题：不优化时可能导致性能瓶颈。

5. Redux 的中间件是什么?有哪些常用的 Redux 中间件?

中间件定义

Redux 中间件是对 dispatch 方法的增强，用于在 action 到达 Reducer 前执行额外的逻辑。

常用中间件

  1. redux-thunk：

    • 支持异步 action，允许 action 返回函数而不是对象。
    const fetchData = () => async (dispatch) => {const data = await fetch('/api').then((res) => res.json());dispatch({ type: 'DATA_LOADED', payload: data });
};

  2. redux-saga：

    • 使用 Generator 函数管理异步操作。
    function* fetchDataSaga() {const data = yield call(fetch, '/api');yield put({ type: 'DATA_LOADED', payload: data });
}

  3. redux-logger：

    • 打印 action 和状态变化的日志，便于调试。

6. Redux 的 store 是什么?

  • Redux Store 是整个应用的状态容器，用于存储和管理全局状态。
  • 它通过以下方法与应用交互：
    1. getState：获取当前状态。
    2. dispatch：分发 action。
    3. subscribe：订阅状态变化。

创建 Store：

import { createStore } from 'redux';
const store = createStore(reducer);

7. Redux 中如何重置状态?

方法 1：定义一个 RESET Action
const initialState = { count: 0 };const reducer = (state = initialState, action) => {switch (action.type) {case 'RESET':return initialState;default:return state;}
};// Dispatch 重置
store.dispatch({ type: 'RESET' });
方法 2：创建新 Reducer
const rootReducer = (state, action) => {if (action.type === 'RESET') {return undefined; // 清空状态}return appReducer(state, action);
};

8. Redux 状态管理器与将变量挂载到 window 对象中有什么区别?

特性Redux 状态管理器挂载到 window 对象
作用域控制状态在组件内访问，作用域明确全局变量容易污染命名空间
调试能力支持调试工具查看状态变化无法直接追踪变量变化
状态更新通过 Reducer 保持状态不可变全局变量可随意修改，易出错
组件通信统一数据流，方便跨组件共享需要手动管理数据流
扩展性支持中间件、插件扩展缺乏扩展能力

9. 什么是 React 的 contextType?它的作用是什么?

contextType
  • contextType 是 React 提供的一个类组件属性，用于订阅 Context 对象。
  • 在类组件中，可以直接通过 this.context 访问 Context 的值。
作用
  1. 提供跨组件共享数据的能力。
  2. 替代多层级的 props 传递。
示例
const MyContext = React.createContext('default value');class MyComponent extends React.Component {static contextType = MyContext; // 订阅 Contextrender() {return <div>Value: {this.context}</div>;}
}// 使用
<MyContext.Provider value="provided value"><MyComponent />
</MyContext.Provider>

输出：Value: provided value

限制
  • 仅适用于类组件；函数组件可以使用 useContext 替代。

通过这些详细回答，希望能更清晰地理解 React 和 Redux 状态管理相关概念及其应用。

1. 在 Redux 中如何发起网络请求?

Redux 本身不支持直接发起网络请求，但可以通过中间件（如 redux-thunk 或 redux-saga）来实现。

使用 redux-thunk
// Action creator
const fetchData = () => async (dispatch) => {dispatch({ type: 'FETCH_DATA_START' });try {const response = await fetch('/api/data');const data = await response.json();dispatch({ type: 'FETCH_DATA_SUCCESS', payload: data });} catch (error) {dispatch({ type: 'FETCH_DATA_FAILURE', error });}
};
使用 redux-saga
import { call, put, takeEvery } from 'redux-saga/effects';function* fetchDataSaga() {try {const response = yield call(fetch, '/api/data');const data = yield response.json();yield put({ type: 'FETCH_DATA_SUCCESS', payload: data });} catch (error) {yield put({ type: 'FETCH_DATA_FAILURE', error });}
}// Watcher Saga
function* watchFetchData() {yield takeEvery('FETCH_DATA_START', fetchDataSaga);
}

2. Redux 中间件如何获取 store 和 action?它们是如何处理的?

中间件获取 Store 和 Action

Redux 中间件通过函数链的形式接入 Redux 流程。中间件接收以下三个参数：

  1. store：通过 store.getState() 获取当前状态。
  2. next：调用以继续分发到下一个中间件或 Reducer。
  3. action：当前分发的动作。
中间件实现机制

中间件通过增强 dispatch 方法实现其功能：

const loggerMiddleware = (store) => (next) => (action) => {console.log('Dispatching:', action);const result = next(action); // 调用下一个中间件或 reducerconsole.log('Next State:', store.getState());return result;
};

3. 什么是 React 的 childContextTypes?它的作用是什么?

定义
  • childContextTypes 是 React 中的一个旧 API，用于声明子组件可以访问的上下文数据类型（在 Context API 之前）。
  • 它通过 getChildContext() 方法提供上下文。
作用

允许父组件向深层嵌套的子组件传递数据，而不需要通过 props 层层传递。

示例
import PropTypes from 'prop-types';class Parent extends React.Component {getChildContext() {return { theme: 'dark' };}render() {return <Child />;}
}Parent.childContextTypes = {theme: PropTypes.string,
};class Child extends React.Component {render() {return <div>{this.context.theme}</div>;}
}Child.contextTypes = {theme: PropTypes.string,
};

4. 在 React 中，如何使用 Context API?

使用 Context API 的步骤

  1. 创建 Context

    const MyContext = React.createContext(defaultValue);

  2. 提供 Context

    <MyContext.Provider value={value}>{children}
</MyContext.Provider>

  3. 消费 Context

    • 类组件：使用 static contextType。
    • 函数组件：使用 useContext 钩子。
示例
const ThemeContext = React.createContext('light');function App() {return (<ThemeContext.Provider value="dark"><Toolbar /></ThemeContext.Provider>);
}function Toolbar() {const theme = React.useContext(ThemeContext); // 消费 Contextreturn <div>Theme: {theme}</div>;
}

5. 请解释 Redux 的核心概念、设计思想、工作流程和工作原理

核心概念
  1. Store：存储应用状态。
  2. Action：描述状态变化的事件对象。
  3. Reducer：定义如何根据 action 更新状态。
  4. Middleware：扩展 dispatch 功能的插件。
  5. 单向数据流：状态流转的方向是固定的，易于维护。
设计思想
  • 状态管理的核心是单向数据流和不可变状态。
  • 状态只通过 dispatch(action) 和 Reducer 更新。
工作流程
  1. 用户触发 action。
  2. dispatch 传递 action 到中间件。
  3. 中间件处理后，传递给 Reducer。
  4. Reducer 返回新状态并更新 Store。
工作原理

Redux 的内部通过以下机制保持状态流转：

  • 中间件拦截 dispatch，执行异步逻辑或扩展功能。
  • 状态更新由 Reducer 的纯函数返回新对象，保证不可变性。

6. Redux 是否建议在 Reducer 中触发 Action?为什么?

结论

Redux 不建议在 Reducer 中触发 action。

原因
  1. Reducer 必须是纯函数：
    • Reducer 不应有副作用（如触发异步操作或调度 action）。
  2. 破坏单向数据流：
    • 在 Reducer 中触发 action 会导致状态更新流程复杂化。

7. Redux 的数据存储和本地存储有什么区别?

特性Redux 数据存储本地存储（LocalStorage）
作用范围当前运行的应用跨页面持久化
数据更新状态不可变，通过 action 更新可随意直接修改
生命周期随应用生命周期存在持久化，需手动清理
同步性即时更新组件手动检测变化

8. 什么是 redux-saga 中间件?它有什么作用?

定义

redux-saga 是 Redux 的异步中间件，用于管理复杂的异步流程。

作用
  1. 处理副作用：如 API 请求、定时器等。
  2. 流控制：优雅地处理并发任务、队列任务。
  3. 易测试：基于 Generator 函数，易于测试异步逻辑。
示例
function* fetchDataSaga() {const data = yield call(fetch, '/api/data');yield put({ type: 'DATA_SUCCESS', payload: data });
}

9. Redux 如何添加新的中间件?

步骤

  1. 引入中间件：

    import { applyMiddleware, createStore } from 'redux';
import thunk from 'redux-thunk';
const store = createStore(reducer, applyMiddleware(thunk));

  2. 组合多个中间件：

    const middlewares = [thunk, logger];
const store = createStore(reducer, applyMiddleware(...middlewares));

10. Redux 请求中间件如何处理并发请求?

通过唯一标识管理并发请求

在 Action 中添加唯一标识，标记请求的起始和结束。

const fetchData = (id) => async (dispatch) => {dispatch({ type: 'REQUEST_START', id });const data = await fetch(`/api/data/${id}`).then((res) => res.json());dispatch({ type: 'REQUEST_SUCCESS', id, data });
};
通过 redux-saga 实现取消任务

使用 takeLatest 确保只保留最近的一次请求。

import { takeLatest, call, put } from 'redux-saga/effects';function* fetchData(action) {const data = yield call(fetch, `/api/data/${action.id}`);yield put({ type: 'DATA_SUCCESS', payload: data });
}function* watchFetchData() {yield takeLatest('FETCH_REQUEST', fetchData);
}

通过以上回答，全面覆盖了 Redux 中如何处理网络请求、状态管理和中间件扩展。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/491999.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【C++游记】string的使用和模拟实现

【C++游记】string的使用和模拟实现

枫の个人主页 你不能改变过去&#xff0c;但你可以改变未来 算法/C/数据结构/C Hello&#xff0c;这里是小枫。C语言与数据结构和算法初阶两个板块都更新完毕&#xff0c;我们继续来学习C的内容呀。C是接近底层有比较经典的语言&#xff0c;因此学习起来注定枯燥无味&#xf…
阅读更多...
飞牛 fnos 上用docker部署一款网页端办公系统

飞牛 fnos 上用docker部署一款网页端办公系统

描述 一款高效的内网办公操作系统&#xff0c;内含word/excel/ppt/pdf/内网聊天/白板/思维导图等多个办公系统工具&#xff0c;支持原生文件存储。平台界面精仿windows风格&#xff0c;操作简便&#xff0c;同时保持低资源消耗和高性能运行。无需注册即可自动连接内网用户&…
阅读更多...
【网络安全】网站常见安全漏洞—服务端漏洞介绍

【网络安全】网站常见安全漏洞—服务端漏洞介绍

文章目录 网站常见安全漏洞—服务端漏洞介绍引言1. 第三方组件漏洞什么是第三方组件漏洞&#xff1f;如何防范&#xff1f; 2. SQL 注入什么是SQL注入&#xff1f;如何防范&#xff1f; 3. 命令执行漏洞什么是命令执行漏洞&#xff1f;如何防范&#xff1f; 4. 越权漏洞什么是越…
阅读更多...
单元测试-Unittest框架实践

单元测试-Unittest框架实践

文章目录 1.Unittest简介1.1 自动化测试用例编写步骤1.2 相关概念1.3 用例编写规则1.4 断言方法 2.示例2.1 业务代码2.2 编写测试用例2.3 生成报告2.3.1 方法12.3.2 方法2 1.Unittest简介 Unittest是Python自带的单元测试框架&#xff0c;适用于&#xff1a;单元测试、Web自动…
阅读更多...
C++动态规划解决最长公共子序列

C++动态规划解决最长公共子序列

动规非常经典的一道题目&#xff0c;由于需要用到二维数组——姑且算为中等难度的题目&#xff0c;其实和01背包有着极高的相似度&#xff0c;无论是实现还是理论。 今天这篇博客不讲过多的DP理论&#xff0c;重在讲解题目本身。其实有一定经验的同志都清楚&#xff0c;DP的难点…
阅读更多...
学习日志024--opencv中处理轮廓的函数

学习日志024--opencv中处理轮廓的函数

目录 前言​​​​​​​ 一、 梯度处理的sobel算子函数 功能 参数 返回值 代码演示 二、梯度处理拉普拉斯算子 功能 参数 返回值 代码演示 三、Canny算子 功能 参数 返回值 代码演示 四、findContours函数与drawContours函数 功能 参数 返回值 代码演示 …
阅读更多...
《Modern CMake for C++》学习笔记

《Modern CMake for C++》学习笔记

学习 Modern CMake for C - Second Edition 时的学习笔记&#xff0c;供大家参考。 相关资源&#xff1a; 原书链接&#xff1a; Modern CMake for C: Effortlessly build cutting-edge C code and deliver high-quality solutions , Second Edition 中文翻译链接&#xff1a…
阅读更多...
实战 | 某院校小程序记录

实战 | 某院校小程序记录

更多大厂面试经验的视频分享看主页和专栏 目录&#xff1a; 前言&#xff1a; 渗透思路 1.绕过前端 2.信息泄露 3.爆破用户账号密码 4.信息泄露2 结束 前言&#xff1a; 遇到一个学校小程序的站点&#xff0c;只在前端登录口做了校验&#xff0c;后端没有任何校验&#x…
阅读更多...
Visual studio的AI插件-通义灵码

Visual studio的AI插件-通义灵码

通义灵码 TONGYI Lingma 兼容 Visual Studio、Visual Studio Code、JetBrains IDEs 等主流 IDE&#xff1b;支持 Java、Python、Go、C/C、C#、JavaScript、TypeScript、PHP、Ruby、Rust、Scala 等主流编程语言。 安装 打开扩展管理器&#xff0c;搜送“TONGYI Lingma”&…
阅读更多...
【泛微系统】HR同步功能实例讲解

【泛微系统】HR同步功能实例讲解

HR同步功能实例讲解\ 前言 HR同步是指ecology与专业的人事管理软件进行数据同步的功能，ecology中的组织结构和人员信息将完全取自HR软件。 官方HR同步功能解释 实例背景 客户本身有外购EHR系统用于员工的入转调离的基础信息管理，现又外购泛微的OA系统用于企业信息协同办…
阅读更多...
【测试】Pytest

【测试】Pytest

建议关注、收藏&#xff01; 目录 功能pytest 自动化测试工具。 功能 单元测试&#xff1a;用于验证代码的最小功能单元&#xff08;如函数、方法&#xff09;的正确性。 简单的语法&#xff1a;不需要继承特定类或使用复杂的结构。断言语句简化。 自动发现测试&#xff1a;P…
阅读更多...
实验12 socket网络编程

实验12 socket网络编程

设计程序 1&#xff0e;阅读TCP、UDP数据通信的例子8-2、8-7&#xff0c;理解并运行查看其功能。 2. 编写程序&#xff0c;使用socket网络接口函数&#xff0c;实现同一网段的两台主机的聊天。注&#xff1a;使用多线程&#xff0c;实现实时聊天功能。&#xff08;使用UDP或TCP…
阅读更多...
【LeetCode】2406、将区间分为最少组数

【LeetCode】2406、将区间分为最少组数

【LeetCode】2406、将区间分为最少组数 文章目录 一、数据结构-堆、贪心1.1 数据结构-堆、贪心1.2 多语言解法 二、扫描线2.1 扫描线 一、数据结构-堆、贪心 1.1 数据结构-堆、贪心 题目已知一些区间, 需要尽量合并, 使 组 最少. 可以用图解画一下 因为尽量合并, 为了紧凑, …
阅读更多...
【Python】利用函数模拟创建【栈】的数据结构操作

【Python】利用函数模拟创建【栈】的数据结构操作

知识解读&#xff1a;来自&#xff1a;https://fishc.com.cn[#FwSB,M 9xKOA!^6fP)_EC(nsd什么是栈呢&#xff1f;Powered by https://fishc.com.cn3>A?5JXL#_}YBGD"FWdubKeyhQP栈是一种具有 FILO 特性的数据结构&#xff0c;即先放入的数据反而后取出。e&"%b…
阅读更多...
JAVA入门：使用IDE开发

JAVA入门：使用IDE开发

JAVA入门：使用IDE开发 什么是IDE IDE（Integrated Development Environment，集成开发环境）是一种软件应用程序，它为程序开发、软件设计、项目管理等提供全面的设施。 简单来说就是简化开发过程，让编程更加方便。 IDEA 业界公认最好用的JAVA IDE 安装IDEA 打开IDEA官…
阅读更多...
机器学习《西瓜书》学习笔记《待续》

机器学习《西瓜书》学习笔记《待续》

如果说&#xff0c;计算机科学是研究关于“算法”的学问&#xff0c;那么机器学习就是研究关于“学习算法”的学问。 目录 绪论引言基本术语 扩展向量的张成-span使用Markdown语法编写数学公式希腊字母的LaTex语法插入一些数学的结构插入定界符插入一些可变大小的符号插入一些函…
阅读更多...
o1 Pro模型架构揭秘与 Scaling Law 深度解析 | Claude 3.5 Opus、草莓训练、推理成本剖析

o1 Pro模型架构揭秘与 Scaling Law 深度解析 | Claude 3.5 Opus、草莓训练、推理成本剖析

引言 近期&#xff0c;Semianalysis 发布了一篇重磅万字长文&#xff0c;首次披露 OpenAI 的 o1 Pro 模型架构与推理训练方法&#xff0c;同时深入探讨了当前 AI 领域的重要话题&#xff1a; Claude 3.5 Opus 是否失败&#xff1f;Scaling Laws&#xff08;扩展法则&#xff…
阅读更多...
流程引擎Activiti性能优化方案

流程引擎Activiti性能优化方案

流程引擎Activiti性能优化方案 Activiti工作流引擎架构概述 Activiti工作流引擎架构大致分为6层。从上到下依次为工作流引擎层、部署层、业务接口层、命令拦截层、命令层和行为层。 基于关系型数据库层面优化 MySQL建表语句优化 Activiti在MySQL中创建默认字符集为utf8&…
阅读更多...
labml.ai Deep Learning Paper Implementations (带注释的 PyTorch 版论文实现)

labml.ai Deep Learning Paper Implementations (带注释的 PyTorch 版论文实现)

labml.ai Deep Learning Paper Implementations {带注释的 PyTorch 版论文实现} 1. labml.ai2. labml.ai Deep Learning Paper Implementations3. Sampling Techniques for Language Models (语言模型的采样技术)4. Multi-Headed Attention (MHA)References 1. labml.ai https…
阅读更多...
qemu源码解析【04】qom实例

qemu源码解析【04】qom实例

目录 qemu源码解析【04】qom实例1. type_init()宏2. type_register_static()宏3. arm_sbcon_i2c_init()何时被qemu系统调用 qemu源码解析【04】qom实例 qemu源码解析【总目录】 继续分析arm_sbcon_i2c实例&#xff0c;代码从行尾往上逐步分析 #include "qemu/osdep.h&q…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023