KAHIBARO Bookshelves
Discord Login Register

13. Working with Scripts and Live Scripts

Introduction

Scripts and live scripts let you save commands in files so you can run them again, share them, and build longer pieces of code. They move you from typing one command at a time in the Command Window to writing reproducible programs. In this chapter you will see what scripts and live scripts are, how they behave compared to commands you type interactively, and where they fit into a basic MATLAB workflow. Details of how to create, run, and enrich them are covered in the child chapters.

What Scripts Are

A script is a plain text file that contains a sequence of MATLAB commands. The file has the extension .m. When you run a script, MATLAB executes the commands in the file as if you had typed them, line by line, in the Command Window.

Scripts do not have their own separate workspace. They use and modify variables in the base workspace. This means any variable that exists in the base workspace before you run a script can be read by that script, and any variable that the script creates or changes will appear in or update the base workspace.

Script files are often used for small analyses, exploratory work, quick calculations, or any situation where you would otherwise repeat the same set of commands manually. They are also the natural first step before learning to write functions, because the syntax inside a script is almost the same as in a function, just without an input or output definition line.

What Live Scripts Are

A live script is similar to a script but stored in a different format with extension .mlx. A live script supports rich content. You can mix executable MATLAB code with formatted text, titles, equations, images, and interactive outputs in one document.

Code in a live script is organized into sections. Each section can be run on its own. Results are usually shown next to the code instead of only in the Command Window. Live scripts are well suited for teaching, reports, tutorials, and exploratory analysis where you want to describe what you are doing, show the code, and show the results together in one document.

Internally, the MATLAB commands in a live script behave like those in a script. They are still executed by the MATLAB engine and they still work in a workspace. What is different is the way you view, edit, and present them.

Scripts and Live Scripts in the Workflow

When you use MATLAB as a calculator or to try a quick idea, you usually type directly in the Command Window. As soon as you want to repeat work, keep a record of what you have done, or build something longer than a few lines, you should move those commands into a script or a live script.

A typical beginner workflow is to experiment in the Command Window until some commands are working, then copy the useful ones into a new script file. Over time, you can turn that script into a live script if you want to add explanations or present it to someone else, or into functions if you want reusable building blocks with inputs and outputs.

Scripts and live scripts are saved in files under your project folders. MATLAB runs them based on the current folder or on the search path, so where you save these files becomes part of how you organize your work.

Differences Between Scripts, Live Scripts, and Functions

Scripts and live scripts both hold sequences of MATLAB commands. Functions also live in .m files, but have some important differences. A function file begins with a function definition line that defines the function name, input arguments, and output arguments. A script or live script does not have this line. As a result, you run a script or live script simply by using its file name, while you call a function by writing its name followed by parentheses and any input arguments.

A function executes in its own workspace which is separate from the base workspace and from the workspaces of other functions. Scripts and live scripts execute in the base workspace. For beginners this usually makes scripts easier to understand, but it also makes them less controlled and more dependent on the current state of the workspace.

Live scripts differ from plain scripts mostly in the editor experience and the storage format. They support formatted text, output inline with code, and some interactive controls. The underlying code is still MATLAB code that can often be converted to or from a plain script when needed.

You will learn the exact syntax for scripts and functions in the specific chapters that follow, so this chapter only highlights the conceptual differences.

Naming and Running Behavior

Both scripts and live scripts must follow MATLAB naming rules. The file name, without its extension, is also the program name you use to run it. For example, if you save a script as myAnalysis.m or a live script as myAnalysis.mlx, you run it by typing myAnalysis in the Command Window or using the Run controls in the Editor. The name must start with a letter, can contain letters, digits, and underscores, and should not match a built-in function or keyword.

Since scripts and live scripts share the workspace with the Command Window, running one can overwrite variables that already exist. In small experiments this is often acceptable, but for larger tasks you should be aware of this side effect. As you advance, you can reduce such issues by using functions or by clearing variables explicitly within scripts, which is described in later chapters.

Choosing Between Script and Live Script

For many simple tasks, a basic .m script is enough. If your goal is to automate a small calculation, test some code, or write something that only you need to read, a script file is usually the simplest choice.

Live scripts are more suitable when you want to explain your steps, keep notes with your code, or present results. A live script can serve as a combination of a lab notebook and a report. You can show it directly in MATLAB, or later convert it to other formats with the tools that will be described in child chapters.

Over time, you may start a project with a live script while exploring data, then move stable parts of the code into functions, and keep the live script as a documented top level analysis.

Important reminders:
Scripts and live scripts share the base workspace, so they see and change the same variables as the Command Window.
Scripts are plain .m files with sequences of commands. Live scripts are .mlx files that support formatted text and rich output.
You run a script or live script by its file name, and file naming rules in MATLAB still apply.
Use scripts for simple automation and live scripts when you want both runnable code and human readable explanations in one document.

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