Save file dialog in excel vba - Word и Excel - помощь в работе с программами

There may be times when you need to ask the user to select a location to save a file. This can be done using a save file dialog. Keep in mind that a save file dialogs doesn’t actually save anything. It only returns the full path the user has selected to save the file. There are several different methods for creating a save file dialog. One of the methods is explained in the article Excel VBA Save File Dialog, FileDialog(msoFileDialogSaveAs). The method explained there has some pros and cons:

Pros:

The FileDialog(msoFileDialogSaveAs) is available for VBA in all office products

Cons:

You can’t apply a filter to the file types.

The method I will explain in this article uses the command, GetSaveAsFilename(). This method also has some pros and cons:

Pros

You can apply filters to the file types.

Cons

It is only available for VBA in Excel

Jump To:

Example 1
Example 2, File Filters
Example 3, Multiple Filters
Example 4, Custom Title
Example 5, Start Location

You can download the file and code related to this article here.

–

Example 1:

In this example a dialog will open asking the user to select a location to save the file. The path selected will be printed in cell A2. Note the save file dialog will not actually save the file. It will only provide the full path the user has selected to save the file:

Sub Example1() Dim varResult As Variant 'displays the save file dialog varResult = Application.GetSaveAsFilename 'checks to make sure the user hasn't canceled the dialog If varResult <> False Then Cells(2, 1) = varResult End If End Sub

Result:

The user selected the directory “D:Temp” and the name “Test”. The full path can be seen in cell A2:

–

Example 2, File Filters:

There was a problem with Example 1. There were no file filters to choose from:

The result path was “D:TempTest.”. A path with no file extension. If you try to save an excel file using that path you will end up with an unrecognized file type:

In order for this not to happen you have 2 options:

Option 1: Ask the user to input the file extension every time he decides to save a file:

This would be very annoying on the users side.

Option 2: Apply filters to the save file dialog.

The code below opens a save file dialog with the .xlsx filter. Note the save file dialog will not actually save the file. It will only provide the full path the user has selected to save the file:

Sub Example2() Dim varResult As Variant 'displays the save file dialog varResult = Application.GetSaveAsFilename( _ FileFilter:="Excel Files (*.xlsx), *.xlsx") 'checks to make sure the user hasn't canceled the dialog If varResult <> False Then Cells(2, 1) = varResult End If End Sub

Result:

The path selected is printed in cell A2:

As you can see this time the .xlsx extension was added to the file path.

–

Example 3, Multiple Filters:

Sometime you might want to give the user the option to choose the file extension from multiple available extensions. The example below creates 2 filters a .xlsx and a .xlsm:

Sub Example3() Dim varResult As Variant 'displays the save file dialog varResult = Application.GetSaveAsFilename(FileFilter:= _ "Excel Files (*.xlsx)," & "*.xlsx, Macro Enabled" & _ "Workbook (*.xlsm), *xlsm") 'checks to make sure the user hasn't canceled the dialog If varResult <> False Then Cells(2, 1) = varResult End If End Sub

Result:

–

Example 4, Custom Title:

The default title for the save file dialog is “Save As”:

The code below changes the dialogs title to “Some Random Title”:

Sub Example4() Dim varResult As Variant 'displays the save file dialog varResult = Application.GetSaveAsFilename(FileFilter:= _ "Excel Files (*.xlsx),*.xlsx, Macro Enabled Workbook " & _ "(*.xlsm), *xlsm", Title:="Some Random Title") 'checks to make sure the user hasn't canceled the dialog If varResult <> False Then Cells(2, 1) = varResult End If End Sub

Result:

–

Example 5, Start Location:

You can tell the dialog to start in a specific folder. In the example below the save file dialog will start in the directory “D:TempFolder to Start”:

Sub Example5() Dim varResult As Variant 'displays the save file dialog varResult = Application.GetSaveAsFilename(FileFilter:= _ "Excel Files (*.xlsx), *.xlsx, Macro Enabled Workbook" & _ "(*.xlsm), *xlsm", Title:="Some Random Title", _ InitialFileName:="D:TempFolder to Start") 'checks to make sure the user hasn't canceled the dialog If varResult <> False Then Cells(2, 1) = varResult End If End Sub

Result:

You can download the file and code related to this article here.

Save Workbook – VBA

The VBA Save command saves an Excel file similarly to clicking the Save icon or using the Save Shortcut (CTRL + S).

Save a Specified Workbook

To save a workbook, reference the workbook object and use the Save command.

Workbooks("savefile.xlsm").Save

Save the Active Workbook

Note: This is the current active workbook from with in the VBA code, which is different from ThisWorkbook which contains the running code.

ActiveWorkbook.Save

VBA Coding Made Easy

Stop searching for VBA code online. Learn more about AutoMacro – A VBA Code Builder that allows beginners to code procedures from scratch with minimal coding knowledge and with many time-saving features for all users!

Learn More!

Save the Workbook Where the Code is Stored

ThisWorkbook.save

Save all Open Workbooks

This will loop through all open workbooks, saving each one.

Dim wb as workbook

For Each wb In Application.Workbooks
	wb.Save
Next wb

Save all open workbooks that were not opened ReadOnly

Note: opening a workbook in ReadOnly mode prevents the file from being saved.
To save the file you will need to use Save As and save the file with a different name.

Dim wb as workbook

For Each wb In Application.Workbooks
	If not wb.ReadOnly then
		wb.Save
	End if
Next wb

Save a workbook defined by a variable

This will save a workbook that was assigned to a workbook object variable.

Dim wb as workbook

set wb = workbooks("savefile.xlsm")
wb.save

Save a workbook defined by a string variable

This will save a workbook that’s name was saved to a string variable.

Dim wbstring as string

wbstring = "savefile.xlsm"
workbooks(wbstring).save

Save a workbook defined by the order it was opened.

Note: The first workbook opened would have 1, the second 2, etc.

workbooks(1).save

VBA Programming | Code Generator does work for you!

Save a workbook based on a cell value

This will save a workbook that’s name is found in a cell value.

Dim wbstring as string

wbstring = activeworkbook.sheets("sheet1").range("wb_save").value
workbooks(wbstring).save

Save As – VBA

The VBA Save As command saves an Excel file as a new file, similar to clicking the Save As icon or using the Save As Shortcut (Alt > F > A).
Above, we identified all the ways to specify which workbook to save. You can use those exact same methods to identify workbooks when using Save As.

Save As behaves similarly to Save, except you also need to specify the name of the new file.
In fact, Save As has many potential variables to define:

SaveAs Syntax:

workbook object .SaveAs(FileName, FileFormat, Password, WriteResPassword, _
ReadOnlyRecommended, CreateBackup, AccessMode, ConflictResolution, _
AddToMru,TextCodepage, TextVisualLayout, Local)

A full description of all of the SaveAs arguments is included below. For now we will focus on the most common examples.
Note: These arguments can be entered as string with parenthesis or as defined variables.

Save As Syntax Examples:

Workbook Save As – Same Directory

ActiveWorkbook.SaveAs Filename:= "new"

ActiveWorkbook.SaveAs "new"

Dim wbstring as string

wbstring = "new"
ActiveWorkbook.SaveAs Filename:= wbstring

AutoMacro | Ultimate VBA Add-in | Click for Free Trial!

Workbook Save As – New Directory

ActiveWorkbook.SaveAs Filename:= "C:new"

Dim wbstring as string

wbstring = "C:new"
ActiveWorkbook.SaveAs Filename:= wbstring=

Workbook Save As – New Directory, Specify File Extension

ActiveWorkbook.SaveAs Filename:= "C:new.xlsx"

Dim wbstring as string

wbstring = "C:new.xlsx"
ActiveWorkbook.SaveAs Filename:= wbstring

Workbook Save As – New Directory, Specify File Extension – Alt Method

You can also specify the file format in it’s own argument.

.xlsx = 51 '(52 for Mac)
.xlsm = 52 '(53 for Mac)
.xlsb = 50 '(51 for Mac)
.xls = 56 '(57 for Mac)

ActiveWorkbook.SaveAs Filename:= "C:new", FileFormat:= 51

Workbook Save As – Add Password to Open File

ActiveWorkbook.SaveAs Filename:= "C:new.xlsx", Password:= "password"

AutoMacro | Ultimate VBA Add-in | Click for Free Trial!

Workbook Save As – Add Password for Write Privileges

If correct password is not supplied then workbook opens as Read-Only

ActiveWorkbook.SaveAs Filename:= "C:new.xlsx", WriteRes:= "password"

Workbook Save As – Read-Only Recommended

TRUE to display a message box, recommending that the file is opened read-only.

ActiveWorkbook.SaveAs Filename:= "C:new.xlsx", ReadOnlyRecommended:= TRUE

Other Save As Examples

Create Save As Dialog Box

This Generates the Save As Dialog Box, prompting the user to Save the file.
Keep in mind that this simple code may not be appropriate in all cases.

Application.GetSaveAsFilename

AutoMacro | Ultimate VBA Add-in | Click for Free Trial!

Create Save As Dialog Box with Default File Name Provided

