DEV Community: Rohit

Looking for the dev community especially sofware developer for developing my skills ...

Rohit — Thu, 26 Dec 2024 18:03:12 +0000

Hello all i am pursing Btech degree in computer now i am in the final year looking for the community for building and growing the my skills ...looking forward to teach me and get oppourtunity to me .....

Pattern Printing

Rohit — Tue, 13 Aug 2024 01:52:20 +0000

#include <iostream>
using namespace std;
int main() {
    // Write C++ code here
   int n=5;
   for(int row=1;row<=n;row++){
       for(int space =1;space<=row;space++){
           cout<<" ";
       }
       for(int col=1;col<=n-row+1;col++){
           cout<<"* ";
       }
       cout<<endl;
   }
   for(int row=1;row<=n;row++){
       for(int space =1;space<=n-row;space++){
           cout<<" ";
       }
       for(int col=1;col<=row;col++){
           cout<<" *";
       }
       cout<<endl;
   }

    return 0;
}

Learning New Things

Rohit — Fri, 19 Apr 2024 18:32:16 +0000

Map,Reduce,For-each Loops in js

Rohit — Tue, 16 Apr 2024 13:10:21 +0000

Reduce:
The reduce() function iterates over the elements of an array and accumulates a single result by applying a provided function against an accumulator and each element in the array.

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
console.log(sum); // Output: 15

Industry Scenario: Consider an e-commerce platform where you need to calculate the total price of items in a shopping cart. You have an array of objects representing each item with properties like price and quantity. You can use reduce() to sum up the total price:

const cartItems = [
  { name: 'Shirt', price: 20, quantity: 2 },
  { name: 'Pants', price: 30, quantity: 1 },
  { name: 'Shoes', price: 50, quantity: 1 }
];

const totalPrice = cartItems.reduce((total, item) => total + (item.price * item.quantity), 0);
console.log(totalPrice); // Output: 120

ForEach:
The forEach() function executes a provided function once for each array element.

const numbers = [1, 2, 3, 4, 5];
numbers.forEach(number => console.log(number));
// Output:
// 1
// 2
// 3
// 4
// 5

Industry Scenario: Consider a scenario in a project management tool where you want to update the status of each task in a list. You can use forEach() to iterate through the array of tasks and update their status:

const tasks = [
  { id: 1, name: 'Task 1', status: 'Pending' },
  { id: 2, name: 'Task 2', status: 'InProgress' },
  { id: 3, name: 'Task 3', status: 'Pending' }
];

tasks.forEach(task => {
  if (/* condition for updating status */) {
    task.status = 'Completed';
  }
});

reduce()

const cartItems = [
  { name: 'Shirt', price: 20, quantity: 2 },
  { name: 'Pants', price: 30, quantity: 1 },
  { name: 'Shoes', price: 50, quantity: 1 }
];

const totalPrice = cartItems.reduce((total, item) => total + (item.price * item.quantity), 0);
console.log(totalPrice); // Output: 120

Promices and Async Await

Rohit — Tue, 16 Apr 2024 03:44:38 +0000

Promises in JavaScript:
Promises are objects representing the eventual completion or failure of an asynchronous operation. They are widely used in JavaScript for handling asynchronous operations such as fetching data from a server, reading files, or any other operations that take time to complete.

Scenario: Fetching Data from an API

Suppose you have an application where you need to fetch data from an API. You can use promises to handle the asynchronous nature of this operation.


// Example function to fetch data from an API using promises
function fetchData(url) {
  return new Promise((resolve, reject) => {
    fetch(url)
      .then(response => {
        if (!response.ok) {
          throw new Error('Network response was not ok');
        }
        return response.json();
      })
      .then(data => {
        resolve(data);
      })
      .catch(error => {
        reject(error);
      });
  });
}

// Usage
fetchData('https://api.example.com/data')
  .then(data => {
    console.log('Data:', data);
  })
  .catch(error => {
    console.error('Error:', error);
  });

In this example:

The fetchData function returns a promise that resolves with the fetched data or rejects with an error.
We handle the resolution and rejection of the promise using .then() and .catch() respectively.

Async/Await in JavaScript:
Async/await is a modern approach for writing asynchronous code in a synchronous-looking manner. It provides a syntactic sugar on top of promises, making asynchronous code easier to read and write.

Scenario: Fetching Data from an API Using Async/Await

Let's rewrite the previous example using async/await:

// Example function to fetch data from an API using async/await
async function fetchData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error('Network response was not ok');
    }
    const data = await response.json();
    return data;
  } catch (error) {
    throw error;
  }
}

// Usage
async function getData() {
  try {
    const data = await fetchData('https://api.example.com/data');
    console.log('Data:', data);
  } catch (error) {
    console.error('Error:', error);
  }
}

getData();

In this example:
The fetchData function is declared as async, indicating that it returns a promise implicitly.
We use await to pause the execution of the function until the promise returned by fetch resolves.
The getData function is also declared as async, allowing us to use await inside it to wait for the asynchronous operation to complete.

Differences in Industry Example:
Readability and Maintainability:

Promises: While promises provide a good way to handle asynchronous operations, the code can become nested and less readable when dealing with multiple asynchronous calls.
Async/Await: Async/Await simplifies the code structure by making it look more synchronous, thus enhancing readability and maintainability, especially when dealing with complex asynchronous operations.
Error Handling:

