After creating a new react project using npx create-react-app new I'm getting functional js code in App.js:
import React from 'react';
import './App.css';
//need to have a class instead of a function here:
function App() {
return (
<div className="App">
</div>
);
}
export default App;
What command do I need to create a none functional react project? If functional is better than none functional please explain why.
If you have install create-react-app for this project, then it is come up with all the new features from react 16.8.6 (latest version of react). The latest react version come up with concept of Hooks. That is why we are getting functional component by default instead of class based component to increase the performance.
If you want class based component by default they you have to come up with older version of create-react-app. Ref
You can migrate react-scripts v3.x to v2.x like so:
npx create-react-app my-app --scripts-version react-scripts#2.1.7
When a new react app is created using create-react-app, it pulls the template from here https://github.com/facebook/create-react-app/tree/master/packages/react-scripts/template
Functional components are preferred than Class components (ES6 class) because, Functional components are usually stateless i.e. without any state and lifecycle methods - check this https://reactjs.org/docs/state-and-lifecycle.html. Their performance is better over class components which have state. Therefore, as a good practice one should always prefer as many stateless components (Functional) over stateful (Class), which is also done in react starter app i.e. create-react-app
Use: create-react-app <project> --scripts-version 2.1.7 to create a new react project that start with a class based App component rather than functional.
There are situations where a developer would prefer the class based design so the --scripts-version argument is good to know about.
I've installed Styled Components into my Create React App, and everything works fine, but by default, it looks as though the class name it appends to the element isn't based off of the styled component name (ie. MyButton should create an element with the class MyButton-134as23f).
In the Styled Components documentation, it says to install the babel-plugin-styled-components, and then configure the .babelrc file, however, from what I understand, we don't have access to that file until we eject from the app.
So how can I debug styled components while I am developing an app within Create React App?
I was able to find an answer to this:
Because Create React App is a zero-config application, the only way to add anything to the .babelrc file is to eject from React.
Obviously, I wanted to keep all of my tooling, and came across babel-plugin-macro. It's essentially a way for users to run libraries at compile time, without having to configure their Babel file beforehand.
So after installing it to my devDependencies, I then changed the import path to import styled from 'styled-components/macro, and all of the Babel plugin features that you would normally need to eject for came standard with Styled Components.
Let me know if you have any questions or trouble with my answer.
Hope this helps!
If so, please share folder structure (where is semantic path) and an example of importing a component.
I know this question is rather "old" (in a front-end dev sense), but Semantic UI now has official React integration and bindings:
Semantic UI React
https://react.semantic-ui.com/
Among its key features (from the landing page):
jQuery Free
All jQuery functionality has been re-implemented in React.
Declarative API
Declarative APIs provide for robust features and prop validation.
Augmentation
Control the rendered HTML tag, or render one component as another component. Extra props are passed to the component you are rending as.
Shorthand Props
Shorthand props generate markup for you, making many use cases a breeze. All object props are spread on the child components.
Sub Components
Sub components give you complete access to the markup. This is essential for flexibility in customizing components.
Auto Controlled State
Our stateful components self manage their state out of the box, without wiring. Dropdowns open on click without wiring onClick to the open prop. The value is also stored internally, without wiring onChange to value.
Installation
$ npm install semantic-ui-react --save
$ npm install semantic-ui-css --save
or if you prefer Yarn:
$ yarn add semantic-ui-react
$ yarn add semantic-ui-css
After installing, include this line in your index.js file:
import 'semantic-ui-css/semantic.min.css';
I will make use of the react package https://react.semantic-ui.com/ . Same stuff but without jquery and all react components
I'm a bit new to react. I see we have to import two things to get started, React and ReactDOM, can anyone explain the difference. I'm reading through the React documentation, but it doesn't say.
React and ReactDOM were only recently split into two different libraries. Prior to v0.14, all ReactDOM functionality was part of React. This may be a source of confusion, since any slightly dated documentation won't mention the React / ReactDOM distinction.
As the name implies, ReactDOM is the glue between React and the DOM. Often, you will only use it for one single thing: mounting with ReactDOM.render(). Another useful feature of ReactDOM is ReactDOM.findDOMNode() which you can use to gain direct access to a DOM element. (Something you should use sparingly in React apps, but it can be necessary.) If your app is "isomorphic", you would also use ReactDOM.renderToString() in your back-end code.
For everything else, there's React. You use React to define and create your elements, for lifecycle hooks, etc. i.e. the guts of a React application.
The reason React and ReactDOM were split into two libraries was due to the arrival of React Native. React contains functionality utilised in web and mobile apps. ReactDOM functionality is utilised only in web apps. [UPDATE: Upon further research, it's clear my ignorance of React Native is showing. Having the React package common to both web and mobile appears to be more of an aspiration than a reality right now. React Native is at present an entirely different package.]
See the blog post announcing the v0.14 release:
https://facebook.github.io/react/blog/2015/10/07/react-v0.14.html
From the React v0.14 Beta release announcement.
As we look at packages like react-native, react-art, react-canvas, and react-three, it's become clear that the beauty and essence of React has nothing to do with browsers or the DOM.
To make this more clear and to make it easier to build more environments that React can render to, we're splitting the main react package into two: react and react-dom.
Fundamentally, the idea of React has nothing to do with browsers, they just happen to be one of many targets for rendering trees of components into. The ReactDOM package has allowed the developers to remove any non-essential code from the React package and move it into a more appropriate repository.
The react package contains React.createElement, React.createClass and React.Component, React.PropTypes, React.Children, and the other helpers related to elements and component classes. We think of these as the isomorphic or universal helpers that you need to build components.
The react-dom package contains ReactDOM.render, ReactDOM.unmountComponentAtNode, and ReactDOM.findDOMNode, and in react-dom/server we have server-side rendering support with ReactDOMServer.renderToString and ReactDOMServer.renderToStaticMarkup.
These two paragraphs explain where the core API methods from v0.13 ended up.
TL;TR the react package is required to create and use components and hooks, react-dom contains react-dom/client and react-dom/server to render you app in the browser's DOM or inside a string (or a stream) on the server. With react-native you can use React to create native apps for Android and iOS.
This question has been asked almost seven years ago and a lot has changed since then.
Most of the answer are no longer correct or contains outdated information.
I'll try to give you a complete but simple answer with the most up to date information available.
React 18
In March 2022 React 18 has been released. It has brought some interesting changes in its public APIs.
Packages
react
As stated in React documentation:
React is the entry point to the React library. If you load React from a <script> tag, these top-level APIs are available on the React global.
Indeed it exposes most of the common React features to create and use components. Some of these are:
React.Component and React.PureComponent, used to create class components and function components
React.createElement(), used convert your JSX code from <Page title="Home page" />to React.createElement(Page, { title: "Home page" }, null)
React.Fragment, to return multiple elements without creating additional DOM elements (starting with React 16.2 you can also use <></> to create a fragment.
hooks, to let you use state and other React features without writing a class
Refs, Suspence and Transitions
Complete list of API exposed by the React object
react-dom, react-native and the others listed below are React renderers. They manage how a React tree turns into the underlying platform calls.
react-dom
The react-dom package provides DOM-specific methods that can be used at the top level of your app and as an escape hatch to get outside the React model if you need to.
This package is essentially a container used to expose both the client and server sub-packages from a single one. Indeed it exposes only two function:
createPortal(), used to create portals and render children outside the DOM hierarchy of the parent component
flushSync() is something you may not never have heard about and for a reason. Because it can significantly hurt performance.
Starting from React 18 these functions have been flagged as legacy, so they will be deprecated in future releases:
render()
hydrate()
findDOMNode()
unmountComponentAtNode()
If you are thinking "OMG they have deprecated the ´ReactDOM.render´ method from React", don't worry and read below.
The reason behind the deprecation is:
the opportunity to redesign the APIs we expose for rendering on the client and server. These changes allow users to continue using the old APIs in React 17 mode while they upgrade to the new APIs in React 18.
Keep in mind that if you continue to use those legacy APIs, new React 18 features will be disabled.
Complete list of API exposed by the react-dom package
react-dom/client
The react-dom/client package provides client-specific methods used for initializing an app on the client. Most of your components should not need to use this module.
The React DOM Client module exposes only two methods:
createRoot() is the new method to create a root where your app will. This the replacement for ReactDOM.render - see the example below
hydrateRoot() is the replacement for ReactDOM.hydrate, required to hydrate a server rendered application
Now the idiomatic way to render you app is using createRoot and render chained together:
import React from 'react';
import * as ReactDOM from 'react-dom/client';
ReactDOM
.createRoot(document.getElementById('root'))
.render(<h1>Hello, world!</h1>);
Or using a constant if you don't like chaining, it's just a matter of style:
import React from 'react';
import * as ReactDOM from 'react-dom/client';
const root = ReactDOM.createRoot(document.getElementById('root'))
root.render(<h1>Hello, world!</h1>);
Complete list of API exposed by the react-dom/client package
react-dom/server
The ReactDOMServer object enables you to render components to static markup. Typically, it’s used on a Node server
Using ReactDOMServer you can render React components server-side. It offers a wide range of methods to achieve this - there are dedicated functions for every environment:
renderToPipeableStream(), uses Node.js Streams
renderToNodeStream() (Deprecated), uses Node.js Streams
renderToStaticNodeStream(), uses Node.js Streams
renderToReadableStream(), uses Web Streams available in browsers, Deno, ...
Moreover, there are also render that can be used in the environments that don not support streams:
renderToString() discouraged from React 18
renderToStaticMarkup()
You can use them but they have limited Suspense support.
This is a the minimal working example to try ReactDOMServer on your own:
import React from 'react';
import * as ReactDOMServer from 'react-dom/server';
const html = ReactDOMServer.renderToString(<h1>Hello, world!</h1>);
Complete list of API exposed by the react-dom/server package
react-native
With React Native, React primitives render to native platform UI, meaning your app uses the same native platform APIs other apps do.
React Native has now a huge ecosystem itself and it is not limited to only render components.
Today is no longer recommended to install the react-native module yourself. Instead, you can use the the expo-cli to take advantage of its automation for the development of your application.
Other React renderers
These are some of the most interesting renderer available today (not dead) for React
react-canvas
react-canvas project is dead, but similar features can be found in
react-konva. Using it you can render your React components inside an HTML canvas.
react-three
react-three has been superseded by react-three-fiber. It allows you to build your three.js scene declaratively from React.
ink
ink is a React renderer for CLIs. Using it you can build your CLI output using components.
react-figma
react-figma is a React renderer for Figma. You can use React components as a source for your designs.
react-pdf
react-pdf is a React renderer for creating PDF files on the browser and server.
FAQ
Where did prop-types go?
With the release of react 15.5 the prop-types library
moved outside of React into a dedicated package.
It looks like they've separated React into react and react-dom packages, so you don't have to use the DOM-related part for projects where you'd like to use it in non-DOM-specific cases, like in here https://github.com/Flipboard/react-canvas
where they import
var React = require('react');
var ReactCanvas = require('react-canvas');
as you can see. Without react-dom.
Before v0.14 they were part of main ReactJs file, but as in some cases we may not need both, they separate them and it starts from version 0.14, that way if we need only one of them, our app gonna be smaller due to using only one of those:
var React = require('react'); /* importing react */
var ReactDOM = require('react-dom'); /* importing react-dom */
var MyComponent = React.createClass({
render: function() {
return <div>Hello World</div>;
}
});
ReactDOM.render(<MyComponent />, node);
React package contains: React.createElement, React.createClass, React.Component, React.PropTypes, React.Children
React-dom package contains: ReactDOM.render, ReactDOM.unmountComponentAtNode, ReactDOM.findDOMNode, and react-dom/server that's including: ReactDOMServer.renderToString and ReactDOMServer.renderToStaticMarkup.
To be more concise, react is for the components and react-dom is for rendering the components in the DOM. 'react-dom' acts as a glue between components and DOM. You will be using render() method of the react-dom to render components in the DOM and that's all you have to know when you are starting off with it.
The ReactDOM module exposes DOM-specific methods, while React has the core tools intended to be shared by React on different platforms (e.g. React Native).
http://facebook.github.io/react/docs/tutorial.html
React: React is a javascript library, designed for building better user interfaces.
React-DOM: React-DOM is a complimentary library to React which glues React to the browser DOM
We’re using React and whenever we use methods like render() or findDOMNode() we’re using React-DOM.
As we look at packages like react-native, react-art, react-canvas, and react-three, it's become clear that the beauty and essence of React has nothing to do with browsers or the DOM.
To make this more clear and to make it easier to build more environments that React can render to, they splitting the main react package into two: react and react-dom.
The react package holds the react source for components, state, props and all the code that is react.
The react-dom package as the name implies is the glue between React and the DOM. Often, you will only use it for one single thing: mounting your application to the index.html file with ReactDOM.render().
Why separate them?
The reason React and ReactDOM were split into two libraries was due to the arrival of React Native (A react platform for mobile development).
The react package holds the react source for components, state, props and all the code that is react.
The react-dom package as the name implies is the glue between React and the DOM. Often, you will only use it for one single thing: mounting your application to the index.html file with ReactDOM.render().