Hello Readers, CoolMonkTechie heartily welcomes you in A Short Note Series (Functional vs Class Components in React Native).
In this note series, we will understand about the difference between Functional and Class Components in React Native.
So Let’s begin.
In React Native, there are two main types of components that make up an application: functional components and class components. These are structured the same as they would be in a regular React app for the web.
Class Components vs Functional Components
1. Syntax
Class components are JavaScript ES2015 classes that extend a base class from React called Component and create a render function that returns a React element. This requires more code as well.
The Class Component in React Native
class App extends Component {
render () {
return (
<Text>Hello World!</Text>
)
}
}
export default App;A Functional Component looks like a plain JavaScript function and are sometimes called stateless components.
The Functional Component in React Native
const App = () =>{
return (
<Text>Hello World!</Text>
)
}
export default App;
2. State
In Class components, there is a way to store and manage state built in to React Native. This gives the class App access to the React life cycle methods like render as well as state/props functionality from the parent. While managing the state in classes, we use setState and this.state to set and get the state, respectively.
State in Class Component
mport React from 'react';
import {Text, View} from 'react-native';
class App extends React.Component {
constructor(props){
super(props);
this.state = { value:0};
setInterval(() =>{
this.setState({ value: this.state.value + 1});
}, 1000);
}
render() {
return (
<View>
<Text>{'State Value =>' + this.state.value}</Text>
</View>
);
}
}
export default App;But in the functional component, we have useState hook after the update of React 16.8. They don’t manage their own state by React Native.
State in Functional Component
import React, { useState } from 'react';
import {Text, View} from 'react-native';
const App = () => {
let [value, setValue] = useState(0);
setInterval(() =>{
setValue(value + 1);
}, 1000);
return (
<View>
<Text>{'State Value =>' + value}</Text>
</View>
);
};
export default App;
3. Lifecycle Methods/Hooks
Another most important difference in Class and Functional Component is the life cycle methods, or we can say Lifecycle Hooks. We all know how important is the Lifecycle methods while developing any React Native application. Life cycle methods give us the power to control the data and application flow on different activities. We are very much familiar with the class component Lifecycle methods but in case of Functional Components we have to manage all this with the help of useEffect hook.
Example of Lifecycle Methods for Class Component
import React, { Component } from 'react';
import { StyleSheet, Text, View } from 'react-native';
export default class App extends Component {
constructor(props) {
super(props);
this.state = {
count: 0,
}
}
componentDidMount() {
const interval = setTimeout(() => {
this.setState({ count: this.state.count + 1 });
}, 1000);
return () => {
clearInterval(this.interval);
}
}
render() {
return (
<View style={styles.container}>
<Text> Count incremented {this.state.count} times</Text>
</View>
);
}
}
const styles = StyleSheet.create({
container: {
flex: 1,
backgroundColor: '#fff',
alignItems: 'center',
justifyContent: 'center',
},
});Example of useEffect Hook for Functional Component
import React, { useState, useEffect } from 'react';
import { StyleSheet, Text, View } from 'react-native';
export default function App() {
const [count, setCount] = useState(0);
// Similar to componentDidMount
useEffect(() => {
const interval = this.setTimeout(() => {
setCount(count + 1);
}, 1000);
return () => {
clearInterval(this.interval);
}
}, []);
return (
<View style={styles.container}>
<Text> Count incremented {count} times</Text>
</View>
);
}
const styles = StyleSheet.create({
container: {
flex: 1,
backgroundColor: '#fff',
alignItems: 'center',
justifyContent: 'center',
},
});
Conclusion
In this note series, we understood about the difference between Functional and Class Components in React Native. We conclude that :
- Class components are used as container components to handle state management and wrap child components.
- Functional components are just used for display purposes – these components call functions from parent components to handle user interactions or state updates.
Thanks for reading! I hope you enjoyed and learned about Functional Vs Class Components Concepts in React Native. Reading is one thing, but the only way to master it is to do it yourself.
Please follow and subscribe to the blog and support us in any way possible. Also like and share the article with others for spread valuable knowledge.
You can find Other articles of CoolmonkTechie as below link :
You can also follow official website and tutorials of React Native as below links :
If you have any comments, questions, or think I missed something, leave them below in the comment box.
Thanks again Reading. HAPPY READING !!???
