Výpis stejných souborů (Perl vs Ruby)

2.12.2021 01:06 | Přečteno: 1467× | Linux

Následující skript najde ve složce stejné soubory a vypíše je. Skript využívá haš polí, jehož klíče jsou velikosti souborů, takže je nevhodný na několikabajtové soubory. Šlo mi hlavně o srovnání Perlu a Ruby.

use strict;
use Cwd;
use File::Spec::Functions;

my %files = ();
my $dir = $ARGV[0] || getcwd();

opendir(DIRHANDLE, $dir);

for (readdir(DIRHANDLE)) {
    my $path = catfile($dir, $_);
    if (-f $path) {
        push( @{ $files{-s $path} } , $_); 
    }
}

delete_singels(\%files);
print_dup(\%files);

sub delete_singels {
    my $href = shift;
    
    for (keys %$href) {    
        if (scalar @{ $href->{$_} } == 1) {
            delete $href->{$_};
        }
    }    
}

sub print_dup {
    my $href = shift;
    
    for (keys %$href) {
        print "Found " . scalar @{ $href->{$_} } . 
              " files with size $_ bytes:\n";
        print join("\n", @{ $href->{$_} } ) . "\n\n";
    }    
    
}

Skript můžeme spustit takto:

perl dup.pl Books/Perl

Představme si, že ve složce Perl je mnoho pdf souborů a některé jsou stejné. Skript by mohl vypsat třeba toto:

Found 2 files with size 9673854 bytes:
OReilly.Perl.Cookbook.pdf
Cookbook.pdf

Found 3 files with size 2035408 bytes:
Higher.Order.Perl.pdf
Higher_Order_Perl.pdf
HigherOrderPerl.pdf

Ten samý skript v Ruby:

class Dup
  def initialize
    @files = Hash.new {|h,k| h[k] = [] }
    @dir = ARGV[0] || __dir__
  end
  
  def read_files
    Dir.entries(@dir).each do |name|
      path = File.join(@dir, name)
      if File.file? path       
        @files[File.size(path)] << name
      end      
    end
    delete_singles
  end 
 
  def print
    @files.each do |k,v|      
      puts "Found #{v.length} files" +
           " with size #{k} bytes:"
      puts v
      puts      
    end
  end
  
  private
  
  def delete_singles
    @files.delete_if {|k,v| v.length == 1 }
  end    
end

d = Dup.new
d.read_files
d.print

a opět:

ruby dup.rb Books/Perl

Myslím, že Ruby je na tenhle typ skriptování docela efektivní jazyk.

Mimochodem, teď už chápu popularitu Pythonu. Protože kdybych uměl jen Perl a někdo mi ukázal Python, Python bych si asi rychle oblíbil. Tím nechci říct, že je Perl špatný jazyk, podle mě je to velmi zajímavý jazyk, ale určitě není KISS.        

Komentáře

[Miriam]

Perl je hlavně mrtvý jazyk. Zdar Max

[sad]

Ruby už má zřejmě to nejlepší také za sebou...

[ja osobne]

Teraz letí jedine JavaScript a RUST !!!

[tttt]

require 'pathname'

@dir = ARGV[0] || __dir__

Pathname.new(@dir).children.select(&:file?)
  .group_by { |path| File.size(path) }
  .tap { |h| h.delete(1) }
  .each do |k, v|
  puts "Found #{v.length} files with size #{k} bytes:"
  puts v
  puts
end

[tttt]

7. řádek zahazuje malé soubory, koukám, že to má zahazovat unikátní. Mělo to tedy být:

.select { |_, v| v.length > 1 }

[sad]

Hezký a elegantní způsob. Dík.

[luky]

