KAHIBARO Bookshelves
Discord Login Register

10.6. Basic File Management from MATLAB

Working with Files from MATLAB

In many projects you will not only compute and plot, you will also need to organize input data, write output, and keep track of many files. MATLAB includes commands that let you inspect folders, create and remove directories, and copy, move, and delete files directly from the Command Window or from scripts. This chapter focuses on these basic file management tasks, not on reading or writing the contents of files, which is handled in other chapters.

Viewing and Navigating Folders

MATLAB always has a current folder. Most file operations without full paths use this folder as the starting point. You see it in the Current Folder panel and in the field at the top of the desktop, but you can also work with it using commands.

To find the current folder, use pwd, which stands for "print working directory". For example:

pwd

MATLAB displays the full path to the current folder as a character vector.

To change the current folder from the Command Window you use cd. Pass either an absolute path or a path relative to the current folder:

cd('C:\Users\yourname\Documents\MATLAB')
cd ../data

In the first command MATLAB jumps to the specified folder. In the second it moves one level up with .. then into the data subfolder. On Windows you can use either \ or / in paths, on macOS and Linux you use /.

To list the contents of the current folder use dir:

dir

This displays files and subfolders with sizes and dates. You can also pass a pattern to dir to narrow the list. For example, to list only MAT-files or only text files:

dir('*.mat')
dir('*.txt')

You can also use a relative or absolute folder path with dir, which has no effect on the current folder itself:

dir('..\raw_data')

MATLAB shows the listing for that folder while keeping the current folder unchanged.

Building and Inspecting File Paths

When you manage files from MATLAB it is safer to construct paths programmatically instead of typing long paths manually. This is especially important if your code needs to run on different operating systems.

The function fullfile joins folder names and file names into a single path using the correct file separators for the running platform. For example:

folder = 'data';
name   = 'results.csv';
filepath = fullfile(folder, name)

The variable filepath becomes something like data/results.csv or data\results.csv depending on your system. You can nest folders:

filepath = fullfile('project', 'outputs', 'results.csv');

To test whether a file or folder exists before you operate on it, use exist with a second argument:

exist('notes.txt','file')      % returns 2 if a file exists
exist('myfolder','dir')        % returns 7 if a folder exists

If you already have a full path, you can split it into parts with fileparts. This helps when you want to change only the name or the extension:

p = 'C:\data\experiment1\signal.dat';
[folder, name, ext] = fileparts(p);

After this call folder contains the folder part, name the base file name without extension, and ext the extension including the dot.

Creating and Removing Folders

You can create new folders directly from MATLAB with mkdir. The simplest form takes the new folder name. MATLAB will create it relative to the current folder if you do not provide a full path:

mkdir('results')
mkdir('C:\data\project1')

If intermediate folders are missing, MATLAB creates them as needed.

To remove a folder use rmdir. By default rmdir only removes empty folders:

rmdir('old_results')

If the folder contains files or subfolders you can pass a second argument 's' to remove the folder and its contents recursively:

rmdir('temp','s')

Use the recursive option with care, because it will permanently remove everything inside that folder.

Copying and Moving Files

MATLAB includes commands to copy and move files without leaving the environment. To copy a file you use copyfile. The first argument is the source, the second argument is the destination. Both can be file names or folder names.

To copy a single file to a new name in the same folder:

copyfile('data.csv','data_backup.csv')

To copy a file into a different folder, you can use fullfile to build the destination path:

src  = 'data.csv';
dest = fullfile('backup','data.csv');
copyfile(src, dest)

If the destination is a folder, MATLAB creates a copy with the same name inside that folder. copyfile can also copy whole folders including subfolders by giving a folder name as the source.

To move or rename files you use movefile. The syntax is similar to copyfile. To rename a file in the same folder:

movefile('oldname.txt','newname.txt')

To move a file into a different folder:

movefile('report.pdf', fullfile('reports','report.pdf'))

Just like copyfile, movefile can work with entire folders as sources and destinations.

Both copyfile and movefile can return status information if you capture output arguments. This allows you to check whether the operation succeeded and view any error message text programmatically.

Deleting Files Safely

To delete a file from MATLAB you use delete. You can pass one file or several, and you can use patterns:

delete('temp.txt')
delete('*.tmp')

delete('*.tmp') removes all files with the .tmp extension in the current folder. These operations cannot be undone from MATLAB, so you should use them carefully, especially when you use wildcard patterns.

