डिफ़ॉल्ट PowerShell ls कमांड में मानव-पठनीय फ़ाइल आकार दिखाएं

26

मैं PowerShell में डिफ़ॉल्ट ls( Get-ChildItem) को कैसे संशोधित कर सकता हूं ताकि यह मानव-पठनीय फ़ाइल आकारों को प्रदर्शित करे, जैसे ls -hकि * nix मशीन?

ls -lh फ़ाइल आकार के साथ सरल तर्क करता है, ताकि यह वास्तव में छोटी फ़ाइलों के लिए बाइट्स दिखाता है, 1K से अधिक फ़ाइलों के लिए किलोबाइट्स (एक दशमलव स्थान के साथ यदि यह 10K से कम है), और मेगाबाइट्स 1M से अधिक फ़ाइलों के लिए (यदि यह 10MB है तो एक दशमलव स्थान के साथ) ।

powershell  powershell-2.0 
— टॉम मेफील्ड
स्रोत

जवाबों:

10

इसे इस्तेमाल करे

PS> gc c:\scripts\type\shrf.ps1xml

<Types>
<Type>
  <Name>System.IO.FileInfo</Name>
   <Members>
      <ScriptProperty>
          <Name>FileSize</Name>
          <GetScriptBlock>
             switch($this.length) {
               { $_ -gt 1tb } 
                      { "{0:n2} TB" -f ($_ / 1tb) }
               { $_ -gt 1gb } 
                      { "{0:n2} GB" -f ($_ / 1gb) }
               { $_ -gt 1mb } 
                      { "{0:n2} MB " -f ($_ / 1mb) }
               { $_ -gt 1kb } 
                      { "{0:n2} KB " -f ($_ / 1Kb) }
               default  
                      { "{0} B " -f $_} 
             }      
          </GetScriptBlock>
     </ScriptProperty>   
  </Members>
</Type>
</Types>

PS> Update-TypeData -AppendPath c:\scripts\type\shrf.ps1xml -verbose
PS> get-childItem $env:windir  | select Name,FileSize,length
PS> # you can paste this in your profile
PS>

तुम भी PS3 के साथ गतिशील प्रकार डेटा का उपयोग कर सकते हैं:

   PS> Update-TypeData -TypeName System.IO.FileInfo -MemberName FileSize -MemberType ScriptProperty -Value { 

    switch($this.length) {
               { $_ -gt 1tb } 
                      { "{0:n2} TB" -f ($_ / 1tb) }
               { $_ -gt 1gb } 
                      { "{0:n2} GB" -f ($_ / 1gb) }
               { $_ -gt 1mb } 
                      { "{0:n2} MB " -f ($_ / 1mb) }
               { $_ -gt 1kb } 
                      { "{0:n2} KB " -f ($_ / 1Kb) }
               default  
                      { "{0} B " -f $_} 
             }      

 } -DefaultDisplayPropertySet Mode,LastWriteTime,FileSize,Name
— वालिद तौमी
स्रोत
मुझे वास्तव में एक अतिरिक्त संपत्ति के रूप में इसका निर्माण करना पसंद है। PS3 संस्करण का उपयोग करने में एकमात्र समस्या मुझे मिलती है: Update-TypeData : Error in TypeData "System.IO.FileInfo": The member DefaultDisplayPropertySet is already present.9/4 से नवीनतम PS3 पूर्ण रिलीज चल रहा है।
— टॉम मेफ़ील्ड
3
बहुत बढ़िया जवाब! यह विश्वास करना मुश्किल है कि इसके लिए एक स्विच नहीं है Get-ChildItemजो बस इस बॉक्स से बाहर कर देगा
— बेन कॉलिन्स
शानदार जवाब लेकिन क्या किसी -DefaultDisplayPropertySetको काम मिला है?
— निक कॉक्स
@ ThomasG.Mayfield की तरह काम नहीं करता है।
— क्रिसब्रोनी 55
14

सबसे पहले, निम्नलिखित फ़ंक्शन बनाएं:

