Blog Feed - Yagisanatode

Count the Occurrence of a Selection of a Cell in Google Sheets with Apps Script

A mate reached out to me last week asking if there was a way to monitor the times any article in a Google Sheet list goes through an editing stage before being published. From there, he wanted to report the number of edits on the article in an adjacent cell.

Take a look at the example:

As you can see in the example, whenever “NEEDS EDIT” is selected from the dropdown menu, then the counter column for the selected row item is updated automatically.

In this tutorial, we will cover how to create this for a single Google Sheet tab or for multiple selected tabs. I’ll also wrap up with a script to calculate just the aggregate count of changes to all the rows in the selected range and report it in a single cell.

Check out the video tutorial that covers the basics and grab the Starter Sheet to play along:

The Video

Scheduled release 6 Dec 2022 9am GMT+10

Generally better to view it from YouTube.

Starter Sheet

Here is a link to the starter sheet copy the sheet and head to Extensions > Apps Script in the menu.

Starter Sheet

The onEdit(e) Simple Trigger

Everything starts with the onEdit(e) simple trigger. This is a special trigger in Google Apps Script called a Simple Trigger that will run every time you edit your Google Sheet. If Apps Script sees the onEdit() function in your project it runs automatically.

Every time onEdit() is executed, it will retrieve an event parameter that is commonly referenced as "e" (onEdit(e)). The event object can return things like:

The current value
The previous value
The edited range
The source spreadsheet
The trigger id
The authorisation mode

We will be using a few of these in our code below.

Unless you have a very short coding task, it is generally good practice to reference another function that will be executed when onEdit() is run rather than coding directing within the onEdit() function.

Take a look at the three examples I added for my test project for this tutorial:

function onEdit(e) {


  countTimesSpecificCellValSelected_v1_(e); // Count each row in a single col
  countTimesSpecificCellValSelected_v2_(e); // Count for multiple Sheet Tabs
  countTimesSpecificCellValSelected_v3_(e); // Count Aggregate

};

function onEdit(e) {

countTimesSpecificCellValSelected_v1_(e); // Count each row in a single col

countTimesSpecificCellValSelected_v2_(e); // Count for multiple Sheet Tabs

countTimesSpecificCellValSelected_v3_(e); // Count Aggregate

};

You can see that each one of these functions will be run one after the other when a cell is edited and calls onEdit().

Count Every Time The Cell Changes

In this example, we add a count to our adjacent counter cell each time the cell is edited.

Note that we take the event (e) as our parameter for our countEveryTimeCellIsChanged(e) function.

/**
 * @OnlyCurrentDoc
 */


/**
 * Simple trigger function that runs after each change in the sheet. 
 */
function onEdit(e) {

  countEveryTimeCellIsChanged(e)

};



/**
 * Counts the times a cell is edited in a specified column and displays 
 * the count in the selected adjacent column. 
 * @param {Object} e - The event object from the onEdit trigger event.
 */
function countEveryTimeCellIsChanged(e){

  // ### VARIABLES ###
  // Update these
  const tgtSheet = "Single List"; // The sheet name the data is on. 
  const tgtCol = 3; // The column to search for a change. 
  const counterCol = 4; // The column to update the counter.

  // ### --- ###


  const range = e.range
  const sheet = range.getSheet();
  const column = range.getColumn();
  
  // check if on the correct sheet and in the correct column.
  if(sheet.getName() === tgtSheet && column === tgtCol){
      
    const row = range.getRow()
      
    // Get the counter cell;
    const counterCellRange = sheet.getRange(row, counterCol);
    const counterCellVal = counterCellRange.getValue();

    const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

    counterCellRange.setValue(updateCounterCell)
 
  };
};

/**

* @OnlyCurrentDoc

/**

* Simple trigger function that runs after each change in the sheet.

function onEdit(e) {

countEveryTimeCellIsChanged(e)

};

/**

* Counts the times a cell is edited in a specified column and displays

* the count in the selected adjacent column.

* @param {Object} e - The event object from the onEdit trigger event.

function countEveryTimeCellIsChanged(e){

// ### VARIABLES ###

// Update these

const tgtSheet = "Single List"; // The sheet name the data is on.

const tgtCol = 3; // The column to search for a change.

const counterCol = 4; // The column to update the counter.

// ### --- ###

const range = e.range

const sheet = range.getSheet();

const column = range.getColumn();

// check if on the correct sheet and in the correct column.

if(sheet.getName() === tgtSheet && column === tgtCol){

const row = range.getRow()

// Get the counter cell;

const counterCellRange = sheet.getRange(row, counterCol);

const counterCellVal = counterCellRange.getValue();

const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

counterCellRange.setValue(updateCounterCell)

};

Set the Variables

First, let’s assign all our variables at the top of our function to make it easier for us to change should we need to down the track.

We have 3 variables that we need to include here. They won’t change so we will make them a constant variable:

tgtSheet – This is the target sheet tab name. For our example, this is assigned to “Single List”.
tgtCol – This is the target column or the column that has the values that will need to be monitored for changes. In our example, this is the status column, column 3.
counterCol – This is the column where we display our change count. For us, this is column 4, but it could be any selected column in the sheet.

You can stop here if you want to copy and paste the script into your own project and update the variables for your own purposes. Or continue to learn how it all works.

Looking to learn more about Google Apps Scripts in a more structured format? Udemy has some great courses that can get you from the basics to a real Google Apps Script pro.

Got a more specific problem you need help with, but don’t have the time to develop the skills? Make an enquiry on my 'Hire me!' page. I occasionally pick up projects. Alternatively, Fiverr’s your best bet to find a skilled Google Apps Script developer to solve your problem quickly and professionally. *

*The above affiliate links have been carefully researched to get you to what you specifically need. If you decide to click on one of these links it will cost you just the same as going to the site. If you decide to sign up, I just get a little pocket money to help pay for the costs of running this website.

Get the Correct Sheet Tab and Column

Lines 33-38

We don’t want to end up counting the wrong column or updating a completely different sheet tab by mistake. This means we need a way to check if we are in the right spot.

The first thing we need to do is check the range we are currently editing. This can be done by grabbing the range object in our event parameter. Line 33

We now have access to the Google Apps Script range class. From this class, we can get the sheet class and also the range column number. Line 34-35

Using the JavaScript ‘if’ statement we first check that the sheets name (sheet.getName()) is equal to our assigned target sheet name and if it is, then check that the selected column is equal to the target column. Line 38

Update the Counter Cell

Lines 40 – 48

We need to update the adjacent counter cell in the same row that was changed when edited.

We can use the range class again with the getRow() method. This will give us a row number. Line 40

const row = range.getRow();

Next, using the sheet variable we created earlier we can call the getRange() method to get the counter cell. For a single cell, this method can take two variables the row and the column number. Here, we add in these two variables we collected earlier.

const counterCellRange = sheet.getRange(row, counterCol);

Now we need to add one to the current count in our counter cell. This means that we first need to collect the current value in the cell, which we do with the getValue() method.

We need a way to check if the value in the counter cell is empty. If it is then we want to give it a value of 1 otherwise we want to add 1 to the current value.

const counterCellVal = counterCellRange.getValue();

This can be achieved with a ternary operation. Think of a JavaScript ternary operator as a single line if statement in a way.

The ternary operator below states that if the value is less than zero (empty) then add one otherwise add one to the counter cell value.

const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

Finally, we update the counter cell:

counterCellRange.setValue(updateCounterCell);

Done!

The following scripts will modify this code. We will touch on the changes only in the code discussion of each script.

Count Every Time The Cell Changes To the Selected Value

In this scenario, we only want to count when a cell changes to a specific value. For our example, this value is “NEEDS EDIT”.

/**
 * @OnlyCurrentDoc
 */