Before you delete, you can use dir to inspect the files that match your pattern, or you can use exist to confirm that the specific file you are about to remove actually exists:

if exist('temp.txt','file') == 2
    delete('temp.txt')
end

This form avoids an error if the file is missing when the delete command runs.

Using Relative Paths and the Current Folder

When you work with many files it is usually better to write your code so that it uses relative paths based on the current folder instead of absolute paths that refer to a specific user or drive. Relative paths help your scripts and functions run on different machines and in different locations.

The basic relative path components are:

. refers to the current folder.
.. refers to the parent folder.

For example, if the current folder is C:\project\code, then:

..\data refers to C:\project\data.
.\output refers to C:\project\code\output.

You can combine these with fullfile to keep your path building readable:

dataFolder = fullfile('..','data');
infile     = fullfile(dataFolder,'measurements.csv');

Your scripts can also change the current folder with cd, but it is often clearer to leave the current folder unchanged and build full paths to files using a known base folder. You can obtain the folder of the running script with functions that are specific to scripts and functions, then build paths relative to that folder. This approach helps avoid confusion when users run code from different starting folders.

Inspecting File Information

Sometimes you need more information about a file than just its name. The output of dir is a structure array that contains one element per file or folder, with fields such as name, folder, date, bytes, and an isdir flag.

For example:

info = dir('results.csv');

Now info.bytes contains the file size in bytes and info.date contains the last modification time as text. If your pattern matches several files, info becomes an array and you can index into it or loop over it.

You can also use dir without arguments to obtain information for everything in the current folder and then filter in MATLAB instead of in the pattern. This gives you more flexibility when you want to select based on size or modification date.

Simple Automation with File Operations

File management commands are often used inside scripts to automate repeated tasks, such as processing all files of a certain type in a folder or creating backup copies of results. A typical pattern is to use dir to get a list of files that match a pattern, then loop over the result with commands such as fullfile, copyfile, or movefile.

For instance, you might take all .csv files in a folder and copy them to a backup folder:

files = dir('*.csv');
for k = 1:numel(files)
    src  = fullfile(files(k).folder, files(k).name);
    dest = fullfile('backup', files(k).name);
    copyfile(src, dest);
end

In this example you do not have to type each file name manually. MATLAB discovers them with dir and you build full paths using the folder and name fields. This pattern appears often in scripts that prepare data for later analysis.

