mira, tengo esto: import React, { useState, useEffect, useRef } from "react"; import…
- User
mira, tengo esto:
import React, { useState, useEffect, useRef } from "react"; import YouTube, { YouTubeProps, YouTubePlayer } from "react-youtube"; import Navbar from "./components/Navbar"; import PlaylistInfo from "./components/PlaylistInfo"; import PlaybackControls from "./components/PlaybackControls"; import SongList from "./components/SongList"; import NowPlayingBar from "./components/NowPlayingBar"; import FullScreenPlayer from "./components/FullScreenPlayer"; import PlaybackBar from "./components/PlaybackBar"; import { songs as initialSongs, Song } from "./songs";
const formatTotalDuration = (totalSeconds: number): string => { const hours = Math.floor(totalSeconds / 3600); const minutes = Math.floor((totalSeconds % 3600) / 60); return
${hours} h ${minutes} min; };const App: React.FC = () => { const [currentSong, setCurrentSong] = useState<Song | null>(null); const [isPlaying, setIsPlaying] = useState(false); const [isMobile, setIsMobile] = useState(window.innerWidth < 1024); const [showNavbar, setShowNavbar] = useState(true); const [isFullScreenPlayer, setIsFullScreenPlayer] = useState(false);
const playerRef = useRef<YouTubePlayer | null>(null);
const [currentTime, setCurrentTime] = useState(0); const [duration, setDuration] = useState(0);
const [volume, setVolume] = useState(100);
const lastScrollY = useRef(0);
const [searchValue, setSearchValue] = useState("");
const handleSearchChange = (e: React.ChangeEvent) => { setSearchValue(e.target.value); };
const handleClearSearch = () => { setSearchValue(""); };
const [sortOrder, setSortOrder] = useState<"asc" | "desc" | null>(null);
const sortAscending = () => { setSortOrder("asc"); };
const sortDescending = () => { setSortOrder("desc"); };
const [isShuffle, setIsShuffle] = useState(false);
const filteredSongs = searchValue ? initialSongs.filter( (song) => song.title.toLowerCase().includes(searchValue.toLowerCase()) || song.artist.toLowerCase().includes(searchValue.toLowerCase()) ) : initialSongs;
const sortedSongs = [...filteredSongs]; if (sortOrder === "asc") { sortedSongs.reverse(); }
const totalDurationInSeconds = sortedSongs.reduce( (sum, song) => sum + (song.duration || 0), 0 ); const totalDuration = formatTotalDuration(totalDurationInSeconds);
const playlist = { name: "Time Free", description: "Relajao", owner: "Johan Morales", songsCount: sortedSongs.length, totalDuration: totalDuration, coverImage: "https://i.postimg.cc/y8KhsW1p/imagen-blessd.jpg", };
useEffect(() => { const handleResize = () => { setIsMobile(window.innerWidth < 1024); };
handleResize(); window.addEventListener("resize", handleResize); return () => window.removeEventListener("resize", handleResize);}, []);
useEffect(() => { const handleScroll = () => { if (typeof window !== "undefined" && !isFullScreenPlayer) { if (window.scrollY > lastScrollY.current && window.scrollY > 100) { setShowNavbar(false); } else { setShowNavbar(true); } lastScrollY.current = window.scrollY; } };
window.addEventListener("scroll", handleScroll); return () => window.removeEventListener("scroll", handleScroll);}, [isFullScreenPlayer]);
const getCurrentIndex = (): number => { if (!currentSong?.youtubeId) return -1; return sortedSongs.findIndex( (song) => song.youtubeId === currentSong.youtubeId ); };
useEffect(() => { if (playerRef.current && currentSong?.youtubeId) { try { playerRef.current.loadVideoById(currentSong.youtubeId); setCurrentTime(0); setDuration(0); } catch (error) { console.error("Error al cargar el video:", error); } } }, [currentSong]);
useEffect(() => { if (playerRef.current) { if (isPlaying) { try { playerRef.current.playVideo(); } catch (error) { console.error("Error intentando reproducir el video:", error); } } else { playerRef.current.pauseVideo(); } } }, [isPlaying]);
useEffect(() => { let intervalId: number | null = null;
if (playerRef.current && isPlaying) { intervalId = window.setInterval(() => { if (playerRef.current) { const current = playerRef.current.getCurrentTime(); const dura = playerRef.current.getDuration(); setCurrentTime(current); setDuration(dura); } }, 1000); } return () => { if (intervalId !== null) { window.clearInterval(intervalId); } };}, [isPlaying]);
const handlePlayPause = () => { if (isPlaying) { playerRef.current?.pauseVideo(); setIsPlaying(false); } else { if (currentSong?.youtubeId) { try { playerRef.current?.playVideo(); setIsPlaying(true); } catch (error) { console.error("Error intentando reproducir el video:", error); } } } };
const handleNextSong = () => { if (!currentSong) return; let nextIndex: number;
if (isShuffle) { do { nextIndex = Math.floor(Math.random() * sortedSongs.length); } while (nextIndex === getCurrentIndex()); } else { const currentIndex = getCurrentIndex(); nextIndex = (currentIndex + 1) % sortedSongs.length; } const nextSong = sortedSongs[nextIndex]; setCurrentSong(nextSong); setIsPlaying(true);};
const handlePreviousSong = () => { if (!currentSong) return; let previousIndex: number;
if (isShuffle) { do { previousIndex = Math.floor(Math.random() * sortedSongs.length); } while (previousIndex === getCurrentIndex()); } else { const currentIndex = getCurrentIndex(); previousIndex = (currentIndex - 1 + sortedSongs.length) % sortedSongs.length; } const previousSong = sortedSongs[previousIndex]; setCurrentSong(previousSong); setIsPlaying(true);};
const onPlayerReady: YouTubeProps["onReady"] = (event) => { playerRef.current = event.target; setDuration(event.target.getDuration());
event.target.setVolume(volume); if (isPlaying) { try { event.target.playVideo(); } catch (error) { console.error("Error intentando reproducir el video:", error); } }};
const onPlayerEnd: YouTubeProps["onEnd"] = () => { handleNextSong(); };
const onPlayerError: YouTubeProps["onError"] = (event) => { console.error("Error del reproductor de YouTube:", event.data); };
const onPlayerStateChange: YouTubeProps["onStateChange"] = (event) => { if (window.YT && event.data === YT.PlayerState.ENDED) { handleNextSong(); } else if ( window.YT && (event.data === YT.PlayerState.CUED || event.data === YT.PlayerState.BUFFERING) && isPlaying ) { try { playerRef.current?.playVideo(); } catch (error) { console.error("Error intentando reproducir el video:", error); } } };
const opts: YouTubeProps["opts"] = { height: "0", width: "0", playerVars: { autoplay: 0, controls: 0, disablekb: 1, fs: 0, modestbranding: 1, rel: 0, }, };
const handleProgressChange = (e: React.ChangeEvent) => { const newTime = Number(e.target.value); if (playerRef.current) { try { playerRef.current.seekTo(newTime, true); setCurrentTime(newTime); } catch (error) { console.error("Error al cambiar el progreso del video:", error); } } };
const handleVolumeChange = (e: React.ChangeEvent) => { const newVolume = Number(e.target.value); setVolume(newVolume); if (playerRef.current) { try { playerRef.current.setVolume(newVolume); } catch (error) { console.error("Error al cambiar el volumen:", error); } } };
const toggleMute = () => { if (playerRef.current) { try { if (playerRef.current.isMuted()) { playerRef.current.unMute(); setVolume(playerRef.current.getVolume()); } else { playerRef.current.mute(); setVolume(0); } } catch (error) { console.error("Error al alternar mute/unmute:", error); } } };
const toggleFullScreenPlayer = () => { setIsFullScreenPlayer(!isFullScreenPlayer); if (!isFullScreenPlayer) { setShowNavbar(false); } else { setShowNavbar(true); } };
const ensurePlayback = () => { if (isPlaying && playerRef.current) { try { playerRef.current.playVideo(); console.log("Reproducción iniciada automáticamente."); } catch (error) { console.error("Error al intentar reproducir automáticamente:", error); } } };
useEffect(() => { if (currentSong && isPlaying) { const timeoutId = setTimeout(() => { ensurePlayback(); }, 1000);
return () => clearTimeout(timeoutId); }}, [currentSong, isPlaying]);
const handleSongSelect = (song: Song) => { setCurrentSong(song); setIsPlaying(true); };
const handleShuffle = () => { setIsShuffle(!isShuffle); };
const handleRepeat = () => { if (currentSong) { setIsPlaying(false); setCurrentSong(currentSong); setIsPlaying(true); } };
return ( {currentSong?.youtubeId && ( )}
{showNavbar && ( <Navbar searchValue={searchValue} onSearchChange={handleSearchChange} onClear={handleClearSearch} onSortAscending={sortAscending} onSortDescending={sortDescending} /> )} <div className={`pt-20 flex-1 overflow-y-auto bg-gradient-to-b from-red-900 to-gray-900 ${ isFullScreenPlayer ? "hidden" : "" } pb-24`} > <PlaylistInfo playlist={playlist} /> {currentSong && ( <PlaybackControls isPlaying={isPlaying} onPlayPause={handlePlayPause} onAddToQueue={() => { console.log("Agregar a la cola"); }} onMoreOptions={() => { console.log("Más opciones"); }} /> )} <SongList songs={sortedSongs} currentSong={currentSong} onSongSelect={handleSongSelect} /> </div> {isMobile && currentSong && !isFullScreenPlayer && ( <NowPlayingBar currentSong={currentSong} isPlaying={isPlaying} onPlayPause={(e) => { e.preventDefault(); handlePlayPause(); }} onToggleFullScreen={toggleFullScreenPlayer} /> )} {isMobile && isFullScreenPlayer && currentSong && ( <FullScreenPlayer currentSong={currentSong} isPlaying={isPlaying} onPlayPause={handlePlayPause} onNextSong={handleNextSong} onPreviousSong={handlePreviousSong} onShuffle={handleShuffle} onRepeat={handleRepeat} onVolumeChange={handleVolumeChange} volume={volume} onProgressChange={(values) => { const newTime = (values[0] / 100) * duration; if (playerRef.current) { try { playerRef.current.seekTo(newTime, true); setCurrentTime(newTime); } catch (error) { console.error("Error al cambiar el progreso del video:", error); } } }} currentTime={currentTime} duration={duration} onClose={toggleFullScreenPlayer} isShuffle={isShuffle} /> )} {!isMobile && currentSong && ( <PlaybackBar currentSong={currentSong} isPlaying={isPlaying} onPlayPause={handlePlayPause} onNextSong={handleNextSong} onPreviousSong={handlePreviousSong} onShuffle={handleShuffle} onRepeat={handleRepeat} onVolumeChange={handleVolumeChange} volume={volume} onFullScreen={toggleFullScreenPlayer} currentTime={currentTime} duration={duration} onProgressChange={handleProgressChange} isShuffle={isShuffle} /> )} </div>); };
export default App;
y aqui es donde listo todas las canciones:
import React from "react"; import PlayingIcon from "./ui/icon/PlayingIcon";
interface Song { title: string; artist: string; album: string; added: string; duration?: number; youtubeId?: string; }
interface SongListProps { songs: Song[]; currentSong: Song | null; onSongSelect: (song: Song) => void; }
const getYouTubeThumbnail = (youtubeId: string): string =>
https://img.youtube.com/vi/${youtubeId}/hqdefault.jpg;const SongList: React.FC = ({ songs, currentSong, onSongSelect, }) => { const formatTime = (seconds: number): string => { const minutes = Math.floor(seconds / 60); const secs = Math.floor(seconds % 60); const minutesStr = minutes < 10 ?
0${minutes}:${minutes}; const secondsStr = secs < 10 ?0${secs}:${secs}; return${minutesStr}:${secondsStr}; };return ( # Título Álbum Fecha en que se agregó Duración {songs.map((track, index) => ( <tr key={ track.youtubeId ?
${track.youtubeId}-${index}:index-${index}} className={hover:bg-gray-800 cursor-pointer ${ track.youtubeId === currentSong?.youtubeId ? "bg-gray-700" : "" }} onClick={() => { if (track.youtubeId) { onSongSelect(track); } }} > {index + 1} {track.youtubeId === currentSong?.youtubeId && ( )} <img src={ track.youtubeId ? getYouTubeThumbnail(track.youtubeId) : "/placeholder.svg" } alt="Video thumbnail" className="w-10 h-10 mr-4 object-cover rounded-md" /> <p className={font-medium ${ track.youtubeId === currentSong?.youtubeId ? "text-green-500" : "text-white" }} > {track.title} {track.artist} {track.album} {track.added} {track.duration ? formatTime(track.duration) : "--:--"} ))} ); };export default SongList;
lo que sucede es que como san tantas canciones, mas de 1000, se demora un poco en cargar, hay alguna manera de hacer que todo vaya mas rapido?
- Assistant
Cuando se manejan listas grandes en React, como más de 1000 canciones en tu caso, el rendimiento puede verse afectado significativamente debido a la cantidad de elementos que el DOM necesita renderizar. A continuación, te presento varias estrategias para optimizar el rendimiento de tu aplicación:
1. Implementar Virtualización de Listas
La virtualización de listas es una técnica que renderiza solo los elementos visibles en la pantalla y, a medida que el usuario se desplaza, va renderizando los nuevos elementos que entran en el viewport y desmontando los que salen. Esto reduce drásticamente el número de nodos en el DOM, mejorando el rendimiento.
Cómo hacerlo:
Utiliza librerías como
react-windoworeact-virtualized. A continuación, te muestro cómo implementarreact-windowen tu componenteSongList.-
Instalar
react-window:npm install react-window -
Modificar
SongListpara usarFixedSizeList:// SongList.tsx import React, { memo } from "react"; import { FixedSizeList as List, ListChildComponentProps } from "react-window"; import PlayingIcon from "./ui/icon/PlayingIcon"; interface Song { title: string; artist: string; album: string; added: string; duration?: number; youtubeId?: string; } interface SongListProps { songs: Song[]; currentSong: Song | null; onSongSelect: (song: Song) => void; } const getYouTubeThumbnail = (youtubeId: string): string => `https://img.youtube.com/vi/${youtubeId}/hqdefault.jpg`; const formatTime = (seconds: number): string => { const minutes = Math.floor(seconds / 60); const secs = Math.floor(seconds % 60); const minutesStr = minutes < 10 ? `0${minutes}` : `${minutes}`; const secondsStr = secs < 10 ? `0${secs}` : `${secs}`; return `${minutesStr}:${secondsStr}`; }; const Row = memo(({ index, style, data }: ListChildComponentProps) => { const track: Song = data.songs[index]; const currentSong: Song | null = data.currentSong; const onSongSelect = data.onSongSelect; return ( <tr key={ track.youtubeId ? `${track.youtubeId}-${index}` : `index-${index}` } className={`hover:bg-gray-800 cursor-pointer ${ track.youtubeId === currentSong?.youtubeId ? "bg-gray-700" : "" }`} onClick={() => { if (track.youtubeId) { onSongSelect(track); } }} style={style} > <td className="hidden lg:table-cell py-2">{index + 1}</td> <td className="py-2"> <div className="flex items-center"> {track.youtubeId === currentSong?.youtubeId && ( <PlayingIcon /> )} <img src={ track.youtubeId ? getYouTubeThumbnail(track.youtubeId) : "/placeholder.svg" } alt="Video thumbnail" className="w-10 h-10 mr-4 object-cover rounded-md" /> <div> <p className={`font-medium ${ track.youtubeId === currentSong?.youtubeId ? "text-green-500" : "text-white" }`} > {track.title} </p> <p className="text-sm text-gray-400">{track.artist}</p> </div> </div> </td> <td className="hidden lg:table-cell py-2 text-sm text-gray-400"> {track.album} </td> <td className="hidden lg:table-cell py-2 text-sm text-gray-400"> {track.added} </td> <td className="hidden lg:table-cell py-2 text-sm text-gray-400"> {track.duration ? formatTime(track.duration) : "--:--"} </td> </tr> ); }); const SongList: React.FC<SongListProps> = ({ songs, currentSong, onSongSelect, }) => { const itemData = { songs, currentSong, onSongSelect, }; const RowRenderer = (props: ListChildComponentProps) => ( <Row {...props} /> ); return ( <div className="px-6"> <table className="w-full"> <thead> <tr className="text-left text-sm text-gray-400 border-b border-gray-500"> <th className="hidden lg:table-cell pb-2">#</th> <th className="pb-2">Título</th> <th className="hidden lg:table-cell pb-2">Álbum</th> <th className="hidden lg:table-cell pb-2"> Fecha en que se agregó </th> <th className="hidden lg:table-cell pb-2">Duración</th> </tr> </thead> <tbody> <List height={600} // Ajusta según sea necesario itemCount={songs.length} itemSize={60} // Altura de cada fila width="100%" itemData={itemData} className="overflow-x-hidden" > {RowRenderer} </List> </tbody> </table> </div> ); }; export default SongList;Notas Importantes:
height: Define la altura del contenedor de la lista. Ajusta este valor según el diseño de tu aplicación.itemSize: Altura de cada fila. Asegúrate de que coincida con la altura real de tus filas para evitar problemas de renderizado.itemData: Pasa los datos necesarios a cada fila.Row: UtilizaReact.memopara evitar re-renderizados innecesarios de cada fila.
2. Memoizar Componentes
Utiliza
React.memopara componentes que no necesitan re-renderizarse a menos que sus props cambien. Esto es especialmente útil para los elementos de la lista.// Ejemplo de memoización en el componente Row const Row = memo(({ index, style, data }: ListChildComponentProps) => { // ...contenido del Row });3. Optimizar el Manejo de Estados
Asegúrate de que los estados que afectan a la lista grande no causen re-renderizados globales. Por ejemplo, evita que el estado de un componente padre afecte a todos los elementos de la lista.
4. Lazy Loading de Imágenes
Las miniaturas de YouTube (
<img src={...} />) pueden ser una fuente de ralentización. Implementa el lazy loading para cargar las imágenes solo cuando estén cerca de ser visibles.// Utiliza el atributo loading="lazy" <img src={ track.youtubeId ? getYouTubeThumbnail(track.youtubeId) : "/placeholder.svg" } alt="Video thumbnail" className="w-10 h-10 mr-4 object-cover rounded-md" loading="lazy" />5. Optimizar Filtrado y Ordenamiento
Si realizas operaciones pesadas de filtrado y ordenamiento, considera usar
useMemopara memorizar los resultados y evitar cálculos innecesarios en cada render.import React, { useMemo } from "react"; // Dentro de tu componente principal const filteredSongs = useMemo(() => { return searchValue ? initialSongs.filter( (song) => song.title.toLowerCase().includes(searchValue.toLowerCase()) || song.artist.toLowerCase().includes(searchValue.toLowerCase()) ) : initialSongs; }, [searchValue, initialSongs]); const sortedSongs = useMemo(() => { const sorted = [...filteredSongs]; if (sortOrder === "asc") { sorted.reverse(); } return sorted; }, [filteredSongs, sortOrder]);6. Optimizar el Uso de Imágenes
Si las miniaturas están alojadas externamente y causan retrasos en la carga, considera optimizarlas usando formatos más eficientes o integrando un servicio de CDN.
7. Dividir el Código
Si tu aplicación es muy grande, dividir el código (code splitting) puede ayudar a cargar solo los componentes necesarios en cada vista, reduciendo el tiempo de carga inicial.
8. Uso de Paginación (Opcional)
Aunque la virtualización es generalmente preferida debido a su fluidez, en algunos casos la paginación puede ser una buena opción para dividir la lista en fragmentos más manejables.
Ejemplo Combinado
Aquí tienes cómo podrías integrar
react-windowcon las optimizaciones mencionadas:// SongList.tsx import React, { memo, useMemo } from "react"; import { FixedSizeList as List, ListChildComponentProps } from "react-window"; import PlayingIcon from "./ui/icon/PlayingIcon"; interface Song { title: string; artist: string; album: string; added: string; duration?: number; youtubeId?: string; } interface SongListProps { songs: Song[]; currentSong: Song | null; onSongSelect: (song: Song) => void; } const getYouTubeThumbnail = (youtubeId: string): string => `https://img.youtube.com/vi/${youtubeId}/hqdefault.jpg`; const formatTime = (seconds: number): string => { const minutes = Math.floor(seconds / 60); const secs = Math.floor(seconds % 60); const minutesStr = minutes < 10 ? `0${minutes}` : `${minutes}`; const secondsStr = secs < 10 ? `0${secs}` : `${secs}`; return `${minutesStr}:${secondsStr}`; }; const Row = memo(({ index, style, data }: ListChildComponentProps) => { const track: Song = data.songs[index]; const currentSong: Song | null = data.currentSong; const onSongSelect = data.onSongSelect; return ( <tr key={ track.youtubeId ? `${track.youtubeId}-${index}` : `index-${index}` } className={`hover:bg-gray-800 cursor-pointer ${ track.youtubeId === currentSong?.youtubeId ? "bg-gray-700" : "" }`} onClick={() => { if (track.youtubeId) { onSongSelect(track); } }} style={style} > <td className="hidden lg:table-cell py-2">{index + 1}</td> <td className="py-2"> <div className="flex items-center"> {track.youtubeId === currentSong?.youtubeId && ( <PlayingIcon /> )} <img src={ track.youtubeId ? getYouTubeThumbnail(track.youtubeId) : "/placeholder.svg" } alt="Video thumbnail" className="w-10 h-10 mr-4 object-cover rounded-md" loading="lazy" /> <div> <p className={`font-medium ${ track.youtubeId === currentSong?.youtubeId ? "text-green-500" : "text-white" }`} > {track.title} </p> <p className="text-sm text-gray-400">{track.artist}</p> </div> </div> </td> <td className="hidden lg:table-cell py-2 text-sm text-gray-400"> {track.album} </td> <td className="hidden lg:table-cell py-2 text-sm text-gray-400"> {track.added} </td> <td className="hidden lg:table-cell py-2 text-sm text-gray-400"> {track.duration ? formatTime(track.duration) : "--:--"} </td> </tr> ); }); const SongList: React.FC<SongListProps> = ({ songs, currentSong, onSongSelect, }) => { const itemData = useMemo(() => ({ songs, currentSong, onSongSelect, }), [songs, currentSong, onSongSelect]); const RowRenderer = (props: ListChildComponentProps) => ( <Row {...props} /> ); return ( <div className="px-6"> <table className="w-full"> <thead> <tr className="text-left text-sm text-gray-400 border-b border-gray-500"> <th className="hidden lg:table-cell pb-2">#</th> <th className="pb-2">Título</th> <th className="hidden lg:table-cell pb-2">Álbum</th> <th className="hidden lg:table-cell pb-2"> Fecha en que se agregó </th> <th className="hidden lg:table-cell pb-2">Duración</th> </tr> </thead> <tbody> <List height={600} // Ajusta según sea necesario itemCount={songs.length} itemSize={60} // Altura de cada fila width="100%" itemData={itemData} className="overflow-x-hidden" > {RowRenderer} </List> </tbody> </table> </div> ); }; export default SongList;9. Consideraciones Adicionales
- Usar
keyÚnicos: Asegúrate de que cada fila tenga unakeyúnica y estable para evitar problemas de renderizado. - Evitar Renderizados Condicionales Complejos: Mantén la lógica de renderizado lo más simple posible dentro de la lista.
Resumen
Implementar la virtualización de listas con
react-windowes la solución más efectiva para manejar y renderizar listas grandes de manera eficiente en React. Complementa esta técnica con la memoización de componentes, optimización de estados y lazy loading de imágenes para lograr el mejor rendimiento posible.Si tienes alguna pregunta adicional o necesitas más detalles sobre alguna de estas optimizaciones, no dudes en preguntar.
-