Можно ли вернуть действительный ключ из хеш-таблицы?

Предисловие:

• Небольшое предостережение: решения, приведенные ниже, используют оператор PowerShell -eq для выполнения сравнения равенства без учета регистра, которое неявно происходит в контексте инвариантной культуры, где, как задано, хеш-таблица/словарь могут использовать другой контекст культуры, например, нынешний.
  Хотя обычно это не имеет значения, есть крайние случаи, когда это может иметь значение. Из-за отсутствия возможности получить компаратор, который данный экземпляр хеш-таблицы/словаря использует внутри себя, не существует надежного решения этой проблемы.

Мне неизвестен эффективный способ получения исходного ключа в точной по регистру форме, но ниже приводится краткий способ (в ущерб производительности 'First' можно опустить) с использованием встроенного .Where() метод:

@{
 'One' = 1
 'Two' = 2
 'Three' = 3
}.Keys.Where({ $_ -eq 'two' }, 'First')[0] # -> 'Two'

Примечание:

• Вышеупомянутое надежно работает только со словарями, нечувствительными к регистру, которыми являются хеш-таблицы PowerShell и [ordered] литералы хэш-таблицы (обратите внимание, что использование 'First' не является строго обязательным, но является оптимизацией производительности: он перестает следить за первым - и определение только в регистронезависимом словаре — match [0] извлекает единственный элемент коллекции совпадений, который .Where() неизменно возвращает).

• В случае словарей, чувствительных к регистру, вышеизложенное может сообщать о ложных срабатываниях — см. ниже решение, которое также работает с такими словарями.

  • Если, напротив, вы хотите получить (потенциально) все ключи из регистрозависимого словаря, которые идентичны или имеют вариации по регистру данного ключа поиска (независимо от того, соответствует ли ключ поиска одному из них с точностью до регистра), замените
    .Keys.Where({ $_ -eq 'two' }, 'First')[0] с
    .Keys.Where({ $_ -eq 'two' })

• Причина, по которой это неэффективно, заключается в необходимости выполнения линейного (O(N)) поиска по коллекции ключей, а тот факт, что блок сценария должен вызываться для каждого элемента коллекции, не помогает.

Работа со словарем, чувствительность к регистру которого неизвестна, требует дополнительной работы, включая, возможно, проверку всех ключей:

# Note: [System.Collections.Specialized.OrderedDictionary] is the type
#       underlying [ordered] hashtable literals in PowerShell.
#       It - like [System.Collections.Hashtable] - is case-SENSITIVE by default; 
#       it is PowerShell that makes them case-INsensitive behind the scenes.
$dictionary = [System.Collections.Specialized.OrderedDictionary]::new()
$dictionary['One'] = 1
$dictionary['TWO'] = 2
$dictionary['two'] = 2  # case variation
$dictionary['Three'] = 2

$lookupKey = 'two'

# -> Stores 'two' in $actualKey, the case-exact match.
$actualKey = 
  if ($dictionary.Contains($lookupKey)) {
    $candidateKeys = $dictionary.Keys.Where({ $_ -eq $lookupKey }, 0, 2)
    if ($candidateKeys.Count -ge 2) { $lookupKey }
    else                            { $candidateKeys }
  }

• .Contains($lookupKey), отсеивает ключи поиска, которые не соответствуют существующему ключу, независимо от регистра или без учета регистра.

• .Where({ $_ -eq $lookupKey }, 0, 2) ищет не более 2 кандидатов (потенциальных) ключевых совпадений, без учета регистра; ограничение поиска двумя кандидатами является оптимизацией производительности: по наличию двух (или более) ключей, которые являются вариациями регистра друг друга, можно сделать вывод, что имеющийся словарь чувствителен к регистру.

• Если есть (по крайней мере) два потенциальных ключа ($candidateKeys.Count -ge 2), это означает, что хеш-таблица чувствительна к регистру и, следовательно, ключ поиска по определению уже находится в форме с точным регистром (в противном случае .Contains() не возвращался бы $true) , поэтому $lookupKey возвращается.

• В противном случае, если возвращается только один ключ-кандидат, этот ключ по определению является правильным и возвращается (обратите внимание, что в этом случае нет необходимости использовать [0] для вывода самого единственного элемента, поскольку использование Оператор if вызывает автоматическое перечисление любой коллекции (перечисляемой), как в конвейере).

Альтернатива, которая оптимизируется для случая, когда ключ поиска уже находится в точной по регистру форме:

$actualKey =
  if ($dictionary.Contains($lookupKey)) {
      if (-1 -ne [Array]::IndexOf($dictionary.Keys, $lookupKey)) { $lookupKey }
      else { $dictionary.Keys.Where({ $_ -eq $lookupKey }, 'First') }
  }

• Как только существование соответствующего ключа подтверждено с помощью .Contains(), сначала выполняется регистрозависимый (линейный) поиск с использованием [Array]::IndexOf() (который выполняет сравнения с учетом регистра и региональных параметров), который работает намного лучше, чем фильтр .Where().

• Если обнаружено совпадение с точным регистром, ключ поиска по определению уже находится в форме с точным регистром.

• В противном случае подразумевается, что словарь нечувствителен к регистру и, следовательно, этого достаточно для поиска первого (и по определению только) ключа в коллекции .Keys, который без учета регистра соответствует ключу поиска, используя .Where() с -eq.

Гипотетическое эффективное решение потребует эффективных (O(1)) поисков в коллекции .Keys, которые сами возвращают совпадающие ключи, но, как вы заметили, словари не предназначены для этого, поскольку они переводят ключи в абстрактные хеши (числа) для поиска. значений (и эти хэши не имеют обратной связи с ключами, из которых они были получены).

