DEV Community: Victor Chan

3 Javascript features you probably didn't know

Victor Chan — Mon, 27 Jun 2022 14:30:35 +0000

Deep object destructuring You probably know you can destructure objects, but did you know you can destructure a destructured object?

const {
    dog,
    cat: { legs, eyes, breed },
  } = pets;

Destructuring an array You can also destructure an array by its index

const {0: first, 5: sixth} = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"];
console.log(first) // expected output: "Jan"
console.log(sixth) // expected output: "Jun"

The comma operator (,) Evaluates each of its operands (from left to right) and returns the value of the last operand.

let x = 1;

x = (x++, x);

console.log(x); // expected output: 2

x = (2, 3);

console.log(x); // expected output: 3

This is used when you need multiple variables for for loops

for (var i = 0, j = 9; i <= 9; i++, j--)
  console.log('a[' + i + '][' + j + '] = ' + a[i][j]);

7 Useful Javascript Tips

Victor Chan — Thu, 18 Jun 2020 09:31:56 +0000

7 Useful Javascript Tips

Without further ado, lets dive into it:

Filtering falsy values:

If you have an array of values, you can filter out falsy values(null undefined 0 "" NaN false ) with Boolean()

//Example 1
const x = ["a","",3,false,"hello",undefined]
const y = x.filter(Boolean);

console.log(y) // ["a",3,"hello"]

//Use it like this
myArray.filter(Boolean);

2. Floor a decimal number instead of Math.floor()
Useful for when you want to show whole numbers
(Edit: This removes decimal numbers so it actually acts like Math.ceil() for negative numbers, credits to @veljko94pesic)

//Example 1 
const x = 1.5 
const y = ~~x   
console.log(y) // Equals 1

//Example 2
const a = -1.5
const b = ~~a
console.log(b) // Equals -1

//Example 3 
const z = ~~2.73123 
console.log(z) // Equals 2

3. Implicit boolean coercion
Change a value into a boolean (Instead of Boolean(value))

const x = {} 
const y = !!x //Equals true 
console.log(y) // true

4. Last items in an array
You can use Array.slice() with negative indicies to count backwards.

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8]

console.log(array.slice(-1)); // Equals [8]

console.log(array.slice(-2)); // Equals [7, 8]

console.log(array.slice(-3)); // Equals [6, 7, 8]

5. Implicit number coercion using +

Putting a + in front of any value will attempt to change it to a number, similar to Number(value). This can also be used for Date objects as an alternative to Date.getTime()

//Example 1 
const x = new Date() 
const y = +x 
console.log(y) //Equals 1591887393586 (gives back time in ms)

Useful for doing this (get time 10 seconds later)

const z = new Date(+new Date() + 10 *1000)
console.log(z) //Equals 1591887403586

6.Method parameter validation
Lets you throw an error if input not given

const isRequired = () => { throw new Error('param is required'); };

const print = (value = isRequired()) => {   
    console.log(`${value}`)  
};

print(2);// Equals  2  
print()// Throws error  
print(null)// Equals null

7.Swallow errors for promise all

Normally, Promise.all() will throw if any promises inside its array rejects. We can ignore errors by using map and catch for each promise.

const promiseArray = [
    Promise.reject(null),
    Promise.resolve(100),
    Promise.resolve("More data"),
    Promise.reject(new Error('Throw an error here'))
];

//Map and catch for promises 
//And just console.log them 
const all = await Promise.all(
    promiseArray.map(p => p.catch(console.log))
)

Thats all!
Do you have any Javascript tips?
Feel free to leave them as a comment below 🙂

NodeJS: Quick and dirty logging 📈

Victor Chan — Thu, 11 Jun 2020 11:21:47 +0000

Here is a quick and dirty guide on how to add logging to your ExpressJS app. I’ll assume that you already know about Javascript, NodeJS and ExpressJS.

Why logging 📈?
Logging is one of the three main pillars of a systems Observability. Adding logging allows your express app to be monitored, for debugging errors as well as infer usage of the app.

Im sold 🙋🏻‍♂️, how do I add logging?
Just follow the four examples below to get an understanding of it.
Or just skip to Step 4 👇 if you want the answer to just add to your Express app.

Step 1: Have an ExpressJS app prepared
For this tutorial we will go through the hello world example found here.

Also make sure you have NodeJS, npm and express dependencies installed.

//index.js
const express = require("express");
const app = express();
const port = 3000;

app.get("/", (req, res) => res.send("Hello World!\n"));

