Installing Linux (WSL) in windows

e27: Installing Linux WSL in windows




<body>
    <h1>Common UNIX Commands</h1>
    <ul>
        <li>ls - List directory contents</li>
 <li>ls-al  - List directory contents in long format</li>
 <li>who - print information about user</li>
 <li>echo- prints strings onto console</li>
        <li>cd - Change directory</li>
        <li>pwd - Print working directory</li>
        <li>mkdir - Make directory</li>
        <li>rmdir - Remove directory</li>
        <li>rm - Remove files or directories</li>
        <li>cp - Copy files or directories</li>
        <li>mv - Move or rename files or directories</li>
        <li>touch - Create a new empty file</li>
        <li>cat - Concatenate and display file contents</li>
       
 
        <li>find - Search for files in a directory hierarchy</li>
      
    </ul>

</body>


Common unix commands

Common Unix Commands

**Course mein aapka bahut swagat hai!**  Node.js ko hum bahut detail mein samjhenge, aur Express aur MongoDB ko bhi achhe se cover karenge. Course lamba aur deep hone wala hai, aur hum Node.js ke core concepts ko 2024 ke end tak complete karenge. Main course ko regularly update karta rahunga, aapko bas dheere dheere padhna hai. Kabhi kabhi ek-do din ka gap ho sakta hai.

### Request from Anurag Bhaiya (Procdrr):

* Notes Jaroor banaye, chahe digital ya copy,
* WebSockets aur WebHooks bhi isme cover honge.
* Community mein active rahiye aur Discord par bhi active rahiye.
* Documents aur queries ke liye, logo se puchiye aur unke jawab dijiye.
* [App.procoderr.com](App.procoderr.com) par jaake bhi aap help maang sakte ho ya Discord mein ye kar sakte ho.
* Aao ab prerequisites ke bare me jante hain in Markdown