/**
 * Simple trigger function that runs after each change in the sheet. 
 */
function onEdit(e) {

  countTimesSpecificCellValSelected_v1_(e); // Count each row in a single col

};


/**
 * Counts the number of times a cell value is change to a specfic item
 * from a dropdown in a specified column and displays the count in the 
 * selected adjacent column. 
 * @param {Object} e - The event object from the onEdit trigger event.
 */
function countTimesSpecificCellValSelected_v1_(e){

  // ### VARIABLES ###
  // Update these
  const tgtSheet = "Single List"; // The sheet name the data is on. 
  const tgtCol = 3; // The column to search for a change. 
  const counterCol = 4; // The column to update the counter.
  const tgtVal = "NEEDS EDIT"

  // ### --- ###


  const range = e.range
  const sheet = range.getSheet();
  const column = range.getColumn();
  
  // check if on the correct sheet and in the correct column.
  if(sheet.getName() === tgtSheet && column === tgtCol){

    // Check if the cell value matches the target value we need to count.
    const cellVal = e.value;
    if(cellVal === tgtVal){
      
      const row = range.getRow()
      
      // Get the counter cell;
      const counterCellRange = sheet.getRange(row, counterCol);
      const counterCellVal = counterCellRange.getValue();

      const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

      counterCellRange.setValue(updateCounterCell)
    };
  };
};

/**

* @OnlyCurrentDoc

/**

* Simple trigger function that runs after each change in the sheet.

function onEdit(e) {

countTimesSpecificCellValSelected_v1_(e); // Count each row in a single col

};

/**

* Counts the number of times a cell value is change to a specfic item

* from a dropdown in a specified column and displays the count in the

* selected adjacent column.

* @param {Object} e - The event object from the onEdit trigger event.

function countTimesSpecificCellValSelected_v1_(e){

// ### VARIABLES ###

// Update these

const tgtSheet = "Single List"; // The sheet name the data is on.

const tgtCol = 3; // The column to search for a change.

const counterCol = 4; // The column to update the counter.

const tgtVal = "NEEDS EDIT"

// ### --- ###

const range = e.range

const sheet = range.getSheet();

const column = range.getColumn();

// check if on the correct sheet and in the correct column.

if(sheet.getName() === tgtSheet && column === tgtCol){

// Check if the cell value matches the target value we need to count.

const cellVal = e.value;

if(cellVal === tgtVal){

const row = range.getRow()

// Get the counter cell;

const counterCellRange = sheet.getRange(row, counterCol);

const counterCellVal = counterCellRange.getValue();

const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

counterCellRange.setValue(updateCounterCell)

};

First off, we need to store a target value that we want to monitor for and if that value appears add one to our counter cell. Here on line 29, we set our target value to “NEEDS EDIT”.

const tgtVal = "NEEDS EDIT"

You can change this to the value that you need for your project.

Next, we need to check if the cell that was edited was edited to the new target value before we update the counter cell.

To do this we first get the value of the selected range (Line 42):

const cellVal = range.getValue();

Then we create an if statement checking that the cell value matches the target value on line 43 and closes on line 54.
if(cellVal === tgtVal){

Apply The Script to Multiple Selected Google Sheets

What if we have different editorial teams or genres handled by different editors? We might want to put the data for each team in a different sheet tab to make it easy for monitoring. Here we will need to check all the selected sheets for any changes.

In our example now we want the “Team 1” and “Team 2” sheet tabs. Both tabs are identical in format.

Let’s see how our code works now:

/**
 * @OnlyCurrentDoc
 */


/**
 * Simple trigger function that runs after each change in the sheet. 
 */
function onEdit(e) {

  countTimesSpecificCellValSelected_v2_(e); // Count for multiple Sheet Tabs

};

/**
 * Counts the number of times a cell value is change to a specfic item
 * from a dropdown in a specified column for selected sheets and displays 
 * the count in the selected adjacent column.
 * @param {Object} e - The event object from the onEdit trigger event.
 */
function countTimesSpecificCellValSelected_v2_(e){

  // ### VARIABLES ###
  // Update these
  const tgtSheets = ["Team 1", "Team 2"]; // The sheet names the data is on. 
  const tgtCol = 3; // The column to search for a change. 
  const counterCol = 4; // The column to update the counter.
  const tgtVal = "NEEDS EDIT"

  // ### --- ###


  const range = e.range
  const sheet = range.getSheet();
  const column = range.getColumn();
  
  // check if on the correct sheet and in the correct column.
  if(tgtSheets.includes(sheet.getName()) && column === tgtCol){ 

    // Check if the cell value matches the target value we need to count.
    const cellVal = e.value;
    if(cellVal === tgtVal){
      
      const row = range.getRow()
      
      // Get the counter cell;
      const counterCellRange = sheet.getRange(row, counterCol);
      const counterCellVal = counterCellRange.getValue();

      const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

      counterCellRange.setValue(updateCounterCell)
    };
  };
};

