React Flashcards

Question

What is the rendering limitation of SPAs?

Answer 1

* The client-side rendering that SPAs do means delayed rendering and delivering more JavaScript to the client. * This is a limitation that all JavaScript frameworks have.

Answer 2

Frameworks such as React, Ember and Angular 2 are creating server-side rendering engines in Nodejs that can pre-render the app as static HTML, so that the browser has HTML to read immediately on page load.

Answer 3

Make use of constructor function to declare the intitial state of a component: `import React from 'react';` `class ComponentName extends React.Component { constructor(props) { super(props); this.state = { [var]: [expression] }; } render() { ... } }} ` `export default ComponentName;`

Answer 4

Props are arbitrary inputs accepted by components. * For components created as objects: props are a property of this. * For components created as functions, props are a function parameter.

Answer 5

Component some\_prop=input / \>

Answer 6

Only access props (e.g. this.props) to read values. Never modify props inside components.

Answer 7

1. Add a single wrapper element: \< div \> ... [your\_elements] ... \< /div \> 2. Nest one of the top-level elements inside the other.

Answer 8

import React from 'react'; ``` class ComponentName extends React.Component { render() { return ( [... some elements defined with JSX ...] ); } } export default ComponentName; ```

Answer 9

state is a private property of components. Only the corresponding component can read it and change it.

Answer 10

It is a JavaScript expression used to call functions on a parent's object within a constructor function. It runs the constructor function of the parent component. props is passed along to make sure super() has access to the same arguments as the overwriting constructor.

Answer 11

Pass the state explicitly via props in the call to an other component.

Answer 12

* When a component's output is first inserted into the DOM it will trigger a hook called componentDidMount(). * When it's removed from the DOM it will trigger one called componentWillUnmount(). * These hooks are on the same level as render() and return(), and between them.

Answer 13

They should be stored on the this object or on a variable initialized at the top of a file. Only variables used in render() should be stored in state.

Answer 14

Use the setState() method within a function inside a component: ``` class ComponentName extends React.Component { constructor(props) { super(props); this.state = { [var]: [expression] }; } updateFunc() { this.setState({ [var]: [expression] }); } render() { ... } } ```

Answer 15

Use a second form of setState that accepts a function as an argument, rather than directly passing the state (because value of state and prop may be unpredictable due to React asynchronous nature): updateFunc() { this.setState(function (prevState, props) { return { [var]: [expression] }; }); }

Answer 16

``` class MyComponent extends React.Component { constructor(props) { super(props); this.handleClick = this.handleClick.bind(this); } handleClick(event) { console.log(this); } render() { return ( [button onclick={this.handleClick}] Click me ``` [/button] ); } }

Answer 17

Because the value of this is not bound to the object where the function was originally defined. it is a common pattern when you define a class, and need to preserve reference to this inside its class functions after they are passed around to be executed as callbacks outside the orginal class context.

Answer 18

Apps are organized as a series of nested components. These components are functional in nature: they receive information through the props attribute, and pass information via their return values. Data is passed down from components to their children.

Answer 19

No, if you find yourself writing selectors to access elements on the page, then there is something wrong.

Answer 20

The parent component should pass one of its own functions as a callback in a prop when calling the child component.

Answer 21

The right place of the element of state is in a common ancestor component.

Answer 22

As the application is contained in a single page, it cannot rely on the browser’s forward/back buttons.

Answer 23

* Production: $ npm install [package] --save * Development/test: $ npm install [package] --save-dev

Answer 24

React Router fixes the routing limitation of PSAs. It allows the application to navigate between different components, changing the browser URL, modifying the browser history, and keeping the UI state in sync.

Answer 25

1. Router: keeps the UI in sync with the URL. 2. Link: renders a navigation link to change the location. 3. Route: renders a UI component depending on the URL.

Answer 26

* BrowserRouter: using the HTML5 History API. * import { BrowserRouter } from 'react-router-dom'; * http://localhost:3000/route/subroute * HashRouter: using the hash portion which sets or returns the anchor part of the URL. * import { HashRouter } from 'react-router-dom'; * http://localhost:3000/#/route/subroute

Answer 27

Only one child component.

Answer 28

The main job of a Router component is to create a history object to keep track of the location (URL). When the location changes because of a navigation action, the child component is re-rendered.

Answer 29

[Link to="route"] text [/Link]

Answer 30

The route components can be placed anywhere inside of the router, and the associated component will be rendered in that place, just like any other component.

Answer 31

The Link components allow to change the URL without refreshing the page, which is not the case when using directly the [a] tag.

