Orthogonal Thinking

Tag: JavaScript

  • JavaScript Finance: Calculate ichimoku value

    Looking to enhance your trading strategy with JavaScript? The Ichimoku Kinko Hyo indicator, commonly known as the Ichimoku Cloud, is a powerful tool for identifying market trends and support/resistance levels. In this article, we’ll walk through how to calculate Ichimoku values in JavaScript and use them to make buy/sell decisions.

    Ichimoku Kinko Hyo is a comprehensive technical analysis indicator comprised of several components: Tenkan-sen (Conversion Line), Kijun-sen (Base Line), Senkou Span A (Leading Span A), Senkou Span B (Leading Span B), and Chikou Span (Lagging Span). Each component helps traders visualize momentum, trend direction, and potential reversal points.

    To compute Ichimoku values for a stock, you need to specify several parameters: the time frame, the number of periods for each component, and the stock price data. Here’s how you might define these parameters in JavaScript:

    // Define the time frame to use for the Ichimoku indicator (e.g. daily, hourly, etc.)
const timeFrame = 'daily';

// Define the number of periods to use for each of the Ichimoku components
const conversionPeriod = 9;
const basePeriod = 26;
const spanAPeriod = 52;
const spanBPeriod = 26;

// Define the stock price for which to calculate the Ichimoku values
const price = 123.45;

// Initialize the Ichimoku Kinko Hyo indicator with the given parameters
const ichimoku = initializeIchimoku({
  timeFrame,
  conversionPeriod,
  basePeriod,
  spanAPeriod,
  spanBPeriod,
});

    With these parameters set, you can calculate the Ichimoku values for a given stock price. Below is an example implementation in JavaScript:

    const ichimoku = {
  // Define the Ichimoku parameters (fictional example)
  tenkanSen: 9,
  kijunSen: 26,
  senkouSpanB: 52,
  
  // Calculate the Ichimoku values for the given stock price
  calculate(params) {
    const { stock} = params;
    
    // Calculate the Tenkan-sen and Kijun-sen values
    const tenkanSen = (stock.highValues.slice(-this.tenkanSen).reduce((a, b) => a + b, 0) / this.tenkanSen)
    const kijunSen = (stock.lowValues.slice(-this.kijunSen).reduce((a, b) => a + b, 0) / this.kijunSen)
    
    // Calculate the Senkou Span A value
    const senkouSpanA = ((tenkanSen + kijunSen) / 2)
    
    // Calculate the Senkou Span B value
    const senkouSpanB = (stock.highValues.slice(-this.senkouSpanB).reduce((a, b) => a + b, 0) / this.senkouSpanB)
    
    // Calculate the Chikou Span value
    const chikouSpan = (this.prices[-this.senkouSpanB])
    
    // Return the calculated Ichimoku values
    return { tenkanSen, kijunSen, senkouSpanA, senkouSpanB, chikouSpan };
  }
};

// Calculate the Ichimoku values for the given stock price
const ichimokuValues = ichimoku.calculate({ price });

// Output the calculated Ichimoku values
console.log('Tenkan-sen:', ichimokuValues.tenkanSen);
console.log('Kijun-sen:', ichimokuValues.kijunSen);
console.log('Senkou Span A:', ichimokuValues.senkouSpanA);
console.log('Senkou Span B:', ichimokuValues.senkouSpanB);
console.log('Chikou Span:', ichimokuValues.chikouSpan);

    In this example, the ichimoku.calculate() function receives an object containing the stock price and returns an object with the computed Ichimoku values. The function leverages the parameters defined in the ichimoku object and uses fictional historical data (such as this.highs and this.lows) for its calculations.

    To interpret the Ichimoku Cloud indicator and make trading decisions, focus on these key values:

    • Tenkan-sen: The average of the highest high and lowest low over the past 9 periods. If the price is above Tenkan-sen, the trend is up; below, the trend is down.
    • Kijun-sen: The average of the highest high and lowest low over the past 26 periods. Price above Kijun-sen indicates an uptrend; below signals a downtrend.
    • Senkou Span A: The average of Tenkan-sen and Kijun-sen, shifted forward 26 periods. Price above Senkou Span A suggests an uptrend; below, a downtrend.
    • Senkou Span B: The average of the highest high and lowest low over the past 52 periods, shifted forward 26 periods. Price above Senkou Span B means uptrend; below, downtrend.
    • Chikou Span: The current price shifted back 26 periods. If Chikou Span is above the price, it signals an uptrend; below, a downtrend.

    Traders typically look for a combination of these signals. For instance, if the price is above both Tenkan-sen and Kijun-sen, and Chikou Span is above the price, this is considered bullish—a potential buy signal. Conversely, if the price is below Tenkan-sen and Kijun-sen, and Chikou Span is below the price, it’s bearish—a potential sell signal. Remember, interpretations may vary among traders.

    function buySellDecision(ichimokuValues) {
if (ichimokuValues.tenkanSen > ichimokuValues.kijunSen && ichimokuValues.chikouSpan > ichimokuValues.senkouSpanA) {
return "buy";
} else if (ichimokuValues.tenkanSen < ichimokuValues.kijunSen && ichimokuValues.chikouSpan < ichimokuValues.senkouSpanA) {
return "sell";
} else {
return "hold";
}
}