Application.GetSaveAsFilename InitialFilename:="test.xlsx"

Create Save As Dialog Box with Default File Name Provided

Application.GetSaveAsFilename InitialFilename:="test.xlsx"

Create & Save New Workbook

This will create a new workbook and immediately save it.

Dim wb As Workbook

Set wb = Workbooks.Add
Application.DisplayAlerts = False
wb.SaveAs Filename:=”c:Test1.xlsx”
Application.DisplayAlerts = True

Disable Save Alerts

As you work with saving in VBA, you may come across various Save Warnings or Prompts. To disable warnings, add this line of code:

Application.DisplayAlerts=False

and to re-able alerts:

Application.DisplayAlerts=True

Источник

If you’ve worked with Excel before, you’re probably quite familiar with 2 basic commands for saving workbooks:

Save.
Save As.

It may not surprise you to know that, when working with VBA, you can carry out these same activities.

In fact, knowing how to save Excel workbooks using VBA is essential. As you work with Visual Basic for Applications, you’ll notice that saving workbooks is one of the most important things your macros can do.

Due to the importance of knowing how to save workbooks using VBA, this Excel tutorial focuses on this particular topic:

How to save an Excel workbook using VBA.

In addition to providing some examples of VBA code that you can use to save workbooks, I explain the basics surrounding 4 VBA methods that you’re likely to encounter and use constantly while saving workbooks. The following table of contents shows the specific topics that I explain in this Excel tutorial:

How To Save An Excel Workbook Using the Workbook.Save VBA Method
How To Save An Excel Workbook Using The Workbook.SaveAs VBA Method
- How To Save An Excel Workbook With A New Name Using The Workbook.SaveAs Method
- The Workbook.SaveAs Method: Parameters
How To Save A Copy Of An Excel Workbook Using The Workbook.SaveCopyAs VBA Method
- Part #1: ActiveWorkbook.SaveCopyAs
- Part #2: Filename:=ActiveWorkbook.Path & “Copy ” & Format(Now, “yy-mm-dd”) & ” ” & ActiveWorkbook.Name
- How To Save A Copy Of An Excel Workbook Using The Workbook.SaveCopyAs VBA Method: An Example
How To Name A Workbook Using The Application.GetSaveAsFilename Method
- The Application.GetSaveAsFilename Method: Purpose
- The Application.GetSaveAsFilename Method: Syntax
- The Application.GetSaveAsFilename Method: Arguments
Conclusion

This Excel tutorial doesn’t cover the topic of saving an Excel workbook as PDF using VBA. I explain how to export an Excel file to PDF using macros, and provide several code examples, here.

Let’s start taking a look at the basic ways to save an Excel workbook using VBA.

How To Save An Excel Workbook Using the Workbook.Save VBA Method

The most basic method to save Excel workbooks using VBA is the Workbook.Save method. Workbook.Save saves the relevant workbook.

In other words, the Workbook.Save method is, roughly, the VBA equivalent of the Save command in Excel.

The syntax of the Workbook.Save method is as follows:

expression.Save

Where “expression” is the relevant Workbook object you want to save.

Let’s take a look at an example to make this clearer. The following macro, named “Save_Workbook”, saves the current active workbook:

This Excel VBA Save Workbook Tutorial is accompanied by an Excel workbook containing the data and macros I use (including the Save_Workbook macro). You can get immediate free access to this example workbook by subscribing to the Power Spreadsheets Newsletter.

Notice that the macro has only 1 statement which follows the general syntax of the Workbook.Save method explained above:

ActiveWorkbook.Save

In this case, ActiveWorkbook is a simplified reference to the Application.ActiveWorkbook property. This property returns a Workbook object, as required by the Workbook.Save method. The workbook that is returned by the ActiveWorkbook property is, more precisely, the workbook in the current active window.

In summary, the sample Save_Workbook macro above simply saves the current active Excel workbook.

Just as when working directly with Excel, the Save method is an important command/method that is relatively easy and straightforward to execute. However, it doesn’t allow you to determine much in connection with the way the relevant Excel workbook is saved. The workbook is saved and that’s pretty much it.

When working directly in Excel, you use the Save As command if you want to be able to determine more about the way the actual saving of a workbook takes place. Things work in a similar fashion within Visual Basic for Applications.

More precisely, when working with Visual Basic for Applications, you can use the SaveAs method for these purposes. So let’s take a look at:

How To Save An Excel Workbook Using The Workbook.SaveAs VBA Method

The arguments or parameters of a method are what allows you to determine the characteristics of the action that a particular method performs.

As explained above, the Workbook.Save method doesn’t have any parameters. As a consequence, you can’t really determine much about how the relevant workbook is saved.

The Workbook.SaveAs method is different. Its 12 parameters allow you to further determine several aspects about the way in which an Excel workbook is saved. In other words, Workbook.SaveAs is more flexible and complex than Workbook.Save.

Workbook.SaveAs is, roughly speaking, the VBA equivalent of the Save As command in Excel. Therefore, it allows you to save a workbook in a particular file. The complete syntax of the Workbook.SaveAs method is as follows:

expression.SaveAs(FileName, FileFormat, Password, WriteResPassword, ReadOnlyRecommended, CreateBackup, AccessMode,ConflictResolution, AddToMru, TextCodepage, TextVisualLayout, Local)

“expression” is, just as in the case of the Workbook.Save method above, the relevant Workbook object.

All of the parameters (which appear within parentheses) of the SaveAs method are optional. However, in order to understand what this method can help you with, I explain these parameters below.

However, as usual, I use a practical macro example for purposes of illustrating how Workbook.SaveAs works. So let’s start by taking a look at the basic VBA code of the macro example:

How To Save An Excel Workbook With A New Name Using The Workbook.SaveAs Method

The following piece of VBA code saves the current active workbook with a new name provided by the user.

Dim workbook_Name As Variant

workbook_Name = Application.GetSaveAsFilename

If workbook_Name <> False Then

ActiveWorkbook.SaveAs Filename:=workbook_Name

End If

The following screenshot shows the VBA code behind the example macro (called “Save_Workbook_NewName”) which is included in the Excel workbook that accompanies this Excel VBA Save Workbook Tutorial. You can get immediate free access to this example workbook by subscribing to the Power Spreadsheets Newsletter.

This macro can be divided in the following 3 parts:

Let’s take a quick look at each of these parts to understand how the Save_Workbook_NewName macro works:

Part #1: Dim workbook_Name As Variant

This statement simply declares a variable named workbook_Name. The variable is of the Variant data type.

Even though Variant variables are sometimes undesirable, in this particular case that’s not necessarily the case. A Variant variable allows the GetSaveAsFilename (which I introduce below) to be quite flexible.

As implied by its name, and made evident by the following parts of the macro, the purpose of the workbook_Name variable is to store the new name of the saved Excel workbook.

Part #2: workbook_Name = Application.GetSaveAsFilename

This statement assigns a value to the workbook_Name variable. Which value is actually assigned is determined by the Application.GetSaveAsFilename method, which I explain thoroughly below.

At its most basic level, the GetSaveAsFilename method, does the following 2 things:

Step #1: Displays the Save As dialog box.
You’re probably quite familiar with this dialog box, as it’s the one Excel displays when you execute the Save As command.
Step #2: Once the user has provided a file name through the Save As dialog box, GetSaveAsFilename gets that particular name.
This is the name that the whole statement we’re analyzing assigns to the variable workbook_Name.

Note that the Application.GetSaveAsFilename method doesn’t actually save a file. It simply gets a name.

To actually save the file using the name provided by the GetSaveAsFilename method, you usually rely on the Workbook.SaveAs method. This method is used in the last part of the Save_Workbook_NewName macro:

Part #3: If workbook_Name <> False Then ActiveWorkbook.SaveAs Filename:=workbook_Name End If

This is an If… Then… Else statement. These type of statements conditionally execute a particular group of statement depending on whether a condition is met or not. The statement begins with the word If. The whole block finishes with the End If statement.

In the case of the Save_Workbook_NewName macro, the If… Then… Else statement proceeds as follows:

Step #1: Test Whether workbook_Name <> False.

The first part of the If… Then… Else statement carries out a logical test. This logical test seeks to confirm whether the variable workbook_Name has a value that is different from (<>) the logical value False.

If the value of workbook_Name isn’t False, the logical test (workbook_Name <> False) evaluates to True. In such a case, the statements within the If… Then… Else are executed.

However, if the value of workbook_Name is equal to the Boolean value False, the logical test evaluates to False. In this case, the conditional statements aren’t executed.

For purposes of this logical test, the value of the variable workbook_Name is that assigned in the previous part. Therefore, the value depends on the input given by the user when the Save As dialog box is displayed. More precisely:

If the user cancels the Save As dialog box, the value of workbook_Name is False.
If the user provides a file name through the Save As dialog box, the value of the workbook_Name variable is (generally) that assigned by the user.

In other words:

If the user provides a file name:
- The logical test carried out by the first part of the If… Then… Else statement is True; and
- The conditional statements that follow are executed.
If the user cancels the Save As dialog box (by, for example, clicking on the Cancel button):
- The logical test is False; and
- The conditional statements within the If… Then… Else statement aren’t executed.

