Índice
O método de inserir comandos diretamente no terminal PowerShell
Como escrever e executar arquivos .ps1
Pesquise por nome de arquivo, comprimento e extensão
escreva o resultado em um arquivo
Explicação do código (não é importante, é recomendado pular)
Use a ferramenta PowerShell para encontrar arquivos duplicados em várias pastas. Diferentes comandos e seus efeitos são exibidos, e o método correspondente é selecionado de acordo com o efeito desejado.
O acima é o método do produto acabado, selecione o código de acordo com o efeito, e o código pode ser copiado e usado.
Resumo final e explicação do código, o código pode ser ajustado conforme necessário.
O método de inserir comandos diretamente no terminal PowerShell
A saída é bruta
Abra o terminal powershell e digite diretamente
Get-ChildItem -Path C:\222, D:\111 -Recurse | Grupo-Objeto -Nome da Propriedade | Onde-Objeto { $_.Count -gt 1 }
-Parâmetro de caminho "C:\222, D:\111" modifica a pasta que você precisa encontrar de acordo com suas próprias necessidades.
O resultado é exibido na interface do terminal e o efeito de saída é:
Contagem Nome Grupo
----- ---- -----
4 1.docx {1.docx, 1.docx, 1.docx, 1.docx}
3 1.pptx {1.pptx, 1.pptx , 1.pptx}
O caminho pode ser alterado para um caminho chinês, ou seja, caminhos como "C:\222" podem conter caracteres chineses.
A saída está completa
Abra o terminal powershell e digite diretamente
Get-ChildItem -Path C:\222, D:\111 -Recurse | Grupo-Objeto -Nome da Propriedade | Onde-Objeto { $_.Count -gt 1 }| Selecione-Object -ExpandProperty Grupo | Select-Object FullName, Comprimento, CreationTime, LastWriteTime
-Parâmetro de caminho "C:\222, D:\111" modifica a pasta que você precisa encontrar de acordo com suas próprias necessidades.
O resultado é exibido na interface do terminal e o efeito de saída é:
FullName Comprimento CreationTime LastWriteTime
-------- ------ ------------ -------------
C:\222\1. docx 12175 2023/5/15 19:01:13 2023/5/15 16:41:39
D:\111\1.docx 12175 2023/5/15 16:39:09 2023/5/15 16:41: 39
D:\111\Nova Pasta\1.docx 0 2023/5/15 16:39:44 2023/5/15 16:39:09
D:\111\Nova Pasta\Nova Pasta (2)\ 1.docx 0 2023/5/15 16:39:53 2023/5/15 16:39:09
C:\222\1.pptx 0 2023/5/15 19:01:13 2023/5/15 16: 39:37
D:\111\1.pptx 0 2023/5/15 16:39:37 2023/5/15 16:39:37
D:\111\Nova pasta\1.pptx 0 2023/5/15 16:39: 44 15/05/2023 16:39:37
Como escrever e executar arquivos .ps1
O método de gravação e execução de arquivos .ps1 pode obter efeitos complexos.
Saída de classificação
Pesquise nas duas pastas C:\222 e D:\111:
Crie um novo documento de texto e insira o seguinte conteúdo:
$folderspath = "C:\222", "D:\111"
$files = Get-ChildItem -Path $folderspath -Recurse | Where-Object { !$_.PSIsContainer }
$groups = $files | Group-Object -Property Name | Where-Object { $_.Count -gt 1 }
foreach ($group in $groups) {
$group.Group | Select-Object FullName, Length, CreationTime | Sort-Object FullName | Format-Table -AutoSize
}
$folderspath = "C:\222", "D:\111" é modificado de acordo com a situação.
Salve como um arquivo com o sufixo “.ps1”, como “111.ps1”. Digite ".\111.ps1" no PowerShell para executar o arquivo.
Efeito:
.\12.ps1
Comprimento do nome completo CreationTime
-------- ------ ------------
C:\222\1.docx 12175 2023/5/15 17:28:00
D: \111\1.docx 12175 2023/5/15 16:39:09
D:\111\Nova pasta\1.docx 0 2023/5/15 16:39:44
D:\111\Nova pasta\Nova pasta( 2)\1.docx 0 2023/5/15 16:39:53Comprimento do nome completo Tempo de criação
-------- ------ ------------
C:\222\1.pptx 0 2023/5/15 17:23:57
D: \111\1.pptx 0 2023/5/15 16:39:37
D:\111\Nova pasta\1.pptx 0 2023/5/15 16:39:44
Pesquise por nome de arquivo, comprimento e extensão
Modifique o parâmetro "Group-Object -Property" e defina-o como desejar:
$folderspath = "C:\222", "D:\111"
$files = Get-ChildItem -Path $folderspath -Recurse | Where-Object { !$_.PSIsContainer }
$groups = $files | Group-Object -Property Length, Name, Extension | Where-Object { $_.Count -gt 1 }
foreach ($group in $groups) {
$group.Group | Select-Object FullName, Length, CreationTime | Sort-Object FullName | Format-Table -AutoSize
}
Efeito
Comprimento do nome completo Tempo de criação
-------- ------ ------------
C:\222\1.docx 12175 2023/5/15 19:01:13
D: \111\1.docx 12175 2023/5/15 16:39:09Comprimento do nome completo Tempo de criação
-------- ------ ------------
C:\222\1.pptx 0 2023/5/15 19:01:13
D: \111\1.pptx 0 2023/5/15 16:39:37
D:\111\Nova pasta\1.pptx 0 2023/5/15 16:39:44
Encontrar por valor MD5
Encontre o mesmo arquivo com base no valor MD5 do arquivo
$folderspath = "C:\222", "D:\111"
$files = Get-ChildItem -Path $folderspath -Recurse | Where-Object { !$_.PSIsContainer }
$md5s = $files | ForEach-Object { Get-FileHash $_.FullName | Select-Object -ExpandProperty Hash }
$groups = $files | Group-Object -Property @{ Expression={$md5s[$files.IndexOf($_)]} } | Where-Object { $_.Count -gt 1 }
foreach ($group in $groups) {
Write-Output "以下是 MD5 值为 $($group.Name) 的文件："
foreach ($item in $group.Group) {
Write-Output $item.FullName
}
Write-Output "---------------------------------------------------------------`n"
}
Este código é usado primeiro para Get-ChildItemobter todos os arquivos no caminho especificado e, em seguida, Get-FileHashpara calcular o valor MD5 de cada arquivo e salvá-lo na $md5svariável.
Em seguida, use para Group-Objectagrupar por valor MD5 e filtrar os grupos cujo número de arquivos no grupo seja maior que 1. Por fim, foreachpercorra cada grupo usando para gerar o caminho completo e o nome do arquivo desse grupo, com uma linha em branco entre cada grupo.
Efeito de saída:
Aqui está o arquivo com valor MD5 23C2732778B8A5BFAD00AEA036D8F614430822C40E69A511E1E7AA5F4535B753:
C:\222\1.docx
D:\111\1.docx
------------------------- -----------------------------------------A seguir está o arquivo cujo valor MD5 é E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855:
C:\222\1.pptx
C:\222\1.txt
D:\111\1.pptx
D:\111\1.txt
D:\ 111 \Nova pasta \ 1.pptx
D:\111\Nova Pasta\Nova Pasta (2)\1.docx
---------------------------- - ----------------------------------
Pode-se observar que os arquivos são considerados o mesmo arquivo de acordo com o valor MD5.
O autor descobriu por meio de experimentos que os arquivos copiados do mesmo arquivo possuem o mesmo valor MD5 e serão considerados arquivos duplicados. E se o arquivo copiado for modificado, seu valor MD5 muda e não é mais considerado um arquivo duplicado.
Além disso, os valores MD5 dos arquivos vazios são os mesmos. Por exemplo, os últimos seis arquivos no exemplo acima são todos arquivos vazios e são considerados arquivos duplicados.
MD5 (Message Digest Algorithm 5) é uma função hash unidirecional comumente usada, também conhecida como algoritmo de resumo de mensagem. Ele calcula uma "mensagem" de comprimento arbitrário (como conteúdo de arquivo ou fluxo de dados) como uma impressão digital de comprimento fixo, normalmente um número binário de 128 bits (16 bytes).
O algoritmo MD5 é amplamente utilizado em áreas como integridade de dados verificáveis e assinaturas criptografadas. As aplicações comuns incluem criptografia, certificados digitais, somas de verificação de arquivos, transmissão segura e muito mais. Ao comparar os valores MD5 de dois arquivos, pode-se avaliar se seu conteúdo é totalmente consistente. Se forem diferentes, significa que os arquivos foram adulterados ou danificados.
Deve-se notar que devido à vulnerabilidade de colisão no algoritmo MD5, duas mensagens diferentes podem ser construídas, mas seus valores MD5 são iguais. Portanto, com a melhoria do poder computacional, o algoritmo MD5 foi gradualmente substituído por algoritmos mais seguros, como SHA-256, SHA-3, etc.
Um arquivo vazio possui um valor MD5 diferente de um arquivo não vazio. O algoritmo MD5 é um algoritmo que pega o conteúdo do arquivo como entrada e gera um valor hash de 128 bits como saída. Portanto, diferentes fatores, como tamanho do arquivo, tipo de arquivo e nome do arquivo, afetarão o resultado do cálculo do valor MD5.
No entanto, para vários arquivos vazios, seus valores MD5 são iguais. Isso ocorre porque o conteúdo dos arquivos vazios é todo igual, sem um único byte. Portanto, os resultados do cálculo MD5 também são os mesmos.
escreva o resultado em um arquivo
O resultado é muito longo para ser lido de uma vez, então você pode salvá-lo em um arquivo de texto e lê-lo mais tarde.
O método de salvamento é usar "$output" para salvar.
$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
$folderspath = "C:\222", "D:\111"
$files = Get-ChildItem -Path $folderspath -Recurse | Group-Object -Property Length,Name | Where-Object { $_.Count -gt 1 }
foreach ($file in $files) {
$output = "Duplicate file name: $($file.Name)`r`n"
foreach ($item in $file.Group) {
$output += "`tPath+File Name: $($item.FullName)`r`n"
}
$output += ('-'*80) + "`r`n"
$output | Out-File -FilePath .\11.txt -Append -Encoding UTF8
}
O resultado da saída é salvo em .\11.txt, o conteúdo do arquivo:
Nome de arquivo duplicado: 12175, 1.docx
Caminho+Nome do arquivo: C:\222\1.docx
Caminho+Nome do arquivo: D:\111\1.docx
--------------- -------------------------------------------------- ---------------Nome de arquivo duplicado: 0, 1.pptx
Caminho+Nome do arquivo: C:\222\1.pptx
Caminho+Nome do arquivo: D:\111\1.pptx
Caminho+Nome do arquivo: D:\111\Nova pasta\1 . pptx
------------------------------------------------ - -------------------------------
Primeiro crie a variável $output e, em seguida, envie $output para o arquivo.
Explicação do código (não é importante, é recomendado pular)
A explicação do código relevante fornecida pela GPT:
Ok, aqui está o que cada parâmetro significa:
```powershell
$files = Get-ChildItem -Path "C:\sua\pasta" -Recurse | Where-Object { !$_.PSIsContainer }
```- `Get-ChildItem`: Obtenha uma lista de arquivos e subdiretórios no diretório especificado.
- `-Path "C:\your\folder"`: Especifique o caminho da pasta a ser pesquisada. Pode ser substituído entre aspas pelo caminho completo da pasta que deseja pesquisar.
- `-Recurse`: Retorna recursivamente todos os arquivos e pastas na hierarquia de pastas.
- `Where-Object { !$_.PSIsContainer }`: Use condições para filtrar objetos que não são pastas. Você pode pensar nisso como um filtro que retorna apenas itens que não são pastas.```powershell
$md5s = $arquivos | ForEach-Object {Get-FileHash $_.FullName | Select-Object -ExpandProperty Hash }
```- `$files`: Uma lista de todos os objetos de arquivo previamente filtrados da pasta.
- `ForEach-Object`: Para cada elemento da lista `$files`, execute operações subsequentes.
- `Get-FileHash`: Calcula o valor hash do arquivo especificado. Aqui, usamos o algoritmo hash MD5 para calcular o valor hash de cada arquivo.
- `Select-Object`: Selecione propriedades ou outros dados de um objeto passado pelo pipeline. Aqui, precisamos apenas do valor hash.
- `-ExpandProperty Hash`: Expanda o atributo de valor hash, que é conveniente para agrupamento subsequente.```powershell
$arquivos | Grupo-Objeto -Propriedade @{Expressão={$md5s[$files.IndexOf($_)]} } | Onde-Objeto { $_.Count -gt 1 }
```- `$files`: Uma lista de todos os objetos de arquivo previamente filtrados da pasta.
- `Group-Object`: Agrupa objetos de entrada por valores de propriedade especificados.
- `-Property @{ Expression={$md5s[$files.IndexOf($_)]} }`: Especifica o nome da propriedade a ser usada para agrupamento. A expressão `@{ Expression={$md5s[$files.IndexOf($_)]} }` realizará um cálculo de índice em cada elemento da lista `$files` para obter seu valor de hash.
- `Where-Object { $_.Count -gt 1 }`: Filtre grupos de arquivos duplicados. Apenas serão mantidos grupos com número de elementos superior a 1.```powershell
foreach ($grupo em $grupos) { $group.Group | Select-Object FullName, Comprimento, CreationTime | Nome completo do objeto de classificação | Formato-Tabela -AutoSize } ```- `foreach`: Para cada elemento da lista `$groups`, execute operações subsequentes.
- `$group`: o objeto de agrupamento na iteração do loop atual.
- `$group.Group`: lista de arquivos duplicados no objeto de grupo para a iteração do loop atual.
- `Select-Object FullName, Length, CreationTime`: Selecione as propriedades do arquivo para enviar para o console. Aqui escolhemos o caminho completo, tamanho e hora de criação do arquivo de saída.
- `Sort-Object FullName`: Classifique a saída em ordem alfabética por nome de arquivo.
- `Format-Table -AutoSize`: Formate os resultados de saída e ajuste automaticamente a largura da coluna para um tamanho adequado.`Where-Object { !$_.PSIsContainer }` é um filtro após o símbolo de barra vertical `|` no PowerShell, que é usado para filtrar itens que não são diretórios (pastas) dos resultados de saída.
Aqui, o comando `Get-ChildItem -Path "D:\111" -Recurse` é usado para obter todos os itens filhos no caminho especificado, incluindo arquivos e pastas. Utilize o filtro `Where-Object` para filtrar subitens, onde `$_.PSIsContainer` é uma propriedade booleana, se for `$true` significa que o item é um diretório, caso contrário é um arquivo. Portanto, a expressão `!$_.PSIsContainer` significa que o item que é `$true` após a negação é um item que não é de diretório (arquivo), ou seja, apenas o subitem do tipo de arquivo é reservado.
O objetivo disso é fazer com que a variável `$files` contenha apenas as informações do arquivo no diretório especificado, o que é conveniente para cálculo posterior de valores MD5 e agrupamento por valor.
Espero que isso lhe dê uma melhor compreensão do código!
Reportar erro
Para comandos de execução do PowerShell, erros comuns e manuseio, consulte:
Resumir
O método de inserção direta de instruções no terminal Powershell é adequado para instruções de uma linha e a operação é relativamente simples. Os métodos de gravação e execução de arquivos .ps1 podem atingir efeitos complexos, mas os códigos dos dois têm o mesmo significado. O significado de cada código é o seguinte:
Get-ChildItem -Path $folderspath -Recurse: Obtenha os arquivos no caminho $folderspath, o parâmetro -Recurse é usado para retornar recursivamente todos os arquivos e pastas na hierarquia de pastas.
Where-Object { !$_.PSIsContainer }: Filtre itens que não são pastas. Se houver esta etapa, é para encontrar arquivos duplicados, se não houver tal etapa, ele encontrará arquivos e pastas duplicados.
Grupo-Objeto -Nome da propriedade: Agrupe os arquivos obtidos de acordo com "Nome", e o padrão de agrupamento "Nome" pode ser substituído por outros, como agrupamento de acordo com nome, comprimento e extensão pode ser definido como "Comprimento, Nome, Extensão". Verifique o peso é melhor.
Where-Object {$_.Count -gt 1}: Filtre grupos de arquivos duplicados. "$_.Count -gt 1" significa que serão mantidos apenas grupos cujo número de elementos seja maior que 1. "gt" significa "maior que". Se quiser repetir o grupo com número de arquivos maior que 2, configure-o para "$_.Count -gt 2".
foreach ($file in $files) { : Para cada elemento da lista `$files`, execute operações subsequentes.
$output | Out-File -FilePath .\11.txt -Append -Encoding UTF8 : Arquivo de saída Out-File, gera a variável construída anteriormente "$output", o caminho do arquivo de " -FilePath .\11.txt " é . \11.txt, o método de salvamento é "-Append" e o formato do texto é "-Encoding UTF8".