const decision = buySellDecision(ichimokuValues);
console.log('Buy/Sell decision:', decision);

  • JavaScript Finance: Calculate RSI value

    Looking for a reliable way to spot market momentum and potential buy or sell signals? The Relative Strength Index (RSI) is a popular technical indicator that helps traders gauge whether an asset is overbought or oversold. In this article, you’ll learn how to calculate RSI using JavaScript, with clear explanations and practical code examples.

    To calculate the RSI value, you first need to compute the average gain and average loss over a specified number of periods. These values are then used to determine the relative strength and, ultimately, the RSI using the following formula:

    RSI = 100 – 100 / (1 + (average gain / average loss))

    Start by determining the price change for each period. If the price increases, the change is positive and added to the total gain. If the price decreases, the change is negative and added to the total loss. Calculate the average gain and average loss by dividing the total gain and total loss by the number of periods used for the RSI.

    For example, if you’re calculating RSI over 14 periods, compute the price change for each of the last 14 periods. If the price increased by $1 in a period, add that to the total gain; if it decreased by $1, add that to the total loss. Divide each total by 14 to get the average gain and average loss, then use the formula above to calculate the RSI.

    Remember, RSI is an oscillator that fluctuates between 0 and 100. An RSI above 70 is considered overbought, while below 30 is considered oversold. These thresholds can help identify potential buying and selling opportunities.

    function rsi(prices, period) {
  const gains = [];
  const losses = [];

  for (let i = 1; i < prices.length; i++) {
    const change = prices[i] - prices[i - 1];
    if (change > 0) {
      gains.push(change);
    } else {
      losses.push(change);
    }
  }

  const avgGain = average(gains.slice(0, period));
  const avgLoss = average(losses.slice(0, period).map(Math.abs));
  const rs = avgGain / avgLoss;

  return 100 - (100 / (1 + rs));
}

function average(values) {
  return values.reduce((total, value) => total + value) / values.length;
}

    The code above calculates the RSI value for a given list of prices over a specified period. It computes the gains and losses for each price change, calculates the average gain and average loss, then determines the relative strength (RS) as the ratio of average gain to average loss. Finally, it calculates the RSI value using the standard formula.

    To use this code, simply call the rsi function with your price list and desired period, for example:

    const prices = [100, 105, 110, 115, 120, 130, 135];