Function Format-FileSize() {
    Param ([int]$size)
    If     ($size -gt 1TB) {[string]::Format("{0:0.00} TB", $size / 1TB)}
    ElseIf ($size -gt 1GB) {[string]::Format("{0:0.00} GB", $size / 1GB)}
    ElseIf ($size -gt 1MB) {[string]::Format("{0:0.00} MB", $size / 1MB)}
    ElseIf ($size -gt 1KB) {[string]::Format("{0:0.00} kB", $size / 1KB)}
    ElseIf ($size -gt 0)   {[string]::Format("{0:0.00} B", $size)}
    Else                   {""}
}

फिर आप फ़ाइलों को प्रारूपित करने के लिए एक परिकलित संपत्ति के Get-ChildItemमाध्यम से आउटपुट का Select-Objectउपयोग कर सकते हैं :

Get-ChildItem | Select-Object Name, @{Name="Size";Expression={Format-FileSize($_.Length)}}

फ़ंक्शन को निश्चित रूप से पीबी रेंज में आकारों के लिए और अधिक, या आवश्यकतानुसार दशमलव बिंदुओं की संख्या को अलग करने के लिए सुधार किया जा सकता है।

— Indrek
स्रोत
क्या कोई कारण है कि एक उपनाम को इसे स्वयं प्राप्त करने के लिए नहीं बनाया जा सकता है (जाँच वहाँ एक-ध्वज या कुछ और है, और यदि नहीं, तो बस Get-ChildItem का उपयोग करें, अन्य का उपयोग करें)
— soandos
आप पाइप किए गए आदेशों के लिए उपनाम नहीं बना सकते, और न ही डिफ़ॉल्ट उपनामों को ओवरराइड कर सकते हैं। यदि आप एक उपनाम का उपयोग कर के साथ रह सकते हैं, तो एक ls2और फ़ंक्शन बनाने का प्रयास करें जो आपके द्वारा वर्णित पैरामीटर पर आधारित है, तो इसके लिए एक उपनाम जोड़ें। उपनाम बनाने के बारे में अधिक जानकारी के लिए यहाँ देखें ।
— Indrek
वैकल्पिक रूप से, cmdlet आउटपुट का विस्तार करने के लिए कस्टम स्वरूपण फ़ाइलों में देखें । एक उदाहरण के लिए इस मंच विषय को देखें । इसके अलावा, PowerShell सत्र के माध्यम से स्वरूपण फ़ंक्शन को बनाए रखने के लिए, इसे अपनी प्रोफ़ाइल फ़ाइल में जोड़ें ( Get-Variable profileइसके स्थान के लिए देखें )।
— Indrek
1
मेरे लिए, यह फ़ंक्शन ~ 2GB से बड़ी फ़ाइलों को काम नहीं करता है, जैसा $size कि एक के रूप में परिभाषित किया गया है int, जो कि एint32 । इसके लिए बड़ी फ़ाइलों के साथ काम करने के लिए, या के $sizeरूप में परिभाषित करें । int64uint64
— एलेक्स लीच
मुझे मिलता है Select-Object : Es wurde kein Positionsparameter gefunden, der das Argument "System.Collections.Hashtable" akzeptiert.। मैं कैसे पथ निर्दिष्ट कर सकता हूं? मैं उपयोग करता हूं $pst= Get-ChildItem -Path $home_user -Filter *.pst -Recurse -File| Sort-Object Length -Descending | ForEach-Object{ $_.FullName}। यह काम करता है, लेकिन फ़ाइल आकार के बिना।
— तिमो
6

सिर्फ फ़ाइल साइज़ को सूचीबद्ध करने के लिए कुछ इस प्रकार है। हां यह आंखों पर थोड़ा व्यंग्य है लेकिन यह काम पूरा करने का प्रबंधन करता है।

KB में परिवर्तित करने के लिए:

ls | Select-Object Name, @{Name="KiloBytes";Expression={$_.Length / 1KB}}

MB में परिवर्तित करने के लिए:

ls | Select-Object Name, @{Name="MegaBytes";Expression={$_.Length / 1MB}}
— jmreicha
स्रोत
1
सर्वश्रेष्ठ उत्तर, बिना स्क्रिप्ट / फ़ंक्शन के। pipeसमाधान!
— टिमो
3

