DEV Community: laxman

3 tips to find the value of 'this' in javascript

laxman — Thu, 11 Nov 2021 18:49:14 +0000

This article is to help you deduce the value of 'this' in javascript. It is not as simple as in Java where this refers to the current object. In javascript, "this" is dynamic. To calculate the value of this, the following 3 tips are enough and it is not difficult at all. I will present the tips and give some sample snippets in the end to help you understand the idea better.

(Basic knowledge of JS is assumed)

The first tip:

Javascript is a function-scoped language.

It does not create new lexical scopes for every bracket pair. This is a common misunderstanding.

The following syntax does not create a new scope:

if (true) {
    // statements
}

Same applies for loops, switch statements as well.

However the following statement does create a new scope:

function getName() {
    return "Jake";
}

Note the use of function keyword here. Arrow functions do not create a new scope.

The second tip:

Starting from ES6, there are two variants for creating functions in JS:

Using function keyword
Using arrow syntax

The important difference between them is arrow function is very lightweight - it does not support prototype keyword; bind, call and apply don't work, arrow functions are not constructible and arrow functions do not create a scope.

However the most important distinction lies in how they both handle this keyword.

this keyword inside a normal function is bound to the object where the reference of the function is invoked.

Note: If there is no outer scope, the default scope is used, which is the global object (Window in case of browser and global in case of Node.js)

function getName() {
    return this.name
}

// will return Window.name because getName is called globally.
getName();

One catch is "this" of global scope will be set to undefined in strict mode. (but not really the point of focus here)

this keyword inside an arrow function is bound to the object where the function is defined.

Note the difference between defined and invoked. More examples on this after the third one.

The third tip:

The function keyword is special. It sets its scope to the object even if it is defined using the object literal or function is defined using prototype property. And more special property of normal functions: nesting normal functions does not alter how this is resolved. Every nested function is simply treated as a top level function.

object literal syntax:

let obj = {
    fn: function() {
        // prints obj
        console.log(this)
    }
}

However, the function using arrow syntax does not comply with the above rule (because remember js is function-scoped and not bracket-scoped).

let obj = {
    fn: () => {
        // prints Window (outer scope in this case)
        console.log(this)
    }
}

functional literal syntax:

The extension to this rule is when you define object using the function literal.

Consider a car class

function Car() {
    this.name = "BMW";
}

Car.prototype.getName = () => this.name;

const c = new Car();

// Will return Window.name
c.getName();

the getName is defined using arrow syntax and thus does not obey the prototype declaration and prints out Window.name

However,

Car.prototype.getName = function () {
  return this.name;
}

will return "BMW". This is because of the nature of function keyword is to obey prototype declaration or object literal.

What happens in ES6 class syntax?

You might know this already, ES6 classes are just a sugarcoat over the function literal for defining objects.

class Car {
    name = "BMW";

    getName() {
        return this.name;
    }

}

The above getName will return BMW because function keyword obeys function literal objects.

Arrow syntax:

class Car {
    name = "BMW";

    getName = () => {
        return this.name;
    }
}

The arrow syntax also prints BMW because of a different and an interesting reason - since class keyword just abstracts function literal and function literal creates a scope, the getName arrow function is always bound to Car object. This is different to object literal arrow syntax case - where it was bound to the outer scope and not the object itself.

And that's it!

These are the three tips which you can follow to always deduce the exact value of this keyword.

Building up on the above idea, let's consider the below examples:

Example 1: Indirect invocation

class Car {
    name = "BMW";

    getNameFn() {
       return this;
    }

    getNameArrow = () => {
       return this;
    }
}

function printUtil(obj) {
    const util = (fn) => {
      console.log(fn());
    }

    util(obj);
}


let c = new Car();
printUtil(c.getNameFn); // prints undefined
printUtil(c.getNameArrow); // prints BMW

If we pass a function defined inside a class to another function, the scope will change as in the example above, the first print statement produces undefined.

However, if we define an arrow function, it is always bound to where it is defined (respecting the function-scope) and thus it prints BMW.

In order to overcome this situation, js has methods like bind, apply and call which indirectly invoke the function.

printUtil(c.getNameFn.bind(c)); // prints BMW

bind, call and apply are simple. They just call the function with the scope of any given object (This prevents function from having dynamic "this" value). Here, c.getNameFn is passed to printUtil and is bound to object "c" (It can be bound to any object for that matter). Therefore it prints BMW.

Example 2: Function Invocation

function print() {
    console.log(this)
}

print()

Since print function is invoked directly, it will print its outer scope object which is Window object.

Example 3: IIFE

(function () {
    console.log(this)
})()

This syntax is called Immediately Invoked function expressions (IIFE). Quite a mouthful but nothing special about them. Consider them as normal functions that get invoked.