const period = 5;
const rsiValue = rsi(prices, period);

    This will calculate the RSI value for the provided prices array over a period of 5. The resulting rsiValue will be a number between 0 and 100, indicating the relative strength of the asset. Values below 30 suggest oversold conditions, while values above 70 indicate overbought conditions.

    function rsiBuySellDecision(rsi) {
  if (rsi < 30) {
    return 'BUY';
  } else if (rsi > 70) {
    return 'SELL';
  } else {
    return 'HOLD';
  }
}

    Keep in mind, this is a basic example and RSI thresholds for buy or sell decisions may vary depending on your trading strategy. RSI should not be used in isolation; it’s best combined with other indicators and market analysis for more reliable results.

  • Calculate the SHA-256 hash of a string in JavaScript without library

    Ever wondered how to generate a SHA-256 hash in JavaScript without relying on external libraries? This post walks you through a pure JavaScript implementation of the SHA-256 algorithm, helping you understand each step and the underlying logic.

    The SHA-256 (Secure Hash Algorithm 256) is a widely used cryptographic hash function that produces a fixed-size output for any given input. It is commonly used to verify the integrity of data. In this post, we will learn how to implement the SHA-256 hash function in JavaScript without using any external libraries.

    function sha256(string) {
  // Initialize the SHA-256 hash
  var hash = new Uint32Array(8);
  hash[0] = 0x6a09e667;
  hash[1] = 0xbb67ae85;
  hash[2] = 0x3c6ef372;
  hash[3] = 0xa54ff53a;
  hash[4] = 0x510e527f;
  hash[5] = 0x9b05688c;
  hash[6] = 0x1f83d9ab;
  hash[7] = 0x5be0cd19;

  // Convert the string to a byte array
  var stringBytes = toUTF8Bytes(string);

  // Pad the byte array to a multiple of 64 bytes
  var paddedBytes = padToMultipleOf(stringBytes, 64);

  // Process the padded byte array in blocks of 64 bytes
  for (var i = 0; i < paddedBytes.length; i += 64) {
    processBlock(paddedBytes.slice(i, i + 64), hash);
  }

  // Return the final hash as a hexadecimal string
  return toHexString(hash);
}

    The hexadecimal values 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, and 0x5be0cd19 are the initial values of the eight 32-bit words used in the SHA-256 algorithm. These values are defined in the SHA-2 standard and serve as the starting state of the hash calculation. They are commonly referred to as the “initial hash values” or the “initial digest.”

    This function calculates the SHA-256 hash of a given string by first initializing the hash with the default initial values, then converting the string to a byte array, padding the byte array to a multiple of 64 bytes, and finally processing the padded byte array in blocks of 64 bytes.

    The toUTF8Bytes, padToMultipleOf, processBlock, and toHexString functions are helper functions used to convert the string to a byte array, pad the byte array, process the blocks of bytes, and convert the final hash to a hexadecimal string, respectively.

    Here are the implementations of these helper functions:

    function toUTF8Bytes(str) {
  var bytes = [];
  for (var i = 0; i < str.length; i++) {
    var codePoint = str.charCodeAt(i);
    if (codePoint < 0x80) {
      bytes.push(codePoint);
    } else if (codePoint < 0x800) {
      bytes.push(0xc0 | codePoint >> 6);
      bytes.push(0x80 | codePoint & 0x3f);
    } else if (codePoint < 0x10000) {
      bytes.push(0xe0 | codePoint >> 12);
      bytes.push(0x80 | codePoint >> 6 & 0x3f);
      bytes.push(0x80 | codePoint & 0x3f);
    } else {
      bytes.push(0xf0 | codePoint >> 18);
      bytes.push(0x80 | codePoint >> 12 & 0x3f);
      bytes.push(0x80 | codePoint >> 6 & 0x3f);
      bytes.push(0x80 | codePoint & 0x3f);
    }
  }
  return bytes;
}

    This function converts the given string to a UTF-8 encoded byte array by iterating over the string and converting each character to a code point using charCodeAt. It then encodes the code point as a sequence of bytes in the array, depending on the value of the code point. If the code point is less than 0x80, it is encoded as a single byte. If it is between 0x80 and 0x800, it is encoded as two bytes. If it is between 0x800 and 0x10000, it is encoded as three bytes. Otherwise, it is encoded as four bytes. The function returns the resulting byte array.

    Here is the complete implementation of padToMultipleOf and processBlock:

    function padToMultipleOf(bytes, multiple) {
  var padding = bytes.length % multiple;
  if (padding > 0) {
    padding = multiple - padding;
  }
  for (var i = 0; i < padding; i++) {
    bytes.push(i === 0 ? 0x80 : 0x00);
  }
  return bytes;
}

