How to Add Newlines to Strings and Variables in PowerShell

Posted by By Rohit February 24, 2025
Add Newlines to Strings and Variables in PowerShell

Properly formatted output is essential for readability and functionality when working with PowerShell scripts. One of the fundamental aspects of text formatting involves adding line breaks at appropriate places. This comprehensive guide explores various techniques for implementing new lines in PowerShell strings, variables, commands, and arrays.

Understanding PowerShell Line Break Characters

PowerShell provides several special characters for managing line breaks:

CharacterDescriptionUsage
`nLine feed (LF)Adds a new line in string output
`rCarriage return (CR)Returns cursor to beginning of line
`r`nCarriage return + Line feed (CRLF)Windows-style complete line break
` (backtick)Line continuationBreaks commands across multiple lines

Adding New Lines in PowerShell Strings

Using the Line Feed Character (`n)

The line feed character (`n) is the most straightforward way to insert a new line within a string:

PS C:\> "Welcome to PowerShell Programming`nMastering text formatting"

Output:

Welcome to PowerShell Programming
Mastering text formatting

Using Carriage Return and Line Feed Together (`r`n)

For complete Windows-style line breaks, combine carriage return and line feed:

PS C:\> "First line`r`nSecond line`r`nThird line"

Output:

First line
Second line
Third line

Using Natural Line Breaks in String Literals

PowerShell also recognizes natural line breaks within multi-line string literals:

PS C:\> "First line
>> Second line
>> Third line"

Output:

First line
Second line
Third line

Adding New Lines in PowerShell Variables

When storing text in variables, you can incorporate line breaks using the same special characters:

PS C:\> $multiLineText = "Header Text`r`nBody paragraph one`r`nBody paragraph two"
PS C:\> $multiLineText

Output:

Header Text
Body paragraph one
Body paragraph two

This approach ensures that when the variable is displayed or used in other commands, the line breaks are preserved.

Breaking Long Commands with Line Continuation

PowerShell scripts often contain complex commands that become difficult to read when written on a single line. The backtick character (`) serves as a line continuation marker, allowing you to split commands across multiple lines:

Before Line Continuation

Get-CimInstance -ComputerName localhost win32_logicaldisk | Where-Object caption -eq "C:" | ForEach-Object {Write-Output " $($_.caption) $('{0:N2}' -f ($_.Size/1gb)) GB total, $('{0:N2}' -f ($_.FreeSpace/1gb)) GB free "}

After Line Continuation

Get-CimInstance -ComputerName localhost win32_logicaldisk `
| Where-Object caption -eq "C:" `
| ForEach-Object { `
    Write-Output " $($_.caption) $('{0:N2}' -f ($_.Size/1gb)) GB total, $('{0:N2}' -f ($_.FreeSpace/1gb)) GB free " `
}

Important: The backtick must be the last character on the line, with no spaces after it, or PowerShell will not recognize it as a line continuation marker.

Line Breaks with Write-Output and Write-Host

The Write-Output and Write-Host cmdlets display text in the console and can incorporate line breaks:

PS C:\> Write-Host "System Information:`nOS: Windows 11`nArchitecture: 64-bit"

Output:

System Information:
OS: Windows 11
Architecture: 64-bit

Adding New Lines in PowerShell Arrays

When working with arrays, you might want to display each element on a separate line. The Out-String cmdlet converts the array into a string with line breaks:

PS C:\> $teamMembers = "Alice Smith", "Bob Johnson", "Carol Williams", "David Brown"
PS C:\> $formattedTeam = $teamMembers | Out-String
PS C:\> Write-Host "Team Members:$formattedTeam"

Output:

Team Members:
Alice Smith
Bob Johnson
Carol Williams
David Brown

Alternative Approach Using ForEach-Object

You can also use ForEach-Object to process each array element separately:

PS C:\> $teamMembers = "Alice Smith", "Bob Johnson", "Carol Williams", "David Brown"
PS C:\> $teamMembers | ForEach-Object { Write-Host $_ }

Output:

Alice Smith
Bob Johnson
Carol Williams
David Brown

Here-Strings for Multi-Line Text

PowerShell “here-strings” provide an elegant way to define multi-line text without escape characters:

PS C:\> $emailBody = @"
Dear Customer,

Thank you for your recent purchase.

Your order #12345 has been processed and will ship within 2 business days.

Best regards,
Customer Support Team
"@

PS C:\> $emailBody

The output preserves all line breaks exactly as formatted in the here-string.

Best Practices for Line Breaks in PowerShell

  1. Consistency: Choose one approach (`n or `r`n) and use it consistently throughout your scripts
  2. Readability: Use line continuation (`) to break complex commands into logical segments
  3. Documentation: Comment your code to explain the purpose of complex string formatting
  4. Here-Strings: For multi-line text blocks, prefer here-strings over concatenated strings with line breaks
  5. Escape Sequences: Remember that line break characters only work in double-quoted strings, not single-quoted strings

Troubleshooting Line Break Issues

If line breaks aren’t displaying correctly:

  • Verify you’re using double quotes, not single quotes (line breaks don’t work in single quotes)
  • Check for spaces after the backtick in line continuations
  • Ensure you’re using the appropriate line break character for your context
  • If outputting to a file, be aware that different text editors may display line breaks differently

Conclusion

Mastering line breaks in PowerShell enhances both script readability and output formatting. You can create more professional and user-friendly PowerShell scripts by understanding and applying these techniques—from simple string manipulation to advanced command structuring.

Whether generating reports, creating configuration files, or improving script readability, these line break techniques are essential tools in your PowerShell toolkit.