String Concatenation with strcat in MATLAB

By /

Okay, here’s a comprehensive article on string concatenation in MATLAB, with a focus on strcat and its alternatives, exceeding the requested word count significantly to provide a truly in-depth exploration.

String Concatenation in MATLAB: A Deep Dive into strcat and Beyond

String manipulation is a fundamental aspect of programming, and MATLAB provides a rich set of tools for working with text data. One of the most common operations is string concatenation – the process of joining two or more strings together to form a new string. While MATLAB offers several ways to achieve this, strcat has historically been a prominent function for this purpose. This article delves into the intricacies of strcat, explores its limitations, and presents modern alternatives that offer greater flexibility and efficiency.

1. Introduction to String Concatenation

String concatenation is the process of appending one string to the end of another. This is crucial for a vast array of tasks, including:

  • Building dynamic messages: Creating output strings that vary based on program variables. For example, displaying a user’s name along with a personalized greeting.
  • Generating file paths: Combining directory names and filenames to construct complete file paths.
  • Formatting data for output: Joining data values with labels and separators for reports or visualizations.
  • Creating SQL queries: Dynamically constructing SQL queries based on user input or program logic.
  • Processing text data: Combining segments of text extracted from files or user input.
  • Log File Generation: Creating entries by combining timestamps, event descriptions, and severity levels.
  • User Interface Development: Constructing labels, messages, and tooltips by combining static text with dynamic data.

2. The strcat Function: Syntax and Basic Usage

The strcat function (short for “string concatenate”) is a built-in MATLAB function designed to concatenate strings horizontally.

Syntax:

matlab
newStr = strcat(s1, s2, ..., sN)

  • s1, s2, ..., sN: The input strings (or character arrays) to be concatenated. These can be individual strings, string arrays, cell arrays of strings, or even a mix of these types.
  • newStr: The resulting concatenated string.

Basic Example:

matlab
str1 = 'Hello';
str2 = ' ';
str3 = 'World';
result = strcat(str1, str2, str3);
disp(result); % Output: HelloWorld

In this simple example, strcat joins the three strings together. Notice, however, that strcat removes trailing whitespace from character arrays, but preserves it from strings. This is a crucial distinction and a common source of confusion.

3. Handling Trailing Whitespace: The strcat Quirk

One of the most important behaviors of strcat to understand is its handling of trailing whitespace (spaces at the end of a string). This behavior differs depending on whether the input is a character array or a string.

  • Character Arrays: strcat removes trailing spaces from character arrays.
  • Strings: strcat preserves trailing spaces from strings.

This inconsistency can lead to unexpected results if you’re not careful. Let’s illustrate this with examples:

“`matlab
% Using character arrays
char1 = ‘MATLAB ‘; % Trailing spaces
char2 = ‘rocks!’;
result_char = strcat(char1, char2);
disp(result_char); % Output: MATLABrocks! (Trailing spaces removed)

% Using strings
str1 = string(‘MATLAB ‘); % Trailing spaces
str2 = string(‘rocks!’);
result_str = strcat(str1, str2);
disp(result_str); % Output: “MATLAB rocks!” (Trailing spaces preserved)
“`

As you can see, strcat removes the trailing spaces from char1 (a character array) but preserves them from str1 (a string). This difference is fundamental to understanding how strcat works and why modern alternatives are often preferred.

4. Concatenating String Arrays and Cell Arrays

strcat can also handle string arrays and cell arrays of strings.

  • String Arrays: When concatenating string arrays, strcat performs element-wise concatenation.

matlab
strArray1 = ["apple", "banana"];
strArray2 = [" pie", " split"];
result = strcat(strArray1, strArray2);
disp(result);
% Output:
% 2×1 string array
% "apple pie"
% "banana split"

  • Cell Arrays of Character Arrays: strcat treats each cell as a separate input, concatenating the contents horizontally. Trailing spaces are removed from character arrays within the cells.

matlab
cellArray = {'Hello ', 'World'}; % Cell array of character arrays
result = strcat(cellArray{:}); % Use {:} to unpack the cell array
disp(result); % Output: HelloWorld (Trailing spaces removed)

  • Cell Arrays of Strings: strcat treats each cell as a separate input and trailing spaces are preserved.

matlab
cellArray = {string('Hello '), string('World')}; % Cell array of character arrays
result = strcat(cellArray{:}); % Use {:} to unpack the cell array
disp(result); % Output: "Hello World" (Trailing spaces preserved)

  • Mixed Inputs: You can combine strings, character arrays, and cell arrays within a single strcat call. The rules for trailing whitespace removal apply to each input individually.