Step#2: Execute The Statement ActiveWorkbook.SaveAs Filename:=workbook_Name If The Tested Condition Is True.

You already know that, roughly speaking, the logical test workbook_Name <> False returns True if the user has assigned a file name through the Save As dialog box.

In such case, the following statement is executed:

ActiveWorkbook.SaveAs Filename:=workbook_Name

This is where the Workbook.SaveAs method comes into play. This statement does the following:

Step #1: Uses the Application.ActiveWorkbook property to return the workbook in the current active window.
Step #2: Saves the active workbook in a file whose name is that given by the user through the Save As dialog displayed by the GetSaveAsFilename method.

In this particular case, only 1 argument of the Workbook.SaveAs method is used: Filename. The Filename argument, as implied by its name, allows you to specify the name of the saved workbook.

I explain more about the Filename argument, and the other arguments of the SaveAs method, in the sections below.

If the tested condition isn’t true, no further statements are executed. In other words, the workbook isn’t saved when the used has cancelled the Save As dialog box.

The Workbook.SaveAs Method: Parameters

The following table introduces the 10 most important optional parameters of the Workbook.SaveAs method:

Position	Name	Description
1	Filename	Name of saved workbook.
2	FileFormat	File format for saved workbook.
3	Password	Protection password for saved workbook
4	WriteResPassword	Write-reservation password for saved workbook.
5	ReadOnlyRecommended	Determines whether workbook is saved as read-only recommended.
6	CreateBackup	Determines whether a backup file of the saved workbook is created.
7	AccessMode	Determines the access mode of the saved workbook.
8	ConflictResolution	Applies only if saved workbook is shared. Determines how conflicts that show up when saving are resolved.
9	AddToMru	Determines whether saved workbook is added to list of recently used files.
12	Local	Determines whether the workbook is saved against the language of Excel (usually local) or VBA (usually US-English).

