This article mainly introduces a brief discussion of React high-order components. Now I will share it with you and give you a reference.
Some time ago when I was writing a Hybrid page at work, I encountered such a scenario. The company needed a series of active components, and when each component was registered, it needed to call an interface provided by the App. Several methods were considered at the beginning, including mixins, component inheritance, and react higher-order components. But after various considerations, we finally chose to use high-level components.
So what are advanced components? First of all, you must first understand that requesting classes in ES6 is just syntactic sugar, and the essence is prototypal inheritance. To better illustrate this, we will not modify the component's code. Instead, it provides components that wrap components and enhance them with additional functionality. We call such components higher-order components (Higher-Order Component).
1. Disadvantages of Mixins
React officially does not recommend the use of Mixins technology to achieve code reuse. Mixins technology has a series of shortcomings. First, Mixins will cause naming problems. Conflict, we inject Mixins in the following way:
var myMixins = require('myMixins'); var Button = React.createClass({ mixins: [myMixins], // ... })
If you need to inject multiple mixins, one of them is your own, and the other may be a third party of. It is possible to use a method with the same name in two mixins, which will cause one of them to not work, and all you can do is change the name of one of the methods. On the other hand, a mixins may be very simple at first, only needing to implement a certain function, but when the business becomes more complex and more methods need to be added, it will become very complicated. To learn more about the shortcomings of mixins, you can check out the official blog.
2. Component inheritance
For myself, this method has been used more often. First, create a BaseComponent and implement a series of public methods in it. Each subsequent component inherits from this component, but the disadvantage is that it is not flexible enough. Only some relatively fixed methods can be implemented in the basic components, and there are great restrictions on the customization of each component.
3. React high-order components
Due to a series of shortcomings of mixins, React officials also realized that the pain points caused by using mixins are far higher than those caused by the technology itself. Advantages, high-order components can replace mixins, and it has richer uses when you go deeper.
Higher-order components (HOC) are advanced technologies in React that reuse component logic. But higher-order components themselves are not React APIs. It's just a pattern that arises inevitably from the compositional nature of React itself.
Higher-order function
Speaking of high-order components, we must first talk about high-order functions. High-order functions are functions that at least meet the following conditions :
1. Accept one or more functions as input
2. Output a function
In JavaScript, a language where functions are first-class citizens, higher-order functions There are still many uses, such as our usual callback functions, etc., which all use the knowledge of high-order functions. Let's first look at a simple higher-order function
var fun = function(x, y) { return x + y; }
fun is a function. Next we pass the entire function as a parameter to another function
var comp = function(x, y, f) { return f(x,y); }
Verify it
comp(1,2,fun) // 3
Higher-order component definition
Analogy to the definition of a higher-order function, a higher-order component accepts a component as a parameter, performs a series of processes on the component in the function, and then returns a new component as the return value.
We first define a high-order component BaseActivity
const BaseActivity = (WrappedComponent) => { return class extends Component { render() { return ( <section> <p>我的包裹组件</p> <WrappedComponent /> </section> ) } } }
The component accepts a wrapped component as a parameter and returns a processed anonymous components.
Use this high-order component in other components
class Example extends React.PureComponent { constructor(props) { super(props); this.state = { width: '100%', height: '100%' } } componentWillMount() { if ((navigator.userAgent.match(/(phone|pad|pod|iPhone|iPod|ios|iPad|Android|Mobile|BlackBerry|IEMobile|MQQBrowser|JUC|Fennec|wOSBrowser|BrowserNG|WebOS|Symbian|Windows Phone)/i))) { return; } else { this.setState({ width: '375px', height: '640px' }) } } render() { let { width, height } = this.state; return ( <p className="activity"> <p className="activity-content" style={{ width, height }}> <button className="btn">参加活动</button> </p> </p> ) } } export default BaseActivity(Example);
The specific usage is to use the BaseActivity function when exporting the component. Wrap this component and look at the output react dom content
An anonymous component is wrapped outside the Example component.
Parameters
Since the higher-order component is a function, we can pass the parameters we need to it
const BaseActivity = (WrappedComponent, title) => { return class extends Component { render() { return ( <section> <p>{title}</p> <WrappedComponent /> </section> ) } } }
Export like this in Example
export default BaseActivity(Example, '这是高阶组件的参数');
Let’s take a look at the output react dom
You can see that the parameters have been passed in.
Of course you can also use it like this (currying)
const BaseActivity (title) => (WrappedComponent) => { return class extends Component { render() { return ( <section> <p>{title}</p> <WrappedComponent /> </section> ) } } }
Export like this in Example
export default BaseActivity('这是高阶组件的参数')(Example);
We can see this usage in the form of ant-design and the connect of redux
// ant const WrappedDemo = Form.create()(Demo) // redux export default connect(mapStateToProps, mapDispatchToProps)(Counter)
High-order components You can also extend the props attribute of the original component, as shown below:
const BaseActivity (title) => (WrappedComponent) => { return class extends Component { render() { const newProps = { id: Math.random().toString(8) } return ( <section> <p>{title}</p> <WrappedComponent {...this.props} {...newProps}/> </section> ) } } }
Look at the output react dom
Disadvantages of higher-order components
High-order components also have a series of disadvantages. The first is that the static method of the wrapped component will Disappear, this is actually very easy to understand. When we pass the component into the function as a parameter, what is returned is not the original component, but a new component. The original static method naturally no longer exists. If we need to retain it, we can manually copy the methods of the original component to the new component, or use a library such as hoist-non-react-statics to copy.
The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.
Related articles:
Ajax method to obtain response content length
Ajax method to regularly update a certain piece of content on the page Method
Ajax method of reading properties resource file data
The above is the detailed content of A brief discussion of React high-order components. For more information, please follow other related articles on the PHP Chinese website!

Yes, the engine core of JavaScript is written in C. 1) The C language provides efficient performance and underlying control, which is suitable for the development of JavaScript engine. 2) Taking the V8 engine as an example, its core is written in C, combining the efficiency and object-oriented characteristics of C. 3) The working principle of the JavaScript engine includes parsing, compiling and execution, and the C language plays a key role in these processes.

