Scribd
Upload
3 views7 pages

Javascript Doc

The document provides various JavaScript functions for string manipulation, finding unique elements in arrays, grouping elements by keys, sorting arrays, and identifying duplicates. It also explains concepts like higher-order functions, call/apply/bind methods, hoisting, encapsulation, memoization, and closures. Each concept is illustrated with code examples to demonstrate their functionality.

Uploaded by

Vijayant Gautam
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views7 pages

Javascript Doc

The document provides various JavaScript functions for string manipulation, finding unique elements in arrays, grouping elements by keys, sorting arrays, and identifying duplicates. It also explains concepts like higher-order functions, call/apply/bind methods, hoisting, encapsulation, memoization, and closures. Each concept is illustrated with code examples to demonstrate their functionality.

Uploaded by

Vijayant Gautam
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 7

1.

Reverse a string

function reverseStringInbuilt(str) {
return str.split('').reverse().join('');
}

function reverseStringCustom(str) {
let reversedStr = '';
for (let i = str.length - 1; i >= 0; i--) {
reversedStr += str[i];
}
return reversedStr;
}

2. Find unique element in an array with count:

function findUniqueElements(arr) {
const elementCount = {};
const uniqueElements = [];
// Count the occurrences of each element
for (const element of arr) {
elementCount[element] = (elementCount[element] || 0) + 1;
}
// Filter elements that occur only once
for (const element of arr) {
if (elementCount[element] === 1) {
uniqueElements.push(element);
}
}
return uniqueElements;
}

function findUniqueElements(arr) {

return arr.filter((element, index) => {

return arr.indexOf(element) !== index;


});

3. Group element based on key

function groupBy(array, key) {


return array.reduce((result, currentValue) => {
const groupKey = currentValue[key];
if (!result[groupKey]) {
result[groupKey] = [];
}
result[groupKey].push(currentValue);

return result;
}, {});
}

4. Sorting function
function sortArrayCustom(arr) {
let n = arr.length;
for (let i = 0; i < n - 1; i++) {
for (let j = 0; j < n - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}return arr;
}
5. find duplicate items in an array
function findDuplicatesInbuilt(arr) {

return arr.filter(

(item, index) => arr.indexOf(item) !== index && arr.indexOf(item)


=== index

);

function findDuplicatesCustom(arr) {
const duplicates = [];
for (let i = 0; i < arr.length; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
duplicates.push(arr[i]);
}
}
}
return duplicates;
}

Q: What is Higher Order Function?


Ans: A Higher-order functions are regular functions that take other functions as
arguments or return functions as their results. Eg:

function x() {

console.log("Hi)";

};
function y(x) {

x();

};

y();

Q: Call, apply and bind?

The call method calls a function with a given this value and arguments provided
const person = {
fullName: function () {
return this.firstName + " " + this.lastName;
},
};

const person1 = {
firstName: "John",
lastName: "Doe",
};

console.log(person.fullName.call(person1));

The apply method is similar to call, but it takes arguments as an array

const person = {
fullName: function (city, country) {
return this.firstName + " " + this.lastName + ", " + city + ", " +
country;
},
};

const person1 = {
firstName: "John",
lastName: "Doe",
};
console.log(person.fullName.apply(person1, ["Oslo", "Norway"]));

The bind method creates a new function that, when called, has its this value set to
the provided value, with a given sequence of arguments
const person = {
firstName: "John",
lastName: "Doe",
fullName: function () {
return this.firstName + " " + this.lastName;
},
};

const person1 = {
firstName: "Jane",
lastName: "Doe",
};

const fullName = person.fullName.bind(person1);

console.log(fullName());

Q: Hoisting

Hoisting is a concept which enables us to extract values of variables and


functions even before initialising/assigning value without getting error and this is
happening due to the 1st phase (memory creation phase) of the Execution
Context.
Q: Data Hiding and Encapsulation:

● Encapsulation hides the internal details of an object and exposes only


necessary methods and properties. It improves code maintainability and
security.

Q: Memoization

Memoization:

● Memoization optimizes expensive function calls by caching their results.


It's useful for recursive or repetitive computations.

Q: Closure

A closure is a function that has access to its outer function scope even after
the function has returned. Meaning, A closure can remember and access
variables and arguments reference of its outer function even after the function
has returned.

If a function needs to access a variable, it first goes to its local memory. When it
does not find it there, it goes to the memory of its lexical parent.
function x() {
var a = 7;
function y() {
console.log(a);
}
return y;
}
var z = x();
console.log(z); // value of z is entire code of function y.

You might also like