Nota: esta respuesta se aplica a Windows PowerShell ; por el contrario, en la edición multiplataforma de PowerShell Core (v6 +), UTF-8 sin BOM es la codificación predeterminada , en todos los cmdlets.
En otras palabras: si está utilizando PowerShell [Core] versión 6 o superior , obtendrá archivos UTF-8 sin BOM de forma predeterminada (que también puede solicitar explícitamente con -Encoding utf8/ -Encoding utf8NoBOM, mientras que obtiene con la codificación -BOM con -utf8BOM).
Para complementar la propia respuesta simple y pragmática de M. Dudley (y la reformulación más concisa de ForNeVeR ):
Por conveniencia, aquí está la función avanzada Out-FileUtf8NoBom, una alternativa basada en canalización que imitaOut-File , lo que significa:
- puedes usarlo como
Out-Fileen una tubería.
- Los objetos de entrada que no son cadenas están formateados como lo estarían si los enviara a la consola, al igual que con
Out-File.
Ejemplo:
(Get-Content $MyPath) | Out-FileUtf8NoBom $MyPath
Tenga en cuenta cómo (Get-Content $MyPath)se incluye (...), lo que garantiza que todo el archivo se abra, se lea por completo y se cierre antes de enviar el resultado a través de la canalización. Esto es necesario para poder volver a escribir en el mismo archivo (actualizarlo en su lugar ).
En general, sin embargo, esta técnica no es aconsejable por 2 razones: (a) todo el archivo debe caber en la memoria y (b) si se interrumpe el comando, se perderán datos.
Una nota sobre el uso de la memoria :
- La propia respuesta de M. Dudley requiere que todo el contenido del archivo se acumule primero en la memoria, lo que puede ser problemático con archivos grandes.
- La siguiente función mejora ligeramente esto: todos los objetos de entrada todavía se almacenan en el búfer primero, pero sus representaciones de cadena se generan y se escriben en el archivo de salida una por una.
Código fuente deOut-FileUtf8NoBom (también disponible como Gist con licencia MIT ):
<#
.SYNOPSIS
Outputs to a UTF-8-encoded file *without a BOM* (byte-order mark).
.DESCRIPTION
Mimics the most important aspects of Out-File:
* Input objects are sent to Out-String first.
* -Append allows you to append to an existing file, -NoClobber prevents
overwriting of an existing file.
* -Width allows you to specify the line width for the text representations
of input objects that aren't strings.
However, it is not a complete implementation of all Out-String parameters:
* Only a literal output path is supported, and only as a parameter.
* -Force is not supported.
Caveat: *All* pipeline input is buffered before writing output starts,
but the string representations are generated and written to the target
file one by one.
.NOTES
The raison d'être for this advanced function is that, as of PowerShell v5,
Out-File still lacks the ability to write UTF-8 files without a BOM:
using -Encoding UTF8 invariably prepends a BOM.
#>
function Out-FileUtf8NoBom {
[CmdletBinding()]
param(
[Parameter(Mandatory, Position=0)] [string] $LiteralPath,
[switch] $Append,
[switch] $NoClobber,
[AllowNull()] [int] $Width,
[Parameter(ValueFromPipeline)] $InputObject
)
#requires -version 3
# Make sure that the .NET framework sees the same working dir. as PS
# and resolve the input path to a full path.
[System.IO.Directory]::SetCurrentDirectory($PWD.ProviderPath) # Caveat: Older .NET Core versions don't support [Environment]::CurrentDirectory
$LiteralPath = [IO.Path]::GetFullPath($LiteralPath)
# If -NoClobber was specified, throw an exception if the target file already
# exists.
if ($NoClobber -and (Test-Path $LiteralPath)) {
Throw [IO.IOException] "The file '$LiteralPath' already exists."
}
# Create a StreamWriter object.
# Note that we take advantage of the fact that the StreamWriter class by default:
# - uses UTF-8 encoding
# - without a BOM.
$sw = New-Object IO.StreamWriter $LiteralPath, $Append
$htOutStringArgs = @{}
if ($Width) {
$htOutStringArgs += @{ Width = $Width }
}
# Note: By not using begin / process / end blocks, we're effectively running
# in the end block, which means that all pipeline input has already
# been collected in automatic variable $Input.
# We must use this approach, because using | Out-String individually
# in each iteration of a process block would format each input object
# with an indvidual header.
try {
$Input | Out-String -Stream @htOutStringArgs | % { $sw.WriteLine($_) }
} finally {
$sw.Dispose()
}
}