DEV Community: Utkarsh Dhiman

Supercharge Your Vocab Bot: Google Sheets Persistence and Better Logs

Utkarsh Dhiman — Sat, 18 Jul 2026 00:55:00 +0000

In our last post, we built a private Telegram bot powered by Gemini 2.5 Flash that turns raw vocabulary words into beautiful study cards. We turned Google Apps Script into a fully functional, zero-cost cloud endpoint. If you missed that setup, you can catch up here

Right now, our bot is a great conversationalist, but it has short-term memory loss. The second you clear your chat history, your words vanish. Plus, every time you send it a word, you pay the "AI token tax"—even if you look up the exact same word three times a day.

Today, we are going to fix both problems. We will extend our bot to automatically check a Google Sheet database first to save AI tokens, save fresh words permanently, and build an automated production log tracker. Along the way, we'll peel back the curtain on how Google Cloud Platform (GCP) handles your script's architecture under the hood—and why setting up a custom GCP project fixes silent runtime crashes.

Here is the updated blueprint of our optimized system:

                        [ Telegram Webhook Request ]
                                     │
                                     ▼
                   ┌──────────────────────────────────┐
                   │    Google Apps Script (GAS)      │
                   └─────────────────┬────────────────┘
                                     │
             ┌───────────────────────┴───────────────────────┐
             ▼                                               ▼
  【 OLD DEFAULT SETUP 】                         【 NEW CUSTOM GCP PROJECT 】
  • Anonymous runtime identity                    • Verified OAuth Owner Identity
  • Low-priority processing                       • High-priority processing
  • Silent write dropping                         • Bulletproof data commits
             │                                               │
             └───────────────────────┬───────────────────────┘
                                     │
                                     ▼
                      ┌──────────────────────────────┐
                      │    Step 1: Sheet Cache Check │
                      └──────────────┬───────────────┘
                                     │
                      ┌──────────────┴───────────────┐
                      │    Step 2: Gemini 2.5 API    │ (Only if not in sheet!)
                      └──────────────┬───────────────┘
                                     │
                                     ▼
                      ┌──────────────────────────────┐
                      │    Step 3: Google Sheets     │
                      └──────────────┬───────────────┘
                                     │
             ┌───────────────────────┴───────────────────────┐
             ▼                                               ▼
    [ Vocabulary Tab ]                                  [ Logs Tab ]
    • Word (A)                                          • Timestamp (A)
    • Created Time (B)                                  • Input Word (B)
    • Description (C)                                   • Status (C)
    • Sentence (D)                                      • Details/Error Trace (D)
    • Synonyms (E)                                           ▲
    • Way to Remember (F)                                    │
             │                                               │
             └───────────────[ SpreadsheetApp.flush() ]──────┘
                               Forces instant recording!

Part 1: The Code Upgrade

We're adding a brand new lookup and save layer in sheet.gs and configuring main.gs to run a "cache-first" check before burning any AI tokens.

1. Preparing Your Google Sheet Database

Before writing code, create a fresh Google Sheet (type sheets.new into your browser bar) and name your first tab Vocabulary. Set up your header row in Row 1 across columns A to F exactly like this:

Create a second tab at the bottom and name it Logs. This will act as our private production terminal window.

Now, grab your unique Spreadsheet ID from your browser's URL bar (it's the long string of letters and numbers between /d/ and /edit).

Go to your Apps Script Project Settings (Gear Icon), scroll down to Script Properties, and add it:

SPREADSHEET_ID ➔ (Your copied Spreadsheet ID string)

2. Updating Your Code Files

Open your workspace editor. Leave your telegram.gs and gemini.gs code completely as they are. Head over to the Gist link below and update the remaining files:

Create sheet.gs: Copy the database query logic from the Gist. This handles searching through Column A to find matching records, caching data frames, and managing your execution logs.
Update main.gs: Overwrite your existing main function with the new optimized script block. This routes traffic dynamically—loading saved entries instantly from your Google Sheet or querying Gemini when a brand new word drops.