JavaScript is at the heart of modern websites because it enhances the interactivity and dynamicity of web pages. 1) It allows to change content without refreshing the page, 2) manipulate web pages through DOMAPI, 3) support complex interactive effects such as animation and drag-and-drop, 4) optimize performance and best practices to improve user experience.

C and JavaScript achieve interoperability through WebAssembly. 1) C code is compiled into WebAssembly module and introduced into JavaScript environment to enhance computing power. 2) In game development, C handles physics engines and graphics rendering, and JavaScript is responsible for game logic and user interface.

JavaScript is widely used in websites, mobile applications, desktop applications and server-side programming. 1) In website development, JavaScript operates DOM together with HTML and CSS to achieve dynamic effects and supports frameworks such as jQuery and React. 2) Through ReactNative and Ionic, JavaScript is used to develop cross-platform mobile applications. 3) The Electron framework enables JavaScript to build desktop applications. 4) Node.js allows JavaScript to run on the server side and supports high concurrent requests.

Python is more suitable for data science and automation, while JavaScript is more suitable for front-end and full-stack development. 1. Python performs well in data science and machine learning, using libraries such as NumPy and Pandas for data processing and modeling. 2. Python is concise and efficient in automation and scripting. 3. JavaScript is indispensable in front-end development and is used to build dynamic web pages and single-page applications. 4. JavaScript plays a role in back-end development through Node.js and supports full-stack development.

C and C play a vital role in the JavaScript engine, mainly used to implement interpreters and JIT compilers. 1) C is used to parse JavaScript source code and generate an abstract syntax tree. 2) C is responsible for generating and executing bytecode. 3) C implements the JIT compiler, optimizes and compiles hot-spot code at runtime, and significantly improves the execution efficiency of JavaScript.

JavaScript's application in the real world includes front-end and back-end development. 1) Display front-end applications by building a TODO list application, involving DOM operations and event processing. 2) Build RESTfulAPI through Node.js and Express to demonstrate back-end applications.

The main uses of JavaScript in web development include client interaction, form verification and asynchronous communication. 1) Dynamic content update and user interaction through DOM operations; 2) Client verification is carried out before the user submits data to improve the user experience; 3) Refreshless communication with the server is achieved through AJAX technology.


Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

SAP NetWeaver Server Adapter for Eclipse
Integrate Eclipse with SAP NetWeaver application server.

DVWA
Damn Vulnerable Web App (DVWA) is a PHP/MySQL web application that is very vulnerable. Its main goals are to be an aid for security professionals to test their skills and tools in a legal environment, to help web developers better understand the process of securing web applications, and to help teachers/students teach/learn in a classroom environment Web application security. The goal of DVWA is to practice some of the most common web vulnerabilities through a simple and straightforward interface, with varying degrees of difficulty. Please note that this software

EditPlus Chinese cracked version
Small size, syntax highlighting, does not support code prompt function

PhpStorm Mac version
The latest (2018.2.1) professional PHP integrated development tool

SublimeText3 Linux new version
SublimeText3 Linux latest version
