dns.lookup() Method in Node.js

Introduction to dns.lookup() in Node.js

When developing network-based applications in Node.js, domain name resolution is a common task. The dns module provides several functions to perform DNS operations. Among these, dns.lookup() is the most basic yet widely used method. It allows you to resolve a domain name into its corresponding IP address, making it an essential tool for networking tasks in Node.js.

What is dns.lookup()?

The dns.lookup() function performs a standard DNS resolution using the operating system’s underlying resolver. This is the same mechanism used when you ping a domain or access a website through your browser.

Unlike other DNS methods like dns.resolve(), which performs a full DNS query, dns.lookup() uses the local configuration and is often faster for common lookups.

Syntax

dns.lookup(hostname[, options], callback)

Parameters:

• hostname – The domain name you want to resolve (e.g., 'example.com').
• options – (Optional) Can be a number (for IP family) or an object with fields like family, hints, and all.
• callback – A function that receives (err, address, family) as arguments.

Basic Example

Here’s a simple example of using dns.lookup() to resolve a domain:

const dns = require('dns');

dns.lookup('example.com', (err, address, family) => {
  if (err) throw err;
  console.log('Address:', address);
  console.log('IP Family:', family);
});

This script will output the resolved IP address of example.com and whether it is an IPv4 or IPv6 address.

Specifying IP Version (IPv4 or IPv6)

You can control which IP version to use by setting the family option:

dns.lookup('example.com', { family: 6 }, (err, address, family) => {
  if (err) throw err;
  console.log('IPv6 Address:', address);
});

Returning All IPs

If a domain has multiple IP addresses, you can retrieve them all by setting all: true:

dns.lookup('example.com', { all: true }, (err, addresses) => {
  if (err) throw err;
  console.log('All IPs:', addresses);
});

This will return an array of objects, each containing an address and its IP family.

dns.lookup() vs dns.resolve()

It’s important to distinguish between dns.lookup() and dns.resolve():

• dns.lookup(): Uses OS-level DNS resolution, follows local configuration (like /etc/hosts).
• dns.resolve(): Performs an actual DNS query using configured DNS servers.

Use Cases for dns.lookup()

The dns.lookup() method is best suited for scenarios where you want quick and simple IP resolution using the system’s DNS logic. It’s ideal when building tools that interact with remote servers, APIs, or perform basic connectivity checks.

Conclusion

In Node.js, dns.lookup() is a straightforward and efficient method to resolve domain names to IP addresses using your system’s built-in DNS capabilities. It's perfect for most general-purpose DNS lookups and integrates seamlessly with other network-related operations in your application.