“`matlab
mixedInput = strcat(‘Hello ‘, string(‘World ‘), {‘! ‘});
disp(mixedInput); % Output: “HelloWorld !” (Character array spaces are removed, string spaces are kept.)

“`

5. Limitations of strcat

While strcat is functional, it has several limitations that make other methods more attractive in many situations:

  • Inconsistent Whitespace Handling: As discussed extensively, the different treatment of trailing whitespace between character arrays and strings is a major source of confusion and potential bugs.
  • Horizontal Concatenation Only: strcat is primarily designed for horizontal concatenation. While you can technically achieve vertical concatenation using transposes, it’s less intuitive and efficient than other methods.
  • Performance: For large strings or numerous concatenations, strcat can be less efficient than alternatives like string arrays and the join function.
  • Readability: For complex concatenation scenarios, strcat calls can become long and difficult to read.

6. Modern Alternatives to strcat

MATLAB has introduced several more modern and versatile ways to concatenate strings that address the limitations of strcat. These are generally preferred for new code.

6.1. String Arrays (The Preferred Method)

String arrays, introduced in MATLAB R2016b, are the recommended way to work with text data in most cases. They provide a consistent and efficient way to perform string concatenation.

  • Horizontal Concatenation: Use the + operator or square brackets [] with spaces.

“`matlab
str1 = “Hello”;
str2 = ” “;
str3 = “World”;

result1 = str1 + str2 + str3; % Using the + operator
result2 = [str1 str2 str3]; % Using square brackets
disp(result1); % Output: “Hello World”
disp(result2); % Output: “Hello World”
“`

  • Vertical Concatenation: Use square brackets [] with semicolons ;.

matlab
str1 = "Line 1";
str2 = "Line 2";
result = [str1; str2];
disp(result);
% Output:
% 2×1 string array
% "Line 1"
% "Line 2"

  • Element-wise Concatenation: The + operator automatically handles element-wise concatenation with string arrays.

matlab
strArray1 = ["apple", "banana"];
strArray2 = [" pie", " split"];
result = strArray1 + strArray2;
disp(result);
% Output:
% 2×1 string array
% "apple pie"
% "banana split"

  • Consistent Whitespace Handling: String arrays treat whitespace consistently. Trailing spaces are always preserved, regardless of whether they are explicitly added or part of the original string.

  • Performance: String array concatenation is generally faster than strcat, especially for repeated concatenations or large strings.

6.2. The join Function

The join function provides a powerful and flexible way to concatenate strings, especially when dealing with string arrays and delimiters.

Syntax:

matlab
newStr = join(strArray, delimiter)

  • strArray: A string array containing the strings to be joined.
  • delimiter: (Optional) The string to insert between the elements of strArray. If omitted, a single space is used as the default delimiter.

Examples:

“`matlab
strArray = [“apple”, “banana”, “cherry”];

% Join with a space (default delimiter)
result1 = join(strArray);
disp(result1); % Output: “apple banana cherry”

% Join with a comma and a space
result2 = join(strArray, “, “);
disp(result2); % Output: “apple, banana, cherry”

% Join with a hyphen
result3 = join(strArray, “-“);
disp(result3); % Output: “apple-banana-cherry”

% Join vertically with a newline character
result4 = join(strArray, newline);
disp(result4);
% Output:
% apple
% banana
% cherry

% Joining across rows with different delimiters:
strArray2D = [“a”,”b”,”c”; “d”,”e”,”f”];
result5 = join(strArray2D, [“,”, “;”]);
disp(result5);
% Output:
% 2×1 string array
%
% “a,b,c”
% “d;e;f”
“`

The join function is particularly useful when you need to create formatted strings with specific separators, such as comma-separated values (CSV) or file paths.

6.3. The compose Function

The compose function is designed for formatted string output, similar to sprintf but specifically for creating string arrays. It allows you to embed values from variables into a string template using format specifiers.

Syntax:

matlab
newStrArray = compose(formatSpec, A1, ..., AN)

  • formatSpec: A string containing the format specification, including placeholders for the values to be inserted. These placeholders use format specifiers similar to sprintf (e.g., %d for integers, %f for floating-point numbers, %s for strings).
  • A1, ..., AN: The variables (scalars, vectors, matrices, or string arrays) whose values will be inserted into the format string.

Examples:

“`matlab
% Simple example
names = [“Alice”, “Bob”, “Charlie”];
ages = [25, 30, 28];
result = compose(“Name: %s, Age: %d”, names, ages);
disp(result);
% Output:
% 3×1 string array
% “Name: Alice, Age: 25”
% “Name: Bob, Age: 30”
% “Name: Charlie, Age: 28”

% Using different format specifiers
numbers = [1.2345, 2.7183, 3.1416];
result = compose(“Value 1: %.2f, Value 2: %e, Value 3: %g”, numbers, numbers, numbers);
disp(result);
% Output:
% 3×1 string array
% “Value 1: 1.23, Value 2: 2.718300e+00, Value 3: 3.1416”
% “Value 1: 2.72, Value 2: 2.718300e+00, Value 3: 2.7183”
% “Value 1: 3.14, Value 2: 3.141600e+00, Value 3: 3.1416”

%Using compose to create a file path:

folder = “/Users/MyName/Documents”;
filename = “data.txt”;
fullpath = compose(“%s/%s”, folder, filename);
disp(fullpath); % Output: “/Users/MyName/Documents/data.txt”

“`

compose is very efficient for generating formatted string arrays, especially when you need to combine multiple variables with text and apply specific formatting rules.

6.4. sprintf (for single strings, limited use with string arrays)

The sprintf function (formatted print to string) is primarily used to create a single formatted string, not a string array. While it can be used in loops to create string arrays, compose is generally a more efficient and direct approach for that purpose.

Syntax:

matlab
newStr = sprintf(formatSpec, A1, ..., AN)

The arguments are the same as for compose.

Example:

matlab
name = 'Alice';
age = 25;
result = sprintf('Name: %s, Age: %d', name, age);
disp(result); % Output: Name: Alice, Age: 25

You can use sprintf in a loop to build a string array, but it’s less efficient than compose:

“`matlab
names = [“Alice”, “Bob”, “Charlie”];
ages = [25, 30, 28];
strArray = strings(1, length(names)); % Pre-allocate string array

for i = 1:length(names)
strArray(i) = sprintf(‘Name: %s, Age: %d’, names(i), ages(i));
end
disp(strArray);
% Output:
% 1×3 string array
% “Name: Alice, Age: 25” “Name: Bob, Age: 30” “Name: Charlie, Age: 28”
“`

6.5. char (converting strings to character arrays – rarely needed)

The char function can convert a string or a string array to a character array. This is generally not needed for concatenation itself, but it might be necessary if you’re working with legacy code or functions that require character array input. Be mindful of the whitespace behavior when doing this.

“`matlab
str = “Hello”;
charArray = char(str);
disp(charArray); % Output: Hello (as a character array)

strArray = [“Hello”, “World”];
charArray = char(strArray);
disp(charArray);
% Output:
% 2×5 char array
% ‘Hello’
% ‘World’
``
Notice that when converting a *string array* to a character array,char` pads the rows with spaces to make them all the same length.

6.6. String Builders (for very large, repeated concatenations)

For scenarios involving extremely large strings or a massive number of repeated concatenations, even string arrays can become inefficient. In these very specialized cases, a “string builder” pattern can be implemented using a cell array of character vectors and then joining them at the very end. This avoids the repeated memory allocation and copying that can occur with other methods. This is generally not necessary for typical use cases, but is included for completeness.

“`matlab
% Initialize a cell array to act as the string builder
builder = {};

% Repeatedly append strings (character arrays are most efficient here)
for i = 1:10000
builder{end+1} = ‘Some text ‘;
builder{end+1} = num2str(i);
builder{end+1} = ‘, ‘;
end

% Finally, join everything into a single string
finalString = [builder{:}]; % horizontal concatenation of character arrays

% Or, convert to a string at the end (if desired)
finalString = string(finalString);

disp(finalString(1:100)); %Show a small part of the large string
“`

This approach minimizes memory overhead by delaying the final string creation until all the pieces are collected. However, this level of optimization is rarely needed in MATLAB. String arrays are usually sufficient.

