[encoding] बीओएम के बिना यूटीएफ -8 में एक फाइल लिखने के लिए PowerShell का उपयोग करना



Answers

@Moman टिप्पणियों में @Roman Kuzmin द्वारा अनुशंसित समाधान का उपयोग करने का उचित तरीका है। डडली answer :

[IO.File]::WriteAllLines($filename, $content)

(मैंने अनावश्यक System नेमस्पेस स्पष्टीकरण को अलग करके इसे छोटा कर दिया है - इसे डिफ़ॉल्ट रूप से स्वचालित रूप से प्रतिस्थापित किया जाएगा।)

Question

यूटीएफ -8 का उपयोग करते समय Out-File बीओएम को मजबूर करता है:

$MyFile = Get-Content $MyPath
$MyFile | Out-File -Encoding "UTF8" $MyPath

मैं PowerShell का उपयोग कर कोई बीओएम के साथ यूटीएफ -8 में एक फाइल कैसे लिख सकता हूं?




किसी भी कारण से, WriteAllLines कॉल अभी भी मेरे लिए बीओएम का उत्पादन कर रहे थे, बोमलेस यूटीएफ 8 एन्कोडिंग तर्क और इसके बिना। लेकिन निम्नलिखित मेरे लिए काम किया:

$bytes = gc -Encoding byte BOMthetorpedoes.txt
[IO.File]::WriteAllBytes("$(pwd)\BOMthetorpedoes.txt", $bytes[3..($bytes.length-1)])

मुझे काम करने के लिए फ़ाइल पथ को पूर्ण बनाना था। अन्यथा यह मेरे डेस्कटॉप पर फ़ाइल लिखा था। साथ ही, मुझे लगता है कि यह केवल तभी काम करता है यदि आप जानते हैं कि आपका बीओएम 3 बाइट है। मुझे नहीं पता कि एन्कोडिंग के आधार पर दिए गए बीओएम प्रारूप / लंबाई की अपेक्षा करना कितना विश्वसनीय है।

साथ ही, जैसा लिखा है, यह शायद तभी काम करता है जब आपकी फ़ाइल एक पावरहेल सरणी में फिट बैठती है, जो कि मेरी मशीन पर [int32]::MaxValue से कम कुछ मान की लंबाई सीमा है।




बीओएम के बिना यूटीएफ 8 प्राप्त करने के लिए नीचे उपयोग कर सकते हैं

$MyFile | Out-File -Encoding ASCII



एम। डडले के अपने सरल और व्यावहारिक उत्तर (और ForNeVeR के अधिक संक्षिप्त सुधार ) के पूरक के लिए :

सुविधा के लिए, यहां उन्नत फ़ंक्शन Out-FileUtf8NoBom , एक पाइपलाइन-आधारित विकल्प है जो Out-File नकल करता है , जिसका अर्थ है:

  • आप इसे एक पाइपलाइन में Out-File तरह ही उपयोग कर सकते हैं।
  • इनपुट ऑब्जेक्ट्स जो स्ट्रिंग्स नहीं हैं उन्हें प्रारूपित किया गया है क्योंकि वे आपको Out-File साथ ही कंसोल पर भेज देंगे।

उदाहरण:

(Get-Content $MyPath) | Out-FileUtf8NoBom $MyPath

ध्यान दें (Get-Content $MyPath) कैसे (Get-Content $MyPath) (...) में संलग्न है, जो सुनिश्चित करता है कि पूरी फ़ाइल खोला गया है, पूर्ण रूप से पढ़ा गया है, और पाइपलाइन के माध्यम से परिणाम भेजने से पहले बंद कर दिया गया है। यह एक ही फ़ाइल पर वापस लिखने में सक्षम होने के लिए आवश्यक है (इसे जगह में अपडेट करें)।
आम तौर पर, हालांकि, इस तकनीक को 2 कारणों से सलाह नहीं दी जाती है: (ए) पूरी फ़ाइल को स्मृति में फिट होना चाहिए और (बी) यदि आदेश बाधित है, तो डेटा खो जाएगा।

स्मृति उपयोग पर एक नोट:

  • एम। डडले के अपने उत्तर के लिए आवश्यक है कि पूरी फ़ाइल सामग्री पहले स्मृति में बनाई जाए, जो बड़ी फ़ाइलों के साथ समस्याग्रस्त हो सकती है।
  • नीचे दिया गया कार्य इस पर थोड़ा सा सुधार करता है: सभी इनपुट ऑब्जेक्ट्स अभी भी पहले buffered हैं, लेकिन उनके स्ट्रिंग प्रस्तुतियों को तब उत्पन्न किया जाता है और आउटपुट फ़ाइल में एक-एक करके लिखा जाता है।

Out-FileUtf8NoBom का स्रोत कोड ( एमआईटी-लाइसेंसीकृत गिस्ट के रूप में भी उपलब्ध है):

<#
.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) # Caveat: .NET Core doesn'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()
  }

}



Out-File बजाय Set-Content का उपयोग करते Set-Content , आप एन्कोडिंग Byte निर्दिष्ट कर सकते हैं, जिसे किसी फ़ाइल में बाइट सरणी लिखने के लिए उपयोग किया जा सकता है। यह एक कस्टम यूटीएफ 8 एन्कोडिंग के संयोजन में है जो बीओएम को उत्सर्जित नहीं करता है वांछित परिणाम देता है:

# This variable can be reused
$utf8 = New-Object System.Text.UTF8Encoding $false

$MyFile = Get-Content $MyPath -Raw
Set-Content -Value $utf8.GetBytes($MyFile) -Encoding Byte -Path $MyPath

[IO.File]::WriteAllLines() या इसी तरह का उपयोग करने के लिए अंतर यह है कि इसे किसी भी प्रकार के आइटम और पथ के साथ ठीक काम करना चाहिए, न केवल वास्तविक फ़ाइल पथ।




एक तकनीक जिसका मैं उपयोग करता हूं आउटपुट फ़ाइल cmdlet का उपयोग कर आउटपुट को ASCII फ़ाइल में रीडायरेक्ट करना है।

उदाहरण के लिए, मैं अक्सर SQL स्क्रिप्ट चलाता हूं जो ओरेकल में निष्पादित करने के लिए एक और SQL स्क्रिप्ट बनाता है। सरल पुनर्निर्देशन (">") के साथ, आउटपुट यूटीएफ -16 में होगा जो SQLPlus द्वारा मान्यता प्राप्त नहीं है। इसके आसपास काम करने के लिए:

sqlplus -s / as sysdba "@create_sql_script.sql" |
Out-File -FilePath new_script.sql -Encoding ASCII -Force

जेनरेट की गई स्क्रिप्ट को किसी अन्य यूनिकोड चिंता के बिना किसी अन्य SQLPlus सत्र के माध्यम से निष्पादित किया जा सकता है:

sqlplus / as sysdba "@new_script.sql" |
tee new_script.log





Related