/**

* @OnlyCurrentDoc

/**

* Simple trigger function that runs after each change in the sheet.

function onEdit(e) {

countTimesSpecificCellValSelected_v2_(e); // Count for multiple Sheet Tabs

};

/**

* Counts the number of times a cell value is change to a specfic item

* from a dropdown in a specified column for selected sheets and displays

* the count in the selected adjacent column.

* @param {Object} e - The event object from the onEdit trigger event.

function countTimesSpecificCellValSelected_v2_(e){

// ### VARIABLES ###

// Update these

const tgtSheets = ["Team 1", "Team 2"]; // The sheet names the data is on.

const tgtCol = 3; // The column to search for a change.

const counterCol = 4; // The column to update the counter.

const tgtVal = "NEEDS EDIT"

// ### --- ###

const range = e.range

const sheet = range.getSheet();

const column = range.getColumn();

// check if on the correct sheet and in the correct column.

if(tgtSheets.includes(sheet.getName()) && column === tgtCol){

// Check if the cell value matches the target value we need to count.

const cellVal = e.value;

if(cellVal === tgtVal){

const row = range.getRow()

// Get the counter cell;

const counterCellRange = sheet.getRange(row, counterCol);

const counterCellVal = counterCellRange.getValue();

const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

counterCellRange.setValue(updateCounterCell)

};

Two changes need to be made to the script here.

On line 25, we need to change the tgtSheet variable to tgtSheets and include an array of all the Google Sheet tabs we need to monitor with our Apps Script code.

const tgtSheets = ["Team 1", "Team 2"]; // The sheet names the data is on.

Then on line 38, we need to replace the first part of the if statement with a way that will look through our array of sheets and check if the current sheet contains the selected name.

This can be achieved with the JavaScript includes function. This function appends a selected array (In our case, the target sheets array) and takes a target value as an argument. Our target value is the select sheet that this being edited.

... tgtSheets.includes(sheet.getName()) ...

Get the Aggregate Count of the Changes

This final script checks all the cells in the target column in a single Google Sheet tab and checks if they have been changed to “NEEDS EDIT”. Then records the aggregate count of all the cells in a single counter cell in a separate sheet tab.

In our example, we will monitor the “Single List” sheet tab for our desired change and record the total count of changes for all rows in the “Aggregate” sheet tab.

Check out the code:

/**
 * @OnlyCurrentDoc
 */


/**
 * Simple trigger function that runs after each change in the sheet. 
 */
function onEdit(e) {

  countTimesSpecificCellValSelected_v3_(e); // Count Aggregate

};


/**
 * Gets the aggregate of all the times each cell item changes to the 
 * selected cell value in a given row and reprots in a selecte cell. 
 * @param {Object} e - The event object from the onEdit trigger event.
 */
function countTimesSpecificCellValSelected_v3_(e){

  // ### VARIABLES ###
  // Update these
  const tgtSheet = "Single List"; // The sheet name the data is on. 
  const tgtCol = 3; // The column to search for a change. 
  const counterCell = 'Aggregate!A2'; // The column to update the counter.
  const tgtVal = "NEEDS EDIT"

  // ### --- ###


  const range = e.range
  const sheet = range.getSheet();
  const column = range.getColumn();
  
  // check if on the correct sheet and in the correct column.
  if(sheet.getName() === tgtSheet && column === tgtCol){

    // Check if the cell value matches the target value we need to count.
    const cellVal = e.value;
    if(cellVal === tgtVal){
      
      const counterCellRange = e.source.getRange(counterCell);
      const counterCellVal = counterCellRange.getValue();

      const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

      counterCellRange.setValue(updateCounterCell)
    };
  };
};

