Map Array Method
The map method iterates over each item in an array and returns a new array containing the results of calling the callback functions on each element. This method does not mutate the original array.

Map is a pure function as it does not alter the original array.

Filter method:
filter calls a function on each element of an array and returns a new array for which the return value ie true . It is the non-destructive function i.e does not modify the original array. The call back function accepts three arguments. The first argument is the current element begin processed, second is the index of the element, third is the array which filter method was called.

Concat Method:
This method helps to join items end to end. Concat method is for both strings and arrays. It is non-destructive method.

Reduce Method:

Reduce method combines both filter and map method. It iterates over each item in an array and returns a single value(string, number, object or array). This is achieved via call back function which can be accepts four arguments(accumulator, current element, index of that element, array).

Sort Method:

The sort method sorts the elements of an array according to the callback function. It is a destructive method i.e mutates the original array.

Split Method:

This method change the argument to an array.

Join Method:

The join method is used to join the elements of an array together to create a string.

Every Method:

The every method works is an array method that checks if every element passes a particular test. It returns a Boolean value - true if all values meet the criteria, false if not.

RESOURCES:
Functions

Splice and Slice both were introduced in ES3 in Javascript and both are JavaScript Array functions.

.splice() Array Method

The .splice() method is a destructive array method that modifies the original array and returns the removed item(s) in an array.
The first argument in the splice method indicates the index in the array at which to begin adding or removing elements.

The second argument is optional, but if it is provided it denotes the number of elements to be removed from the array. If not provided it denotes all elements starting from the 1st argument index will be removed.

The third argument is optional and indicates the new items to be added to the array.

.slice() Array Method

.slice() method returns the selected element(s) in an array, as a new array object. It is non-destructive method i.e does not modify the original array on which it is called. It is used to get the slice from any given array.

The first argument of .slice() is required method that indicates the index at which to begin the extraction. We can also use negative numbers to select from the end of the array.

The second argument is optional and if provided it specifies the index to end the selection without including the array at that index. If set to 0(zero), no items will be removed. And if not passed, all item(s) from provided index will be removed.

Conclusion:

Thus, .splice() modifies the array on which it is called, uses index(start) and number(number of elements to be removed) as 1st and 2nd argument respectively. Also, in terms of remembering I see slice as slicing the piece of an array from first argument to the second(without including).

Resources:

Array.prototype.slice()
Array.prototype.splice()

For example: Person object have different properties like age, height etc. All person have age but not all age has same number.

Here, person object has two property or two value pairs. We can access the property of an object using dot notation or bracket notation.

Objects can also have special type of method called as functions. We can use this keyword to access the property of the object.

Constructor:
Constructor are the functions that create new objects. Also, called as the blueprint for the construction of new objects. They will define the properties and behaviors that will belong to the new object. Constructor use this keyword to set the properties of the object they will create.

As constructor allows to create new object in the above example, Dog1 is the object created also called as instance of Dog. name and color are directly defined on the instance object so called as own properties. instanceof can be used to check the type of an object.

Prototype:
Prototype is also called as recipe for creating objects. Every object has prototype property which is the part of the constructor function that created it.

So, the properties can be be defined as own property and prototype property. Own properties are defined directly on the object instance while prototype properties are defined on the prototype.

Just like children inherit genes from their parents, an object inherits its prototype directly from the constructor function. In the Dog1 inherits its prototype from Dog constructor function. We can check this by using isPrototypeOf method.

Also, an object’s prototype is itself an object. Since a prototype is an object, a prototype can have its own prototype. The hasOwnProperty method is defined in Object.prototype which can be accessed by Dog.prototype and then by Dog1. So, Dog is the supertype while Dog1 is the subtype. It is called as prototype chain.

Inheritance:
In order to remove the repeated code and use principle in programming called DRY(Don’t Repeat Yourself) inheritance is the important principle of OOP.

Here, Cat inherits all the properties from supertype/parent Animal so Cat is the instance of Animal and snoogy is the instance of Cat which inherits all of the Animal properties. Thus, behavior can be shared through inheritance.

Closure:
In the previous example Dog had public property name and color which can be accessed and changed outside of Dog definition using :
Dog1.name = “Bob”

This may cause various issues in case of private data. So, in JavaScript closures are the for data privacy in which you can not get data from an outside scope except though the object’s privileged methods. Example:

Here, getnumber is a privileged method because it has access to the private method numberofdogs. This is possible because numberofdogs is declared in the same context as getnumber.

