我有一张表，其中包含 cols 中的A数据H。
我需要确定A包含数据的列中的最后一行（它都是连续的 - 数据/行中没有间隙）。
其他列中的数据也有比列多的数据行A，所以我只需要隔离列A。（和/或只是 col 内的一个范围A）。
我可以在电子表格级别使用
=COUNTA(A2:A100)
然而，在我对 Google Apps 脚本解决方案的所有研究中，我似乎发现的只是执行包含数十行代码的多个功能的要求 - 包括大量的i++东西......我可以通过直接从A1.
是否存在修改此方法的特定于列的方法？
var aLast = ss.getDataRange().getNumRows();
如果需要一个复杂的过程，那就这样吧。但我发现很难想象（甚至更难找到！）更简单的解决方案。
有没有人愿意启发我（或弹出我的泡泡）？
使用 JavaScript 技巧怎么样？
var Avals = ss.getRange("A1:A").getValues();
var Alast = Avals.filter(String).length;
我从这个答案中借用了这个想法。该Array.filter()方法对Avals数组进行操作，该数组包含 A 列中的所有单元格。通过过滤本机函数的构造函数，我们只返回非空元素。
这仅适用于单列；如果范围包含多列，则结果filter()将包括所有列中的单元格，因此超出范围的填充维度。
假设基于 A 列，这将获得工作表中的最后一行。
function getLastDataRow(sheet) {
var lastRow = sheet.getLastRow();
var range = sheet.getRange("A" + lastRow);
if (range.getValue() !== "") {
return lastRow;
} else {
return range.getNextDataCell(SpreadsheetApp.Direction.UP).getRow();
}
}
这修复了@mrityunjay-pandey 部分正确的答案。
要扩展此答案以获取最后一行和最后一列，我们可以使用：
function columnToLetter(column) {
var temp, letter = '';
while (column > 0) {
temp = (column - 1) % 26;
letter = String.fromCharCode(temp + 65) + letter;
column = (column - temp - 1) / 26;
}
return letter;
}
function letterToColumn(letter) {
var column = 0, length = letter.length;
for (var i = 0; i < length; i++) {
column += (letter.charCodeAt(i) - 64) * Math.pow(26, length - i - 1);
}
return column;
}
function getLastDataColumn(sheet) {
var lastCol = sheet.getLastColumn();
var range = sheet.getRange(columnToLetter(lastCol) + "1");
if (range.getValue() !== "") {
return lastCol;
} else {
return range.getNextDataCell(SpreadsheetApp.Direction.PREVIOUS).getColumn();
}
}
function getLastDataRow(sheet) {
var lastRow = sheet.getLastRow();
var range = sheet.getRange("A" + lastRow);
if (range.getValue() !== "") {
return lastRow;
} else {
return range.getNextDataCell(SpreadsheetApp.Direction.UP).getRow();
}
}
function run() {
var sheet = SpreadsheetApp.getActiveSheet();
var [startRow, lastRow] = [2, getLastDataRow(sheet)];
var [startCol, lastCol] = [1, getLastDataColumn(sheet)];
}
虽然没有直截了当的公式，但我能想到，不需要几十行代码就能找出 A 列的最后一行。试试这个简单的函数。以正常方式在单元格中使用它，就像使用其他功能一样=CountColA()
function CountColA(){
var sheet = SpreadsheetApp.getActiveSheet();
var data = sheet.getDataRange().getValues();
for(var i = data.length-1 ; i >=0 ; i--){
if (data[i][0] != null && data[i][0] != ''){
return i+1 ;
}
}
}
var Direction=SpreadsheetApp.Direction;
var aLast =ss.getRange("A"+(ss.getLastRow()+1)).getNextDataCell(Direction.UP).getRow();
正如lopezvit所提到的，根据文档，getNextDataCell 类似于转到给定范围并按 ctrl（命令）+ 箭头键。所以这是可行的，因为它进入了 las 可能的行，添加一个（向下箭头）然后 ctrl + UP，所以它肯定会得到最后一行的一些内容。唯一可以改进的是检查最后一个单元格 + 1 是否大于最大单元格，并为这种情况制定特定的逻辑。
接受的答案以及大多数答案（如果不是全部）都有一个共同的限制，对于问题的所有者（他们有连续的数据）可能不是这种情况，但对于未来的读者来说。
例如，考虑这个非常简单的场景：
接受的解决方案会给出4，而正确的答案是6.
使用reverse方法查找从数组末尾开始的第一个非空值的索引。
const ss = SpreadsheetApp.getActive();
const sh = ss.getSheetByName('Sheet1')
const lrow = sh.getLastRow();
const Avals = sh.getRange("A1:A"+lrow).getValues();
const Alast = lrow - Avals.reverse().findIndex(c=>c[0]!='');
我希望发布替代答案永远不会太晚。这是我查找最后一个单元格的片段。我主要对速度感兴趣。在我使用大约 150,000 行的数据库上，这个函数需要（平均）0.087 秒来找到解决方案，而上面的@Mogsdad 优雅 JS 解决方案需要（平均）0.53 秒处理相同的数据。两个数组都是在函数调用之前预加载的。它利用递归进行二分查找。对于 100,000+ 行，您应该会发现返回结果不超过 15 到 20 跳。
我已经保留了 Log 调用，因此您可以先在控制台中对其进行测试并查看其工作原理。
/* @OnlyCurrentDoc */
function myLastRow() {
var ss=SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
var colArray = ss.getRange('A1:A').getDisplayValues(); // Change to relevant column label and put in Cache
var TestRow=ss.getLastRow();
var MaxRow=ss.getMaxRows();
Logger.log ('TestRow = %s',TestRow);
Logger.log ('MaxRow = %s',MaxRow);
var FoundRow=FindLastRow(TestRow,MaxRow);
Logger.log ('FoundRow = %s',FoundRow);
function FindLastRow(v_TestRow,v_MaxRow) {
/* Some housekeeping/error trapping first
* 1) Check that LastRow doesn't = Max Rows. If so then suggest to add a few lines as this
* indicates the LastRow was the end of the sheet.
* 2) Check it's not a new sheet with no data ie, LastRow = 0 and/or cell A1 is empty.
* 3) A return result of 0 = an error otherwise any positive value is a valid result.
*/
return !(colArray[0][0]) ? 1 // if first row is empty then presume it's a new empty sheet
:!!(colArray[v_TestRow][0]) ? v_TestRow // if the last row is not empty then column A was the longest
: v_MaxRow==v_TestRow ? v_TestRow // if Last=Max then consider adding a line here to extend row count, else
: searchPair(0,v_TestRow); // get on an find the last row
}
function searchPair(LowRow,HighRow){
var BinRow = ((LowRow+HighRow)/2)|0; // force an INT to avoid row ambiguity
Logger.log ('LowRow/HighRow/BinRow = %s/%s/%s',LowRow, HighRow, BinRow);
/* Check your log. You shoud find that the last row is always found in under 20 hops.
* This will be true whether your data rows are 100 or 100,000 long.
* The longest element of this script is loading the Cache (ColArray)
*/
return (!(colArray[BinRow-1][0]))^(!(colArray[BinRow][0])) ? BinRow
: (!(colArray[BinRow-1][0]))&(!(colArray[BinRow][0])) ? searchPair(LowRow,BinRow-1)
: (!!(colArray[BinRow-1][0]))|(!!(colArray[BinRow][0])) ? searchPair(BinRow+1,HighRow)
: false; // Error
}
}
/* The premise for the above logic is that the binary search is looking for a specific pairing, <Text/No text>
* on adjacent rows. You said there are no gaps so the pairing <No Text/Text> is not tested as it's irrelevant.
* If the logic finds <No Text/No Text> then it looks back up the sheet, if it finds <Text/Text> it looks further
* down the sheet. I think you'll find this is quite fast, especially on datasets > 100,000 rows.
*/
虽然不知道这个方法好不好，但是这个方法怎么样？此方法不使用循环。请将此作为样本之一进行检查。
getLastRow()。示例脚本：
var col = ##; // Here, please input a column number.
var ss = SpreadsheetApp.getActiveSheet();
var coldata = ss.getRange(1, col, ss.getLastRow(), 1).getValues();
var tempss = SpreadsheetApp.create("temporary_sheet");
tempss.getActiveSheet().getRange(1,1,coldata.length, coldata[0].length).setValues(coldata);
var last_row = tempss.getLastRow(); // The number of last row
Drive.Files.remove(tempss.getId()); // In this case, the file is removed using Drive API.
笔记 ：
在上述情况下，即使列有空单元格，也可以检索最后一行的数量。如果该列没有空单元格，您可以通过以下脚本检索特定列的最后一行的数量。这不会创建临时工作表。
var last_row = ss.getRange(1, col, ss.getLastRow(), 1).getValues().filter(String).length;
在这种情况下，我想使用以下两种模式。
通过从工作表的顶部搜索来检索特定列的第一个空单元格
通过从工作表的底部搜索来检索特定列的第一个非空单元格
为了实现上述，我认为可以使用以下2种模式。
检索列的值并使用循环搜索结果。
使用 Google Apps 脚本的内置方法直接检索结果。
我测量了他们的流程成本。结果发现，以下 2 个脚本是所有方法中最低的。
Object.prototype.get1stEmptyRowFromTop = function (columnNumber, offsetRow = 1) {
const range = this.getRange(offsetRow, columnNumber, 2);
const values = range.getDisplayValues();
if (values[0][0] && values[1][0]) {
return range.getNextDataCell(SpreadsheetApp.Direction.DOWN).getRow() + 1;
} else if (values[0][0] && !values[1][0]) {
return offsetRow + 1;
}
return offsetRow;
};
// Please run this function.
function main() {
const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Sheet1");
const res = sheet.get1stEmptyRowFromTop(3);
console.log(res); // Retrieve the 1st empty row of column "C" by searching from TOP of sheet.
}
const res = sheet.get1stEmptyRowFromTop(3, 2);.在这个问题中，我认为这种模式可能是合适的。
Object.prototype.get1stNonEmptyRowFromBottom = function (columnNumber, offsetRow = 1) {
const search = this.getRange(offsetRow, columnNumber, this.getMaxRows()).createTextFinder(".").useRegularExpression(true).findPrevious();
return search ? search.getRow() : offsetRow;
};
// Please run this function.
function main() {
const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Sheet1");
const res = sheet.get1stNonEmptyRowFromBottom(3);
console.log(res); // Retrieve the 1st non empty row of column "C" by searching from BOTTOM of sheet.
}
const res = sheet.get1stNonEmptyRowFromBottom(3, 2);.使用上述脚本时，会得到以下结果。
当“C”列使用“通过从表格顶部搜索检索特定列的第一个空单元格”的脚本时，获得第6行。
当“C”列使用“通过从表格底部搜索检索特定列的第一个非空单元格”的脚本时，获得第9行。
你可以通过相反的方式来做到这一点。从电子表格的最后一行开始，直到你得到一些价值。即使您之间有一些空行，这也适用于所有情况。代码如下所示：
var iLastRowWithData = lastValue('A');
function lastValue(column) {
var iLastRow = SpreadsheetApp.getActiveSheet().getMaxRows();
var aValues = SpreadsheetApp.getActiveSheet().getRange(column + "2:" + column + lastRow).getValues();
for (; aValues[iLastRow - 1] == "" && iLastRow > 0; iLastRow--) {}
return iLastRow;
}
sheet.getRange(1, 1).getDataRegion(SpreadsheetApp.Dimension.ROWS).getLastRow()
请注意，这依赖于连续的数据（根据 OP 的要求）。
旧线程，但我找到了一种似乎可行的简单方法
ws.getRange("A2").getNextDataCell(SpreadsheetApp.Direction.DOWN).getLastRow()
您还可以使用以下代码：
function findTheLastRow(){
var ui = SpreadsheetApp.getUi();
var ss = SpreadsheetApp.getActiveSpreadsheet();
var sheet = ss.getActiveSheet();
var range = sheet.getRange("B1:B").getValues();
var filtered_r = range.filter(String).length;
ui.alert("Column B's last cell is number: " + filtered_r + " and its value is: " + range[filtered_r - 1][0]);
}
此脚本计算列中具有值的单元格的数量，因此最后一个单元格上方的单元格需要具有值才能获得正确的结果。
对于非常大的电子表格，此解决方案非常快：
function GoLastRow() {
var spreadsheet = SpreadsheetApp.getActive();
spreadsheet.getRange('A:AC').createFilter();
var criteria = SpreadsheetApp.newFilterCriteria().whenCellNotEmpty().build();
var rg = spreadsheet.getActiveSheet().getFilter().setColumnFilterCriteria(1, criteria).getRange();
var row = rg.getNextDataCell (SpreadsheetApp.Direction.DOWN);
LastRow = row.getRow();
spreadsheet.getActiveSheet().getFilter().remove();
spreadsheet.getActiveSheet().getRange(LastRow+1, 1).activate();
};
经过一段时间尝试构建一个函数以获取单列中最后一行的整数，这很好用：
function lastRow() {
var spreadsheet = SpreadsheetApp.getActiveSheet();
spreadsheet.getRange('B1').activate();
var columnB = spreadsheet.getSelection().getNextDataRange(SpreadsheetApp.Direction.DOWN).activate();
var numRows = columnB.getLastRow();
var nextRow = numRows + 1;
}
要获取列数或最后一列的索引：
var numColumns = sheet.getLastColumn()
要获取行数或最后一行的索引：
var numRows = sheet.getLastRow()
在哪里
var sheet = SpreadsheetApp.getActiveSheet()
这对我有用：
var ss = SpreadsheetApp.openById(YourSpreadsheetID);
var main_sheet = ss.getSheetByName(YourMainSheet);
main_sheet.getRange('K16').activate(); // substitute your cell from where you want to count
main_sheet.getCurrentCell().getNextDataCell(SpreadsheetApp.Direction.DOWN).activate();
var last_row_submissions = main_sheet.getCurrentCell().getRowIndex();
Mogsdad 解决方案的更新：
var Avals = ss.getRange("A1:A").getValues();
var Alast = Avals.filter(function(r){return r[0].length>0});
这对我来说是最好的方法，获取参考列，然后获取最后一行
var ssm = SpreadsheetApp.openById(id).getSheetByName(name);
var lastRow = ssm.getRange('A2').getNextDataCell(SpreadsheetApp.Direction.DOWN).offset(1, 0).getRow();
ssm.getRange(lr, 1, 1, 8).setValues([data]);
就我个人而言，我遇到了类似的问题，并采用了这样的方法：
function getLastRowinColumn (ws, column) {
var page_lastrow = ws.getDataRange().getNumRows();
var last_row_col = 0
for (i=1; i<=page_lastrow;i++) {
if (!(spread.getRange(column.concat("",i)).isBlank())) {last_row_col = i};
}
return last_row_col
}
它查找 ws 中的行数并循环遍历列中的每个单元格。当它找到一个非空单元格时，它会更新该单元格在 last_row_col 变量中的位置。它的优点是允许您拥有不连续的列并且仍然知道最后一行（假设您正在浏览整个列）。
我稍微改变了田池的回答。此版本创建工作表而不是电子表格。
var col = 1; // Here, please input a column number, in this case it is the number of A column(1).
var ss = SpreadsheetApp.getActiveSheet();
var coldata = ss.getRange(1, col, ss.getLastRow(), 1).getValues();
var tempss = SpreadsheetApp.getActiveSpreadsheet().insertSheet("temporary_sheet");
tempss.getRange(1,1,coldata.length, coldata[0].length).setValues(coldata);
var last_row = tempss.getLastRow(); // The number of last row
SpreadsheetApp.getActiveSpreadsheet().deleteSheet(SpreadsheetApp.getActiveSpreadsheet().getSheetByName("temporary_sheet"));
最佳解决方案取决于您的工作表有多少行以及数据的类型。我已经对各种提议的解决方案进行了比较和基准测试。大多数仅适用于普通数据，如果数据有间隙、公式、数组fourmulae、导入范围、本地引用、过滤或查询函数等，则会失败。几乎总是这样。
在所有数据类型上运行相当快的始终准确的解决方案是 Reversed for + getValues() 之一。如果您不想头疼，请使用它：
// replace 'yourSheetName' and column 1 with your values
var tab = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('yourSheetName')
var column = tab.getRange('A:A')
// get lastFilledRow
var value = ''
const max = tab.getMaxRows()
var values = column.getValues()
values = [].concat.apply([], values)
for (row = max - 1; row > 0; row--) {
value = values[row]
if (value != '') { break }
}
var lastFilledRow = row + 1
如果您真的想要一个单行并且您确定您的数据没有本地引用，请使用 getNextDataCell() 解决方案，它既快速又简单
// replace 'yourSheetName' and column 'A' with your values
var tab = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('yourSheetName')
var column = tab.getRange('A' + tab.getMaxRows())
// get lastFilledRow
var lastFilledRow = column.getNextDataCell(SpreadsheetApp.Direction.UP).getA1Notation().slice(1)
如果您想查看完整的分析和基准测试结果，请转到此处
我意识到这是一个相当古老的线程，但它是搜索此问题时的第一个结果。
有一个简单的解决方案，afaik 一直可用......这也是在 VBA 中执行相同任务的“推荐”方式。
var lastCell = mySheet.getRange(mySheet.getLastRow(),1).getNextDataCell(
SpreadsheetApp.Direction.UP
);
这将返回您在 getRange(row,column) 中指定的列中的最后一个完整单元格，如果您想使用第一个空行，请记住添加 1。
这对我有用：
var ss = SpreadsheetApp.openById(YourSpreadsheetID);
var main_sheet = ss.getSheetByName(YourMainSheet);
main_sheet.getRange('K16').activate(); // substitute your cell from where you want to count
main_sheet.getCurrentCell().getNextDataCell(SpreadsheetApp.Direction.DOWN).activate();
var last_row_submissions = main_sheet.getCurrentCell().getRowIndex();
我的方法采用列值的平面数组，反转它，搜索第一个定义的单元格的索引。
从 values 数组的总长度中减去该索引以获得非反向索引，然后添加可能在列值之前的任何行以返回电子表格中该列的实际最后一行。
const colValues = WORKSHEET.getRange(STARTROW, STARTCOLUMN, WORKSHEET.getLastRow(), 1)
.getValues()
.flat();
const getLastRowOfCol = (colValues, startRow = 1) => {
return (colValues.length - colValues.reverse().findIndex(cell => !!cell)) + startRow - 1;
};
对于我的用例，我需要在第 13 行之后获取第 5 列的最后一行。
const ss = SpreadsheetApp.openById(mySpreadsheetId);
const ws = ss.getSheetByName('myWorkSheetName');
const colValues = ws.getRange(14, 5, ws.getLastRow(), 1)
.getValues()
.flat()
const colLastRow = getLastRowOfCol(colValues, 13)
这可能是另一种绕过lastrow的方法。您可能需要使用代码以满足您的需求
function fill() {
var spreadsheet = SpreadsheetApp.getActive();
spreadsheet.getRange('a1').activate();
var lsr = spreadsheet.getLastRow();
lsr=lsr+1;
lsr="A1:A"+lsr;
spreadsheet.getActiveRange().autoFill(spreadsheet.getRange(lsr), SpreadsheetApp.AutoFillSeries.DEFAULT_SERIES);
};
这似乎有效：
function myFunction() {
var spreadsheet = SpreadsheetApp.getActive();
spreadsheet.getRange('B1').activate();
spreadsheet.getCurrentCell().getNextDataCell(SpreadsheetApp.Direction.DOWN).activate();
var LastDataRow = spreadsheet.getCurrentCell().getRowIndex();
Logger.log(LastDataRow);
};
我尝试编写以下 3 个函数，您可以针对您的不同情况对其进行测试。这是我测试的数据：
函数 getLastRow1 和 getLastRow2 将为 B 列返回 0 函数 getLastRow3 将为 B 列返回 1
根据您的情况，您将根据需要调整它们。
function getLastRow1(sheet, column) {
var data = sheet.getRange(1, column, sheet.getLastRow()).getValues();
while(typeof data[data.length-1] !== 'undefined'
&& data[data.length-1][0].length === 0){
data.pop();
}
return data.length;
}
function test() {
var sh = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Sheet6');
Logger.log('Cách 1');
Logger.log("Dòng cuối cùng của cột A là: " + getLastRow1(sh, 1));
Logger.log("Dòng cuối cùng của cột B là: " + getLastRow1(sh, 2));
Logger.log("Dòng cuối cùng của cột C là: " + getLastRow1(sh, 3));
Logger.log("Dòng cuối cùng của cột D là: " + getLastRow1(sh, 4));
Logger.log("Dòng cuối cùng của cột E là: " + getLastRow1(sh, 5));
Logger.log('Cách 2');
Logger.log("Dòng cuối cùng của cột A là: " + getLastRow2(sh, 1));
Logger.log("Dòng cuối cùng của cột B là: " + getLastRow2(sh, 2));
Logger.log("Dòng cuối cùng của cột C là: " + getLastRow2(sh, 3));
Logger.log("Dòng cuối cùng của cột D là: " + getLastRow2(sh, 4));
Logger.log("Dòng cuối cùng của cột E là: " + getLastRow2(sh, 5));
Logger.log('Cách 3');
Logger.log("Dòng cuối cùng của cột A là: " + getLastRow3(sh, 'A'));
Logger.log("Dòng cuối cùng của cột B là: " + getLastRow3(sh, 'B'));
Logger.log("Dòng cuối cùng của cột C là: " + getLastRow3(sh, 'C'));
Logger.log("Dòng cuối cùng của cột D là: " + getLastRow3(sh, 'D'));
Logger.log("Dòng cuối cùng của cột E là: " + getLastRow3(sh, 'E'));
}
function getLastRow2(sheet, column) {
var lr = sheet.getLastRow();
var data = sheet.getRange(1, column, lr).getValues();
while(lr > 0 && sheet.getRange(lr , column).isBlank()) {
lr--;
}
return lr;
}
function getLastRow3(sheet, column) {
var lastRow = sheet.getLastRow();
var range = sheet.getRange(column + lastRow);
if (range.getValue() !== '') {
return lastRow;
} else {
return range.getNextDataCell(SpreadsheetApp.Direction.UP).getRow();
}
}
我使用getDataRange()后跟getNumRows(). 第一个功能
返回与存在数据的维度相对应的范围
和第二个功能
返回此范围内的行数。
var ss = SpreadsheetApp.getActiveSpreadsheet();
var ws = ss.getActiveSheet();
var lastRow = ws.getDataRange().getNumRows();
PS我希望这适用于所有情况。
这是解决此问题的另一种方法。它使用while循环，但考虑了行之间的空白。
function getLastRow (column) {
var iLastRow = ss.getActiveSheet().getMaxRows();
var aValues = ss.getActiveSheet().getRange(column + ":" + column).getValues();
var row = "";
while(row == ""){
row = aValues[iLastRow-1];
iLastRow--;
}
return iLastRow;
}
我重写了 getLastRow/getLastColumn 函数来指定行索引或列索引。
function get_used_rows(sheet, column_index){
for (var r = sheet.getLastRow(); r--; r > 0) {
if (sheet.getRange(1, 1, sheet.getLastRow(), sheet.getLastColumn()).getCell(r, column_index).getValue() != ""){
return r;
break;
}
}
}
function get_used_cols(sheet, row_index){
for (var c = sheet.getLastColumn(); c--; c > 0) {
if (sheet.getRange(1, 1, sheet.getLastRow(), sheet.getLastColumn()).getCell(row_index, c).getValue() != ""){
return c;
break;
}
}
}