वालिद तौमी के जवाब के आधार पर:

करने के लिए कदम:

  • नई FileSize-Property के साथ अपनी खुद की टाइप-फ़ाइल बनाएं
  • FileInfo के लिए मानक आउटपुट स्वरूप बदलें
  • में परिवर्तन लोड करें $PROFILE

नई FileSize-Property के साथ अपनी खुद की टाइप-फ़ाइल बनाएं

  • अपनी खुद की टाइप-फ़ाइल बनाएं: MyTypes.ps1xml
    (मैंने इसे $Env:USERPROFILE\Documents\WindowsPowershellअपने सामने रखा , इसलिए मेरे ठीक बगल में $PROFILE)

    <?xml version="1.0" encoding="utf-8" ?>
<Types>
    <Type>
        <Name>System.IO.FileInfo</Name>
        <Members>
            <ScriptProperty>
                <!-- Filesize converts the length to a human readable
                    format (kb, mb, gb, tb) -->
                <Name>FileSize</Name>
                <GetScriptBlock>
                    switch($this.length) {
                        { $_ -gt 1tb } 
                            { "{0:n2} TB" -f ($_ / 1tb) ; break }
                        { $_ -gt 1gb } 
                            { "{0:n2} GB" -f ($_ / 1gb) ; break }
                        { $_ -gt 1mb } 
                            { "{0:n2} MB " -f ($_ / 1mb) ; break }
                        { $_ -gt 1kb } 
                            { "{0:n2} KB " -f ($_ / 1Kb) ; break }
                        default
                            { "{0}  B " -f $_}
                    }
                </GetScriptBlock>
            </ScriptProperty>
        </Members>
    </Type>
</Types>

  • नई प्रॉपर्टी को पावरशेल-सेशन में लोड करें:

    • Update-TypeData -PrependPath $Env:USERPROFILE\Documents\WindowsPowershell\MyTypes.ps1xml
  • नई संपत्ति का प्रयास करें
    • Get-ChildItem | Format-Table -Property Name, Length, FileSize

FileInfo के लिए मानक आउटपुट स्वरूप बदलें

  • अपनी खुद की Fileformat-file बनाएँ: MyFileFormat.format.ps1xml (फिर से $Env:USERPROFILE\Documents\WindowsPowershell\)

    <?xml version="1.0" encoding="utf-8" ?> 
