Cognizant Javascript Interview Questions

1. What does indexOf() return if the substring is not found?

Difficulty: MediumType: MCQTopic: String Methods

IndexOf returns minus 1 when the substring is not found in the string. If found, it returns the index of the first occurrence, which is zero or a positive number. You should check if the result equals minus 1 to determine if substring exists. Never use indexOf in a boolean context without comparing, because zero is falsy but a valid index. Modern alternative is the includes method which returns true or false. LastIndexOf works similarly but searches from the end.

Example code

const str = 'Hello World';

// indexOf() - returns index or -1
console.log(str.indexOf('World')); // 6 (found at index 6)
console.log(str.indexOf('o'));     // 4 (first 'o')
console.log(str.indexOf('xyz'));   // -1 (not found)

// Correct way to check existence
if (str.indexOf('World') !== -1) {
  console.log('Found!');
}

// WRONG way (don't do this)
if (str.indexOf('Hello')) { // 0 is falsy!
  console.log('This will not run!'); // Won't execute
}

// Modern alternative - includes()
console.log(str.includes('World')); // true
console.log(str.includes('xyz'));   // false

if (str.includes('World')) {
  console.log('Found!'); // Cleaner
}

// lastIndexOf() - searches from end
const text = 'hello hello';
console.log(text.indexOf('hello'));     // 0 (first)
console.log(text.lastIndexOf('hello')); // 6 (last)

// Case sensitive
console.log(str.indexOf('world')); // -1 (lowercase not found)

// Starting position
console.log(str.indexOf('o', 5)); // 7 (search from index 5)

2. What is the correct way to prevent form submission?

Difficulty: MediumType: MCQTopic: DOM Forms

Event.preventDefault stops the default action of an event. For forms, it prevents page reload on submission. Call preventDefault in the submit event handler. This allows you to validate data and submit via AJAX instead. Return false works in inline HTML but is not recommended. It also stops propagation, which may not be intended. Preventing default is essential for modern web applications that handle forms with JavaScript. You can also prevent default on links, context menus, and other events. Understanding preventDefault is crucial for controlling browser behavior.

Example code

const form = document.getElementById('myForm');

// PREVENT FORM SUBMISSION

form.addEventListener('submit', (event) => {
  event.preventDefault(); // Stop page reload
  
  console.log('Form submitted');
  
  // Get form data
  const formData = new FormData(form);
  const data = Object.fromEntries(formData);
  console.log(data);
  
  // Validate and send via AJAX
  if (validateForm(data)) {
    submitForm(data);
  }
});

// FORM VALIDATION

function validateForm(data) {
  const errors = [];
  
  if (!data.username || data.username.trim().length < 3) {
    errors.push('Username must be at least 3 characters');
  }
  
  if (!data.email || !data.email.includes('@')) {
    errors.push('Invalid email');
  }
  
  if (!data.password || data.password.length < 8) {
    errors.push('Password must be at least 8 characters');
  }
  
  if (errors.length > 0) {
    displayErrors(errors);
    return false;
  }
  
  return true;
}

// ACCESSING FORM DATA

// Method 1: FormData API
const formData = new FormData(form);
console.log(formData.get('username'));
console.log(formData.get('email'));

// Convert to object
const dataObj = Object.fromEntries(formData);
console.log(dataObj); // {username: '...', email: '...'}

// Method 2: Direct access
const username = form.elements.username.value;
const email = form.elements.email.value;

// Method 3: querySelector
const username2 = form.querySelector('input[name="username"]').value;

// REAL-TIME VALIDATION

const emailInput = document.getElementById('email');
const emailError = document.getElementById('emailError');

emailInput.addEventListener('blur', () => {
  if (!emailInput.value.includes('@')) {
    emailError.textContent = 'Invalid email';
    emailInput.classList.add('error');
  } else {
    emailError.textContent = '';
    emailInput.classList.remove('error');
  }
});

// Clear error on input
emailInput.addEventListener('input', () => {
  emailError.textContent = '';
  emailInput.classList.remove('error');
});

// PASSWORD STRENGTH INDICATOR

const passwordInput = document.getElementById('password');
const strengthMeter = document.getElementById('strength');

passwordInput.addEventListener('input', () => {
  const password = passwordInput.value;
  let strength = 'Weak';
  
  if (password.length >= 8) {
    strength = 'Medium';
  }
  if (password.length >= 12 && /[A-Z]/.test(password) && /[0-9]/.test(password)) {
    strength = 'Strong';
  }
  
  strengthMeter.textContent = strength;
  strengthMeter.className = strength.toLowerCase();
});