my %sizes; $, = "\n";
unshift @{$sizes{-s $_}}, $_ foreach grep -f $_, glob "* .*";
foreach (keys %sizes) {
        next unless $#{$sizes{$_}};
        print 'Found ' . ($#{$sizes{$_}} + 1) . " files with size $_ bytes:\n";
        print @{$sizes{$_}}, "\n";
}

[luky]

Vypis by sel na jeden radek pres grep taky, ale uz je to pak necitelne.

[debian+]

<?php

// nacita zoznam suborov
$list=scandir(".");

// zisti velkosti
$statistic=array();
foreach($list as $name)
	if(is_file($name))
	{
		$size=filesize($name);
		if(isset($statistic[$size]))
			array_push($statistic[$size], "$name");
		else
			$statistic[$size]=array("$name");
	}

// vypise
foreach($statistic as $size => $items)
{
	$count=count($items);
	if($count < 2)
		continue;
	echo "Size: ${size} B, count: $count\n";
	echo implode("\n", $items)."\n";
}

[Odin1918]

K cemu je seskupeni souboru podle velikosti? Jiste, pravdepodobnost duplicity nejaka je, ale nebylo by lepsi vypocitat alespon md5ku a s tou operovat?

[Tomáš]

A nechtěl by ses kromě velikosti podívat i na obsah souboru? To, že jsou soubory stejně dlouhé, většinou neznamená, že musejí být stejné.

Většinou se počítá nějaký hash nebo checksum a pak se porovnávají mezi sebou.

[sad]

require 'digest/md5'

digest = Digest::MD5.hexdigest(File.read(f))

[Heron]

Viz poznámka níže. Nepoužívejte md5. Jsou k disposici různé soubory se stejnou md5 hash. Úprava pro SHA512 je triviální.

[Gréta]

supr skripty :D ;D

teda já jako perlu a ruby vubec nerozumim ale vidim žeto neni koronarýma tak jakoby lajkuju :D :D ;D ;D

[kvr]

perl -e 'use File::Slurp; $x{$_}++ foreach (map({ -s $_ } read_dir("."))); while (my ($s, $c) = each(%x)) { print("size=$s count=$c\n") if ($c > 1); }'

[kvr]

A "nepopulární" Java:

Arrays.stream(new File(".").listFiles()) .map(file -> file.length()) .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())) .forEach((s, c) -> if (c > 1) System.out.printf("size=%s count=%c\n", s, c));

Kratší než oba původní příklady (i když ty by šly taky zkrátit, viz výše) a přesto IMHO čitelnější. Ta čitelnost se pak objeví v případě větší komplexity, teď je to přece jen dost primitivní podle jednoho klíče.

[srbt]

Zdá se mi, že to sem ještě nikdo nenapsal v tom zmiňovaném pythonu, tak jsem si dovolil...

#!/usr/bin/env python3

from pathlib import Path
from itertools import groupby

files = sorted((file.stat().st_size, file) for file in Path('.').iterdir() if file.is_file())

groups = (same_files for size, group in groupby(files, lambda x: x[0]) if len(same_files := list(group)) > 1)

for group in groups:
    print('Found {count} files with size {size} bytes:\n{files}\n'.format(
        count=len(group),
        size=group[0][0],
        files='\n'.join(file[1].name for file in group)
    ))

Omlouvám se za použití operátoru :=.

[srbt]

No a ještě v bashi a gnu tools:

#!/usr/bin/env bash

files="$(find . -type f -printf '%s %f\n' | sort -n)"
sizes="$(cut -f 1 -d ' ' <<< "$files" | uniq --repeated)"

for size in $sizes; do
  count="$(grep -c "^$size " <<< "$files")"
  names="$(grep "^$size " <<< "$files" | cut -f 2 -d ' ')"
  printf 'Found %s files with size %s bytes:\n%s\n\n' "$count" "$size" "$names"
done

[Gilhad]

Pro hledani duplicitnich souboru (teda nejen stejne dlouhych) pouzivam neco jako

find -type f -exec md5sum {} \; | sort |uniq --all-repeated=separate -w32

(teda normalne ty md5sum mam nekde ulozene a pracuju s nima opakovane, takze to jsou bezne prikazy 2, jeden vytvori seznam hashu souboru, druhy hleda duplicity)

