C questions

CSS Grid Layout areas are named regions in a grid. Defined with `grid-template-areas`, they simplify the placement of grid items. For example, `grid-template-areas: 'header header' 'main sidebar' 'footer footer';` organizes content into distinct sections.

`align-items` aligns flex items along the cross axis. Values include `flex-start`, `flex-end`, `center`, `baseline`, and `stretch`. For example, `align-items: center;` vertically centers items within the flex container.

`justify-content` aligns flex items along the main axis. Values include `flex-start`, `flex-end`, `center`, `space-between`, and `space-around`. For example, `justify-content: space-between;` distributes items with equal space between them and no space at the ends.

Use `position: sticky;` along with `top`, `right`, `bottom`, or `left` to create a sticky element that toggles between `relative` and `fixed` positioning based on scroll position. For example, `position: sticky; top: 0;` keeps the element at the top of its container as you scroll.

readFile reads the entire file into memory, which can be inefficient for large files, whereas createReadStream reads the file in chunks, making it more memory efficient. Example: Use fs.createReadStream() when reading large files to prevent memory overload.

The 'require' function is used to import modules in Node.js, following the CommonJS module system. Example: To import the 'fs' module, you use 'const fs = require('fs');' to access file system operations like reading or writing files.

Express.js is a fast, minimal web framework for Node.js that simplifies server creation and request handling. Example: Express allows you to define routes and middleware in a structured way. A simple Express app might handle GET requests at '/home' with app.get('/home').

Clustering allows Node.js to create child processes (workers) that share the same server port to handle multiple requests in parallel. This improves application performance by leveraging multi-core systems. Example: Using the cluster module to spawn worker processes for increased throughput.

ES modules allow you to use JavaScript's import/export syntax in Node.js. Example: In an ES module, you can import another module using 'import { func } from './module.js';' instead of using 'require'. Node.js supports ES modules natively from version 12 onwards.

The crypto module in Node.js provides cryptographic functionalities like hashing, encryption, and decryption. Example: To hash a password before storing it, you can use crypto.createHash('sha256').update('password').digest('hex'). It ensures data security by generating unique and irreversible hashes.

npm (Node Package Manager) is the default package manager for Node.js, used to manage packages and dependencies in Node.js projects. Example: npm install installs dependencies, and npm init initializes a new project with a package.json file to manage those dependencies.

Environment variables in Node.js can be accessed via process.env. These variables allow you to configure application settings such as API keys or database URLs without hardcoding sensitive information. Example: Accessing an environment variable using process.env.DB_URL in the code.

Synchronous methods block the event loop until the operation is complete, while asynchronous methods allow the program to continue running while the operation completes in the background. Example: fs.readFileSync is synchronous, while fs.readFile is asynchronous, not blocking the event loop.

Redux Thunk is a middleware that allows action creators to return a function instead of an action object. This enables handling asynchronous operations. For example, you can fetch data from an API and dispatch an action once the data is received.

Actions in Redux are plain JavaScript objects that represent an intention to change the state. They must have a 'type' property. For example, an action to add a user might look like this: { type: 'ADD_USER', payload: { id: 1, name: 'John' } }.

The Redux store holds the application's state. It provides methods to access the state, dispatch actions, and register listeners. For example, when an action is dispatched to add a new item, the store updates its state and notifies subscribers.

Redux Toolkit is the official, recommended way to write Redux logic. It simplifies store setup and reduces boilerplate. With features like 'createSlice', it allows for easy state management and action creation, making development faster and more intuitive.

To create a slice in Redux Toolkit, use 'createSlice'. It takes an object with a name, initial state, and reducers. For example: const userSlice = createSlice({ name: 'user', initialState: {}, reducers: { addUser: (state, action) => { state[action.payload.id] = action.payload; } }});.

Redux is a predictable state container for JavaScript apps. It helps manage the state of an application in a centralized way, allowing for easier debugging and testing. For example, in a React app, Redux can store user authentication status, which can be accessed by any component.

createAsyncThunk is a utility in Redux Toolkit for handling asynchronous actions. It simplifies the process of creating thunks. For example: const fetchUser = createAsyncThunk('user/fetch', async (userId) => { const response = await fetch(`/api/users/${userId}`); return response.json(); });.

Add custom properties to `req` in middleware. For example: `app.use((req, res, next) => { req.customProperty = 'value'; next(); });` allows access to `req.customProperty` in subsequent middleware and routes.

Implement authentication using middleware like `passport` or `jsonwebtoken`. For example: `passport.authenticate('local')` or verify JWT tokens in middleware to control access based on user credentials.

Set response headers using `res.set()`. For example: `res.set('Content-Type', 'application/json');` sets the `Content-Type` header. You can also use `res.header()` for similar functionality.

Synchronous errors are caught using try-catch blocks, while asynchronous errors should be handled with `.catch()` or async error-handling middleware. For example: `app.use(async (req, res, next) => { try { await asyncFunction(); } catch (err) { next(err); } });`.

A reducer is a pure function that takes the current state and an action as arguments, returning a new state. For instance, a user reducer might handle actions like 'ADD_USER' or 'REMOVE_USER' and return the updated user list.