// SUBMIT VIA AJAX

async function submitForm(data) {
  try {
    const response = await fetch('/api/submit', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(data)
    });
    
    if (response.ok) {
      showSuccess('Form submitted successfully!');
      form.reset();
    } else {
      showError('Submission failed');
    }
  } catch (error) {
    showError('Network error');
  }
}

// RESET FORM

const resetBtn = document.getElementById('resetBtn');

resetBtn.addEventListener('click', () => {
  form.reset(); // Clear all fields
  clearErrors();
});

// PREVENT MULTIPLE SUBMISSIONS

let isSubmitting = false;

form.addEventListener('submit', async (event) => {
  event.preventDefault();
  
  if (isSubmitting) return; // Prevent double submit
  
  isSubmitting = true;
  const submitBtn = form.querySelector('button[type="submit"]');
  submitBtn.disabled = true;
  submitBtn.textContent = 'Submitting...';
  
  await submitForm(new FormData(form));
  
  isSubmitting = false;
  submitBtn.disabled = false;
  submitBtn.textContent = 'Submit';
});

// FILE INPUT HANDLING

const fileInput = document.getElementById('fileInput');

fileInput.addEventListener('change', (event) => {
  const files = event.target.files;
  
  if (files.length > 0) {
    const file = files[0];
    console.log('File:', file.name);
    console.log('Size:', file.size);
    console.log('Type:', file.type);
    
    // Validate file
    if (file.size > 5 * 1024 * 1024) {
      alert('File too large (max 5MB)');
      fileInput.value = '';
    }
  }
});

3. What is the difference between charAt() and bracket notation for accessing characters?

Difficulty: EasyType: MCQTopic: String Methods

CharAt and bracket notation both access characters at a specific index, but handle invalid indices differently. CharAt returns an empty string for out-of-bounds indices. Bracket notation returns undefined for out-of-bounds indices. Both return the same result for valid indices. Bracket notation is more modern and commonly used. CharAt exists for backwards compatibility with older JavaScript.

Example code

const str = 'Hello';

// Both work for valid indices
console.log(str.charAt(0));  // 'H'
console.log(str[0]);         // 'H'

console.log(str.charAt(4));  // 'o'
console.log(str[4]);         // 'o'

// Different for invalid indices
console.log(str.charAt(10)); // '' (empty string)
console.log(str[10]);        // undefined

console.log(str.charAt(-1)); // '' (empty string)
console.log(str[-1]);        // undefined

// Common use cases

// Get first character
const first = str[0];

// Get last character
const last = str[str.length - 1];

// Check if character exists
if (str[5] !== undefined) {
  console.log('Character exists');
}

// charCodeAt() - returns Unicode value
console.log(str.charCodeAt(0)); // 72 (Unicode for 'H')

// Loop through characters
for (let i = 0; i < str.length; i++) {
  console.log(str[i]); // H, e, l, l, o
}

// Modern way - for...of
for (const char of str) {
  console.log(char); // H, e, l, l, o
}

4. What happens if you call a function with fewer arguments than parameters?

Difficulty: EasyType: MCQTopic: JS Functions

If you call a function with fewer arguments than parameters, the missing parameters are automatically set to undefined. JavaScript does not enforce the number of arguments and allows you to pass more or fewer arguments than the function expects. This flexibility can be useful but also requires defensive coding to handle missing arguments. You can use default parameters introduced in ES6 to provide fallback values for missing arguments.

Example code

function greet(firstName, lastName) {
  console.log(firstName); // 'John'
  console.log(lastName);  // undefined
}
greet('John'); // Called with only 1 argument

// Default parameters (ES6)
function sayHello(name = 'Guest') {
  console.log('Hello ' + name);
}
sayHello();       // 'Hello Guest'
sayHello('John'); // 'Hello John'

// Old way to handle defaults
function oldWay(name) {
  name = name || 'Guest';
  console.log('Hello ' + name);
}

// Multiple defaults
function multiply(a, b = 1) {
  return a * b;
}
console.log(multiply(5));    // 5 (5 * 1)
console.log(multiply(5, 2)); // 10

// Undefined triggers default
function test(x = 10) {
  console.log(x);
}
test(undefined); // 10 (default used)
test(null);      // null (default NOT used)

5. How do you check if a string is empty or contains only whitespace in JavaScript?

Difficulty: EasyType: SubjectiveTopic: String Methods