[Heron]

Nepoužívej md5. Je prolomená, je slabá, jsou k disposici různé souboru se stejným md5 hashem. Uprav si ten skript pro sha512sum. Jsou to dvě změny.

[Want]

A proč zdlouhavě počítat kontrolní součet? Není jednodušší o souborů o shodné délce nejprve binárně porovnat začátek a konec, a teprve po této shodě ověřit kontrolní součet, případně použít metodu, která by vykázala procentuální shodu obsahu?

[Heron]

Optimalizacím se věnuje komentář od Ploštěnky. Mým cílem bylo upozornit na již dávno překonanou funkci md5.

Navíc Gilhad píše, že si ty hashe ještě někam ukládá, takže jeho cílem nejspíše není jen hledat stejné soubory (to by nám musel sdělit on). Proto rychlá úprava jeho skriptu na sha512sum je více než dostatečná.

Já si například pravidelně ukládám shasumy všech souborů na datovém úložišti nikoliv pro hledání duplicit, ale proto, abych věděl, jestli se ty soubory mění nebo ne. V minulosti se mi stávalo, že video, které šlo bez problémů přehrát najednou nešlo. Nevím, jestli se ten soubor poškodil na disku a nebo jsem jen začal používat jiný přehrávač, který nebyl tolerantní k chybám. Právě proto jsem začal dělat checksumy, abych tohle případně zjistil. Pravděpodobnější ovšem je, že ten soubor byl poškozen od počátku - tako jsem měl mp3, které winamp dokázal přehrát bez problémů, ale jiné přehrávače - po mém přechodu na linux - hlásily poškozený soubor. I dneska se stane, že je nějaký soubor vadný a proto důležitá videa nechám protáhnout přes ffmpeg, který to jednak detekuje a taky někdy umí opravit (pokud je to jen chyba v multiplexoru).

Navíc mám díky tomu i historii souborů na disku a jsem schopen dohledat existenci souboru, který jsem já blbec smazal, a teď bych jej potřeboval - sice mi to data nevrátí, ale alespoň vím, kdy k tomu došlo a to mi může pomoci při pátrání.

[Tomáš]

A není na tohle lepší nějaký verzovací systém? Ten ty checksumy dělá implicitně.

[marbu]

Na nějak omezenou množinu dat možná, ale tady Heron mluví "všech souborech na datovém úložišti", a v takovém případě bych řekl že spíš ne. Nechtěl bych verzovat něco jako celý /home ...

[marbu]

Já si například pravidelně ukládám shasumy všech souborů na datovém úložišti nikoliv pro hledání duplicit, ale proto, abych věděl, jestli se ty soubory mění nebo ne.

Tohle dělám taky, akorát pouze při zálohování celého /home oddílu. Udělám snapshot kvůli konzistenci, v něm nechám spočítat checksum všeho a pak spustím zálohu. Ten checksum soubor mám pak jak lokálně tak u té zálohy, takže v případě poškozeného binárního souboru co se normálně moc nemění jsem schopen rychle dohledat v které záloze mám předchozí verzi. Ale dělám to primárně kvůli kontrole konzistence zálohy a obnovených dat.

[Gilhad]

Cílem je 1) hledání duplicitních souborů 2) ověřování zda se soubor nezměnil

Úprava na jiný součet je poněkud nepraktická, protože to je součástí systému, který jsem napsal kdysí, asi tak mezi 2000 a 2002, pro mou tehdejší 486 za účelem ukládání na CDčka a zase vytahování z nich, a v té době jsem tam narval podstatnou část souborů.

Problém je, že některá CD se časem stávala méně a méně čitelná, cena CD/DVD klesala a soubory jsem nejen přejmenovával (z různých kódování češtin, ale i z různých stylů popisu), ale i přesouval mezi adresáři a do toho se mi motaly starší verze (nepřejmenované) ale také verze novější, které přišly odjinud a jmenovaly se klidně jako verze starší, nebo naprosto jinak, protože si to někdo upravil podle svých konvencí.