/**

* @OnlyCurrentDoc

/**

* Simple trigger function that runs after each change in the sheet.

function onEdit(e) {

countTimesSpecificCellValSelected_v3_(e); // Count Aggregate

};

/**

* Gets the aggregate of all the times each cell item changes to the

* selected cell value in a given row and reprots in a selecte cell.

* @param {Object} e - The event object from the onEdit trigger event.

function countTimesSpecificCellValSelected_v3_(e){

// ### VARIABLES ###

// Update these

const tgtSheet = "Single List"; // The sheet name the data is on.

const tgtCol = 3; // The column to search for a change.

const counterCell = 'Aggregate!A2'; // The column to update the counter.

const tgtVal = "NEEDS EDIT"

// ### --- ###

const range = e.range

const sheet = range.getSheet();

const column = range.getColumn();

// check if on the correct sheet and in the correct column.

if(sheet.getName() === tgtSheet && column === tgtCol){

// Check if the cell value matches the target value we need to count.

const cellVal = e.value;

if(cellVal === tgtVal){

const counterCellRange = e.source.getRange(counterCell);

const counterCellVal = counterCellRange.getValue();

const updateCounterCell = (counterCellVal < 0)? 1 : counterCellVal + 1;

counterCellRange.setValue(updateCounterCell)

};

First, we have replaced the counterCol variable with the counterCell variable and set that to cell A2 of the ‘Aggregate’ sheet tab.

const counterCell = 'Aggregate!A2'; // The column to update the counter.

Next, we don’t need to get the row number this time so we have deleted this variable.

Lastly, on line 44, we use the source property of the event (e) object to grab the current spreadsheet. This allows us to use the getRange() method to select our counter cell.

Conclusion

There should be enough samples there for you to work out your own combinations. If you want to test your new skills out, try to:

Create an aggregate count of multiple sheet tabs.
Move the counter column to another location in the sheet.
Check for different target values in different sheets with different locations.

If you get stuck check out some of the other popular tutorials on using onEdit():

It’s always nice to hear how people use these scripts in their own projects and it can be inspiring to share your use cases with others. Feel free to share your experience and examples in the comments below.

Finally a big thanks to Mike Kanert for the inspiration for this post. Editor, writer, artist, actor, educator, polymath and all-around nice fella, you can find Mike on Instagram @Unremarkable_Us for his latest comic series made by parents for parents:

Unremarkable Us

If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.

~Yagi

Sort and randomize data in Google Sheets with Apps Script

You might want to sort some Google Sheet data based on a condition in your Google Apps Script or simply sort by selected columns and rows after inserting a new row.

If you are always building sample data for tutorials like me, you might also be interested in randomising your data programmatically.

Fortunately, Google Apps Script’s SpreadsheetApp Class has built-in methods to handle just that for you. Plus it’s super easy to implement.

Check out the video tutorial below or grab one of the code snippets to add into your own project.

Continue reading “Sort and randomize data in Google Sheets with Apps Script”

Add a Row of Data Below the Header in Google Sheets with Apps Script

Sometimes it is just more intuitive to add a row of data to a Google Sheet just below the header instead of at the bottom of the Sheet.

One instance when this comes to mind is when we need to monitor time-dependent data as it is being input programmatically based on a trigger through Google Apps Script. Seeing purchases or sign-ins at the top of your sheet live might be more convenient than at the bottom of the sheet.

In this tutorial, we will walk through how to insert a row and add a new row of data to that row. We’ll also look at how to maintain formatting during this process.

Then if you need to maintain a Named Range or Some formula columns, we’ll walk through that too.

Let’s dive in!

The Starter Sheet

If you want to try out the script examples directly or are playing along from the video tutorial, here is a copy of the starter script:

Add a Row of Data Below the Header with Apps Script – STARTER

The Video

The Basic Code to Add a Row after A Header

In this example, we have a simple Google Sheet where we need to add our data to a row just below the header.

Simple example of adding a row below the header in Google Sheets With Apps Script — A simple example of adding a row below the header in Google Sheets With Apps Script

The main run function is the insertRowAtTop_v1() function. This contains all the code we need to complete our task.

The runsies_example1() function is simply a sample function that simulates how you can integrate the insertRowAtTop_v1() function into your own project.

/**
 * Add a Row of Data Below the Header with Apps Script
 * [This is an example]{@link https://yagisanatode.com}
 * @author Scott (Yagi) <yagisanatode@gmail.com>
 * @license Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
 */

/**
 * Inserts a row at the top below the header. 
 * @param {array<string>} data - 2d array [[id, date, email]]
 * @param {string} sheetName - the name of the selected sheet.
 * @param {number} targetRow - the row to insert the data in.
 */
function insertRowAtTop_v1(data, sheetName, targetRow) {
  
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = ss.getSheetByName(sheetName);

  // Insert a row
  // NOTE show what happens if we use insertRowAfter and how it carries over formatting from the top. 
  sheet.insertRowBefore(targetRow);
  sheet
    .getRange(targetRow, 1, 1, data[0].length)
    .setValues(data);

  SpreadsheetApp.flush();
}


/**
 * Runs example1. 
 * This function simulates how the insertRowAtTop funciton can be used. 
 */
function runsies_example1(){
  const targetRow = 2;
  const sheetName = "Example 1"

  // Dummy Data
  const myDate = new Date();
  const myTime = myDate.getTime() // The id
  const data = [
    [
      myTime,
      myDate,
      `${myTime}@example.com`
    ]
  ]

  insertRowAtTop_v1(data, sheetName, targetRow)
}

