How do you append strings in VBScript?

In VBScript, you append strings primarily using the ampersand (&) operator. While the plus (+) operator can also perform string concatenation, it is generally recommended to use the ampersand for clarity and to avoid potential issues.

---

Understanding String Concatenation in VBScript

VBScript provides flexible ways to combine, or "append," multiple string values into a single string. This is a fundamental operation for displaying dynamic messages, constructing file paths, or building complex data structures.

The Ampersand (&) Operator: The Preferred Choice

The ampersand (&) is the dedicated string concatenation operator in VBScript. It is designed specifically for joining strings and ensures that concatenation occurs even if one of the operands is not explicitly a string type (VBScript will attempt to convert it to a string first).

Why Use &?

• Clarity: It clearly indicates your intention is to combine strings.
• Predictability: It consistently performs string concatenation, minimizing unexpected behavior.
• Type Safety: It handles type conversions gracefully, often converting non-string values into their string representations before joining.

Example of Using &

Dim firstName
Dim lastName
Dim fullName
Dim age

firstName = "John"
lastName = "Doe"
age = 30

' Concatenating two string variables
fullName = firstName & " " & lastName 
' Result: "John Doe"

' Concatenating a string with a number
Dim message
message = "Welcome, " & fullName & "! You are " & age & " years old."
' Result: "Welcome, John Doe! You are 30 years old."

WScript.Echo fullName
WScript.Echo message

The Plus (+) Operator: Handle with Care

VBScript allows the plus (+) operator to also perform string concatenation, but with a crucial distinction: the concatenation is performed both by plus (+) and by ampersand (&) operators. While the plus operator is primarily intended to perform arithmetic addition, if both operators are strings, then string concatenation occurs.

Potential Pitfalls of Using +

The + operator's dual role can lead to unexpected results or runtime errors if you're not careful with data types:

• Arithmetic vs. Concatenation: If both operands are numbers, + performs addition. If both are strings, it concatenates.
• Type Mismatch Errors: If one operand is a string and the other is a number, VBScript will attempt to convert the string to a number to perform arithmetic addition. If the string cannot be converted into a valid number, a "Type Mismatch" error will occur.

Examples of Using +

Dim textPart1, textPart2, numValue, stringNum

textPart1 = "Hello"
textPart2 = " World"
numValue = 123
stringNum = "456"

' Concatenation (both operands are strings)
Dim greeting
greeting = textPart1 + textPart2
' Result: "Hello World"

' Arithmetic addition (both operands are numbers)
Dim total
total = numValue + 789
' Result: 912

' Concatenation (string + string disguised as number)
Dim combinedString
combinedString = textPart1 + stringNum
' Result: "Hello456" (VBScript treats stringNum as a string here)

' !!! POTENTIAL ERROR !!!
' VBScript tries to convert "Text" to a number for addition, leading to a Type Mismatch error.
' Dim errorMessage
' errorMessage = "Total: " + numValue + " Text" ' This line would cause a runtime error.

WScript.Echo greeting
WScript.Echo total
WScript.Echo combinedString

Best Practices for Concatenation

• Always use & for string concatenation. This eliminates ambiguity and makes your code more robust and easier to understand.
• Be explicit with type conversions if mixing string and non-string data with & is not sufficient, although & often handles simple conversions automatically. For example, CStr(MyNumber) & MyString.
• For building very long strings, especially in loops, consider building an array of strings and then using the Join function for efficiency. Repeated concatenation with & in a loop can be less performant.

Comparing & and + Operators

The following table summarizes the key differences between the & and + operators when dealing with strings and numbers in VBScript:

Feature	Ampersand (&) Operator	Plus (+) Operator
Primary Role	Dedicated string concatenation	Primarily arithmetic addition
Behavior with Strings	Always concatenates (e.g., "A" & "B" becomes "AB")	Concatenates only if both operands are strings (e.g., "A" + "B" becomes "AB")
Behavior with Numbers	Converts numbers to strings, then concatenates (e.g., "X" & 123 becomes "X123")	Performs arithmetic addition (e.g., 1 + 2 becomes 3)
Behavior with Mixed Types (String + Number)	Converts number to string, then concatenates (e.g., "X" & 123 becomes "X123")	Attempts to convert the string to a number for addition. If conversion fails, a "Type Mismatch" error occurs. (e.g., "X" + 123 causes error)
Recommendation	Highly recommended for all string concatenation to ensure clarity and avoid errors.	Avoid for string concatenation due to its ambiguous nature and potential for runtime errors with mixed data types.

---

Further Reading

• VBScript Operators (Microsoft Learn)
• VBScript Data Types (Microsoft Learn)

---