Answer 32

More than one [Route] component can match a URL path and render at the same time.

Answer 33

* Format: [Route exact path="/" component={MyComponent}] * The matching logic uses the path-to-regexp library: possibility to display different components just by declaring that they belong to the same (or similar) path.

Answer 34

Renders the component only if the defined path matches the URL path exactly.

Answer 35

Make the path matching exclusive rather than inclusive: it renders only the first route that matches the location.

Answer 36

Insert Route components as child elements of the Switch component. Note that it is necessary to specify the exact property for the "/" path.

Answer 37

Within a Switch component, use a [Redirect to="path" /] component. This component will navigate to a new location overriding the current one in the history stack.

Answer 38

* match * location * history

Answer 39

* params: key/value pairs parsed from the URL. * isExact: true if the entire URL was matched. * path: path pattern used to match. * url: matched portion of the URL.

Answer 40

Use one of the 3 following properties: * component: render a component. * render: renders an element or component. * children: renders an element or component regardless of whether the path is matched or not.

Answer 41

``` < Route path="/some_path" render={(props) => < Component {...props} myProp={myValue} / >} / > ```

Answer 42

* Only called one time before the initial render(). * Component does not have accees to the Natve UI (DOM, etc...) and children refs. * Opportunity to handle configuration, update our state and prepare for the first render(). * Possible to safely query this.props and this.state knowing with certainty they are the current value.

Answer 43

``` myPromise.then(function() { // Handle success // Some error may happen during handling of success }).catch(function() { // Handle error }); ```

Answer 44

Local Storage is a Web API native to modern web browsers. It allows websites/apps to store simple and limited data in the browser, making that data available in future browser sessions.

Answer 45

``` // setter localStorage.setItem('myData', data); // getter localStorage.getItem('myData'); ```

Answer 46

``` class App extends React.Component { constructor(props) { super(props); this.state = { hits: null }; } onSearch = (e) => { e.preventDefault(); const { value } = this.input; if (value === '') { return; } ``` const cachedHits = localStorage.getItem(value); if (cachedHits) { this.setState({ hits: JSON.parse(cachedHits) }); return; } ``` fetch('https://example.com/api/v1/search?query=' + value) .then(response => response.json()) .then(result => this.onSetResult(result, value)); } onSetResult = (result, key) => { localStorage.setItem(key, JSON.stringify(result.hits)); this.setState({ hits: result.hits }); } render() {...} } ```

Answer 47

Use sessionStorage instead of localStorage. Setter and getter are the same as localStorage.

Answer 48

* When a component is rendered by React Router via component prop to a Route, that component is passed 3 different props: location, match and history. * If we render it ourselves (like \< Component / \> ), then we do not have access to these Router props. By adding the HOC withRouter in export default withRouter(Component), that takes care of this issue.

Answer 49

* input: either a USVString containing a direct URL or a Request object. * init (optional): an object containing any custom settings that should be applied to the request, such as: method, headers, body...

Answer 50

A Promise that resolves to a Response object.

Answer 51

* headers. * ok: boolean for success/failure. * redirected: boolean for whether or not the response's URL list has more than one entry. * status: code. * statusText. * type: e.g. basic, cors. * url: final URL. * useFinalURL: boolean for whether this is the final URL of the response.

Answer 52

The json() method of the Body class (inplemented by Response) takes a Response stream and reads it to completion. It returns a promise that resolves with the result of parsing the body text as JSON.

Answer 53

The Object.assign() method is used to copy the values of all enumerable own properties from one or more source objects to a target object. It will return the target object. The target object can be {}. Syntax: const targetObject = Object.assign(target, ...sources)

Answer 54

It returns a Promise object that is rejected with the given reason. For debugging purposes and selective error catchng, it is useful to make reason an instance of Error.

Answer 55

``` Promise.reject(new Error('fail')) .then(function() { // not called }, function(error) { console.log(error); // Stacktrace } ); ```

Answer 56

An algorithm providing consistent layout on different screen sizes.

Answer 57

* flexDirection. * alignItems. * justifyContent.

Answer 58

Determines the primary axis of a component's layout: should the children be organized: * horizontally (row) * or vertically (column) ==\> default.

Answer 59

Determines the distribution of children along the primary axis (X). Positional alignments: * flex-start: aligns items at the beginning of the container ==\> default. * center: aligns items at the center of the container. * flex-end: aligns items at the end of the container. Distributed alignments: * space-around: evenly distributes items along the main axis such that all items have equal space around them. * space-between: evenly distributes items along the main axis such that the first item aligns at the start and the final item aligns at the end.

