React Fundamentals
React is a JavaScript library for building web and native user interfaces from reusable components. Components describe what should appear for the current data, and React updates the host interface when that data changes.
itWeb development | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic - React Fundamentals
React is a JavaScript library for building user interfaces from components. A component is a function that returns a description of part of the screen. You compose those pieces into a tree. React focuses on the interface layer. Routing, data fetching, styling, and deployment come from the browser, libraries, or a framework. The documentation recommends a framework for many new applications because a framework can coordinate routing, data loading, rendering, and production optimization. React can also be added to part of an existing HTML page when a full framework is unnecessary.
Props are the inputs a parent passes down. State is the data a component owns and may change over time. When state changes, React renders again and updates the DOM to match the new tree. That one-way data flow is the whole trick: parents pass new props; children do not reach upward and mutate what they were given. Lift state to the owner that needs to change it.
JSX places markup near the JavaScript that controls it. A capital JSX name is a component. A lowercase name is a DOM tag. JSX is common and optional; the element tree is what matters. Lists need stable keys so React can match items across updates. Index keys reuse the wrong local state when order changes, which looks like "the wrong row edited" rather than a crash.
Hooks such as useState and useEffect let function components hold state and synchronize with systems outside React. Effects are for those outside systems. They are not a second rendering engine for values you can already compute from props and state during render. Context shares values down the tree without hand-threading props, at the cost of notifying every consumer when the value changes. Keep high-churn state close to the consumers that need it.
Read the Intro for the component model and data flow end to end. Use the Cheatsheet when you need the Hooks and list checklist. The Timeline and Landscape place React among related UI libraries; Updates tracks the release line that changes the APIs this course teaches.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://react.dev/
Supports
- React as a library for web and native interfaces built from components
- Incremental adoption and framework recommendations
- https://react.dev/learn
Supports
- Components, JSX, conditions, lists, events, state, and shared data
- https://react.dev/learn/thinking-in-react
Supports
- Component hierarchy, minimal state, state ownership, props, and one-way data flow
- https://react.dev/learn/render-and-commit
Supports
- Trigger, render, commit, and browser paint stages
- Minimal DOM updates after rendering
- https://react.dev/learn/passing-props-to-a-component
Supports
- Props as read-only component inputs and nested JSX through children
- https://react.dev/learn/state-as-a-snapshot
Supports
- State values as render snapshots and setter behavior
- https://react.dev/learn/queueing-a-series-of-state-updates
Supports
- Event batching, replacement updates, and functional updater ordering
- https://react.dev/learn/preserving-and-resetting-state
Supports
- State tied to tree position and reset through type or key changes
- https://react.dev/learn/rendering-lists
Supports
- Mapping arrays, stable sibling keys, and key selection limits
- https://react.dev/learn/sharing-state-between-components
Supports
- Lifting state to a closest common parent and controlled components
- https://react.dev/learn/managing-state
Supports
- Reducers, context, state preservation, and state structure
- https://react.dev/reference/react/hooks
Supports
- Built-in state, context, ref, Effect, performance, and other Hooks
- https://react.dev/learn/synchronizing-with-effects
Supports
- Effects for external synchronization, setup, dependencies, and cleanup
- https://react.dev/learn/lifecycle-of-reactive-effects
Supports
- Effect start and stop cycles across dependency changes
- https://react.dev/learn/you-might-not-need-an-effect
Supports
- Render-time derivation and event-handler work as alternatives to Effects
- https://react.dev/learn/removing-effect-dependencies
Supports
- Reactive dependencies and object or function identity problems
- https://react.dev/learn/reusing-logic-with-custom-hooks
Supports
- Custom Hooks sharing stateful logic while each call retains independent state
- https://react.dev/learn/escape-hatches
Supports
- Refs, DOM manipulation, Effects, and escape-hatch boundaries
- https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary
Supports
- Error boundary behavior, implementation, and exceptions
- https://react.dev/learn/creating-a-react-app
Supports
- Framework-first recommendations and from-scratch build-tool scope
- https://react.dev/reference/react
Supports
- Current React APIs and formal usage reference
- https://github.com/sindresorhus/awesome
Supports
- Discovery of the curated Awesome React list
- https://github.com/enaqx/awesome-react
Supports
- Discovery of React Testing Library, Storybook, TanStack Query, XState, Motion, and React Hook Form
- https://testing-library.com/docs/react-testing-library/intro/
Supports
- React DOM test utilities and user-facing query approach
- https://storybook.js.org/docs
Supports
- Isolated component and page stories, testing, and documentation
- https://tanstack.com/query/latest/docs/framework/react/overview
Supports
- Asynchronous server-state caching, refetching, mutation, loading, and error states
- https://stately.ai/docs/xstate-react
Supports
- Hooks and helpers connecting XState machines and actors to React
- https://motion.dev/docs/react
Supports
- React animation components and Hooks for layout, gestures, scroll, SVG, and presence
- https://react-hook-form.com/docs
Supports
- React form registration, validation, submission, and error APIs
- https://nextjs.org/docs
Supports
- Next.js as a React full-stack framework with routing, rendering, data, and build conventions
- https://reactrouter.com/home
Supports
- Declarative, data, and framework routing modes for React
- https://vite.dev/guide/
Supports
- Development server, source transformation, and production build tooling
- https://redux-toolkit.js.org/introduction/getting-started
Supports
- Store setup, slices, reducers, actions, and React bindings
- https://mui.com/material-ui/getting-started/
Supports
- React components implementing Material Design and component customization
- https://ant.design/docs/react/introduce/
Supports
- React component library and design system for application interfaces
- https://docs.expo.dev/
Supports
- React Native application development, build, and deployment services
- https://engineering.fb.com/2013/12/20/web/2013-a-year-of-open-source-at-facebook/
Supports
- React public launch at JSConf in May 2013
- https://legacy.reactjs.org/blog/2013/06/05/why-react.html
Supports
- Original composable component, JSX, and reconciliation model
- https://legacy.reactjs.org/blog/2015/10/07/react-v0.14.html
Supports
- React and React DOM package split and function component introduction
- https://legacy.reactjs.org/blog/2016/04/07/react-v15.html
Supports
- React 15 release date, major numbering, and DOM mounting changes
- https://legacy.reactjs.org/blog/2017/09/26/react-v16.0.html
Supports
- Fiber rewrite, error boundaries, fragments, and expanded return types
- https://legacy.reactjs.org/blog/2019/02/06/react-v16.8.0.html
Supports
- Hooks stable release and function-component stateful logic
- https://legacy.reactjs.org/blog/2020/10/20/react-v17.html
Supports
- React 17 gradual upgrade focus and multiple-version embedding
- https://react.dev/blog/2022/03/29/react-v18
Supports
- Concurrent renderer, automatic batching, transitions, root APIs, and streaming server rendering
- https://react.dev/blog/2023/03/16/introducing-react-dev
Supports
- react.dev launch and function-component and Hooks-first documentation
- https://react.dev/blog/2024/12/05/react-19
Supports
- React 19 release date, Actions, form APIs, use API, and Server Components support