We are keeping our code modular and clean. All the raw files we are working with today are updated and available in the gist:

🔗 Get the Complete Updated Source Files on GitHub Gist

Make sure you deploy a New Version inside the deployment manager dropdown pane so the architecture update takes effect!

Part 2: The Invisible Production Crash (And Why Your Logs Are Missing)

Once you copy this code over and deploy a New Version, you might run into a frustrating rite of passage in the Apps Script world: The bot works fine when you click "Run" manually inside the editor, but fails silently when you message it via Telegram.

Even worse, when you check your Apps Script dashboards, the "Cloud Logs" option next to your failed production executions is grayed out or completely disabled.

What gives?

By default, every Apps Script runs on a hidden, micro-scoped background GCP project managed entirely by Google. Because you don't own that background container, Google strips away your administrative logging privileges. When an anonymous webhook executes via Telegram, it runs on low-priority infrastructure. If it runs out of processing breath, it dies mid-flight—and your cached spreadsheet writes (appendRow) vanish into thin air.

Part 3: The GCP Architecture Explained (Simply)

To make our bot bulletproof, we need to connect it to our own Standard GCP Project and configure an OAuth Consent Screen. Let's break down exactly what that means.

Think of a Google Cloud Project as a secure Digital Office Building that you own. Inside this building, different specialized departments work together.

When our bot runs inside your custom GCP project building, the flow changes completely:

The Front Gate (Telegram Webhook): Telegram hits your doPost URL endpoint.
The Security Desk (OAuth Consent Screen): Because you set up an OAuth profile, your script isn't running as an anonymous internet stranger anymore. It holds a verified digital security badge. It inherits permissions seamlessly via Implicit Scopes—meaning Apps Script pre-scanned your code, realized you were touching Sheets, and automatically authorized your badge to read/write to your spreadsheet file as you.
High-Priority Execution: Because you own the building, Google allocates a dedicated, high-priority processing runtime. Your script gets the server bandwidth it needs to safely check your sheet cache, talk to Gemini if needed, and drop the data straight into your spreadsheet grids.
The Security Cameras (Cloud Logging Explorer): Every single print statement and error stack trace is permanently caught on camera. Because you are the building administrator, you can open the Log Explorer dashboard anytime to review production behaviors.

Step 4: Connecting Your Script to Your GCP Project

Ready to make your bot production-grade? Follow these steps:

Head over to the Google Cloud Console and create a new project.
Search for OAuth Consent Screen in the top bar, set User Type to External, and fill out the basic app name and your email (you can leave scopes completely blank—Apps Script's implicit scopes will handle that on deployment!).
Go to Project Settings in the GCP dashboard and copy your Project Number.
Return to your Apps Script editor, click the gear icon (Project Settings), click Change project, and paste your Project Number.

While you are in your Apps Script Project Settings, make sure to check the box labeled "Log uncaught exceptions to Cloud Operations".

Deploy a New Version of your Web App one last time (Deploy > Manage Deployments > Edit > New Version > Deploy).

The Verdict

Go back to Telegram and send your bot a word you already looked up. It will reply almost instantly, stamped with appropriate marker.

Send it a completely new word, and you will watch it slide into your Vocabulary spreadsheet in real time, with an execution confirmation flag stamped cleanly in your Logs tab.

You now have an incredibly optimized, AI-powered vocabulary engine that tracks your learning database for life without wasting API credits.

Drop a comment below if your token-saving sheet integration is humming along perfectly, and happy hacking! 🚀

How to Set Up Absolute Imports in Node.js and TypeScript with Nodemon

Utkarsh Dhiman — Fri, 17 Jul 2026 11:12:50 +0000

TLDR

Switching from relative to absolute imports in TypeScript can greatly enhance code readability and manageability. By updating the tsconfig.json settings to use a fixed path from your project's root, you can simplify import statements. Additionally, when using nodemon and ts-node for development with absolute imports, you need to install tsconfig-paths and configure it in tsconfig.json. Updating these configurations ensures smooth functioning of absolute imports in your TypeScript project.

Introduction

I was working on a TypeScript project when I noticed messy relative imports. I'm sure you too may have stumbled across something like this. Relative imports make our code verbose and hard to understand where things are coming from, especially when files are nested in folders. For every relative import I write, I have to calculate the number of dots and slashes from the current file.

// example of relative imports
import User, { validateUser } from '../../models/user';
import { cors, middleware } from '../../middlewares';
import connectDb from '../../db';

Absolute imports to the rescue, they make your code cleaner and easier to manage by letting you use a fixed path from the root of your project instead of complex relative paths. This improves readability, and avoids confusion from navigating nested directories. For instance:

// example of absolute imports
import User, { validateUser } from '@/models/user';
import { cors, middleware } from '@/middlewares';
import connectDb from '@/db';

To switch from relative to absolute imports, make sure your tsconfig.json has these configurations set to appropriate values:

// tsconfig.json

{
  "compilerOptions": {
    "target": "es2016",
    "module": "commonjs",

    // configurations for absolute imports
    "rootDir": "./src",
    "baseUrl": "./",
    "paths": {
      "@/*": [
        "./src/*"
      ] 
    },
    "outDir": "./dist",

    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true
  }
}

Also, since we use nodemon for hot module reloading on the development server, it needs ts-node, a TypeScript compiler, to work. This setup works perfectly with relative imports. However, with absolute imports, we need to install another development dependency and add some configuration to tsconfig.json.

# install this package as development dependency
npm install -D tsconfig-paths

// tsconfig.json(final)

{
  "compilerOptions": {
    "target": "es2016",
    "module": "commonjs",
    "rootDir": "./src",
    "baseUrl": "./",
    "paths": {
      "@/*": [
        "./src/*"
      ] 
    },
    "outDir": "./dist",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true
  },

  // This module registers the TypeScript path resolver, 
  // which enables the resolution of TypeScript paths.
  "ts-node": {
    "require": ["tsconfig-paths/register"]
  }
}

Now, if we run the project in development using nodemon, absolute imports work just fine. Here's an example of how the scripts section in package.json looks:

...  
"scripts": {
  "build": "tsc",
  "start": "nodemon ./src/index.ts",
}
...

I'm using tsc for production build and ts-node for development server through nodemon. Deciding between tsc and ts-node requires understanding how they work internally and what purpose they serve. To learn more about it, read here.

Build a Personal Vocab-Boosting Telegram Bot with Gemini

Utkarsh Dhiman — Thu, 16 Jul 2026 10:16:35 +0000

Ever come across a word like serendipity or valiancy and thought, "I should write that down," only to completely forget about it five minutes later?

Yeah, me too.

Instead of carrying around a leather notebook like a 19th-century poet, let's build a private Telegram bot that does the heavy lifting for us. You send it a raw word or phrase, it runs it through Google’s lightning-fast Gemini 2.5 Flash model, and spits back a beautifully formatted dictionary card with the definition, synonyms, a custom mnemonic device, and an example sentence. Plus, you get a complete journal in Google Sheets (which we'll cover in the next blog post!).

Best part? It’s completely free, requires zero server maintenance, and takes about 15 minutes.

Here is the high-level blueprint of what we're building today:

       ┌───────────┐
       │ Your Phone│
       └─────┬─────┘
             │
             │ 1. Send word (e.g., "Serendipity")
             ▼
   ┌───────────────────┐
   │  Telegram Bot     │
   └─────────┬─────────┘
             │
             │ 2. Webhook HTTPS POST
             ▼
┌─────────────────────────┐
│ Google Apps Script (GAS)│ ◄─── Check: Is CHAT_ID == Owner?
└────────────┬────────────┘
             │
             │ 3. Forward prompt with strict JSON schema
             ▼
     ┌───────────────┐
     │  Gemini AI    │  (gemini-2.5-flash)
     └───────┬───────┘
             │
             │ 4. Return clean, structured JSON object
             ▼