2 parameters of the SaveAs method (#10, TextCodepage and #11, TextVisualLayout) aren’t included in the table above nor explained below. According to Microsoft’s Official Documentation (at the time of writing), both of these parameters are ignored.

Let’s take a closer look at each of the individual arguments of Workbook.SaveAs:

Argument #1: Filename

As implied by its name, you use the Filename argument of the Workbook.SaveAs method to specify the name of the saved workbook.

When working with the Filename argument, you can either:

Specify the full file path; or
Don’t specify the file path.

If you don’t specify the file path, Excel saves the workbook in the current folder.

For most users, specifying the file path isn’t very convenient. You (or the user) need to specify accurate file paths, names and extensions. The approach is tedious and error prone.

This is the main reason why the Application.GetSaveAsFilename used in the Save_Workbook_NewName is so helpful: it allows the user to browse the different folders and easily specify the full file path and name of the saved Excel workbook.

The initial basic version of the Save_Workbook_NewName macro uses the Filename argument, as shown in the screenshot below:

Argument #2: FileFormat

You can use the FileFormat argument of the Workbook.SaveAs method to specify the file format of the saved file.

If you don’t use the FileFormat argument, Excel determines the file format as follows:

In the case of workbooks that already exist, the workbook is saved using the same file format as the last time.
If the workbook is new, the workbook is saved using the format of the Excel version you’re using.

Even though this parameter (as all other arguments of the SaveAs method) is optional, you may want to develop the habit of using it.

You specify a particular file format using the XlFileFormat enumeration. The Microsoft Developer Network lists more than 50 different possible values.

In practice, you’re unlikely to need/use so many different formats. In fact, some of the formats that are listed at the Microsoft Developer Network are not supported in the more recent versions of Excel.

Therefore, I provide a basic overview and breakdown of the XlFileFormat values that you may actually encounter. Even though this list is much shorter than that at the Microsoft Developer Network, you’re still likely to use only a subset of the values I explain below.

The following are the 4 main file formats in Excel 2007-2013:

50: xlExcel12.
51: xlOpenXMLWorkbook.
52: xlOpenXMLWorkbookMacroEnabled.
56: xlExcel8.

As a general rule, it’s better to use the FileFormat values (numbers) instead of the names. The reason for this is that this avoids some compilation problems whenever you execute the relevant macro in an older version of Excel that may not recognize the name.

So let’s a look at some of the values that the FileFormat argument can take:

Value	Name	Description
Add-Ins And Templates
17	xlTemplate / xlTemplate8	Template / Template 8. Generally used in versions between Excel 97 and Excel 2003.
18	xlAddIn / xlAddIn8	Excel 1997 to 2003 Add-In.
53	xlOpenXMLTemplateMacroEnabled	Macro-Enabled Open XML template.
54	xlOpenXMLTemplate	Open XML template.
55	xlOpenXMLAddIn	Open XML Add-In.
Text Files
-4158	xlCurrentPlatformText	Text file format for platform in which workbook is saved.
2	xlSYLK	Symbolic Link Format file. Only the active sheet is saved.
6	xlCSV	CSV (comma-separated values) text file format.
9	xlDIF	Data Interchange Format file. Only saves the current active sheet.
19	xlTextMac	Mac text file format. Ensures that basic formatting (such as tab and line breaks) and characters are interpreted correctly. xlTestMac saves only the active sheet.
20	xlTextWindows	Windows text file format. Ensures that basic formatting (such as tab and line breaks) and characters are interpreted correctly. xlTestWindows saves only the active sheet.
21	xlTextMSDOS	MSDOS text file format. Ensures that basic formatting (such as tab and line breaks) and characters are interpreted correctly. xlTestMSDOS saves only the active sheet.
22	xlCSVMac	CSV file format for Mac platform. Ensures that basic formatting (such as tab and line breaks) and characters are interpreted correctly. xlCSVMac saves only the active sheet.
23	xlCSVWindows	CSV file format for Windows platform. Ensures that basic formatting (such as tab and line breaks) and characters are interpreted correctly. xlCSVWindows saves only the active sheet.
24	xlCSVMSDOS	CSV file format for MS-DOS platform. Ensures that basic formatting (such as tab and line breaks) and characters are interpreted correctly. xlCSVMSDOS saves only the active sheet.
36	xlTextPrinter	Formatted text file. Only saves the current active worksheet.
42	xlUnicodeText	Unicode text file format.
Spreadsheets (Excel and Others)
-4143	xlWorkbookNormal	Excel workbook file format.
39	xlExcel5 / xlExcel7	Excel versions from 1993 (Excel 5.0) and 1995 (Excel 7.0).
43	xlExcel9795	Excel versions from 1995 and 1997. However, as explained by author Richard Mansfield in Mastering VBA for Microsoft Office 2013, this file format is generally compatible with Excel 95 and later versions.
46	xlXMLSpreadsheet	XML spreadsheet file format. Generally used in Excel 2003.
50	xlExcel12	Excel 2007 version.
51	xlOpenXMLWorkbook / xlWorkbookDefault	Open XML workbook / Workbook default file format.
52	xlOpenXMLWorkbookMacroEnabled	Macro-Enabled Open XML workbook.
56	xlExcel8	Excel version from 1997.
60	xlOpenDocumentSpreadsheet	Open Document Spreadsheet file format. OpenDocument Spreadsheet files can be opened using spreadsheet applications that use the OpenDocument Spreadsheet format. Examples of such applications are Google Sheets, Open Office Calc and Excel itself. Formatting may be affected when saving or opening Open Document Spreadsheet files.
61 (&H3D)	xlOpenXMLStrictWorkbook	ISO Strict Open XML file format.
Clipboard Files
44	xlHtml	HTML / webpage file format.

If you save the Excel workbook to a CSV or text file format, the following 2 things happen:

Excel selects the code page to use by checking the system locale configuration in the computer where the workbook is saved. The code page used is the one corresponding to the language for the system locale in use. In Windows 10, you can find these settings by going to Settings > Time & Language > Region & Language.
Excel saves the file in logical layout. This is relevant, in particular, when working with files containing bi-directional text, where text may be in different directions (left-to-right and right-to-left). Whenever text in one direction is embedded within text in the other direction, the logical layout saves the file in such a way that the reading order is correct for all languages being used, regardless of their directionality. Then, when such a file is opened later, all the text within the file is (generally) displayed in the appropriate direction. This direction is determined by the character value ranges of the code page being used.

Let’s go back to the sample Save_Workbook_NewName. The following screenshot shows how the VBA code of this macro looks like when I add the FileFormat argument and set its value to 52 (Macro-Enabled Open XML workbooks).

Argument #3: Password

The Password argument of the Workbook.SaveAs method allows you to (as you may expect) enter a password to protect the saved Excel workbook.

The Password argument has the following 3 main characteristics:

Is a string.
Is case-sensitive.
Its maximum length is 15 characters.

The following screenshot shows the VBA code behind the Save_Workbook_NewName macro with a password. In this case, the password is “Excel Tutorial”.

If you save a workbook using a macro such as the above, next time anyone (you or another user) tries to open the Excel workbook, Excel displays the Password dialog.

If the wrong password is entered, Excel doesn’t open the workbook. Instead, it displays a warning.

Argument #4: WriteResPassword

The WriteResPassword parameter of the Workbook.SaveAs method is, in some ways, similar to the Password argument that I explain above. However, Password and WriteResPassword differ in one essential characteristic:

They protect different things.

As explained above, Password protects the workbook. If you (or the relevant user) fail to provide the correct password, Excel doesn’t open the workbook.

WriteResPassword protects the write-reservation characteristic of the workbook. To see what this is, and how it works in practice, I add the WriteResPassword argument to the Save_Workbook_NewName macro. The password for these purposes is “Excel Course”.

The dialog box that Excel displays to ask for the WriteResPassword is slightly different than the one it uses when asking for the Password. Notice how it informs that the user who has saved the workbook reserved it and provides 2 options:

You can enter the password and Excel grants you write access.
Otherwise, you can open the workbook as read-only.

If I choose to open the workbook as read-only, Excel does precisely so. In that case, it warns in a few places that the workbook is read-only and changes aren’t saved.

If you enter the wrong WriteResPassword, Excel reacts in the same way as it does when you enter the wrong Password (as shown above). In other words, it doesn’t open the workbook and displays the following message:

Argument #5: ReadOnlyRecommended

The ReadOnlyRecommended argument provides you with a less strict way (when compared with the WriteResPassword above) to protect the Excel workbook you’re saving.

More precisely, if you set a particular workbook to be read-only recommended, Excel displays a message making such recommendation whenever the file is opened.

Setting a workbook to be read-only recommended doesn’t actually protect or reserve the workbook in the same way as the Password or the WriteResPassword do. Any user can open a read-only recommended Excel workbook normally (not as read-only) by, for example:

Clicking “No” in the dialog box above.
Setting the IgnoreReadOnlyRecommended argument of the Workbooks.Open argument to True when opening the workbook using VBA.

To determine that an Excel workbook is read-only recommended, you simply set the ReadOnlyRecommended argument to True.

Argument #6: CreateBackup

The CreateBackup argument of the Workbook.SaveAs method allows you to determine whether a backup of the workbook being saved is created.

If you want to create a backup of the saved Excel workbook, set the CreateBackup argument to True.

Argument #7: AccessMode

The AccessMode argument allows you to specify the access mode for the saved workbook. This argument can take the following 3 values:

1: Stands for xlNoChange. In this case, the default access mode is used.
2: Represents xlShared. In this case, the access mode is share list.
3: Value for xlExclusive. In this scenario, access mode is exclusive mode.

The following screenshot shows the VBA code of the Save_Workbook_NewName macro with the AccessMode parameter set to xlNoChange:

Argument #8: ConflictResolution

ConflictResolution applies when you’re working with shared workbooks. More precisely, this argument allows you to determine how conflicts (while saving the Excel workbook) are resolved.

You can set the ConflictResolution parameter to any of the following 3 values:

1: Stands for xlUserResolution. In this case, Excel displays a dialog box asking the user to resolve the conflict. This is the default setting in case you omit the ConflictResolution argument.
2: Represents xlLocalSessionChanges. If you choose this value, the changes made by the local user are accepted always.
3: The value for xlOtherSessionChanges. This is the opposite from the above: the changes made by the local user are rejected always.

The following screenshot shows the code of the Save_Workbook_NewName macro with the ConflictResolution parameter set to the default xlUserResolution.

Argument #9: AddToMru

MRU stands for Most Recently Used. This makes reference to Excel’s list of most recently used files which, generally, you find on the Backstage View.

The AddToMru argument of the Workbook.Save method allows you to determine whether the saved workbook is added to this most recently used list.

If AddToMru is set to True, the Excel workbook is added to the list. The default value of AddToMru is, however, False.

In the following image, you can see the VBA code behind the sample Save_Workbook_NewName macro with AddToMru set to True:

As mentioned above, I’m not covering in detail the TextCodePage and TextVisualLayout arguments (arguments #10 and #11).

Argument #12: Local

The last argument of the Workbook.SaveAs method is Local. As implied by its name, Local refers to language and localization aspects of the saved workbook.

More precisely, the Local parameter allows you to determine whether the saved workbook is saved against the language of:

Excel, as generally determined from the control panel setting; or
VBA, which is usually US-English. The basic exception to this rule of VBA’s language being US-English occurs when the VBA project that executes the Workbook.SaveAs method is an internationalized XL5/95 VBA project. My guess is that you’re unlikely to work with such projects often.

To determine how Excel proceeds in connection with this topic, you can set the Local argument to True or False.

True: Saves the workbook against Excel’s language.
False: Saves the Excel workbook against VBA’s language.

In the following image, you can see the sample Save_Workbook_NewName with the Local parameter set to True:

How To Save A Copy Of An Excel Workbook Using The Workbook.SaveCopyAs VBA Method

The Save and SaveAs methods explained above are the basic methods you’ll need to save Excel workbooks using VBA.

However, both of these methods save and modify the current open Excel workbook. You may encounter some situations where this isn’t the outcome you desire.

In other words, you’ll probably be in situations where you want a macro to simply:

Save a copy of the current Excel workbook, but…
Don’t actually modify the current file in the memory of the computer.

These type of situations are great for using the Workbook.SaveCopyAs VBA method. This method does precisely this. It takes the workbook and:

Saves a copy to a file.
Doesn’t modify it in memory.

The syntax of the SaveCopyAs method is, once again, relatively simple:

expression.SaveCopyAs(Filename)

Just as with the other methods explored in this Excel tutorial, “expression” represents a Workbook object. “Filename”, the only parameter of the SaveCopyAs method is the full file path, name and extension of the copy that you’re saving.

Since you’re likely to use this method on the active workbook most of the time, you’ll probably end up using the following syntax often:

ActiveWorkbook.SaveCopyAs(Filename)

Another commonly used alternative is to use the ThisWorkbook property instead of ActiveWorkbook. The main difference between ThisWorkbook and ActiveWorkbook is that:

ActiveWorkbook refers to the current active workbook.
ThisWorkbook refers to the workbook where the macro is actually stored.

Let’s take a look at an example of a macro that uses the Workbook.SaveCopyAs method to save a copy of the current active workbook:

The screenshot below shows a macro called “Save_Copy_Workbook”.

This macro has a single (quite long) statement. This goes as follows:

ActiveWorkbook.SaveCopyAs Filename:=ActiveWorkbook.Path & “Copy ” & Format(Now, “yy-mm-dd”) & ” ” & ActiveWorkbook.Name

Notice that the structure I use in the Save_Copy_Workbook macro follows the basic syntax of the Workbook.SaveCopyAs method explained above. However, let’s split the statement in 2 parts in order to understand better what’s going on, and what can this particular method do for you:

Part #1: ActiveWorkbook.SaveCopyAs

This is the reference to the SaveCopyAs method. It follows the basic syntax explained above.

“ActiveWorkbook” makes reference to the Application.Workbook property. This property returns a Workbook object representing the current active workbook. This active workbook is the one which is manipulated by the SaveCopyAs method.

In other words, the statement simply tells Excel to proceed as follows:

Step #1: Take the current active workbook.
Step #2: Save a copy of the current active workbook, without actually modifying it in memory.

Part #2: Filename:=ActiveWorkbook.Path & “Copy ” & Format(Now, “yy-mm-dd”) & ” ” & ActiveWorkbook.Name

This part of the statement specifies the only argument of the Workbook.SaveCopyAs method:

The Filename.

This particular file name for the copy is slightly long but, basically, is built by concatenating 5 items. You use the ampersand (&) operator to concatenate the different items.

Item #1: ActiveWorkbook.Path

This makes reference to the Workbook.Path property. The Path property returns the complete path to the relevant workbook.

In the case of the example above, “ActiveWorkbook.Path” is used to get the path to the current active workbook.

Let’s assume, for example, that the current active workbook (called “Book1”) is saved in the D drive. In this case the path is, simply “D:”.

This sample path (D:) isn’t very long or complicated. However, in practice, you’re more likely to work with longer and more complicated paths that you are to work with just the D drive.

Items #2 And #4: “Copy ” and ” “

This are, simply, text strings. The first string specifies that the first word in the file name is “Copy”. The second string adds a space ( ).

Item #3: Format(Now, “yy-mm-dd”)

This particular statement uses 2 VBA built-in functions, as follows:

Now returns today’s date and the current time. Alternatively, you can use the Date function, which returns the current date.
Format takes the date returned by Now and formats it according to the date format “yy-mm-dd”.

In other words, this part of the argument is responsible for returning the date in which the copy is saved in the format yy-mm-dd.

For example, if the date in which you save the copy of the workbook is November 30 of 2015, this item returns 15-11-30.

Item #5: ActiveWorkbook.Name

This item uses the Workbook.Name property to get the name of the workbook.

For example, if the name of the workbook is “Best Excel Tutorial”, Workbook.Name returns exactly that.

In order to make everything clear regarding the Workbook.SaveCopyAs method, let’s take a look at an example:

How To Save A Copy Of An Excel Workbook Using The Workbook.SaveCopyAs VBA Method: An Example

Let’s assume that the current active workbook is called “Best Excel Tutorial” and is saved in the D drive (D:). This is how the D drive looks like before I run the sample Save_Copy_Workbook macro:

The following screenshot shows how the same drive looks after I run the macro. Notice how, now, there’s a new Excel workbook. This is the copy created by the Save_Copy_Workbook Sub procedure.

Let’s go back to the Filename argument of the SaveCopyAs method used within the Save_Copy_Workbook macro:

Filename:=ActiveWorkbook.Path & “Copy ” & Format(Now, “yy-mm-dd”) & ” ” & ActiveWorkbook.Name

Notice how, each of the 5 items explained above expresses itself in practice once the macro is run:

Item #1: The copy is saved in the same folder as the original workbook, as given by the Workbook.Path property.
Items #2 and #4: The first word in the actual workbook name is Copy, as determined by the string “Copy”. Also, there is a space between the date (15-11-19) and the original workbook’s name (Best Excel Tutorial) as specified by ” “.
Item #3: The date in which the workbook is saved (November 19 of 2015 in the example above) is added to the name in the format yy-mm-dd (15-11-19).
Item #5: The name of the original workbook (Best Excel Tutorial) is added at the end of the copy’s name.

The following image shows this:

How To Name A Workbook Using The Application.GetSaveAsFilename Method

I introduced the Application.GetSaveAsFilename method above. This method is used by one of the sample macros (Save_Workbook_NewName) for purposes of opening the Save As dialog box and allow users to easily browse and enter the path, name and file extension of the saved Excel workbook.

The screenshot below shows the VBA code of the Save_Workbook_NewName macro. Notice the presence of the Application.GetSaveAsFilename method.

The Application.GetSaveAsFilename method doesn’t actually save a file. However, GetSaveAsFilename is a helpful method to use whenever you have a macro that needs to get a file name from the user in order to, among others, save a workbook.

GetSaveAsFilename is useful when the procedure needs to receive/know the name of the file to save. This gives the user the possibility of specifying the file’s path and filename.

As I explain below, you can use the Application.GetSaveAsFilename method precisely for these purposes.

The GetSaveAsFilename method has a few parameters that allow you to customize some of its characteristics. Let’s take a closer look at the method itself and its arguments, starting with:

The Application.GetSaveAsFilename Method: Purpose

The Application.GetSaveAsFilename method does 2 things:

Displays the Save As dialog box.
Gets the file name entered by the user in the Save As dialog box.

GetSaveAsFilename doesn’t save a workbook by itself. That’s why, for example, the Save_Workbook_NewName macro above includes uses the Workbook.SaveAs method to actually save the Excel workbook.

The Application.GetSaveAsFilename Method: Syntax

The full syntax of the Application.GetSaveAsFilename method is as follows:

expression.GetSaveAsFilename(InitialFilename, FileFilter, FilterIndex, Title, ButtonText)

“expression” is used to represent the Application object. You’re, therefore, likely to usually use the following basic syntax for this method:

Application.GetSaveAsFilename

This is the syntax used in the version of the Save_Workbook_NewName method shown above.

All of the 5 arguments of the GetSaveAsFilename method are optional. Let’s take a look at them:

The Application.GetSaveAsFilename Method: Arguments

The following table provides a basic description of the 5 parameters of the Application.GetSaveAsFilename method. I explain each of them more thoroughly below.

Position	Name	Description
1	InitialFilename	Specifies a suggested/default file name.
2	FileFilter	Determines file filtering criteria.
3	FilterIndex	Determines the default file filter.
4	Title	Determines the title of the (usually called) Save As dialog box.
5	ButtonText	Applies only in the Mac platform. Determines the text of the (normally called) Save As button.

There are quite a few similarities between the GetSaveAsFilename method and the GetOpenFilename method (which I describe here). In terms of their arguments, the main differences are as follows:

GetSaveAsFilename has the InitialFilename argument. GetOpenFilename doesn’t.
GetOpenFilename has the MultiSelect argument. GetSaveAsFilename doesn’t.

Both of these differences make sense. For example, MultiSelect allows you to determine whether a user can select multiple file names at the same time. This makes sense in the context of opening files. But not in the context of saving files with the GetSaveAsFilename method.

Let’s take a look at each of the parameters introduced above:

Argument #1: InitialFilename

The InitialFilename of the Application.GetSaveAsFilename method allows you to set a suggested file name. This suggested file name is the one that appears, by default, in the File name box of the Save As dialog.

The Save As dialog box displayed above is the result of running the following version of the Save_Workbook_NewName macro. Notice that the InitialFilename argument is added and the suggested name is “Best Excel Tutorial”, as displayed in the image above.

Argument #2: FileFilter

The FileFilter argument of the Application.GetSaveAsFilename method allows you to determine the criteria for file filtering within the Save As dialog box.

These file filtering criteria determine what appears in the Save as type drop-down list box of the Save As dialog box. If you omit the FileFilter argument, the default (as shown in the image below) is All Files.

This isn’t ideal because it may lead to the saved Excel workbook being of an unrecognizable file type if the user doesn’t enter the file extension when saving the file.

However, my guess is that you’ll be in situations where specifying the file filtering criteria is more convenient or, even, necessary. In order to be able to determine which file filters appear in the Save As dialog box, you’ll need to follow the 4 guidelines below.

Don’t worry if the guidelines don’t seem that clear at first. I show you a practical example of VBA code after making the introduction and basic description.

Guideline #1: Each Filter Consists Of A Pair Of Strings.

Each filter you specify when using the FileFilter argument is made up of 2 strings separated by a comma. This looks, roughly, as follows:

String1,String2

String1 and String2 have different structures and purposes. More precisely:

String1: Is a descriptive string. This string determines what actually appears in the Save as type drop-down box of the Save As dialog box.
String2: Is the MS-DOS wildcard file-type filter specification. In other words, this string determines how the files are actually filtered depending on their file format.

You don’t need to follow many guidelines regarding the way in which the first string (String1) is specified. However, you do need to follow a more specific syntax when specifying the second string (String2). Let’s take a look at it:

Guideline #2: Syntax To Specify The File-Type Filter.

The second string that you use to specify a file filter is itself composed of 3 elements which are, generally speaking, as follows:

Element #1: An asterisk (*), used as a wildcard.
Element #2: A dot (.).
Element #3: An indication of the file extension used to filter the files. This particular element is usually composed of (where appropriate) an asterisk (*), used as a wildcard, and/or (if appropriate), some text.

The most basic filter is all files, which in practice means that there’s no filter. To specify a file-type filter than includes all files using the syntax above, you’d type asterisk dot asterisk (*.*).

Other examples of file-type filter specifications following this syntax are the following:

*.txt for text files.
*.xla for add-ins.
*.xlsx for Excel workbooks.
*.xlsm for Macro-Enable Excel workbooks.
*.xls for Excel 97 to Excel 2003 workbooks.
*.csv for CSV files.

Knowing these first 2 guidelines is enough for you to start using the FileFilter argument. However, they only explain how to specify a single filter according to a single file type.

However, when working with FileFilter, you can actually specify:

Several different filters; as well as
Several different file types for each filter.

The next 2 guidelines show how you can do each of these:

Guideline #3: Syntax To Specify Several Filters.

You can create more than a single filter with the FileFilter argument. In order to so, use commas (,) to separate the filters. In other words, separate each of the pair of strings that constitute a filter from the other pair of strings by using commas (,).

This looks, roughly, as follows:

String1Filter1,String2Filter1,String1Filter2,String2Filter2

Guideline #4: Syntax To Specify Several File Types In A Single Filter.

If you need to filter according to several different data types, you can use several filters by using the syntax explained above.

Alternatively, you can specify several data types for a particular single filter. To do this, separate the MS-DOS wildcard expressions that you use with semicolons (;). This looks roughly as follows:

String1,String2.1;String2.2

Those are the 4 basic guidelines you need to bear in mind to start using the FileFilter argument. Let’s go back to the Save_Workbook_NewName macro and create some file filters:

The following screenshot shows (again) the VBA code behind Save_Workbook_NewName. Notice that the FileFilter argument has been inserted and its syntax follows all of the guidelines I explained above.

To make this clearer, let’s break the argument value into its different parts and highlight how it complies with all of the guidelines described above.

The complete argument is as follows:

“Excel Workbook,*.xlsx,Excel Macro-Enabled Workbook,*xlsm,Excel Templates,*.xltx;*.xltm”

Notice the following things:

There are 3 filters. Each of the filters is separated from the other by commas (,).
Each filter is composed of 2 parts: a descriptive string and the relevant MS-DOS wildcard file-type filter specification. These 2 parts are separated by commas (,).
MS-DOS wildcard file-type filter specifications follow the syntax described above: (i) asterisk (*); (ii) dot (.); and (iii) file extension specification, without wildcard asterisks in this case.
The last filter uses 2 different file types. These file types are separated by a semicolon (;).

The following image shows how all of the above looks like in practice. Notice how, now, there are 3 different options within the Save as Type box of the Save As dialog box. These 3 filters are those created by the FileFilter argument of the Application.GetSaveAsFilename method.

Argument #3: FilterIndex

Notice how, in the image above, the default file filtering criteria is “Excel Workbook”. This is the first filter that was specified with the FileFilter argument.

You can, however, change the default file filtering criteria by using the FilterIndex argument. You do this by specifying the index number of the criteria you want to set as default.

As a consequence of the above, the FilterIndex argument can take any value between 1 (the first filter) and the number of filters you’ve specified with the FileFilter argument (3 in the example above).

If you set the FilterIndex value to a number higher than the amount of available filters (4 or higher in the case of the Save_Workbook_NewName macro), the first filter is used. In other words, the practical result of specifying an index number that is too high, is the same as that of omitting the FilterIndex parameter.

The following screenshot shows the code of the Save_Workbook_NewName macro with the FilterIndex parameter set to 2.

In the case of this macro, a FilterIndex value of 2 means that “Excel Macro-Enabled Workbook” is the new default filter.

Argument #4: Title

The Title argument of the Application.GetSaveAsFilename method allows you to modify the title of the (usually called) Save As dialog box. If you omit the argument, the default title (Save As) is maintained.

The following image shows how this argument can be used to change the title of the Save As dialog box when executing the Save_Workbook_NewName macro. In this case, the Title argument is set to “VBA Save Excel Workbook”.

When this macro is executed, the (previously called) Save As dialog looks as follows. Notice that the title has indeed changed to “VBA Save Excel Workbook”.

Argument #5: ButtonText

The ButtonText parameter is only applicable in the Mac platform. If you use this argument in Windows, it’s simply ignored.

For those cases where it is applicable, the ButtonText argument allows you to set the text that appears in the (usually known as) Save button.

Conclusion

Knowing how to save Excel workbooks using VBA is essential.

If you’ve read this Excel tutorial, you now know the basics of how to save workbooks using VBA. In fact, you’ve seen 3 different ways to achieve this:

Using the Workbook.Save method.
Using the Workbook.SaveAs method.
Using the Workbook.SaveCopyAs method.

Each of these cases is explained with the help of a real example of VBA code.

Additionally, in the last section of this blog post, I explained the Application.GetSaveAsFilename method. Even though this method doesn’t actually save a file by itself, it allows you to display the Save As dialog so that the users of your macro can easily specify the path and file name of the workbook they’re saving.

Источник

We already know how to open or save an Excel file in VBA. We simply use the Open and SaveAs method of Workbook object. But that requires hard-coding of the path of the file. But most of the time you will want the end user to select a file using GUI or say File Open or Save As Dialog box that lets the user choose the location of the file visually and easily.

In this article, we cover the code used for displaying workbook open dialog box and save as dialog box.

I have attached a workbook that you can download. Workbook attached to this article contains three macros

VBA Code to Open File Using Open File Dialog

In this code, we will use GetOpenFilename method of Application. The syntax of the GetOpenFilename method is:

Application.GetOpenFilename([FileFilter],[FilterIndex],[Title],[ButtonText],[MultiSelect])

[FileFilter]: You can define to show only one kind of file in the select folder. If you write «Excel-Files, *.xlsx, *.xls, *.xlsm» etc. then only excel files will be shown from the folder in the file open dialog box.

[FilterIndex]: It is the number of file filters you want to use.

[Title]: The Title of the dialog box.

[ButtonText]: For specifying the button text. Not important.

[MultiSelect]: It is a Boolean variable. If you set it True or 1, you will be able to select more than one file. If you set it false, you can only select only one file.

Enough of the theory. Let’s do some spells.

VBA Code To Open One File at a Time

Option Explicit

Sub OpenOneFile()

Dim FileName As Variant

'Displaying the open file dialog box
FileName = Application.GetOpenFilename("Excel-files,*.xls", _
    1, "Select One File To Open", , False)

'User didn't select a file
If TypeName(FileName) = "Boolean" Then Exit Sub

'Open the workbook
Workbooks.Open FileName

End Sub

How does it work?

When you run this segment of code, the GetOpenFilename method for the Application object will open an Open File Dialog box. The title of the dialog box will be «Select One File To Open» as we defined in the code. If you select a file then the Worbook.Open code will run and the file will be opened. If you don’t select a file, the sub will exit without running the Workbook.Open code.

VBA Code To Open One or More File at a Time

This segment of code will open the file open dialog box but you will be able to select more than one file at one time.

Sub OpenMultipleFiles()

Dim FileName As Variant, f As Integer

'Displaying the open file dialog box
FileName = Application.GetOpenFilename("Excel-files,*.xlsx", _
    1, "Select One Or More Files To Open", , True)

'User didn't select a file
If TypeName(FileName) = "Boolean" Then Exit Sub

'Open all the workbooks selected by user
For f = 1 To UBound(FileName)
    Workbooks.Open FileName(f)
Next f

End Sub

Note that here we have set the multiselect variable to True. This will enable the multiple selection of the file.

VBA Code to Open Save as Dialog Box

To open a Save As dialog box we will use the GetSaveAsFilename method of the Application object. Syntax of the method is:

Application.GetSaveAsFilename([InitialFileName],[FileFilter],[FilterIndex],[Title],[ButtonText])

[InitialFileName]: The initial file name. If you don’t rename the file while saving it, your file will be saved with this name.

[FilterIndex]: The filter index of the file.

[Title]: The title of the dialog box.

[ButtonText]: This is used in Mac system to change the name of the button.

Please follow below for the code

Sub SaveFile()

Dim FileName As Variant

'Displaying the saveas dialog box
FileName = Application.GetSaveAsFilename("MyFileName.xls", _
    "Excel files,*.xls", 1, "Select your folder and filename")

'User didn't save a file
If TypeName(FileName) = "Boolean" Then Exit Sub

'Save the workbook
ActiveWorkbook.SaveAs FileName

End Sub

SaveFile Macro uses GetSaveAsFilename method of Application object to open save as dialog box, assigning the file name, and selecting the location for saving the workbook.

So yeah guys, this is how you can use dialog box to open and save files using VBA. I hope it was helpful. If you have any doubts regarding this article or any other VBA topic, ask in the comments section below.

Related Articles:

Use a closed workbook as a database (DAO) using VBA in Microsoft Excel | To use a closed workbook as a database with DAO connection use this VBA snippet in Excel.

Use a closed workbook as a database (ADO) using VBA in Microsoft Excel | To use a closed workbook as a database with ADO connection use this VBA snippet in Excel.

Getting Started With Excel VBA UserForms | To insert data to database, we use forms. The Excel UserForms are useful for getting information from the user. Here is how you should start with VBA userforms.

Change the value/content of several UserForm-controls using VBA in Excel | To change the content of the userform controls use this simple VBA snippet.

Prevent a userform from closing when the user clicks the x-button by using VBA in Excel | To prevent the userform from closing when the user clicks on the x button of the form we use UserForm_QueryClose event.

Popular Articles:

50 Excel Shortcuts to Increase Your Productivity | Get faster at your task. These 50 shortcuts will make you work even faster on Excel.

The VLOOKUP Function in Excel | This is one of the most used and popular functions of excel that is used to lookup value from different ranges and sheets.

COUNTIF in Excel 2016 | Count values with conditions using this amazing function. You don’t need to filter your data to count specific value. Countif function is essential to prepare your dashboard.

How to Use SUMIF Function in Excel | This is another dashboard essential function. This helps you sum up values on specific conditions

Источник

Often in VBA we need to ask the users to select files or directories before we execute the actual functionality of our macro. Welcome to the VBA Open file dialog post. Today we will learn how to use the Application.FileDialog, to understand the various msoFileDialogFilePicker file dialog picking options and how to properly manage these dialogs.

Here is a simple example of a VBA File Dialog:

Dim fDialog As FileDialog
Set fDialog = Application.FileDialog(msoFileDialogFilePicker)

'Show the dialog. -1 means success!
If fDialog.Show = -1 Then
   Debug.Print fDialog.SelectedItems(1) 'The full path to the file selected by the user
End If

Application FileDialog function

Before we start let’s understand the Application.FileDialog function.

The Application.FileDialog has the following syntax:

Application.FileDialog( fileDialogType as MsoFileDialogType )

Parameter

MsoFileDialogType
An enumeration defining the type of file dialog to open. It has the following values:

Value	Description
msoFileDialogOpen	Open dialog box
msoFileDialogSaveAs	Save As dialog box
msoFileDialogFilePicker	File picker dialog box
msoFileDialogFolderPicker	Folder picker dialog box

Properties and functions

FileDialog properties

Property	Description
AllowMultiSelect	Allow to select more than one file or folder
ButtonName	Text displayed on the action button of a file dialog box
DialogType	Change the MsoFileDialogType (see above)
Filter	Set a file filter to filter file types user can select
InitialFileName	The initial path to be opened e.g. C:
InitialView	The initial file view. Can be one of the following: msoFileDialogViewDetails msoFileDialogViewLargeIcons msoFileDialogViewList msoFileDialogViewPreview msoFileDialogViewProperties msoFileDialogViewSmallIcons msoFileDialogViewThumbnail msoFileDialogViewWebView
SelectedItems	Collection of type FileDialogSelectedItems with all selected items
Title	Title of the Open file dialog window

Select files – msoFileDialogFilePicker

The msoFileDialogFilePicker dialog type allows you to select one or more files.

Select single files

The most common select file scenario is asking the user to select a single file. The code below does just that:

Dim fDialog As FileDialog, result As Integer
Set fDialog = Application.FileDialog(msoFileDialogFilePicker)
    
'Optional: FileDialog properties
fDialog.AllowMultiSelect = False
fDialog.title = "Select a file"
fDialog.InitialFileName = "C:"
'Optional: Add filters
fDialog.Filters.Clear
fDialog.Filters.Add "Excel files", "*.xlsx"
fDialog.Filters.Add "All files", "*.*"

'Show the dialog. -1 means success!
If fDialog.Show = -1 Then
   Debug.Print fDialog.SelectedItems(1)
End If

'Result: C:somefile.xlsx

Select multiple files

Quite common is a scenario when you are asking the user to select one or more files. The code below does just that. Notice that you need to set AllowMultiSelect to True.

Dim fDialog As FileDialog, result As Integer
Set fDialog = Application.FileDialog(msoFileDialogFilePicker)
    
'IMPORTANT!
fDialog.AllowMultiSelect = True

'Optional FileDialog properties
fDialog.title = "Select a file"
fDialog.InitialFileName = "C:"
'Optional: Add filters
fDialog.Filters.Clear
fDialog.Filters.Add "Excel files", "*.xlsx"
fDialog.Filters.Add "All files", "*.*"

'Show the dialog. -1 means success!
If fDialog.Show = -1 Then
  For Each it In fDialog.SelectedItems
    Debug.Print it
  Next it
End If

'Results:
'C:somefile.xlsx
'C:somefile1.xlsx
'C:somefile2.xlsx

Select folder – msoFileDialogFilePicker

Selecting a folder is more simple than selecting files. However only a single folder can be select within a single dialog window.

Select folder example

The dialog below will ask the user to select a folder:

Set fDialog = Application.FileDialog(msoFileDialogFolderPicker) 'Important we use msoFileDialogFolderPicker instead of (...)FilePicker

'Optional: Properties
fDialog.title = "Select a folder"
fDialog.InitialFileName = "C:"

If fDialog.Show = -1 Then
  Debug.Print fDialog.SelectedItems(1)
End If

The msoFileDialogFolderPicker dialog allows you to only select a SINGLE folder and obviously does not support file folders

Open file – msoFileDialogOpen

Opening files is much more simple as it usually involves a single file. The only difference between the behavior between Selecting and Opening files are button labels.

Open file example

The dialog below will ask the user to select a file to open:

Dim fDialog As FileDialog, result As Integer, it As Variant
Set fDialog = Application.FileDialog(msoFileDialogOpen)
    
'Optional: FileDialog properties
fDialog.title = "Select a file"
fDialog.InitialFileName = "C:"
    
'Optional: Add filters
fDialog.Filters.Clear
fDialog.Filters.Add "All files", "*.*"
fDialog.Filters.Add "Excel files", "*.xlsx"
  
If fDialog.Show = -1 Then
  Debug.Print fDialog.SelectedItems(1)
End If

Save file – msoFileDialogSaveAs

Saving a file is similarly easy, and also only the buttons are differently named.

The save file dialog will in fact not save any files! It will just allow the user to select a filename for the file. You need to open the files for reading / writing yourself. Check out my post on how to write files in VBA

Save file example

The dialog below will ask the user to select a path to which a files is to be saved:

Dim fDialog As FileDialog, result As Integer, it As Variant
Set fDialog = Application.FileDialog(msoFileDialogSaveAs)

'Optional: FileDialog properties
fDialog.title = "Save a file"
fDialog.InitialFileName = "C:"

If fDialog.Show = -1 Then
  Debug.Print fDialog.SelectedItems(1)
End If

The msoFileDialogSaveAs dialog does NOT support file filters

FileDialog Filters

One of the common problems with working with the Application.FileDialog is setting multiple file filters. Below some common examples of how to do this properly. To add a filter for multiple files use the semicolor ;:

Dim fDialog As FileDialog
Set fDialog = Application.FileDialog(msoFileDialogOpen)
'...
'Optional: Add filters
fDialog.Filters.Clear
fDialog.Filters.Add "All files", "*.*"
fDialog.Filters.Add "Excel files", "*.xlsx;*.xls;*.xlsm"
fDialog.Filters.Add "Text/CSV files", "*.txt;*.csv"
'...

Be sure to clear your list of filters each time. The FileDialog has its nuisances and often filters are not cleared automatically. Hence, when creating multiple dialogs you might see filters coming from previous executed dialogs if not cleared and re-initiated properly.

The open file dialog will in fact not open any files! It will just allow the user to select files to open. You need to open the files for reading / writing yourself. Check out my posts:

Read file in VBA
Write file in VBA

Источник

Содержание

Application.GetSaveAsFilename method (Excel)
Syntax
Parameters
Return value
Remarks
Example
Support and feedback
Display VBA Save As Dialog with msoFileDialogSaveAs
The VBA Tutorials Blog
The String-based Properties
The Title and Button Properties
The Initial Name (and Location) Property
Filters, File Types, and Views
The Initial View
The Methods
Execute
Saving A File Other Than the Active Workbook
User Cancellations
Persistence
Resetting the Dialog
A Fully Implemented Example

Application.GetSaveAsFilename method (Excel)

Displays the standard Save As dialog box and gets a file name from the user without actually saving any files.

Syntax

expression.GetSaveAsFilename (InitialFilename, FileFilter, FilterIndex, Title, ButtonText)

expression A variable that represents an Application object.

Parameters

Name	Required/Optional	Data type	Description
InitialFilename	Optional	Variant	Specifies the suggested file name. If this argument is omitted, Microsoft Excel uses the active workbook’s name.
FileFilter	Optional	Variant	A string specifying file filtering criteria. Max length is 255 characters, otherwise the method returns Error 2015.
FilterIndex	Optional	Variant	Specifies the index number of the default file filtering criteria, from 1 to the number of filters specified in FileFilter. If this argument is omitted or greater than the number of filters present, the first file filter is used.
Title	Optional	Variant	Specifies the title of the dialog box. If this argument is omitted, the default title is used.
ButtonText	Optional	Variant	Macintosh only.

Return value

This string passed in the FileFilter argument consists of pairs of file filter strings followed by the MS-DOS wildcard file filter specification, with each part and each pair separated by commas. Each separate pair is listed in the Files of type drop-down list box. For example, the following string specifies two file filtersвЂ”text and addin:

«Text Files (*.txt), *.txt, Add-In Files (*.xla), *.xla»

To use multiple MS-DOS wildcard expressions for a single file filter type, separate the wildcard expressions with semicolons; for example, «Visual Basic Files (*.bas; *.txt), *.bas;*.txt» .

This method returns the selected file name or the name entered by the user. The returned name may include a path specification. Returns False if the user cancels the dialog box.

This method may change the current drive or folder.

When InitialFilename is used with an extension and a filter is applied, this extension must match the filter extension, otherwise the effective InitialFilename displayed in the dialog box will be an empty string.

Example

This example displays the Save As dialog box, with the file filter set to text files. If the user chooses a file name, the example displays that file name in a message box.

Support and feedback

Have questions or feedback about Office VBA or this documentation? Please see Office VBA support and feedback for guidance about the ways you can receive support and provide feedback.

Источник

Display VBA Save As Dialog with msoFileDialogSaveAs

The VBA Tutorials Blog

The FileDialog object in Excel allows one to show users precreated but customizable windows to users so they can open, save, and pick files and folders. In this tutorial, the last of our FileDialog series, we will take a look at how to save files under different names while retaining the original file (Save As). If you havenвЂ™t read our other FileDialog tutorials, no worries. This tutorial is entirely self-contained. Of course I encourage you to check out the others to round out your knowledge of VBA!

If you need a fully customizable вЂњSave AsвЂќ experience, youвЂ™ll need to build your own Userforms from scratch. FileDialogs offer a good compromise, wherein you can customize a bit but the form layout is already created by Microsoft.

We will step through setting up and modifying the object before getting into the methods (.Show and .Execute). There is a fully functional macro at the end if you want to jump there and begin playing with the code. ThatвЂ™s also where youвЂ™ll find a screenshot of our customized VBA Save As dialog box.

The String-based Properties

If youвЂ™re familiar with our FileDialog series, youвЂ™ll recall the FileDialog object has four settings. WeвЂ™ll use the msoFileDialogSaveAs setting in this tutorial to teach you how to display the Save As dialog box. The first step to displaying the Save As dialog is to set up your variables, which you can do with this code:

Make powerful macros with our free VBA Developer Kit

ItвЂ™s easy to copy and paste a macro like this, but itвЂ™s harder make one on your own. To help you make macros like this, we built a free VBA Developer Kit and wrote the Big Book of Excel VBA Macros full of hundreds of pre-built macros to help you master file I/O, arrays, strings and more — grab your free copy below.

The msoFileDialogSaveAs box has the same properties and methods as the other FileDialogs, but only a subset of them actually do anything with the Save As dialog. This is particularly important for the Filters collection, which we will discuss below.

The Title and Button Properties

Two simplest properties to modify are Title and ButtonName . These properties both accept a string and control the text on your Save As dialog. The title refers to the caption at the top of the window, and the button refers to the execute/go button. The default settings are вЂњFile SaveвЂќ and вЂњSaveвЂќ respectively. You can set these directly using VBA, since they are read/write properties:

If you want a keyboard shortcut for your users, you can prepend an ampersand to the letter in the ButtonName variable, which will underline the letter and tell the OS to treat the key press as a shortcut. For example, if you wanted a shortcut for вЂњaвЂќ, you could write

and users can press Alt+a to save. Just make sure the key you choose isnвЂ™t already in use as a shortcut for another property by default.

The Initial Name (and Location) Property

As you might expect, the InitialFileName property sets the string that appears in the file name box in the dialog. However, this property controls more than just the file name. Not only does the InitialFileName property set the name, it also sets the default location.

To set a default file name, you add a line of code like this:

When you do that, youвЂ™ll get a dialog that opens to some default location (likely the Documents folder) with a preset filename of myFile . On the other hand, if you set the InitialFileName property to a file path, your Save As dialog box will automatically open to that location.

Consider these two statements:

The first statement will open the dialog in the Users folder, while the second will open the dialog in the Users folder and preset the filename to myFile . The only difference is the backslash at the end of the string. A backslash at the end of your string tells the dialog box youвЂ™re pointing to a folder and the lack of a backslash tells it youвЂ™re specifying a file.

Filters, File Types, and Views

When we want to open a file, we can change filters around and do all kinds of interesting things with the Filters collection. These filters donвЂ™t really make as much sense when you want to save a file. With the VBA Save As dialog box, we can only set the default filter via the FilterIndex property. There are 25+ filters that populate the FileDialog upon its instantiation, and you can choose one of them. However, you canвЂ™t clear the list and you canвЂ™t add your own filters — mainly because Excel canвЂ™t save in nonstandard formats.

You can find the descriptions and extensions of the Filters items using this code in the [Immediate Window] (keyboard shortcut Ctrl+g):

Just change 1 to the filter you want to see. You should get this output for Filter 1:

You can also see the list in the Locals window if you prefer that (View>Locals Window in the VBE).

To set the default filter, simply write a code like this: oFD.FilterIndex = 1 . YouвЂ™ll want to replace the integer 1 with the filter index corresponding to your file type. This will select the correct filter from the dropdown in the FileDialog, and it will also append the file extension (.xlsx, .txt) to the file upon saving.

ThatвЂ™s about all the filter customization you can do with the VBA Save As dialog box.

The Initial View

Unlike the string properties, Enum properties have a distinct set of options. The InitialView property is one of those Enum properties. The operating system can only display information in so many ways, so the number of selectable options for setting the InitialView property is limited. If you have Intellisense turned on, when you type oFD.InitialView = . , you should get a dropdown list of possible default views for the dialog itself. Options include things like large icons, thumbnails, and details. TheyвЂ™re generally self-explanatory.

List of InitialView Styles
msoFileDialogViewDetails
msoFileDialogViewLargeIcons
msoFileDialogViewList
msoFileDialogViewPreview
msoFileDialogViewProperties
msoFileDialogViewSmallIcons
msoFileDialogViewThumbnail
msoFileDialogViewTiles
msoFileDialogViewWebView

The reason they are called Enum is because they are enumerated. You can actually assign them as an integer instead of a long name like msoFileDialogViewDetails or msoFileDialogViewThumbnail . ItвЂ™s much easier for people to understand and remember the name rather than the corresponding вЂњenumerationвЂќ number. The numbers often are not simply listed as 1,2,3, either, which means you cannot always guess the correct Enum. Using Intellisense and the predefined strings makes using enumerated properties much easier.

Just take note that the initial view property is not the most reliable, and you might not get the view you want. The OS might override your decision, so donвЂ™t get frustrated if your initial view does not match what you specified.

The Methods

Just like the other FileDialogs, the msoFileDialogSaveAs box has two methods: Show and Execute. The Show method draws the window with the preset properties you specified earlier. When you show the dialog, you wonвЂ™t be able to do anything with other parts of Excel or VBA (there is no modal version for FileDialogs).

Once you display the dialog, the user can select the file location and name and click the Save button. The Save button wonвЂ™t do anything until call the .Execute method, though.

Execute

Pressing the Save button in the Save As FileDialog will not actually save the file. It only populates the SelectedItems collection with the filename and filepath the user selected as a string (including the automatically appended extension). To save the file, you need to call the Execute method.

Since there is no way to choose nonstandard files for users, as long as resources are not locked, this should be a pretty smooth process. Even if a user types myFile.special , the attempt to create a .special file extension will be moot: VBA will just add .txt or .xlsx to the end, creating myFile.special.xlsx .

Execute will save the active workbook as the filename and type selected by the user in the dialog box, so you will need to know which one is active before implementing this method. Keep in mind that this is a Save As dialog, so the currently open version will be saved as a copy with the new filename.

Saving A File Other Than the Active Workbook

It is quite common to save something other than the active workbook. If youвЂ™ve been processing files in VBA but not actually opening them in Excel, such as a text file loaded via FSO OpenTextFile, you might only run the Save As dialog to give users a visually-appealing and interactive way to select the file destination.

In that case, you can access the userвЂ™s choice through the SelectedItems collection, which will only have one item (unlike the Open dialog that could have multiple items). In the Immediate window, type the following to retrieve the filepath string:

You would just save your file with that string name, like you would for any other VBA File I/O trick.

User Cancellations

On the other hand, it is possible that the user will press the Cancel button instead of the Execute button. In that case, our SelectedItems collection will be empty and you cannot execute anything. You wonвЂ™t get an error, but you wonвЂ™t get a saved file, either.

In that case, it is practical to check whether the Cancel button was selected. Remember that .Show is a method or function, and it always returns some value to the VBA program. That means you can check it like so:

If the user presses Cancel, the method returns the integer zero and you can handle that case. Perhaps you can send out a MsgBox to ask them to confirm that they do not want to save.

Persistence

As discussed in our msoFileDialogOpen tutorial, only one FileDialog object can live in an instance of Excel. If you change the type (like msoFileDialogSaveAs to msoFileDialogOpen), all of your future FileDialogs will change to Open types, even if you have different objects in your macro. For example, this code will result in both oFD and oFD1 being Open Dialog Boxes (with the same settings):

DonвЂ™t believe me? Pause your macro write after these lines and type ?oFD.DialogType:?oFD1.DialogType in your immediate window. YouвЂ™ll see theyвЂ™re both reported as the same dialog type, even though we set the different objects to different types. Moreover, even if the macro stops, the last FileDialog will persist until the entire Excel application is restarted. Thus, if you originally set the default filter to be .xlam but ran a completely separate macro later and wanted .csv, you would need to reset the filter index in the second macro.

Just keep this in mind when using FileDialogs — it can lead to many frustrating bugs and user complaints if you forget about persistence.

Resetting the Dialog

Even though the FileDialog is persistent while the application is alive, you can still reset the dialog if youвЂ™ve made significant changes to the defaults by reassigning the FileDialog to a different type and then back again.

The third line here will create the FileDialog in its default state. It isnвЂ™t a great workaround, and it might not even be intentional on MicrosoftвЂ™s part, so I suggest not relying on this solution. Rebuilding explicitly is a much safer route.

A Fully Implemented Example

Although the filters are not as customizable with the Open FileDialog, the Save As dialog still offers some nice customization. Sometimes itвЂ™s important to give the user a choice for where to save files via a GUI FileDialog rather than simply saving it outright or using a clumsy VBA InputBox.

If you want really customizable features, youвЂ™ll have to build an entire UserForm scratch. It is an arduous process to build a beautiful GUI, though, so why not just use the tools Microsoft has already given us?

To get you started, here is the code block weвЂ™ve pieced together throughout this tutorial. After the macro, youвЂ™ll see a screenshot of what appears once you call the Show method. Note that the target workbook here is dailyReport.xlsx , so even if dailyReport.xlsx is not the active workbook, we will still save the right file! We did this to demonstrate how you can save files using two different methods.

The VBA Save As FileDialog customized to the specifications in the macro above

ThatвЂ™s all for this tutorial. When youвЂ™re ready to take your VBA to the next level, subscribe using the form below.

Ready to do more with VBA?
We put together a giant PDF with over 300 pre-built macros and we want you to have it for free. Enter your email address below and we’ll send you a copy along with our VBA Developer Kit, loaded with VBA tips, tricks and shortcuts.

Before we go, I want to let you know we designed a suite of VBA Cheat Sheets to make it easier for you to write better macros. We included over 200 tips and 140 macro examples so they have everything you need to know to become a better VBA programmer.

This article was written by Cory Sarver, a contributing writer for The VBA Tutorials Blog. Visit him on LinkedIn and his personal page.

Источник