/**

* Add a Row of Data Below the Header with Apps Script

* [This is an example]{@link https://yagisanatode.com}

* @author Scott (Yagi) <yagisanatode@gmail.com>

* @license Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)

/**

* Inserts a row at the top below the header.

* @param {array<string>} data - 2d array [[id, date, email]]

* @param {string} sheetName - the name of the selected sheet.

* @param {number} targetRow - the row to insert the data in.

function insertRowAtTop_v1(data, sheetName, targetRow) {

const ss = SpreadsheetApp.getActiveSpreadsheet();

const sheet = ss.getSheetByName(sheetName);

// Insert a row

// NOTE show what happens if we use insertRowAfter and how it carries over formatting from the top.

sheet.insertRowBefore(targetRow);

sheet

.getRange(targetRow, 1, 1, data[0].length)

.setValues(data);

SpreadsheetApp.flush();

}

/**

* Runs example1.

* This function simulates how the insertRowAtTop funciton can be used.

function runsies_example1(){

const targetRow = 2;

const sheetName = "Example 1"

// Dummy Data

const myDate = new Date();

const myTime = myDate.getTime() // The id

const data = [

[

myTime,

myDate,

`${myTime}@example.com`

]

insertRowAtTop_v1(data, sheetName, targetRow)

}

If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.

insertRowAtTop_v1()

Set up the function

The insertRowAtTop_v1() function takes 3 arguments:

data – This is a 2d array of data containing the values you want to enter into your new row.
Google Sheet data is presented as a 2d array in Google Apps Script where a row of data is an entire array and each row array is contained in an outer array. So for example, a sheet range that is 3 columns by 4 rows deep would look like this:

A 2d array from a Google Sheet

[ ["1A", "1B", "1C"], ["2A", "2B", "2C"], ["3A", "3B", "3C"] ]

1
2
3
4
5

[
  ["1A", "1B", "1C"],
  ["2A", "2B", "2C"],
  ["3A", "3B", "3C"]
]
sheetName – This is the sheet tab name.
targetRow – This is the row where you want to insert your range. If your header data is deeper than one row, then you can change this value.

First, we call the getActiveSpreadsheet() method from the Google Apps Script SpreadsheetApp class. You can use the openById() or openByUrl() methods.

Now that we have access to our sheet we can invoke the getSheet() method taking the selected sheet as our parameter. For our example, the sheet will be ‘Example 1’ as indicated by the sheetName parameter.

insert a row into the sheet

Our next task is to add a row to our sheet. We can do this with the .insertRowBefore(targetRow) method. This method takes a target row as a parameter. For us, our argument for this parameter is row 2. Line 21

This method will insert a row above the target row.

Now you might have also seen the .insertRowAfter() method and may be wondering why this was not used. These insert methods reference their formatting (i.e. Font, font colour, borders, background colours etc.) from the target row. So if we used the ‘after’ method we would have the header formatting in our cell, which is not what we want.

add data to the new row

With the new row added, we can add the data to that range.

First, we need to get the range where we will add our data. We do this with the getRange() method. This can take a number of parameter formations, but we will use the 4-integer set. These include:

Row Start – This will be the target row we set.
Column Start – All our data will begin in Column A so we set this to one.
Row Depth – We are only inserting one row of data so our depth will be one.
Column Width – The width of the range will be determined by the width of the data that we will put into it. This means that if we get the length or total count of each cell item in the row then this will be the column width.
We can do this by using the JavaScript length property. Note that we need to get the length of the inner array (data[0].length). This is done by referencing the first or zeroeth item in the array. Line 23

Now that we have our range we can set the values from our data parameter. We do this using the setValues() method. Line 24

Flush the Spreadsheet

While Google Apps Script will try and bundle your data together into one operation, a Flush can ensure that all operations on the spreadsheet are complete before any other operations are done on the sheet.

We achieve this with the SpreadsheetApp.flush() method.

runsies_example1()

This example function helps us to understand what parameters we can enter into insertRowAtTop_v1().

Here we set our target row to row 2 and the sheet name to ‘Example 1’.

For our dummy data, we will abuse the JavaScript Date constructor to generate the current date time stamp (Line 39). Then we will convert the date to a time in milliseconds with the getTime() method (Line 40).

We will then use the time as an ID, the date as, well… the date and build a dummy email from the time and a ‘@example.com’ string.

After that, add these variables into the function insertRowAtTop_v1() call parameters.

Handling The Edge of a Named Range

In this example, we have added a named range to our data range. Perhaps to make it easier to handle the data in another operation in our sheet or in our script.

However, if we were to run our script in ‘Example 1’ above on this we would find that after inserting a new row, our Named Range will change its range. It will go from ‘Example 2’!A2:C15 to ‘Example 2’!A3:C16 as you can see in our Example 2 sheet DataSet named range in the image below. Each subsequent addition to the range will add another row to the DataSet named range.

This will cause problems for us because it will miss the new data we add.

We need to fix this.

Check out the code for our updated function insertRowAtTop_v2():

/**
 * Inserts a row at the top below the header. 
 * @param {array<string>} data - 2d array [[id, date, email]]
 * @param {string} sheetName - the name of the selected sheet.
 * @param {number} targetRow - the row to insert the data in.
 * @param {string} namedRangeName - the name of the affected Named Range
 */
function insertRowAtTop_v2(data, sheetName, targetRow, namedRangeName) {
  
  // Variables
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = ss.getSheetByName(sheetName);
  const rowDepth = sheet.getLastRow() - targetRow + 3; // Add 1 to include depth + 1 for bottom space + 1 to remove the target row.
  const colWidth = data[0].length;

  // Insert a row
  // NOTE show what happens if we use insertRowAfter and how it carries over formatting from the top. 
  sheet.insertRowBefore(targetRow); // Insert a row.
  sheet // Add the data to the new row.
    .getRange(targetRow, 1, 1, colWidth)
    .setValues(data);
  sheet
    .getNamedRanges()
    .find(namedRange => namedRange.getName() === namedRangeName)
    .setRange(
      sheet.getRange(targetRow, 1, rowDepth, colWidth)
    )

  SpreadsheetApp.flush();
}

/**

* Inserts a row at the top below the header.

* @param {array<string>} data - 2d array [[id, date, email]]

* @param {string} sheetName - the name of the selected sheet.

* @param {number} targetRow - the row to insert the data in.

* @param {string} namedRangeName - the name of the affected Named Range

function insertRowAtTop_v2(data, sheetName, targetRow, namedRangeName) {

// Variables

const ss = SpreadsheetApp.getActiveSpreadsheet();

const sheet = ss.getSheetByName(sheetName);

const rowDepth = sheet.getLastRow() - targetRow + 3; // Add 1 to include depth + 1 for bottom space + 1 to remove the target row.

const colWidth = data[0].length;

// Insert a row

// NOTE show what happens if we use insertRowAfter and how it carries over formatting from the top.

sheet.insertRowBefore(targetRow); // Insert a row.

sheet // Add the data to the new row.

.getRange(targetRow, 1, 1, colWidth)

.setValues(data);

sheet

.getNamedRanges()

.find(namedRange => namedRange.getName() === namedRangeName)

.setRange(

sheet.getRange(targetRow, 1, rowDepth, colWidth)

)

SpreadsheetApp.flush();

}

Update insertRowAtTop_v2()

In this updated version we have added an extra parameter called namedRangeName. In our example, this will be the DataSet named range. Line 8

On lines 22-26, we need to update the named range, maintaining the existing row and column height, and column width but expanding its row depth.

Two new variables

Lines 13 and 14 add two new variables to our function and will be used to recalculate the range of our named range:

rowDepth: This is the last row number subtracted by the target row + 3. In the example image above our target row is row 2. The last row with data is row 14. If we subtract 14 from 2 we get 12. However, we have 13 items in our sheet and our name range also included an empty space at the bottom – Which means we need to add 2. We will also add an extra row during our process so now our formula would look like this:
14 - 2 + 3 = sheet.getLastRow() - targetRow + 3
colWidth: We will now need to get the column width twice from our data parameter. Once when we get the range and, once when we get the width of the named range. Let’s call the length property only once (data[0].length) and then reference the resulting value.

find the named range and update it

The only way we can update a named range with the SpreadsheetApp class is to first get an array of all named ranges in the spreadsheet. This is done with the getNamedRanges() method. Line 22

From here we can use the JavaScript Find method that will return the first matching item in the array. Line 23

.find(namedRange => namedRange.getName() === namedRangeName)

The Find method takes a function as an argument containing an iterator parameter that we set to namedRange. This will run through each named range in the array until it finds our desired match.

For simplicity, we are using an arrow function here.

On each iteration, we can call the getName() method on the selected named range and compare that with our namedRangeName parameter (e.g. ‘DataSet’). If there is a match Find will conclude its iteration and return the current named range.

Once we have our selected named range we can use the setRange() method to update the range (Line 25). This method takes another range construct as an argument (Line 26).

    .setRange(
      sheet.getRange(targetRow, 1, rowDepth, colWidth)

1 2	.setRange( sheet.getRange(targetRow, 1, rowDepth, colWidth)

Here we set the start row to our target row in column A and then assign our row depth and column widths we generated earlier in the function.

Including preexisting formulas into the newly inserted row

You may have a scenario where you have some formulas in your sheet that you need to add to your data row when it is added to your Google Sheet.

In our ‘Example 3’ sheet tab, we have added two formula rows to our data set in columns D and E that we want to include in our new row entries.

Let’s take a look at the updated function now:

/**
 * Inserts a row at the top below the header. 
 * @param {array<string>} data - 2d array [[id, date, email]]
 * @param {string} sheetName - the name of the selected sheet.
 * @param {number} targetRow - the row to insert the data in.
 * @param {string} namedRangeName - the name of the affected Named Range
 * @param {boolean} hasFormulas - true if formula columns must be duplicated.
 */
