Макрос excel ускорить работу макроса

Время на прочтение
4 мин

Количество просмотров 127K

Предисловие

Так уж сложилось, что на сегодняшний день много кому приходится работать(писать макросы) на VBA в Excel. Некоторые макросы содержат сотни строк кода, которые приходится выполнять каждый день (неделю, месяц, квартал и так далее) и, при этом, они занимают изрядное количество времени. Вроде бы и и процесс автоматизирован и человеческого вмешательства не нужно, но время, занимаемое выполнением макроса, может охватывать десятки минут, а то и несколько часов. Время, как говориться, — деньги и в этом посте я постараюсь значительно ускорить время выполнения Вашего макроса и, возможно, это положительно скажется на ваших делах, а в итоге и деньгах.

Перед началом работы

Перед тем, как перейти прямо к сути, я хотел бы обратить внимание на пост: Несколько советов по работе с VBA в Excel. В частности, в блоке “Ускорение работы макросов” есть полезные примеры кода, которые стоит использовать вместе с моими советами по ускорению работы, для достижения максимального результата.

Ускоряем работу макроса

Итак, к сути… Для того что бы реально ускорить работу VBA в Ecxel нужно понимать, что обращение к ячейке на листе — занимает значительно время. Если Вы хотите записать в ячейку одно значение, то это не займет значительного времени, но если Вам потребуется записать(прочитать, обратиться) к тысячам ячеек, то это потребует гораздо большего времени. Что же делать в таких случаях? На помощь приходят массивы. Массивы хранятся в памяти, а операции в памяти VBA выполняет в сотни, а то и в тысячи раз быстрее. Поэтому, если у Вас в данных тысячи, сотни тысяч значений, то время выполнения макроса может занимать от нескольких минут до нескольких часов, а если эти данные перенести в массив, то выполнение макроса может сократиться до нескольких секунд (минут).

Я наведу пример кода и в комментариях объясню что к чему, так будет яснее. К тому же, могут пригодиться некоторые строки кода, не относящееся прямо к процессу ускорения.

Пример

Предположим, что у нас есть данные на “Лист1” (“Sheet1”). Данные содержаться в 50 колонках (колонки содержат названия) и 10 000 строк. К примеру, нам нужно в последнюю колонку внести значение, которое равно значению во второй колонке, деленное на значение в третьей колонке (начиная со 2-й строки, так как первая содержит заглавие). Потом мы возьмем первые 10 колонок и скопируем их на “Лист2” (“Sheet2”), для дальнейшей обработки (для других потребностей). Пусть пример и банальный, но, как мне кажется, он может отобразить всю суть данного поста.

'Для явной инициализации переменных, включаем эту опцию
'Это поможет избежать многих ошибок
Option Explicit

Sub Test()

'К листам будем обращаться через переменные
Dim Sheet1_WS, Sheet2_WS As Worksheet
'Переменная для прохождения срок на листе (в массиве)
Dim i As Long

'Массив, в котором будут храниться наши данные
Dim R_data As Variant
'Переменные последней строки и колонки
Dim FinalRow, FinalColumn As Long

'Можно инициализировать лист не по названию, а по порядковому номеру
'Set Sheet1_WS = Application.ThisWorkbook.Worksheet("Sheet1")
Set Sheet1_WS = Application.ThisWorkbook.Sheets(1)
Set Sheet2_WS = Application.ThisWorkbook.Sheets(2)

'Поиск последней не пустой строки в первой колонке
'Нужно, что бы данные не были отфильтрованы, иначе последняя строка будет последней строкой в фильтре
'Также в последней строке, в первой колонке, не должно быть пустой ячейки. Конечно, если в этой строке вообще есть данные. Иначе последней строкой будет последняя не пустая ячейка.
FinalRow = Sheet1_WS.Cells(Rows.Count, 1).End(xlUp).Row '=10 000

'Поиск последней не пустой колонки в первой строке
FinalColumn = Sheet1_WS.Cells(1, Columns.Count).End(xlToLeft).Column '=50

'Присваиваем массиву диапазон данных на Листе 1
R_data = Sheet1_WS.Range(Sheet1_WS.Cells(1, 1), Sheet1_WS.Cells(FinalRow, FinalColumn))

For i = 2 To FinalRow
    'Выполняем нужные нам операции с данными.
    'Проверяем, что бы не было деления на ноль.
    'Предполагается, что в колонке 2 и 3 стоят числовые данные
    'Иначе потребуется обработка ошибок
    If R_data(i, 3) <> 0 Then
        R_data(i, FinalColumn) = R_data(i, 2) / R_data(i, 3)
    End If
Next i

'Копируем данные из массива обратно на Лист1
'Перед этим очищаем данные на листе (если есть форматирование или формулы, то лучше Sheet1_WS.Cells.ClearContents)
Sheet1_WS.Cells.Delete
Sheet1_WS.Range(Sheet1_WS.Cells(1, 1), Sheet1_WS.Cells(FinalRow, FinalColumn)) = R_data

'Копируем данные на Лист2, копируем первые 10 колонок.
Sheet2_WS.Range(Sheet2_WS.Cells(1, 1), Sheet2_WS.Cells(FinalRow, 10)) = R_data

'Закрываем книгу и сохраняем её
Workbooks(Application.ThisWorkbook.Name).Close SaveChanges:=True

End Sub

В данном примере массив заполняется указанным диапазоном. Если у нас будет явно заданный двумерный массив, то скопировать его значение на лист можно таким образом:

Dim R_new() As Variant
............................................
' Явно указываем размер массива

ReDim R_new(1 To FinalRow, 1 To 50) As Variant
...........................................
Sheet1_WS.Range(Sheet1_WS.Cells(1, 1), Sheet1_WS.Cells(FinalRow, 50)) = R_new()

Заключение

Большинство операций над данными можно выполнять в массиве, при этом, отображать на лист только результат. Иногда целесообразным бывает показать результат на лист, потом выполнить некоторые действия (например, сортировку) и снова загрузить данные в массив.

