Google Workspace and Software Development
Google Apps Script, Google Sheets
On a recent board post, a Google Sheets user wanted to change a four-digit number (for example, 1230) to a time, like 12:30, in the same cell that the item was entered.
Unfortunately, the user was not in a position to change the starting values, so they were left with the 4 digits.
There are two ways of doing this with varying levels of complexity:
Sometimes your Google Sheet tabs can get out of hand. They can be mixed up and confusing to users. It’s often necessary to simply sort them in ascending or descending order.
In this tutorial, we will use Google Apps Script to sort tabs in Google Sheets. We’ll also use a handy menu bar to quickly run the sort.
The approach below relies on a natural sort. In a normal sort where you also have numbers say:
"2. Cheese", "10. Pizza", "1. Bananas"
Then you ran your sort, you would not get what your expected but rather:
"1. Bananas", "10. Pizza", "2. Cheese"
With a natural sort, we consider the number numerically, rather than as characters. This means our sort would come out as expected:
"1. Bananas", "2. Cheese", "10. Pizza"
You can learn more about creating the Apps Script by following the video below or you can jump down and grab a copy of your code and run it in your own project.
You can grab the starter Google Sheet Here:
Step 1: In your Google Sheet, Go to Extensions > Apps Script.
Step 2: copy the code from below and paste it into the edits and save.
Step 3: Next, reload the Google Sheet. You will see a menu item called Extras. Click it and you will see your two sort options.
Step 4: Go ahead and click an option.
You should see your tabs being sorted.
Step 5: You will be prompted to run authorisation of the script the first time the script is run. You can learn more about this here:
Step 6: Select an option again and you will see the tabs being sorted.
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
/** * Creates a menu item for ascending and descending sheet tab sort. */ function onOpen(){ const ui = SpreadsheetApp.getUi() ui .createMenu("Extras") .addItem("Sort tabs Asc","tabSorter.ascending") .addItem("Sort tabs Desc","tabSorter.descending") .addToUi() } /** * Object container to direct tab sorts for either ascending or descening order. */ const tabSorter = { ascending: function(){this.sortTabs(true)}, descending: function(){this.sortTabs(false)}, /** * Naturally sort tabs. This means where there are number, * the sort will order them in numerical order. e,g, 1, 2, 10, "Car", "Goat" * @param {boolean} isAscending - if true will sort ascending, otherwise descending. */ sortTabs: function(isAscending){ const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheets = ss.getSheets(); // Enable language sensitive string comparison. // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator const collator = new Intl.Collator(undefined, { numeric: true, // Sets numeric collation so 1 < 2 < 10 sensitivity: 'base' // Ignores accents and other diacritic marks in lettering. }); // Sorts the sheet. let sheetNames = sheets.sort((a,b) => { // Compares first sorted sheet name value against last sorted sheet name value. return collator.compare(a.getName(), b.getName()) }) // If set to descending the sheetNames lists is ignored. sheetNames = (!isAscending)? sheetNames.reverse(): sheetNames; // Iterates through each sheet sets it to activve and updates it order. sheetNames.forEach((sheet, idx) => { ss.setActiveSheet(sheet) ss.moveActiveSheet(idx + 1) // Sheet tab indexes start from one so we must add one. }); } }; |
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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
/** * Creates a menu item for ascending and descending sheet tab sort. */ function onOpen(){ const ui = SpreadsheetApp.getUi() ui .createMenu("Extras") .addItem("Sort tabs Asc","tabSorter.ascending") .addItem("Sort tabs Desc","tabSorter.descending") .addToUi() } |
The onOpen() function is a Google Apps Script simple trigger that runs automatically when the user opens the Google Sheet.
Line 5: In our example, we call the Spreadsheet App UI class, so that we can build the menu.
Line 8: To create a menu we use the Create Menu method and add the menu label “Extras” as an argument.
Lines 9-10: Next, we can add menus to the main menu header with the Add Item method. These menus take a menu label and then a function or an object method that will run when the menu is selected. Ensure that you don’t include parentheses in these arguments and contain them in a string.
Line 11: Finally, we need to build the menu by adding all the menu items to the UI.
You can learn more about building menus in Google Sheets, Docs and Slides here:
The tabSorter object contains 3 properties:
ascendingdescendingsortTab|
1 2 3 4 5 6 7 8 |
const tabSorter = { ascending: <em>method</em>, descending: <em>method</em>, ... sortTabs: <em>method</em> ... |
Both of these property methods run the sortTabs method providing either true for ascending or false for descending as the argument.
We need to encapsulate these method calls inside their own anonymous functions so that they don’t run automatically when the menu is loaded.
ascending: function(){this.sortTabs(true)},
descending: function(){this.sortTabs(false)},
The sortTabs property does all the heavy lifting in this object.
It takes a boolean as an argument that will determine if the sort is ascending or descending.
|
1 2 3 |
const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheets = ss.getSheets(); ss.sheet |
Our first task is to get an array containing all the Google Sheets in the currently active sheet. We can do this with the SpreadSheet App Get Sheets method. This will contain an array with all the methods available for each found sheet tab.
We want to sort our sheet tabs naturally just in case we have numbers in the name of the tab (e.g. “1”, “2”, “4. Cake”). We can do this with the JavaScript Intl.Collator object to sort the sheet tabs in a natural order, meaning that numeric values are sorted in numerical order and text values are sorted alphabetically. You can modify this function to use a different sorting algorithm or change the sorting order.
|
1 2 3 4 |
const collator = new Intl.Collator(undefined, { numeric: true, // Sets numeric collation so 1 < 2 < 10 sensitivity: 'base' // Ignores accents and other diacritic marks in lettering. }); |
Line 2: Here, we create a new Intl.Collator constructor. The first optional parameter of the constructor defines the locale or language tab. We don’t need this option, so we set it to ‘undefined’.
The second parameter sets the options for the collator.
Line 3: First, we use the numeric property and set it to true. This will allow us to order the numbers properly so that 1 < 2 <10.
Line 4: Secondly, we set the sensitivity to base. This means that we do not take into account any accents or other markings on letter characters. If you are using this Google Sheets sort tab code in other languages, then you might want to modify this.
Now that we have our collator set up we use the JavaScript sort method to sort through the array of sheet names.
|
1 2 3 4 5 |
// Sorts the sheet. let sheetNames = sheets.sort((a,b) => { // Compares first sorted sheet name value against last sorted sheet name value. return collator.compare(a.getName(), b.getName()) }) |
Line 2: Here, we use an arrow function with a standard a, b parameter set. These parameters refer to the first and second elements of comparison respectively.
Line 3: Use our collator and apply the compare method to compare the sheet names against each other.
|
1 2 |
// If set to descending the sheetNames lists is ignored. sheetNames = (!isAscending)? sheetNames.reverse(): sheetNames; |
If isAscending parameter of the sortTabs method is set to false, then we use JavaScript reverse() to reverse the array order of the sheetNames.
Finally, once our array is in the desired order we need to update the Google Sheet with the new tab order.
|
1 2 3 4 5 6 7 |
// Iterates through each sheet sets it to activve and updates it order. sheetNames.forEach((sheet, idx) => { ss.setActiveSheet(sheet) ss.moveActiveSheet(idx + 1) // Sheet tab indexes start from one so we must add one. }); |
Line 2: First, we loop through the sheet names array with the JavaScript forEach() method.
Line 3: Inside each loop, we need to set the active sheet to the currently iterated sheet.
Line 4: Finally, we move the active sheet to the next position in the sheet tabs. Note that sheet indexes start from one (1) however our array index starts from zero (0). This is why we need to add one to the index.
That’s all there is to it.
If you want to learn more about how to modify Google sheets tabs with Apps Script, check out these tutorials:
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
Using the Spreadsheet App Class’ Text Finder Class to find and hide rows in Google Sheets containing target text in a cell can be a fast way to hide values. In many situations, this may be a faster way to hide rows based on cell value in Google Sheets with Google Apps Script than iterating through a range and extracting rows.
In this tutorial, we will cover 3 approaches to using the Text Finder class to hide rows. Each may be useful in its own circumstances.
This tutorial accompanies the YouTube video series of the same name. You can find the links to each of the related videos in each of the sections along with the starter Google Sheets so that you can play along.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
/** * Hide or unhide all rows that contains the selected value. * Single sheet * @param {string} text - the text to find. * @param {string} sheetName - the target sheet. * @param {boolean} [isHide] - True to hide false to show. */ function hideAllRowsWithVal(text, sheetName, isHide = true) { const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const textFinder = sheet.createTextFinder(text); const allOccurrences = textFinder.findAll(); allOccurrences.forEach(cell => { const row = cell.getRow(); if (isHide) { sheet.hideRow(row); } else { sheet.showRows(row); } }) }; |
Unlike when formatting rows and cell activation, – as we did in the previous tutorial – our fasted approach here is to hide and unhide sheets while looping through all the found cells.
In this basic approach, our function contains 3 parameters:
text – The text to search.sheetName – The sheet name to search.isHide – An optional argument set to true by default to hide values or false manually to unhide them.Lines 10-11 – We first collected our current Google Sheet workbook and then select the sheet tab we will be working in.
Lines 13-14 – Then we use the Text Finder class in the Spreadsheets App to search for our target text and then use the findAll() method to get an array constructor of all the found value cell ranges. You can learn more about this in the first tutorial in this series here:
Line 16 – Next we iterate through each found row with a JavaScript forEach() loop.
Line 17 – On each iteration, we collect the row number. We do the same thing here in our previous tutorial when activating and formatting entire rows.
Lines 19-23 – Lastly we need to check if the user has set isHide to false to show the rows or true (or not used) to hide the row. We then call the sheet and apply either the Spreadsheets Apps Hide Rows (hideRows()) method or (showRows()) Show Rows method. These methods can take a single row as an argument. We provide this with the row variable.
This is a quick and easy solution to understand. However, it does not perform well with a large dataset. It will also try and hide rows multiple times when a found cell is on the same row as a previously found cell.
The function, just like the other two examples, can be called from another function with:
hideAllRowsWithVal(text, sheetName, boolean)
e.g.:
hideAllRowsWithVal("koala", "Sheet1", true)
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
Released Monday 12 Feb 2023. Subscribe (Top right) to get a notification for when this video comes out.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
/** * Hide or unhide all rows that contains the selected value. * Single sheet * Collects adjacent rows into one range before hiding or unhiding. * @param {string} text - the text to find. * @param {string} sheetName - the target sheet. * @param {boolean} [isHide] - True to hide false to show. */ function hideAllRowsWithVal_v2(text, sheetName, isHide = true) { const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); // Find all matching values. const textFinder = sheet.createTextFinder(text); const allOccurrences = textFinder.findAll(); /** * Hides or shows the desired range. * @param {Object} setRange - {startRow, endRow} */ function hideRange(setRange) { if (isHide) { sheet.hideRows(setRange.startRow, setRange.numRows); } else { sheet.showRows(setRange.startRow, setRange.numRows); }; }; // Iterates throuhg each row and combines them into ranges. let rowRange = { startRow: null, numRows: null } allOccurrences.forEach((cell, idx) => { const row = cell.getRow(); const lastRowRangeRow = rowRange.startRow + rowRange.numRows; if (idx === 0) { // If on the first iteration. OR rowRange.startRow = row; rowRange.numRows = 1; } else if (lastRowRangeRow - 1 === row){ // If the the current row is the same as the previous. Skip this row. return; } else if (lastRowRangeRow === row) { // If the next row number is equal to the sum of the start row and number of rows to count. ++rowRange.numRows; // If this is the last row in the range if (idx === allOccurrences.length - 1) { hideRange(rowRange); }; } else { // If the new row is not part of the previous range. hideRange(rowRange); rowRange.startRow = row; rowRange.numRows = 1; // If this is the last row in the range if (idx === allOccurrences.length - 1) { hideRange(rowRange); }; } }) SpreadsheetApp.flush(); }; |
In larger, ranges we might have a lot of situations where our found text is on multiple adjacent rows.
In the image above, we can see that rows 30 and 31, 38-43, and 46-49 can all be batched together into a single range.
Furthermore, rows with the found text (Koala) on the same row can be ignored, the consecutive times that they are found.
Let’s go ahead and fix our code to make it more efficient.
Note that lines 9-16 of the code are the same as the previous function. Refer to this for an explanation.
Line 22 – After we have collected our ranges of found rows we will create a hideRange() method. This will either hide or show the range based on the isHide argument.
This function takes a single object parameter that contains a start row and a number of rows.
Lines 24 – 26 – Unlike the previous version, we use the Hide Rows and Show Rows extra parameter to include the number of rows deep to hide.
Lines 32 – 35 – This mutable variable stores the start row and row depth as we collected each range of rows to hide in our sheet.
Line 37 – Here, we start the forEach loop that iterates through each found cell range. We include the index (idx) in our arguments in our arrow function as well here.
Line 39 – Next, we grab the row number with the Get Row (getRow()) method.
Line 40 – Then we get the next possible row in the current range collection by adding the start row with the row depth. This will be used in a moment ot compare against the currently iterated row.
Lines 42-46 – On our first loop through our found cells, all we need to do is add our first found row and add one to our depth.
Lines 47-51 – If there is another cell on the same row, then we don’t need to do anything and we simply return the function for that iteration.
Lines 52-55 – If the next found row is only one cell down (adjacent), then we just want to add one to the number of rows of the existing rowRange variable.
Lines 57-60 – If the row is the last found row, then we can run the hideRange function on our update range set.
If the next found row is not directly below the previous one. We need to:
hideRange on the current rowRange variable set.rowRange variable adding in the current row to the start range and one to the depth.Lines 69-71 – Again, if we are on the last found row, we can just run hideRow to end the loop.
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.
Released Thursday 13 Feb 2023. Subscribe (Top right) to get a notification when this video comes out.
I found version two to be remarkably efficient. However, if you want to do a lot of editing to the sheet tab then you might want to consider using the Google Apps Script Advanced Sheet Service API.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
/** * Hide or unhide all rows that contains the selected value. * Single sheet * Uses Google Sheets Advanced Service Batch Update. * @param {string} text - the text to find. * @param {string} sheetName - the target sheet. * @param {boolean} [isHide] - True to hide false to show. */ function hideAllRowsWithVal_v3(text, sheetName, isHide = true){ const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const sheetId = sheet.getSheetId() const ssId = ss.getId(); // Find all matching values. const textFinder = sheet.createTextFinder(text); const allOccurrences = textFinder.findAll(); // Build Requests for Batch Update let requests = [] /** * Appends each request to the requests array. * @param {Object} setRange - {startRow, endRow} */ function appendRequest(setRange){ requests.push({ 'updateDimensionProperties': { "range": { "sheetId": sheetId, "dimension": 'ROWS', "startIndex": setRange.startRow - 1, "endIndex": setRange.endRow, }, "properties": { "hiddenByUser": isHide, }, "fields": 'hiddenByUser', }}) }; // Iterates throuhg each row and combines them into ranges. let rowRange = { startRow: null, endRow: null } allOccurrences.forEach((cell, idx) => { const row = cell.getRow(); if (idx === 0) { // If on the first iteration. OR rowRange.startRow = row; rowRange.endRow = row; }else if (rowRange.endRow === row){ // If the the current row is the same as the previous. Skip this row. return; } else if (rowRange.endRow === row - 1) { // If the next row number is equal to the sum of the start row and number of rows to count. ++rowRange.endRow; // If this is the last row in the range if (idx === allOccurrences.length - 1) { appendRequest(rowRange); }; } else { // If the new row is not part of the previous range. appendRequest(rowRange); rowRange.startRow = row; rowRange.endRow = row; // If this is the last row in the range if (idx === allOccurrences.length - 1) { appendRequest(rowRange); }; } }) Sheets.Spreadsheets.batchUpdate({requests: requests}, ssId) } |
We need to add a few more variables to our main variables here.
Line 12 – We will need to get the spreadsheet ID to use in our batch update.
Line 13 – The sheet name does not work the same as an identifier in the advanced service, so we will need to extract the sheet ID too.
Line 21 – The Sheets batch request property requires a list of requests as its value. Here we will store an array of all the requests that we want to batch together to hide each row range of the Google Sheet.
Line 27 – The appendRequest(setRange) function pushes a new request to the requests property.
When hiding and displaying rows or columns in a Google Sheet with the Advanced Service we are updating a dimension property. These properties can be a number of different field types, but for us, we want to hide rows.
Let’s take another look at the layout of this JSON object:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
{ 'updateDimensionProperties': { "range": { "sheetId": sheetId, "dimension": 'ROWS', "startIndex": setRange.startRow - 1, "endIndex": setRange.endRow, }, "properties": { "hiddenByUser": isHide, }, "fields": 'hiddenByUser', } } |
Lines 3-8 – The first sub-property is the range object. This object requires a sheet ID. The dimension is either the columns or rows.
Then we need to set the start index. Note that the cell ranges will start from zero instead of 1. We must then subtract 1 from our start row to get the correct start index of our row range.
Finally, we set the end row. This will be one row after our desired end row. Think, ‘up to, but not including this row’.
Lines 9-11 – Next, we identify the property that we want to change. For hiding and showing rows this is the "hiddenByUser" property, where the value is a boolean. This conveniently fits with our ishide parameter.
Line 12 – Weirdly, we then need to declare that we are using the "hiddenByUser" property by adding it to the fields list.
Lines 46-49 – Just like the previous version, we need to store each range before sending it to appendRequest(). Unlike the previous version, our last property is the end row rather than the number of rows.
Lines 52-54 –Now we can commence our loop through the found cells.
Here, the first task is to collect all the row numbers.
Lines 56-60 – On the first loop of our cell array, we just want to add the current row number to the start and end row of rowRange.
Lines 61 – 65 – If we have more than one result on the same row we want to ignore it and return the current loop.
Line 69 – We add one to our end row value in rowRange.
Lines 72-74 – If we are on our last found row, send it to appendRequest().
Line 77 – If the current row is not the next row down then we send appendRequest() with our current rowRange.
Lines 79-80 – Next, we create a new rowRange.
Line 83-85 – If the current row is the last row in the array, we sent it to appendRequest().
Line 90. Here we use the batch request of the spreadsheet resource. The batch request takes an object with a requests property. This property, in turn, requires an array of JSON object requests.
For its second argument, we reference the Spreadsheet ID.
If you know that there may not be any matches in your text finder then you might wish to add a return agent after the allOccurrences variable:
if(allOccurences.length === 0) return;
Another good measure might be to use a try/catch statement in the third version when running the batch call, just in case there is an error with the API server.
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
~ Yagi
In this tutorial, we create 3 Google Apps Script functions that are used to:
You can grab a copy of the starter Google Sheet to play along here:
Find & Select or Format Rows – Tutorial
This tutorial accompanies the YouTube video of the same name:
All functions are built to be run from another function, making it easy for you to integrate them into your own projects.
For our example, we will use the runies function for this purpose.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
function runsies() { const text = "koala"; const sheetName = "Animalz!"; // selectFirstRowWithVal(text, sheetName); // selectAllRowsWithVal(text, sheetName); const sheetName1 = "Animalz! Format" // formatAllRowsWithVal(text, sheetName1) }; |
All three of the examples below take two arguments as parameters:
text – the search text.sheetName – the Name of the selected sheet tab.These functions rely on the Apps Script Spreadsheet App Text finder class to search for the target text within the range.
All examples search a selected sheet tab. However, you can easily modify the script to search a specific range or the entire Google Sheets workbook. You can learn more about how to do this here:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/** * Selects the row that contains the first found value. * Single sheet * @param {string} text - the text to find. * @param {string} sheetName - the target sheet. */ function selectFirstRowWithVal(text, sheetName) { console.log(text, sheetName) const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const textFinder = sheet.createTextFinder(text); const cell = textFinder.findNext(); // const cell = textFinder.findPrevious(); const row = cell.getRow(); sheet .getRange(`A${row}:${row}`) .activate(); }; |
Lines 10-12 – In this scenario, we activate the first (findNext()) or last (findPrevious())found row based on a search item that can be found anywhere in the row. We then store this cell range in the cell variable.
Line 17 – From the cell variable, we can select the Spreadsheet App Range getRow() method to get the row number of the cell.
Line 19-21 – Next, we can activate the range of the selected row using the activate method.
We set the entire range by using A1-notation here within a template literal (that is a string within backticks ()). In Google Sheets, we can set the full width of a sheet by leaving the last column value blank in the notation, for example:
A1:1 or even 1:1.
Incidentally, you can also select a portion of the width by including an end letter in the range, for example:
A1:K1 or in the script .getRange(A${row}:K${row}`)
You can learn more about selecting the first or last found values in this tutorial:
Find first, last or nth value in a Google Sheets range with Apps Script
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
/** * Select all rows that contains the selected value. * Single sheet * @param {string} text - the text to find. * @param {string} sheetName - the target sheet. */ function selectAllRowsWithVal(text, sheetName) { const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const textFinder = sheet.createTextFinder(text); const allOccurrences = textFinder.findAll(); const ranges = allOccurrences .map(item => `A${item.getRow()}:${item.getRow()}`); sheet.getRangeList(ranges).activate(); }; |
In this example, we select all of the rows containing the target search value.
Line 13 – First, we modify the Text Finder variable to the findAll method and rename the variable. This will return an array of all the cells where the values are found as an array.
Lines 15-16 – Now, we can map over each item in the array creating a new array of ranges that contain A1-notation of the selected row.
Line 18 – Finally, we can use the Spreadsheet App Sheet Class getRangeList() method to collect all ranges in our array and then activate them.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/** * Format all rows that contains the selected value. * Single sheet * @param {string} text - the text to find. * @param {string} sheetName - the target sheet. */ function formatAllRowsWithVal(text, sheetName) { const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const textFinder = sheet.createTextFinder(text); const allOccurrences = textFinder.findAll(); const ranges = allOccurrences .map(item => `A${item.getRow()}:${item.getRow()}`); sheet.getRangeList(ranges) .setBackground('#0b5394') .setFontColor('white') .setFontWeight('bold') }; |
This last function is virtually the same as the previous one. However, we are doing something much more useful, we are programmatically updating the format of the selected rows.
Lines 18-21 – Using the getRangeList method, we can modify the formatting of any range in the list. In our example, we set the background of the row to a dark blue, changed the text colour to white and bolded the font.
Here is a list of common formatting methods that you can apply to a range list:
clearFormat() – Clears the formatting of the selected range.setBackgroundColor(colour) – Use CSS notation like hexadecimal colours, colour names or RGB colourssetFontColor(colour)– Use CSS notation like hexadecimal colours, colour names or RGB colours.setFontWeight(type) – Either “bold” or “normal”.setFontSize(size) – The font size as a number.setFontStyle(style) – The style, e.g. “Helvetica”, “Poppins”.setVerticalAlignment(alignment) – “top”, “middle” or “bottom”.setHorizontalAlignment(alignment) – “left”, “center”, “right”.setTextRotation() – Sets the rotation of the text in each cell in degrees from the original horizontal plain.In the next tutorial, we will cover how to hide and unhide rows based on found values in a range. The process is a little different, so well worth checking out.
Subscribe to get an email when the next tutorial in this series comes out or get regular updates on my latest tutorials.
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
~Yagi
Inspired by research into a recent blog post, the Google Apps Script Text Finder Class’ Find All (findAll()) and Find Next (findNext()) methods were benchmarked over two different datasets containing 50,000 rows. The first dataset contained 1,000 cells matching the search text. The second dataset contained 100 matching cells.
For each dataset, a test was conducted to retrieve either the first 10 matching cells or the first 100 matching cells. The Find All and Find Next approaches were tested and compared on each test.
It was expected that Find Next would perform best on the condition where the dataset contained a large number of found items and only a small number of first cells needed to be reported. The benchmark results suggest that this hypothesis is most likely.
Table: The average time in milliseconds of 100 runs of each test of Apps Script Text Finder findAll() and findNext() methods. Image link for mobile-friendly viewers.
Two columns of data 50,000 rows deep were generated for this test. Each cell in each column consisted of a number; either 1, 2, 3, 4 or 5. An equal spread of numbers 1 through 4 where added to each row. Each column differs by the number of 5s in each row:
Each column was then selected and randomised with: Data > Randomise range.
Two functions are compared to test their performance based on four test conditions based on 100 runs of each test:
The time in milliseconds was recorded using the JavaScript Date.now() method before and after the functions were run. The difference in time in milliseconds was then appended to an array and added to a Google Sheet column for each test type. This culminated in 8 sets of 100 results.
The average of each test was then recorded and used to compare performance.
Note: Performance.now() is not available in Google Apps Script.
All code and results can be found copied from this sheet:
Analysis of Google Apps Script Create Finder Class Retrieve n found values
To explore the code and run your own independent tests, make a copy of the Google Sheet: File > Make a copy.
More detailed breakdowns of the code for each test function can be found in the source tutorial.
Note! There is no v1. The version numbers refer to the tutorial related to this post.
This function ran all the test conditions. Modify colPastePosition to add the culminated times to the desired columns. Then uncomment the desired run.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
function testRun(){ const sheetName = "Test Data" const text = 5; const n_small = 10; const n_big = 50; const rangeLoc_1000items = "A2:A"; const rangeLoc_100items = "B2:B"; let start, end const colPastePosition = 10; const times = []; for(let i = 0; i < 100; i++){ start = Date.now(); // Test 1: 1000 items to find. Return first ten, V2. const results = test_v2(sheetName, text, n_small, rangeLoc_1000items); // // Test 2: 1000 items to find. Return first ten, V3. // const results = test_v3(sheetName, text, n_small, rangeLoc_1000items); // // Test 3: 1000 items to find. Return first 50, V2. // const results = test_v2(sheetName, text, n_big, rangeLoc_1000items); // // Test 4: 100 items to find. Return first 50, V3. // const results = test_v3(sheetName, text, n_big, rangeLoc_1000items); // // Test 5: 100 items to find. Return first ten, V2. // const results = test_v2(sheetName, text, n_small, rangeLoc_100items); // // Test 6: 100 items to find. Return first ten, V3. // const results = test_v3(sheetName, text, n_small, rangeLoc_100items); // // Test 7: 100 items to find. Return first 50, V2. // const results = test_v2(sheetName, text, n_big, rangeLoc_100items); // // Test 8: 100 items to find. Return first 50, V3. // const results = test_v3(sheetName, text, n_big, rangeLoc_100items); end = Date.now(); times.push([end - start]) } SpreadsheetApp.getActiveSpreadsheet() .getSheetByName("Test") .getRange(6,colPastePosition,100,1) .setValues(times) } |
Code breakdown can be found here: link.
This function retrieves the full list of all found cells using the findAll() method from the Text Finder Class. All available found items in the range are then stored in the found variable.
It then relies on a for-loop to iterate through each cell and collect the cell location using the Spreadsheet App Class’ range getA1Notation method. Each cell location is then stored in the locations variable as an array item before returning the array to the initialising function.
The for-loop breaks when the total number of required cell items (the position) equal the index variable (i) in the loop.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
/** * Finds the first set of matching cells of n in length or less. * @param {string} sheetName - the name of the sheet tab. * @param {string|number} text - text to search. * @param {number} n - the max number of items to report. * @param {string} rangeLoc - A1- Notation of selected range. * @return {array} - Array of cell positions of the found match. */ function test_v2(sheetName, text, n, rangeLoc){ const position = n - 1; const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const range = sheet.getRange(rangeLoc) const found = range.createTextFinder(text) .findAll(); let locations = []; for(let i = 0; i < found.length; i++){ const cell = found[i]; locations.push(cell.getA1Notation()) if( i === position) break; } return locations; } |
Code breakdown can be found here: link.
In this function, a call is made to the spreadsheet to retrieve the found cell value each time findNext() method of the Text Finder Class is called. On each iteration, the getA1Notation method is used to retrieve the cell location. This location is then stored as an array value in the locations variable before being returned to the initiating function.
The function used a while-loop to iterate through each next item found until the counter – or the number of required cells to collect – is reached.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
/** * Finds the first set of matching cells of n in length or less. * @param {string} sheetName - the name of the sheet tab. * @param {string|number} text - text to search. * @param {number} n - the max number of items to report. * @param {string} rangeLoc - A1- Notation of selected range. * @return {array} - Array of cell positions of the found match. */ function test_v3(sheetName, text, n, rangeLoc){ const ss = SpreadsheetApp.getActiveSpreadsheet(); const sheet = ss.getSheetByName(sheetName); const range = sheet.getRange(rangeLoc) const finder = range.createTextFinder(text) let locations = []; let counter = n; while(counter > 0){ let found = ""; found = finder .findNext() .getA1Notation(); locations.push(found); --counter; }; return locations }; |
Version 3 –findNext() performed better on average when there were 1000 potential items to find in the range but only the first 10 items need to be selected. Versions 3’s average speed was 1368.45ms compared to version 2’s average run speed of 1826.24ms. This is a performance increase of 257.79ms for version 3.
Version 2’s lower performance is likely due to needing to collect all available found cells before it can extract the top 10 items.
Version 3, makes 10 calls to the Google Sheets in this example. Compared to version 2, this takes relatively less time than collecting all available found cell references to the search item.
Version 2 – findAll() performed significantly better over 100 runs than version 3 when retrieving the top 50 found cells from a possible 1000. Version 2 was, on average, 4993.61ms faster at an average runtime of 1578.19ms compared to version 3’s sluggish 6571.80ms average.
It was expected that test one and test two’s times for version 2 would be similar and there are only 48.05ms between their average runtimes.
Version 3’s poor performance is likely due to its reliance on calling the spreadsheet to collect the cell data on all 50 calls it needs to make.
Version 2, again, performed better by 975.16ms than version 3 when there was a smaller potential number of items to find in the range and only the first ten items need to be retrieved.
Here the performance margin between the two versions was closer than in the previous test. Version 2’s average run speed was 360.94ms while version 3’s runtime was 1336.10ms.
With a smaller number of retrieved items, the version 2 findAll() function did not have to work as hard to collect the methods related to each range it collects. Whereas version 3 still needed to make 10 performance-intensive calls back to the Google Sheet each time with relatively no performance change to test one.
Predictably, version 2 – findAll() performed the best when the expected match sample is small (100 available matches) and the total first set of cells to retrieve was relatively large (50).
Version 2’s average completion time was 377.13ms compared to version 3’s average of 6552.72ms, performing on average 6175.59ms faster. This is by far the largest margin on performance between the two versions.
Here again, version 3 must perform 50 calls to the Google Sheet, each one retrieving the cell range data. Alternatively, version 2 makes one call to the spreadsheet and then retrieves the cell data for all collected values. This is significantly faster than version 3’s approach.
On datasets that may have the potential to contain a large number of matching items, but fewer required results to return, version 3 may be the best option. In all other cases, version 2 is the most optimal approach to finding data in a range.
It is important to note that it can be difficult to accurately measure performance with Apps Script runs because resource allocation to run a script does seem to vary. Nevertheless, with a sample size of 100 runs, it is hoped that average values will be more accurate than a smaller sample.
Grab Your Own Copy of the Google Sheet and Attached Code here
If you have found the tutorial helpful, why not shout me a coffee ☕? I'd really appreciate it.
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.
~Yagi