function insertRowAtTop_v3(data, sheetName, targetRow, namedRangeName, hasFormulas = false) {
  
  // Variables
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = ss.getSheetByName(sheetName);
  const rowDepth = sheet.getLastRow() - targetRow + 3; // Add 1 to include depth + 1 for bottom space + 1 to remove the target row.
  const colWidth = data[0].length;

  // Insert a row
  // NOTE show what happens if we use insertRowAfter and how it carries over formatting from the top. 
  sheet.insertRowBefore(targetRow); // Insert a row.

  // If the sheet has a extra formulas to add. 
  if(hasFormulas){
    const maxCols = sheet.getMaxColumns()
    const rowBelow = sheet.getRange(targetRow + 1, 1, 1, maxCols)
    const rowAbove = sheet.getRange(targetRow, 1, 1, maxCols)
    rowBelow.copyTo(rowAbove)
  }


  sheet // Add the data to the new row.
    .getRange(targetRow, 1, 1, colWidth)
    .setValues(data);
  sheet
    .getNamedRanges()
    .find(namedRange => namedRange.getName() === namedRangeName)
    .setRange(
      sheet.getRange(targetRow, 1, rowDepth, colWidth)
    )



  SpreadsheetApp.flush();
}

/**

* Inserts a row at the top below the header.

* @param {array<string>} data - 2d array [[id, date, email]]

* @param {string} sheetName - the name of the selected sheet.

* @param {number} targetRow - the row to insert the data in.

* @param {string} namedRangeName - the name of the affected Named Range

* @param {boolean} hasFormulas - true if formula columns must be duplicated.

function insertRowAtTop_v3(data, sheetName, targetRow, namedRangeName, hasFormulas = false) {

// Variables

const ss = SpreadsheetApp.getActiveSpreadsheet();

const sheet = ss.getSheetByName(sheetName);

const rowDepth = sheet.getLastRow() - targetRow + 3; // Add 1 to include depth + 1 for bottom space + 1 to remove the target row.

const colWidth = data[0].length;

// Insert a row

// NOTE show what happens if we use insertRowAfter and how it carries over formatting from the top.

sheet.insertRowBefore(targetRow); // Insert a row.

// If the sheet has a extra formulas to add.

if(hasFormulas){

const maxCols = sheet.getMaxColumns()

const rowBelow = sheet.getRange(targetRow + 1, 1, 1, maxCols)

const rowAbove = sheet.getRange(targetRow, 1, 1, maxCols)

rowBelow.copyTo(rowAbove)

}

sheet // Add the data to the new row.

.getRange(targetRow, 1, 1, colWidth)

.setValues(data);

sheet

.getNamedRanges()

.find(namedRange => namedRange.getName() === namedRangeName)

.setRange(

sheet.getRange(targetRow, 1, rowDepth, colWidth)

)

SpreadsheetApp.flush();

}

Here we have included a new optional parameter hasFormulas that is set to false by default. You can set this option to true if you wish to include formulas at the end of your row input. Line 9

Adding the formulas to the input

We have included an if condition after we created our row on lines 21-27. Here we check if the sheet has formulas at the end. If it does then get the total number of columns in the sheet with the getMaxColumns method. Line 22

Next, we need to get the ranges for the newly inserted row (rowAbove) and the row below it (rowBelow). We will add one to the row to grab the row below and apply the maxCols variable from line 22 to indicate the width of the range.

Finally, we will copy the row below in its entirety to the row above with the copyTo method.

The format for this method is as follows:

sourceRange.copyTo(destinationRange)

Without any other optional parameters, this method will copy over the formatting and the formulas from the previous range. If the formulas are not set to absolute ranges (with the $ sign) then they will adjust automatically to the new cell range.

Conclusion

While there are probably still some edge cases that these examples don’t cover, I think that they will handle the majority of scenarios that you come across. The examples should also provide you with some understanding of the workings of the code to make your own modifications where you see fit.

It’s always interesting to hear how you apply the scripts to your own projects. Feel free to comment below.

Create a Dynamic Password Generator in Google Sheets

I need to create a lot of sample data for tutorials and courses. One of the things that I needed for a recent course I am building was to generate a column containing dummy passwords in Google Sheets. Each password needed to consist of letters, numbers and characters.

Until recently, this task would have been relegated to Google Apps Script.

However, with the recent introduction of the LAMBDA function (Well, at the time of writing this anyway), we can do so much more with our Google Sheets.

Before we dive into the formula, it’s important to understand that these ‘passwords’ or random strings of characters are dynamically generated. This means every time you update a cell or reload your Google Sheet the characters in each cell will change.

So once you generate your passwords, copy the range and paste the values back in (Ctrl + c, Ctrl + Shift + v). This way only the values remain.

If you just want to grab the formula and be on your way, you can copy it from the section below. However, if you want to learn how it all works, read on for a breakdown.

Table of Contents

The Password Maker Formula

Note in the formulas below there are three parameters that you can change:

[NumChars]: The number of characters in each string in each cell.
[NumRows]: The number of rows to produce the random string of characters in.
[NumCols]: The number of columns to produce the random string of characters in.

=MAKEARRAY(
  [NumRows],
  [NumCols],
  LAMBDA(
   row_index, 
   column_index,
   JOIN(
     "",
     MAP(
       SEQUENCE(1,[NumChars]),
       LAMBDA(
         cell, 
         MID(
           "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+{[}]|\:;<,>.?/",
           RANDBETWEEN(1,91),
           1
         )
       )
     )
   )
  )
)

=MAKEARRAY(

[NumRows],

[NumCols],

LAMBDA(

row_index,

column_index,

JOIN(

"",

MAP(

SEQUENCE(1,[NumChars]),

LAMBDA(

cell,

MID(

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+{[}]|\:;<,>.?/",

RANDBETWEEN(1,91),

)

Replace the items in the square [] braces with your own values.

For example, if we wanted to generate a matrix of passwords 4 rows deep, 5 columns wide and with each cell containing 12 random characters we would do this:

=MAKEARRAY(
  4,
  5,
  LAMBDA(
   row_index, 
   column_index,
   JOIN(
     "",
     MAP(
       SEQUENCE(1,12),
       LAMBDA(
         cell, 
         MID(
           "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+{[}]|\:;<,>.?/",
           RANDBETWEEN(1,91),
           1
         )
       )
     )
   )
  )
)

=MAKEARRAY(

LAMBDA(

row_index,

column_index,

JOIN(

"",

MAP(

SEQUENCE(1,12),

LAMBDA(

cell,

MID(

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+{[}]|\:;<,>.?/",

RANDBETWEEN(1,91),

)

Matrix of passwords generated in Google Sheets

Use just numbers, numbers and letters, etc.

To quickly change the formula to produce only a certain subset of characters, you will need to delete the desired characters from the string contained in the MID function on line 14 of the example above.

You will also need to change the second argument of the RANDBETWEEN function to the length of your new string of characters.

Hint! You can quickly count the string of characters by copying the characters in the formula (including the double quotation marks on each end) and pasting it inside a LEN function. For example:

=LEN("GOAT!1234") = 9

Check out the sample sets below and their letter lengths for convenience.

Name	Character Set	Length
Numbers	“0123456789”	1o
Letters UPPER	“ABCDEFGHIJKLMNOPQRSTUVWXYZ”	26
Letters lower	“abcdefghijklmnopqrstuvwxyz”	26
Letters UPPER and lower	“ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz”	52
Alphanumeric UPPER	“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ”	36
Alphanumeric lower	“0123456789abcdefghijklmnopqrstuvwxyz”	36
Alphanumeric UPPER & lower	“0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz”	62
Characters only	“~`!@#$%^&*()_-+{[}]\|\:;<,>.?/"`	29

Formula Breakdown

In this section, we will walk through the process of creating the random string generator. Not only does this help to provide an understanding of how the formula works, but it also gives you some insight into a good workflow for building your own complex formulas in Google Sheets.

The Video

The Starter Sheet - To Play Along

If you want to get hands-on to make things more fun, grab the starter sheet from here:

RANDOM STRINGS - Starter Sheet

I'll be referring to locations in the starter sheet as a part of the walkthrough below.

The Character List

Our character list is as follows:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~!@#$%^&*()_-+{[}]|\:;<,>.?/

Place the list in a separate cell so you can reference it during testing. In the example (The Starter Sheet), I have added this to cell B2.

If you want to learn how to create a character list with a formula check out the tutorial below:

5 ways to create an ordered alphanumeric list in Google Sheets

Get the length of characters

The first thing we need to do is get the total number of characters in our list. This number will be used in another formula later.

We can do this quickly with the LEN function which gets the length of a string.

In our example I reference the string in cell B2 and apply LEN to it:

= LEN(B2) = 91

Get the total length of a string in Google Sheets with the LEN function — Click to Expand!

Select a Random Character from the String

RANDBETWEEN

We can select a random number from between 1 and 91 with the RANDBETWEEN function.

Check out this tutorial for an advanced use of RANDBETWEEN Skewed Random Range in Google Sheets (RANDBETWEEN)

This function takes two arguments, the starting value and the end value. Let’s input our range:

=RANDBETWEEN(1,91) = A random number between 1 and 91

It will dynamically return a random value between 1 and 91.

Note! The Google Sheets RANDBETWEEN function updates dynamically. This means that every time you apply a change to your sheet the random number will change.

MID

We can then use the MID function to find a character in the string at a designated position. For us, this position will be determined by the number that our RANDBETWEEN function returns.

MID takes 3 variables:

The reference string or cell.
The start index in the cell that contains the string.
The length of characters to extract.

So in our example, our formulas would look like this:

=MID(B1, RANDBETWEEN(1,91),1) = A random character from our string.

Where B1 in our example is the string of characters.

You can see in the example above that the formula randomly selected the pipe (|) characters from the string in B1.

Set a Sequence of n Columns

Let’s work on another part of the formula now. We need a way to create a string of random characters at any length we desire – we’ll call this n.

The first part of this process is to generate a row that is n cells wide.

This can be achieved with the SEQUENCE function. With this function, we can generate a range or matrix of values at any row or column width.

The SEQUENCE function takes 4 arguments:

Number of rows: For us, this will always be 1.
Number of columns: We will assign our desired n length here.
The Starting value (optional): This will always be 1 in our formula.
The Step between each value (optional): This will also always be one in our formula.

Let’s say we want to create a formula one row deep and five columns across:

=SEQUENCE(1, 5, 1, 1) = Array [1, 2, 3, 4, 5]

Map a Random Character to Each Sequence Item

Now that we have our sequence, we can map a random character to each item in the sequence. To do this we use the Google Sheets MAP function. This is a helper function of the LAMBDA function set.

The MAP function allows you to traverse an array and modify each item in the array. For us, we are going to apply a random character to each item in the sequence we generated.

MAP can take a number of arrays or ranges as its first argument and then a LAMBDA function as its last argument.

The nested LAMBDA array takes an iterator item argument. This represents the current cell the item is modifying as it works through each item in the range. We need to add this argument even if we don’t use it in our formula.

The second LAMBDA argument is the formula expression. That is, what we are doing to change the value in each of the cells.

=MAP(array,LAMBDA(iterator argument, formula expression)

For us, our first argument is our SEQUENCE, and our formula expression is our MID-RANDBETWEEN combo.

=MAP(SEQUENCE(1,5),LAMBDA(cell, MID(B1,RANDBETWEEN(1,91),1)))

Note that we can always change the second argument of the SEQUENCE to change the number of columns containing random characters.

Join the array of random characters into one password string

We can combine our random character array into a single string of characters to generate a password with the JOIN function.

JOIN takes two arguments:

The delimiter – This is the value we want to use to separate each cell item when we combine it into a string. In our example, we don’t want to separate the characters so we will leave this as an empty string.
The array – This will be the array we generated in the previous section.

=JOIN(delimiter, array)

=JOIN("",MAP(SEQUENCE(1,5),LAMBDA(cell, MID(B1,RANDBETWEEN(1,91),1))))

If you just want a single password, then this is a pretty good place to stop, but if you want a bunch of passwords across columns and rows, read on.

Generate an Array of Passwords

We can use another LAMBDA helper function for us to create an array n rows deep by n rows wide. To do this we can the MAKEARRAY function.

As the name suggests, MAKEARRAY generates a 2-dimensional array of data generated by whatever is in the contained LAMBDA function.

MAKEARRAY takes three arguments:

Number of Rows: How many passwords deep that we want to run.
Number of Columns: The total number of passwords we want to run across our Google Sheet.
The LAMBDA function: The MAKEARRAY lambda function also requires three arguments:
1. The Row Argument: We won’t use this or the Column argument, but they are mandatory for a MAKEARRAY function. We’ll call this argument row_index.
2. The Column Argument: Again, this is not needed for our password maker, but we will name this argument column_index.
3. Formula Expression: Here we can insert our password generate from the previous section.

We will also add the string data now into our entire formula. We don’t need to keep it separate.

=MAKEARRAY(
 5,
 2,
 LAMBDA(
  row_index, 
  column_index,
  JOIN(
   "",
   MAP(
    SEQUENCE(1,5),
    LAMBDA(
     cell, 
     MID(
      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+{[}]|\:;<,>.?/",
      RANDBETWEEN(1,91),
      1   
     )
    )
   )
  )
 )
)

=MAKEARRAY(

LAMBDA(

row_index,

column_index,

JOIN(

"",

MAP(

SEQUENCE(1,5),

LAMBDA(

cell,

MID(

"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()_-+{[}]|\:;<,>.?/",

RANDBETWEEN(1,91),

)

In the example above we have created an array two columns wide and five columns deep with a random password length of 5 characters (See the second argument of the SEQUENCE)..

Conclusion

This password generator is a really helpful tool for templating spreadsheets to create examples or quickly generate a password or random string of characters for codes.

As we mentioned above, the passwords will change each time you update the sheet. The best solution to provide a static password would be to use a bit of Google Apps Script Magic connected to an onEdit() function similar to this tutorial:

Add the Current Date to a Sheet When Data Is Added So That The Date Does Not Change(Static) Google Sheets (Updated January 2022)

If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.

Did you enjoy the tutorial? Want to upskill and get a solid step-by-step course to become a pro at Google Sheets? Check out my course, Google Sheets: Learn the Essentials with Three Detailed Projects. Sign up today.

Want a fast track to boost your Spreadsheet efficiency? Grab one of these handy Google Sheets Shortcuts mousepads that I created from my store.

Google Sheets Shortcuts Mousepad Gel — Google Sheets Shortcuts Mousepad Ge

~ Yagi

5 ways to create an ordered alphanumeric list in Google Sheets

For whatever reason, sometimes we just need a list of alphanumeric letters and numbers like this “0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ” to run down a column or across a row, or just all packed into one string of text in a cell in our Google Sheet.

I most commonly use an alphanumeric list to index data or use an alphanumeric string in the random assignment of a value.

In this tutorial, we will cover 4 ways to achieve this. Some approaches have different benefits than others. While two of the approaches even use the new Google Sheets LAMDA function.

If you just want to dive in, copy the formula, and get back into your own project, click on the link to the main numbered headers in the table of contents below. You can copy the formula into your project using the copy symbol in the dropdown menu of the formula bar and selecting the formula you want.

Each formula type can be:

Transposed to run across a row.
Join into a string in a cell.
Set to lowercase.
Extended to include a lowercase option.

The How it Works sections are not mandatory reading but might be helpful if you plan to extend the formula or are simply curious.

Oh, and number 1 is my favorite.

Continue reading “5 ways to create an ordered alphanumeric list in Google Sheets”

The Video

Starter Sheet

The onEdit(e) Simple Trigger

Count Every Time The Cell Changes

Set the Variables

Get the Correct Sheet Tab and Column

Update the Counter Cell

Count Every Time The Cell Changes To the Selected Value

Apply The Script to Multiple Selected Google Sheets

Get the Aggregate Count of the Changes

Conclusion

Share this:

Like this:

Share this:

Like this:

The Starter Sheet

The Video

The Basic Code to Add a Row after A Header

insertRowAtTop_v1()

Set up the function

insert a row into the sheet

add data to the new row

Flush the Spreadsheet

runsies_example1()

Handling The Edge of a Named Range

Update insertRowAtTop_v2()

Two new variables

find the named range and update it

Including preexisting formulas into the newly inserted row

Adding the formulas to the input

Conclusion

Further Reading

Share this:

Like this:

The Password Maker Formula

Use just numbers, numbers and letters, etc.

Formula Breakdown

The Video

The Starter Sheet - To Play Along

The Character List

Get the length of characters

Select a Random Character from the String

RANDBETWEEN

MID

Set a Sequence of n Columns

Map a Random Character to Each Sequence Item

Join the array of random characters into one password string

Generate an Array of Passwords

Conclusion

Share this:

Like this:

Share this:

Like this: