Time Complete The Project: 1 Hour
Building a CRUD App with React Redux and Local Storage
Create a CRUD application from existing API. API link is given below. Follow these
instruction mentioned:
1. Get some data from API. You can chose any type of resource like
post/comments/todos etc.
2. Then save this data in your locale storage.
3. Show this data in the UI for CRUD.
4. Apply CRUD operations.
NOTE: You can use any CSS framework Bootstrap/Tailwind CSS.
API: https://jsonplaceholder.typicode.com/
https://github.com/webappickhasan/frontend-exam
git branch yourname
git checkout yourname
git push --set-upstream origin yourname
git checkout man
git branch -d yourname
https://www.interviewbit.com/javascript-interview-questions/
https://www.interviewbit.com/react-interview-questions/
https://www.interviewbit.com/es6-interview-questions/
What are the object-oriented terms supported by TypeScript?
TypeScript supports the following object-oriented terms:
● Modules
● Classes
● Interfaces
● Inheritance
● Data Types
● Member functions
1. Difference between “==” and “===”?
2. Define let and const keywords.
let: The variables declared using let keyword will be mutable, i.e., the values of the
variable can be changed. It is similar to var keyword except that it provides block
scoping.
const: The variables declared using the const keyword are immutable and
block-scoped. The value of the variables cannot be changed or re-assigned if they are
declared by using the const keyword.
3. Difference between rest operator and spread operator?
4. What do you mean by IIFE (Immediately invoked function
expressions)?
IIFE is a function in JavaScript that runs as soon as it is defined. It is also called as the
Self-Executing Anonymous Function. It includes two major parts that are as follows:
● The first part is an anonymous function that has a lexical scope (static scope),
which is enclosed within the Grouping operator ().
● The second part creates the IIFE by which the JavaScript engine will interpret the
function directly.
You can learn more about arrow functions by clicking on this link ES6 IIFE.
5. List the new Array methods introduced in ES6?
There are many array methods available in ES6, which are listed below:
● Array.of()
● Array.from()
● Array.prototype.copyWithin()
● Array.prototype.find()
● Array.prototype.findIndex()
● Array.prototype.entries()
● Array.prototype.keys()
● Array.prototype.values()
● Array.prototype.fill()
6) What are the new features introduced in ES6?
The new features that are introduced in ES6 are listed as follows:
● Let and const keywords.
● Default Parameters.
● Arrow functions.
● Template Literals.
● Object Literals.
● Rest and spread operators.
● Destructuring assignment.
● Modules, Classes, Generators, and iterators.
● Promises, and many more.
What are the differences between class and functional components?
Class Components Functional Components
State Can hold or manage state Cannot hold or manage state
Simplicity Complex as compared to the Simple and easy to understand
stateless component
Lifecycle Can work with all lifecycle Does not work with any
methods methods lifecycle method
Reusability Can be reused Cannot be reused
Explain the lifecycle methods of components.
Mounting Lifecycle Methods:
React supports three mounting lifecycle methods for component
classes: componentWillMount(), render(), and componentDidMount().
componentWillMount() will be called first followed by the render() method and
finally the componentDidMount() method.
Updating Lifecycle Method:
When a component updates, shouldComponentUpdate() gets called after
componentWillReceiveProps(), but still before the rendering begins. It
automatically receives two arguments: nextProps and nextState.
should return either true or false. The best way to
shouldComponentUpdate()
use this method is to have it return false only under certain conditions.
If those conditions are met, then your component will not update.
What are the object oriented features supported in ES6.
The object-oriented features supported in ES6 are:
● Classes: We can create classes in ES6. The class function essentially builds a
template from which we may later create objects. When a new instance of the
class is created, the constructor method is invoked.
● Methods: Static methods can also be found in classes. A static method, unlike
an object, is a function that is bound to the class. A static method can't be called
from a class instance.
Let's take a look at getters and setters for a moment. Encapsulation is a
fundamental notion in OOP. Data (object properties) should not be directly
accessed or updated from outside the object, which is a crucial aspect of
encapsulation. A getter (access) or a setter (modify) are particular methods we
define in our class to access or edit a property.
● Inheritance: It is also possible for classes to inherit from one another. The
parent is the class that is being inherited from, and the child is the class that is
inheriting from the parent.