function processBlock(bytes, hash) {
  // Initialize the word array
  var words = new Uint32Array(64);
  for (var i = 0; i < 64; i++) {
    words[i] = bytes[i * 4] << 24 | bytes[i * 4 + 1] << 16 | bytes[i * 4 + 2] << 8 | bytes[i * 4 + 3];
  }

  // Initialize the working variables
  var a = hash[0];
  var b = hash[1];
  var c = hash[2];
  var d = hash[3];
  var e = hash[4];
  var f = hash[5];
  var g = hash[6];
  var h = hash[7];

  // Process the words in the block
  for (var i = 0; i < 64; i++) {
    var s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
    var maj = (a & b) ^ (a & c) ^ (b & c);
    var t2 = s0 + maj;
    var s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
    var ch = (e & f) ^ (~e & g);
    var t1 = h + s1 + ch + K[i] + words[i];

    h = g;
    g = f;
    f = e;
    e = d + t1;
    d = c;
    c = b;
    b = a;
    a = t1 + t2;
  }

  // Update the hash with the final values of the working variables
  hash[0] += a;
  hash[1] += b;
  hash[2] += c;
  hash[3] += d;
  hash[4] += e;
  hash[5] += f;
  hash[6] += g;
  hash[7] += h;
}

    The padToMultipleOf function pads the given byte array so that its length becomes a multiple of the specified value. It calculates the required padding, adds a 0x80 byte followed by 0x00 bytes as needed, and returns the padded array.

    function padToMultipleOf(bytes, multiple) {
  var padding = bytes.length % multiple;
  if (padding > 0) {
    padding = multiple - padding;
  }
  for (var i = 0; i < padding; i++) {
    bytes.push(i === 0 ? 0x80 : 0x00);
  }
  return bytes;
}

    Implementation of the toHexString helper function:

    function toHexString(hash) {
  var hex = "";
  for (var i = 0; i < hash.length; i++) {
    hex += (hash[i] >>> 0).toString(16);
  }
  return hex;
}

    The toHexString function converts the hash (an array of 32-bit unsigned integers) to a hexadecimal string by iterating over the array and converting each element to its hexadecimal representation.

    Here is an example of how the sha256 function can be used to calculate the SHA-256 hash of a given string:

    var hash = sha256("Hello, world!");
// The value of "hash" is now "7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069"

  • Make a Microsoft graph call using javascript

    Unlocking Microsoft 365 Data with JavaScript

    Imagine this: your team is building a productivity app that needs to pull in user calendars, emails, or OneDrive files from Microsoft 365. You’ve heard of Microsoft Graph, the unified API endpoint for accessing Microsoft 365 data, but you’re not sure where to start. The documentation feels overwhelming, and you just want to see a working example in JavaScript. Sound familiar?

    Microsoft Graph is a goldmine for developers. It allows you to interact with Microsoft 365 services like Outlook, Teams, OneDrive, and more—all through a single API. But getting started can be tricky, especially when it comes to authentication and managing API calls securely. In this guide, I’ll walk you through how to set up and make your first Microsoft Graph API call using JavaScript. Along the way, I’ll share some hard-earned lessons, gotchas, and tips to ensure your implementation is both functional and secure.

    Before We Dive In: Security Implications

    Before writing a single line of code, let’s talk security. Microsoft Graph requires OAuth 2.0 for authentication, which means you’ll need to handle access tokens. These tokens grant access to sensitive user data, so mishandling them can lead to serious security vulnerabilities.

    🔐 Security Note: Never hardcode sensitive credentials like client secrets or access tokens in your codebase. Use environment variables or a secure secrets management service to store them.

    Additionally, always request the minimum set of permissions (scopes) your app needs. Over-permissioning is not only a security risk but also a violation of Microsoft’s best practices.

    Step 1: Setting Up the Microsoft Graph JavaScript Client Library

    The easiest way to interact with Microsoft Graph in JavaScript is by using the official @microsoft/microsoft-graph-client library. This library simplifies the process of making HTTP requests and handling responses.

    First, install the library via npm:

    npm install @microsoft/microsoft-graph-client

    Once installed, you’ll also need an authentication library to handle OAuth 2.0. For this example, we’ll use msal-node, Microsoft’s official library for authentication in Node.js:

    npm install @azure/msal-node

    Step 2: Authenticating with Microsoft Graph

    Authentication is the trickiest part of working with Microsoft Graph. You’ll need to register your application in the Azure portal to get a client_id and client_secret. Here’s how:

    1. Go to the Azure Portal and navigate to “App Registrations.”
    2. Click “New Registration” and fill in the required details.
    3. Once registered, note down the Application (client) ID and Directory (tenant) ID.
    4. Under “Certificates & Secrets,” create a new client secret. Store this securely; you’ll need it later.

    With your app registered, you can now authenticate using the msal-node library. Here’s a basic example:

    const msal = require('@azure/msal-node');

