# data[].attributes.body
Babel is a very famous transpiler that basically allows us to use future JavaScript in today’s browsers. In simple words, it can convert the latest version of JavaScript code into the one that the browser understands. The latest standard version which JavaScrip

# data[].attributes.body
Node.js is a cross-platform, open source, server-side runtime environment based on the JavaScript programming language, asynchronous, with data I/O in an event-driven architecture and based on Google's V8 engine.

# data[].attributes.body
Webpack is a popular module bundling system built on top of Node.js. It can handle not only combination and minification of JavaScript and CSS files, but also other assets such as image files (spriting) through the use of plugins. Webpack is the recommended bundling solution

# data[].attributes.body
The React useCallback Hook returns a memoized callback function. Think of memoization as caching a value so that it does not need to be recalculated. This allows us to isolate resource intensive functions so that they will not automatically run on every render.

# data[].attributes.body
The useReducer Hook accepts two arguments. useReducer (<reducer>, <initialState>) The reducer function contains your custom state logic and the initialState can be a simple value but generally will contain an object. The useReducer Hook returns the current state

# data[].attributes.body
To use the useState Hook, we first need to import it into our component. Example: At the top of your component, import the useState Hook. import { useState } from "react"; Notice that we are destructuring useState from react as it is a named export.

# data[].attributes.body
useEffect runs on every render. That means that when the count changes, a render happens, which then triggers another effect. This is not what we want. There are several ways to control when side effects run. We should always include the second parameter which accepts

# data[].attributes.body
When to Use Context. Context is designed to share data that can be considered “global” for a tree of React components, such as the current authenticated user, theme, or preferred language. For example, in the code below we manually thread through a “theme” prop in order

# data[].attributes.body
Hooks are functions that allow you to "hook" React state and lifecycle from function components. Hooks do not work inside classes - they allow you to use React without classes.

# data[].attributes.body
Now in App is where we are going to control all the status of our application I will not go into detail what the like and unlike method does but in summary is to get the list identify the element that we pass later to the method by parameter

# data[].attributes.body
React events don't work exactly the same as native events. See the SyntheticEvent reference guide to learn more. When you are using React, you generally do not need to call addEventListener to add event listeners to an element.

# data[].attributes.body
Tailwind CSS bridges the gap between design and dev more than anything else. It reintroduces context to development, limits cognitive load with choice architecture, grants access to a token library out of the box and is incredibly easy to pickup.

# data[].attributes.body
Sass is completely compatible with all versions of CSS. We take this compatibility seriously, so that you can seamlessly use any available CSS libraries. Feature Rich. Sass boasts more features and abilities than any other CSS extension language out there.

# data[].attributes.body
CSS is the language we use to style an HTML document. CSS describes how HTML elements should be displayed.

# data[].attributes.body
Conditional rendering in React works in the same way that conditions do in JavaScript. Use JavaScript operators like if or the conditional operator to create elements representing the current state, and let React update the user interface.

# data[].attributes.body
Props are arguments passed into React components. Props are passed to components via HTML attributes. props stands for properties. React Props React Props are like function arguments in JavaScript and attributes in HTML.

# data[].attributes.body
In simple terms, a component is simply a block of code that can take arguments and that generates React elements.

# data[].attributes.body
React Router DOM is an npm package that enables you to implement dynamic routing in a web app. It allows you to display pages and allow users to navigate them. It is a fully-featured client and server-side routing library for React.

# data[].attributes.body
The array methods are not async functions. They are normal functions . So when we pass an async function as a callback , It will not invoke the async callback function with await .

# data[].attributes.body
The conditional (ternary) operator is the only JavaScript operator that takes three operands: a condition followed by a question mark (?), then an expression to execute if the condition is truthy followed by a colon (:), and finally the expression to execute if the condition is falsy.

# data[].attributes.body
ES Modules is the ECMAScript standard for working with modules. While Node.js has been using the CommonJS standard since years, the browser never had a module system, as every major decision such as a module system must be first standardized by ECMAScript

# data[].attributes.headline
3. Default Parameters Spread Operator / Rest Parameters

# data[].attributes.subject
3. Default Parameters Spread Operator / Rest Parameters

# data[].attributes.body
Rest Operator: It allows a function to accept an indefinite number of arguments if we are not sure how many arguments will receive. Syntax: function f(a, b, ...args) { ... } Example: In the below example, we are using the rest parameter which allows taking indefinite parameters.

# data[].attributes.body
arrow functions: destructuring arguments and grabbing them as a whole at the same time. Can we do both destructuring: ( {a, b}) => ( a + b ) and grab the arguments: (...args) => ( f ( {...args}) ), at the same time for arrow functions in ES6. Looking for something like (...args = {a, b}) =>

I understood that they are used to save code in some way and take several variables separated by commas.

# data[].attributes.body
Template literals are literals delimited with backtick (`) characters, allowing for multi-line strings, string interpolation with embedded expressions, and special constructs called tagged templates. Template literals are sometimes informally called template strings