Если бы это было возможно - это не так^[1] - получить System.Collections.IEqualityComparer / System.Collections.Generic.IEqualityComparer`1 , используемый данным экземпляром словаря, и конкретный используемый экземпляр имеет тип предоставляется через статические свойства класса System.StringComparer , например [System.StringComparer]::OrdinalIgnoreCase, вы можете, по крайней мере, сделать вывод о чувствительности к регистру и оптимизировать на основе этого: если словарь чувствителен к регистру и поиск значения (.Contains()) завершается успешно, вы по определению имеете дело с формой ключа, точной по регистру; в противном случае достаточно (линейно) найти первый ключ, совпадающий без учета регистра, в .Keys.
Если данный словарь имеет тип System.Collections.Generic.SortedDictionary`2, вы можете выполнить бинарный поиск по коллекции .Keys, воспользовавшись тем фактом, что коллекция ключей по определению отсортирована по строки:
[Array]::BinarySearch($sortedDict.Keys, $lookupKey, [StringComparer]::InvariantCultureIgnoreCase)

В частности, с помощью System.Collections.Generic.SortedDictionary`2 вы можете добиться относительно эффективного решения, даже не зная компаратора, с помощью двух-трех нелинейных поисков (хотя на практике вы можете не заметить разницы с линейным подходом, за исключением больших словарей):

• Проверьте, соответствует ли ключ поиска .Contains(), и остановитесь, если нет.

• Если это так, сначала используйте двоичный поиск с учетом регистра: если он успешен, ключ поиска по определению уже находится в форме с учетом регистра, поэтому верните его.

• В противном случае (словарь должен быть нечувствителен к регистру) повторите поиск без учета регистра, который по определению найдет единственный соответствующий ключ, который является регистрозависимым вариантом ключа поиска, и вернет его.

^[1]

На основе тестов Pester и предоставленных сценариев использования.

Вы можете добавить член метода сценария get_Key в хеш-таблицу, которая выполняет поиск по списку ключей, который точно соответствует формату заголовка (без учета всех заглавных букв*) указанной строки параметра $CaseInsensitiveKey, используя метод System.Globalization.TextInfo.ToTitleCase():

$Hashtable | Add-Member -Force -MemberType ScriptMethod -Name get_Key -Value {
  param([string] $CaseInsensitiveKey)
  if (($Keys = @($this.Keys.Where{ $_ -eq $CaseInsensitiveKey })).Count -gt 1) {
    return $Keys.Where{ $_ -ceq $CaseInsensitiveKey }
  }
  return $Keys[0]
}

* Формат Title-Case включает все прописные буквы, которые в этом случае игнорируются.

Базовое решение

$this.Keys возвращает список ключей, который фильтруется по индексу в методе Where(). Это означает, что возвращаемое значение не является сфабрикованным. Из отредактированного решения добавлен дополнительный тест на то, что ключ поиска возвращает значение, когда он индексируется хеш-таблицей. Однако решение не самое оптимальное, поскольку поиск производится дважды.

Результат теста Пестера

Starting discovery in 1 files.
Discovery found 20 tests in 19ms.
Running tests.
[+] W:\PowerShell\markdown-to-html-shortcut\MarkdownToHtmlShortcut\test.ps1 119ms (39ms|63ms)
Tests completed in 123ms
Tests Passed: 20, Failed: 0, Skipped: 0 NotRun: 0

Тест на Пестера и результаты

На основе статей about_Hash_Tables и about_Arrays:

Обновлять:

$HashTable = @{ 'One' = 1; 'Two' = 2; 'Three' = 3}

$HashTable.Keys | Where-Object { $_ -eq 'two' }  # returns string of value 'Two'
$HashTable.Keys | Where-Object { $_ -eq 'foo' }  # returns $null

# or

$HashTable.Keys.Where( { $_ -eq 'two' } ) # returns Collection`1 of value @('Two')
$HashTable.Keys.Where( { $_ -eq 'foo' } ) # returns Collection`1 of value @()

Оригинальный ответ:

$HashTable = @{ 'One' = 1; 'Two' = 2; 'Three' = 3; 'Single' = 1 }

$HashTable.Keys | Where-Object { $HashTable.$_ -eq 1 }

'--- or using GetEnumerator method ---'
$HashTable.GetEnumerator().Where( {$_.Value -eq 1}) |
    Select-Object -ExpandProperty Name

Хорошо! Я считаю, что решение, охватывающее оба сценария сопоставления с учетом регистра и без учета регистра на основе количества, может выглядеть примерно так:

$HashTable = @{ 'One' = 1; 'Two' = 2; 'Three' = 3 }

$to_match = 'two'

[System.Linq.Enumerable]::Where(
    ($entries = [System.Collections.DictionaryEntry[]]@($HashTable.GetEnumerator())),
    [Func[System.Collections.DictionaryEntry, bool]]{
        param($entry)
        $entry.Key -match $to_match -and $entries.Where{$_.Key -match $to_match}.Count -eq 1 -or 
        $entry.Key -cmatch $to_match -and $entries.Where{$_.Key -match $to_match}.Count -ge 1
    }
)

где мы превращаем хеш-таблицу в набор явных DictionaryEntry, а затем фильтруем записи с помощью Linq.EnumerableWhere() метода. Так,

• если ключи содержат ровно 1 соответствующий ключ, верните пару с учетом регистра
• но если ключи содержат более одного соответствующего ключа, для возврата записи используйте сопоставление с учетом регистра.

Теперь мы получаем, что 'one' соответствует одной записи 'one','One','oNe' и т. д., но несколько записей, таких как 'two','TWO', сопоставляются с тем, что фильтруется в $to_match.