7. Best Practices and Recommendations

  • Prefer String Arrays: For most string concatenation tasks, use string arrays and the + operator or square brackets []. This is the most modern, readable, and generally efficient approach.
  • Use join for Delimited Strings: When you need to join strings with specific delimiters, the join function is the best choice.
  • Use compose for Formatted Output: For creating formatted string arrays with embedded variable values, compose is highly efficient and readable.
  • Avoid strcat for New Code: While strcat is still functional, its inconsistent whitespace handling and lower performance make it less desirable than the alternatives. Use it only when interacting with legacy code that requires it.
  • Be Mindful of Whitespace: Always be aware of how whitespace is handled, especially when mixing character arrays and strings.
  • Pre-allocate String Arrays: When building string arrays in loops, pre-allocate the array using strings(rows, cols) for better performance. This avoids repeated memory allocation as the array grows.
  • Consider String Builders Only for Extreme Cases: Only resort to the string builder pattern if you’re dealing with truly massive strings and repeated concatenations where performance is absolutely critical.
  • Use string to create strings: Use the function string to create strings from character arrays or numbers, instead of using double quotes directly on those data types.

8. Examples: Common Concatenation Scenarios

Let’s look at some practical examples of how to perform string concatenation in various situations.

8.1. Creating a File Path

“`matlab
folder = “/home/user/documents”; % or string(‘/home/user/documents’)
filename = “report.txt”; % or string(‘report.txt’)

% Using string arrays (recommended)
filepath1 = folder + “/” + filename;
filepath2 = fullfile(folder, filename); % BEST PRACTICE – platform independent
filepath3 = [folder, “/”, filename];

disp(filepath1); % Output: /home/user/documents/report.txt
disp(filepath2); % Output: /home/user/documents/report.txt (or \ on Windows)
disp(filepath3)

% Using join (also a good option)
filepath = join([folder, filename], “/”);
disp(filepath); % Output: /home/user/documents/report.txt
“`

8.2. Generating a Dynamic Message

“`matlab
username = “JohnDoe”; % or string(‘JohnDoe’)
score = 95;

% Using string arrays and +
message1 = “Congratulations, ” + username + “! Your score is: ” + score;
disp(message1); % Output: Congratulations, JohnDoe! Your score is: 95

% Using compose (more readable for complex formatting)
message2 = compose(“Congratulations, %s! Your score is: %d”, username, score);
disp(message2); % Output: Congratulations, JohnDoe! Your score is: 95
“`

8.3. Creating a CSV String

“`matlab
data = [“Name”, “Age”, “City”; “Alice”, “25”, “New York”; “Bob”, “30”, “London”];
data = string(data); % Convert to string array (best practice)
csvString = join(data, “,”);
disp(csvString);
% Output:
% Name,Age,City
% Alice,25,New York
% Bob,30,London
csvString = join(data.’); % Transpose for different layout.
disp(csvString);

%Output
% Name,Alice,Bob
% Age,25,30
% City,New York,London
“`

8.4. Building an SQL Query

“`matlab
tableName = “users”; % or string(‘users’)
condition = “age > 25”; % or string(‘age > 25’)

% Using string arrays
query = “SELECT * FROM ” + tableName + ” WHERE ” + condition + “;”;
disp(query); % Output: SELECT * FROM users WHERE age > 25;

% Using compose (can be useful for more complex queries)
query = compose(“SELECT * FROM %s WHERE %s;”, tableName, condition);
disp(query); % Output: SELECT * FROM users WHERE age > 25;
“`

8.5 Vertical Concatenation with Different Lengths
“`matlab
str1 = string(“Hello”);
str2 = string(“World”);
str3 = string(“!”);

result = [str1; str2; str3]; % Simple Vertical
disp(result)

% Output
% 3×1 string array
%
% “Hello”
% “World”
% “!”

arr1 = [“a”, “b”, “c”];
arr2 = [“d”, “e”];
arr3 = [“f”];

% Pad the arrays to the same length before vertical concatenation
maxLength = max([length(arr1), length(arr2), length(arr3)]);

arr1Padded = [arr1, repmat(“”, 1, maxLength – length(arr1))];
arr2Padded = [arr2, repmat(“”, 1, maxLength – length(arr2))];
arr3Padded = [arr3, repmat(“”, 1, maxLength – length(arr3))];

result = [arr1Padded; arr2Padded; arr3Padded];
disp(result)
% 3×3 string array
%
% “a” “b” “c”
% “d” “e” “”
% “f” “” “”
“`

9. Conclusion

String concatenation is a fundamental operation in MATLAB. While strcat has served its purpose, modern alternatives like string arrays, join, and compose offer greater flexibility, consistency, readability, and performance. By understanding the nuances of each method and adopting best practices, you can write cleaner, more efficient, and less error-prone MATLAB code for all your string manipulation needs. The move towards using string arrays as the primary data type for text is highly recommended for any new MATLAB development. They provide a robust and intuitive foundation for working with strings.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top