Nota: questa risposta si applica a Windows PowerShell ; al contrario, nell'edizione multipiattaforma PowerShell Core (v6 +), UTF-8 senza distinta base è la codifica predefinita , su tutti i cmdlet.
In altre parole: se si utilizza PowerShell [Core] versione 6 o successiva , si ottengono file UTF-8 senza BOM per impostazione predefinita (che è anche possibile richiedere esplicitamente con -Encoding utf8/ -Encoding utf8NoBOM, mentre si ottiene con la codifica -BOM con -utf8BOM).
Per completare la risposta semplice e pragmatica di M. Dudley (e la riformulazione più concisa di ForNeVeR ):
Per comodità, ecco la funzione avanzata Out-FileUtf8NoBom, un'alternativa basata sulla pipeline che imitaOut-File , il che significa:
- puoi usarlo proprio come
Out-Filein una pipeline.
- gli oggetti di input che non sono stringhe vengono formattati come se fossero inviati alla console, proprio come con
Out-File.
Esempio:
(Get-Content $MyPath) | Out-FileUtf8NoBom $MyPath
Si noti come (Get-Content $MyPath)è racchiuso in (...), il che assicura che l'intero file sia aperto, letto per intero e chiuso prima di inviare il risultato attraverso la pipeline. Ciò è necessario per poter riscrivere nello stesso file (aggiornarlo sul posto ).
In genere, tuttavia, questa tecnica non è consigliabile per 2 motivi: (a) l'intero file deve rientrare nella memoria e (b) se il comando viene interrotto, i dati andranno persi.
Una nota sull'uso della memoria :
- La risposta di M. Dudley richiede che tutto il contenuto del file sia prima creato in memoria, il che può essere problematico con file di grandi dimensioni.
- La funzione seguente migliora solo leggermente: tutti gli oggetti di input vengono ancora bufferizzati per primi, ma le loro rappresentazioni di stringa vengono quindi generate e scritte nel file di output una per una.
Codice sorgente diOut-FileUtf8NoBom (disponibile anche come Gist con licenza 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()
}
}