<Configuration>
    <SelectionSets>
        <SelectionSet>
            <Name>FileSystemTypes</Name>
            <Types>
                <TypeName>System.IO.DirectoryInfo</TypeName>
                <TypeName>System.IO.FileInfo</TypeName>
            </Types>
        </SelectionSet>
    </SelectionSets>

    <!-- ################ GLOBAL CONTROL DEFINITIONS ################ -->
    <Controls>
        <Control>
            <Name>FileSystemTypes-GroupingFormat</Name>
                    <CustomControl>
                        <CustomEntries>
                            <CustomEntry>
                                <CustomItem>
                                    <Frame>
                                        <LeftIndent>4</LeftIndent>
                                        <CustomItem>
                                            <Text AssemblyName="System.Management.Automation" BaseName="FileSystemProviderStrings" ResourceId="DirectoryDisplayGrouping"/>
                                            <ExpressionBinding>
                                              <ScriptBlock>
                                                  $_.PSParentPath.Replace("Microsoft.PowerShell.Core\FileSystem::", "")                                                  
                                              </ScriptBlock>
                                            </ExpressionBinding>
                                            <NewLine/>
                                        </CustomItem> 
                                    </Frame>
                                </CustomItem>
                            </CustomEntry>
                        </CustomEntries>
            </CustomControl>
        </Control>
    </Controls>

    <!-- ################ VIEW DEFINITIONS ################ -->

    <ViewDefinitions>
       <View>
            <Name>children</Name>
            <ViewSelectedBy>
                <SelectionSetName>FileSystemTypes</SelectionSetName>
            </ViewSelectedBy>
            <GroupBy>
                <PropertyName>PSParentPath</PropertyName> 
                <CustomControlName>FileSystemTypes-GroupingFormat</CustomControlName>  
            </GroupBy>
            <TableControl>
                <TableHeaders>
                   <TableColumnHeader>
                      <Label>Mode</Label>
                      <Width>7</Width>
                      <Alignment>left</Alignment>
                   </TableColumnHeader>
                    <TableColumnHeader>
                        <Label>LastWriteTime</Label>
                        <Width>25</Width>
                        <Alignment>right</Alignment>
                    </TableColumnHeader>
                    <TableColumnHeader>
                        <Label>FileSize</Label>
                        <Width>14</Width>
                        <Alignment>right</Alignment>
                    </TableColumnHeader>
                    <TableColumnHeader/>
                </TableHeaders>
                <TableRowEntries>
                    <TableRowEntry>
                        <Wrap/>
                        <TableColumnItems>
                            <TableColumnItem>
                                <PropertyName>Mode</PropertyName>
                            </TableColumnItem>
                            <TableColumnItem>
                                <ScriptBlock>
                                    [String]::Format("{0,10}  {1,8}", $_.LastWriteTime.ToString("d"), $_.LastWriteTime.ToString("t"))
                                </ScriptBlock>
                            </TableColumnItem>
                            <TableColumnItem>
                            <PropertyName>FileSize</PropertyName>
                            </TableColumnItem>
                            <TableColumnItem>
                                <PropertyName>Name</PropertyName>
                            </TableColumnItem>
                        </TableColumnItems>
                    </TableRowEntry>
                </TableRowEntries>
            </TableControl>
        </View>
        <View>
            <Name>children</Name>
            <ViewSelectedBy>
                <SelectionSetName>FileSystemTypes</SelectionSetName>
            </ViewSelectedBy>
            <GroupBy>
                <PropertyName>PSParentPath</PropertyName> 
                <CustomControlName>FileSystemTypes-GroupingFormat</CustomControlName>  
            </GroupBy>
            <ListControl>
                <ListEntries>
                    <ListEntry>
                        <EntrySelectedBy>
                            <TypeName>System.IO.FileInfo</TypeName>
                        </EntrySelectedBy>
                        <ListItems>
                            <ListItem>
                                <PropertyName>Name</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>FileSize</PropertyName>
                            </ListItem>
                           <ListItem>
                                <PropertyName>CreationTime</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>LastWriteTime</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>LastAccessTime</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>Mode</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>LinkType</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>Target</PropertyName>
                            </ListItem>                        
                            <ListItem>
                                <PropertyName>VersionInfo</PropertyName>
                            </ListItem>
                        </ListItems>
                    </ListEntry>
                    <ListEntry>
                        <ListItems>
                            <ListItem>
                                <PropertyName>Name</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>CreationTime</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>LastWriteTime</PropertyName>
                            </ListItem>
                            <ListItem>
                                <PropertyName>LastAccessTime</PropertyName>
                            </ListItem>
                          <ListItem>
                            <PropertyName>Mode</PropertyName>
                          </ListItem>
                          <ListItem>
                            <PropertyName>LinkType</PropertyName>
                          </ListItem>
                          <ListItem>
                            <PropertyName>Target</PropertyName>
                          </ListItem>
                        </ListItems>
                    </ListEntry>
                </ListEntries>
            </ListControl>
        </View>
        <View>
            <Name>children</Name>
            <ViewSelectedBy>
                <SelectionSetName>FileSystemTypes</SelectionSetName>
            </ViewSelectedBy>
            <GroupBy>
                <PropertyName>PSParentPath</PropertyName> 
                <CustomControlName>FileSystemTypes-GroupingFormat</CustomControlName>  
            </GroupBy>
            <WideControl>
                <WideEntries>
                    <WideEntry>
                        <WideItem>
                            <PropertyName>Name</PropertyName>
                        </WideItem>
                    </WideEntry>
                    <WideEntry>
                        <EntrySelectedBy>
                            <TypeName>System.IO.DirectoryInfo</TypeName>
                        </EntrySelectedBy>
                        <WideItem>
                            <PropertyName>Name</PropertyName>
                            <FormatString>[{0}]</FormatString>
                        </WideItem>
                    </WideEntry>
                </WideEntries>
            </WideControl>
        </View>
        <View>
            <Name>FileSecurityTable</Name>
            <ViewSelectedBy>
                <TypeName>System.Security.AccessControl.FileSystemSecurity</TypeName>
            </ViewSelectedBy>
            <GroupBy>
                <PropertyName>PSParentPath</PropertyName> 
                <CustomControlName>FileSystemTypes-GroupingFormat</CustomControlName>  
            </GroupBy>
            <TableControl>
                <TableHeaders>
                   <TableColumnHeader>
                      <Label>Path</Label>
                   </TableColumnHeader>
                   <TableColumnHeader />
                   <TableColumnHeader>
                      <Label>Access</Label>
                   </TableColumnHeader>
                </TableHeaders>
                <TableRowEntries>
                    <TableRowEntry>
                        <TableColumnItems>
                            <TableColumnItem>
                                <ScriptBlock>
                                    split-path $_.Path -leaf
                                </ScriptBlock>
                            </TableColumnItem>
                            <TableColumnItem>
                            <PropertyName>Owner</PropertyName>
                            </TableColumnItem>
                            <TableColumnItem>
                                <ScriptBlock>
                                    $_.AccessToString
                                </ScriptBlock>
                            </TableColumnItem>
                        </TableColumnItems>
                    </TableRowEntry>
                </TableRowEntries>
            </TableControl>
        </View>
       <View>
            <Name>FileSystemStream</Name>
            <ViewSelectedBy>
                <TypeName>Microsoft.PowerShell.Commands.AlternateStreamData</TypeName>
            </ViewSelectedBy>
            <GroupBy>
                <PropertyName>Filename</PropertyName> 
            </GroupBy>
            <TableControl>
                <TableHeaders>
                   <TableColumnHeader>
                      <Width>20</Width>
                      <Alignment>left</Alignment>
                   </TableColumnHeader>
                    <TableColumnHeader>
                        <Width>10</Width>
                        <Alignment>right</Alignment>
                    </TableColumnHeader>
                </TableHeaders>
                <TableRowEntries>
                    <TableRowEntry>
                        <TableColumnItems>
                            <TableColumnItem>
                                <PropertyName>Stream</PropertyName>
                            </TableColumnItem>
                            <TableColumnItem>
                                <PropertyName>Length</PropertyName>
                            </TableColumnItem>
                        </TableColumnItems>
                    </TableRowEntry>
                </TableRowEntries>
            </TableControl>
        </View>          
    </ViewDefinitions>