Checking for empty or whitespace-only strings is common in form validation and data processing. Empty string check: Compare length property to zero. Or compare directly to empty string with triple equals. Or use logical NOT for falsy check, but be careful as it also catches undefined and null. Whitespace-only check: Use trim method and check if result is empty. This removes all leading and trailing whitespace. If trimmed string is empty, original contained only whitespace. Common validation patterns: Check if string exists and has content. Check if string is not just spaces. Validate user input before processing. Provide user feedback for invalid input. Edge cases to consider: Null and undefined are not empty strings. Zero is not an empty string. Tab and newline characters are whitespace. Empty array converted to string is empty string. Best practices: Always trim user input before validation. Check for both null or undefined and empty. Provide clear error messages. Use helper functions for reusability. String validation is essential for building robust applications that handle user input correctly.

Example code

// CHECK IF STRING IS EMPTY

// Method 1: Check length
function isEmpty(str) {
  return str.length === 0;
}

console.log(isEmpty(''));      // true
console.log(isEmpty('hello')); // false

// Method 2: Direct comparison
function isEmpty2(str) {
  return str === '';
}

// Method 3: Falsy check (careful!)
if (!str) {
  // This catches '', undefined, null
  console.log('Empty or falsy');
}

// CHECK IF STRING IS EMPTY OR WHITESPACE

// Method 1: Trim and check (best)
function isEmptyOrWhitespace(str) {
  return str.trim().length === 0;
}

console.log(isEmptyOrWhitespace(''));        // true
console.log(isEmptyOrWhitespace('   '));    // true
console.log(isEmptyOrWhitespace('\t\n'));   // true
console.log(isEmptyOrWhitespace('hello'));  // false

// Method 2: Regex
function isEmptyOrWhitespace2(str) {
  return /^\s*$/.test(str);
}

// HANDLE NULL/UNDEFINED

function isNullOrEmpty(str) {
  return !str || str.trim().length === 0;
}

console.log(isNullOrEmpty(null));      // true
console.log(isNullOrEmpty(undefined)); // true
console.log(isNullOrEmpty(''));        // true
console.log(isNullOrEmpty('   '));    // true
console.log(isNullOrEmpty('hello'));  // false

// FORM VALIDATION EXAMPLE

function validateForm(formData) {
  const errors = [];
  
  // Check username
  if (!formData.username || formData.username.trim().length === 0) {
    errors.push('Username is required');
  }
  
  // Check email
  if (!formData.email || formData.email.trim().length === 0) {
    errors.push('Email is required');
  }
  
  // Check if string has minimum length
  if (formData.password && formData.password.trim().length < 8) {
    errors.push('Password must be at least 8 characters');
  }
  
  return errors;
}

const errors = validateForm({
  username: '  ',
  email: '',
  password: 'short'
});
console.log(errors);
// ['Username is required', 'Email is required', 'Password must be...']

// REUSABLE VALIDATION HELPERS

const StringUtils = {
  isEmpty: (str) => !str || str.length === 0,
  
  isBlank: (str) => !str || str.trim().length === 0,
  
  hasContent: (str) => str && str.trim().length > 0,
  
  hasMinLength: (str, min) => str && str.trim().length >= min,
  
  isNotEmpty: (str) => str && str.length > 0
};

// Usage
const input = '  hello  ';
console.log(StringUtils.isEmpty(input));    // false
console.log(StringUtils.isBlank(input));    // false
console.log(StringUtils.hasContent(input)); // true

// EDGE CASES

console.log(isEmpty(null));      // TypeError (cannot read length)
console.log(isEmpty(undefined)); // TypeError
console.log(isEmpty(0));         // TypeError

// Safe check
function safeIsEmpty(str) {
  return typeof str === 'string' && str.length === 0;
}

console.log(safeIsEmpty(null));  // false
console.log(safeIsEmpty(''));    // true

6. What is the difference between parameters and arguments?

Difficulty: EasyType: MCQTopic: JS Functions

Parameters are placeholders defined in a function declaration. Arguments are the real values passed when calling that function. In short, parameters are like empty boxes, and arguments are what you put inside them. If you pass fewer arguments than parameters, the missing ones become undefined. Matching them correctly ensures your function works as expected.

Example code

function add(a, b) { return a + b; }
console.log(add(2, 3)); // 2 and 3 are arguments; a and b are parameters

7. What is the difference between hasOwnProperty and the in operator?

Difficulty: EasyType: MCQTopic: Object Props

HasOwnProperty checks if a property exists directly on the object, not in its prototype chain. The in operator checks if a property exists anywhere in the prototype chain, including inherited properties. Use hasOwnProperty when you only want own properties, not inherited ones. This is important when iterating over objects to avoid processing inherited properties. Modern alternative is Object.hasOwn for better safety. Understanding this difference is crucial for working with prototypes.