Key points to remember:
Use pwd and cd to inspect and change the current folder, and dir to list files.
Use fullfile to build paths in a platform independent way and exist to test for files and folders before operating on them.
Use mkdir and rmdir to create and remove folders, and be very cautious with rmdir(...,'s') which removes folders recursively.
Use copyfile and movefile to copy, move, and rename files or folders, and delete to remove files, especially careful when you use wildcard patterns like *.tmp.
Prefer relative paths and programmatically built file paths when writing scripts, so your code remains portable and easier to reuse.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Getting Started with MATLAB
    • ☰ 1.1. What Is MATLAB and What Is It Used For
      • ☰ 1.2. Installing MATLAB and Setting Up the Environment
        • ☰ 1.3. Understanding the MATLAB Desktop Interface
          • ☰ 1.4. Command Window, Workspace, and Current Folder
            • ☰ 1.5. Basic Workflow and Running Simple Commands
              • ☰ 1.6. Getting Help and Documentation
              • ☰ 2. MATLAB Language Basics
                • ☰ 2.1. MATLAB Syntax and Expressions
                  • ☰ 2.2. Variables and Assignment
                    • ☰ 2.3. Data Types and Type Conversion
                      • ☰ 2.4. Vectors and Matrices Fundamentals
                        • ☰ 2.5. Creating and Indexing Arrays
                          • ☰ 2.6. Basic Arithmetic and Elementwise Operations
                            • ☰ 2.7. Using Built-In Constants and Functions
                            • ☰ 3. Working with Variables and the Workspace
                              • ☰ 3.1. Creating, Viewing, and Editing Variables
                                • ☰ 3.2. Workspace Browser and Variable Inspector
                                  • ☰ 3.3. Saving and Loading Data Files
                                    • ☰ 3.4. MAT-Files and Importing External Data
                                      • ☰ 3.5. Clearing Variables and Managing the Workspace
                                      • ☰ 4. Vectors, Matrices, and Arrays
                                        • ☰ 4.1. Row and Column Vectors
                                          • ☰ 4.2. Matrix Creation and Concatenation
                                            • ☰ 4.3. Indexing, Slicing, and Logical Indexing
                                              • ☰ 4.4. Matrix Operations vs Elementwise Operations
                                                • ☰ 4.5. Reshaping and Rearranging Arrays
                                                  • ☰ 4.6. Special Matrices and Functions
                                                  • ☰ 5. Basic Programming Constructs
                                                    • ☰ 5.1. Scripts vs Functions
                                                      • ☰ 5.2. Control Flow with if, elseif, else
                                                        • ☰ 5.3. Loops with for and while
                                                          • ☰ 5.4. break, continue, and return
                                                            • ☰ 5.5. Logical Expressions and Relational Operators
                                                              • ☰ 5.6. Best Practices for Clear and Readable Code
                                                              • ☰ 6. Functions in MATLAB
                                                                • ☰ 6.1. Creating Simple Functions
                                                                  • ☰ 6.2. Function Inputs and Outputs
                                                                    • ☰ 6.3. Function Files and the Path
                                                                      • ☰ 6.4. Local vs Global Variables
                                                                        • ☰ 6.5. Anonymous Functions
                                                                          • ☰ 6.6. Organizing Code into Multiple Functions
                                                                          • ☰ 7. Working with Numbers and Math
                                                                            • ☰ 7.1. Scalars and Vectorized Computations
                                                                              • ☰ 7.2. Basic Mathematical Functions
                                                                                • ☰ 7.3. Trigonometric and Exponential Functions
                                                                                  • ☰ 7.4. Complex Numbers in MATLAB
                                                                                    • ☰ 7.5. Rounding, Modulo, and Special Values
                                                                                      • ☰ 7.6. Numerical Precision and Floating Point Considerations
                                                                                      • ☰ 8. Strings, Characters, and Categorical Data
                                                                                        • ☰ 8.1. Character Arrays and String Arrays
                                                                                          • ☰ 8.2. Creating and Manipulating Strings
                                                                                            • ☰ 8.3. Converting Between Data Types and Strings
                                                                                              • ☰ 8.4. Comparing and Searching Strings
                                                                                                • ☰ 8.5. Categorical Arrays Basics
                                                                                                • ☰ 9. Tables, Structures, and Cell Arrays
                                                                                                  • ☰ 9.1. Introduction to Tables
                                                                                                    • ☰ 9.2. Creating Tables and Accessing Data
                                                                                                      • ☰ 9.3. Modifying and Joining Tables
                                                                                                        • ☰ 9.4. Structures and Nested Structures
                                                                                                          • ☰ 9.5. Cell Arrays and Cell Indexing
                                                                                                            • ☰ 9.6. Choosing the Right Container Type
                                                                                                            • ☰ 10. Importing and Exporting Data
                                                                                                              • ☰ 10.1. Reading Text and CSV Files
                                                                                                                • ☰ 10.2. Importing Excel Spreadsheets
                                                                                                                  • ☰ 10.3. Importing Data with the Import Tool
                                                                                                                    • ☰ 10.4. Exporting Data to Files
                                                                                                                      • ☰ 10.5. Working with Image and Audio Files
                                                                                                                        • ☰ 10.6. Basic File Management from MATLAB
                                                                                                                        • ☰ 11. Plotting and Visualization
                                                                                                                          • ☰ 11.1. Introduction to 2D Plotting
                                                                                                                            • ☰ 11.2. Customizing Plots and Axes
                                                                                                                              • ☰ 11.3. Multiple Plots in One Figure
                                                                                                                                • ☰ 11.4. Labels, Titles, Legends, and Annotations
                                                                                                                                  • ☰ 11.5. Plotting with Different Line and Marker Styles
                                                                                                                                    • ☰ 11.6. Saving and Exporting Figures
                                                                                                                                    • ☰ 12. Advanced Plotting for Beginners
                                                                                                                                      • ☰ 12.1. Subplots and Tiled Layouts
                                                                                                                                        • ☰ 12.2. Bar, Scatter, and Stem Plots
                                                                                                                                          • ☰ 12.3. Histograms and Density Plots
                                                                                                                                            • ☰ 12.4. 3D Plots and Surface Plots
                                                                                                                                              • ☰ 12.5. Using plottools and Interactive Editing
                                                                                                                                                • ☰ 12.6. Basics of Handle Graphics
                                                                                                                                                • ☰ 13. Working with Scripts and Live Scripts
                                                                                                                                                  • ☰ 13.1. Creating and Running Script Files
                                                                                                                                                    • ☰ 13.2. Sectioning Code and Running Sections
                                                                                                                                                      • ☰ 13.3. Live Scripts and Rich Text
                                                                                                                                                        • ☰ 13.4. Adding Equations, Images, and Outputs
                                                                                                                                                          • ☰ 13.5. Sharing and Exporting Live Scripts
                                                                                                                                                          • ☰ 14. Debugging and Code Quality
                                                                                                                                                            • ☰ 14.1. Finding and Fixing Syntax Errors
                                                                                                                                                              • ☰ 14.2. Setting Breakpoints and Stepping Through Code
                                                                                                                                                                • ☰ 14.3. Inspecting Variable Values During Execution
                                                                                                                                                                  • ☰ 14.4. Using the Editor Debugging Tools
                                                                                                                                                                    • ☰ 14.5. Using Code Analyzer and Warnings
                                                                                                                                                                      • ☰ 14.6. Writing Clean and Maintainable MATLAB Code
                                                                                                                                                                      • ☰ 15. Basic Linear Algebra with MATLAB
                                                                                                                                                                        • ☰ 15.1. Vectors and Norms
                                                                                                                                                                          • ☰ 15.2. Matrix Addition and Multiplication
                                                                                                                                                                            • ☰ 15.3. Solving Linear Systems with Backslash
                                                                                                                                                                              • ☰ 15.4. Inverses, Determinants, and Rank
                                                                                                                                                                                • ☰ 15.5. Eigenvalues and Eigenvectors
                                                                                                                                                                                  • ☰ 15.6. Using Linear Algebra Functions Safely
                                                                                                                                                                                  • ☰ 16. Data Analysis and Statistics Fundamentals
                                                                                                                                                                                    • ☰ 16.1. Descriptive Statistics and Summary Measures
                                                                                                                                                                                      • ☰ 16.2. Sorting, Filtering, and Grouping Data
                                                                                                                                                                                        • ☰ 16.3. Basic Correlation and Regression
                                                                                                                                                                                          • ☰ 16.4. Simple Data Cleaning Techniques
                                                                                                                                                                                            • ☰ 16.5. Basic Time Series Handling
                                                                                                                                                                                            • ☰ 17. Working with Time and Dates
                                                                                                                                                                                              • ☰ 17.1. Representing Dates and Times
                                                                                                                                                                                                • ☰ 17.2. Creating and Formatting datetime Arrays
                                                                                                                                                                                                  • ☰ 17.3. Date Calculations and Differences
                                                                                                                                                                                                    • ☰ 17.4. Plotting Data over Time
                                                                                                                                                                                                    • ☰ 18. Introduction to Signal and Image Handling
                                                                                                                                                                                                      • ☰ 18.1. Basic Signal Representation in MATLAB
                                                                                                                                                                                                        • ☰ 18.2. Simple Filtering and Transformations
                                                                                                                                                                                                          • ☰ 18.3. Reading, Displaying, and Writing Images
                                                                                                                                                                                                            • ☰ 18.4. Basic Image Transformations
                                                                                                                                                                                                            • ☰ 19. Automation and Scripting Tasks
                                                                                                                                                                                                              • ☰ 19.1. Batch Processing of Files
                                                                                                                                                                                                                • ☰ 19.2. Writing Reusable Utility Scripts
                                                                                                                                                                                                                  • ☰ 19.3. Using Relative Paths and the MATLAB Path
                                                                                                                                                                                                                    • ☰ 19.4. Simple User Interaction with input and disp
                                                                                                                                                                                                                    • ☰ 20. Introduction to Toolboxes
                                                                                                                                                                                                                      • ☰ 20.1. What Are Toolboxes and How to Use Them
                                                                                                                                                                                                                        • ☰ 20.2. Exploring Installed Toolboxes
                                                                                                                                                                                                                          • ☰ 20.3. Finding Functions in Toolboxes
                                                                                                                                                                                                                            • ☰ 20.4. Add-Ons and MATLAB File Exchange
                                                                                                                                                                                                                            • ☰ 21. Best Practices and Next Steps
                                                                                                                                                                                                                              • ☰ 21.1. Organizing Projects and Folders
                                                                                                                                                                                                                                • ☰ 21.2. Version Control Basics with MATLAB
                                                                                                                                                                                                                                  • ☰ 21.3. Performance Tips for Beginners
                                                                                                                                                                                                                                    • ☰ 21.4. Learning Resources and Documentation Path
                                                                                                                                                                                                                                      • ☰ 21.5. Suggested Practice Projects for Beginners