커스텀 훅을 활용한 React 리소스 소비 마스터하기: 글로벌 관점

            import { useState, useEffect } from 'react';

function useFetch(url, options = {}) {
  const [data, setData] = useState(null);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      setIsLoading(true);
      setError(null);
      try {
        const response = await fetch(url, options);
        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }
        const result = await response.json();
        setData(result);
      } catch (err) {
        setError(err);
      } finally {
        setIsLoading(false);
      }
    };

    fetchData();

    // Cleanup function if needed, e.g., for aborting requests
    return () => {
      // AbortController or similar logic could be implemented here
    };
  }, [url, JSON.stringify(options)]); // Re-fetch if URL or options change

  return { data, isLoading, error };
}

export default useFetch;

            

              
                Copy
              
            
          

            import React from 'react';
import useFetch from './useFetch';

function UserProfile({ userId }) {
  const { data: user, isLoading, error } = useFetch(`https://api.example.com/users/${userId}`);

  if (isLoading) {
    return 
Loading user profile...
;
  }

  if (error) {
    return 
Error loading profile: {error.message}
;
  }

  if (!user) {
    return null;
  }

  return (
    

      
{user.name}
      
Email: {user.email}
      {/* ... other user details */}
    
  );
}

export default UserProfile;

            

              
                Copy
              
            
          

            import { useState, useEffect, useRef } from 'react';

function useSubscription(channel) {
  const [messages, setMessages] = useState([]);
  const wsRef = useRef(null);

  useEffect(() => {
    // Establish WebSocket connection
    wsRef.current = new WebSocket('wss://realtime.example.com/ws');

    wsRef.current.onopen = () => {
      console.log('WebSocket connected');
      // Subscribe to the channel
      wsRef.current.send(JSON.stringify({ type: 'subscribe', channel }));
    };

    wsRef.current.onmessage = (event) => {
      const messageData = JSON.parse(event.data);
      setMessages((prevMessages) => [...prevMessages, messageData]);
    };

    wsRef.current.onerror = (err) => {
      console.error('WebSocket error:', err);
      // Handle error appropriately, e.g., set an error state
    };

    wsRef.current.onclose = () => {
      console.log('WebSocket disconnected');
      // Attempt to reconnect if necessary, or set a disconnected state
    };

    // Cleanup function to close the connection and unsubscribe
    return () => {
      if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
        wsRef.current.send(JSON.stringify({ type: 'unsubscribe', channel }));
        wsRef.current.close();
      }
    };
  }, [channel]); // Re-establish connection if channel changes

  return { messages };
}

export default useSubscription;

            

              
                Copy
              
            
          

            import React from 'react';
import useSubscription from './useSubscription';

function RealtimeChat({ topic }) {
  const { messages } = useSubscription(`chat:${topic}`);

  return (
    

      
{topic} Chat
      

        {messages.map((msg, index) => (
          
{msg.sender}: {msg.text}
        ))}
      
      {/* Input field for sending messages */}
    
  );
}

export default RealtimeChat;

            

              
                Copy
              
            
          

            import { useState, useCallback } from 'react';

function useForm(initialValues, validationRules = {}) {
  const [values, setValues] = useState(initialValues);
  const [errors, setErrors] = useState({});

  const handleChange = useCallback((event) => {
    const { name, value } = event.target;
    setValues((prevValues) => ({ ...prevValues, [name]: value }));

    // Basic validation on change
    if (validationRules[name]) {
      const validationError = validationRules[name](value);
      setErrors((prevErrors) => ({ ...prevErrors, [name]: validationError }));
    }
  }, [validationRules]);

  const validateForm = useCallback(() => {
    let formIsValid = true;
    const newErrors = {};

    for (const field in validationRules) {
      const validationError = validationRules[field](values[field]);
      if (validationError) {
        newErrors[field] = validationError;
        formIsValid = false;
      }
    }

    setErrors(newErrors);
    return formIsValid;
  }, [values, validationRules]);

  const handleSubmit = useCallback((onSubmit) => async (event) => {
    event.preventDefault();
    if (validateForm()) {
      await onSubmit(values);
    }
  }, [values, validateForm]);

  return {
    values,
    errors,
    handleChange,
    handleSubmit,
    setValues, // For programmatic updates
    setErrors  // For programmatic error setting
  };
}

export default useForm;

            

              
                Copy
              
            
          

            import React from 'react';
import useForm from './useForm';

const emailRegex = /^[\w-\.+]*@[\w-]+\.[\w-]+$/;

const validation = {
  name: (value) => (value ? '' : 'Name is required.'),
  email: (value) => (emailRegex.test(value) ? '' : 'Invalid email address.'),
};

function RegistrationForm() {
  const { values, errors, handleChange, handleSubmit } = useForm(
    { name: '', email: '' },
    validation
  );

  const registerUser = async (userData) => {
    console.log('Submitting:', userData);
    // API call to register user...
  };

  return (
    

      

        Name:
        
        {errors.name && 
{errors.name}
}
      
      

        Email:
        
        {errors.email && 
{errors.email}
}
      
      Register
    
  );
}

export default RegistrationForm;

            

              
                Copy
              
            
          

            import React, { createContext, useContext, useState } from 'react';

const AuthContext = createContext(null);

export function AuthProvider({ children }) {
  const [user, setUser] = useState(null);
  const [isLoadingAuth, setIsLoadingAuth] = useState(true);

  // Simulate fetching user data on mount
  useEffect(() => {
    const fetchUser = async () => {
      // Replace with actual API call to get current user
      const currentUser = await new Promise(resolve => setTimeout(() => resolve({ id: 1, name: 'Global User' }), 1000));
      setUser(currentUser);
      setIsLoadingAuth(false);
    };
    fetchUser();
  }, []);

  const login = (userData) => {
    setUser(userData);
  };

  const logout = () => {
    setUser(null);
  };

  return (
    
      {children}
    
  );
}

export function useAuth() {
  return useContext(AuthContext);
}

            

              
                Copy
              
            
          

            // App.js
import React from 'react';
import { AuthProvider } from './useAuth';
import UserDashboard from './UserDashboard';

function App() {
  return (
    
      
    
  );
}

// UserDashboard.js
import React from 'react';
import { useAuth } from './useAuth';

function UserDashboard() {
  const { user, isLoadingAuth, login, logout } = useAuth();

  if (isLoadingAuth) {
    return 
Loading authentication status...
;
  }

  return (
    

      {user ? (
        
Welcome, {user.name}! Logout
      ) : (
         login({ id: 2, name: 'New User' })}>Login
      )}
    
  );
}

export default UserDashboard;

            

              
                Copy