Hello! I am Vishal Tiwari and I am going to provide you with some challenging javascript interview questions.
console.log(typeof null); // Output?
Output: object
Explanation: This is a well-known quirk in JavaScript. The typeof operator returns "object" when applied to null, even though null is not an object. This behavior is due to how JavaScript was implemented and has been retained for backward compatibility.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: false
Explanation: Due to the way floating-point arithmetic works in JavaScript (and many programming languages), 0.1 0.2 does not precisely equal 0.3. Instead, it results in 0.30000000000000004, leading to the comparison returning false.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: 123
Explanation: When you try to set a property on an object using another object as a key (a[b]), JavaScript converts the object b to a string, which results in "[object Object]". Thus, you are essentially setting the property "[object Object]" to 123, and when you log a[b], it returns 123.
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: 11
Explanation: When you assign a value to an index that is larger than the current length of the array (like arr[10] = 11), JavaScript creates "empty slots" in the array for the indices from 3 to 9. However, the length property of the array reflects the highest index plus one, which in this case is 11.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Output:
Explanation:
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output:
Explanation:
console.log(typeof null); // Output?
Output: The output will depend on the context in which foo is called, but if it's in the global context, it will log the global object (window in browsers or global in Node.js).
Explanation: In arrow functions, this is lexically bound, meaning it uses the this value from the surrounding context. If foo is called in the global scope, this will refer to the global object.
console.log(0.1 + 0.2 === 0.3); // Output?
Output:
Explanation: The createCounter function creates a closure that maintains its own count variable. Each method (increment, decrement, getCount) accesses and modifies the same count variable, providing consistent behavior.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: [99, 2, 3]
Explanation: In JavaScript, arrays (like all objects) are reference types. When b is assigned to a, both variables point to the same array in memory. Thus, modifying b affects a.
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: 3
Explanation: In this example, the inner function has its own a variable, which shadows the a variable in the outer function. When console.log(a) is called within inner, it refers to the a defined in inner, which is 3.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Output: { a: 1, b: 3, c: 4 }
Explanation: The Object.assign() method copies the values of all enumerable properties from one or more source objects (obj1 and obj2) to a target object (an empty object {}). If the same property exists in multiple source objects, the last one takes precedence. Hence, b: 3 from obj2 overwrites b: 2 from obj1.
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output: undefined
Explanation: JavaScript automatically inserts a semicolon after the return statement if there’s a line break. Therefore, it’s interpreted as return;, which returns undefined. To return the object, you should put the opening brace { on the same line as the return keyword.
console.log(typeof null); // Output?
Output: undefined
Explanation: The variable x inside the function foo is hoisted but not initialized until the assignment var x = 2;. Thus, when console.log(x); executes, the local x is declared but not yet assigned, so it outputs undefined.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: 99
Explanation: Both a and b refer to the same array in memory. When you modify b[0], you are also modifying a[0] because they both reference the same array.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Explanation:
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: []
Explanation: Setting the length property of an array to 0 effectively clears the array. Therefore, arr is now an empty array.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Output: 2
Explanation: The inner function, when called, has its own a variable which is 2. When you call innerFunc(), it logs 2 since it refers to the local variable a within inner.
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output: 3
Explanation: The c method is called on the obj, so this inside the method refers to obj. Thus, it outputs the sum of obj.a and obj.b, which is 3.
const foo = () => { console.log(this); }; foo(); // Output?
Explanation:
console.log(typeof null); // Output?
Output: global object (or undefined in strict mode)
Explanation: In non-strict mode, the value of this inside a function called in the global context is the global object (i.e., window in browsers or global in Node.js). In strict mode, this would be undefined.
console.log(0.1 + 0.2 === 0.3); // Output?
Explanation:
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: 3
Explanation: In the inner function, a refers to the variable defined in outer. When inner is called, a is incremented from 2 to 3 and logged.
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Output: Hello, my name is undefined
Explanation: When greet is called without a context (i.e., not as a method of person), this is not bound to person. In non-strict mode, this defaults to the global object, and since name is not defined on the global object, it logs undefined.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Explanation:
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Explanation: The foo function maintains a closure around the count variable, which is incremented each time foo is called, preserving its state across calls.
console.log(typeof null); // Output?
Output:
Explanation: a is accessible in the second function due to closure. b is also accessible as it is defined in first. c is local to second, so all three variables are logged correctly.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: 3
Explanation: The call method invokes increment with newObj as this, so this.num refers to newObj.num. The increment operation changes newObj.num from 2 to 3.
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output:
const arr = [1, 2, 3]; arr[10] = 11; console.log(arr.length); // Output?
Explanation: The setTimeout functions are all referencing the same i variable due to hoisting. When the timeouts execute, i has already been incremented to 4, resulting in 4 being logged three times.
let x = 1; let y = 2; const obj = { x: 10, y: 20, sum: function() { return this.x + this.y; } }; console.log(obj.sum()); // Output? console.log(obj.sum.call({ x: 100, y: 200 })); // Output? console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?
Explanation: The map function creates a new array based on the transformation applied to each item. The original array remains unchanged, while newArray reflects the increments.
console.log(1 + '1'); // Output? console.log(1 - '1'); // Output?
Output: The output will depend on the context in which foo is called, but if it's in the global context, it will log the global object (window in browsers or global in Node.js).
Explanation: In arrow functions, this is lexically bound, meaning it uses the this value from the surrounding context. If foo is called in the global scope, this will refer to the global object.
const foo = () => { console.log(this); }; foo(); // Output?
Output: 42
Explanation: The inner function is an arrow function, which lexically binds this to the method function's context. Therefore, this.value refers to obj.value, which is 42.
function createCounter() { let count = 0; return { increment: function() { count++; return count; }, decrement: function() { count--; return count; }, getCount: function() { return count; } }; } const counter = createCounter(); console.log(counter.increment()); // Output? console.log(counter.increment()); // Output? console.log(counter.getCount()); // Output? console.log(counter.decrement()); // Output? console.log(counter.getCount()); // Output?
Output: ReferenceError
Explanation: The variable x is hoisted within myFunction, meaning it exists in the function scope but is not initialized until after the console.log(x). This results in a ReferenceError because the x variable is accessed before its declaration.
console.log(typeof null); // Output?
Output: Hello undefined
Explanation: When greet is called without an explicit context, this does not refer to obj, so this.name is undefined.
console.log(0.1 + 0.2 === 0.3); // Output?
Output: number
Explanation: In JavaScript, NaN (Not-a-Number) is considered a numeric type, and typeof NaN returns "number".
const a = {}; const b = { key: 'b' }; const c = { key: 'c' }; a[b] = 123; // What happens here? console.log(a[b]); // Output?
Output: [1, 2, 3, 4]
Explanation: Both a and b refer to the same array in memory. When you push 4 into b, it affects a as well.
The above is the detailed content of Top Challenging and hardest javascript technical interview questions with solutions.. For more information, please follow other related articles on the PHP Chinese website!