Thus the value of this will be its outer scope object. Same as above.

Example 4: Nested Function

let obj = {
    name = "car";

    function print() {

        function util() {
            console.log(this); // prints Window
        }

        util();
    }
}

obj.print()

The one caveat here is nesting normal functions does not modify how this resolves. (In other words, closure scope does modify this). Every nested function is simply treated as a top level function. Therefore util is still treated as a separate function and will print Window.

But as you may have guessed, this is still dynamic. You can bind it to print function using the two methods as discussed earlier:

use bind/call/apply keyword:

let obj = {
    name = "car";

    function print() {

        function util() {
            console.log(this); // prints obj
        }

        util.call(this);
    }
}

obj.print()

Or use the arrow syntax:

let obj = {
    name = "car";

    function print() {

        const util = () => {
            console.log(this); // prints obj
        }

        util.call(this);
    }
}

obj.print()

The reason: You guessed it! JS is function-scoped and print function created a scope and since the scope of util arrow function is based on where it is defined (respecting function-scope).

Conclusion:

Always remember JS is function-scoped. It will solve a lot of this keyword confusions.
The function keyword obeys function literal and object literal.
The arrow syntax obeys only function-scope nature of js.
Nesting normal functions do not modify how this is resolved.
If the value of this inside a normal function has to be bound to a specific object consider bind/call/apply.
Always prefer ES6 classes and Arrow syntax. Go for normal functions only when you have to extend a prototype.

More resources:

Feedbacks, questions and constructive criticisms are always welcome!

Compression and Archival in Linux

laxman — Thu, 03 Dec 2020 10:25:02 +0000

File archiving is used when one or more files need to be transmitted or stored as efficiently as possible. Linux supports lots of file archival mechanisms. This article describes the most popular ones.

Before looking into those here's a quick definition of compression and archival

Compression: Makes the files smaller by removing redundant information.

Archival: Combines multiple files into one, which eliminates the overhead in individual files and makes the files easier to transmit.

Simply compression reduces size and archival combines files.

Compression algorithms:

gzip
bzip2
xz

gzip:

gzip (GNU zip) is a compression algorithm. It uses the Lempel-Ziv-Markov (LZMA) chain algorithm. It is quite fast but the file size may be larger.

gzip {filename}

The original file is deleted and replaced by the compressed file.

Decompression of gzipped files:

Decompression is done using gunzip command.

gunzip {gzipped filename}

Including -l flag will show the compression information without actually compressing/decompressing.

bzip2:

bzip2 uses a different compression algorithm called Burrows-Wheeler block sorting, which can compress files smaller than gzip at the expense of more CPU time.

bzip2 {filename}

Decompression of bzip2'ed files:

Decompression is done using bunzip2 command.

bunzip2 {bunzip2'ed filename}

xz:

xz also uses the LZMA algorithm. It has the benefits of both gzip and bzip2. It compresses quickly and also results in smaller file sizes.

xz {filename}

Decompression of xzed files:

Decompression is done using unxz command.

unxz {xzed filename}

Archival:

tar:

Tar is a short form of TApe Archive. The tar command takes in several files and creates a single output file that can be split up again into the original files. The tar archived file is often called a tarball.

tar -f {filename} {options} {files to archive}

The tar command has three modes (pass the appropriate flag to mention the mode):

Create: Make a new archive out of a series of files. (-c)
Extract: Extract files out of an archive. (-x)
List: Show the contents without extracting. (-t)

Tar can also compress the resulting archive using the above compression algorithms.

Provide any of the following flags to mention the compression algorithm.

gzip (-z)
bzip2 (-j)
xz (-J)

The -v flag can be provided for a verbose result.

Example:

tar -cvJf backup.tar.xz projects/

This creates a tarball of the projects folder that is compressed using xz with a filename of backup.tar.xz

The extension can be anything but it is generally preferred to name this way.

for gzip, it is .tar.gz or .tgz, .taz
for bzip2, it is tar.bz2 or .tb2, .tbz, .tbz2, .tz2
for xz, it is tar.xz

Listing:

You can list the contents inside the archive without actually extracting using the -t flag.

Example:

tar -tvf backup.tar.xz

This command lists the contents of backup.tar.xz

Unarchival:

Unarchival is done by passing -x flag.

Example:

tar -xvJf backup.tar.xz

This command extracts the file in the same folder. If you wish to change it, pass the -C flag. (which will change directory to the specified one, therefore the directory should be present.)

tar -C backups -xvJf backup.tar.xz

This will extract in backups folder.

In order to extract a specific file/folder from the archive, provide the relative path of the file/folder.

tar -xvJf backup.tar.xz projects/project1

This will extract only project/project1 from the archive.

It is important to note that -f flag should always precede the filename

Zip:

Zip is an archival and compression mechanism. It does both. The compression is lossless. The default compression algorithm is DEFLATE. It is more common than tarballs. It has builtin support in Windows and Mac. Therefore, it is more preferred for archival than tar.

zip {options} {output filename} {files to compress}

By default, zip will not compress recursively. Therefore in order to compress files/subfolders inside a folder, use -r flag.

Example:

zip files.zip temp*

This will compress all files starting with temp.

zip -r projects.zip projects

This will recursively compress all files inside the projects folder.

Unzip:

the unzip command is used to extract the contents of the zipped archive.

Example:

unzip projects.zip

To just list without extracting,

unzip -l projects.zip

To extract specific files/folders inside the zip,

unzip projects.zip projects/project1

This is similar to tar.

Thanks for reading :)