Example code

function Person(name) {
  this.name = name;
}

Person.prototype.greet = function() {
  console.log('Hello');
};

const john = new Person('John');
john.age = 30;

// hasOwnProperty - only own properties
console.log(john.hasOwnProperty('name'));  // true (own)
console.log(john.hasOwnProperty('age'));   // true (own)
console.log(john.hasOwnProperty('greet')); // false (inherited)

// in operator - checks prototype chain
console.log('name' in john);  // true (own)
console.log('age' in john);   // true (own)
console.log('greet' in john); // true (inherited)
console.log('toString' in john); // true (from Object.prototype)

// Iterating safely with for...in
for (let key in john) {
  console.log(key); // name, age, greet (includes prototype)
}

for (let key in john) {
  if (john.hasOwnProperty(key)) {
    console.log(key); // name, age (only own)
  }
}

// Modern alternative - Object.keys (only own enumerable)
const ownKeys = Object.keys(john);
console.log(ownKeys); // ['name', 'age']

// Object.hasOwn (ES2022) - safer than hasOwnProperty
console.log(Object.hasOwn(john, 'name'));  // true
console.log(Object.hasOwn(john, 'greet')); // false

// Why Object.hasOwn is better
const obj = Object.create(null); // No prototype
// obj.hasOwnProperty('x'); // TypeError!
Object.hasOwn(obj, 'x'); // false (safe)

// Practical example - checking property
function getValue(obj, key) {
  if (obj.hasOwnProperty(key)) {
    return obj[key];
  }
  return 'Property not found';
}

8. What does JSON.stringify() do?

Difficulty: EasyType: MCQTopic: JS Objects

JSON stringify converts a JavaScript object into a JSON string. It is used to send data to servers, store data in local storage, or create deep copies. Undefined, functions, and symbols are omitted from the output. Dates are converted to strings. You can pass optional parameters for formatting and filtering. JSON parse does the opposite, converting JSON string back to object.

Example code

const obj = {
  name: 'John',
  age: 30,
  active: true
};

// Convert to JSON string
const json = JSON.stringify(obj);
console.log(json); // '{"name":"John","age":30,"active":true}'
console.log(typeof json); // 'string'

// Pretty print with indentation
const pretty = JSON.stringify(obj, null, 2);
console.log(pretty);
// {
//   "name": "John",
//   "age": 30,
//   "active": true
// }

// Convert back to object
const parsed = JSON.parse(json);
console.log(parsed); // {name: 'John', age: 30, active: true}

// What gets omitted
const complex = {
  name: 'John',
  age: 30,
  greet: function() {},  // Functions omitted
  data: undefined,       // undefined omitted
  id: Symbol('id')       // Symbols omitted
};
console.log(JSON.stringify(complex)); // '{"name":"John","age":30}'

// Deep clone using JSON
const original = {a: 1, b: {c: 2}};
const clone = JSON.parse(JSON.stringify(original));
clone.b.c = 3;
console.log(original.b.c); // 2 (unchanged)

9. How many primitive data types are there in JavaScript?

Difficulty: EasyType: MCQTopic: Data Types

JavaScript has exactly 7 primitive data types. The 7 primitive types: String for text like names and messages. Number for all numbers including decimals. BigInt for extremely large integers. Boolean for true and false values. Undefined for variables not yet assigned. Null for intentional empty values. Symbol for unique identifiers. Memory trick: Some Nice Ugly Bears Bought New Shoes. Or remember: String, Number, Undefined, Boolean, BigInt, Null, Symbol. Primitives are immutable, stored by value, and are the basic building blocks of JavaScript.

Example code

// All 7 primitive types
let text = 'Hello';           // String
let age = 25;                 // Number
let bigNumber = 123n;         // BigInt (notice the 'n')
let isActive = true;          // Boolean
let notAssigned;              // undefined
let empty = null;             // null
let id = Symbol('unique');    // Symbol

// Check types with typeof
console.log(typeof text);       // 'string'
console.log(typeof age);        // 'number'
console.log(typeof bigNumber);  // 'bigint'
console.log(typeof isActive);   // 'boolean'
console.log(typeof notAssigned);// 'undefined'
console.log(typeof empty);      // 'object' (JavaScript bug!)
console.log(typeof id);         // 'symbol'

// Everything else is an object
let arr = [1, 2, 3];        // object
let obj = {name: 'John'};   // object
let func = function() {};   // function (special object)

10. What does array.length return?

Difficulty: EasyType: MCQTopic: JS Arrays