app.get("/forbidden", (req, res) => res.status(403).send("Forbidden!\n"));

app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`));

Run the server on your terminal$ node index.js and you should be able to access it through your browser at http://localhost:3000

Step 2: Lets add some simple logging to the console
Lets modify the code and add a library called Morgan. npm install morgan

//index.js
const express = require("express");
const morgan = require("morgan"); //Import it here
const app = express();
const port = 3000;

app.use(morgan("tiny")); //Use it here
app.get("/", (req, res) => res.send("Hello World!\n"));

app.get("/forbidden", (req, res) => res.status(403).send("Forbidden!"));

app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`));

Run the server again on your terminal $ node index.js and on your browser test it with the following links:
http://localhost:3000/
http://localhost:3000/
http://localhost:3000/forbidden
http://localhost:3000/sdfasdfasdf

👏 Great, you now have logging! 👏
Your terminal should look something like this:

Step 3: Store the logs on the machine

const express = require("express");
const fs = require("fs");
const app = express();
const port = 3000;

app.use(morgan("tiny")); //We will keep this for demo purposes
app.use(morgan("tiny", { stream: fs.createWriteStream("./access.log", { flags: "a" }),})); //Write to a file here

app.get("/", (req, res) => res.send("Hello World!\n"));

app.get("/forbidden", (req, res) => res.status(403).send("Forbidden!"));

app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`));

Once again run the server in your terminal $ node index.js and access the links, the server will now store them into a file called access.log

But what if the server keeps running, and keeps generating logs? Over time the file size could become way too large. This can be solved by rotating the log files.

Step 4: Rotate the logs daily, and remove older logs

Lets add another library called file-stream-rotator $ npm install file-stream-rotator which will allow us to clean up logs past a certain amount of time. Lets also change the type of logging from tiny to combined , this will show more details in the logs.

const express = require("express");
const morgan = require("morgan");
const fs = require("fs");
const fileStreamRotator = require("file-stream-rotator");
const app = express();
const port = 3000;

//This will ensure log directory exists for acccess logs
const logsFolder = __dirname + "/accessLog";
fs.existsSync(logsFolder) || fs.mkdirSync(logsFolder);
//Create a log stream here
const rotatingLogStream = fileStreamRotator.getStream({
    filename: `${logsFolder}/access-%DATE%.log`,
    frequency: "daily",
    verbose: false,
    date_format: "YYYY-MM-DD",
    max_logs: 45, //Keep for 45 days
});

app.use(morgan("tiny")); //We will keep this for demo purposes
app.use(morgan("combined", {stream: rotatingLogStream}));

app.get("/", (req, res) => res.send("Hello World!\n"));

app.get("/forbidden", (req, res) => res.status(403).send("Forbidden!"));

app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`));

Again run the server in your terminal $ node index.js and access the links, the server will now store them into a folder with log files sorted daily, and cleaning them up after 45 days.

🎉 Congratulations! 🎊 You now have a rotating log setup for your Express app with just a few lines of code.

For a production setup you can easily use Filebeats, Elasticsearch and Kibana to collect and display these logs onto a dashboard (Out of this posts scope, but maybe I’ll cover it in a future writeup).

Short snippets: SSH Port Forwarding

Victor Chan — Thu, 11 Jun 2020 09:21:45 +0000

How to access a database behind a firewall

Scenario: Say you have a remote linux server somewhere remote (AWS EC2 or something) and you want to access a database whose port is blocked by a firewall, you can use the SSH (Secure Shell) local port forwarding command (-L) to gain access on your localhost to that port.

This is very useful when you’re developing and don’t want to expose your database in the cloud to the outside world.

Open a terminal and use this command below:

(You may be prompted to enter the user’s password for the remote server)

#This would connect you to port 5432 on your remote server
#And allow you to access it locally on port 5432 also, like magic!

$ ssh -L localhost:5432:localhost:5432 <user>@<server_ip>

You can even specify another port if you wish, like this:

#This would connect you to port 5432 on your remote server
#And allow you to access it locally on port 8000

$ ssh -L localhost:8000:localhost:5432 <user>@<server_ip>

#You will notice that this creates a new shell
#(You will be logged in to your remote server)
#If you don't want this to happen then you can use the -N flag

$ ssh -NL localhost:8000:localhost:5432 <user>@<server_ip>

Further Reading:

If you want to find out more about SSH and tunnels, I recommend the two links below, there are much more things you can achieve with SSH tunneling.

SSH Tunneling
How to create SSH Tunnels