Question 1

Can you explain the differences between stacks and queues in data structures? Provide code examples of each.

Accepted Answer

Stacks and queues are both linear data structures, but they have different rules for adding and removing elements. A stack follows the Last In First Out (LIFO) principle, while a queue follows the First In First Out (FIFO) principle.

Here’s an example of a stack implementation in JavaScript:

```javascript
class Stack {
    constructor() {
        this.items = [];
    }

push(element) {
        this.items.push(element);
    }

pop() {
        if (this.isEmpty()) return null;
        return this.items.pop();
    }

isEmpty() {
        return this.items.length === 0;
    }
}

const stack = new Stack();
stack.push(1);
stack.push(2);
console.log(stack.pop()); // Outputs: 2
```

For a queue implementation:

```javascript
class Queue {
    constructor() {
        this.items = [];
    }

enqueue(element) {
        this.items.push(element);
    }

dequeue() {
        if (this.isEmpty()) return null;
        return this.items.shift();
    }

isEmpty() {
        return this.items.length === 0;
    }
}

const queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);
console.log(queue.dequeue()); // Outputs: 1
```

In these examples, the `Stack` class allows you to push and pop elements, while the `Queue` class allows you to enqueue (add) and dequeue (remove) elements. Both implementations include a method to check if the structure is empty, which is crucial for preventing errors.

Question 2

Define the different types of database keys: Primary, Foreign, and Unique constraints. How do they ensure data integrity in relational databases like PayPal?

Accepted Answer

In relational databases, keys are fundamental for maintaining data integrity and establishing relationships between tables. Here’s an overview of the different types of keys:

1. Primary Key: A primary key uniquely identifies each record in a table. It cannot contain NULL values and must contain unique values for each row. A table can have only one primary key.

Example:
   ```sql
   CREATE TABLE Users (
       UserID INT PRIMARY KEY,
       UserName VARCHAR(100) NOT NULL
   );
   ```

2. Foreign Key: A foreign key is a field (or collection of fields) in one table that uniquely identifies a row of another table. It establishes a relationship between the two tables, enforcing referential integrity. A foreign key can accept NULL values unless specified otherwise.

Example:
   ```sql
   CREATE TABLE Orders (
       OrderID INT PRIMARY KEY,
       UserID INT,
       FOREIGN KEY (UserID) REFERENCES Users(UserID)
   );
   ```

3. Unique Constraint: A unique constraint ensures that all values in a column are different from one another, effectively preventing duplicate entries. Unlike primary keys, a table can have multiple unique constraints, and these can accept NULL values.

Example:
   ```sql
   CREATE TABLE Users (
       UserID INT PRIMARY KEY,
       UserName VARCHAR(100) NOT NULL,
       Email VARCHAR(100) UNIQUE NOT NULL
   );
   ```

### Ensuring Data Integrity:
Keys are vital for data integrity in relational databases like PayPal:
- Primary Keys ensure that each entry in the Users table can be uniquely identified, which is crucial for user-specific data retrieval.
- Foreign Keys maintain the relationship between users and their orders, ensuring that every order is linked to a valid user.
- Unique Constraints prevent duplicate emails in the Users table, ensuring that no two users can register with the same email address, which is essential for user identification and communication.

By implementing these keys, relational databases can maintain high data integrity and reduce the risk of data anomalies.

Question 3

What is the purpose of the 'this' keyword in JavaScript, and how does it behave in different contexts?

Accepted Answer

The `this` keyword in JavaScript refers to the object from which it was called. Its value is determined by how a function is called, and it can behave differently in various contexts:

1. Global context: In the global execution context, `this` refers to the global object (i.e., `window` in browsers).
   
   ```javascript
   console.log(this); // In browser, it logs the Window object
   ```

2. Function context: In a regular function, `this` refers to the global object unless the function is called as a method on an object.
   
   ```javascript
   function show() {
       console.log(this);
   }
   show(); // Logs the global object
   ```

3. Object method: When a function is called as a method of an object, `this` refers to that object.
   
   ```javascript
   const person = {
       name: 'Alice',
       greet: function() {
           console.log(this.name);
       }
   };
   person.greet(); // Logs 'Alice'
   ```

4. Arrow functions: Arrow functions do not have their own `this` context; they inherit `this` from the parent scope.
   
   ```javascript
   const person = {
       name: 'Alice',
       greet: function() {
           const arrowFunc = () => {
               console.log(this.name);
           };
           arrowFunc();
       }
   };
   person.greet(); // Logs 'Alice'
   ```

5. Event handlers: In event handlers, `this` refers to the element that triggered the event.
   
   ```javascript
   const button = document.querySelector('button');
   button.addEventListener('click', function() {
       console.log(this); // Logs the button element
   });
   ```

Understanding how `this` behaves in different contexts is essential for writing effective JavaScript code, especially in object-oriented programming and event handling.

Question 4

What is the difference between an INNER JOIN and a LEFT JOIN in SQL? Provide examples.

Accepted Answer

The difference between an INNER JOIN and a LEFT JOIN lies in how they handle unmatched records. An INNER JOIN returns only the rows that have matching values in both tables, while a LEFT JOIN returns all rows from the left table and matched rows from the right table, with NULLs in case of no match.

1. INNER JOIN example:
   
   ```sql
   SELECT a.id, a.name, b.order_date 
   FROM customers a
   INNER JOIN orders b ON a.id = b.customer_id;
   ```
   This query will return only customers who have placed orders.

2. LEFT JOIN example:
   
   ```sql
   SELECT a.id, a.name, b.order_date 
   FROM customers a
   LEFT JOIN orders b ON a.id = b.customer_id;
   ```
   This query will return all customers, including those who have not placed any orders (with NULL for order_date).

Understanding these differences is crucial for effective data retrieval in relational databases.

Question 5

What are the core concepts of React components and props? Provide an example of how to pass props to a component.

Accepted Answer

In React, a component is a reusable piece of UI that can accept inputs known as 'props' (short for properties). Props allow data to flow from parent components to child components, enabling dynamic rendering based on the input. Here’s an example of a parent component passing props to a child component: ```javascript import React from 'react'; function Greeting(props) { return

Hello, {props.name}!

; } function App() { return ; } export default App; ``` In this example, the `Greeting` component is defined to accept a prop named `name`. The `App` component renders `Greeting` and passes the string 'John Doe' as the value for `name`. When the `Greeting` component is rendered, it displays 'Hello, John Doe!'. This demonstrates how components can be composed and reused while effectively passing data through props in React.

SarthiQ

Interview Preparation Guide

PayPal
Questions & Answers

Document Details

Need Help?

Top PayPal Interview Questions

PayPal Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Frontend Developer

Backend Developer

Interview Preparation Guide

PayPalQuestions & Answers

Document Details

Need Help?

Top PayPal Interview Questions

PayPal Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Frontend Developer

Backend Developer

PayPal
Questions & Answers