### Request from Notes Creator

 Dekho maine kitni pyari notes banayi hain aapke liye, aap bhi aage ki notes likh sakte ho kyunki ye notes github se hai aur open sourced hai, [ ye rahi link](https://github.com/ashumsd7/heyashu/) ab jaake github par star kro iss repo ko aur padhna jaari rakho , Dhanywaad


Welcome to Node.Js Course

e1: welcome

**Terminal:** Yeh ek tarike ka app hai jiske through aap apne system ko operate karte ho. Jaise kai tarah ke browsers hote hain, waise hi kai tarah ke terminals bhi hote hain.

Achha, ab kaise open karein? Iske liye aap apne keyboard par **Start** key ko press karein aur search bar mein **Terminal** ya **PowerShell** type karein. Aur bas, open ho jayega!

Ye terminal me kai tarah ke **shell** hote hain, jaise **Command Prompt** aur **Windows PowerShell** — yeh Windows mein milte hain. Agar aap **Linux** use karoge, to wahan aapko **Bash** shell dikhega. MacOS mein aapko **Terminal** app mein **zsh~** shell milega.

Hum aage **Bash shell** hi use karenge.

### Install bash shell

Chalo, ab VS Code mein chalte hain aur ek file banate hain **terminal.js**. Terminal ko open karne ke liye **Ctrl + J** press karo, jahan hum apna code run karte hain, wahi terminal hota hai. Ab waha right side aapko option milega select karne ka, ki aap kya use karna chahte ho — **Git Bash** select karo ya agar download nahi kiya, to [iss link pe click karke](https://git-scm.com/downloads) Git download kar lo.

VS Code ko reopen karoge, to **Git Bash** bhi dikhne lagega.

![image.png](/public/images/blogs/cmd_pro122.png)

Git install hua ki nahi ye janne ke liye aap check kr skte ho aise, terminal me

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ git -v
git version 2.45.0.windows.1
```

Chrome mein aur har ek OS mein ek terminal by default aata hai, lekin **Git Bash** shell ek best options mein se ek hai, aur yahi hum use karne wale hain.


 Introduction to Terminal and Shell

E:10 Introduction to Terminal and Shell

Now let see few commands of the shell,

```jsx
echo heyashu
```

### echo

echo is same as console.log() just printing what you typed

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo heyashu
heyashu

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo $num

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ num=8

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo $num
8
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ echo $((num+2))
10
```

So, aapne dekha ki Bash ke andar hum bahut kuch kar pa rahe hain. Actually, Bash bhi ek tarike ki scripting language hai, isme bhi loops hote hain aur bahut kuch. Bash file ka extension hota hai **.sh**, aur koi bhi file aap **.sh** se bana ke run kar sakte ho, aur saara code waha likh sakte ho.

```jsx
//test.sh

num1=2
num2=3

echo $((num1+node2))
echo "KAHTAM'

// ab terminal pe jaake likh do ./test.sh aur aapki file run ho jayegi
```

### pwd : print working Directory/ Folder

Iska full form hai **print working directory**, ye aapko current folder ka naam print kar deta hai.

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ pwd
/c/Users/Ashutosh Tiwari/Desktop/ME/node-js-by-procodrr
```

### whoami

ye user ka naam print kr deti hai

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ whoami
Ashutosh Tiwari
```

### cd

Iska naam hai **change directory**. Ek directory se pichhle ya agle mein jaane ke liye. Dekho, aap ek level upar bhi ja sakte ho aur next directory mein type karke ja sakte ho, ya fir aap pichhe ja sakte ho. To kuch commands likh deta hu, aap apne terminal mein try kariye. Haan, aur Bash hi use kariye, PowerShell nahi.

```jsx
cd ../
cd <press tab>
cd ..
cd <type file name>
```

Achha, ek cheez, agar aap **cd ../** karte jaoge to aap root directory par pahunch jaoge, aur last mein **~** sign dikhega aapko. Aur agar kahin se bhi aapko home directory mein aana hai, to aapko terminal mein sirf **cd** likhna hoga.

```jsx
~/
```

achh aapko kaise pta chalega kitne next folder hai directories hai mere curr directory ke andar

### ls : List

ye hai list command aapke type krte hi jitne folder ya diretcories hai wo list ho jayengi

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me
$ ls
ashu-port-2024/  delete/  namaste-node-js-by-ashutosh/  node-js-by-procodrr/  test/

//yad rakhein
./  represents current directory and
../ parent directory
```

### ls -la ( will discuss later)

```jsx
// i will drop a link in the heading , keep visiting 
$ ls -la
total 5
drwxr-xr-x 1 Ashutosh Tiwari 197121  0 Sep 18 13:10 ./
drwxr-xr-x 1 Ashutosh Tiwari 197121  0 Sep 18 10:42 ../
-rw-r--r-- 1 Ashutosh Tiwari 197121  0 Sep 18 10:43 terminal.js
-rw-r--r-- 1 Ashutosh Tiwari 197121 46 Sep 18 13:11 test.sh
```

### Creating , Copying Moving and Deleting using commands

Ab hum dekhne ja rhe hain files ko copy move rename aur delete kaise kr sakte hian ?

### touch : Create File

**touch** ka use karke aap ek nayi file create kar sakte ho. Agar folder yaani directory create karni ho, to **mkdir** command ka use karna padega.

```jsx
//go to you command and write 
touch index.html
// ye index.html ban jayegi same root pe, aap sape deke kayi file likh sakte  ho
```

### mkdir : Make Directory / Folder

Iska full form hai **make directory**, aur jab aap iske baad kuch likhte ho, to wo folder ke roop mein create ho jata hai. Niche jo command likhi hai, usse same root mein **src** folder ban jayega.

```jsx
$ mkdir src 
```

### cp : Copy Files

**cp** file copy karne ke liye use kiya jata hai, aur aapko do paths dene hote hain. Ye dhyan rakhna, agar aap path likh rahe ho to quotes me likhna.

```jsx
// cp <kya krna hai uska path> <jaha carna hai uska path>

Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ cp index.html src
// isse index.html src me copy ho jayegi/

// example with full path
$ cp index.html "C:\Users\Ashutosh Tiwari\Desktop\mera-project\src"
```

### mv : Move files

ye bhi same hai bs 

```jsx
// mv <kya krna hai uska path> <jaha carna hai uska path>
```

### Rename the files

Yeha abhi same command use hoti hai bs aapko file ka naam likhna hai jaise

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ mv test.sh  abc.sh
// test.sh abc.sh se rename ho jayegi.. aap yaha par path bhi de skte ho kaha move krne hai aur kya rename 
//krna hai bs baat ke aage file na rename wala naame likh do
```

Dhyan rakhiyega, yaha **Ctrl + Z** kaam nahi karta hai. Har cheez permanently remove, delete, aur rename hoti hai.

![image.png](/public/images/blogs/ctrlzpro.png)

### rm: Remove a file

```jsx
rm fileName

// for multiple files
rm fileName1 fileName2
```

### rmdir : Remove a Directory / folder

**rmdir folderName** se sirf empty directory ya folder hi delete hoga. Agar uske andar kuch hai to wo delete nahi hoga.

```jsx
rmdir emptyFolderName // deletes empty folder 

rmdir -r anyFolderName // r denotes recursive flag ( mtlb jabardasti )

// ek aur flag hota hai -f ( force ) joki bad me dekhenge
```

### Create Multiple files

Agar humein bahut saari files ek sath banani ho, to hum Bash mein loop bhi chala sakte hain.

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr/src
$ for i in {1..50}; do touch app$i.js; done
```

Aur aap delete bhi kar sakte ho, bas previous command me **touch** ki jagah **rm** likh do.

### cat : Files read

Agar bahut badi file ho, to ye concatenate karke print kar deta hai.

```jsx
cat test.sh
// niche saara content print ho jayega
```

### nano : a Editor

Ye ek tareeke ka editor hai. Iske aage koi file likhoge, to wo ek editor me khul jayegi aur aap kuch bhi edit kar sakte ho. Ye kya hota hai aur kyu hota hai, aap internet pe search kar lijiyega.

```jsx
nano abc.sh
// niche screen me jo aapko ^ dikh rha hai, use command kahte hain.+
```

![image.png](/public/images/blogs/nano_proc.png)

### vim : ye bhi ek editor hai

Vim ek aur editor hai jo **nano** se zyada powerful hai. Exit karne ke liye kuch tarike hote hain. Actually, Vim mein do modes hote hain — **insert** mode aur **command** mode. Jab aap bahar aana chahte ho ya jo bhi likha hai usko save karna chahte ho, to sabse pehle **ESC** press karo, fir likhne ke liye `:w` likho. Iska matlab hai jo aapne edit kiya hai, usse save karo. Fir `:q` likho aur enter press karo, to quit ho jaoge. Agar aap **I** press karoge to insert mode mein aa jaoge. Aap `:wq` bhi likh sakte ho, jo save aur quit dono ek saath karta hai. Vim bahut powerful hai, lekin isme bahut saari aur powerful cheezein bhi hain.

```jsx
vim app.js
```

To aapne dekha, agar server pe koi cheez aapko edit karni hai jaha sirf **CLI** hai, koi **UI** nahi, to aapko **vim** ya **nano** editor use karna hoga. **vi editor** ke baare mein bhi jaake padhiye, bahut khoobsurat cheez hai. Maza aayega! Jaake padhiyega **vi editor**, **vim editor**, aur unki history.


Basic shell commands

E11 Basic shell commands

Ab humne **GUI**, **CLI**, aur commands ke baare mein kaafi achhe se jaan liya hai. Ab baari hai ye jaanne ki **prompt** kya hota hai.

## **What is a command prompt?**

A command prompt is the input field in a text-based [user interface](https://www.techtarget.com/searchapparchitecture/definition/user-interface-UI) screen for an operating system (OS) or program. The prompt is designed to elicit an action. The command prompt consists of a brief text string followed by a blinking [cursor](https://www.techtarget.com/whatis/definition/cursor), which is where the user types command prompt commands.  [This is copied from](https://www.techtarget.com/whatis/definition/command-prompt). 
Jab hum koi bhi terminal open karte hain, jaise **Start** button par click karke **PowerShell** open karte hain, to aapko waha ek **PS** likha hua milega, jaise ye:

```jsx
PS C:\Users\heyashu>
```

Aapko pata hai ye **PS** kya hota hai? PS ka full form hota hai **Prompt String**. PS ko nahi, but `C:\Users\heyashu>` isse **Prompt** kehte hain. PS ka matlab **Prompt String** hai.

Ab aao, jaante hain prompt ko kaise customize karein?

Dekho, Bash mein **PS1** aur **PS2** naam se variables hote hain. To chalo, print karke dekhte hain. Kaise print karenge? Using `$`.

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ echo $PS1
\[\]\[\033]0;$TITLEPREFIX:$PWD\007\]\n\[\033[32m\]\u@\h \[\033[35m\]$MSYSTEM \[\033[33m\]\w\[\033[36m\]`__git_ps1`\[\033[0m\]\n$ \[\]
```

to ps1 ke andar wo stored ahi badi si string, ab isko hum rename ekr sate hain kaise??

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/Me/node-js-by-procodrr
$ PS1=ashu
ashu
ashu
ashu

// ab upar wali string badal ke ashu ho gyi. lekin ye permanant nahi fix hua 
// bad me permanant krenge modify isko
```

### Configure Terminal

To agar hume **PS1** aur **PS2** ko permanently change karna hai, to aaye dekhte hain kaise possible hoga.

Ek file hoti hai **home directory** ke andar. Achha, aapko kaise pata chalega home directory kya hai? To aap terminal mein jaayein aur likhiye:

```jsx
~ explorer .
// enter kriye aur aapka home directory fataak se file explorere me khul jayegi
// note: agar aap linux pe hai to ./ use karye after explorer
```

to ab folder open hua ab agar `.bashrc` file na ho waha to aapko banani padegi aise, ya fir normally

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~
$ touch .bashrc
```

ab file create ho jayegi..

ab us `.bashrc` ko vs code ya kisi editor me open kr lijiye, ab iss bash rc me jo bhi likh denge aap wo har naye terminal pe run hoga , ab aap likh dijiye .bashrc me

```jsx
//.bashrc
echo "heyyyy"
PS1='hello=> '
```

ab har bar naye terminal me mere hello print hoga

```jsx
// in terminal
heyyyy
hello=> 
```

### Alias

Iska use tab hota hai jab aapko koi bahut badi command baar-baar likhni padti ho, to aap usko ek naam de sakte ho. Jaise, `git add .` aur aap nahi chahte baar-baar ye command likho, to iska ek upnaam (alias) de do, jaise mera naam Ashutosh hai aur aap mujhe **Ashu** bula sakte ho waise. Ab aapko **.bashrc** file mein likhna hoga.

To chalo, sabse pehle **.bashrc** ko **source** karte hain aur run karte hain.

```jsx
// in terminal
source ~./.bashrc
```

ab jaise maine bashrc me likh diya hai 

```
// .bashrc
alias hey='echo 1233445'
```

ab jaise aapne source ~/.bashrc kiya to wo file run kr jayegi aur saara content print ho jayega, ab jaise aap hey likhge 1233445 print ho jayega

```jsx
Ashutosh Tiwari@DESKTOP-NCVPMH3 MINGW64 ~/Desktop/ME/node-js-by-procodrr
$ hey
1233445
```

aise aap git ki commnds ko bhi customize kr sakte ho, aurr bahut kuchh, ab dekho aise aap bahut customize kr sakte ho,. kuchh error aaye mujhe contact kro ya fi google kariye, Dhanywaad


Promt in Terminal

E16: Promt in terminal

Jaise hum JavaScript ko web pe run karte hain aur browser ki capabilities jaante hain, jaise document aur aur bhi cheezen, waise hi **Node.js** bhi JavaScript hai, lekin jab run hoti hai, to usko **OS** yani hardware ka access hota hai. Matlab, Node.js ko operating system ke resources tak pohoch hoti hai.

Yeh samajhna zaroori hai ki kaise yeh sab kaam karta hai, kyunki agar aapko OS basics acche se aate hain, to aap ek pro developer ban sakte ho. Isi liye OS ki understanding bahut important hai Node.js development mein.

### CPU: Central Processing Unit

Jo abhi aapke dimaag me image aa rahi hai, wo CPU nahi hai. Wo **CPU ka dabba** hota hai, jise cabinet bolte hain. CPU actually uska chhota sa hissa hota hai jo **motherboard** ke upar laga rehta hai.

![image.png](/public/images/blogs/procod_os2.png)

**Cabinet** ke andar **Motherboard** hota hai, aur Motherboard pe hi **SSD** laga hota hai. **OS** inhi cheezon pe run karta hai.

### Core kya hoti hai?

**CPU** me **cores** hoti hain, lekin unhe aankhon se nahi dekh sakte. Pehle zamane me sirf **single core** hoti thi, aur ek baar me sirf ek hi program run ho sakta tha. Aaj kal **4 cores** hoti hain, jinka matlab yeh hai ki ek baar me multiple tasks perform ho sakte hain.

### Logical Cores

Agar hamare system me 4 **logical cores** hain, to modern technology se unhe **8** cores tak badha diya jata hai. Is tarah se manage kiya jata hai ki 4 cores ka kaam **8 cores** jaisa ho jata hai. Ye sab processor ke manufacturer manage karte hain, aur **operating system** bas inhe operate karta hai. Apne system me ye information dekhne ke liye **Task Manager** open kariye, aur **CPU** tab pe jayiye — aapko sari details wahan mil jayengi.

![image.png](/public/images/blogs/prcod_os3.png)

Ab aao dekhte hain yeh sab **Node.js** se kaise pata karte hain. Apne **terminal** me jayiye, aur likhiye `node`, phir enter press karke Node.js environment me aayiye.

```jsx
🕑 23:46  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 node
Welcome to Node.js v22.2.0.
Type ".help" for more information.
> os.availableParallelism()
8  // ye hai cores 
>
```

### Operating System kya hai?

**OS** bas ek software hota hai. Yeh ek special software hai jo hardware ko manage karta hai. Yeh decide karta hai kaunsi app kitne time ke liye kaunsa hardware use karegi. Basically, OS ek manager hai jo sab applications ke liye kaam karta hai.

### Kernel kya hai?

Operating System ka ek chhota sa hissa **Kernel** kehlata hai. Kernel OS ka core part hota hai, aur yeh hardware aur OS ke beech kaam karta hai.

### Single Core ka kya matlab hota hai?

Kya iska matlab sirf ek app run hoga? Agar ek **core** sirf ek hi kaam kare, to ek time pe sirf ek hi cheez process ho sakti hai. Yeh baat 100% sahi hai, lekin iska yeh matlab nahi hai ki agar 8 logical cores hain to sirf 8 hi apps open ho sakti hain. Aap 8 se zyada apps bhi khol sakte ho.

Agar aapne 10 apps kholi hain lekin sabko ek saath use nahi kar rahe, to OS kya karta hai? OS in apps ko processor se baar-baar sync karta rehta hai, mtlb update ke liye inhe core me daal ke check karta hai. Jaise **VS Code** ko OS ne pick kiya, process pe daal ke kaam kar liya aur nikaal diya. Yeh sab ek process ke cycle me hota hai.

Do processors honge to ek baar me zyada programs handle kar paayenge, lekin iska matlab yeh nahi ki sirf 2 hi apps handle kar sakte hain. Yeh sab **context switching** ke through hota hai. Waise yeh academic concept hai, lekin context switching ko dekhna hai to aap padh sakte ho.

### Ye sb Search kr skte ho

1. C Mos kya hota hai
2. GPU kya hota hai



.....baki aage mai  kal likhta hu, aapko likhne ka man hai aage to likhiye.... edit page par click kr dijiye upar


Basic OS feat Node JS

E19 Basic OS feat Node JS


### Prerequisites
Basics of Frontend (Not covered in the course)
**HTML/CSS**: Basic knowledge of HTML and CSS is useful since we'll be using Node.js for web development.


### Good Knowledge of JavaScript (Not covered in the course)
**Syntax and Basics**: You should be comfortable with JavaScript syntax, variables, loops, conditionals, functions, and error handling.
**Advanced JavaScript Concepts**: Understanding concepts like closures, callbacks, promises, async/await, classes & OOPs, JSON, and event handling is crucial since Node.js heavily relies on asynchronous programming.


### Basics of Terminal (Covered in the course)
**Shell Commands**: You should be comfortable using basic shell commands to navigate directories, manage files, and execute scripts.


### Basics of OS (Covered in the course)
**CPU and Cores**: You should have a basic understanding of CPU and Cores.
Process, Threads and Kernel: You should have a basic understanding of Process, Threads and Kernel.


**File Systems and Paths**: Understanding file paths, relative vs absolute paths, and file permissions. Environment Variables: Knowing what environment variables are and how to set them in different operating systems.
Environment Variables: Knowing what environment variables are and how to set them in different operating systems.


### Basics of Computer Networking (Covered in the course)
**IP Addresses, Ports, and DNS**: Understanding how IP addresses, ports, and DNS work is helpful when dealing with networking in Node.js.


Above content is copied from [https://procodrr.com/nodejs/section-1_introduction/1_prerequisites/](https://procodrr.com/nodejs/section-1_introduction/1_prerequisites/) :

Prerequisite

e2:  prerequisite

Process ek unit of execution hota hai, matlab ek aisa program, code ka piece ya application jiska apna memory allocation hota hai aur jo processor ko use karke computation yani kuch kaam kar sakta hai. Har process apni life cycle ke dauran alag-alag states se guzarta hai, jaise ready state, waiting state, running state, terminated state, aur sleep state. Ye states process ki current condition ko define karti hain.

Agar aapko ye states dekhni hain ya kisi process ko monitor karna hai, to aap Windows mein Task Manager khol sakte hain, macOS mein Activity Monitor ya Linux mein System Monitor open kar sakte hain.

Har process ki apni ek unique ID hoti hai, jise Process ID (PID) kehte hain.

![image.png](/public/images/blogs/1osprocess1.jpg)

Ab in sab mein kuch important details jo humne pehle discuss ki hain, jaise Execution Context aur doosri cheezein, wo aapko dikh nahi rahi hongi. Inhe dekhne ke liye aap kuch additional apps install kar sakte hain jo in details ko monitor karne mein madad karte hain. Un apps mein se ek popular app hai **Process Explorer**.

Is app ko install karke aap har process ki in-depth information jaise CPU usage, memory consumption, aur execution context ka analysis kar sakte hain. Iske alawa, aap **htop** (Linux ke liye) aur **Activity Monitor** (macOS ke liye) jaise tools bhi use kar sakte hain.

https://learn.microsoft.com/en-us/sysinternals/downloads/process-explorer

https://processhacker.sourceforge.io/downloads.php : isme windows ka setup download kr lijiye

![image.png](/public/images/blogs/2osprocess2.jpg)

Yaha se aap **context switches** bhi dekh sakte hain. Kisi bhi subprocess pe click karke jo dialog open hoga, usse aap yeh check kar sakte ho ki uska **parent process** kya tha aur **current process** kya hai. Ab ek kaam karte hain, chaliye dekhte hain **Node.js** ka process kaise hota hai aur kitna CPU aur memory consume karta hai.

Terminal pe jaake `node` start kar dijiye. Jaise hi aap `node` start karte ho, wo **REPL environment** (Read-Eval-Print Loop) ko start kar deta hai, jiska matlab hai aap waha directly commands likh ke unhe execute kar sakte ho. 

Ab yaha se hum dekh sakte hain Node.js ka process kaise behave karta hai.   **[REPL : Read-Eval-Print Loop](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e6-installing-node-js)**

```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node
Welcome to Node.js v22.2.0.       
Type ".help" for more information.
>
```

Ye screen shot niche dekhiye, hum **Node.js** ka process observe kar rahe hain, jiska **context switch** 2004 hai, yaani ki bahut zyada nahi hai. Context switch ka matlab hota hai ki processor kitni baar ek process se dusre process me switch karta hai. 

![image.png](/public/images/blogs/3osprocess.jpg)

ab aap while(true){} ye likh dijiye node js ke terminal me

```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node
Welcome to Node.js v22.2.0.       
Type ".help" for more information.
>while(true){}
```

Node ke REPL, yani terminal me, agar aapne ek **infinite loop** chal diya, toh ab ye **Node.js** ki process aapke ek core ko poora use karegi. Ab kya hoga? Mere paas total 8 cores hain, aur ye ek core ko use kar raha hai. Toh kitna percentage hua?

100/8 = 12.5% max, na?

Ab aap niche screen shot me dekhiye, wahi dikh raha hai. Aur ab **context switch** ka jo number hai, woh count bhi badh chuka hai. Aur bas yahi pura khel hai, ki kaise ek process ek core ko fully utilize kar ke performance ko impact karti hai.

![image.png](/public/images/blogs/4osprocess.jpg)

Aap process pe right-click karke uski **priority ko "realtime"** kar sakte ho, isse ye 12.5% tak pahunch jayega, yani max utilization. Agar aapne aise 8 processes Node ke open kar diye aur unki priority ko realtime kar doge, to aapka system **Siachen Glacier** ki tarah freeze ho jayega, ekdum jam ho jayega. Phir aap kuchh nahi kar paoge, haha!

4o

### Process vairable

Accha iska alawa hamare pass node js env me process variable bhi rahta hai, aap 

```jsx
console.log(process)
// aapko dikhega
  pid: 16328,
  ppid: 23832,
  execPath: 'C:\\Program Files\\nodejs\\node.exe',
  debugPort: 9229,
```

Aap console ya debugger laga ke process ko check kar sakte ho, aur usme aapko **PID** (Process ID) aur **PPID** (Parent Process ID) bhi dikh jayegi.

Aur ab milte hai, lekin isse pehle aapko ek question ka jawab pta karna hai: **Node.js single-threaded hai ya multi-threaded?** Soch ke jawab do!

Milte hain agle blog mein..


What is process ?

e21: what is process in operation system

### Dekh rahe ho Vinod? kaa bhaiya, kaise thread ghoom rha hai ?

Achha, hum yeh toh jaante hain ki ek process ek core par execute hota hai. Lekin kya ek process sirf ek core par hi chalta hai? Nahin! Ek process ke kai sare threads ho sakte hain. Jaise Chrome mein kai tabs hote hain—ek tab mein video chal raha hota hai, aur doosre tab mein aap email likh rahe hote ho. Dono alag-alag threads mein kaam kar rahe hote hain.

Jab koi process start hota hai, toh hum kehte hain process ko "spawn" karna. Jab ek parent process apne child process ko banata hai, toh usse "spawn" kehate hain. Ye baat toh suna hi hoga? Process kai threads create kar sakta hai. Threads ko spawn karna fast hota hai, jabki process ko spawn karna kaafi expensive (mehenga) hota hai.

Baki details aap online padh sakte ho. Socho, ek Chrome jisme do tabs hain, dono alag threads par chal rahe hain, aur yeh threads alag-alag cores par run kar sakte hain. Lekin agar CPU mein sirf ek hi core hai, toh kya fayda hoga do threads banane ka? Haan, fayda hoga! Thread banane ka fayda yeh hai ki OS (Operating System) kaam efficient banata hai.

Threads ke saath kaam karne se context switches (yaad hai?) jaldi-jaldi hote rehte hain. Matlab, ek thread ke execute hone ka intezaar nahin karna padta. Samajh rahe ho? Jaise aapke do bacche (threads) ek ke baad ek kaam kar rahe hain, bina time waste kiye.

Isliye, multi-threading single core CPU par bhi possible hoti hai. Process hi thread create karta hai, isliye ise "worker thread" kehte hain, kyunki thread process ka worker hota hai. Aise samjho, aap ek boss ho (process) aur aapke do naukar hain (threads), jo bina rukhe kaam karte ja rahe hain.

Ab aao, samajhte hain kaise system mein threads ko dekh sakte hain!

### Threads in Task Manager

Ab aap Task Manager open kar lijiye... aur "Details" section mein chale jayein. Agar aapko "Threads" column nahi mil raha hai, toh kisi bhi column ke upar right-click karke "Threads" ko select kar lijiye. Isse aap dekh sakte hain ki har process mein kitne threads chal rahe hain.

Aur yeh sab aap apne third-party software mein bhi dekh sakte hain. Iske liye aap "System Informer" jaisa software download kar sakte hain. Jaise maine apne pichle blog mein bataya tha, aap yaha se bhi check kar sakte hain: [Check this](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e21-what-is-process-in-operation-system).

![image.png](/public/images/blogs/2threas2.jpg)

### Create Thread in Node.js

Aao ab Node.js me thread create karte hain aur system me observe karte hain. Ab aap Node.js me jo bhi threads dekh rahe hain, unhe aap Task Manager ya System Informer me filter kar sakte hain. Jaise hi niche diya gaya code aap VS Code ke terminal me run karenge, aapke process ka number badh jayega. Ye isliye hoga kyunki Node.js in tino loops ko lagatar run karega, aur single thread me run karega.

```
console.time();
for (let i = 0; i < 1000000000; i++) {
  if (i % 400000000 == 0) {
    console.log("loop 1 " + i);
  }
}

for (let i = 0; i < 1000000000; i++) {
  if (i % 400000000 == 0) {
    console.log("loop 2 " + i);
  }
}
for (let i = 0; i < 1000000000; i++) {
  if (i % 400000000 == 0) {
    console.log("loop 3 " + i);
  }
}
console.timeEnd(); // 4.001s
```

### Multi-threading in Node.js

Ab socho agar CPU me bahut saari cores hain, aur hamare paas ye teen kaam hain, to ab Node.js jo ki ek process hai, kaise efficiently run karega? Kaise? Ye loop ko kaise threads me efficiently dalta hai? Agar aap ye code run karke observe karenge, to aapko threads dikhaai dengi. Aao dekhte hain kaise alag-alag threads me rakhte hain.

Aao pehle 3 files banate hain `a.js`, `b.js`, aur `c.js`, aur in teeno files me hum loops paste karenge.

```jsx
console.time();

const {Worker}= require('worker_threads')

new Worker("./a.js") // pahla thread
new Worker("./b.js")  // dosora thread
new Worker("./c.js")   // teesra thread

console.timeEnd();
```

'worker_threads' ek module hai jiska use karke humne thread create kiya hai. Ab thread count bhi 3 se badh jayega, aur CPU ka usage bhi teen guna ho jayega, kyunki CPU cores block ho jayengi ab. Ye hai multi-threading... hahahahahahaha.

Soch ke dekho, agar teeno loops ek hi thread me rakh ke run karoge to 12% CPU consume hoga kyunki mere paas total 8 cores hain, to 12% * 8 = lagbhag 100%.

Lekin abhi aapne kya kiya? 3 alag-alag threads bana diye aur teeno cores block kar diye. To ab CPU usage kitna ho jayega? 12% * 3 = lagbhag 37-38% ke aas-paas dikhai dega!

![image.png](/public/images/blogs/3thread.jpg)

Actually, teeno threads parallel run kar rahe hain… isse threads ka parallel run hona kehte hain.

### Concurrency aur Parallelism

Concurrency ka matlab hota hai ki ek thread thoda sa instance run karta hai, aur context switching hoti hai. Jaise, pehle thread 1 run hota hai, phir thread 2, aur phir thread 3. Matlab, multiple threads create karke hum experience smooth karte hain. Concurrency ka matlab hai sabko ek-ek karke chance milta hai, sabka time aata hai — jaise ek-ek turn lena.

Lekin Parallelism ka matlab hota hai concurrency ke saath, lekin teeno threads ek saath parallel run honge, mtlb sabka time aayega, lekin sab sath-sath run karenge. Toh threads se cheeje to concurrent hoti hain, lekin wo parallel hongi ya non-parallel, ye depend karta hai. Lekin context switching apni jagah hoti hai.

Dekh lo bhai, mai fir bol raha hoon, ye koi academic class nahi hai, aap isko achhe se padh sakte ho aur apko maza aa raha hoga yaha... hai ki nahi? Jao aur repo ko star do... hahaha, arey yaar, parallelly!

![image.png](/public/images/blogs/4-thread.jpg)

### Node.js single-threaded hai ya multi-threaded?

Node.js bhai saab, multi-threaded hai, lekin default mein yeh single-threaded environment mein kaam karta hai. Haan, agar aap chaho to multi-threading bhi use kar sakte ho with the help of modules like `worker_threads`. Matlab, marzi aapki hai—chahe to single-threaded mein kaam karo ya multi-threading ka maza lo. Jaise ke kehna ho, "Mere account mein ek crore rupaye hain, lekin aap bol rahe ho ki main sirf ek rupaya hi kharch karun!"

![image.png](/public/images/blogs/5threadgareeb.jpg)

Haan, bilkul sahi kaha! Node.js ke version 10 ke pehle multi-threading ka support nahi tha, isliye log ise single-threaded hi maante the. 2019 ke baad `worker_threads` module ke aane se multi-threading possible ho gayi. Matlab, ab developer bhi khud se multiple threads create kar sakte hain aur unhe efficiently manage kar sakte hain. Pehle sirf asynchronous model tha, lekin ab hum real multi-threading ka faayda utha sakte hain.

Dekha na, ab aap multiple threads easily create kar pa rahe ho aur system ka full utilization bhi kar sakte ho!



Haan, bilkul! Ab ek kaam karo, jo loop abhi humne create kiya tha, usse ek alag file me paste karke run karo. Phir dekho CPU usage kaise badhta hai aur single-thread ke comparison me multi-thread ke andar CPU ka usage zyada hota hai, lekin time kam lagta hai.

### **Kya Process Bina Thread Ke Exist Kar Sakta Hai?**

Jab koi process execute hota hai, to kya wo bina kisi thread ke chal sakta hai? Aisa bilkul nahi hota. Jab koi process start hota hai, to uska ek thread zaroor hota hai, jo "main thread" kehlata hai. Ye main thread hi hota hai jo baaki worker threads ko start karta hai. Mtlb, ek Node.js process me hamesha ek thread hoti hi hai, aur wo main thread hota hai. Agar aap Task Manager me dekhenge, to har process ke sath kam se kam ek thread zaroor hoti hai.

Ye hi hai multi-threading ka faayda, thread banaiye aur efficiently kaam complete kariye.
 
![image.png](/public/images/blogs/6trhead.jpg)

Aur dekho bhai, mera CPU to ab ghoom gaya hai, raat ke 3 baj rahe hain aur ab sone ka mann bhi kar raha hai 😅.

To chalo, milte hain next blog me, tab tak ke liye Dhanyawaad! Keep experimenting and exploring!


Duniya Threads ki !

e22: Thread, Concurrency, and Parallelism

Ye ek tareeke ke key-value pair hote hain, aur dono strings hote hain. Achha, aapke Windows OS me bhi environment variables hote hain. MacOS aur Linux pe bhi aap inhe dekh sakte hain. Agar aap Windows me "environment" search karenge, to aapko global environment variables dikh jayenge.

![image.png](/public/images/blogs/2env.jpg)

User variables aur System variables ke do tareeke ke sections aap dekh sakte ho. Aur aap naye variables bhi add kar sakte ho "New" pe click karke, jisme aap paths wagairah bhi dal sakte hain. System variables me aapko PATH wagairah bhi dikh jayega. Lekin system variables ko edit karna recommend nahi kiya jata.

Abhi humne dekha ek user variable aur ek system variable show ho raha hai, jo basically operating system aur user se related hote hain. Achha, ek teesre tareeke ka variable bhi hota hai.

### Process Specific Variables

Jab bhi ek process start hoti hai, jaise Node.js process, to hume us process ke variables ka bhi access milta hai. Ek warning hai aapke liye—ye blog jo aap padh rahe ho, wo pichhle blog se related hai, to kaafi cheeje humne pehle se install aur configure kar rakhi hain. To ye highly recommended hai ki aap pehle pichhle blogs ko achhe se padhein. Yaha hum pichhle wale A, B, aur C thread wale example par debugger laga ke run karenge.

Aap JavaScript debugger ke auto-attach ko on kar lijiye. Agar samajh nahi aa raha ho, to pichhle blog ko follow kariye [ye rahi link](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e22-thread-concurrency-and-parallelism). Humne debugger laga ke start kar diya hai thread wali file, jisme humne teen threads bana rakhe the, aur debugger unhi threads me doosre thread par ruk gaya hai.

Ab jab aap "Process Informer" app kholenge (jo humne pichhle session me download kiya tha) aur Node.js process pe click karoge, to environment section me PS1 dikhai dega.

![image.png](/public/images/blogs/3env.jpg)

Actually, is dialog box me aapko teen accordion dikhenge: Process, System, aur User. Jo ye Process section hai, yahi process-specific variables ka hota hai. Achha, hum yeh bhi samajhte hain ki jab ek process child process ko start karti hai, to child process apne parent process ke saare variables ko access kar sakti hai, yaani wo variables inherit ho jaate hain. Aap "inspect" ya debugger use karke bhi in variables ko dekh sakte ho aur process ki details ko check kar sakte ho.

```jsx
🚀> node --inspect fileName
```

Achha, ye baat dhyaan rakhni hai ki kisi bhi JavaScript file me ek normal variable ko env variable nahi bolte hain. Env (environment) variable ek special variable hota hai jo aapke system ya application ke environment se related hota hai.

Ab agar aapko ek naya env variable banana ho, to uska ek alag tareeka hota hai, jo hum ab dekhte hain. Env variables uske andar key-value pairs likhe jaate hain. Fir usse aap apne application me access kar sakte ho `process.env` ke through.

### Create new Env Variable

```jsx
//in terminal
export website=heyashu.in
```

![image.png](/public/images/blogs/4env.jpg)

Achha, jo humne create kiya wo sirf us bash shell ke liye tha, yani wo variable permanent nahi hai.

Ab kaise ek aisa variable banayein jo environment variable bhi ho aur permanent bhi rahe? Iske liye hum `.bashrc` ka use karenge. Aapko bas us file me jaake wahi code likhna hoga.

```jsx
//in .bashrc
export website=heyashu.in  
// this will be created in all sub sets of bash new terminal
```

Ab baari aati hai ki access kaise karte hain? Matlab humne environment variables to bana liye, par use kaise karein?

### Access env variables in code

To ab tak humne yeh samajh liya ki user, system, aur process env variables hote hain. Ab hume process env variables ko access karna hai. Process ke andar ek object hota hai jiska naam hai `env`. Aap apne code me isko aise access kar sakte hain:

```jsx
// in terminal
console.log(process.env)
```

![image.png](/public/images/blogs/5env.jpg)

Ab dekha apne, jo new variable humne `website_name` ke naam se `.bashrc` me banaya tha, wo `process.env` me bhi visible hai aur hum usse code me bhi access aur use kar pa rahe hain. Accha, ek cheez aur, `PATH` naam ka bhi ek variable hota hai jo kabhi override nahi hota, balki concatenate hota hai. Iske baare me hum detail me baad me jaanenge. Abhi ke liye, `process.env` ki mystery resolve ho chuki hai!

- - -

### How to Print Env Variables in Terminal

Bas aap terminal me jaake `env` likh dijiye, aur aapko saare environment variables list ho jayenge!

4o

```jsx
🕑 15:00  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 env
ProgramFiles(x86)=C:\Program Files (x86)
CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files
SHELL=/usr/bin/bash
NUMBER_OF_PROCESSORS=8
FPS_BROWSER_USER_PROFILE_STRING=Default
COLORTERM=truecolor
PROCESSOR_LEVEL=6
TERM_PROGRAM_VERSION=1.92.2
MINGW_PREFIX=/mingw64
VSCODE_INSPECTOR_OPTIONS=:::{"inspectorIpc":"\\\\.\\pipe\\node-cdp.16944-a308e7a1-12.sock","deferredMode":false,"waitForDePKG_CONFIG_PATH=/mingw64/lib/pkgconfig:/mingw64/share/pkgconfig
USERDOMAIN_ROAMINGPROFILE=DESKTOP-NCVPMH3
HOSTNAME=DESKTOP-NCVPMH3
PROGRAMFILES=C:\Program Files
NODE_OPTIONS= --require "c:/Users/Ashutosh Tiwari/.vscode/extensions/ms-vscode.js-debug-nightly-2024.9.1817/src/bootloader.js"  --inspect-publish-uid=http
MSYSTEM=MINGW64
ChocolateyInstall=C:\ProgramData\chocolatey
PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY;.PYW
ORIGINAL_TEMP=/tmp
MINGW_CHOST=x86_64-w64-mingw32
OS=Windows_NT
HOMEDRIVE=C:
MSYSTEM_CARCH=x86_64
USERDOMAIN=DESKTOP-NCVPMH3
PWD=/c/Users/Ashutosh Tiwari/Desktop/ME/node-js-by-procodrr
USERPROFILE=C:\Users\Ashutosh Tiwari
OneDriveConsumer=C:\Users\Ashutosh Tiwari\OneDrive
MANPATH=/mingw64/local/man:/mingw64/share/man:/usr/local/man:/usr/share/man:/usr/man:/share/man
VSCODE_GIT_ASKPASS_NODE=C:\Users\Ashutosh Tiwari\AppData\Local\Programs\Microsoft VS Code\Code.exe
MINGW_PACKAGE_PREFIX=mingw-w64-x86_64
ALLUSERSPROFILE=C:\ProgramData
ORIGINAL_PATH=/mingw64/bin:/usr/bin:/c/Users/Ashutosh Ti
CommonProgramW6432=C:\Program Files\Common Files
HOME=/c/Users/Ashutosh Tiwari
USERNAME=Ashutosh Tiwari
SSH_ASKPASS=/mingw64/bin/git-askpass.exe
LANG=en_US.UTF-8
PLINK_PROTOCOL=ssh
OneDrive=C:\Users\Ashutosh Tiwari\OneDrive
COMSPEC=C:\Windows\system32\cmd.exe
TMPDIR=/tmp
GIT_ASKPASS=c:\Users\Ashutosh Tiwari\AppData\Local\Programs\Microsoft V
APPDATA=C:\Users\Ashutosh Tiwari\AppData\Roaming
SYSTEMROOT=C:\Windows
LOCALAPPDATA=C:\Users\Ashutosh Tiwari\AppData\Local
COMPUTERNAME=DESKTOP-NCVPMH3
INFOPATH=/mingw64/local/info:/mingw64/share/info:/usr/local/info:/usr/share/info:/usr/info:/share/info
VSCODE_GIT_ASKPASS_EXTRA_ARGS=
TERM=xterm-256color
LOGONSERVER=\\DESKTOP-NCVPMH3
ZES_ENABLE_SYSMAN=1
ACLOCAL_PATH=/mingw64/share/aclocal:/usr/share/aclocal
PSModulePath=C:\Program Files\WindowsPowerShell\Modules;C:\Windows\system32\WindowsPowerShell\v1.0\Modules
VSCODE_GIT_IPC_HANDLE=\\.\pipe\vscode-git-ada4b81b52-sock
TEMP=/tmp
MSYSTEM_CHOST=x86_64-w64-mingw32
DISPLAY=needs-to-be-defined
ORIGINAL_TMP=/tmp
SHLVL=1
PROCESSOR_REVISION=8e0a
DriverData=C:\Windows\System32\Drivers\DriverData
COMMONPROGRAMFILES=C:\Program Files\Common Files
EXEPATH=C:\Program Files\Git\bin
PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 142 Stepping 10, GenuineIntel
SESSIONNAME=Console
PS1=\[\]🕑 \[\033[01;36m\]\A \[\033[0m\] \[\033[1;32m\]heyashu \[\033[1;33m\]\w\[\033[36m\]`__git_ps1`\[\033[0m\]\n🚀 \[\033[1m\]\[\]
PKG_CONFIG_SYSTEM_LIBRARY_PATH=/mingw64/lib
VSCODE_GIT_ASKPASS_MAIN=c:\Users\Ashutosh Tiwari\AppData\Local\Programs\Microsoft VS Code\resources\app\extensions\git\dist\askpass-main.js
CHROME_CRASHPAD_PIPE_NAME=\\.\pipe\crashpad_7888_UATMJLDLBBTYUQND
HOMEPATH=\Users\Ashutosh Tiwari
TMP=/tmp
CONFIG_SITE=/etc/config.site
PATH=/c/Users/Ashutosh Tiwari/bin:/mingw64/bin:/usr/local/bin:
FPS_BROWSER_APP_PROFILE_STRING=Internet Explorer
PROCESSOR_ARCHITECTURE=AMD64
PUBLIC=C:\Users\Public
PKG_CONFIG_SYSTEM_INCLUDE_PATH=/mingw64/include
MSYS=disable_pcon
SYSTEMDRIVE=C:
TERM_PROGRAM=vscode
ProgramData=C:\ProgramData
website=heyashu.in
_=/usr/bin/env
```

In sabme **PATH** variable bahut hi important hota hai. Aap online jaake iske baare mein aur achhe se padh sakte ho. Har operating system ka **PATH** variable ka structure alag hota hai. Agar aap **bash** ya **Unix** system use karte ho to ye **colon (:)** se concatenate karta hai. Aap terminal me `printenv` ya `env` likh ke bhi variables print kar sakte ho.

```jsx
// in terminal
printenv
```

Baki terminal me variables kaise create karte hain, ye bhi hum pahle padh chuke hain. Aap simply terminal me `export` command ka use kar ke variable create kar sakte ho. Jaise:

```jsx
//in terminal ya .bashrc
export website=heyashu.in
```

Ye variable tab tak available rahega jab tak aapka current terminal session open hai. Session close karte hi ye variable remove ho jayega. Permanent variable banane ke liye `.bashrc` ya `.bash_profile` file me add karna hota hai, jaisa humne pehle discuss kiya tha.

ekin agar aap chahte ho ki ek env variable ko system ke operating system ke process me add karna hai, to uske liye?

### setx command (Create env using bash)

Hum `setx` command ka use karke key-value pair ke form me environment variables ko system pe globally set kar sakte hain.

```jsx
🕑 15:04  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 setx hey hi

SUCCESS: Specified value was saved.
```

![image.png](/public/images/blogs/6env.jpg)

Agar aako us evaribale ko empty krna hai to just empty string  pass kr dijiye

```jsx
// in terminal
🚀 setx hey ""   // deletes variable  temp

SUCCESS: Specified value was saved.

// Permanant Delete
REG delete HKCU\Environment /F /v KeyName 
//( search online ) , but ye command kewal pewershell me hi run hoti hai
// to chahe aap direct power shell me REG command likh do
// ya shell se powershell -Command "REG delete HKCU\Environment /F /v KeyName " run kr do
```

Humne yaha ye bhi jana, bash me PowerShell bhi use kar sakte hain.

Ab aao dekhte hain Node.js se variables kaise create karein aur delete karein.

### Create env variable using node js

```jsx
const {exec}= require('child_process')

exec(`setx aa bb`)
```

### The new way to debug Node.js code (In Chrome Dev Tools)

Debug lagaiye apne code me, chahe thread wale example me ya phir ek file me `setInterval` laga ke. `—inspect` flag ke saath run kar lijiye aur aap Chrome Dev Tools me apne Node.js code ko debug kar paayenge.

```jsx
const envs=process.env
setInterval(() => {
  console.log(envs);
}, 2000);
```

```jsx
🚀> node --inspect fileName
```

Aur ab Chrome open karo Inspect mode me, waha aapko Node.js ka green icon dikhega. Us par click karte hi ek naya Dev Tools window open ho jayega, aur ab aap yaha pe apne code ko easily debug kar sakte hain

![image.png](/public/images/blogs/7emv.jpg)

agr aap chahte ho isss process me kisi env ko exclude krna to aap command ruin kr skate ho

Agar aap chahte ho iss process me kisi specific env variable ko exclude karna, to aap command run kar sakte ho aur uss variable ko process se temporarily hata sakte ho.

```jsx
env -u PS1 -u node --inspect fileName
```

e itna janana zaroori hai ki child process apne parent process ke env variables ko inherit karta hai. Lekin agar child process koi parent env variable ko inherit karega, to parent process ka variable change nahi hoga. Aap kuch extra commands run karke ise check kar sakte ho. Baki aap explore kar sakte ho, abhi ke liye itna hi jan lo ki aisa hota hai. Mujhe pata hai ki aap thoda confuse ho sakte ho.

### .env files

Aap chaho to `.env` ya `.meraenv` file bana sakte ho, dono ka kaam same hota hai. Ya phir bina kisi extension ke ek `meraenv` file bana lo, jise hum read karenge aur process ke env me store karenge.

Pehle aap ek file banayein `meraenv` aur usme kuch likh dein.

```jsx
xyz lololo
```

Aur ab agar ye code likh ke usko read karke, split karke `process.env` me attach kar doge,

```
const fs= require("fs");  

const fileData=fs.readFileSync('./meraenv')
let parsedFile= fileData.toString()
const splittedVar= parsedFile.split(' ')
console.log("splittedVar", splittedVar);
process.env[splittedVar[0]]= splittedVar[1]

setInterval(() => {
  console.log(process.env);
  console.log("Check");
}, 1000);

//output ( Process env ka console hai)
  website: 'heyashu.in',
  WINDIR: 'C:\\Windows',
  API_URL: 'my api url'
  xyz: 'lololo',
```

Aapko ye samajhna hai ki `.env` ek standard hai jisme aap environment variables ko store karte ho aur kebab-case me likhte ho. Iska syntax simple hota hai aur Node.js jaise environments isse read karke variables ko `process.env` me attach kar lete hain.

Ab `.env` koi special file nahi hoti, bas Node.js isko piche se read karta hai aur process ke env me variables ko attach karta hai. Ye ek widely accepted standard hai, aur aapke kaam ko simplify karne ke liye ek npm package bhi hai jiska naam hai `dotenv`, jo yehi kaam automatically karta hai.

**Package link**: [dotenv npm package](https://www.npmjs.com/package/dotenv)

**GitHub link**: [dotenv GitHub](https://github.com/motdotla/dotenv)

**Source code line**: [Code block](https://github.com/motdotla/dotenv/blob/master/lib/main.js#L327) jo same kaam karta hai jaisa humne manually kiya tha.

**Homework**:

1. CRLF aur LF ka kya farak hota hai VS Code me?
2. `\r\n` kya hota hai aur iska kya use hai?


What are Environment Variables?

e25: What are Environment Variables?

The permission system on Linux is totally different from Windows, and whenever we deploy our project on a server, the terminal we get is usually a Linux system. So, it's important to learn the Linux path and file system as well. What are you waiting for? Let's start!

Click the Windows key and search for "WSL." If it shows up, great! Otherwise, just install it and get ready to explore.

```jsx
// in powershell
wsl --install
```

After opening and installing, if you search and click on WSL, you'll get this terminal where you can start exploring the Linux environment.

```jsx
 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

This message is shown once a day. To disable it please create the
/home/heyashu/.hushlogin file.
heyashu@DESKTOP-NCVPMH3:~$  
```

So, just like this, all cloud providers offer you a similar terminal. If you're installing it for the first time, you might need to restart and set up in the terminal, meaning you'll need to answer a few setup questions. That's it!

Now, if you check your VS Code terminal, you'll notice that WSL has been added as a new terminal environment option.

![image.png](/public/images/blogs/2wsl.jpg)

he full form of WSL is **Windows Subsystem for Linux**, and with this, we've basically installed a new OS (Linux) inside our Windows system. If you already have Linux, then you're good to go—nothing to worry about, you're already rocking!

To navigate in the terminal, use `cd /` to move to the previous directory.

Go to `\\wsl.localhost\Ubuntu` to check all Ubuntu files.

And for accessing the `.bashrc` file, navigate to `\\wsl.localhost\Ubuntu\home\heyashu`.

So, did you get it? Windows has a different `.bashrc` and Ubuntu has its own `.bashrc`, right?

Now, you can create any file or folder inside this directory, open it with VS Code, and run whatever you need.

We also recommend downloading this extension as well!

https://code.visualstudio.com/docs/remote/wsl-tutorial

and then you can wirte sudo commands  also

```jsx
sudo ls
```

The full form of **sudo** is **Super User Do**. So, what you've done is downloaded WSL, which installed Ubuntu. Now, any folder you're opening in VS Code is actually opening in Ubuntu. This makes it super easy for you to learn Linux file paths and use all the Ubuntu commands, including **sudo** for superuser privileges. You're all set to explore Linux commands and manage your system like a pro!


Okay, before discussing anything, let's first understand what comes to your mind when I say "file" or "folder."

A file is like a box or container of data such as audio, video, or text. A collection of files can be put inside one more container, which is called a folder or directory. That's easy, right? But here's one more thing called:

### Symbolic Links

These can't be seen in file explorers, but if you open your bash terminal, you will. When you go to the root directory using `cd ~/`, you will see all symbolic links.

```jsx
🕑 14:31  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 cd ~/
🕑 14:31  heyashu ~
🚀 ls
'3D Objects'/            'My Documents'@                                                                                 ntuser.ini   
 AppData/                 NetHood@                                                                                       OneDrive/    
'Application Data'@       npm-cache/                                                                                     Pictures/    
 Contacts/                NTUSER.DAT                                                                                     PrintHood@   
 Cookies@                 ntuser.dat.LOG1                                                                                Recent@      
 Desktop/                 ntuser.dat.LOG2                                                                               'Saved Games'/
 Documents/               NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.0.regtrans-ms                             Searches/    
 Downloads/               NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.1.regtrans-ms                             SendTo@      
 Favorites/               NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.2.regtrans-ms                            'Start Menu'@ 
 IntelGraphicsProfiles/   NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.blf                                       Templates@   
 Links/                   NTUSER.DAT{53b39e88-18c4-11ea-a811-000d3aa4692b}.TM.blf                                        Videos/      
'Local Settings'@         NTUSER.DAT{53b39e88-18c4-11ea-a811-000d3aa4692b}.TMContainer00000000000000000001.regtrans-ms
 Music/                   NTUSER.DAT{53b39e88-18c4-11ea-a811-000d3aa4692b}.TMContainer00000000000000000002.regtrans-ms
```

And when you run `ls -l`, here are a few things to know:

* `d` stands for directory
* `l` means symbolic links
* `` indicates regular files

```jsx
🚀 ls -l
total 9125
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:41 '3D Objects'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:40  AppData/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      40 May  8 20:40 'Application Data' -> '/c/Users/Ashutosh Tiwari/AppData/Roaming'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:41  Contacts/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      68 May  8 20:40  Cookies -> '/c/Users/Ashutosh Tiwari/AppData/Local/Microsoft/Windows/INetCookies'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Sep 26 20:03  Desktop/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Jun  7 14:02  Documents/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Sep 26 20:03  Downloads/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:41  Favorites/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Sep 27 00:16  IntelGraphicsProfiles/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:41  Links/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      38 May  8 20:40 'Local Settings' -> '/c/Users/Ashutosh Tiwari/AppData/Local'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:41  Music/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      34 May  8 20:40 'My Documents' -> '/c/Users/Ashutosh Tiwari/Documents'/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      76 May  8 20:40  NetHood -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/Network Shortcuts'/   
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May 15 14:44  npm-cache/
-rw-r--r-- 1 Ashutosh Tiwari 197121 3145728 Sep 14 05:09  NTUSER.DAT
-rw-r--r-- 1 Ashutosh Tiwari 197121  991232 May  8 20:40  ntuser.dat.LOG1
-rw-r--r-- 1 Ashutosh Tiwari 197121  786432 May  8 20:40  ntuser.dat.LOG2
-rw-r--r-- 1 Ashutosh Tiwari 197121 1048576 Sep 27 14:31  NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.0.regtrans-ms
-rw-r--r-- 1 Ashutosh Tiwari 197121 1048576 Sep 21 12:19  NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.1.regtrans-ms
-rw-r--r-- 1 Ashutosh Tiwari 197121 1048576 Sep 21 12:19  NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.2.regtrans-ms
-rw-r--r-- 1 Ashutosh Tiwari 197121   65536 Sep 27 14:31  NTUSER.DAT{53b39e87-18c4-11ea-a811-000d3aa4692b}.TxR.blf
-rw-r--r-- 1 Ashutosh Tiwari 197121   65536 May  8 20:40  NTUSER.DAT{53b39e88-18c4-11ea-a811-000d3aa4692b}.TM.blf
-rw-r--r-- 1 Ashutosh Tiwari 197121  524288 May  8 20:40  NTUSER.DAT{53b39e88-18c4-11ea-a811-000d3aa4692b}.TMContainer00000000000000000001.regtrans-ms 
-rw-r--r-- 1 Ashutosh Tiwari 197121  524288 May  8 20:40  NTUSER.DAT{53b39e88-18c4-11ea-a811-000d3aa4692b}.TMContainer00000000000000000002.regtrans-ms 
-rw-r--r-- 1 Ashutosh Tiwari 197121      20 May  8 20:40  ntuser.ini
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Aug 12 20:14  OneDrive/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Sep 19 22:52  Pictures/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      76 May  8 20:40  PrintHood -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/Printer Shortcuts'/ 
lrwxrwxrwx 1 Ashutosh Tiwari 197121      65 May  8 20:40  Recent -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/Recent'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:41 'Saved Games'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 May  8 20:42  Searches/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      65 May  8 20:40  SendTo -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/SendTo'/
lrwxrwxrwx 1 Ashutosh Tiwari 197121      69 May  8 20:40 'Start Menu' -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/Start Menu'/      
lrwxrwxrwx 1 Ashutosh Tiwari 197121      68 May  8 20:40  Templates -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/Templates'/
drwxr-xr-x 1 Ashutosh Tiwari 197121       0 Sep 26 20:03  Videos/
🕑 14:32  heyashu ~
```

A symbolic link points to a file or a folder (directory).

Below, if you see `l`, it indicates that it's pointing to the `Templates` directory.

```jsx
lrwxrwxrwx 1 Ashutosh Tiwari 197121      68 May  8 20:40  Templates -> '/c/Users/Ashutosh Tiwari/AppData/Roaming/Microsoft/Windows/Templates'/
```

We don't work too much with symbolic links, but if you want to explore more, do some research. Let's move to the path system.

### Path System (Windows)

A path refers to the location or route of a directory or file. There are two types of paths. You can go to your VS Code, right-click on any file in the left-side file explorer, and you will get two options: copy relative path and copy absolute path.

1. Relative Path
2. Absolute Path

An absolute path means it will start from the root directory.

```jsx
C:\Users\Ashutosh Tiwari\Desktop\ME\node-js-by-procodrr\path.js
```

Relative path ( soemtime stats with ./ )

```jsx
path.js
```

and in windows it starts with \ and i unix it starts with /

```jsx
\ back slash
/ forward slash
```

And in widnows what is the propblem lets try to understand

```jsx
const mtPath= 'src\text.js'
console.log("mtPath",mtPath);
// so here if you will try to console in terminal
mtPath src      ext.js
```

Actually, above you will see `\t` is pointing to the tab, which is why `\` can be dangerous.

`\n` will point to new lines, and the backslash (`\`) is a special character in multiple programming languages. That's why in Windows, we use double backslashes `\\` in paths.

```jsx
const mtPath= 'src\\text.js'
console.log("mtPath",mtPath);
// so here if you will try to console in terminal
//src\text.js
```

But in Unix, it's different.

### Path in Unix System

In bash, if you observe, everywhere it uses and gives `/` (forward slash) because bash simulates the UNIX system and handles everything behind the scenes.

```jsx
🕑 14:51  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 pwd
/c/Users/Ashutosh Tiwari/Desktop/ME/node-js-by-procodrr
// see u r in windows but u are getting / forward slash
```

And read about the `cygpath` command, what it does, and how in the future you can interchange paths. But don’t worry, we will handle everything.

Now, let's dive into WSL. Type `\\WSL$` in the explorer path to open Ubuntu. If you're not getting it, we've already downloaded WSL in Windows. Check the last blog [here's the link](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e27-installing-linux-wsl-in-windows).

Now, if you create any file and copy the path, it will show the Unix path only, meaning forward slashes will appear in both relative and absolute paths.

I faced so many errors while installing Node.js in WSL and creating files, but once you search and follow the steps properly, you’ll be able to handle everything!

```jsx
root@DESKTOP-NCVPMH3:/learning# node app
dsdfs
root@DESKTOP-NCVPMH3:/learning# 
```

In WSL, after typing `\\WSL$`, I created a folder named "learning" and then an `app.js` file. And look, it's printing *"dsdfs"* – yoooo! 🎉

We got Linux, and now the folder and files are running using Node.js perfectly! The path is showing with forward slashes as expected.

I right-clicked on `app.js` and copied the absolute path – see, forward slashes everywhere!

```jsx
\\wsl.localhost\Ubuntu\learning\app.js
```

### Lets learn something more

```jsx
cd . // current folder
cd ..   // parent folder 
cd ../  // parent folder
~/      // moves to home folder
cd ~    // home folder
cat ~/fileName   // read fileName content
cd /   // root directory
```


Understanding the Path System: Windows vs. Linux Explained

E28: Understanding the Path System: Windows vs. Linux Explained

Let's understand more about what executable files are and how you can create them. What is the purpose of these executable files?

There are two types of executable files:

Script Executable File
Binary Executable File
You can create any file and write anything in it, but it will only be treated as an executable file if it's properly formatted for execution.

For example, in VS Code, if you create a file called hello.txt and write "hello" inside, it won't automatically run as an executable. However, in the terminal, if you type ./hello.txt, the system will try to execute it, assuming you’ve given the necessary permissions.

The term ".exe" refers specifically to Windows executable files, but other systems like Linux or macOS have different formats for executable files.

```jsx
🕑 12:08  heyashu //wsl.localhost/Ubuntu/learning
🚀  ./hello.txt
./hello.txt: line 1: hello: command not found
🕑 12:29  heyashu //wsl.localhost/Ubuntu/learning
🚀 
```

Now, if you write the ls command in the hello.txt file, which is a valid command, and then execute the file using ./hello.txt, it will list all the files in that directory (assuming you have made the file executable and are using a Unix-based system like Linux or macOS).

```jsx
🕑 12:29  heyashu //wsl.localhost/Ubuntu/learning
🚀  ./hello.txt
app.js  hello.txt
🕑 12:30  heyashu //wsl.localhost/Ubuntu/learning
🚀 
```

So, this hello.txt is treated as an executable file, specifically a script executable file.

Note that in Windows, whatever file you create can potentially be treated as an executable file, regardless of its extension or even if it has no extension. Remember, a script file does not necessarily need to have a .js extension; it can be anything.

However, a confusion arises—since all files can potentially be treated as executable files in Windows, to avoid this, we use the .sh extension for better visibility. Files with this extension are referred to as bash script files.

There are two common types of script files:

.sh files are used for Linux-based systems.
.bat files are used for Windows systems.
Everything we've discussed so far applies mainly to Windows. However, if you try the same thing in Linux, or in Windows using the Windows Subsystem for Linux (WSL), you may encounter an error like "Permission denied". This is because Linux systems require explicit permissions to execute files.
  [How to install WSL](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e27-installing-linux-wsl-in-windows) 

```jsx
root@DESKTOP-NCVPMH3:/learning# ./hello.txt
-bash: ./hello.txt: Permission denied
root@DESKTOP-NCVPMH3:/learning#      
```

To grant the Permission 

```jsx
chmod +x hello.txt
```

After this

```jsx
root@DESKTOP-NCVPMH3:/learning# ./hello.txt
abc.sh  app.js  hello.txt
```

### Binary Executable File

You have seen `.exe` file extensions. Now, if you try to open any `.exe` file in VS Code, you can't open it unless you either download an extension or open it in a text editor. Basically, just know that `.exe` files do not have text written inside. Instead, these are binary files.

You can copy-paste the absolute path and run it, just like you would run `hello.txt`.

So, we are just telling you both file types can be run here.

### What is Binary?

A binary file is a file that is written in 0s and 1s (machine code), so it is not readable like a text file.
[What is binary](https://www.techtarget.com/whatis/definition/binary)

### Can We Create `.exe` Files / Binary Files?

Yes, we can create binary files and app-like things using Node.js. Here is one example:

Create a `package.json` file and paste this code. We are going to see a timer example, and in the end, you will get a `timer.exe`.

```json
{
  "name": "timer",
  "bin": "app.js",
  "scripts": {
    "build": "pkg -t node16-win-x64 ."
  },
  "devDependencies": {
    "pkg": "^5.8.1"
  }
}
```

and create an app.js and paste this

```
let time = 1;
console.log('Hello, I am ProCodrr.');
setInterval(() => {
  console.log(time++);
}, 1000);
```

and then do 

```jsx
npm i
```

and then 

```jsx
npm run build
```

and then timer.exe will be created for you

![image.png](/public/images/blogs/2_29_prooo.jpg)

Now, if you click `timer.exe`, which is a binary executable file, double-clicking it will start the timer as written in the app (`timer.js`). Just open your `timer.exe` after revealing it in File Explorer.

```jsx
Hello, I am ProCodrr.
1
2
3
4
5
6
```

For creating this, `pkg` is a dependency that is used.

You can check the `pkg` command and learn many things from it.

Now, is there any `.exe` file that exists in WSL or Linux systems? Yes, but not with the `.exe` extension. `.exe` only exists in Windows operating systems. In WSL or Linux, you can check the `/bin` folder and run the listed executable files inside `bin`.


What are Executable Files ?

e29: What are Executable Files



Server ek tarike ka computer hi hota hai. Maine iske baare mein pehle hi kaafi likh rakha hai, aap [yaha click karke](https://heyashu.in/digital-garden/notes/namaste-node-js/e2-js-on-server) padh sakte hain. Uske baad yaha aake continue kar sakte hain.

Ek front-end application ko run karne ke liye ek server hona zaroori hota hai. Jab hum VS Code mein live server use karke run karte hain, to wo Node.js ka code use karke hi run hota hai. Ye live server ka GitHub repo hai, waha jaake aap isko padh sakte hain, ye Node.js ka hi code likha gaya hai.


[https://procodrr.com/nodejs/section-1_introduction/1_prerequisites](https://procodrr.com/nodejs/section-1_introduction/1_prerequisites)

What is backend & client server

e3 what-is-back-end-client-server

Now we are going to see the permissions of different files in OS.

### In Windows

Just click on any file, actually right-click and view it in File Explorer, and then right-click on the file and go to properties.

![image.png](/public/images/blogs/2pro_30.jpg)

And then, once the **Properties** tab is opened, you select the **Security** tab, and you can see the permissions. Now, if you click the **Edit** icon and then select your name as the user, you can modify the permissions.

![image.png](/public/images/blogs/3_pro_30.jpg)

Now, if you deny write permissions, then you will not be able to write anything in `permission.js`, which I have created and accessed after revealing it in File Explorer. If you deny read permission, you will not be able to read, and when you deny write, you will not be able to write.

![image.png](/public/images/blogs/4_pro_30.jpg)

### A Gotcha

A file that has write access but not read access—how will you write without reading it? VS Code and any editor will not help you with this because only after reading will you be able to write. That’s why terminals are powerful. Now, using terminals, you will be able to write into it, using the commands we’ve already discussed earlier.

There are multiple types of permissions, but we will focus on three only:

1. Read
2. Write
3. Execute

In Windows, **Read** and **Execute** permissions are combined in the Windows OS, as you can see in the above screenshot, but that’s not the case in Linux systems.

In Windows, you can click **ALT + ENTER** to open the properties window if the file is opened in File Explorer. Note one thing: if you remove executable permission in Windows, after trying to run the file, you will see the same message in the terminal—**PERMISSION DENIED**.

Read more here: **[What are Executable Files](http://localhost:3000/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e29-what-are-executable-files)**.

### In Linux

```jsx
ls -l // use this to get list of all permission of a file in terminal
```

```jsx
🕑 22:20  heyashu ~/Desktop/ME/node-js-by-ashu/permission (master)
🚀 ls -l
total 0
-rw-r--r-- 1 Ashutosh Tiwari 197121 0 Oct 10 21:47 permission.js
```

- - -

The time you see in the last modified time.

`197121`: is denoting bytes of files.

[What is Byte](https://www.techtarget.com/searchstorage/definition/byte)

And remember, the directory/folder size remains the same, and that doesn’t depend on the files under that folder, technically speaking. Not like on top, but think technically. By default, a folder has 4096 (4KB assigned).

**Ashutosh Tiwari**: is the user of WSL. There is a concept of groups in an OS. You can check and read this online. One computer can have multiple users and multiple groups, and this happens in both Linux and Windows.

`1`: is about a hard link. Read online about what hard links are.

### `rw-r--r--`

So, there are a total of 10 characters.

* If starting with a dash (``), it means it's a file.
* If starting with `d`, it’s a directory or folder.
* If starting with `L`, then it’s a symbolic link.

Then there are 3 groups of 3 characters each:

* `r` means read,
* `w` means write, and
* `x` means executable.

`rw-` means it has read and write permissions.

`r--` means only read.

`r--` means only read.

### Why 3 Groups?

* The first three characters: the owner has those permissions.
* The second group: if the owner is in a group, then what that group can do.
* The third group: other users who are not part of any group.

### How to Change Permissions

```jsx
chmod +x src/ 
```

`chmod` means change mode. `+` means giving permissions, and `-` means denying permissions. You got what `x`, `r`, and `w` mean earlier.

Note: `chmod +x src/` — if you change the permission like this, executable file permission will be given to all three types of users. The same goes for read permission. But if you give or remove `-w`, it will apply to the owner only, the first group.

NOTE**:** you can remove permission group wise or together to do this read online , I am writing this line to let you know that is possible.

**[I will suggest you to check more on chmod .](https://www.javatpoint.com/linux-chmod-command)**

### Number System in file permission result

Now we know there are three letters that denote file permissions: `r`, `w`, and `x`. But there are also numbers that denote file permissions. Those are:

* `1` for execute,
* `2` for write, and
* `4` for read.

```jsx
🕑 02:13  heyashu ~/Desktop/ME/node-js/permission (master)
🚀 stat -c "%A %a %n" permission.js                                          
-rw-r--r-- 644 permission.js
```

As you see, we have written a special command that is giving values, here `644`. So `6` is for the first group, `rw-`, which means `4+2+0 = 6`.

`4` is for the second group, `r--`, which means `4+0+0 = 4`. And the same goes for group 3, which denotes other types of users. and using these number you can give permissions

```jsx
chmod 700 fileName.txt
```

You can create alias of last command Read more about this  **[Promt in Terminal](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e16-promt-in-terminal)**

### Git Identifies the Permission

You know Git only tracks file changes, but if you do `git init` with some file and then add it and commit it, then try to change the permission of any file, Git will track that, and it will show as a change in the Git history. Then you need to add and commit again. So remember, **Git tracks file permissions also**.


 Managing File Permissions in OS

e30: Managing File Permissions in OS

If you write anything and press enter in the terminal, it will say **"command not found."**

```jsx
🕑 23:55  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 hello
bash: hello: command not found
🕑 00:27  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
```

There are some types of commands:

1. **Alias**: Bash first checks if the command matches any defined aliases.
2. **Functions**: Next, it checks if the command matches any defined shell functions.
3. **Built-in commands**: Like `cd`, `echo`, `pwd`, etc.
4. **Hash Table**:
5. **Executable**: Finally, it searches through the directories listed in the `PATH` environment variable, in the order they appear, to find an executable file matching the command name.

So, the question is: How do you know which type of command is being used when you type it?

For example, if you type `pwd`, how do you know what type of command it is?

You can use the `which` command before the actual command to determine its type.

```jsx
🕑 00:27  heyashu ~/Desktop/ME/node-js-by-procodrr (master)
🚀 which pwd
/usr/bin/pwd

🚀 cd /
🕑 00:29  heyashu /
🚀 explorer 
```

If you run `cd /` in Windows, it will take you to the path where Git is installed. When you run `explorer .`, it will open that directory, and you can see the `pwd.exe` file, which is an executable binary file.

### `type` Command

If `which` gives you any unusual result, try using the `type` command.

```jsx
🚀 type cd
cd is a shell builtin
🚀 type pwd
pwd is a shell builtin
```

### How to Create Function Commands

Let's open the `.bashrc` file and see how we can write functions.

To open `.bashrc`, just run:

```jsx
🚀 code ~/.bashrc
🕑 00:36  heyashu /
```

Nowi bahsdrc wirte tghuis

```jsx
cd(){
  echo "my function is running"
}
```

Now, `cd` is already a built-in command. So, how do you know which one will run? Yes, this will override the main `cd` command.

If you define a function named `cd` and type `cd`, it will execute your function and print an echo. Using this overridden `cd`, you will not be able to change directories.

```jsx
🚀 cd
my function is running
```

```jsx
🚀 type cd
cd is a function
```

### How poriority gets decides ?

It checks in the following order: **Aliases**, then **Functions**, and then continues to other types.

Now, guess what the type of `node` would be? `node` is also a command, right?

```jsx
🚀 type node
node is aliased to `winpty 
node.exe'
```

`winpty node.exe` is aliased somewhere. Remember, we saw this `winpty` in the Performer app?

[Check this article](https://heyashu.in/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e21-what-is-process-in-operation-system).

You can learn that `winpty` simulates a Unix-like environment in Windows.

After checking functions, it looks for built-in commands, then the hash table, and finally executable files.

Also, remember that the `which` command only gives you the path.

So, you have a global `PATH` variable in your system. Try to get this by using:

```jsx
heyashu ~/Desktop/ME/node-js-by-procodrr 
(master)
🚀 echo $PATH
/c/Users/Ashutosh Tiwari/bin:/mingw64/bin:/usr/local/bin:/usr/bin:/bin:/mingw64/bin:/usr/bin:/c/Users/Ashutosh Tiwari/bin:/c/Python312/Scripts:/c/Python312:/c/Windows/system32:/c/Windows:/c/Windows/System32/Wbem:/c/Windows/System32/WindowsPowerShell/v1.0:/c/Windows/System32/OpenSSH:/c/Program Files (x86)/MAVProxy:/c/Program Files (x86)/MAVProxy:/c/ProgramData/chocolatey/bin:/cmd:/c/Program Files/dotnet:/c/Program Files/nodejs:/c/Python312/Scripts:/c/Python312:/c/Windows/system32:/c/Windows:/c/Windows/System32/Wbem:/c/Windows/System32/WindowsPowerShell/v1.0:/c/Windows/System32/OpenSSH:/c/Program Files/Docker/Docker/resources/bin:/c/Program Files (x86)/MAVProxy:/c/Program Files (x86)/MAVProxy:/c/ProgramData/chocolatey/bin:/c/Program Files/nodejs:/cmd:/c/Program Files/dotnet:/c/Python312/Scripts:/c/Python312:/c/Windows/system32:/c/Windows:/c/Windows/System32/Wbem:/c/Windows/System32/WindowsPowerShell/v1.0:/c/Windows/System32/OpenSSH:/c/Program Files/Docker/Docker/resources/bin:/c/Program Files (x86)/MAVProxy:/c/Program Files (x86)/MAVProxy:/c/ProgramData/chocolatey/bin:/c/Program Files/nodejs:/cmd:/c/Program Files/dotnet:/c/Users/Ashutosh Tiwari/AppData/Local/Microsoft/WindowsApps:/c/Users/Ashutosh Tiwari/AppData/Local/Programs/Microsoft VS Code/bin:/c/Program Files/nodejs/npm:/c/Program Files/nodejs/npm:/c/Users/Ashutosh Tiwari/AppData/Local/Microsoft/WinGet/Packages/Schniz.fnm_Microsoft.Winget.Source_8wekyb3d8bbwe:/c/Users/Ashutosh Tiwari/AppData/Roaming/npm:/c/Users/Ashutosh Tiwari/AppData/Local/Programs/mongosh:/usr/bin/vendor_perl:/usr/bin/core_perl    
```

You're getting a long string, and to better understand it, let's transform it.

Hehe, you're about to learn a new command now! It basically transforms the output.

```jsx
🚀 echo $PATH | tr ":" " " /"
> 
> ^C
🕑 00:53  heyashu ~/Desktop/ME/node-js-by-procodrr 
(master)
🚀 echo $PATH | tr ":" "\n"                        
/c/Users/Ashutosh Tiwari/bin
/mingw64/bin
/usr/local/bin
/usr/bin
/bin
/mingw64/bin
/usr/bin
/c/Users/Ashutosh Tiwari/bin
/c/Python312/Scripts
/c/Python312
/c/Windows/system32
/c/Windows
/c/Windows/System32/Wbem
/c/Windows/System32/WindowsPowerShell/v1.0
/c/Windows/System32/OpenSSH
/c/Program Files (x86)/MAVProxy
/c/Program Files (x86)/MAVProxy
/c/ProgramData/chocolatey/bin
/cmd
/c/Program Files/dotnet
/c/Program Files/nodejs
/c/Python312/Scripts
/c/Python312
/c/Windows/system32
/c/Windows
/c/Windows/System32/Wbem
/c/Windows/System32/WindowsPowerShell/v1.0
/c/Windows/System32/OpenSSH
/c/Program Files/Docker/Docker/resources/bin       
/c/Program Files (x86)/MAVProxy
/c/Program Files (x86)/MAVProxy
/c/ProgramData/chocolatey/bin
/c/Program Files/nodejs
/cmd
/c/Program Files/dotnet
/c/Python312/Scripts
/c/Python312
/c/Windows/system32
/c/Windows
/c/Windows/System32/Wbem
/c/Windows/System32/WindowsPowerShell/v1.0
/c/Windows/System32/OpenSSH
/c/Program Files/Docker/Docker/resources/bin       
/c/Program Files (x86)/MAVProxy
/c/Program Files (x86)/MAVProxy
/c/ProgramData/chocolatey/bin
/c/Program Files/nodejs
/cmd
/c/Program Files/dotnet
/c/Users/Ashutosh Tiwari/AppData/Local/Microsoft/WindowsApps
/c/Users/Ashutosh Tiwari/AppData/Local/Programs/Microsoft VS Code/bin
/c/Program Files/nodejs/npm
/c/Program Files/nodejs/npm
/c/Users/Ashutosh Tiwari/AppData/Local/Microsoft/WinGet/Packages/Schniz.fnm_Microsoft.Winget.Source_8wekyb3d8bbwe
/c/Users/Ashutosh Tiwari/AppData/Roaming/npm       
/c/Users/Ashutosh Tiwari/AppData/Local/Programs/mongosh
/usr/bin/vendor_perl
/usr/bin/core_perl
```

So basically, these are the steps added to the `PATH` variables.

Now, the **hash** also plays a big role in how things are managed. Search online to learn more about these commands. The hash prepares a table to quickly search, find, and run commands—similar to a cache. It’s a very interesting topic, so try to explore it online.

Before checking for an executable file, **Bash** looks in its **hash table** for previously looked-up executables to quickly locate them.

I know it’s tough, and sometimes I’m not able to understand it fully. These are deep dives, and they will take time to comprehend.

I have just read and created these notes for the first time, but for better understanding, it needs proper revision and study.

### Process Objects

Now lets understand what are process objects

## Process.argv

```jsx
// write this in app.js
console.log(process.argv);
// do node app.js
//o/p
[
  'C:\\Program Files\\nodejs\\node.exe',      
  'C:\\Users\\Ashutosh Tiwari\\Desktop\\ME\\node-js-by-procodrr\\process\\app'
]
🕑 01:14  heyashu ~/Desktop/ME/node-js-by-procodrr/process (master)
```

```jsx
🚀 node app.js 123243 345345 353 5 35 3 5
[
  'C:\\Program Files\\nodejs\\node.exe',      
  'C:\\Users\\Ashutosh Tiwari\\Desktop\\ME\\node-js-by-procodrr\\process\\app.js',
  '123243',
  '345345',
  '353',
  '5',
  '35',
  '3',
  '5'
]
```

See magic its like arguments see above code

Now I will suggest you to try logging this and check what are these process objects

```jsx
// Accessing Process Properties

// Command-line arguments
process.argv;

// Environment variables
process.env;

// Current process ID
process.pid;

// Parent process ID
process.ppid;

// Operating system platform
process.platform;

// Node.js version
process.version;

// Node.js and dependencies versions
process.versions;

// Processor architecture
process.arch;

// Using Process Methods
// Current working directory
process.cwd();

// Change working directory
process.chdir("/tmp");

// Memory usage
process.memoryUsage();

// Process uptime
process.uptime();

// Exiting the process
// process.exit(0);

// Kill the process
process.kill(process.pid);

// Emit warning
process.emitWarning("This is a custom warning message!", {
  code: "MY_WARNING_CODE",
  detail: "This is some additional warning detail.",
});

// Interacting with stdin, stdout, and stderr streams
process.stdout.write("Hello, stdout!\n");
process.stderr.write("Hello, stderr!\n");

// Next Tick demonstration
process.nextTick(() => {
  // This will run on the next tick of the event loop.
});

// Registering event listeners
process.on("exit", (code) => {
  // Process is about to exit with code
});

process.on("warning", (warning) => {
  // Handle warning
});

process.stdin.on("data", (data) => {
  // Process input data
});
```

Dont thank me, Thanks to Anurag sir


How commands gets executed ? 

e32: How commands gets executed



CLI ka full form hota hai **Command Line Interface** aur GUI ka **Graphical User Interface**. Dono tarike ke apps hote hain. Kuchh aisi applications hoti hain jinka interface nahi hota, jaise **git**. Git ko run karne ke liye command yaani terminal application use hoti hai. Jaise aapne likha `git pull`, iska koi GUI (graphical interface) nahi hai, saari cheezein commands se hi hoti hain, hai ki nahi?

Jaise ek aur library hai jiska koi UI nahi hai, lekin command ke through aap saare YouTube ke videos download kar sakte ho, iska link yeh hai: [yt-dlp GitHub](https://github.com/yt-dlp/yt-dlp).

**For example:**

```jsx

//first Python install kar lo from using the official website.
//Aur phir yeh code use karo:
yt-dlp -f "bestvideo[height<=1080]+bestaudio/best[height<=1080]" --merge-output-format mp4 -o "%(playlist_title)s/%(playlist_index)s - %(title)s.%(ext)s"

```

Baaki kaise install hota hai, yeh sab aap jaake inke Discord pe dekh sakte ho. Abhi ke liye itna jaan lo ki aisa possible hai, aur baaki hum aage dekhenge. To bas, yeh ek example tha CLI ka aur commands se kaam karne ka. Windows mein start button dabake `cmd` likho to ek CLI open ho jaata hai. Linux mein terminal hota hai, toh yahi sab hota hai.

Hum bhi aisi applications Node.js ki madad se bana sakte hain, CLI bana sakte hain. Jaise Operating Systems hote hain, kuch terminal-based hote hain jaise **MS-DOS**, **UNIX**, jo ki command-based interfaces hain (CLI). Aur inhi ke upar **macOS** aur **Linux** bane hain jo graphical user interfaces (GUI) hain. Windows bhi ek GUI, yaani Graphical User Interface, hai.

Aage Node.js mein bhi hum CLI use karenge. Aur front-end mein bhi aapne git toh use kiya hoga, hai ki nahi?



CLI vs GUI

e4: cli gui 



Node.js ka use karke aap JavaScript ko browser ke bahar bhi run kar sakte hain. JS pehle sirf browser ke liye bani thi, lekin jab JS ko browser ke bahar run karte hain, toh yeh bahut powerful ho jaata hai.

NPM Node.js ka ek package manager hai, aur Vue ka CLI, Next.js ka CLI, aur Create React App sab Node.js ka use karke hi banaye gaye hain. Chalo, main aapko dikhata hoon:

[Create React App GitHub Repo](https://github.com/facebook/create-react-app)


![image.png](https://i.ibb.co/8g2JGSG/ssssss.png)

Jaake TypeScript aur saare CLI ka code GitHub pe dekho. Scroll karoge toh aapko dikh jayega ki jo JavaScript browser mein nahi chal rahi, wo Node.js mein chal rahi hogi. JavaScript sirf browser tak simit nahi hai.

Bas aap itna samajh lijiye ki yeh bahut interesting hai aur aane wale videos mein hum Node.js ke deeper concepts ko explore karenge. Toh tayaar rahiye, kyunki hum Node.js ke "**muh dikhayi**" karenge aur installation process bhi dekhenge. Milte hain agle blog mein!


What Is Node.js ?

e5-what-node-js 




Agar aapke system mein Node.js installed hai toh bhi is article ko skip mat kariye, kyunki yeh kaafi helpful ho sakta hai seekhne ke liye. Aapko bas apne VS Code editor mein ek `script.js` file banani hai aur usme yeh code likhna hai jo maine neeche diya hai.



```jsx
//script.js  (included in index.html) 
 
console.log("Sanjana Air lines");
let a=5;
let b=4;
console.log(a+b)
```


Aapko pata hoga ki hum `index.html` ya `live server` ka use karke `script.js` ko attach karte hain aur fir Chrome ya kisi aur browser ke DevTools mein check karte hain ki sab sahi se kaam kar raha hai ya nahi. Neeche diye gaye screenshot mein aap dekh sakte hain ki kaise hota hai. Toh sabse pehle aap apni `index.html` file mein `script.js` ko attach karke `live server` ke through `5500` port par run kar lijiye: `http://localhost:5500/index.html`. Isse aapko kuch aisa interface dikhega console me.


![image.png](https://i.ibb.co/Wxzs1nb/e7p2.png)


### Debugging in VS Code (Web App)


Lekin yaha pe "Chrome" ka koi role nahi hai, kyunki hum backend seekh rahe hain, yani browser ko ab side mein rakho. Samajhiye ki ab humne browser se V8 engine ko alag kar liya hai aur usko Node.js mein use kar rahe hain. Ab baat yeh hai ki hum kaise JavaScript ko Node.js ke andar run karenge, kyunki Node.js humein JavaScript ko browser ke bahar run karne ki power deta hai.


Ab aapko VS Code mein jaana hai aur ye teen steps follow karne hain:


1. **Run and Debug** option ko kholiye ya (Ctrl + Shift + D) press kariye.
2. "Run and Debug" wale full-width button pe click kariye.
3. Ab dropdown me se Web App chrome select kariye aur aapka app chrome pe chal rha hai


![image.png](https://i.ibb.co/JccYjLf/proe7e4.png)


Jab aap debugging setup karenge aur dropdown pe click karenge, to ek file automatic generate ho jaayegi `.vscode` folder ke andar, jisme ek `launch.json` file hogi. Is file mein aap apne project ke debugging configurations ko set kar sakte hain.


Aapko port ko 5500 set karna hai, ya fir aap niche ka code `launch.json` file mein paste kar sakte hain: Dhyan rakhiye, `program` key mein jo path hai, usse aap apni main file ka path set kar sakte hain, jaise `app.js` ya `server.js` depending on aapka project structure. agar vs code folder aur aapki js file ek level pe hai to koi jarurat nahi hai.


Yeh setup karne ke baad, aap "Run and Debug" kar sakte hain apne Node.js application ko.


```jsx
{
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "configurations": [
    {
      "type": "chrome",
      "request": "launch",
      "name": "Launch Chrome against localhost",
      "url": "http://localhost:5500",
      "webRoot": "${workspaceFolder}"
    }
  ]
}
```


Ab iske baad, aap jo 1, 2, 3, 4 lines dekh rahe hain, waha cursor le jaake debugger laga sakte ho. Debugger set karne ke baad, aap apne app ko launch kar sakte ho. Neeche diye gaye screenshot mein aap dekh sakte ho kaise ye process hota hai. Phir "Launch Program" select karke, 3 number ke highlighted area se debugging kar sakte ho.


Yeh controls bilkul Chrome DevTools jaise hi hain. Agar aapko inke baare mein zyada knowledge nahi hai, toh aap YouTube videos dekh sakte ho ya koi blog padh sakte ho.


![image.png](https://i.ibb.co/MfQ2zPq/proe7p4.png)


Debugger lagane ke baad, aapko kya karna hai:


1. Niche screenshot mein diye gaye dropdown se "Node.js" select kariye.
2. Phir green play button par click kariye.
3. Jab aap next-next steps follow karenge, to green button press karte hi ek nayi window open hogi (jo Chrome environment hoga), aur waha aapka app run hoga.
4. Is waqt aapka code debugger ke point par aa ke ruk jayega, jahan aap apna code step by step debug kar sakte hain.


Yeh process aapko real-time debugging ka experience dega, aur aap asani se apne code ke flow ko samajh paenge.


![image.png](https://i.ibb.co/QJc7N5d/proe7p5.png)


Aur jab aap apne code ke upar hover karenge, to aap variables ka current value dekh paenge. Is tarah, aap apne code ko step-by-step samajh sakte hain aur debugging process ka maza le sakte hain. Debugger lagate rahiye aur apne code ke har part ko explore kariye.


![image.png](https://i.ibb.co/vzzGYdr/proe7p6.png)


### Debugging in VS Code (NodeJS Code)


To ab tak humne dekha ki kaise VS Code ka live server chalake, JavaScript jo ki `index.html` mein thi, usse humne Chrome pe debug kiya aur VS Code mein bhi debugger laga ke debugging kar li. Lekin agar `index.html` file na ho toh pure Node.js ko kaise debug karoge?


Isse pehle, do kaam kariye:


1. `.vscode` folder ko delete kar dijiye.
2. `index.html` file bhi delete kar dijiye.


Ab jab aap play button press karenge toh error aayegi, kyunki ab humare paas frontend (HTML file) nahi hai. Ab aapko **Debugging in VS Code (Web App)** section ke upar jaake screen shots follow karne honge, aur aapko error dikhegi. to ab kaise run karein , to dono fiiles ko delete krne ke baad aap kuchh krna nahi bs, same last step run and debug point ko click karke **chrome** na select krke ab nodejs/ javascript select krna hai aur Play green button par click kr dena hai, dhyaan rahe aap debug kr  rhe hain to debug mark lagana na bhuliye. see screenshot for saare steps, Output aapko down side terminal ke **Debug console** me dikhega

![image.png](https://i.ibb.co/999XTVt/eproe7last.png)


Yeh steps follow karne ke baad aap samajh payenge ki pure Node.js application ko kaise debug kiya jaata hai bina kisi HTML file ke


### Node Js code in terminal


Ab jab VS Code open hai, toh ```Ctrl + \`` ya``` Ctrl + J` press kariye, isse terminal open ho jayega. Terminal kuchh aisa dikhega, jahan aap apne Node.js commands ya scripts run kar sakte hain.


Isse aap direct terminal se apne project ko manage kar paenge aur Node.js ko run karne ke liye commands execute kar sakte hain.


![image.png](https://i.ibb.co/0FkT16k/proe7p8.png)


Lekin iske pahle aapko nodejs download krna padega


### Install node js from the website


Yaha jaiyie https://nodejs.org/en/download/prebuilt-installer aur node js dwnload kr liye 


![image.png](https://i.ibb.co/ZBx739c/proe7p9.png)


ab jaise hi terminal pe aap liklhoge node kuchh aise diekhega


```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node
Welcome to Node.js v22.2.0.       
Type ".help" for more information.
>2*6
12
```


Aur ab ye REPL environment open ho gaya hai. **[REPL kya hota hai](https://www.digitalocean.com/community/tutorials/what-is-repl)**?

### REPL : Read-Eval-Print Loop
REPL ek aisa environment hota hai jahan aap kuch bhi JavaScript code run kar sakte ho bina kisi browser ke. REPL ka full form hota hai **Read-Eval-Print Loop**, jisme code ko read, execute, aur output display kiya jata hai. Ye environment Node.js ke saath aata hai, jahan aap real-time mein apna JavaScript code run aur test kar sakte ho.


Is REPL environment ko aap `Ctrl + D` press karke band kar sakte ho, jab aapko debugging ya testing complete ho jaye.


![image.png](https://i.ibb.co/9pt1wGp/proe7p10.png)


Aur ab agar aap kisi file ko run karna chahte hain jo aapne banayi thi, jaise `script.js`, toh bas terminal mein likhiye:


```jsx
PS C:\Users\Ashutosh Tiwari\Desktop\node-test> node script.js
Sanjana Air lines
9
```


To abhi tak humne live server ke saath, `index.html` ke sath, aur bina `index.html` ke bhi JavaScript ka code kaise run kiya, yeh sab samjha. Aapne Node.js aur VS Code debugging ko efficiently use karna seekha hai.


Agle session mein milte hain. Thank you




Node JS ki muh dikhaayi 👰

e6 installing node js 



"Chalo ek file `text.txt` banate hain apne VS Code mein aur waha kuch likhte hain, jaise ki 'hello.'

Uske baad `script.js`, jo ki `text.txt` ke bagal mein hi hai, usse run karna hai. Aapko [pichhle session mein dekh sakte ho kaise run karein](http://localhost:3001/digital-garden/notes/backend-with-nodejs-by-procoderr-notes/e6-installing-node-js) ya fir F5 press karo ya `fn + F5` press karo. Haan, debugger lagana mat bhuliye, aur aapko input mil jayega. Output niche code editor mein dekhna hai, aur yaad rakho output debugger console mein hi dikhega."

```
// create a text.txt file and paste hello
// create a script.js and paste till last console.log

const fs = require('fs');
const text= fs.readFileSync('./text.txt')
console.log("text",text);

console.log("yes file aa gyi ");

//ouput in Debugger console
text Buffer(5) [72, 101, 108, 108, 111, buffer: ArrayBuffer(8192), byteLength: 5, byteOffset: 288, length: 5, Symbol(Symbol.toStringTag): 'Uint8Array']
script.js:9
arg1 =
Buffer(5) [72, 101, 108, 108, 111, buffer: ArrayBuffer(8192), byteLength: 5, byteOffset: 288, length: 5, Symbol(Symbol.toStringTag): 'Uint8Array']
0 =
72
1 =
101
2 =
108
3 =
108
4 =
111
buffer =
ƒ buffer()
byteLength =
ƒ byteLength()
byteOffset =
ƒ byteOffset()
```

So, abhi aapko buffer mila hai, aur yeh file se related hai, khaane-peene se nahi. Toh yaha dhyan dijiye! Ab yeh buffer kya hai? Actually, yeh wohi file ka data hai jisme jo bhi content present hai. Ab kaise read karein?

Niche screenshot mein diye gaye steps follow kariye. Number 1 pe hover karke ek extension install kijiye, aur fir buffer ko read karte hain.

![image.png](/public/images/blogs/proe77-2.png)

Install aap [iss link](https://marketplace.visualstudio.com/items?itemName=ms-vscode.hexeditor) se bhi kar sakte hain, lekin view tabhi hoga jab aap debug kar rahe honge, yani red mark file ke console pe rakhiyega. Extension installation ke baad yeh result aayega (baad me dekhenge)

![image.png](/public/images/blogs/pro-e772.png)

Ab aap itna samjhiye ki aap file read kar paa rahe hain. Kya aap ye simple JS se browser environment mein file read kar sakte hain? Answer is **nahiii**! Toh ye ek best benefit hai aur power hai Node.js ki, ki using JS, we can read the file. Aur bhi bahut kuchh kar sakte hain, jo hum aage ke session mein dekhenge.

### Global Object in Node.js

Jaise browser mein `window` global variable hota hai, waise hi Node.js mein `global` naam se global variable hota hai

![image.png](/public/images/blogs/proe77-4.png)

Confuse ho gaye? Rukiye, main aapko dikhata hoon. Left side VS Code mein aapko 'Run and Debug' option dikh raha hoga, waha `Global` object dikhai dega. Usko expand karke dekhiye, aapko `global` object ki sari details dikhengi. Ya fir, aap `script.js` file mein code likh dijiye, aur terminal open karne ke liye ```Ctrl + \`` ya``` Ctrl + J` press kariye, fir likhiye: (Pichle session mein humne ye dekha tha.) Aapko console mein output dikh jayega. Filhaal, main screenshot dono jagah ka niche daal raha hoon.

Iss Global aur window ke baare me english me [yaha se padh sakte hain](https://heyashu.in/digital-garden/notes/namaste-node-js/e3-write-first-line-of-node-js-code).

```jsx
console.log(global)

// output
```

![image.png](/public/images/blogs/pro-e77-p-5.png)

So, yeh jaan lena zaroori hai ki web browsers mein `global` naam ka koi variable nahi hota, aur `window` ka concept Node.js mein nahi hai. Haan, community ne ek default variable create kiya hai jo dono environments (browser aur Node.js) mein related content deta hai. Lekin, bas naam same hai, so no confusion. 

Ab miltey hain next episode me.


First Line in Node Js

e7: running first line of code.

JS browser ke bahar bhi bahut kuchh kar sakti hai, chalo kuch examples dekhte hain.”

```jsx
const fs= require('fs');
fs.writeFileSync('hello.txt','Aur kaise ho??')
const text= fs.readFileSync('hello.txt')
console.log("text read", text);
```

FS ke bahut saare methods hain, bas itna samajh lijiye ki JavaScript Node.js me file delete, write, edit, aur create kar sakti hai. Aage hum isko detail me padhenge. Hum kisi bhi application ko bhi open kar sakte hain, jaise ab ek example dekhte hain kaise Chrome ko open karein.

```jsx
const {exec}= require('child_process')

exec('start chrome')
```

### Networking capabilities

JS Node.js me server bhi start kar sakti hai. Ek file banao aur usme likho

```jsx
const http= require('http')

const server= http.createServer((req,res)=>{
  res.end("hello world")
})

server.listen('3000')

// isko krne ke baad terminal me node script.likho 
// debugger se on kro
// browser pe jaake localhost:3000 hit kro
// browser me aisaa dikhega
```

![image.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/f04e628e-4c39-4f41-b348-53c143900880/78cad77f-52c8-45b2-9c60-7f859188e732/image.png)

Server ka code debug se run karne ke liye, aap left top pe green play button ko click kar sakte hain. Dhyan rahe, aapke `launch.json` file me ye code hona chahiye. Yani, `program` me aapke file ka naam hona chahiye. Mere file ka naam `script.js` hai, to maine `script` likha hai

```
  // .vscode/launch.json
  "version": "0.2.0",
  "configurations": [

    {
      "type": "node",
      "request": "launch",
      "name": "Launch Program",
      "skipFiles": [
        "<node_internals>/**"
      ],
      "program": "${workspaceFolder}\\server.js"
    }
  ]
}
```

* Process management kr sakte hain
* Operating system se interact kr sakte hain node js se

aur bahut saari cheeje ….


Why we should use Node Js

e8: Why Node JS

2008-2009 ke aas-paas ek developer Apache servers ke sath kaam karta tha, jahan har request ke liye ek naya thread create hota tha, jo blocking hota tha. Iska matlab ye tha ki jab ek request process hoti, tab tak doosri request wait karti. Is problem ko solve karne ke liye, 2009 me us developer ne JavaScript ko server pe run karne ka socha aur non-blocking approach ko adopt kiya, jisme ek hi thread multiple requests handle kar sakta tha bina block kiye. Usne **Chrome** ke JavaScript engine **V8** ka use karke JavaScript ko server-side pe run kiya.

Is experiment ke baad, 2010 me **NPM** (Node Package Manager) launch hua, jo JavaScript libraries aur modules ko manage karne ka ek asaan tarika ban gaya. Phir 2011 me Node.js ka Windows version release hua, aur iske baad Node.js ki popularity aur badh gayi.

Ek company, **Joyent**, ne Node.js ke creator, **Ryan Dahl**, ko hire kiya. Ryan ne 2009 me Node.js banaya tha, aur ab Node.js ka development kaafi strong ho gaya. Lekin, 2014 me ek challenge aaya jab kuch developers ne Node.js se alag ek project banaya jiska naam tha **IO.js**. Dono ka focus server-side JavaScript tha, lekin alag-alag development ho raha tha, jiski wajah se confusion badhne laga.

2015 me **Node.js Foundation** banayi gayi jisme Node.js aur IO.js ko merge karke ek single project banaya gaya—Node.js. Is foundation ne Node.js ko organize kiya aur **LTS** (Long-Term Support) version ke sath stable releases shuru kiye. Sab kuch theek hone laga.

2019 me **OpenJS Foundation** banayi gayi, jo web aur server-side JavaScript frameworks ko manage karti hai, aur aaj Node.js **OpenJS Foundation** ke under managed hota hai.

[agar aapko english me padhna hai to yaha click kariye](https://heyashu.in/digital-garden/notes/namaste-node-js/e1-history-of-node-js-in-depth)


Node JS by Procoderr

Installing Linux (WSL) in windows