Regular expressions in JavaScript are special strings that help to match, search, create pattern. They form a separate language in JavaScript. Though, their syntax looks confusing but they are powerful tool for inspecting and processing strings.

A regular expression is a type of object that can be constructed using RegExp constructor or written as literal value by enclosing a pattern within forward slash(/) characters.

let reg1 = new RegExp("hello");
let reg2 = /hello/;

JavaScript has multiple ways to use regexes:

Example of using .test() regex method:

For matching cases with uppercase or lowercases we can use i flag.

To search or extract a pattern more than once we can use g flag.

We can also test multiple case by using gi flag.

Also, using dot or wild card character(.) we can match any one character in the string.

We can match single character with multiple possibilities by placing a group of characters inside the square brackets as shown in example below:

Similarly, we can match using letters from a-z and numbers from 1–8 we can use [a-z1–8] .

If you do not want to match the characters we can negated character sets. To create a negated character set, you place a caret character (^) after the opening bracket and before the characters you do not want to match.

So, the flags used here are for the following:

• i: Ignores upper and lower case from search/match
• g : Retrieves multiple values; default is set to return the first match it encounters
• ^ : Negates the matches following this flag

You can find all the more about Regex Expression from the RegExp cheatsheet and MDN web docs.

According to MDN web docs:

“The Object.freeze() method freezes an object. A frozen object can no longer be changed; freezing an object prevents new properties from being added to it, existing properties from being removed, prevents changing the enumerability, configurability, or writability of existing properties, and prevents the values of existing properties from being changed.”

Syntax:

Object.freeze(obj)

obj is the parameter i.e. the object to freeze.

const vs . object.freeze()

The above example of Object.freeze it completely makes your object immutable but it won’t give any error.

Using const will throw an error as shown in above example.

So according MDN web docs:

“The const declaration creates a read-only reference to a value. It does not mean the value it holds is immutable, solely that the variable identifier can not be reassigned.”

Thus, const and Object.freeze() are two completely different things:

• const is used for declaring variables. It creates an immutable binding i.e. cannot assign a new value to the binding(variable).
• Object.freeze() works on object values. It makes an object immutable. So, the object can not have any of its properties removed or added.

Resources:

MDN web docs: Object.freeze()

MDN web docs: const

a) Number: They are the numbers including decimals without quotes. Example: 4, 5, 9.1

b)String: They are the characters wrapped with in the quotes(single or double). Computers can perform mathematical operations on a number, but not on a string. Example: “Hello”, ‘1’

c)Boolean: This data type has only two possible values either true or false(without quotes). They are called as answers to “yes” or “no” questions.

d) Null: It represent the intentional absence of a value. It is represented by the keyword null (without quotes). Null is an assignment value.

e)Undefined: This data type is represented by the keyword undefined (without quotes). It also represents the absence of a value though it is different than null. Undefined means a variable has been declared but has not been yet assigned to a value.

f)Objects: All other data types contain only a single type value(be it number string or others) but objects are used to store collection of data and more complex entities.

g)Symbols: The symbol type is used to create unique identifiers for objects.

The result of typeof null is "object". That’s wrong. It is an officially recognized error in typeof, kept for compatibility. Of course, null is not an object. So, again, this is an error in the language.

The typeof operator allows us to find out the datatype. It can be also written as typeof(x).

Example:
var a = {}
It creates an object that inherits properties and methods from Object prototype.

var a1 = Object.create(null)
It creates an object that does not inherit anything i.e creates an empty object whose prototype is null.

It would be convenient to create an object that does not inherit from a prototype at all in case you want to use object as hash/map arbitrary keys to values.

var info = {
firstname: "John",
lastname: "Smith",
age: 35
}
function getinfo(word) {
return info[word]
}
console.log(getinfo("firstname"));  //John
console.log(getinfo("constructor"); //function Object()

In this first example, our getinfo function works perfectly for words that we have explicitly defined. However, it also returns inherited properties like constructor.We can check to if the properties are not inherited by using hasOwnProperty but we have another easy way i.e by using Object.create.

Here is the example of how can use Object.create(null).

var info = Object.create(null, {
    firstname: { value:"John" },
lastname: { value:"Smith" },
age: { value:35 }
});

function getinfo(word) {
    return info[word];
}
console.log(getinfo("firstname")); //John
console.log(getinfo("age"))        //35
console.log(getinfo("constructor"));//undefined

So, in this example in our first argument Object.create if we pass null instead of object, our new object does not inherit properties from a prototype at all.