Remove blank lines in powershell output... Generally

You can define a custom Out-Default function that removes all empty/blank lines from the output (for display only):

function Out-Default { 
  $Input | Out-String -Stream | Where { $_.Trim().Length -gt 0 } | Write-Host
}

^{Note: This simple implementation buffers all pipeline input first, which is suboptimal; for a proper but more complex, streaming implementation using a proxy function, see this answer.}

You can place it in your $PROFILE file to be available in all future sessions (except those where PowerShell is invoked with -NoProfile).

All commands implicitly use this function for to-host (console) output, because Out-Default is a special command that PowerShell calls behind the scenes for handling to-host output (that is, for output that is neither captured nor piped nor redirected).

Therefore, once the function has been defined, simply calling Get-ChildItem (which is aliased to dir), for instance, should produce output with all empty/blanks removed.

Note that capturing / piping / redirecting output is not affected, as is desirable.

Caveat: As stated, Out-Default only affects to-host output, not also the behavior of other formatting system-based Out-* cmdlets, which you'd have to redefine separately, if desired.

Notably, a redefined Out-Default does not affect Out-File and its effective aliases > / >> - see the bottom section for a custom Out-File implementation that performs the same stripping of blank lines.

As an aside: PowerShell comes with a default Out-Default command, implemented as a cmdlet. While you can call Out-Default directly (whether the default implementation or a custom one), there is no reason to, and doing so should be avoided - see this answer.

As Compo points out, you can use the same technique ad hoc, for a given command; e.g.:

Get-ChildItem | Out-String -Stream | Where { $_.Trim().Length -gt 0 }

Note, however, that - unlike the Out-Default approach - this technique is suitable for display only, because you're then outputting string representations rather than the original objects (and if you were to pipe to Write-Host, you would bypass the (success) output stream altogether).

Custom Out-File function that also strips empty/blank lines and is also called by > / >>:

Note:

• This function is more complex than the custom Out-Default function, because it needs to support the same parameters as the original cmdlet.

• It will be noticeably slower than the original Out-File / > / >>, and it doesn't support the common -Confirm and -WhatIf parameters (which are rarely used with Out-File, however).

• As printed below, the function is designed for use in PowerShell (Core) 7 - see the comments in the source code for how to (easily) adapt it to Windows PowerShell.

# Note: Supports neither -Confirm nor -WhatIf
function Out-File {
  [CmdletBinding(DefaultParameterSetName = 'ByPath', HelpUri = 'https://go.microsoft.com/fwlink/?LinkID=2096621')]
  param(
    [Parameter(ParameterSetName = 'ByPath', Mandatory, Position = 0)]
    [Alias('Path')]
    [string] $FilePath,
  
    [Parameter(ParameterSetName = 'ByLiteralPath', Mandatory, ValueFromPipelineByPropertyName)]
    [Alias('PSPath', 'LP')]
    [string]
    $LiteralPath,
  
    [Parameter(Position = 1)]
    # Note: This validation set is for *PowerShell 7*.
    # For Windows PowerShell support, comment out the the next line and uncomment the one after.
    [ValidateSet('ascii', 'bigendianutf32', 'unicode', 'utf8', 'utf8NoBOM', 'bigendianunicode', 'oem', 'utf7', 'utf8BOM', 'utf32')]
    # [ValidateSet('default', 'ascii','bigendianutf32','unicode','utf8','bigendianunicode','oem','utf7','utf32')]
    [string] $Encoding,
  
    [switch] $Append,
  
    [switch] $Force,
  
    [Alias('NoOverwrite')]
    [switch] $NoClobber,
  
    [ValidateRange(2, 2147483647)]
    [int] $Width,
  
    [switch] $NoNewline,
  
    [Parameter(ValueFromPipeline)]
    [psobject] $InputObject
  )
  begin {
    try {
      $steppablePipeline = { 
        Out-String -Stream | Where-Object { $_.Trim().Length } | 
          Microsoft.PowerShell.Utility\Out-File @PSBoundParameters
      }.GetSteppablePipeline($myInvocation.CommandOrigin)
      $steppablePipeline.Begin($PSCmdlet)
    }
    catch {
      $PSCmdlet.ThrowTerminatingError($_)
    }
  }
  process {
    try {
      $steppablePipeline.Process($InputObject)
    }
    catch {
      $PSCmdlet.ThrowTerminatingError($_)
    }
  }
  end {
    try {
      $steppablePipeline.End()
    }
    catch {
      $PSCmdlet.ThrowTerminatingError($_)
    }
  }
}