// MSAL configuration
const config = {
  auth: {
    clientId: 'YOUR_APP_CLIENT_ID',
    authority: 'https://login.microsoftonline.com/YOUR_TENANT_ID',
    clientSecret: 'YOUR_APP_CLIENT_SECRET',
  },
};

// Create an MSAL client
const cca = new msal.ConfidentialClientApplication(config);

// Request an access token
async function getAccessToken() {
  const tokenRequest = {
    scopes: ['https://graph.microsoft.com/.default'],
  };

  try {
    const response = await cca.acquireTokenByClientCredential(tokenRequest);
    return response.accessToken;
  } catch (error) {
    console.error('Error acquiring token:', error);
    throw error;
  }
}

    

    In this example, we’re using the “client credentials” flow, which is ideal for server-side applications. If you’re building a client-side app, you’ll need to use a different flow, such as “authorization code.”
    

    Step 3: Making Your First Microsoft Graph API Call
    

    Now that you have an access token, you can use the Microsoft Graph client library to make API calls. Let’s fetch the authenticated user’s profile using the /me endpoint:
    

    const { Client } = require('@microsoft/microsoft-graph-client');
require('isomorphic-fetch'); // Required for fetch support in Node.js

async function getUserProfile(accessToken) {
  // Initialize the Graph client
  const client = Client.init({
    authProvider: (done) => {
      done(null, accessToken);
    },
  });

  try {
    const user = await client.api('/me').get();
    console.log('User profile:', user);
  } catch (error) {
    console.error('Error fetching user profile:', error);
  }
}

// Example usage
(async () => {
  const accessToken = await getAccessToken();
  await getUserProfile(accessToken);
})();

    

    This code initializes the Microsoft Graph client with an authentication provider that supplies the access token. The api('/me').get() call retrieves the user’s profile information.
    

    
💡 Pro Tip: Use the select query parameter to fetch only the fields you need. For example, client.api('/me').select('displayName,mail').get() will return only the user’s name and email.

    

    Step 4: Handling Errors and Debugging
    

    Working with APIs inevitably involves error handling. Microsoft Graph uses standard HTTP status codes to indicate success or failure. Here are some common scenarios:
    

      

    • 401 Unauthorized: Your access token is invalid or expired. Ensure you’re refreshing tokens as needed.
      • 

    • 403 Forbidden: Your app lacks the required permissions. Double-check the scopes you’ve requested.
      • 

    • 404 Not Found: The endpoint you’re calling doesn’t exist. Verify the API URL.
      • 

    

    To debug issues, enable logging in the Microsoft Graph client:
    

    const client = Client.init({
  authProvider: (done) => {
    done(null, accessToken);
  },
  debugLogging: true, // Enable debug logging
});

    

    Step 5: Scaling Your Implementation
    

    Once you’ve mastered the basics, you’ll likely want to scale your implementation. Here are some tips:
    

      

    • Batch Requests: Use the /$batch endpoint to combine multiple API calls into a single request, reducing latency.
      • 

    • Pagination: Many Microsoft Graph endpoints return paginated results. Use the @odata.nextLink property to fetch additional pages.
      • 

    • Rate Limiting: Microsoft Graph enforces rate limits. Implement retry logic with exponential backoff to handle 429 Too Many Requests errors.
      • 

    

    Conclusion
    

    By now, you should have a solid understanding of how to make Microsoft Graph API calls using JavaScript. Let’s recap the key takeaways:
    

      

    • Use the @microsoft/microsoft-graph-client library to simplify API interactions.
      • 

    • Authenticate securely using the msal-node library and environment variables for sensitive credentials.
      • 

    • Start with basic API calls like /me and gradually explore more advanced features like batching and pagination.
      • 

    • Always handle errors gracefully and implement retry logic for rate-limited requests.
      • 

    • Request only the permissions your app truly needs to minimize security risks.
      • 

    

    What will you build with Microsoft Graph? Share your thoughts and questions in the comments below!

  • How to get html code from console of a website

    Hook: The Power of the Browser Console

    Imagine this: you’re debugging a website late at night, and something isn’t rendering correctly. The CSS looks fine, the JavaScript isn’t throwing errors, but the page still isn’t behaving as expected. You suspect the issue lies in the generated HTML structure, but how do you quickly inspect or copy the entire HTML of the page? The answer lies in a tool that’s already at your fingertips: the browser console. Whether you’re a developer troubleshooting a bug, a designer analyzing a competitor’s layout, or a curious learner diving into web development, knowing how to extract a webpage’s HTML directly from the browser console is an essential skill.

    In this article, we’ll go beyond the basics of using document.documentElement.outerHTML. We’ll explore practical use cases, show you how to handle large HTML outputs, discuss security implications, and even touch on automating this process with scripts. By the end, you’ll not only know how to grab HTML from the console but also how to use this knowledge effectively and responsibly.

    Understanding document.documentElement.outerHTML

    The document.documentElement.outerHTML property is a JavaScript method that returns the entire HTML structure of the current webpage as a string. This includes everything from the opening <html> tag to the closing </html> tag. It’s a quick and straightforward way to access the full DOM (Document Object Model) representation of a page.

    Here’s a simple example:

    // Retrieve the entire HTML of the current page
