我需要對具有多級索引的串列進行排序

(@('1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10") | Sort-Object) -join ", "

1、1.1.1、1.99、10、2、2.5、3、5.5 _ _

我想出了這樣一個解決方案，但它不適用于十以上的索引

(@('1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10") | Sort-Object {
    $chanks = $_.Split('.')
    $sum = 0
    for ($i = 0; $i -lt $chanks.Count; $i  ) {
        $sum  = [int]$chanks[$i] / [math]::Pow(10, $i)
    }
    $sum
}) -join ", "

1, 1.1.1, 2, 2.5, 3, 5.5, 10, 1.99

uj5u.com熱心網友回復：

根據 Lance U. Matthews 對您的問題的評論... | Sort-Object { [int] $_.Split('.')[0] }, { [int] $_.Split('.')[1] }, { [int] $_.Split('.')[2] }，

這是一種在不知道嵌套級別數的情況下做同樣事情的方法。

它是通過檢查最大嵌套級別并將其存盤到一個變數中來完成的，然后動態構建一個腳本塊陣列以進行排序。

$Arr = @('1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10", '12.9.3.1.5', '176', '12.9.9', '2.1') 
$MaxDots = ($Arr | % { $_.Split('.').count } | Measure-Object  -Maximum).Maximum

$sbl = for ($i = 0; $i -lt $MaxDots; $i  ) {
  { [int] $_.Split('.')[$i] }.GetNewClosure()
}

$Arr | Sort-Object $sbl

uj5u.com熱心網友回復：

這是一些帶有一些警告的解決方案。

的-Property引數Sort-Object接受一個陣列，因此您可以指定“排序方式...然后...”。如果您知道“子索引”的最大數量是 2（即x.y.z），那么您可以將字串分成由分隔的組件.，然后按每個組件作為整數連續排序。它是重復的，但它有效......

(
    @('1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10") |
        Sort-Object -Property {
            # Sort by the first component
            return [Int32] $_.Split('.')[0]
        }, {
            # Sort by the second component
            return [Int32] $_.Split('.')[1]
        }, {
            # Sort by the third component
            return [Int32] $_.Split('.')[2]
        }
) -join ', '

如果未指定組件（例如'1.2'.Split('.')[2]），那么0在轉換為[Int32].

這是一種僅使用一個的替代方法，[ScriptBlock]但它也要求知道子索引的最大數字長度......

$maxComponentCount = 3
$maxComponentDigits = 2

# Create a string of repeated '0's $maxComponentDigits long
$emptyComponentText = [String]::new([Char] '0', $maxComponentDigits)

(
    @('1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10") |
        Sort-Object -Property {
            $components = [String[]] (
                $_.Split('.').ForEach(
                    # Pad each component to $maxComponentDigits digits
                    { $_.PadLeft($maxComponentDigits, '0') }
                )
            );
            
            if ($components.Length -lt $maxComponentCount)
            {
                # Pad $components up to $maxComponentCount with $emptyComponentText elements
                $components  = ,$emptyComponentText * ($maxComponentCount - $components.Length)
            }

            # Join components - now $maxComponentCount elements of $maxComponentDigits digits - back into an index string
            return $components -join '.'
        }
) -join ', '

那就是填充每個輸入索引以具有相同數量的子索引，并且每個子索引具有相同數量的數字，然后依靠詞法排序將它們按正確的順序排列，所以這......

@('1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10")

......得到排序，好像它看起來像這樣......

@('01.00.00', '02.00.00', '03.00.00', '01.01.01', '01.99.00', '02.05.00', '05.05.00', "10.00.00")

我想你可以同時設定$maxComponentCount和$maxComponentDigits設定，比如說，100如果兩個值都不知道，但這感覺就像一個笨拙的解決方法（也有性能影響）。我會試著想一些更好的東西。

uj5u.com熱心網友回復：

'1', '2', '3', '1.1.1', '1.99', '2.5', '5.5', "10" |Sort-Object { '{0:000}{1:000}{2:000}{3:000}' -f $([int[]]("$_.0.0.0".Split('.'))) }

uj5u.com熱心網友回復：

絕對排序鍵與相對排序方向

我們遇到的問題是，每個[ScriptBlock]傳遞給的每次Sort-Object只接收一個輸入值并回傳一個要排序的鍵值，但是每個索引都有可變數量的子索引，我們無法預測如何當有我們尚未看到的值時，我們需要比較許多級別。我們需要的是一種方法來定義兩個值應該如何相對于彼此進行排序。

幸運的是，（Windows）PowerShell 所基于的 .NET 定義了各種方法用來確定值排序順序的[IComparer[]]介面。它的唯一方法 ,Compare()被傳遞兩個值并回傳它們是否相等，否則，哪個在另一個之前。我們所要做的就是提供我們自己的（簡單）實作，[IComparer[]]然后我們可以將它傳遞給內置的排序方法。

[IComparer[]]實作、使用和測驗輸出

[HierarchicalIndexComparer][IComparer[]]:用于索引字串的 .NET

# Source: https://stackoverflow.com/a/71237565/150605
class HierarchicalIndexComparer : System.Collections.Generic.Comparer[String]
{
    <#
        Implements Comparer[String].Compare()
        See https://docs.microsoft.com/dotnet/api/system.collections.generic.comparer-1.compare
            When $x -lt $y, returns negative integer
            When $x -eq $y, returns 0
            When $x -gt $y, returns positive integer
    #>
    [Int32] Compare([String] $x, [String] $y)
    {
        # Split each index into components converted to integers with validation
        [Int32[]] $xValues = [HierarchicalIndexComparer]::GetComponentValues($x)
        [Int32[]] $yValues = [HierarchicalIndexComparer]::GetComponentValues($y)
        [Int32] $componentsToCompare = [Math]::Min($xValues.Length, $yValues.Length)

        for ($i = 0; $i -lt $componentsToCompare; $i  )
        {
            [Int32] $componentCompareResult = $xValues[$i].CompareTo($yValues[$i])

            # Sort $x and $y by the current component values if they are not equal
            if ($componentCompareResult -ne 0)
            {
                return $componentCompareResult
            }

            # Otherwise, continue with the next component
        }

        # The first $componentsToCompare elements of $x and $y are equal
        # Sort $x and $y by their component count
        return $xValues.Length.CompareTo($yValues.Length)
    }

    hidden static [Int32[]] GetComponentValues([String] $index)
    {
        return [Int32[]] (
            $index.Split('.').ForEach(
                {
                    if ($_.Length -lt 1)
                    {
                        throw "Index string ""$index"" contains an empty sub-index."
                    }

                    [Int32] $value = -1

                    # Leading zeroes will be removed by parsing and not considered when comparing components
                    if (-not [Int32]::TryParse($_, [System.Globalization.NumberStyles]::None, [System.Globalization.CultureInfo]::InvariantCulture, [Ref] $value))
                    {
                        throw "Sub-index ""$_"" of string ""$index"" contains non-digit characters."
                    }

                    return $value
                }
            )
        )
    }
}

你可以看到我使用了一個PowerShell 類來提供對索引字串進行排序的[IComparer[]]介面的實作；它派生自推薦的[Comparer[]]類。請參閱此答案的最后一部分，了解[HierarchicalIndexComparer].

Once defined the class can then be referenced as...

[HierarchicalIndexComparer]

...and instantiated with...

New-Object -TypeName 'HierarchicalIndexComparer'

...or...

[HierarchicalIndexComparer]::new()

Sorting test index strings with a [HierarchicalIndexComparer]

Now that we have our own [IComparer[]] implementation we can pass an instance of it to a sorting method so it's able to sort index strings. LINQ is a .NET technology that allows you to perform operations on sequences in much the same way as the Group-Object, Select-Object, and Where-Object cmdlets do with PowerShell pipelines. LINQ provides two methods, OrderBy() and OrderByDescending(), to perform primary sorting of sequences. After defining some test index strings we just need to pass them and our comparer to one of those methods to get sorted output...

[String[]] $initial = 1, 10, 100 |
    ForEach-Object -Process { "$_", "$_.0", "$_.0.0", "$_.0.0.0", "$_.0.1", "$_.1", "$_.1.0", "$_.1.1" }
# Shuffle the elements into a "random" order that is the same between runs
[String[]] $shuffled = Get-Random -Count $initial.Length -InputObject $initial -SetSeed 12345
[String[]] $sorted = [System.Linq.Enumerable]::OrderBy(
    $shuffled,                                         # The values to be ordered
    [Func[String, String]] {                           # Selects the key by which to order each value
        param($value)

        return $value                                  # Return the value as its own key
    },
    (New-Object -TypeName 'HierarchicalIndexComparer') # The comparer to perform the ordering
) | ForEach-Object -Process {
    # Just for demonstration purposes to show that further pipeline elements can be used after sorting
    return $_
}

for ($index = 0; $index -lt $initial.Length; $index  )
{
    [PSCustomObject] @{
        '#'         = $index
        '$initial'  = $initial[$index]
        '$shuffled' = $shuffled[$index]
        '$sorted'   = $sorted[$index]
    }
}

The advantage of using [Enumerable]::OrderBy() with a custom [IComparer[]] is that it will provide proper sorting with one pass through your index strings, plus you can pipe the output into subsequent cmdlets.

Briefly, the three parameters being passed to OrderBy() are...

1. The sequence of index strings to be sorted
2. The "key" on which each index is sorted
   • We want each index string to be sorted on the string itself (since [HierarchicalIndexComparer] determines the ordering of index [String] instances), so we just return the same value that was passed to us; this is similar to ... | Sort-Object -Property { $_ }
   • See Can LINQ be used in PowerShell? for more information on what's going on here
3. An instance of our custom index comparer

You can also use the Array::Sort() static method, although that sorts the array passed to it in-place and doesn't return anything for a pipeline to process. Here I'll create a copy of the array first so it can be sorted separately...

# Create a copy of the $shuffled array named $sorted
$sorted = New-Object -TypeName 'System.String[]' -ArgumentList $shuffled.Length
[Array]::Copy($shuffled, $sorted, $shuffled.Length)

[Array]::Sort(
    $sorted,                                                      # The array to be sorted
    (New-Object -TypeName 'SO71232189.HierarchicalIndexComparer') # The comparer with which to sort it
)

Sorted result of test index strings using [HierarchicalIndexComparer]

The above script produces three arrays showing the different transformations of the index collection...

Additional notes

[HierarchicalIndexComparer] ordering logic

In short, the Compare() method...

[Int32] Compare([String] $x, [String] $y)
{
    # ...
}

...is splitting each index ($x and $y) into [Int32] components, comparing as many components as they have in common, sorting based on any components that are unequal, and if all common components are equal then sorting the shorter index first.

So, for example, when comparing "1.2.3" to "1.2" it breaks them up into "1", "2", "3" and "1", "2", respectively, and then performs the following comparisons:

Since all 2 components of $y equal the first 2 components of $x, it now falls to the index with less components sorting first; $x has 3 components whereas $y has 2, therefore $x sorts after $y, which is correct: "1.2.3" > "1.2".

When comparing "1.2.3" to "1.20.4" it breaks them up into "1", "2", "3" and "1", "20", "4", respectively, and then performs the following comparisons:

Since when comparing the first 3 components of $x and $y we find that component 1 of each is unequal, we return the result of that comparison; $x[1] < $y[1] therefore $x < $y, which is correct: "1.2.3 < 1.20.4".

標籤：电源外壳 排序 等级制度 字符串比较 排序对象

上一篇：日期欄位上的Elasticsearch條件排序

下一篇：如何設定要繪制的排序資料？