Learn back-end development with Node.js, covering HTTP servers, databases, JWT, WebSockets, and more. Consolidate your skills in a capstone project by building a RESTful API for a practical use case.

nodegui.tar.gz

Without_start_script

With_start_script

cookingProcess

writeFileExample

fileProcessor

fileTask

dynamicServer

directoryManager

axios

expressjs

axios_http

dotenv

lodash

nodemon

postgres

postgres-api

postgres-exercise

bcrypt

complete_authentication

websocket-server

math-jest

async-jest

npm-intro-exercise

babel

process_env

process_dotenv

process_lifecycle

Without_start_script-debug

babel-copy

This Node.js course offers a structured path to mastering back-end development. It begins with introducing Node.js and JavaScript in the server-side context, covering modules and foundational concepts. You’ll explore asynchronous programming with callbacks, Promises, async/await, and the event loop, followed by event-driven programming with the EventEmitter class. Practical skills include file system operations, working with buffers, and using streams for efficient data handling.

The course will then guide you through building HTTP servers, implementing routing, handling GET/POST requests, and integrating PostgreSQL for database-driven APIs. Additional topics include JWT-based authentication, WebSockets for real-time features like chat systems and live dashboards, and testing with Jest.

In the capstone project, you’ll build a RESTful API that stores arbitrary JSON data and enables filtering and retrieval in JSON, HTML, or CSV formats, enhancing your skills in building scalable back-end solutions.

Learn Node.js

`fs.readdir`, `fs.stat`, `fs.mkdir`, `fs.copyFile`

`fs.readdir`, `fs.readFile`, `fs.mkdir`, `fs.copyFile`

`fs.readdirSync`, `fs.statSync`, `fs.mkdirSync`, `fs.copyFileSync`

`fs.readdir`, `fs.stat`, `fs.mkdir`, `fs.bkupdir`

Which set of `fs` methods is best suited for the following tasks?

1. Listing files in a directory.
2. Retrieving metadata about those files.
3. Creating a backup directory.
4. Copying the files into the backup directory.

Which set of <code>fs</code> methods is best suited for the following tasks?
<ol>
<li>Listing files in a directory.</li>
<li>Retrieving metadata about those files.</li>
<li>Creating a backup directory.</li>
<li>Copying the files into the backup directory.</li>
</ol>

Which code snippet or combination creates a directory `test`, writes a file `test/data.txt`, and reads it back?

**Snippet A**
```javascript
const fs = require('fs').promises;

async function manage() {
    await fs.mkdir('test');
    await fs.writeFile('test/data.txt', 'Sample data');
    const content = await fs.readFile('test/data.txt', 'utf8');
    console.log(content);
}

manage();
```

**Snippet B**
```javascript
const fs = require('fs');

fs.mkdir('test', () => {
    fs.writeFile('test/data.txt', 'Sample data', () => {
        fs.readFile('test/data.txt', 'utf8', (err, data) => {
            console.log(data);
        });
    });
});
```

**Snippet C**
```javascript
const fs = require('fs').promises;

async function manage() {
    await fs.mkdir('test', { recursive: true });
    await fs.writeFile('test/data.txt', 'Sample data');
    const content = fs.readFile('test/data.txt', 'utf8');
    console.log(content);
}

manage();
```



Which code snippet or combination creates a directory <code>test</code>, writes a file <code>test/data.txt</code>, and reads it back?
Snippet A
<pre><code class="language-javascript">const fs = require('fs').promises;

async function manage() {
 await fs.mkdir('test');
 await fs.writeFile('test/data.txt', 'Sample data');
 const content = await fs.readFile('test/data.txt', 'utf8');
 console.log(content);
}

manage();
</code></pre>
Snippet B
<pre><code class="language-javascript">const fs = require('fs');

fs.mkdir('test', () =&gt; {
 fs.writeFile('test/data.txt', 'Sample data', () =&gt; {
 fs.readFile('test/data.txt', 'utf8', (err, data) =&gt; {
 console.log(data);
 });
 });
});
</code></pre>
Snippet C
<pre><code class="language-javascript">const fs = require('fs').promises;

async function manage() {
 await fs.mkdir('test', { recursive: true });
 await fs.writeFile('test/data.txt', 'Sample data');
 const content = fs.readFile('test/data.txt', 'utf8');
 console.log(content);
}

manage();
</code></pre>

They allow the simultaneous execution of multiple JavaScript threads.

Buffers enable handling binary data, while Streams process data incrementally, reducing memory usage.

Buffers and Streams are automatically optimized by the Node.js runtime to handle high network latency.

Streams are required only for handling file I/O, while Buffers are used exclusively for network communication.

Why are Buffers and Streams considered critical for handling large-scale data in Node.js applications?

Why are Buffers and Streams considered critical for handling large-scale data in Node.js applications?

Logs `NodeJS`, `Node`, `JS`, and an empty string

What is the output of the following buffer manipulation program?

```javascript
const buffer = Buffer.alloc(10);

buffer.write('Node', 0);
buffer.write('JS', 4);
buffer.write('!', 8);

console.log(buffer.toString());
console.log(buffer.slice(0, 4).toString());
console.log(buffer.slice(4, 8).toString());
console.log(buffer.slice(8).toString());
```

What is the output of the following buffer manipulation program?
<pre><code class="language-javascript">const buffer = Buffer.alloc(10);

buffer.write('Node', 0);
buffer.write('JS', 4);
buffer.write('!', 8);

console.log(buffer.toString());
console.log(buffer.slice(0, 4).toString());
console.log(buffer.slice(4, 8).toString());
console.log(buffer.slice(8).toString());
</code></pre>

Logs `edoN` and `smaertS` on separate lines

Throws an error due to improper stream handling


Given the following Transform stream, what will be logged to the console?

```javascript
const { Transform } = require('stream');

const reverseTransform = new Transform({
    transform(chunk, encoding, callback) {
        const reversed = chunk.toString().split('').reverse().join('');
        this.push(reversed);
        callback();
    }
});

reverseTransform.write('Node');
reverseTransform.write('Streams');
reverseTransform.end();
reverseTransform.on('data', (chunk) => console.log(chunk.toString()));
```


Given the following Transform stream, what will be logged to the console?
<pre><code class="language-javascript">const { Transform } = require('stream');

const reverseTransform = new Transform({
 transform(chunk, encoding, callback) {
 const reversed = chunk.toString().split('').reverse().join('');
 this.push(reversed);
 callback();
 }
});

reverseTransform.write('Node');
reverseTransform.write('Streams');
reverseTransform.end();
reverseTransform.on('data', (chunk) =&gt; console.log(chunk.toString()));
</code></pre>

Test your understanding of Node.js modules with this comprehensive quiz.

Getting Started with Node.js

Global Objects and Modules

Asynchronous Programming

Event-Driven Programming

Core Node.js Modules

Building a Basic Web Server

npm and Package Management

Working with Databases

Advanced Topics

Wrap Up

Appendix

Building a RESTful API with Node.js and PostgreSQL

Quiz: Core Node.js Modules