</Configuration>

    (यह मूल का एक सीधा कॉपी allmost है $PSHOME\FileFormat.format.ps1xml। मैं केवल बदल Lengthकरने के लिए FileSizeकई बार)

  • हमारे शक्तिके सत्र में नया प्रारूप लोड करें:

    • Update-FormatData -PrependPath $Env:USERPROFILE\Documents\WindowsPowershell\MyFileFormat.format.ps1xml
  • नई संपत्ति का प्रयास करें
    • Get-ChildItem

में परिवर्तन लोड करें $PROFILE

  • $PROFILEहर नए सत्र में परिवर्तनों को लोड करने के लिए इन पंक्तियों की प्रतिलिपि बनाएँ

    # local path to use in this script
$scriptpath = Split-Path -parent $MyInvocation.MyCommand.Definition

# custom types and formats
# currently only System.IO.FileInfo is changed
update-TypeData -PrependPath $scriptpath\MyTypes.ps1xml
update-FormatData -PrependPath $scriptpath\MyFileFormat.format.ps1xml
— egolus
स्रोत
0

मैंने अपनी $ प्रोफ़ाइल में एक उपनाम के साथ jmreicha के समाधान का उपयोग किया:

function Get-ChildItem-MegaBytes {
  ls $args | Select-Object Name, @{Name="MegaBytes";Expression={$_.Length / 1MB}}
}

Set-Alias -name megs -val Get-ChildItem-MegaBytes

अब मैं सिर्फ टाइप करता हूं: megs [whatever]

— राफेल किटओवर
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.