Trie par ordre décroissant.

du -s ./* | sort -n| cut -f 2-| xargs du -sh {}

Basé en grande partie sur la logique de cette phrase J'ai écrit un script qui fournit une sortie du(1) triée et lisible par l'homme. En dehors du fait qu'il faille utiliser l'option -h pour des raisons de lisibilité, il ne nécessite aucune autre commande non compatible avec POSIX.

Il est disponible à l'adresse suivante https://github.com/pleappleappleap/sorted-human-du .

Encore un autre du script !

Comme il y a déjà beaucoup de réponses, je me contente d'y poster mon propre script. Je l'utilise depuis plus de huit ans maintenant.

Cela pourrait être géré par

/somepath/rdu.sh [-b] [/somepath] [minSize]

où

• drapeau facultatif -b dire à utiliser nombre d'octets au lieu de nombre de blocs
• en option chemin comme 1er argument, répertoire courant si par défaut.
• si aucun second argument n'est donné, la taille minimale à imprimer est la suivante 256Mb .

Le résultat pourrait ressembler à ceci :

\___   3.01G                 21.67%                .cache
|   \___   1.37G                 45.54%                mozilla
|   |   \___   1.37G                100.00%                firefox
|   |   |   \___ 581.71M                 41.48%                billiethek.default
|   |   |   |   \___ 522.64M                 89.85%                cache2
|   |   |   |   |   \___ 522.45M                 99.96%                entries
...

Il y a le script :

#!/bin/bash

if [ "$1" == "-b" ] ;then
    shift
    units=(b K M G T P)
    duargs="-xbs"
    minsize=${2:-$((256*1024**2))}
else
    units=(K M G T P)
    duargs="-xks"
    minsize=${2:-$((256*1024))}
fi

humansize() {
    local _c=$1 _i=0
    while [ ${#_c} -gt 3 ] ;do
        ((_i++))
        _c=$((_c>>10))
    done
    _c=$(( ( $1*1000 ) >> ( 10*_i ) ))
    printf ${2+-v} $2 "%.2f%s" ${_c:0:${#_c}-3}.${_c:${#_c}-3} ${units[_i]}
}
percent() {
    local p=000$((${1}00000/$2))
    printf ${3+-v} $3 "%.2f%%" ${p:0:${#p}-3}.${p:${#p}-3}
}

device=$(stat -c %d "${1:-.}")
printf -v sep "%16s" ""

rdu() {
    local _dir="$1" _spc="$2" _crt _siz _str _tot _pct
    while read _siz _crt;do
        if [ "$_crt" = "total"  ]; then
            _tot=$_siz
        else
            [ "$_tot" ] || _tot=$_siz
            if [ $_siz -gt $minsize ];then
                humansize $_siz _str
                percent $_siz $_tot _pct
                printf "%s\___ %7s%s%7s%s%s\n" \
                    "$_spc" $_str "$sep" $_pct "$sep" "${_crt##*/}"
                [ -d "$_crt" ] &&
                [ $(stat -c %d "$_crt") -eq $device ] &&
                rdu "$_crt" "|   $_spc"
            fi
        fi
    done < <(
        find "$_dir" -mindepth 1 -maxdepth 1 -xdev \
            \( -type f -o -type d \) -printf "%D;%p\n" |
            sed -ne "s/^${device};//p" |
            tr \\n \\0 |
            xargs -0 du ${duargs}c |
            sort -nr
    )
}

rdu "${1:-.}"

Vous pouvez montrer le script sur mon propre site o Téléchargez-les ici.

Au lieu de violer du et amis, vous pouvez utiliser ls seul pour faire ce que vous voulez :

ls -1Ssh

Cela imprimera tous les fichiers triés par taille sous une forme lisible par l'homme. La première ligne qu'il imprime est le total, si vous voulez vous en débarrasser vous pouvez simplement utiliser

ls -1Ssh | tail -n +2

Vous pouvez ajouter le -r pour ls si vous voulez que les fichiers soient dans l'ordre inverse (du plus petit au plus grand).