19.4. Simple User Interaction with input and disp
Table of Contents
Asking the User for Input
In many automation and scripting tasks you will not want to hard code every value. Instead, you can ask the user to type information when the script runs. MATLAB provides the function input for this purpose.
The simplest way to use input is to provide a prompt, which is the text MATLAB shows in the Command Window to tell the user what to type. For example:
age = input('Enter your age: ');
When this line executes, MATLAB prints Enter your age: in the Command Window and waits. The user types something and presses Enter. The value they type is returned by input and stored in the variable age.
By default, input interprets what the user types as a MATLAB expression. If the user types 10+5, age will be set to 15. If the user types a vector like [1 2 3], then age becomes a numeric array. If the user types something that is not a valid MATLAB expression, MATLAB will produce an error and the script will stop at that line.
Because input treats input as an expression, it is naturally suitable for numeric values. For text input, MATLAB uses a second form of input that returns a string rather than evaluating the expression, which is described later in this chapter.
You can combine input with other operations in a script. For example:
radius = input('Enter circle radius: ');
area = pi * radius.^2;
disp(area);Here the script asks for a radius, computes an area, and displays the result, all based on what the user typed.
Controlling How Input Is Evaluated
When you use input with one argument, MATLAB evaluates the user input as code. In some situations this is not what you want. If the user should type text such as a name, a yes or no answer, or any nonnumeric code, you should prevent MATLAB from trying to evaluate it as an expression.
To obtain literal text, call input with a second argument, 's'. In this case input returns a character vector containing exactly what the user typed, without evaluation. For example:
name = input('What is your name? ', 's');
If the user types Alice, the variable name contains the characters A, l, i, c, e. MATLAB does not try to interpret Alice as a variable or expression.
Using the 's' option is also useful when you want to read input like y or n, file names, codes that include letters and digits, or any value where mathematical interpretation is not intended.
The choice between evaluated input and string input is important. If you expect a number, the basic form:
value = input('Enter a number: ');
is convenient, because the result is already numeric. If you expect text, or you want to later process user responses as strings, the form with 's' avoids evaluation and potential errors.
Displaying Messages with disp
In simple scripts that interact with the user, you often need to show information and results. MATLAB provides several ways to display output, and the simplest is the function disp.
The disp function takes a value and prints a simple, readable representation in the Command Window, followed by a new line. Unlike lower level printing functions, disp does not show the variable name and does not require format strings. For example:
x = 42;
disp(x);prints just:
42
You can also use disp to show text. If you give disp a character vector or string, it prints that text exactly. For instance:
disp('Computation finished.');
writes Computation finished. to the Command Window.
One important detail is that disp accepts a single argument. If you want to combine text and numbers, you need to build one combined value before calling disp. An easy approach for text plus small numbers is to convert the number to text, then concatenate. For example:
name = 'Alice';
score = 95;
msg = ['Student ', name, ' scored ', num2str(score)];
disp(msg);
Here num2str converts the numeric score to characters, so it can be joined with the surrounding text. There are more advanced ways to format output, but for simple interaction disp plus basic string operations are usually enough.
Simple Question and Answer Scripts
By combining input and disp, you can create small interactive scripts that ask questions and respond based on the answers. This is often useful to make automation scripts flexible without editing the code each time.
For example, a short script can ask for a name and an age, then display a message that uses both values:
name = input('Enter your name: ', 's');
age = input('Enter your age: ');
disp(' ');
disp('Summary:');
disp(['Name: ', name]);
disp(['Age: ', num2str(age)]);
When this script runs, the user sees prompts for name and age. After typing, the script prints a small summary. The blank disp(' '); call inserts an empty line to separate parts of the output.
Another script can ask a yes or no question and then choose a message to display according to the answer. Suppose you want to ask the user whether to continue:
reply = input('Do you want to continue? (y/n): ', 's');
if reply == 'y'
disp('Continuing...');
else
disp('Stopping.');
end
This script treats the reply as text, then compares it against the expected character. If the user types y, one branch runs. If they type anything else, the other branch runs. The conditional logic itself belongs to other chapters, but the combination of input for reading a decision and disp for showing feedback is central for simple user interaction.
Basic Input Validation Ideas
For beginner scripts that use input, it is easy to assume the user enters something correct. In real use, a user might type unexpected values or press Enter without answering. Even without writing complex error handling code, you can start to add very simple checks around input.
Suppose you want the user to enter a positive number such as a radius. You could first read the value, then test it and inform the user if something is wrong:
radius = input('Enter radius (must be positive): ');
if radius <= 0
disp('The radius must be a positive number.');
else
area = pi * radius.^2;
disp(['Area is ', num2str(area)]);
end
This pattern uses input just once, then tests the result and chooses what message to disp. Even though this does not prevent the user from entering bad data, it at least gives a clear response and avoids silently using an invalid value.
For text input using input(...,'s'), you might want to check whether the user left the answer empty. For example:
username = input('Enter a username: ', 's');
if isempty(username)
disp('You did not enter a username.');
else
disp(['Welcome, ', username]);
end
Again, the goal is not to build a complete validation system, but to show how simple checks around input and clear messages with disp can already make interactive scripts more robust and understandable.
Pausing and Guiding the User
Some scripts do not just ask for data. They also guide the user through stages with messages and short pauses. You can use disp to explain what is happening before each step. For instance:
disp('This script processes your data file.');
disp('First, you will choose the file.');
fileName = input('Enter the file name (including extension): ', 's');
disp('Processing the file, please wait...');
% processing code would go here
disp('Done.');
Here, disp keeps the user informed at each step, so they are not surprised when the script pauses for input or takes some time to work.
If you want the user to read something before continuing, a simple pattern is to ask them to press Enter using input without storing the return value:
disp('Step 1 complete.');
input('Press Enter to continue...', 's');
disp('Step 2 starting.');
In this case, the string typed by the user is not used. The call to input only creates a pause and a clear moment where the user decides when to proceed.
Combining User Input with Automation
The main purpose of user interaction in automation scripts is to select a few key options, then let MATLAB handle the rest without further questions. A typical pattern is to collect one or more settings from input, then run several automated steps based on them.
Imagine a script that can run in either a test mode or a full mode. You can ask the user once at the beginning which mode they want, then use that choice to control the rest of the script:
mode = input('Choose mode (1 = test, 2 = full): ');
if mode == 1
disp('Running in test mode...');
% test mode actions
elseif mode == 2
disp('Running in full mode...');
% full mode actions
else
disp('Unknown mode selected.');
end
In another example, you can ask the user how many times to repeat an operation, or which folder to process, or which option to apply. In all cases, the pattern is the same. Read a value with input, display clear messages with disp, and then let the rest of the script follow those choices automatically without further manual editing.
This approach keeps your scripts flexible while still being easy to use for someone who only interacts through the Command Window.
Key points to remember:
Use input('prompt') when you expect numeric expressions and want MATLAB to evaluate what the user types.
Use input('prompt', 's') when you expect text, such as names or codes, and you do not want MATLAB to evaluate the input.
Use disp(value) to display results or messages simply, without variable names or formatting codes.
Combine input and disp to build small interactive scripts that ask questions once, then run automated steps based on the answers.
Views: 0
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
-
Comments
Please login to add a comment.
Don't have an account? Register now!