A samozřejmě klasika zálohy záloh záloh ... a stále používané verze na disku spadající jak do tématických záloh podle smyslu, tak do záloh náhodných, např. celého počítače.

Takže v tom časem vzniknul pěkný bordel a bylo ho potřeba nějak rozmotat, nebo to na rozmotání aspoň připravit.

Takže náhoda, že by dva soubory byly různé, ale došlo ke kolizi MD5, ale jejich název a umístění dávalo podobný smysl bylo celkem malé. Navíc jsem měl (ale jinde) i uložené délky a nějaké poznámky o formátu, pokud se rozpoznal (hudba, fotky, filmy, ...) a nečekal jsem, že by na tohle někdo cíleně zaútočil, protože to nedávalo smysl. Na druhou stranu jsem měl po různých adresářích mraky souborů typu SAVEGAME.001 a README.TXT, které byly povětšinou různé a záleželo na jejich umístění v adresářové struktuře, ke které gamese to asi tak patří ...

Takže se mi to nechce předělávat, dokud to kompletně nezkonzoliduju na diskovém poli, duplicity (a balast) nevyházím a naopak nezjistím, co za léta došlo úhony, či ztráty. Což je projekt na léta, protože to má nízkou prioritu a jde o tisíce CD a stovky DVD ... Až budu jednou s výsledkem (relativné) spokojen, tak to předělám na optimalizaci pro disková pole a přegeneruju celý systém.

Ale teď se mi hodí držet kompatibilitu se starou verzí a nové věci mít zároveň v GITu (ostatně teď předělávám i poněkud živelně vzniklou strukturu repozitářů na něco systematičtějšího a vhodnějšího pro současný styl práce)

[Gréta]

když jakoby dělá jenom hledání duplicitních souborů někde  u sebe na disku tak vodolnost toho hashe neni zese jako moc důležitá ne?? :O :O

joa neni md5 taky trošičku rychlejší/lacinější než sha512????? :O ;D

[Heron]

No když si někdo píše program, tak je celkem vhodné je napsat tak, aby byl správný z hlediska aktuálního poznání. To, že existují soubory s různým obsahem a stejnou md5 hash se ví, já mám takové soubory na disku a takto napsaný program by to vyhodnotil špatně. Proto je vhodné použít takovou hash fci, u které kolize ještě známé nejsou. hash funkce je modulární a měla by jít snadno vyměnit. Pro kontinuitu dat, pokud je potřeba, je vhodné použít několik funkcí současně a ukládat všechny hashe.

joa neni md5 taky trošičku rychlejší/lacinější než sha512

Netuším a je to jedno, stejně se čeká na storage, spočítat to je rychlejší, než číst z disku. Pokud má dotyčný data v 1TB ramdisku, tak to nemusí platit, ale v tom případě zřejmě bude mít něco jako EPIC a tak si to snadno může paralelizovat.

Jinak pokud někomu vadí zrovna sha512, tak existují jiné, neprolomené a velmi rychlé funkce (třeba rodina sha3 - kde byla rychlost z jedním z požadavků soutěže).

[Gréta]

ok to zní rozumě :D ;D

[sad]

Ale nikde nevidím Rust. Zřejmě by v Rustu takový prográmek ani napsat nešel...

[plostenka]

Jako petiminutovka dobre, ale kde je nejaka optimalizace?

Pokud maji soubory unikatni velikost, nejsou stejne (netreba draze pocitat hash)
Pokud maji soubory unikatni prvni 1kB, nejsou stejne (netreba draze pocitat hash) ...

Ve vysledku pouzivam rdfind: find . -type f -size +100M -print0 | xargs -0 rdfind -ignoreempty true -checksum sha1 -makehardlinks true -outputname ./rdfind100M_results.txt -dryrun false > ./rdfind100_stdout.txt 2>&1