Post
Ask Question

React Design Pattern Series: Container/Presentational Pattern

Introduction

React, a potent JavaScript library for UI development, offers the Container/Presentational Pattern, aiding in code organization. It segregates components into containers (handling logic) and presentational ones (focused on UI).

Promoting Modularity and Clarity

By separating components into logic-handling containers and UI-focused presentational ones, we improve code maintenance efficiency. Containers use hooks like useState and useEffect, and presentational components shape UI based on props. This pattern streamlines the codebase, ensuring each component has a clear role, promoting modularity and clarity.

Key Benefits of Container/Presentational Pattern

  • Structured Code: Enhances the ease of locating and modifying specific functionalities without disrupting the application's overall structure.
  • High Reusability: Allows for the efficient reuse of presentational components across different sections, fostering a modular development process.
  • Simplified Testing: Streamlines testing with clear logic-UI separation. Containers can be unit-tested, and presentational components can be tested for rendering without complex scenarios.
  • Scalability: Facilitates scalability by providing a structured pattern that accommodates new features and changes with minimal impact on existing code.Container component

Real-World Use Case

In a social media app, PostContainer manages state and logic, fetching and updating data. Post component renders UI based on props.

Code Example

const PostContainer = () => {
  const [post, setPost] = useState({});
  const [comments, setComments] = useState([]);
  const [likes, setLikes] = useState(0);

  useEffect(() => {
    const fetchData = async () => {
      const postResponse = await fetch('api/posts/123');
      const commentsResponse = await fetch('api/posts/123/comments');
      const likesResponse = await fetch('api/posts/123/likes');

      const postData = await postResponse.json();
      const commentsData = await commentsResponse.json();
      const likesData = await likesResponse.json();

      setPost(postData);
      setComments(commentsData);
      setLikes(likesData.likes);
    };

    fetchData();
  }, []);

  const handleLike = () => {
    setLikes(likes + 1);
  };

  return (
    <Post
      post={post}
      comments={comments}
      likes={likes}
      onLike={handleLike}
    />
  );
};

const Post = ({ post, comments, likes, onLike }) => (
  <div>
    <h1>{post.title}</h1>
    <p>{post.content}</p>

    <button onClick={onLike}>Like</button>
    <p>{likes} likes</p>

    <div>
      {comments.map((comment) => (
        <div key={comment.id}>{comment.text}</div>
      ))}
    </div>
  </div>
);

This code defines a PostContainer managing state (post, comments, likes) and fetching data from an API. It uses the Post post-presentational component to render post details, allow liking, and display comments, demonstrating a practical implementation of the Container/Presentational Pattern for scalable and maintainable code.

Conclusion

Adopting the Container/Presentational Pattern in React ensures scalable and maintainable code, offering a structured and expressive approach. The pattern enhances modularity and clarity in development.


Similar Articles