15 Handy Javascript Hacks For Beginners

  • 15 mins read

15 Handy Javascript Hacks For Beginners

Are you looking to take your JavaScript skills to the next level? Look no further! This article will provide you with fifteen secret Javascript hacks for beginners to help you write better JavaScript code.

As a developer, it’s important to be learning and improving your skills constantly. One way to do this is by learning some of the lesser-known tips and tricks that can help you get the most out of the JavaScript language.

This post will cover some of the top JavaScript hacks that every beginner developer should know. From optimizing your code to making it more efficient, these tricks will help you become a more proficient JavaScript developer.

1. Using a Dynamic Key to Destructure an Object

Have you heard of destructuring in Javascript? It’s a handy feature that lets you quickly and easily access data from objects and arrays. And did you know that you can even destructure an object’s properties if you don’t know the key name or if it’s dynamic?

One way to use destructuring is by using aliases, which allow you to rename variables quickly. For example, say you have an object with attributes for a group of people’s names and ages. If you want to access a specific person’s age but don’t know their key name, you can use the bracket notation to retrieve it. 

Here’s an example:

const ages = {
  'John': 25,
  'Jane': 23,
  'Bob': 27

const age = ages[personName];

And this technique works with arrays too! Let’s say you have an array that stores the ages of a group of people. You can use the bracket notation to access the age of a specific person, even if you don’t know the exact index ahead of time:

const ages = [25, 23, 27];
const [, , age] = ages;
console.log(age); // returns 27

As you can see, bracket notation is handy when you need to access data from an object or array but don’t have all the information upfront. It lets you get what you need without writing a lot of code.

2. Making console.log Shorter

Have you ever found yourself getting tired of writing console.log() over and over again? It can be a bit tedious, right? There’s a handy little trick you can use to make things easier. The “bind” method allows you to save your console.log() statements and make them quicker to write.

Here’s an example of how you might use the bind method:

const user = {
  name: 'John',
  age: 30,
  location: 'New York'

console.log(`User name: ${user.name}`);
console.log(`User age: ${user.age}`);
console.log(`User location: ${user.location}`);

// Using the bind method
const log = console.log.bind(console);

log(`User name: ${user.name}`);
log(`User age: ${user.age}`);
log(`User location: ${user.location}`);

In this example, we have an object representing a user with their name, age, and location. The first block of code logs each of these properties to the console using separate console.log() statements. In the second block of code, we use the bind method to create a shortcut for the console.log() function, which we store in a variable called log. We can then use this log variable to log the user’s properties to the console, making the code shorter and easier to read.

3. Short Conditions

Tired of writing multiple lines of code for a simple conditional statement? There’s a trick for that. Use a one-line hack instead of writing numerous lines of code.

Here’s an example:

// Without using the one-line hack
const age = 18;
if (age >= 18) {
  console.log('You are allowed to enter');

// Using the one-line hack
const age = 18;
age >= 18 && console.log('You are allowed to enter');

In this example, we have a simple conditional statement that checks if a person’s age is greater than or equal to 18. If it is, we want to log a message to the console. The first block of code uses a traditional if statement to accomplish this. The second block of code uses the one-line hack to achieve the same result.

This trick is useful for simple conditional statements. It makes your code shorter and easier to read. However, be careful not to overuse it. Excessive use can make your code harder to understand.

4. The !! Operator:

The double negation operator (!!) converts an expression’s result to a boolean. An example:

const user = {
  name: 'John',
  age: 30,
  isAdmin: true

// Check if user is an admin
if (!!user.isAdmin) {
  console.log(`${user.name} has admin privileges.`);
} else {
  console.log(`${user.name} does not have admin privileges.`);

In this example, we have an object representing a user with their name, age, and a boolean property isAdmin that indicates whether or not they have administrative privileges. We use the double negation operator to check the value of isAdmin and log a message to the console accordingly.

This is just one example of how you might use the double negation operator in your code. It can be useful in various situations where you need to:

  • Convert an expression’s result to a boolean value.
  • Ensure a value is a boolean before using it in a conditional statement.

Try it out and see how it can make your code more efficient!

5. Get the First Element that Matches a Condition

The find() method of the Array prototype in Javascript allows you to search an array for the first element that matches a specific condition, and return the element. It is a useful way to search for a specific element in an array, and can be easily incorporated into your code to add additional functionality.

To use find(), call the function on the array you want to search, and pass in a callback function as an argument. 

The callback function should take in an element as an argument, and should return a boolean value indicating whether the element matches the condition you are searching for. find() will return the first element that matches the condition, or undefined if no element is found.

Here is an example of how you can use find() to search for the first element in an array that matches a specific condition:

const arr = [1, 2, 3, 4, 5];

const result = arr.find(x => x > 3);

console.log(result); // 4

In this example, find() is called on the array arr, and a callback function is passed as an argument. The callback function checks if the element is greater than 3, and find() returns the first element that matches the condition, which is 4.

6. Determine the Type of a Value with typeof

JavaScript has a built-in typeof operator that can help you find out what type a value is. It’s super helpful when you need to check a variable’s type before doing something with it.

To use typeof, just put it in front of the value you want to check. For example:

function add(a, b) {
  if (typeof a !== 'number' || typeof b !== 'number') {
    throw new Error('Error: both arguments must be numbers.');
  return a + b;

console.log(add(1, 2)); // 3
console.log(add(1, '2')); // Error: both arguments must be numbers.

In this example, the add function takes two arguments and checks whether they are both numbers using the typeof operator. If either argument is not a number, the function throws an error. Otherwise, the function returns the sum of the two arguments.

This is just one possible use case for the typeof operator. You can use it to check the type of any value in JavaScript and write code that handles different types in different ways. I hope this helps! Let me know if you have any further questions or need additional clarification.

7. Using a Memoized Function for Better Performance

Do you know about memoized functions in JavaScript? One of the cooler JavaScript hacks for beginners, these guys use a technique called ‘closure’, which means creating a function that returns another function. This way, you can store the results of previous calls in a private variable. This can be super helpful for improving the performance of frequently called functions, especially if they have lots of calculations. Just keep in mind that there are trade-offs between performance and memory usage.

For example, here’s a simple memoized function for calculating Fibonacci sequences:

function memoize(func) {
  const cache = {};
  return function(...args) {
    if (cache[args]) {
      return cache[args];
    const result = func(...args);
    cache[args] = result;
    return result;

function slowFibonacci(n) {
  if (n < 2) {
    return n;
  return slowFibonacci(n - 1) + slowFibonacci(n - 2);


const fastFibonacci = memoize(slowFibonacci);

When you run this code, you will see that the fastFibonacci function returns the same result as the slowFibonacci function, but it executes much faster because it is able to reuse previously computed results from its cache.

8. Debounced Function

This is one of my favorite JavaScript hacks for beginners. You can use debouncing to delay the execution of a function in JavaScript. It’s useful when you have a function that gets called a bunch of times in quick succession, but you only want it to run once after a certain amount of time has passed.

You can use the setTimeout() method to debounce a function. setTimeout() delays function execution by a certain number of milliseconds. If you use setTimeout() inside a closure, you can create a debounced function that only runs once after a specific time.

Here’s an example of how you can use debouncing to improve the performance of a function that is called frequently:

function debounce(func, wait) {
  let timeout;
  return function() {
    timeout = setTimeout(func, wait);

function printHello() {

const debouncedPrintHello = debounce(printHello, 1000);


When you run this code, you will see that the printHello function is only executed once, even though it is called multiple times. This is because the debouncing behavior causes the function to pause for 1 second between each call, effectively “debouncing” the calls and preventing them from executing too frequently.

9. Object Freezing to Make an Object Immutable

The Object.freeze() method in JavaScript lets you make an object unchangeable. This is one of the best tricks when you want to make sure the properties of an object stay the same, like to avoid accidental changes or to protect data integrity.

Here’s an example of how you can use it:

const student = {
  name: 'Jasmine',
  grade: 'A'


student.name = 'Olivia'; // this assignment has no effect
student.grade = 'B'; // this assignment has no effect

console.log(student.name); // 'Jasmine'
console.log(student.grade); // 'A'

In this example, we freeze the student object using Object.freeze(), and then try to modify the name and grade properties. But these assignments don’t do anything, because the object is immutable and can’t be changed.

10. Optional Chaining 

Optional chaining is a feature in JavaScript that allows you to safely access the properties of an object even if that object is null or undefined. It can be helpful in avoiding TypeErrors when working with complex data structures.

Here is a simple example of optional chaining in action:

const data = {
  user: {
    name: 'John',
    age: 30,
    address: {
      street: 'Main St',
      city: 'New York',
      state: 'NY',
      zip: 10001

const userZip = data?.user?.address?.zip;  
const missingZip = data?.user?.address?.missing?.zip;  

console.log(userZip); // 10001
console.log(missingZip) // undefined

In this example, data.user.address.zip exists and has a value of 10001, so userZip is assigned this value. However, the missing property does not exist within the address object, so missingZip is assigned the value undefined.

Optional chaining can be a useful tool for safely navigating complex data structures and avoiding errors when working with data that may not always be present. If you have any further questions, please let me know.

11. Ternary Operator (?:) to Conditionally Assign a Value

The ternary operator (?:) in Javascript is a concise way to assign a value to a variable conditionally. It is often used as an alternative to an if statement and can be especially useful when you only need to perform a simple assignment based on a single condition.

To use the ternary operator, you write the condition followed by a ?, then the value you want to assign if the condition is true, followed by a :, and finally, the value you want to give if the state is false. The syntax looks like this:

variable = condition ? valueIfTrue : valueIfFalse;

Here is an example of how you can use the ternary operator to conditionally assign a value:

const x = 10;

const y = 20;

const max = x > y ? x : y;

console.log(max); // 20

In this example, the ternary operator compares the values of x and y, and assigns the value of y to the max variable if x is less than y, or the value of x if x is greater than or equal to y. In this case, max is assigned the value of y because x is less than y.

12. Use the Spread Operator (…) to Merge Objects

The spread operator in Javascript is a handy tool that lets you easily merge multiple objects into one. It’s often used when you want to combine the properties of different objects or create a new object with a mix of properties from existing objects.

To use the spread operator for merging objects, you can do it like this:

const merged = {...object1, ...object2, ...object3};

Here's a practical example of how you could use the spread operator to merge objects:

const customer = { name: 'John', age: 30 };
const order = { product: 'Book', quantity: 2 };
const payment = { method: 'Credit card', paid: true };

const transaction = {...customer, ...order, ...payment};

In the above snippet, we have three objects: customer, order, and payment. Each object has its own properties, like name, age, product, quantity, method, and paid.

We use the spread operator to merge these three objects into a single object called a transaction. The spread operator takes each object and “spreads” its properties into a new object. So the resulting transaction object will have all the properties of the original objects combined.

This would output an object like this:

{ name: 'John', age: 30, product: 'Book', quantity: 2, method: 'Credit card', paid: true }

The spread operator is really useful for combining properties from different objects into a single object. 

13. Object key 

The Object.keys() function in Javascript is a way to get an array of the properties of an object. It’s often used in combination with other methods like forEach() or map() to iterate over an object’s properties and do something with them.

Here’s an example of how you might use Object.keys():

const student = { name: 'Alice', age: 25, major: 'Computer Science' };

const keys = Object.keys(student);

keys.forEach(key => {
  console.log(`${key}: ${student[key]}`);

This would output the following:

name: Alice

age: 25

major: Computer Science

As you can see, Object.keys() returns an array of the object’s enumerable properties, which in this case are name, age, and major. We can then use the forEach() method to iterate over this array and do something with each property, like log it to the console.

14. How to Compress JavaScript Files

When it comes to building websites, it’s important to keep in mind that large JavaScript files can slow down loading and response times. One of the most straightforward JavaScript tips to improve performance is minifying your code.

Minifying JavaScript is the process of removing unnecessary characters from your code to make it smaller and more efficient. This can include things like removing comments, whitespace, and unused code.

Minifying your JavaScript can have a number of benefits:

  • Smaller file size: By removing unnecessary characters, you can reduce the size of your JavaScript files. This can help improve loading times, especially on devices with slower internet connections.
  • Improved performance: By making your code smaller, you can reduce the amount of data that needs to be transferred over the network and processed by the browser. This can result in faster response times and a better overall user experience.

There are several tools available that can help you minify your JavaScript. Some popular ones include the Google Closure Compiler and the Microsoft Ajax Minifier. These tools can parse, analyze, and reduce your JavaScript code, making it smaller and more efficient.

While I just had to add this to the list of JavaScript hacks, it’s important to note that minifying JavaScript isn’t a hack or a substitute for writing clean, well-structured code. Similar to minifying CSS, it is primarily for reducing file size and network load. As such, it can be a helpful technique for improving the performance of your web application.

15.  Replace occurrences in a string more than once 

The String.replace() method is a useful tool for replacing a specific string or pattern in a larger string. However, by default, it only replaces the first occurrence of the string or pattern. If you have a large dataset and need to perform this operation frequently, this can be a bit tedious.

To simplify things, you can add a /g flag to the end of your regular expression. This tells the replace() method to execute the replacement on all matching conditions, rather than just the first one.

Here’s an example of how you might use the /g flag:

const grammar = 'synonym synonym';

console.log(grammar.replace(/syno/, 'anto')); // "antonym synonym"
console.log(grammar.replace(/syno/g, 'anto')); // "antonym antonym"

In the first example, the replace() method only replaces the first occurrence of “syno” with “anto”, resulting in the string “antonym synonym”. In the second example, we add the /g flag to the regular expression, so the replace() method executes the replacement on both occurrences, resulting in the string “antonym antonym.”

Final Thoughts

Once you learn the basics of JavaScript, you can strengthen your skills by learning some helpful JavaScript hacks for beginners. Add these to your toolbox, and you’ll be two steps ahead!

Drop a comment below if you want to suggest some more tips and tricks, or if you have any questions!