Answer 60

Determines the alignment of children along the secondary axis (Y). If the primary axis is row, then the secondary is column, and vice versa. Positional alignments: * flex-start: aligns items at the beginning of the container ==\> default. * center: aligns items at the center of the container. * flex-end: aligns items at the end of the container. Distributed alignments: * stretch: stretches the items to fill the container ==\> default. * baseline: aligns the items so that their baselines align.

Answer 61

A traditional website loads assets like CSS, images and web fonts from remote files based on urls in src attributes in HTML tags or stylesheet rules.

Answer 62

Virtual DOM: 1) faster 2) can't update html directly 3) updates the JSX if element updates (not creates a new DOM if element updates) 4) DOM manipulation is cheaper and easier 5) No memory wastage

Answer 63

It uses the virtual DOM instead of the real DOM. It uses server-side rendering. It follows uni-directional data flow or data binding.

Answer 64

Some of the major advantages of React are: It increases the application’s performance It can be conveniently used on the client as well as server side Because of JSX, code’s readability increases React is easy to integrate with other frameworks like Meteor, Angular, etc Using React, writing UI test cases become extremely easy

Answer 65

Limitations of React are listed below: React is just a library, not a full-blown framework Its library is very large and takes time to understand It can be little difficult for the novice programmers to understand Coding gets complex as it uses inline templating and JSX

Answer 66

JSX is a shorthand for JavaScript XML. This is a type of file used by React which utilizes the expressiveness of JavaScript along with HTML like template syntax. This makes the HTML file really easy to understand. This file makes applications robust and boosts its performance.

Answer 67

require vs import export vs exports component and function props state [https://www.edureka.co/blog/interview-questions/react-interview-questions/](https://www.edureka.co/blog/interview-questions/react-interview-questions/)

Answer 68

Components are the building blocks of a React application’s UI. These components split up the entire UI into small independent and reusable pieces. Then it renders each of these components independent of each other without affecting the rest of the UI.

Answer 69

Each React component must have a render() mandatorily. It returns a single React element which is the representation of the native DOM component. If more than one HTML element needs to be rendered, then they must be grouped together inside one enclosing tag such as

Answer 70

Props is the shorthand for Properties in React. They are read-only components which must be kept pure i.e. immutable. They are always passed down from the parent to the child components throughout the application. A child component can never send a prop back to the parent component. This help in maintaining the unidirectional data flow and are generally used to render the dynamically generated data.

Answer 71

States are the heart of React components. States are the source of data and must be kept as simple as possible. Basically, states are the objects which determine components rendering and behavior. They are mutable unlike the props and create dynamic and interactive components. They are accessed viathis.state().

Answer 72

States vs Props **Conditions****State****Props**1. Receive initial value from parent componentYesYes2. Parent component can change valueNoYes3. Set default values inside componentYesYes4. Changes inside componentYesNo5. Set initial value for child componentsYesYes6. Changes inside child componentsNoYes

Answer 73

`class` `MyComponent ``extends` `React.Component {` ` ``constructor() {` ` ``super``();` ` ``this``.state = {` ` ``name: ``'Maxx'``,` ` ``id: ``'101'` ` ``}` ` ``}` ` ``render()` ` ``{` ` ``setTimeout(()=>{``this``.setState({name:``'Jaeha'``, id:``'222'``})},``2000``)` ` ``return` `( ` ` ` ` ` ` ` `Hello {``this``.state.name}` ` ` ` ` `Your Id is {``this``.state.id}` ` ` ` ``);` ` ``}` ` ``}` `ReactDOM.render(` ` ``, document.getElementById(``'content'``)` `);`

Answer 74

Arrow functions are more of brief syntax for writing the function expression. They are also called *‘fat arrow*‘ (**=\>**) the functions. These functions allow to bind the context of the components properly since in ES6 auto binding is not available by default. Arrow functions are mostly useful while working with the higher order functions. 1 2 3 4 5 6 7 8 9 10 11 12 `//General way` `render() { ` ` ``return``(` ` ``this.handleChange.bind(this) } />` ` ``);` `}` `//With Arrow Function` `render() { ` ` ``return``(` ` `` ``this``.handleOnChange(e) } />` ` ``);` `}`

Answer 75

Stateful vs Stateless Stateful Component/ Stateless Component 1. Stores info about component’s state change in memory / Calculates the internal state of the components 2. Have authority to change state / Do not have the authority to change state 3. Contains the knowledge of past, current and possible future changes in state / Contains no knowledge of past, current and possible future state changes 4. Stateless components notify them about the requirement of the state change, then they send down the props to them. /They receive the props from the Stateful components and treat them as callback functions.

Answer 76

There are three different phases of React component’s lifecycle: Initial Rendering Phase: This is the phase when the component is about to start its life journey and make its way to the DOM. Updating Phase: Once the component gets added to the DOM, it can potentially update and re-render only when a prop or state change occurs. That happens only in this phase. Unmounting Phase: This is the final phase of a component’s life cycle in which the component is destroyed and removed from the DOM.

Answer 77

Some of the most important lifecycle methods are: componentWillMount() – Executed just before rendering takes place both on the client as well as server-side. componentDidMount() – Executed on the client side only after the first render. componentWillReceiveProps() – Invoked as soon as the props are received from the parent class and before another render is called. shouldComponentUpdate() – Returns true or false value based on certain conditions. If you want your component to update, return true else return false. By default, it returns false. componentWillUpdate() – Called just before rendering takes place in the DOM. componentDidUpdate() – Called immediately after rendering takes place. componentWillUnmount() – Called after the component is unmounted from the DOM. It is used to clear up the memory spaces.

Answer 78

In React, events are the triggered reactions to specific actions like mouse hover, mouse click, key press, etc. Handling these events are similar to handling events in DOM elements. But there are some syntactical differences like: Events are named using camel case instead of just using the lowercase. Events are passed as functions instead of strings. The event argument contains a set of properties, which are specific to an event. Each event type contains its own properties and behavior which can be accessed via its event handler only.

Answer 79

``` class Display extends React.Component({ show(evt) { // code }, render() { // Render the div with an onClick prop (value is a function) return ( ``` Click Me! ); } });