┌─────────────────────────┐
│ Google Apps Script (GAS)│
└────────────┬────────────┘
             │
             │ 5. Parse JSON & format beautiful HTML template
             ▼
   ┌───────────────────┐
   │  Telegram Bot     │
   └─────────┬─────────┘
             │
             │ 6. Drop study card in your chat box!
             ▼
       ┌───────────┐
       │ Your Phone│
       └───────────┘

The Secret Sauce: Demystifying Apps Script as a Free Cloud Function Engine

Normally, building an automation backend or conversational bot means provisioning an AWS EC2 instance, setting up a Node.js Express server, managing API gateways, and worrying about environment configurations. If you look into traditional serverless infrastructure like AWS Lambda or GCP Cloud Functions, you still have to deal with deployment pipelines, IAM roles, and credit card billing setups.

We aren't doing any of that.

Instead, we are leveraging Google Apps Script (GAS). Most people think Apps Script is just for writing macro shortcuts inside Google Sheets, but it is actually a fully-fledged, serverless Cloud Function runtime hidden in plain sight.

When we deploy code as a Web App in GAS, Google instantly handles the deployment pipeline, provisions a public HTTPS endpoint, opens up a security layer, and listens for webhooks out of the box. Telegram pings our Apps Script cloud endpoint via a webhook, Google wakes our script up to process the incoming payload, and then it turns it back off. Total infrastructure cost: $0.00.

Let’s dive into the setup.

Step 1: Secure Your API Tokens (The Setup Phase)

Before writing any code, we need our digital access keys. We need to collect exactly three things: a Telegram bot token, your private user ID, and a Google Gemini API key.

A. Create Your Bot via BotFather

Click this link to open the official Telegram bot manager: telegram.me/BotFather.
Send the message /newbot to start the setup.
Give your bot a friendly display name (e.g., My Vocab Journal Bot).
Give your bot a unique username ending in the word bot (e.g., my_vocab_helper_bot).
Copy the long HTTP API token string it gives you. Keep this secret!

B. Extract Your Private Chat ID

Because we don't want strangers using our cloud bot server and burning our free AI credits, we need to lock the application down to your personal account profile.

Click this link to chat with a simple ID extractor bot: telegram.me/userinfobot.
Press Start.
Copy the numeric Id string it prints out immediately (e.g., 123456789). This is your unique CHAT_ID.

C. Create a Free Gemini API Key

Head over to the Google AI Studio Console.
Log in with your standard Google account.
Click the prominent Get API Key button.
Click Create API Key, select your project container, and copy the generated alphanumeric key string.

Step 2: Setting up the Google Apps Script Space

Head over to script.google.com and click New Project.
Rename the project to something descriptive, like Gemini Vocab Bot.
Before dropping code files in, click on the gear icon (Project Settings) on the left sidebar menu drawer.

Scroll all the way down to the bottom section titled Script Properties. This is Google's built-in secure vault for storing your private environment variables.
Click Add script property three times and save these exact key-value pairs:
TELEGRAM_BOT_TOKEN ➔ (Your copied Telegram token)
GOOGLE_API_KEY ➔ (Your copied Gemini API key)
CHAT_ID ➔ (Your numeric private Chat ID string)
Click Save script properties.

Step 3: Getting the Code

We want to keep this architecture simple and modular. On the left sidebar menu, click the Editor icon (the <> symbol). You will see a single file named Code.gs. Rename it to main.gs.

Then, create two more files by clicking the + icon next to Files, choosing Script, and naming them gemini and telegram.

All three files are available in this GitHub Gist.
From this embedded Gist copy the logic into your workspace files matching each filename:

Copy gemini.gs to enforce a strict structured output schema so Gemini's responses never break your layouts.
Copy telegram.gs to drive raw HTML text formatting delivery frames directly into chat panels.
Copy main.gs to act as the primary webhook controller, verifying security gates and organizing traffic patterns.

Step 4: Hooking It Up to Telegram (Deploy & Webhook)

Now for the final step: publishing your code as a live microservice and telling Telegram where to forward incoming chat messages.

A. Deploying the Script Web App