Для меня было большой неожиданностью ускорения работы макроса за счет массивов, так как данные на листах, на самом деле, итак представляют собой двумерный массив. Но, оказывается, обращение к памяти происходит гораздо быстрей, чем к ячейкам на листе.

В дальнейшем я планирую написать советы (примеры) по быстрому поиску данных на листе, но это уже будет другой пост. Если будут вопросы, комментарии, пожалуйста, пишите.

Спасибо за внимание. Удачных разработок.

As part of our work to help enterprises upgrade to Office 365 ProPlus, we have found that some users have been experiencing slow running VBA, which can be frustrating. The good news is that there are steps which can be taken to improve performance.

This post aims to raise awareness of the steps that you can take to improve the performance of your macros, whether you are an end user, IT admin, or developer. We’ve collected the following steps from blog posts, Microsoft field engineers, and Microsoft MVPs like Charles Williams and Jan Karel Pieterse.

1. Turn off everything but the essentials in VBA

One of the first things to do when speeding up VBA code is to turn off unnecessary features such as animations, screen updating, automatic calculations and events while your macro is running. These features can add extra overhead and slow down the macro, particularly if the macro is modifying many cells and triggering lots of screen updates and recalculations.

The below code sample shows you how to enable/disable:

• Manual calculations
• Screen updates
• Animations

Option Explicit
Dim lCalcSave As Long
Dim bScreenUpdate As Boolean
Sub SwitchOff(bSwitchOff As Boolean)
  Dim ws As Worksheet
    
  With Application
    If bSwitchOff Then 

      ' OFF 
      lCalcSave = .Calculation
	bScreenUpdate = .ScreenUpdating
      .Calculation = xlCalculationManual
      .ScreenUpdating = False
      .EnableAnimations = False
      
      '
      ' switch off display pagebreaks for all worksheets
      '
      For Each ws In ActiveWorkbook.Worksheets
        ws.DisplayPageBreaks = False
      Next ws
    Else
 
      ' ON
      If .Calculation <> lCalcSave And lCalcSave <> 0 Then .Calculation = lCalcSave
      .ScreenUpdating = bScreenUpdate
      .EnableAnimations = True
      
    End If
  End With
End Sub

Sub Main()
  SwitchOff(True) ‘ turn off these features
  MyFunction() ‘ do your processing here
  SwitchOff(False) ‘ turn these features back on
End Sub

2. Disabling Office animations through system settings

Animations can be disabled across Windows by accessing the Ease of Access Center.

Animations can be disabled in Excel specifically, under the Advanced or Ease of Access tab, within the File > Options menu.

Please see the following link for more information: https://support.office.com/en-us/article/turn-off-office-animations-9ee5c4d2-d144-4fd2-b670-22cef9fa…

3. Disabling Office animations through registry settings

Office animations can be disabled across multiple computers by setting the appropriate registry key via a group policy setting.

HIVE: HKEY_CURRENT_USER
Key Path: SoftwareMicrosoftOffice16.0CommonGraphics
Key Name: DisableAnimations
Value type: REG_DWORD
Value data: 0x00000001 (1)

Warning: Using Registry Editor incorrectly can cause serious, system-wide problems that may require you to re-install Windows to correct them. Microsoft cannot guarantee that any problems resulting from the use of Registry Editor can be solved. Use this tool at your own risk.

4. Removing unnecessary selects

The select method is common to see in VBA code, however it is often added to the macro where it isn’t needed. Select can trigger cell events such as animations and conditional formatting which slow the macro down, so removing unnecessary selects can significantly speed up your macro.

The following example shows the code before and after making the change to remove unnecessary selects.

Before

Sheets("Order Details").Select
Columns("AC:AH").Select
Selection.ClearContents

After

Sheets("Order Details").Columns("AC:AH").ClearContents

5. Using the With statement to read object properties

When working with objects, use the With statement to reduce the number of times object properties are read. The following example shows the code before and after making the change to use the With statement.

Before

Range("A1").Value = “Hello”
Range("A1").Font.Name = “Calibri”
Range("A1").Font.Bold = True
Range("A1").HorizontalAlignment = xlCenter

After

With Range("A1")
  .Value2 = “Hello” 
  .HorizontalAlignment = xlCenter
    With .Font
      .Name = “Calibri”
      .Bold = True
    End With
End With

6. Using ranges and arrays

Reading and writing to cells in Excel from VBA is expensive. There is an overhead that is incurred every time data moves between VBA and Excel.

The mountain between Excel and VBA

This means that you should try to reduce the number of times you pass data between VBA and Excel. This is where ranges are useful. Instead of reading and writing to each cell individually in a loop, read the entire range into an array at the start, loop through the array, and then write the entire array back at the end. The following example code shows how a range can be used to read and write the values once, instead of reading each cell individually.

Dim vArray As Variant
Dim iRow As Integer
Dim iCol As Integer
Dim dValue As Double
vArray = Range("A1:C10000").Value2 ‘ read all the values at once from the Excel cells, put into an array 

For iRow = LBound(vArray, 1) To UBound(vArray, 1)
  For iCol = LBound(vArray, 2) To UBound(vArray, 2)
    dValue = vArray (iRow, iCol)
    If dValue > 0 Then 
      dValue=dValue*dValue ‘ Change the values in the array, not the cells 
    vArray(iRow, iCol) = dValue
  End If
Next iCol
Next iRow
Range("A1:C10000").Value2 = vArray ‘ writes all the results back to the range at once

7. Use .Value2 instead of .Text or .Value

There are different ways that you can retrieve values from a cell, and which property you use can make a different in the performance of your code.

.Text is commonly used to retrieve the value of a cell – it returns the formatted value of a cell. Getting the formatting of a cell is more complex than just retrieving a value, and makes .Text quite slow.

.Value is an improvement over .Text, as this mostly gets the value from the cell, without formatting. However for cells formatted as a date or currency, .Value will return a VBA date or VBA currency (which may truncate decimal places).

.Value2 gives the underlying value of the cell. As it involves no formatting, .Value2 is faster than .Value. .Value2 is faster than .Value when processing numbers (there is no significant difference with text), and is much faster using a variant array.

