Saltar al contenido
wandres.dev
Iniciar sesión

SolidJS

Reactividad de grano fino: signals, efectos, memos, stores, control flow, createResource, Solid 2.0 (async first-class) y SolidStart.

42 unidades · 206 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología de SolidJShechoen curso
  2. 01

    Nivel 1

    5 temas
    1. 01La reactividad de grano finohechoen curso
    2. 02Sin virtual DOM ni re-renderhechoen curso
    3. 03Comparación honesta con Reacthechoen curso
    4. 04El ecosistema Solid en 2026hechoen curso
    5. 05Cuándo elegir Solid y cuándo NOhechoen curso
  3. 02

    Nivel 2

    5 temas
    1. 01Crear un proyecto Solid: degit, create-solid y render()hechoen curso
    2. 02El JSX de Solid compila a DOM realhechoen curso
    3. 03Diferencias con el JSX de Reacthechoen curso
    4. 04Binding: atributos, propiedades y spreadhechoen curso
    5. 05Tu primer componente reactivo: el contadorhechoen curso
  4. 03

    Nivel 3

    5 temas
    1. 01Anatomía de un signalhechoen curso
    2. 02Lectura reactiva vs no reactivahechoen curso
    3. 03El setter: valor, actualizador y equalshechoen curso
    4. 04Signals fuera de componenteshechoen curso
    5. 05Errores típicos y tipadohechoen curso
  5. 04

    Nivel 4

    5 temas
    1. 01Qué es un efecto y cuándo correhechoen curso
    2. 02Tracking automático de dependenciashechoen curso
    3. 03El valor previo y la limpiezahechoen curso
    4. 04Variantes de timing: render effect y computedhechoen curso
    5. 05Errores comunes con efectoshechoen curso
  6. 05

    Nivel 5

    5 temas
    1. 01Qué es un memo: una derivación cacheadahechoen curso
    2. 02Memo vs función simple vs signalhechoen curso
    3. 03Componer derivaciones: el grafo de memoshechoen curso
    4. 04equals en memos: cortar la propagaciónhechoen curso
    5. 05Cuándo NO necesitas un memohechoen curso
  7. 06

    Nivel 6

    5 temas
    1. 01El componente corre una vezhechoen curso
    2. 02Dónde vive la reactividadhechoen curso
    3. 03Closures y captura de valoreshechoen curso
    4. 04Condicionales y early returnhechoen curso
    5. 05El cambio de mentalidad frente a Reacthechoen curso
  8. 07

    Nivel 7

    5 temas
    1. 01Las props son un proxy reactivo de gettershechoen curso
    2. 02Por qué NO se destructuran las propshechoen curso
    3. 03mergeProps: valores por defecto y fusión reactivahechoen curso
    4. 04splitProps: separar lo propio de lo que reenvíashechoen curso
    5. 05children y props especiales: el borde del modelohechoen curso
  9. 08

    Nivel 8

    5 temas
    1. 01El helper children(): resolver y memoizarhechoen curso
    2. 02Por qué props.children re-crea nodoshechoen curso
    3. 03Inspeccionar y manipular los hijos resueltoshechoen curso
    4. 04Composición: compound components e inyecciónhechoen curso
    5. 05children en Solid frente a slots y Reacthechoen curso
  10. 09

    Nivel 9

    5 temas
    1. 01Eventos: delegados frente a nativoshechoen curso
    2. 02classList y style reactivoshechoen curso
    3. 03Binding fino: atributos, propiedades y booleanoshechoen curso
    4. 04Refs: variable, callback y forwardinghechoen curso
    5. 05Directivas use: clickOutside y tooltiphechoen curso
  11. 10

    Nivel 10

    5 temas
    1. 01Los nodos del grafo: observers y sourceshechoen curso
    2. 02La propagación: stale, push-then-pull y memos perezososhechoen curso
    3. 03Glitch-free: por qué Solid nunca muestra estados intermedioshechoen curso
    4. 04El listener actual: cómo un signal sabe quién lo leehechoen curso
    5. 05Comparación: MobX, Angular, Preact y qué hace único a Solidhechoen curso
  12. 11

    Nivel 11

    5 temas
    1. 01El árbol de ownershiphechoen curso
    2. 02onCleanup: registrar la limpiezahechoen curso
    3. 03getOwner y runWithOwnerhechoen curso
    4. 04onMount y la disposición automáticahechoen curso
    5. 05Fugas de memoria y efectos huérfanoshechoen curso
  13. 12

    Nivel 12

    5 temas
    1. 01untrack: leer sin suscribirsehechoen curso
    2. 02batch: una sola propagaciónhechoen curso
    3. 03on: dependencias explícitas y deferhechoen curso
    4. 04Combinar untrack y on: control finohechoen curso
    5. 05createReaction: observación manualhechoen curso
  14. 13

    Nivel 13

    5 temas
    1. 01createRoot: fabricar un scope reactivohechoen curso
    2. 02El callback dispose: disponer a manohechoen curso
    3. 03Estado global disposable con getOwnerhechoen curso
    4. 04render por dentro: la raíz de la apphechoen curso
    5. 05Memoria en SPAs: disponer y no acumularhechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01equals: false y comparadores a medidahechoen curso
    2. 02Objetos y arrays en un signal: no mutes en sitiohechoen curso
    3. 03createStoredSignal: un primitivo propio con persistenciahechoen curso
    4. 04Derivado como función suelta vs memohechoen curso
    5. 05Igualdad estructural y el límite del signalhechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01Show: when, fallback y keyedhechoen curso
    2. 02Switch y Match: ramas mutuamente exclusivashechoen curso
    3. 03Por que no usar && ni ternarios crudoshechoen curso
    4. 04Anidar y componer control flow con Forhechoen curso
    5. 05Show como guard: el accesor estrechadohechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01For: mapeo keyed por referenciahechoen curso
    2. 02Index: mapeo por posiciónhechoen curso
    3. 03El coste de reconciliación: mover vs recrearhechoen curso
    4. 04El índice reactivo en For y el valor reactivo en Indexhechoen curso
    5. 05Errores típicos con For e Indexhechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01Dynamic: el componente elegido en runtimehechoen curso
    2. 02Portal: renderizar fuera del árbol del padrehechoen curso
    3. 03ErrorBoundary: contener errores de render y efectoshechoen curso
    4. 04Un modal accesible con Portal y Showhechoen curso
    5. 05Patrones robustos: límites, logging y reintentohechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01onMount: el trabajo que espera al DOMhechoen curso
    2. 02onCleanup: liberar al desmontarhechoen curso
    3. 03Refs al DOM: la variable, el callback y su timinghechoen curso
    4. 04No hay lifecycle de updatehechoen curso
    5. 05Integrar librerías imperativashechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01createStore: un proxy reactivo para árboleshechoen curso
    2. 02Grano fino en stores: solo se actualiza quien lee lo que cambióhechoen curso
    3. 03Store vs muchos signals: elegir por la forma del estadohechoen curso
    4. 04Arrays en stores: acceso, For y reactividad por índicehechoen curso
    5. 05Tipar stores en TypeScript: forma, setter y parcialidadhechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01setStore por ruta: de la raíz a la hojahechoen curso
    2. 02Actualizadores en la ruta: derivar del valor previohechoen curso
    3. 03produce: mutar un borrador con reactividad intactahechoen curso
    4. 04Arrays en el store: índice, predicado y el patrón de listashechoen curso
    5. 05modifyMutable, reconcile y la disciplina de un solo canal de escriturahechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01reconcile: fusionar datos externos en el storehechoen curso
    2. 02unwrap: el objeto crudo detrás del storehechoen curso
    3. 03Casos de uso de reconcile: red, sockets, revalidaciónhechoen curso
    4. 04La opción key de reconcile: identidad para diffearhechoen curso
    5. 05reconcile + createResource: estado del servidor en el clientehechoen curso
  23. 22

    Nivel 22

    5 temas
    1. 01Un store a nivel de módulohechoen curso
    2. 02createRoot para estado global con disposiciónhechoen curso
    3. 03El patrón factory createXStore()hechoen curso
    4. 04Cuándo NO usar contextohechoen curso
    5. 05Estado global y SSRhechoen curso
  24. 23

    Nivel 23

    5 temas
    1. 01createContext y Provider: proveer un valor por el árbolhechoen curso
    2. 02useContext y el patrón useX que exige Providerhechoen curso
    3. 03Tipar el contexto: valor, default nullable y narrowinghechoen curso
    4. 04Context + store: estado compartido reactivo de subárbolhechoen curso
    5. 05Múltiples providers, composición y rendimientohechoen curso
  25. 24

    Nivel 24

    5 temas
    1. 01createMutable: el proxy de escritura directahechoen curso
    2. 02La potencia de createMutable: imperativo, getters y setters, interophechoen curso
    3. 03Los peligros de createMutable: reactividad implícita y mutación ocultahechoen curso
    4. 04Cuándo (casi nunca) usar createMutable: interop OOP y migración desde MobXhechoen curso
    5. 05modifyMutable con produce y reconcile: lotes controladoshechoen curso
  26. 25

    Nivel 25

    5 temas
    1. 01from(): envolver una fuente externa en un signalhechoen curso
    2. 02observable(): exponer un signal como observablehechoen curso
    3. 03Integrar stores de terceros: Redux, Zustand, RxJShechoen curso
    4. 04Crear tus propios primitivos reactivoshechoen curso
    5. 05solid-primitives: la colección oficialhechoen curso
  27. 26

    Nivel 26

    5 temas
    1. 01createResource: el fetcher y la fuentehechoen curso
    2. 02Los estados del resource: loading, error, latest y statehechoen curso
    3. 03refetch y mutate: recarga manual y actualización optimistahechoen curso
    4. 04La fuente reactiva: disparar y descartar peticiones en vuelohechoen curso
    5. 05Tipar resources y usarlos en SSRhechoen curso
  28. 27

    Nivel 27

    5 temas
    1. 01Suspense: un fallback mientras los recursos carganhechoen curso
    2. 02Coordinar varios recursos y evitar la cascada de spinnershechoen curso
    3. 03SuspenseList: orquestar el orden de reveladohechoen curso
    4. 04Suspense y lazy: code splitting con carga diferidahechoen curso
    5. 05Suspense en SSR: streaming del HTML por parteshechoen curso
  29. 28

    Nivel 28

    5 temas
    1. 01useTransition y startTransition: la transición concurrentehechoen curso
    2. 02Mantener la UI vieja visible mientras la nueva se preparahechoen curso
    3. 03isPending: el indicador sutil que no desmontahechoen curso
    4. 04Transiciones en navegación, pestañas y filtroshechoen curso
    5. 05Concurrencia, prioridad, Suspense y el rumbo de Solid 2.0hechoen curso
  30. 29

    Nivel 29

    5 temas
    1. 01Del fetcher al límite: el viaje de un error asynchechoen curso
    2. 02Suspense y ErrorBoundary: el orden que separa carga de fallohechoen curso
    3. 03reset y reintento: volver a disparar el fetch con dignidadhechoen curso
    4. 04catchError: el primitivo de captura sin componentehechoen curso
    5. 05Errores async de producción: sección, taxonomía y telemetríahechoen curso
  31. 30

    Nivel 30

    5 temas
    1. 01createAsync: una derivación asíncrona que se lee como un signalhechoen curso
    2. 02createAsync frente a createResource: sin tupla, se lee llamando, Suspense por defectohechoen curso
    3. 03Componer derivaciones async: encadenar sin cascadas manualeshechoen curso
    4. 04latest y obsoleto-mientras-revalida: transiciones sin parpadeohechoen curso
    5. 05El futuro: async transparente en Solid 2.0hechoen curso
  32. 31

    Nivel 31

    5 temas
    1. 01Deduplicación y caché con queryhechoen curso
    2. 02Prefetch en navegación con preloadhechoen curso
    3. 03Mutaciones optimistas con action y useSubmissionhechoen curso
    4. 04Revalidación: invalidar la caché tras mutarhechoen curso
    5. 05Waterfalls: detectarlos y disparar en paralelohechoen curso
  33. 32

    Nivel 32

    5 temas
    1. 01SolidStart: el meta-framework oficial de Solidhechoen curso
    2. 02Crear un proyecto SolidStart y su estructurahechoen curso
    3. 03app.config.ts: configurar el proyecto y su desplieguehechoen curso
    4. 04Los entry points: cliente y servidorhechoen curso
    5. 05Modos del proyecto: SSR, SPA e islandshechoen curso
  34. 33

    Nivel 33

    5 temas
    1. 01El routing por archivos: del fichero a la rutahechoen curso
    2. 02Rutas anidadas y layouts: envolver con props.childrenhechoen curso
    3. 03Rutas dinámicas y catch-all: corchetes como gramáticahechoen curso
    4. 04Leer el estado de la URL: useParams, useSearchParams, useLocationhechoen curso
    5. 05Navegación: el enlace A, useNavigate y saltos programáticoshechoen curso
  35. 34

    Nivel 34

    5 temas
    1. 01SSR síncrono vs en streaminghechoen curso
    2. 02CSR: el modo SPAhechoen curso
    3. 03SSG y prerenderhechoen curso
    4. 04Islands e hidratación parcialhechoen curso
    5. 05Elegir el modo por rutahechoen curso
  36. 35

    Nivel 35

    5 temas
    1. 01La directiva «use server»: el RPC type-safehechoen curso
    2. 02Serialización: qué cruza la frontera y qué nohechoen curso
    3. 03La frontera cliente/servidor y el secreto que no debe filtrarsehechoen curso
    4. 04Acceder al request: getRequestEvent, headers y cookieshechoen curso
    5. 05Seguridad y validación: Zod, autorización y HttpErrorhechoen curso
  37. 36

    Nivel 36

    5 temas
    1. 01action(): definir y disparar una mutación de servidorhechoen curso
    2. 02Formularios con progressive enhancement y FormDatahechoen curso
    3. 03useSubmission y useSubmissions: el estado de la mutaciónhechoen curso
    4. 04Estado optimista: pintar el resultado antes de la confirmaciónhechoen curso
    5. 05Redirects, errores y revalidación desde una actionhechoen curso
  38. 37

    Nivel 37

    5 temas
    1. 01query y createAsync: el patrón canónico de cargahechoen curso
    2. 02preload en rutas: cargar antes de renderizarhechoen curso
    3. 03Caché y revalidación: invalidar por clavehechoen curso
    4. 04Datos diferidos y streaming con Suspensehechoen curso
    5. 05Pantalla real: listado y detalle maestro-detallehechoen curso
  39. 38

    Nivel 38

    5 temas
    1. 01Sesiones en SolidStart con useSessionhechoen curso
    2. 02Middleware: createMiddleware, onRequest y locals tipadoshechoen curso
    3. 03Cookies seguras: getCookie, setCookie y deleteCookiehechoen curso
    4. 04Proteger rutas y funciones de servidor con guardiashechoen curso
    5. 05Un flujo de auth completo: login, sesión, middleware y logouthechoen curso
  40. 39

    Nivel 39

    5 temas
    1. 01babel-plugin-jsx-dom-expressions: el compilador que es Solidhechoen curso
    2. 02Anatomía del output: template, clonar, insert y effecthechoen curso
    3. 03Por qué compilar vence a un runtime: sin VDOM ni diffinghechoen curso
    4. 04Optimizaciones del compilador: izado, clonado y separaciónhechoen curso
    5. 05Leer y depurar el output: por qué reacciona (o no) tu componentehechoen curso
  41. 40

    Nivel 40

    5 temas
    1. 01Por qué Solid es rápido: leer el js-framework-benchmarkhechoen curso
    2. 02Optimización práctica: For vs Index, memoizar, dividir el bundlehechoen curso
    3. 03El runtime reactivo de Solid 2.0: el signal que suspendehechoen curso
    4. 04De 1.x a 2.0: qué se rompe, qué se mantiene y cómo migrarhechoen curso
    5. 05El futuro del ecosistema: Solid Router, SolidStart y la convergenciahechoen curso
  42. 41

    Nivel 41

    5 temas
    1. 01El modelo mental completo de Solidhechoen curso
    2. 02Arquitectar una app real de principio a finhechoen curso
    3. 03Comparación honesta con el ecosistemahechoen curso
    4. 04Cuándo Solid NO es la elección correctahechoen curso
    5. 05Ser experto: depuración, core y dominio continuohechoen curso