Click the blue Deploy button in the top right corner, then select New Deployment.
Click the gear icon next to "Select type" and choose Web App.
Fill out the deployment configuration fields:
Execute as: Select Me (your email address).
Who has access: Select strictly Anyone. (Telegram needs public webhook access to safely hit this API).
Click Deploy.

B. Bypassing the Developer Security Warning Screen

Because our custom script interacts with external networks (Telegram and Gemini), Google prompts a standard safety check sequence since it is an unverified independent development workspace. Don't worry—this is expected behaviour for your custom tools.

When the authorization window prompts you, click Review Permissions and select your active email profile.
On the screen that reads "Google hasn’t verified this app", click the tiny gray Advanced text link located at the bottom left.
Click the sub-link that appears below it: Go to Gemini Vocab Bot (unsafe).
Click Allow to finalize your live environment.
Copy the long production Web App URL it generates (it will end in /exec).

C. Binding the Telegram Webhook

To hook your bot up to this new endpoint, open a fresh tab in your web browser, paste this URL format into your address bar (replacing the bracketed placeholders with your real values):

https://api.telegram.org/bot<YOUR_TELEGRAM_BOT_TOKEN>/setWebhook?url=<YOUR_APPS_SCRIPT_WEB_APP_URL>

Make sure your URL doesn't contain any spaces or placeholder symbols. Your URL should look like: https://api.telegram.org/bot823499087:AAH_n4XxMg5LsdQ6XwGIrGDGf-4ryee7Haw/setWebhook?url=https://script.google.com/macros/s/AKfoyAJHafe28QP3iqV9-XjhQbnsiouf7243lonTItn_eXTlcxdfJofyUOkXxN_mKfefh12XjT2yKdBmEK/exec

Press Enter

If your screen returns a success message confirming {"ok":true,"result":true,"description":"Webhook was set"}, your cloud microservice is officially linked!

Try It Out!

Open up Telegram, pull up your brand new personal bot thread, and send it a word like unprecedented. Within a couple of seconds, you’ll get a perfectly structured, beautifully formatted study card delivered right to your pocket!

Stay tuned—in the next post, I'll show you how to expand this serverless architecture by automatically caching lookups to save AI tokens, and mapping these words into a permanent, beautiful database using Google Sheets.

Drop a comment below if your bot is live! 🚀

Custom Frontend for Google Form

Utkarsh Dhiman — Sat, 30 Jan 2021 12:28:15 +0000

Google form is one of the easiest ways to collect data. The collected data is preorganized and can be analyzed using various tools and add-ons.

Prequisite

You should be familiar with HTML forms at least. Having knowledge of JavaScript and fetch API will be great.

Need of custom front-end

There may be cases when you need a consistent design for your website. Although you can always create your form with a server and database but embedding Google form in your website can be much easier and economical.

Implementation

The very first requirement is to turn off the 'Require sign-in' sub-options in form settings.

Open your Google Form using the sharable link to extract the necessary information, it can be tricky at times.

Open Browser DevTools (F12 or Ctrl+Shift+i for chrome)
Extracting Form Action URL
search for <form

get the action attribute of form. It looks like https://docs.google.com/forms/u/0/d/e/1FAIpQLSfAnJAbfTl23gNM6gAbU1gAXo03N9I6pf5LJbo3Ptmex5nqUg/formResponse
Extracting name attribute(s)
Search for <input in DevTools, you may find many input fields look for the one that looks like this. entry.294341084

Input fields for inputs like radio button etc. are not present initially you have to select any option which will create a corresponding hidden input element otherwise, simply remove the \_sentinel form entry.100000084\_sentinel without checking radio button.

Custom front-end can be created in either of the following ways.

Only HTML forms: Easy way
Fetch API + HTML forms: Better way

Only HTML form

Create an HTML form, set its action attribute to previously extracted action URL and method attribute should be POST.
Set name attributes to corresponding input(s).