The length property returns the number of elements in an array. It is always one more than the highest index because arrays are zero-indexed. You can also set the length property to truncate or extend an array. Setting length to 0 is a quick way to empty an array. The length property is automatically updated when you add or remove elements.

Example code

const numbers = [10, 20, 30, 40, 50];

// Get length
console.log(numbers.length); // 5

// Access last element using length
console.log(numbers[numbers.length - 1]); // 50

// Set length to truncate
numbers.length = 3;
console.log(numbers); // [10, 20, 30]

// Set length to 0 (empty array)
numbers.length = 0;
console.log(numbers); // []

// Empty array check
const arr = [];
if (arr.length === 0) {
  console.log('Array is empty');
}

// Length is always 1 more than highest index
const sparse = [1, 2, 3];
sparse[10] = 100;
console.log(sparse.length); // 11 (not 4!)

11. What happens if a function does not have a return statement?

Difficulty: EasyType: MCQTopic: JS Functions

Every JavaScript function returns something. If you do not write a return statement, it automatically returns undefined. This means the function completes its work but does not give any value back to the caller. Use a return statement when you want to send data out of a function. Remember, console.log only displays the result — it does not return it.

Example code

function add(a, b) {
  const sum = a + b;
}

console.log(add(2, 3)); // undefined

12. Which functions are hoisted in JavaScript?

Difficulty: MediumType: MCQTopic: Scope Hoisting

Hoisting means moving declarations to the top during compilation. Only function declarations are hoisted, not function expressions or arrow functions. That’s why you can call a declared function before writing it in code. This behavior helps JavaScript interpret functions flexibly but can also cause confusion if misused. Always declare clearly to keep your code readable.

Example code

greet(); // Works!
function greet() {
  console.log('Hello');
}

sayHi(); // Error
const sayHi = function() {
  console.log('Hi');
};

13. What is the correct syntax of the ternary operator?

Difficulty: EasyType: MCQTopic: JS Operators

The ternary operator syntax is: condition ? valueIfTrue : valueIfFalse It is a shorthand for if else statements. The condition is evaluated first. If true, it returns the value after the question mark. If false, it returns the value after the colon. It is the only JavaScript operator that takes three operands, hence the name ternary. Use it for simple conditions to make code more concise. Avoid nesting multiple ternary operators as it reduces readability.

Example code

// Basic ternary
let age = 20;
let status = age >= 18 ? 'Adult' : 'Minor';
console.log(status); // 'Adult'

// Same as if-else
let status2;
if (age >= 18) {
  status2 = 'Adult';
} else {
  status2 = 'Minor';
}

// In function return
function checkEven(num) {
  return num % 2 === 0 ? 'Even' : 'Odd';
}
console.log(checkEven(4)); // 'Even'
console.log(checkEven(7)); // 'Odd'

// Inline usage
let score = 85;
console.log('You ' + (score >= 60 ? 'passed' : 'failed'));

// Avoid deep nesting (hard to read)
let grade = score > 90 ? 'A' : score > 80 ? 'B' : 'C';

Master Interviews
Anywhere, Anytime

Quick overview

Cognizant · Javascript questions (13)

1. What does indexOf() return if the substring is not found?

Continue your preparation

2. What is the correct way to prevent form submission?

3. What is the difference between charAt() and bracket notation for accessing characters?

4. What happens if you call a function with fewer arguments than parameters?

5. How do you check if a string is empty or contains only whitespace in JavaScript?

6. What is the difference between parameters and arguments?

7. What is the difference between hasOwnProperty and the in operator?

8. What does JSON.stringify() do?

9. How many primitive data types are there in JavaScript?

10. What does array.length return?

11. What happens if a function does not have a return statement?

12. Which functions are hoisted in JavaScript?

13. What is the correct syntax of the ternary operator?

Master Interviews Anywhere, Anytime

Cognizant Javascript interview questions

Quick overview

1. What does indexOf() return if the substring is not found?

Continue your preparation

2. What is the correct way to prevent form submission?

3. What is the difference between charAt() and bracket notation for accessing characters?

4. What happens if you call a function with fewer arguments than parameters?

5. How do you check if a string is empty or contains only whitespace in JavaScript?

6. What is the difference between parameters and arguments?

7. What is the difference between hasOwnProperty and the in operator?

8. What does JSON.stringify() do?

9. How many primitive data types are there in JavaScript?

10. What does array.length return?

11. What happens if a function does not have a return statement?

12. Which functions are hoisted in JavaScript?

13. What is the correct syntax of the ternary operator?

Master Interviews
Anywhere, Anytime