KAHIBARO Bookshelves
Discord Login Register

3. Working with Variables and the Workspace

Overview

In everyday MATLAB work you will constantly create, inspect, change, and remove variables. All of this happens in what MATLAB calls the workspace. Understanding how the workspace behaves and how variables live inside it is essential before you can write useful scripts, analyze data, or build larger programs.

This chapter introduces the overall idea of working with variables in the interactive environment. It explains what the workspace is, how it relates to the Command Window and the Editor, and how variable data persists or disappears as you run commands and scripts. Later chapters in this section will describe individual tools and tasks in more detail, such as creating and editing variables, using the Workspace browser, saving and loading data, importing files, and clearing variables.

What the Workspace Is

The workspace is the collection of variables that currently exist in your MATLAB session. Whenever you type an expression that produces a result and assign it to a name with =, you are creating or modifying a variable in the workspace. For example, after you enter

matlab
x = 10;
y = x^2;

the workspace now contains x and y. You can think of the workspace as MATLAB’s short term memory. Every name you define in the base environment refers to some value stored in this memory.

In an interactive session you will mostly work with the base workspace. Later, when you write functions, each function call will use its own separate workspace. That separation is important for larger programs, but in this chapter the focus stays on the variables you see and manage directly at the command level.

How Variables Are Created and Updated

Variables in the workspace are created automatically when you assign to a new name. You do not need to declare a type or size before using it. A simple assignment like

matlab
a = 5;

creates the variable a. Assigning a new value to the same name updates the existing variable. MATLAB will overwrite the previous contents of a without any extra confirmation.

You can also create variables as results of calculations, function calls, and data imports. For instance, if you read values from a file with an import function, it will usually place the data into one or more workspace variables that you can use immediately.

Later chapters in this section will show how to create variables in a more controlled way, including editing them with interactive tools and building arrays of different sizes and types. The key point here is that every successful assignment you make updates the workspace.

Viewing and Inspecting the Workspace

MATLAB provides several ways to see what is currently stored in the workspace. The most direct approach is to type the who or whos command. who gives you a list of variable names in text form. whos provides a more detailed table that includes size, type, bytes, and class for each variable.

There is also a graphical view, the Workspace browser, which appears as a panel in the MATLAB desktop. As you run commands and scripts, this panel updates to show new variables and changes to existing ones. Double clicking a variable in the Workspace browser opens a separate window where you can inspect its contents in a spreadsheet like view.

Later in this section you will examine the Workspace browser and the Variable editor in more detail. For now it is enough to know that they give you a visual way to monitor and explore the data you are working with.

How the Workspace Interacts with Commands and Scripts

When you type commands in the Command Window, you are directly changing the contents of the base workspace. Each assignment, function call, or operation that produces or modifies variables acts on this shared set of names.

Simple script files, which you will learn about in a later section of the course, also run in the base workspace by default. This means that commands in a script can use any variables you have already created interactively, and any variables created by the script remain available when the script finishes. As a result, script files and interactive commands often work together during exploratory work.

This sharing can sometimes lead to confusion if old variables remain in the workspace while you expect a clean start. For that reason it is important to learn how to clear variables and how to manage which data stays in memory, topics that will be discussed in a later chapter within this section.

Persistence of Variables within a Session

Variables in the workspace remain available until you remove them explicitly or until you end the MATLAB session. Closing MATLAB clears the entire workspace. When you open MATLAB again, you start with an empty workspace, unless you load saved data.

Within a single session, values do not disappear automatically when commands finish running. If you assign something to x at the beginning of your workday, it will still be there hours later unless you change or clear it. This persistent behavior is convenient during interactive exploration because you can build up a set of variables and reuse them across different commands and scripts.

To keep work between sessions, you must save selected variables or the whole workspace to a file, typically a MAT file. In later chapters you will learn how to save and load these files, and how to import data from external sources so that your workspace can be repopulated when needed.

Memory, Size, and Practical Limits

Every variable in the workspace occupies memory. The amount depends on its size and data type. Large arrays, tables, or imported datasets can consume a significant portion of your computer’s memory, which can slow down computations or lead to errors when there is not enough memory to store new data.

Monitoring variable size in the workspace helps you avoid these problems. Commands like whos show the number of bytes used, and the Workspace browser provides a quick visual overview. If certain intermediate variables become unnecessary, you can clear them to free memory. The detailed use of clearing commands will be covered later in this section, but the general idea is that good workspace management improves performance and reduces confusion.

Organizing Your Work Around the Workspace

As you start writing more commands and small scripts, you will naturally begin to think in terms of what is in your workspace at any moment. A typical workflow might involve importing data into a variable, performing computations that create new variables, inspecting results, and then saving the final variables that matter.

Because the workspace is shared by your interactive commands and scripts, it is helpful to use clear and consistent variable names and to avoid reusing the same name for unrelated types of data. Later chapters on code quality will expand on naming and organization, but the workspace is where these choices have their immediate effect.

You will also learn to distinguish between temporary variables that are safe to discard and key variables that represent important stages in your analysis. That distinction makes it easier to decide what to save to files and what to clear from memory.

Relationship to Files and External Data

The workspace is a live view of the variables you are currently working with. Files on disk are a separate, persistent form of storage. To move data between the two, you use saving, loading, and importing operations.

When you save variables to a MAT file, you are capturing a snapshot of part of your workspace so that you can restore it later with a load operation. When you import data from text files, spreadsheets, or other external formats, you are creating new workspace variables that hold the imported content.

This separation between in memory variables and on disk files is central to effective MATLAB usage. Later chapters in this section will introduce MAT files and importing external data, and a later section on importing and exporting data will go into more detail about different file formats and tools.

Cleaning Up and Managing State

Over time, a busy workspace can make it hard to remember which variables are still meaningful and which ones belong to an earlier experiment. Keeping the workspace tidy helps make your work more reproducible and easier to understand, especially when you return to a project after a break.

MATLAB offers commands to clear selected variables or the entire workspace, and the Workspace browser panel provides interactive options to remove or rename variables. You will learn specific techniques for clearing variables and managing the workspace later in this section. For now, it is useful to be aware that workspace management is not just about memory, it is also about keeping a clear mental picture of where your data comes from.

Looking Ahead

This chapter has introduced the workspace as MATLAB’s working memory, where variables live while you run commands and scripts. The remaining chapters in this section will show you how to use the Workspace browser and Variable editor, how to create, view, and edit variables more precisely, how to save and load data with MAT files, how to import data from outside sources, and how to clear variables when you no longer need them.

As you move forward, try to pay attention to how your actions change the workspace. Noticing which variables appear, which ones grow larger, and which ones can be removed will help you build good habits in MATLAB from the very beginning.

Important points to remember:
The workspace holds all variables that exist in your current MATLAB session.
Interactive commands and scripts operate on the same base workspace.
Variables persist until you clear them or end the MATLAB session.
Large variables consume memory, so managing what stays in the workspace matters.
Saving and loading files is how you move data between the workspace and disk storage.

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