<form method="post" id="form" action="https://docs.google.com/forms/d/e/1FAIpQLSfAnJAbfTl23gNM6gAbU1gAXo03N9I6pf5LJbo3Ptmex5nqUg/formResponse">
    <label for="inp1">Write something</label>
    <input type="text" name="entry.294341084" id="inp1">
    <input type="submit" value="Submit">
</form>

That's it add CSS to make it beautiful.

With this approach, on submission, you will be redirected to the Google Forms acknowledgment page. -_- not so cool. You can avoid this by using fetch API.

Fetch API + HTML form

Create a Form, can be same as above. Prevent default behaviour of form so as to use fetch API using javascript. You have to set Method to post, the header should be "Content-Type": "application/json". You may or may not set mode to no-cors it will throw an error on cors mode but will work anyway.

let url = "https://docs.google.com/forms/d/e/1FAIpQLSfAnJAbfTl23gNM6gAbU1gAXo03N9I6pf5LJbo3Ptmex5nqUg/formResponse"; //action url
let form = document.querySelector("#form"); //form element

form.addEventListener("submit", (e)=>{
    e.preventDefault();//prevent default behaviour

    fetch(url,{
        method: "POST",
        mode: "no-cors",
        header:{
            'Content-Type': 'application/json'
            },
        body: getInputData()
    })
    .then(data=>{
        console.log(data);
        alert("Form Submitted");
    })
    .catch(err=>console.error(err)); //promise based
});

//populating input data
function getInputData(){
    let dataToPost = new FormData(); //formdata API

    //fill name attributes to corresponding values
    dataToPost.append("entry.294341084", document.querySelector("#inp1").value);

    return dataToPost;
}

The response from fetch post request is not satisfactory, but it doesn't matter since it works. ;P

The advantage of using this approach over HTML forms is you have full control, the user won't be redirected to Google Form's acknowledgement page.

Checkout a working example here.

Considerations

Custom Front End for the google forms can only be used to collect data.
It will work only if ‘Require Sign-In’ is turned off in Google form settings.
For Radio buttons, checkboxes etc. only exact values will be accepted, even a small spelling mistake will discard the answer for that particular question.
Tricky and Time-Consuming
Partial Response by the user if not handled properly, so frontend design should also validate user responses.
Sections in google form can be submitted by a single post request.
Images can also be posted using this approach.

It may be a time-consuming task to create a custom frontend for a google form, but results can be worth the effort.

Regular Expressions - not so regular!

Utkarsh Dhiman — Sun, 17 May 2020 15:13:16 +0000

Modifiers (or flags)
Brackets
Meta Characters
Quantifiers
Miscellaneous
Real World applications
Summary

Introduction

Regular Expressions aka RegEx. or RegExp. are powerful tools widely used for pattern matching within strings. They are supported by almost all programming languages. However choice of language plays a key role in deciding the usage and syntax of the same. Here, I'll be using JavaScript. A Website regex101 will let you use regular expressions even without the knowledge of programming language.

What does it look like?

This code will make sense as you proceed further.

How to use regular expressions

It depends majorly upon the language. In JavaScript there are various functions for the same eg: match(), test() and search() are widely used. In MySQL keyword LIKE, REGEXP or operator ~ (aka post-fix operator) are used for searching.

Kneel before the god ;P by memegenerator

Regular Expressions usually have

Quantifiers, Operators, Modifiers (or Flags).

Modifiers

Modifier	Description
'g'	for global search i.e. It won't stop searching after first match and will return all the matches.
'i'	for case in-sensitive search
'm'	for multi-line search (the regexp should be surrounded by ^ and $)

Brackets

Brackets	Description
[abc]	look for any one character between the square brackets(like an OR operator in programming languages)
[a-z]	includes all lower-case alphabets
[A-Z]	includes all upper-case alphabets
[A-z]	includes both upper-case and lower-case alphabets
[0-9]	includes all numerals
[^abc]	Will look for everything other than a,b,c (^ represents inverse here only in square-brackets otherwise it represent anchor operator)
(p\|q)	It is known as grouping operator, it divides the expression within sub-groups. It also saves the index of subgroup starting from 1-9 (which is used by back-reference operator)

Meta characters