Answer 80

Synthetic events are the objects which act as a cross-browser wrapper around the browser’s native event. They combine the behavior of different browsers into one API. This is done to make sure that the events show consistent properties across different browsers.

Answer 81

Refs is the short hand for References in React. It is an attribute which helps to store a reference to a particular React element or component, which will be returned by the components render configuration function. It is used to return references to a particular element or component returned by render(). They come in handy when we need DOM measurements or to add methods to the components.

Answer 82

Following are the cases when refs should be used: When you need to manage focus, select text or media playback To trigger imperative animations Integrate with third-party DOM libraries

Answer 83

We can modularize code by using the export and import properties. They help in writing the components separately in different files.

Answer 84

React forms are similar to HTML forms. But in React, the state is contained in the state property of the component and is only updated via setState(). Thus the elements can’t directly update their state and their submission is handled by a JavaScript function. This function has full access to the data that is entered by the user into a form.

Answer 85

Controlled ComponentsUncontrolled Components 1. They do not maintain their own state1. They maintain their own state 2. Data is controlled by the parent component2. Data is controlled by the DOM 3. They take in the current values through props and then notify the changes via callbacks3. Refs are used to get their current values

Answer 86

Higher Order Component is an advanced way of reusing the component logic. Basically, it’s a pattern that is derived from React’s compositional nature. HOC are custom components which wrap another component within it. They can accept any dynamically provided child component but they won’t modify or copy any behavior from their input components. You can say that HOC are ‘pure’ components.

Answer 87

HOC can be used for many tasks like: Code reuse, logic and bootstrap abstraction Render High jacking State abstraction and manipulation Props manipulation

Answer 88

Pure components are the simplest and fastest components which can be written. They can replace any component which only has a render(). These components enhance the simplicity of the code and performance of the application.

Answer 89

Keys are used for identifying unique Virtual DOM Elements with their corresponding data driving the UI. They help React to optimize the rendering by recycling all the existing elements in the DOM. These keys must be a unique number or string, using which React just reorders the elements instead of re-rendering them. This leads to increase in application’s performance.

Answer 90

Following are some of the major problems with MVC framework: DOM manipulation was very expensive Applications were slow and inefficient There was huge memory wastage Because of circular dependencies, a complicated model was created around models and views

Answer 91

Flux is an architectural pattern which enforces the uni-directional data flow. It controls derived data and enables communication between multiple components using a central Store which has authority for all data. Any update in data throughout the application must occur here only. Flux provides stability to the application and reduces run-time errors.

Answer 92

Redux is one of the hottest libraries for front-end development in today’s marketplace. It is a predictable state container for JavaScript applications and is used for the entire applications state management. Applications developed with Redux are easy to test and can run in different environments showing consistent behavior.

Answer 93