const html = document.documentElement.outerHTML;
console.log(html);

    

    When you run this in your browser’s console, it will output the full HTML of the page. But before we dive into the “how,” let’s address an important topic: security.
    

    🔐 Security Note: Be cautious when running code in the browser console, especially on untrusted websites. Malicious scripts can exploit the console to trick users into executing harmful commands. Always verify the code you’re running and avoid pasting unknown scripts into the console.
    

    Step-by-Step Guide to Extracting HTML
    

    Let’s walk through the process of extracting HTML from a webpage using the browser console. We’ll include tips and tricks to make the process smoother.
    

    1. Open the Browser Console
    

    The first step is to access the browser’s developer tools. Here’s how to do it in popular browsers:
    

      

    • Chrome: Press F12 or Ctrl+Shift+I (Windows/Linux) or Cmd+Option+I (Mac).
      • 

    • Firefox: Press F12 or Ctrl+Shift+K (Windows/Linux) or Cmd+Option+K (Mac).
      • 

    • Edge: Press F12 or Ctrl+Shift+I (Windows/Linux) or Cmd+Option+I (Mac).
      • 

    • Safari: Enable “Develop” mode in Preferences, then press Cmd+Option+C.
      • 

    

    2. Run the Command
    

    Once the console is open, type the following command and press Enter:
    

    document.documentElement.outerHTML
    

    The console will display the entire HTML of the page. You can scroll through it, copy it, or save it for later use.
    

    💡 Pro Tip: If the output is too long and gets truncated, use console.log(document.documentElement.outerHTML) instead. This ensures the full HTML is displayed in a scrollable format.
    

    3. Copy the HTML
    

    To copy the HTML, right-click on the output in the console and select “Copy” or use the keyboard shortcut Ctrl+C (Windows/Linux) or Cmd+C (Mac). Paste it into a text editor for further analysis or modification.
    

    Handling Large HTML Outputs
    

    For complex websites with large DOM structures, the HTML output can be overwhelming. Here are some strategies to manage it:
    

    1. Save to a File
    

    Instead of copying the HTML manually, you can save it directly to a file using the following code:
    

    // Create a Blob and download the HTML as a file
const html = document.documentElement.outerHTML;
const blob = new Blob([html], { type: 'text/html' });
const url = URL.createObjectURL(blob);

const a = document.createElement('a');
a.href = url;
a.download = 'page.html';
a.click();