Promises: Error handling in promises is done using .catch() at the end of the promise chain, which can lead to scattered error handling logic.
Async/Await: Error handling in async/await is done using try/catch blocks, which makes it easier to handle errors locally within the asynchronous function, leading to more organized error handling.
Sequential Execution:

Promises: Promises are executed sequentially within the promise chain, which can sometimes lead to less intuitive code when dealing with multiple asynchronous operations.
Async/Await: Async/Await allows for a more sequential execution of asynchronous operations, making the code easier to understand and maintain, especially for developers who are more familiar with synchronous programming.****

For development you must know some website

Rohit — Wed, 10 Apr 2024 08:14:27 +0000

1.React :
React
gfg
MDN
IN Git
REDUX

for pacakges NPM

3.IN youtube:
1.chain Aur Code,
2.CODE WITH Harry
3.Apna College
4.Unacadmy

Promise in Javascript

Rohit — Wed, 10 Apr 2024 05:41:15 +0000

Description
A Promise is a proxy for a value not necessarily known when the promise is created. It allows you to associate handlers with an asynchronous action's eventual success value or failure reason. This lets asynchronous methods return values like synchronous methods: instead of immediately returning the final value, the asynchronous method returns a promise to supply the value at some point in the future.

A Promise is in one of these states:

While a Promise object is "pending" (working), the result is undefined.
When a Promise object is "fulfilled", the result is a value.
When a Promise object is "rejected", the result is an error object.

myPromise.state myPromise.result :
"pending" -> undefined
"fulfilled" -> a result value
"rejected" -> an error object

Exmample :

[Promises](function myDisplayer(some) {
  document.getElementById("demo").innerHTML = some;
}

let myPromise = new Promise(function(myResolve, myReject) {
  let x = 0;

// The producing code (this may take some time)

  if (x == 0) {
    myResolve("OK");
  } else {
    myReject("Error");
  }
});

myPromise.then(
  function(value) {myDisplayer(value);},
  function(error) {myDisplayer(error);}
);)

#some important packages of Express

Rohit — Thu, 04 Apr 2024 01:31:04 +0000

1.nodemon
nodemon is a tool that helps develop Node.js based applications by automatically restarting the node application when file changes in the directory are detected.

nodemon does not require any additional changes to your code or method of development. nodemon is a replacement wrapper for node. To use nodemon, replace the word node on the command line when executing your script.

Installation
Either through cloning with git or by using npm (the recommended way):
npm install -g nodemon # or using yarn: yarn global add nodemon

2.morgan
NPM Version NPM Downloads Build Status Test Coverage

HTTP request logger middleware for node.js

Named after Dexter, a show you should not watch until completion.

API
var morgan = require('morgan')
morgan(format, options)
Create a new morgan logger middleware function using the given format and options. The format argument may be a string of a predefined name (see below for the names), a string of a format string, or a function that will produce a log entry.

The format function will be called with three arguments tokens, req, and res, where tokens is an object with all defined tokens, req is the HTTP request and res is the HTTP response. The function is expected to return a string that will be the log line, or undefined / null to skip logging.

3.mongoose
TypeScript icon, indicating that this package has built-in type declarations

Mongoose
Mongoose is a MongoDB object modeling tool designed to work in an asynchronous environment. Mongoose supports Node.js and Deno (alpha).

Build Status NPM version Deno version Deno popularity

npm

Documentation
The official documentation website is mongoosejs.com.

Mongoose 8.0.0 was released on October 31, 2023. You can find more details on backwards breaking changes in 8.0.0 on our docs site.

#Node js Debugger

Rohit — Wed, 03 Apr 2024 16:55:48 +0000

Here are some ways to debug in Node.js:

Use the built-in debugger.
The Node.js built-in debugger is a simple but effective tool for debugging your code. To use it, simply add the debugger keyword to the line of code where you want to start debugging. When you run your code, the debugger will pause at that line and you can use the node debugger commands to step through your code, inspect variables, and set breakpoints.
Use the Chrome DevTools debugger.
The Chrome DevTools debugger is a more powerful debugger that can be used to debug Node.js code running in Chrome. To use it, start your Node.js code with the --inspect flag. Then, open Chrome and go to chrome://inspect/. You should see a list of Node.js processes that are running. Click on the process that you want to debug and the Chrome DevTools debugger will open.
Use a third-party debugger.
There are a number of third-party debuggers that can be used to debug Node.js code. Some popular options include Visual Studio Code, WebStorm, and IntelliJ IDEA. These debuggers offer a variety of features that can make debugging your code easier, such as breakpoints, step-through debugging, and variable inspection.

Here are some additional tips for debugging Node.js code:

Use console.log() statements to print out the values of variables.
This can be helpful for tracking down the source of a bug.
Use breakpoints to pause your code at specific points.
This can be helpful for inspecting the values of variables or stepping through your code line by line.
Use a debugger to step through your code line by line.
This can be helpful for understanding how your code is executing and finding the source of a bug.
Use a debugger to inspect the values of variables.
This can be helpful for understanding the state of your code and finding the source of a bug.

how can i take props as image in src please can you explain

Rohit — Wed, 03 Apr 2024 16:26:17 +0000