Useful Linux commands

laxman — Sun, 15 Nov 2020 09:38:46 +0000

This is a list of useful Linux commands. Most of them are basic and they can be used as a reference for developers.

files and directories

ls => list all files
ls -a => list all files along with hidden ones
ls -R => list all files and folders recursively
ls -l => list in long format (shows more info)
rm {filename} => deletes a file
mv {filename} {directory path} => moves a file
mv {srcFileName} {destFileName} => renames a file
cp {srcFileName} {destFileName} => copies file
cp -R {srcDir} {destDir} => copies directory
cat {filename} => read contents of a file
cat > {filename} => writes to file
touch {filename} => creates a file, touch is basically used to change file timestamps. Refer here
mkdir {directory name} => makes a directory
rmdir {directory name} => removes a directory
rm -rf {directory name} => removes a directory recursively along with the files
mv {dirname1} {path or dirname} => moves or renames directory
history => list all commands used in the current session
clear => clears the terminal screen
pwd => displays the path of the current working directory.

file permissions

File permissions will be provided to users, groups and others (in the same order). They can be provided as numbers or letters.

r - read, w - write, x - execute
u - user, g - group, o - other, a - all

0 - no permission
1 - execute
2 - write
3 - execute + write
4 - read
5 - read + execute
6 - read + write
7 - all

chmod {number} {filename} => gives permissions to user,group and others.

Eg: chmod 777 ex.txt => gives all permissions to all users, groups and others.

'+' - gives permission
'-' - removes permission
'=' - assigns the given permission

Eg: chmod u=rw ex.txt => gives read/write to user
Eg: chmod a= ex.txt => removes all permission to all users.

chgrp {group name} {filename} => changes group for a file
chown {user} {filename} => changes owner of a file

input/ output directions

'>' write (stdout)
Eg: ls -al > {filename} => writes the output of "ls -al" to the file. If the file already exists, it is overwritten.
'>>' append (stdout)
Eg: echo "hi" >> {filename} => appends to the file
'<' input

File descriptors : 0 - stdin, 1 - stdout, 2 - stderr

Error redirection:

This is used to redirect errors to a log file, rather than cluttering the terminal.

Eg: cat ex.txt 2> error.log => tries to read the file, if there is any error, it is written to error.log

Here, '2' is the file descriptor for stderr.

working with pipes

pg, more and less

Show large text in the terminal as scrollable chunks by piping it to the pg, more or less commands.

Eg: cat large_file.txt | less => gives a scrollable viewer.

grep

Search for a string in the output by piping to grep.

Eg: ls | grep key => shows files that have a string "key".

Flags:

-i => case insensitive
-c => displays only count
-n => displays matching line and number
-v => displays output that didn't match

Eg: ls | grep -cv key => displays count to output that didn't match

grep can also accept regular expressions. Refer here

sort

Sort the contents

Eg: ls | sort => displays in alphabetic order

Flags:

-r => reverse
-n => numerical
-f => case insensitive

Eg: ls -l | sort -nk2 => displays content numerically sorted on the second column. (number of hard links in this case)

variables

VARIABLE=value => Set variables in the session.
$VARIABLE => gets the value of a variable.
unset VARIABLE => unsets the variable.

networking commands

ping {ip} => checks the connection
dig {hostname} => performs a dns lookup
ssh -i {key} {username@ip} => connects to a remote computer securely. key is the private key file.
scp -i {key.pem} {source} {dest} => copies a file. remote location should be host:file.
lsof -i {protocol:port} => list all processes listening on a port.

Eg: lsof -i tcp:3000 lists all processes listening to port 3000

process management

top => lists all running process
kill {pid} => kills a process with the given process id

mount device

lsblk => list all block devices
mount {device id} {directory} => mount a device to a directory

Eg: mount /dev/sda4 /ex/mnt

Flags:

-a => mounts all devices in /etc/fstab
-l => lists all mounted devices
-t => type of filesystem (eg: ext4)
umount {device id} => unmounts a device

manual

man {command name} => shows usage of a command

cover image by Sai Kiran Anagani