URL.revokeObjectURL(url);

    

    This script creates a downloadable file named page.html containing the full HTML of the page. It’s especially useful for archiving or sharing.
    

    2. Extract Specific Elements
    

    If you’re only interested in a specific part of the page, such as the <body> or a particular div, you can target it directly:
    

    // Get the HTML of the  tag
const bodyHtml = document.body.outerHTML;
console.log(bodyHtml);

// Get the HTML of a specific element by ID
const elementHtml = document.getElementById('myElement').outerHTML;
console.log(elementHtml);

    

    💡 Pro Tip: Use browser extensions like “SelectorGadget” to quickly find the CSS selectors for specific elements on a page.
    

    Automating HTML Extraction
    

    If you need to extract HTML from multiple pages, consider automating the process with a headless browser like Puppeteer. Here’s an example:
    

    // Puppeteer script to extract HTML from a webpage
const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');

  const html = await page.evaluate(() => document.documentElement.outerHTML);
  console.log(html);

  await browser.close();
})();

    

    This script launches a headless browser, navigates to a specified URL, and logs the full HTML of the page. It’s a powerful tool for web scraping and automation.
    

    Security and Ethical Considerations
    

    While extracting HTML is a legitimate technique, it’s important to use it responsibly. Here are some guidelines:
    

      

    • Respect copyright and intellectual property laws. Don’t use extracted HTML to replicate or steal content.
      • 

    • Follow website terms of service. Some sites explicitly prohibit scraping or automated data extraction.
      • 

    • Avoid running untrusted scripts in the console. Always verify the source of the code.
      • 

    

    ⚠️ Gotcha: Some websites use obfuscation or dynamically generate HTML with JavaScript, making it harder to extract meaningful content. In such cases, tools like Puppeteer or browser extensions may be more effective.
    

    Conclusion
    

    Extracting HTML from a webpage using the browser console is a simple yet powerful technique that every developer should know. Here’s a quick recap:
    

      

    • Use document.documentElement.outerHTML to retrieve the full HTML of a page.
      • 

    • Handle large outputs with console.log or save the HTML to a file.
      • 

    • Target specific elements to extract only the content you need.
      • 

    • Automate the process with tools like Puppeteer for efficiency.
      • 

    • Always consider security and ethical implications when extracting HTML.
      • 

    

    Now it’s your turn: What creative uses can you think of for this technique? Share your thoughts and experiences in the comments below!

  • How to convert an async function to promise in javascript

    Why Would You Ever Need to Convert an Async Function to a Promise?

    Picture this: you’re working on a complex JavaScript project with multiple APIs, third-party libraries, and custom modules. Somewhere in the chaos, you encounter a library that only works with traditional Promises, but your codebase is built around modern async/await syntax. You’re stuck trying to bridge the gap between these two paradigms. What do you do?

    This is where converting an async function to a Promise comes in handy. While async functions are essentially syntactic sugar over Promises, there are scenarios where you need explicit control over the Promise lifecycle. For example:

    • Interfacing with libraries or frameworks that don’t support async/await.
    • Creating custom wrappers for async functions to add retries, timeouts, or logging.
    • Debugging or instrumenting asynchronous code with more granular control.

    In this article, we’ll explore how to convert an async function to a Promise, why you might need to do it, and how to avoid common pitfalls. By the end, you’ll have a deeper understanding of both async functions and Promises, along with practical techniques to make your code more robust.

    Understanding Async Functions and Promises

    Before diving into the conversion process, let’s clarify what async functions and Promises are and how they relate to each other.

    Async Functions

    An async function is a special type of function in JavaScript that always returns a Promise. It allows you to write asynchronous code that looks and behaves like synchronous code, thanks to the await keyword. Here’s a simple example:

    // An async function that fetches data from an API
async function fetchData() {
  const response = await fetch('https://example.com/data.json');
  const data = await response.json();
  return data;
}

// Calling the async function
fetchData().then(data => console.log(data)).catch(err => console.error(err));

    

    In this example, fetchData is an async function that uses await to pause execution until the fetch and response.json() Promises are resolved. The function returns a Promise that resolves with the parsed JSON data.
    

    Promises
    

    A Promise is a JavaScript object that represents the eventual completion (or failure) of an asynchronous operation. It has three states:
    

      

    • Pending: The operation is still in progress.
      • 

    • Fulfilled: The operation completed successfully.
      • 

    • Rejected: The operation failed.
      • 

    

    Promises have methods like then, catch, and finally to handle these states. Here’s a basic example:
    

    // A Promise that resolves after 2 seconds