For a more detailed explanation, please see Charles William’s blog post, “TEXT vs VALUE vs VALUE2”: https://fastexcel.wordpress.com/2011/11/30/text-vs-value-vs-value2-slow-text-and-how-to-avoid-it/

8. Bypass the clipboard (copy and paste)

When you use the Macro Recorder to record operations that use copy and paste, the code will use the copy and paste methods by default. However, within VBA code, it is much faster to bypass the clipboard and use internal operations instead. By default, copying will copy everything, including formulas, values and formatting. You can make copying faster by only copying values or formulas, without the formatting. The following example shows the code before and after making the change to bypass the clipboard.

Before

Range("A1").Select
Selection.Copy
Range("A2").Select
ActiveSheet.Paste

After

‘ Approach 1: copy everything (formulas, values and formatting
Range("A1").Copy Destination:=Range("A2")

‘ Approach 2: copy values only
Range("A2").Value2 = Range("A1").Value2

‘ Approach 3: copy formulas only
Range("A2").Formula = Range("A1").Formula

If you still find that a macro takes longer than expected to execute many individual copy and paste operations, you may want to apply the following hot fix: https://support.microsoft.com/en-in/help/2817672/macro-takes-longer-than-expected-to-execute-many-in…

9. Use Option Explicit to catch undeclared variables

Option Explicit is one of the available Module directives in VBA that instructs VBA how to treat the code within the code module. Setting Option Explicit requires all variables to be declared and will give compile errors if an undeclared variable is used. This helps catch incorrectly typed variable names and improves performance with all variable types being defined at compile time, instead of being inferred at runtime.

This can be set by typing: Option Explicit at the top of each module in your project or by checking the «Require Variable Declaration» option under Tools -> Options in the VBA editor. 

Additional Details on Module directives can be found here: https://docs.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/option-explicit-s…

Conclusion

We hope that this has helped highlight some of the ways that you can make your macros run faster. We’re sure that we haven’t covered everything, so please comment below with any other tips or tricks to improve the performance of your macros in Excel.

Further reading

https://blogs.office.com/en-us/2009/03/12/excel-vba-performance-coding-best-practices/

http://datapigtechnologies.com/blog/index.php/ten-things-you-can-do-to-speed-up-your-excel-vba-code/

https://www.ozgrid.com/VBA/SpeedingUpVBACode.htm

FAQs:

After using the new macro animations stopped working/it’s stuck on manual calculation.

It is possible the code disables the various settings, but the macro crashes before re-enabling these settings. To fix this, you will need to run the code to enable these settings again.

Other resources

https://www.thespreadsheetguru.com/blog/2015/2/25/best-way-to-improve-vba-macro-performance-and-prev… — The Best Way To Improve VBA Macro Performance And Prevent Slow Code Execution

https://www.ozgrid.com/VBA/SpeedingUpVBACode.htm — Optimize Slow VBA Code. Speeding Up Slow Excel VBA Code

About the co-authors

Charles Williams founded Decision Models in 1996 to provide advanced consultancy, decision support solutions, and tools based on Microsoft Excel and relational databases. Charles is the author of FastExcel, the widely used Excel performance profiler and performance toolset, and co-author of Name Manager, the popular utility for managing defined names. For more information about Excel calculation performance and methods, memory usage, and VBA user-defined functions, visit the Decision Models Web site.

Jan Karel Pieterse is a long time Excel MVP who develops custom solutions focused on Microsoft Office, with deep expertise in Excel and VBA. He runs the website JKP Application Development Services site, where you can find an interesting collection of articles, training events, and utilities. For a good overview of topics, see this list of in-depth articles. Jan develops some cool and useful utilities for Excel, including NameManager, RefTreeAnalyser, and Flexfind. You can find a full list on the downloads page.

 

Хитрости »

20 Январь 2016              61493 просмотров

---

Рано или поздно у пишущих на Visual Basic for Applications возникает проблема — код хоть и облегчает жизнь и делает все автоматически, но очень долго. В этой статье я решил собрать несколько простых рекомендаций, которые помогут ускорить работу кода VBA, при этом в некоторых случаях весьма внушительно — в десятки, а то и больше, раз. Основной упор в статье сделан на начинающих, поэтому в начале статьи приводятся самые простые методы оптимизации. Более «глубокие» решения по оптимизации кода приведены в конце статьи, т.к. для применения данных решений необходим достаточный опыт работы в VB и сходу такие методы оптимизации кому-то могут быть непонятны.

1. Если в коде есть много всяких Activate и Select, тем более в циклах — следует немедленно от них избавиться. Как это сделать я писал в статье: Select и Activate — зачем нужны и нужны ли?
2. Обязательно на время выполнения кода отключить:
   • автоматический пересчет формул. Чтобы формулы не пересчитывались при каждой манипуляции на листе во время выполнения кода — это может дико тормозить код, если формул много:

     Application.Calculation = xlCalculationManual

     Если во время кода все же нужно пересчитывать какие-то диапазоны, то можно пересчитывать только их:

     Range("A1:C60").Calculate

   • обновление экрана, чтобы действия по изменению значений ячеек и пр. не мелькали. Зачем это надо? Т.к. все эти действия обращаются к графическому процессору и заставляют его трудиться для перерисовки экрана — это может значительно тормозить код:

     Application.ScreenUpdating = False

   • На всякий случай отключаем отслеживание событий. Нужно для того, чтобы Excel не выполнял никаких событийных процедур, которые могут быть в листе, в котором производятся изменения. Как правило это события изменения ячеек, активации листов и пр.:

     Application.EnableEvents = False

   • Если книга выводилась на печать или выводится на печать в процессе выполнения кода, то лучше убрать разбиение на печатные страницы.

     ActiveWorkbook.ActiveSheet.DisplayPageBreaks = False

     если печать производится внутри кода, то эту строку желательно вставить сразу после строки, выводящей лист на печать(при условии, что печать не происходит в цикле. В этом случае — по завершению цикла печати).
     Я советую всегда отключать разбиение на страницы, т.к. это может тормозить весьма значительно, т.к. заставляет при любом изменении на листах обращаться к принтеру и переопределять кол-во и размер печатных страниц. А это порой очень не быстро.

   • На всякий случай можно отключить отображение информации в строке статуса Excel(в каких случаях там вообще отображается информация и зачем можно узнать в статье: Отобразить процесс выполнения). Хоть это и не сильно поедает ресурсы — иногда может все же ускорить работу кода:

     Application.StatusBar = False

   Главное, что следует помнить — все эти свойства необходимо включить обратно после работы кода. Иначе могут быть проблемы с работой внутри Excel. Например, если забыть включить автопересчет формул — большинство формул будут пересчитывать исключительно принудительным методом — после нажатия сочетания клавиш Shift+F9. А если забыть отключить обновление экрана — то есть шанс заблокировать себе возможность работы на листах и книгах. Хотя по умолчанию свойство ScreenUpdating и должно возвращаться в True, если было отключено внутри процедуры — лучше не надеяться на это и привыкать возвращать все свойства на свои места принудительно. По сути все это сведется к нескольким строкам:

   'Возвращаем обновление экрана
   Application.ScreenUpdating = True
   'Возвращаем автопересчет формул
   Application.Calculation = xlCalculationAutomatic
   'Включаем отслеживание событий
   Application.EnableEvents = True

   Как такой код выглядит на практике. Предположим, надо записать в цикле в 10 000 строк значения:

   Sub TestOptimize()
   'отключаем обновление экрана
   Application.ScreenUpdating = False
   'Отключаем автопересчет формул
   Application.Calculation = xlCalculationManual
   'Отключаем отслеживание событий
   Application.EnableEvents = False
   'Отключаем разбиение на печатные страницы
   ActiveWorkbook.ActiveSheet.DisplayPageBreaks = False
    
   'Непосредственно код заполнения ячеек
   Dim lr As Long
   For lr = 1 To 10000
       Cells(lr, 1).Value = lr 'для примера просто пронумеруем строки
   Next
    
   'Возвращаем обновление экрана
   Application.ScreenUpdating = True
   'Возвращаем автопересчет формул
   Application.Calculation = xlCalculationAutomatic
   'Включаем отслеживание событий
   Application.EnableEvents = True
   End Sub

   Разрывы печатных страниц можно не возвращать — они тормозят работу в любом случае.

3. Следует избегать циклов, вроде Do While для поиска последней ячейки. Часто такую ошибку совершают начинающие. Куда эффективнее и быстрее вычислять последнюю ячейку на всем листе или в конкретном столбце без этого тормозного цикла Do While. Я обычно использую

   lLastRow = Cells(Rows.Count,1).End(xlUp).Row

   другие варианты определения последней ячейки я детально описывал в статье: Как определить последнюю ячейку на листе через VBA?

Для более опытных пользователей VBA я приведу несколько решений по оптимизации кодов в различных ситуациях:

• Самая хорошая оптимизация кода, если приходится работать с ячейками листа напрямую, обрабатывать их и, возможно, изменять значения, то быстрее все обработки делать в массиве и разом выгружать на листе. Например, код выше по заполнению ячеек номерами будет в этом случае выглядеть так:

  Sub TestOptimize_Array()
  'Непосредственно код заполнения ячеек
  Dim arr, lr As Long
  'запоминаем в массив одним махом все значения 10000 строк первого столбца
  arr = Cells(1, 1).Resize(10000).Value
  'если нужно заполнение для двух и более столбцов
  'arr = Cells(1, 1).Resize(10000, 2).Value
  'или 
  'arr = Range(Cells(1, 1),Cells(10000, 2)).Value
  'или автоматически вычисляем последнюю ячейку и заносим в массив данные, начиная с ячейки А3
  'llastr = Cells(Rows.Count, 1).End(xlUp).Row 'последняя ячейка столбца А
  'arr = Range(Cells(3, 1),Cells(llastr, 2)).Value
  For lr = 1 To 10000
      arr(lr,1) = lr 'заполняем массив порядковыми номерами
  Next
  'Выгружаем обработанный массив обратно на лист в те же ячейки
  Cells(1, 1).Resize(10000).Value = arr
  End Sub

  Но здесь следует учитывать и тот момент, что большие массивы могут просто вызвать переполнение памяти. Наиболее актуально это для 32-битных систем, где на VBA и Excel выделяется памяти меньше, чем в 64-битных системах

• Если используете быстрый ЕСЛИ — IIF, то замените его на IF … Then … Else
• Так же лучше вместо Switch() и Choose() применить тот же IF … Then … Else
• В большинстве случаев проверять строку на «не пусто» лучше через Len(), чем прямое сравнение с пустотой: Len(s)=0 вместо s = «». Связано с тем, что работа со строками значительно медленнее, чем с числовыми данными и Len по сути не подсчитывает длину переменной, а берет это число непосредственно уже готовое из памяти. При сравнении же текста с пустой строкой(«»), VBA сначала создает в памяти переменную нулевой длинны, а уже потом сравнивает с ней наш текст. Поэтому в некоторых случаях так же ускоряет сравнение и в таком виде: s = vbNullString
• Не применять объединение строк без необходимости. Например, s = «АВ», будет быстрее, чем: s =»А» & «В»
• Не применять сравнение текстовых величин напрямую. Лучше применить встроенную функцию StrComp:
  If s <> s1 Then будет медленнее, чем
  If StrComp(s, s1, vbBinaryCompare) <> 0
  и тем более, если при сравнении необходимо не учитывать регистр:
  If LCase(s) <> LCase(s1) Then будет медленнее, чем
  If StrComp(s, s1, vbTextCompare) <> 0
• Циклы For … Next в большинстве случаев работает быстрее, чем цикл Do … Lоор
• Избегать присвоения переменным типа Variant. Хоть соблазн и велик — этот тип забирает много памяти и в дальнейшем замедляет работу кода. Так же для объектных переменных следует избегать по возможности безликого глобального типа Object и применять конкретный тип:

  Dim rRange as Object, wsSh as Object

  будет медленнее работать, чем:

  Dim rRange as Range, wsSh as Worksheet

  Причина в том, что при объявлении As Object мы не даем VBA практически никакой информации о типе данных, кроме того, что это какой-то объект. И VBA приходится «на лету» внутри кода при каждом обращении к такой переменной определять её конкретный тип(Range, Worksheet, Workbook, Chart и т.д.). Что опять же занимает время.
• Если работаете с массивами, то можно при объявлении указать это явно:

  вместо

  Такая инициализация происходит быстрее.
  А еще лучше будет при этом еще и тип данных сразу присвоить:

  Dim arr() as string, arr2() as long

  но это только если есть уверенность в том, что в массив будут заноситься строго указанные типы данных

Конечно, это не все приемы и решения для оптимизации. Но на первых парах должно хватить. Плюс, всегда следует исходить из здравого смысла. Например, если код выполняется за 2 секунды, то вероятно нет смысла его дальше оптимизировать. Конечно, если этот код не из тех, которые просто изменяют значение одной-двух ячеек.

---

Статья помогла? Поделись ссылкой с друзьями!

    Видеоуроки

---

Поиск по меткам



Access
apple watch
Multex
Power Query и Power BI
VBA управление кодами
Бесплатные надстройки
Дата и время
Записки
ИП
Надстройки
Печать
Политика Конфиденциальности
Почта
Программы
Работа с приложениями
Разработка приложений
Росстат
Тренинги и вебинары
Финансовые
Форматирование
Функции Excel
акции MulTEx
ссылки
статистика

Ускоряем работу макроса в Excel

Чем больше познаём мы макросы, тем интересней выгледят наши программы. А бывает, что их выполнение происходит очень долго, при сложных и долгих математических расчётах или составлении каких-то отчётов и табилц. В ходе выполнения макроса на мониторе происходит мелькание различных окон, открытие и закрытие книг, и прочая светомузыка. Для того чтобы этого не происходило, и чтобы время выполнение нашего макроса сократить раз в 100, можно воспользоваться командами описанные ниже.

Application.ScreenUpdating

Application.ScreenUpdating — отвечает за обновление экрана и может принимать два значения — False (обновление экрана отключено) и True (обновление экрана включено). В коде это обычно прописывается в том месете, где происходит мелькание различных окон или видно как производится расчёт и происходит заполнение таблицы. Ниже показан пример заполнения ячеек, и данную команду вставили в начало и конец макроса, т.е. сначала отключаем обновление экрана, а потом включаем обновление экрана. При такой записи мы не увидим процесс заполнения ячеек. А вот если убрать эти команды, то мы сможем наблюдать за процессом заполнения этих ячеек.

Sub Primer()

Application.ScreenUpdating = False

For a = 1 To 100

For b = 1 To 100

Cells(a, b) = «Пример»

Next b

Next a

Application.ScreenUpdating = True

End Sub

Application.Calculation

Application.Calculation — отвечает за автоматический расчёт в книге Excel и может принимать два значения — xlCalculationManual(ручной расчёт) и xlCalculationAutomatic (автоматический расчёт — по умолчанию установлен в Excel). Но тут есть одна осторожность, если вы перевели Excel в ручной расчёт, и в макросе произошла ошибка и он так и не выполнился до конца — т.е. не включился автоматический расчёт формул, то все ваши вычисления в дальнейшем будут в пустую. Так как формулы не будут автоматически пересчитываться, Excel превратиться в обычную таблицу. Но данная команда играет одну из основных ролей в быстроте выполнеия макроса. Вообщем лучше сделать код, который исключает ошибки, чтобы макрос полюбому выполнился и Excel перевёлся в автоматический расчёт. Если у Вас имеется большая таблица с многочисленными формулами, и часть вычислений вы производите при помощи макросов, то для быстроты выполнения расчётов разумно в начало и конец кода поместить команду Application.Calculation.

Sub Primer2()

Application.Calculation = xlCalculationManual

……………….

……………….

……………….

Application.Calculation = xlCalculationAutomatic

End Sub

Application.EnableEvents

Application.EnableEvents — команда отвечающая за выполнение сторонних событий. Эту команду мы уже затрагивали в этом уроке. И она также может принимать два значения — это False (отключить собтие) и True (включить выполнение промежуточных событий). Но теперь ещё известно, что она играет значительную роль в скорости выполнения некоторых кодов макроса. Пример можно взять из Урока №23.

Private Sub Worksheet_Change(ByVal Target As Range)

Application.EnableEvents = False

Target.Cells = «Привет»

Application.EnableEvents = True

End Sub

ActiveSheet.DisplayPageBreaks

ActiveSheet.DisplayPageBreaks — отображение границ листа. Может принимать два значения — False (отключить отображение границ) и True (включить отображение границ). Не знаю как это помогает на скорости выполнения макроса, лично я этого не ущутил, но некоторые говорят, что помогает. Я вообще не люблю когда отображаются границы листа, мне кажется, что это нужно только при распечатке. Помещать этот код можно в начало и конец макроса.

Private Sub Worksheet_Change(ByVal Target As Range)

ActiveSheet.DisplayPageBreaks = False

…………………….

…………………….

…………………….

ActiveSheet.DisplayPageBreaks = True

End Sub

Application.DisplayStatusBar

Application.DisplayStatusBar — строка состояния. Может принимать два значения — False (отключить строку состояния) и True (включить строку состояния). При выполнении макросов в строке состояния отображаются все происходяще события. Для того чтобы не тратить время на просчёт событий и прорисовку их в статусбаре, отключаем её на время выполнения макроса, и включаем её когда макрос закончил выполняться.

Private Sub Worksheet_Change(ByVal Target As Range)

Application.DisplayStatusBar = False

…………………….

…………………….

…………………….

Application.DisplayStatusBar = True

End Sub

Application.DisplayAlerts

Application.DisplayAlerts — команда отвечающая за события в Excel. Может принимать два значения — False (отключаем запросы Excel) и True (включаем события Excel). Это чень интересная и полезная команда при помощи которой можно отключить запросы Excel, например, чтобы он не спрашивал нужно ли сохранить изменения в книге, или отключить запрос на совместимость версий Excel. Ниже приведён пример, в котором книга закрывает сама себя, при этом независимо от того внесли вы изменения или нет в книгу, при закрытии книги вам не поступит запрос «Сохранить изменения», а книга просто закроется без сохранения и уведомления пользователя.

Sub Primer()

Application.DisplayAlerts = False

ThisWorkbook.Close

Application.DisplayAlerts = True

End Sub

Глобальное ускорение

Из всего выше сказанного можно сделать вывод, что для ускорения работы макроса можно воспользоваться нужными нам командами, теми которые подходят в нашем случае. Бывает, что код очень сложный и включает в себе различные математические и другие операции и использовать можно несколько команд сразу как показано на этом примере:

sub Primer()

Application.ScreenUpdating = False

Application.Calculation = xlCalculationManual

Application.EnableEvents = False

Application.DisplayStatusBar = False

Application.DisplayAlerts = False

…………………….

…………………….

…………………….

…………………….

Application.ScreenUpdating = True

Application.Calculation = xlCalculationAutomatic

Application.EnableEvents = True

Application.DisplayStatusBar = True

Application.DisplayAlerts = True

End Sub

Скрытые перемещения

Я решил выделить отдельный урок, в котором будут описаны относительные команды скрытых перемещений по книге. Например каким образом возможно выполнить перемещение курсора на 3 столбца влево и на 6 строк вниз относительно активной ячейки. Это бывает очень удобно когда вы работаете с одними и теми же данными, с одинаковыми таблицами, из которых Вам надо выделить только определённые значения, скопировать их или наоборот оставить только их, а всё остальное удалить. При этом у Вас всё время выполняется одна и таже операция, которая уже надоела. Почему бы не написать готовый макрос, который будет работать и опираться на определённую ячейку таблицы — активную ячейку. Именно это я и решил собрать всё в одном уроке — Скрытые перемещения.

Относительные перемещения

Рассмотрим команду относительного перемещения, которая называется:

Offset(RowOffset, ColumnOffset)

RowOffset — это на сколько строк вверх или вниз необходимо сделать перемещение. Может принимать как положительные значения (при перемещении вниз), так и отрицательные значения (при перемещении вверх);
ColumnOffset — это на сколько столбцов влево или вправо необходимо сделать перемещение. Может принимать как положительные значения (при перемещении вправо), так и отрицательные значения (при перемещении влево);

Sub Primer()

ActiveCell.Offset(0, 2).Select ‘1

ActiveCell.Offset(4, 0).Select ‘2

ActiveCell.Offset(-2, 0).Select ‘3

ActiveCell.Offset(0, -2).Select ‘4

End Sub

В первом случае курсор выделит ячеку находящуюся на 2 ячейки вправо от активной ячейки. Во втором случае выделится ячейка находящаяся на 4 строки вниз от предыдущей — активной ячейки. В третьем случае выделится ячейка находящаяся на две строки выше от предыдущей — активной ячейки. И в последнем случае выделится ячейка находящаяся на два столбца влево от предыдущей — активной ячейки.

В следующем примере показано как выделить столбец находящийся на два столбца правее от 4 столбца («D»). Вместо цифры 4 можно использовать какую-то переменную, относительно которой уже будет происходить выполнение Вашего макроса.

Sub Primer()

Columns(4).Offset(0, 2).Select

End Sub

Перемещаемся по листам не зная их имён

Иногда возникает необходимость выполнить перемещение по листам, но при этом их имена постоянно меняются или Вы делаете такую программу, в которой Вы заранее не знаете имена листов, но перемещаться в ней по этим листам как-то надо. Для этого можно воспользоваться записью относительной:

Sheets(X)

Sheets — это лист;
(X) — это номер листа;

Ниже на примере показано как можно выделить лист №2, и не важно какое у него имя, второй по счёту лист будет выделен:

Sub Primer()

Sheets(2).Select

End Sub

Лист можно не только выделить, но и перименовать и дальше испоьлзовать в программе ваше имя.

Sub Primer()

Sheets(2).Name = «Пример»

End Sub

Крайние перемещения

Возможно кто-то уже задавался вопросом: «Как определить край таблицы или последний заполненный столбец, строку?» Вот тут я и покажу как определить последнюю заполненную ячейку. Зная эту ячейку можно определить конечную координату таблицы, которую в последствии можно успешно обработать. Ниже показан пример выделения конечных ячеек относительно текущей.

Sub Primer()

Selection.End(xlToRight).Select ‘1

Selection.End(xlUp).Select ‘2

Selection.End(xlToLeft).Select ‘3

Selection.End(xlDown).Select ‘4

End Sub

1 — это выделение крайней правой яейки;
2 — это выделение самой верхней ячейки;
3 — это выделение крайней левой ячейки;
4 — это выделение нижней заполненной ячейки;

При помощи этих команд можно не только выделять ячейки, но и сразу заносить в них данные без предварительного перемещения в них курсора, например:

Sub Primer()

Selection.End(xlToRight) = «Пример»

End Sub

Выделения относительно активной ячейки

Выделить вниз до первой или последней заполненной ячейки (равносильно нажатию Ctrl+Shift+Down)

Sub CtrlShiftDown()

Range(ActiveCell, ActiveCell.End(xlDown)).Select

End Sub

Выделить вверх до первой или последней заполненной ячейки (равносильно нажатию Ctrl+Shift+Up)

Sub CtrlShiftUp()

Range(ActiveCell, ActiveCell.End(xlUp)).Select

End Sub

Выделить вправо до первой или последней заполненной ячейки (равносильно нажатию Ctrl+Shift+Right)

Sub CtrlShiftRight()

Range(ActiveCell, ActiveCell.End(xlToRight)).Select

End Sub

Выделить влево до первой или последней заполненной ячейки (равносильно нажатию Ctrl+Shift+Left)

Sub CtrlShiftLeft()

Range(ActiveCell, ActiveCell.End(xlToLeft)).Select

End Sub

Выделить текущую область (выделяется диапазон неразрывно заполненных ячеек — равносильно нажатию кнопок Ctrl+Shift+*)

Sub CtrlShiftUmn()

ActiveCell.CurrentRegion.Select

End Sub

Выделить активную область (происходит выделение всего заполненного диапазона Ctrl+Shift+Home, End, Home)

Sub CtrlShiftHome()

Range(Range(«A1»), ActiveCell.SpecialCells(xlLastCell)).Select

End Sub

Выделить смежные (заполненные прилегающие к активной ячейке) ячейки в столбце с активной ячейкой

Sub SelectActiveColumn()

Dim TopCell As Range

Dim BottomCell As Range

If IsEmpty(ActiveCell) Then Exit Sub

On Error Resume Next

If IsEmpty(ActiveCell.Offset(-1, 0)) Then Set TopCell = _

ActiveCell Else Set TopCell = ActiveCell.End(xlUp)

If IsEmpty(ActiveCell.Offset(1, 0)) Then Set BottomCell = _

ActiveCell Else Set BottomCell = ActiveCell.End(xlDown)

Range(TopCell, BottomCell).Select

End Sub

Выделить смежные ячейки в строке с активной ячейкой

Sub SelectActiveRow()

Dim LeftCell As Range

Dim RightCell As Range

If IsEmpty(ActiveCell) Then Exit Sub

On Error Resume Next

If IsEmpty(ActiveCell.Offset(0, -1)) Then Set LeftCell = _

ActiveCell Else Set LeftCell = ActiveCell.End(xlToLeft)

If IsEmpty(ActiveCell.Offset(0, 1)) Then Set RightCell = _

ActiveCell Else Set RightCell = ActiveCell.End(xlToRight)

Range(LeftCell, RightCell).Select

End Sub

Выделить весь активный столбец

Sub SelectionEntireColumn()

Selection.EntireColumn.Select

End Sub

Выделить всю активную строку

Sub SelectEntireRow()

Selection.EntireRow.Select

End Sub

Выделить рабочий лист

Sub SelectEntireSheet()

Cells.Select

End Sub

Выделить следующую пустую ячейку снизу

Sub CellNextDown()

ActiveCell.Offset(1, 0).Select

Do While Not IsEmpty(ActiveCell)

ActiveCell.Offset(1, 0).Select

Loop

End Sub

Выделить следующую пустую ячейку справа

Sub CellNextRight()

ActiveCell.Offset(0, 1).Select

Do While Not IsEmpty(ActiveCell)

ActiveCell.Offset(0, 1).Select

Loop

End Sub

Выделение от первой непустой до последней непустой ячеек в строке

Sub SelectFirstToLastInRow()

Dim LeftCell As Range

Dim RightCell As Range

Set LeftCell = Cells(ActiveCell.Row, 1)

Set RightCell = Cells(ActiveCell.Row, 256)

If IsEmpty(LeftCell) Then Set LeftCell = LeftCell.End(xlToRight)

If IsEmpty(RightCell) Then Set RightCell = RightCell.End(xlToLeft)

If LeftCell.Column = 256 And RightCell.Column = 1 Then ActiveCell. _

Select Else Range(LeftCell, RightCell).Select

End Sub

Выделение от первой непустой до последней непустой ячеек в столбце

Sub SelectFirstToLastInColumn()

Dim TopCell As Range

Dim BottomCell As Range

Set TopCell = Cells(1, ActiveCell.Column)

Set BottomCell = Cells(16384, ActiveCell.Column)

If IsEmpty(TopCell) Then Set TopCell = TopCell.End(xlDown)

If IsEmpty(BottomCell) Then Set BottomCell = BottomCell.End(xlUp)

If TopCell.Row = 16384 And BottomCell.Row = 1 Then ActiveCell. _

Select Else Range(TopCell, BottomCell).Select

End Sub

Относительные формулы

Некоторые наверно обращали внимание на то, что при записи макроса вводимые формулы имеют непонятый вид. Тут хотелось бы развеять все непонятки и показать, что в этих формулах нет ничего сложного, и в них всё логично, хоть они и выглядят по другому. Рассмотрим простую формулу сложения двух ячеек.

Sub Primer()

Cells(4, 5) = «=RC[-3]+RC[-1]»

Cells(5, 5) = «=R[-3]C+R[-1]C»

End Sub

R — это строка, от слова Row;
C — это столбец, от слова Column;

В квадратных скобках указано на какое количество столбцов или строк необходимо переместится от заданной ячейки. Принцип отчёта такой же как и в команде рассмотренной самой первой в этом уроке — Offset. И как видно на примере, значения в квадратных скобках могут быть как отрицательные так и положительные.

В первом примере показано, что сумма в ячейке Cells(4, 5) равна сумме двух ячеек, одна из которых находится на третьем столбце влево от заданной ячейки, а другая на один столбец влево от заданной ячейки, при этом строка остаётся неизменной. На втором примере всё аналогично, только тут уже столбец остаётся неизменным а меняются строки.

Столбцы и строки

В этом пункте я расскажу как правильно работать со строками и столбцами. Каким образом можно выделить одну строку, две или несколько строк, и тоже самое со столбцами.

Для того чтобы оперировть какой-то одной строкой или столбцом, можно воспользоваться следующей записью:

Rows(6).Select ‘Строка

Columns(6).Select ‘Столбец

Это самая простая запись не требующая никаких кавычек, Вы просто указываете номер строки или столбца и дальше делаете с ней что угодно, например закрасить в синий цвет:

Rows(6).Interior.ColorIndex = 5 ‘Строка

Columns(6).Interior.ColorIndex = 5 ‘Столбец

Если Вам необходимо выделить более одной строки или столбца, то можно воспользоваться следующей записью:

Rows(«2:2»).Select ‘Строка

Columns(«B:B»).Select ‘Столбец

Такая запись выделяет только одну строку и только один столбец.
А вот если записать так:

Rows(«2:5»).Select ‘Строка

Columns(«B:F»).Select ‘Столбец

то мы сможем обработать целый диапазон строк и столбцов, но он сплошной. Если мы хотим обработать разные строки, например 1, 4, 6-8, и разные столбцы, например B, D, F-G, то запись необходимо произвести следующим образом:

Range(«1:1,4:4,6:8»).Select ‘Строка

Range(«B:B,D:D,F:G»).Select ‘Столбец

При такой записи у нас получается уже диапазон. И умногих возник вопрос: «Каким образом можно одновременно выделить и строки и столбцы?». Пример ниже выделяет одновременно 8 строчку и столбец D:

Range(«D:D,8:8»).Select

А этот пример выделяет сразу несколько строк и столбцов одновременно:

Range(«B:B,D:D,3:6,9:9»).Select

Error. Обработка ошибок

Ну вот и пришёл тот долгожданный день, когда Вы задумались об обработке ошибок. Хорошо когда в программах работаете только Вы, и Вы знаете куда в ней можно нажать, а куда не стоит потому что случится ошибка. Но если Вы пишите программу, в которой работает несколько человек помимо Вас и они понятия не имеют что в ней можно и что нельзя, и они обязательно будут тыкать туда куда нельзя, и эти ошибки Вас просто погубят, потому что все будут грешить на вашу программу.
Конечно же в любой программе необходимо предусмотреть «защиту от дурака», но иногда «дурак» превосходит все ожидания. Если честно, я редко пользуюсь командами для обработки ошибок. Стараюсь предусматривать все возможные варианты действий пользователя, но это иногда заставляет написать такую огромную защиту, что сама программа того не стоит. Вообщем приступим.

Искусственно создадим ошибку. Самый простой способ — взять любое число и поделить его на ноль. Напишем простенькую программу и на ней будем рассматривать различные способы обхода ошибки.

Sub primer1()

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

End Sub

Способ №1. Перенаправление программы

Это пожалуй самый популярный способ, так как при возникновении ошибки лучше указать пользователю где он ошибся и перенаправить на другой путь выполнения программы. Сделать перенаправление можно при помощи команды GoTo, но сначала нам надо дать понять программе, что мы хотим отследить ошибку — т.е. включить распознование ошибок. Делается это следующим образом. В начало кода программы мы помещаем следующую команду

On Error

которая и говорит о том, что необходимо включить отслеживание ошибок. А команда GoTo уже перенаправит программу на то место, которое мы укажем. На примере нашей программе это можно продемонстрировать так:

Sub primer1()

On Error GoTo errors

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

GoTo Endprimer

errors:

MsgBox «Ошибка! Вводите корректные данные», vbCritical, «Ошибка»

Endprimer:

End Sub

Поясню. При возникновении ошибки, программа с места ошибки сразу перенаправится на errors: и уже будет продолжать выполнять код с этого места. То-есть с информационного сообщения о том, что у нас возникла ошибка, после этого сообщения программа так и продолжит выполнять макрос дальше, в данном случае программа просто закончится. В случае, если ошибки нет, нам покажется результат и код перенаправится на Endprimer:, так как туда нас перенаправил GoTo.
Если Вы не хотите чтобы макрос выполнялся дальше, то можно добавить команду для выхода из макросаExit Sub (завершение выполнения текущего макроса).

Sub primer1()

On Error GoTo errors

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

GoTo Endprimer

errors:

MsgBox «Ошибка! Вводите кооректные данные», vbCritical, «Ошибка»

Exit Sub

Endprimer:

End Sub

Способ №2. Настойчивость в исправлении ошибки

Можно сделать так, что в случае возникновения ошибки программа будет требовать от Вас ввести правильное число. Выглядеть это будет так.

Sub primer2()

On Error GoTo errors

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

GoTo vpered

errors:

MsgBox «Ошибка! Повторите ввод», vbCritical, «Ошибка»

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

Resume

vpered:

End Sub

Тут у нас добавилась только одна новая команда Resume, которая и будет перенапрявлять программу на место возникновения ошибки, тем самым требовать от нас правильного ввода данных, и пока мы их не введём, программа так и будет требовать от нас непонятного.

Способ №3. Предупреждён. Сообщение об ошибке

Хорошо, что разработчики VBA дали такой большой спектр обработки ошибок. Следующий способ уведомит Вас о произошедшей ошибке и выдаст её номер, а так же спросит Вас нужно ли выполнять программу дальше или всё таки прекратить её выполнение. Выглядеть это будет так.

Sub primer3()

On Error GoTo errors

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

GoTo propusk

errors:

If Err.Number 0 Then

resultat = MsgBox(«При выполнении программы произошла ошибка №» & Err.Number & _

vbNewLine & «Продолжить выполнение программы не смотря на ошибку?», _

vbYesNo + vbCritical, «Ошибка»)

If resultat = vbYes Then

Resume Next

Else

Exit Sub

End If

End If

propusk:

End Sub

Тут у нас добавилось ещё одна новая команда Resume Next, которая говорит о том, что код необходимо продолжать выполнять дальше с места обнаружения ошибки, не смотря ни на что.

Способ №4. Очистка ошибки

Если Вы написли программу, которая выполняется очень долго и в ней море ошибок, то вы можете просто напросто очистить эти ошибки и отследить их все, а в конечном сообщении вывести результат об ошибках. Делается это на подобии этого.

Sub primer4()

On Error Resume Next

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

If Err.Number 0 Then

p = Err.Number

Err.Clear

MsgBox «Ошибка » & p & » очищена!», vbInformation, «Уведомление»

End If

End Sub

Способ №5. Идём напролом

Если Вам наплевать на все ошибки и Вы даже не хотите о них слышать, то можно воспользоваться следующей записью.

Sub primer5()

On Error Resume Next

a = 10

b = InputBox(«Введите число отличное от 0», «Ввод данных», «0»)

c = a / b

MsgBox «Результат: » & a & «/» & b & «=» & c, vbInformation, «Ответ»

End Sub

При такой записи макрос будет продолжать выполняться не смотря на все ошибки.

Я думаю, что на основе этих примеров и уловок остальные способы обработки ошибок Вы сможете придумать сами, придумать такие, на какие Вам хватит фантазии.