Meta-character	Description
.	Finds a single character, except newline or line terminator
\w	Finds a word character it include [A-Za-z0-9_]
\W	Finds a non-word character
\d	Finds a digit
\D	Finds a non-digit character
\s	Finds a white-space character
\S	Finds a character that is not white-space
\b	Finds a match only at the beginning or end of a word, beginning like this: \bHI, end like this: HI\b
\B	Finds a match, where \b doesn't
\n	Finds a line feed character
\f	Finds a form feed character
\r	Finds a carriage return character
\t	Finds a tab character

Quantifiers

Quantifiers	Description (n here is anything you want to match)
n{2}	match only 2 instances of n
n{1,5}	match at least 1 at most 5 instances of n
n{1,}	match at least 1 instance of n
n+	Shorthand to match 1 or more instances of n
n*	Shorthand to match 0 or more instances of n
n?	Shorthand to match 0 or 1 instances of n

Miscellaneous

Meme on escape-sequence by xkcd

'|' operator can be used to separate sub groups.
'\1' operator(aka back-reference operator) is used to refer to previous subgroup of that index 1 in this case.
There is no concatenation operator as such. Things written together are already concatenated.
Some symbols that are used in expressions can't be used directly. '\' (backslash) is used to escape-sequence.
Multiple bracket sets can be used like [a-z] and [0-9] can be combined in following way [a-z0-9] without '|' and space.
^ and $ are used at beginning and end respectively however when ^ is used as [^\w]+ it is used to invert the selection. In this case no word will be selected i.e. only symbols and white spaces will be selected.

Let's see some interesting examples

To validate an email, username and password

Values are screened by RegExp. for security purpose. By Quickmeme

Real-world application of RegEx.

Forms: Usernames, Email addresses, passwords etc. are validated through RegEx. expressions. as seen above.
Search: RegEx. are used to search for files and within files. Sometimes replacement is followed by search.
Replace: With new updates in languages newer syntax come into play and sometimes older syntax are depreciated. Therefore changing each line of code would be a miserable. To ease the process there are programs that can convert syntax without damaging the functioning of original code.
Data Extraction: RegEx. are used in SQL (a language that makes queries to database) to look for records matching some criteria.

Saved the day. Source Xkcd

Summary

With Regular expression in your tool box, you can manipulate strings like pro!
Otherwise your life would be much more difficult than it need to be. Learn more at W3school
or here

DEV Community: Utkarsh Dhiman

Supercharge Your Vocab Bot: Google Sheets Persistence and Better Logs

Part 1: The Code Upgrade

1. Preparing Your Google Sheet Database

2. Updating Your Code Files

Part 2: The Invisible Production Crash (And Why Your Logs Are Missing)

Part 3: The GCP Architecture Explained (Simply)

Step 4: Connecting Your Script to Your GCP Project

The Verdict

How to Set Up Absolute Imports in Node.js and TypeScript with Nodemon

TLDR

Introduction

Build a Personal Vocab-Boosting Telegram Bot with Gemini

The Secret Sauce: Demystifying Apps Script as a Free Cloud Function Engine

Step 1: Secure Your API Tokens (The Setup Phase)

A. Create Your Bot via BotFather

B. Extract Your Private Chat ID

C. Create a Free Gemini API Key

Step 2: Setting up the Google Apps Script Space

Step 3: Getting the Code

Step 4: Hooking It Up to Telegram (Deploy & Webhook)

A. Deploying the Script Web App

B. Bypassing the Developer Security Warning Screen

C. Binding the Telegram Webhook

Try It Out!

Custom Frontend for Google Form

Prequisite

Need of custom front-end

Implementation

Custom front-end can be created in either of the following ways.

Only HTML form

Fetch API + HTML form

Considerations

Regular Expressions - not so regular!

Table Of Contents

Introduction

What does it look like?

How to use regular expressions

Regular Expressions usually have

Modifiers

Brackets

Meta characters

Quantifiers

Miscellaneous

Let's see some interesting examples

Real-world application of RegEx.

Summary