const delay = new Promise((resolve, reject) => {
  setTimeout(() => resolve('Done!'), 2000);
});

// Handling the Promise
delay.then(message => console.log(message)).catch(err => console.error(err));

    

    How to Convert an Async Function to a Promise
    

    Now that we understand the basics, let’s look at how to convert an async function to a Promise. The key is to wrap the async function in a new Promise constructor. Here’s the general pattern:
    

    // Original async function
async function asyncFunction() {
  // Perform some asynchronous operation
  return 'Result';
}

// Convert to a Promise
const promise = new Promise((resolve, reject) => {
  asyncFunction()
    .then(result => resolve(result))
    .catch(error => reject(error));
});

    

    Let’s break this down:
    

      

    • The asyncFunction is called inside the executor callback of the Promise constructor.
      • 

    • The then method resolves the new Promise with the result of the async function.
      • 

    • The catch method rejects the new Promise if the async function throws an error.
      • 

    

    Real-World Example: Fetching Data with Error Handling
    

    Here’s a more practical example that fetches data from an API and includes error handling:
    

    // Async function to fetch data
async function fetchData() {
  const response = await fetch('https://example.com/data.json');
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return await response.json();
}

// Convert to a Promise
const fetchDataPromise = new Promise((resolve, reject) => {
  fetchData()
    .then(data => resolve(data))
    .catch(error => reject(error));
});

// Using the Promise
fetchDataPromise
  .then(data => console.log('Data:', data))
  .catch(error => console.error('Error:', error));

    

    💡 Pro Tip: Always include error handling when working with async functions or Promises. Use try/catch blocks in async functions and catch methods for Promises.
    

    When to Avoid Wrapping Async Functions in Promises
    

    While converting async functions to Promises can be useful, it’s not always necessary. In fact, doing so can sometimes lead to redundant or overly complex code. Here are some scenarios where you should avoid this pattern:
    

      

    • Unnecessary Wrapping: Async functions already return Promises, so wrapping them in another Promise is redundant unless you need additional control.
      • 

    • Performance Concerns: Adding extra layers of Promises can introduce slight performance overhead, especially in high-frequency operations.
      • 

    • Readability: Overusing this pattern can make your code harder to read and maintain.
      • 

    

    ⚠️ Gotcha: Avoid wrapping async functions in Promises unless you have a specific reason to do so. Redundant wrapping can lead to confusing code and potential bugs.
    

    Security Implications
    

    Before we wrap up, let’s talk about security. When working with async functions and Promises, you need to be mindful of potential vulnerabilities:
    

      

    • Untrusted Data: Always validate and sanitize data fetched from external APIs to prevent injection attacks.
      • 

    • Error Handling: Ensure that all Promises have proper error handling to avoid unhandled rejections, which can crash your application in Node.js.
      • 

    • Timeouts: Use timeouts for network requests to prevent your application from hanging indefinitely.
      • 

    

    🔐 Security Note: Never trust external APIs blindly. Always validate responses and handle errors gracefully to secure your application.
    

    Conclusion
    

    Converting an async function to a Promise in JavaScript is a powerful technique that can help you bridge the gap between modern async/await syntax and traditional Promise-based APIs. Here are the key takeaways:
    

      

    • Async functions always return Promises, so wrapping them is only necessary for additional control.
      • 

    • Use the new Promise constructor to wrap async functions and control their lifecycle.
      • 

    • Always include error handling to make your code more robust and secure.
      • 

    • Avoid redundant wrapping to keep your code clean and maintainable.
      • 

    • Be mindful of security implications when working with external APIs and Promises.
      • 

    

    Now it’s your turn: have you ever needed to convert an async function to a Promise? What challenges did you face, and how did you solve them? Share your thoughts in the comments below!
Home · About · Privacy Policy · Terms of Service
© 2026 Orthogonal Info. All rights reserved.