Single source of truth: The state of the entire application is stored in an object/ state tree within a single store. The single state tree makes it easier to keep track of changes over time and debug or inspect the application. State is read-only: The only way to change the state is to trigger an action. An action is a plain JS object describing the change. Just like state is the minimal representation of data, the action is the minimal representation of the change to that data. Changes are made with pure functions: In order to specify how the state tree is transformed by actions, you need pure functions. Pure functions are those whose return value depends solely on the values of their arguments.

Answer 94

Redux uses ‘Store’ for storing the application’s entire state at one place. So all the component’s state are stored in the Store and they receive updates from the Store itself. The single state tree makes it easier to keep track of changes over time and debug or inspect the application.

Answer 95

Redux is composed of the following components: Action – It’s an object that describes what happened. Reducer – It is a place to determine how the state will change. Store – State/ Object tree of the entire application is saved in the Store. View – Simply displays the data provided by the Store.

Answer 96

Actions in React must have a type property that indicates the type of ACTION being performed. They must be defined as a String constant and you can add more properties to it as well. In Redux, actions are created using the functions called Action Creators. Below is an example of Action and Action Creator:

Answer 97

Reducers are pure functions which specify how the application’s state changes in response to an ACTION. Reducers work by taking in the previous state and action, and then it returns a new state. It determines what sort of update needs to be done based on the type of the action, and then returns new values. It returns the previous state as it is, if no work needs to be done.

Answer 98

A store is a JavaScript object which can hold the application’s state and provide a few helper methods to access the state, dispatch actions and register listeners. The entire state/ object tree of an application is saved in a single store. As a result of this, Redux is very simple and predictable. We can pass middleware to the store to handle the processing of data as well as to keep a log of various actions that change the state of stores. All the actions return a new state via reducers.

Answer 99

FluxRedux 1. The Store contains state and change logic1. Store and change logic are separate 2. There are multiple stores2. There is only one store 3. All the stores are disconnected and flat3. Single store with hierarchical reducers 4. Has singleton dispatcher4. No concept of dispatcher 5. React components subscribe to the store5. Container components utilize connect 6. State is mutable6. State is immutable

Answer 100

Advantages of Redux are listed below: Predictability of outcome – Since there is always one source of truth, i.e. the store, there is no confusion about how to sync the current state with actions and other parts of the application. Maintainability – The code becomes easier to maintain with a predictable outcome and strict structure. Server-side rendering – You just need to pass the store created on the server, to the client side. This is very useful for initial render and provides a better user experience as it optimizes the application performance. Developer tools – From actions to state changes, developers can track everything going on in the application in real time. Community and ecosystem – Redux has a huge community behind it which makes it even more captivating to use. A large community of talented individuals contribute to the betterment of the library and develop various applications with it. Ease of testing – Redux’s code is mostly functions which are small, pure and isolated. This makes the code testable and independent. Organization – Redux is precise about how code should be organized, this makes the code more consistent and easier when a team works with it.

Answer 101

React Router is a powerful routing library built on top of React, which helps in adding new screens and flows to the application. This keeps the URL in sync with data that’s being displayed on the web page. It maintains a standardized structure and behavior and is used for developing single page web applications. React Router has a simple API.

Answer 102

Although a is used to encapsulate multiple routes inside the Router. The ‘switch’ keyword is used when you want to display only a single route to be rendered amongst the several defined routes. The tag when in use matches the typed URL with the defined routes in sequential order. When the first match is found, it renders the specified route. Thereby bypassing the remaining routes.

Answer 103

A Router is used to define multiple routes and when a user types a specific URL, if this URL matches the path of any ‘route’ defined inside the router, then the user is redirected to that particular route. So basically, we need to add a Router library to our app that allows creating multiple routes with each leading to us a unique view.

Answer 104

Few advantages are: Just like how React is based on components, in React Router v4, the API is ‘All About Components’. A Router can be visualized as a single root component () in which we enclose the specific child routes (). No need to manually set History value: In React Router v4, all we need to do is wrap our routes within the component. The packages are split: Three packages one each for Web, Native and Core. This supports the compact size of our application. It is easy to switch over based on a similar coding style.

Answer 105

Conventional Routing vs React Routing TopicConventional RoutingReact Routing PAGES INVOLVEDEach view corresponds to a new fileOnly single HTML page is involved URL CHANGESA HTTP request is sent to a server and corresponding HTML page is receivedOnly the History attribute is changed FEELUser actually navigates across different pages for each viewUser is duped thinking he is navigating across different pages

React Flashcards

(131 cards)