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
Intro
React Fundamentals
React is a JavaScript library for building user interfaces from components. A component is a JavaScript function that returns a description of part of the interface. Components can be as small as a button or as large as a page. You combine them into a tree that represents the screen.
React focuses on the interface layer. It does not prescribe routing, data fetching, styling, or deployment. A full application therefore combines React with browser APIs, libraries, build tools, or a framework. The React documentation recommends a framework for 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.
The component tree
Each component receives inputs called props and returns React elements, usually written with JSX. JSX is a syntax extension that places markup near the JavaScript logic that controls it. A JSX element such as <Profile user={user} /> becomes a description of the component type and its props. JSX is common but optional.
Component names begin with a capital letter. Lowercase JSX names refer to built-in host elements such as div, button, and input. Components may render other components, creating a parent-child tree. Data normally moves from parents to children through props. This one-way flow makes the source of a displayed value explicit.
Props are read-only snapshots. A child must not mutate them. To change information, the component that owns that information updates state and passes new props down. Event-handler functions can travel down as props so a child can request that update.
Rendering and committing
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
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
