Questão Script mostrando o tipo de arquivo?


Eu quero fazer um script que mostre que tipo de arquivo é

por exemplo :

./file.sh haha test lala ssss

haha --> file

test --> directory

lala --> symbolic link

ssss --> executable

Eu estou tentando fazer assim, mas eu não consigo o mesmo resultado ...

#!/bin/bash

function check_symboliclink
{
echo "Write symbolic link"
read something
find $something -type l 
echo "$something  symbolic link";
}

check_symboliclink

Existe alguém que tenha uma ideia melhor para fazer como o exemplo?


1
2018-01-09 09:24


origem




Respostas:


Você pode simplesmente usar file comando.

Exemplo:

c0rp@c0rp: file file_1 file_2 file_3
file_1 ASCII text
file_2 ASCII text
file_3: symbolic link to file_2

ATUALIZAR

Se você não pode usar file comando aqui é outra solução.

#!/bin/bash
for var in "$@"
do
    if [ -d $var ]; then
        echo $var " - > is a directory"
    fi

    if [ -f $var ]; then
        echo $var " - > is a file"
    fi

    if [ -h $var ]; then
        echo $var " - > is a symbolic link"
    fi

    if [ -x $var ]; then
        echo $var " - > executable"
    fi
done

Neste script eu uso for var in "$@", Onde "$@" significa todos os argumentos passados. Então usando for você pode percorrer todos os argumentos passados

Você pode adicionar outra verificação se quiser ler esta.

por exemplo, se você quiser adicionar cheque file is a socket:

basta adicionar mesmo se bloquear antes done palavra:

            if [ -S $var ]; then
                    echo $var " - > is a Socket"
            fi

Eu mudo apenas condição [ -S $var ]


2
2018-01-09 09:30



Existe uma maneira única de obtê-lo sem usar o arquivo de comando? - user233233
Você só quer mostrar isso 4 pontos? (arquivo, diretório, executável, link) - c0rp
sim, sem usar o arquivo de comando - user233233
Eu atualizo a resposta. Mas o que significa dizer "sem usar a linha de comando"? - c0rp
Por favor note que -x não é um teste ideal para determinar se um arquivo é executável. Os diretórios também podem ter o bit executável definido. [ -x /etc/ ] && echo "YES"imprimirá "SIM", mesmo que tecnicamente não seja um "arquivo executável". Seria melhor aninhar as instruções if, de modo que um bastão verifique se os arquivos regulares também são executáveis - Sergiy Kolodyazhnyy


Mostrando tipos de arquivos Unix

A forma como esta questão é apresentada aparece quando o usuário está tentando exibir o tipo de um arquivo em Arquivo do tipo Unix sentido. Para tal, não é necessário um script, pois já existem utilitários capazes de exibir tais informações.

Em particular, stat comando é bem adequado para tal propósito. Por padrão, stat mostra longa saída com muita informação, mas podemos usar -c, --formatou --printf (note que ele interpreta símbolos de escape de barra invertida) opções para obter o resultado desejado. Por exemplo,

$ stat -c '%n: %F' /etc/passwd /etc/resolv.conf /etc                        
/etc/passwd: regular file
/etc/resolv.conf: symbolic link
/etc: directory


$ stat --printf '%n: %F\n' /etc/passwd /etc/resolv.conf /etc                
/etc/passwd: regular file
/etc/resolv.conf: symbolic link
/etc: directory

Outro comando que podemos usar é find, que tem -printf opção, mas difere em especificadores de conversão (o %<letter> símbolos) eo fato de que ele produz o tipo de arquivo em letras man find para correspondência de tipo de arquivo a letra):

$ find /etc/passwd /etc/resolv.conf /etc -prune  -printf "%p:%y\n"          
/etc/passwd:f
/etc/resolv.conf:l
/etc:d

Claro, se houver necessidade, podemos sempre fazer uso de [ ou test comando, mas isso vai exigir um pouco mais de trabalho; no entanto, dessa forma, não precisamos confiar em nada externo; É um modo portátil, embora provavelmente não seja o ideal.

#!/bin/sh

check_filetype(){
    if [ -f "$1" ];then
        if [ -h "$1" ]; then
            printf "%s\n" "$1: symbolic link"
        else
            printf "%s\n" "$1: regular"
        fi
    elif [ -d "$1"  ]; then
        printf "%s\n" "$1: directory"
    elif [ -c "$1" ]; then
        printf "%s\n" "$1: character device"
    elif [ -p "$1" ]; then
        printf "%s\n" "$1: named pipe"
    elif [ -S "$1" ]; then
        printf "%s\n" "$1: socket"
    fi
}

for arg
do
    check_filetype "$arg"
done

E é assim que funcionaria:

$ ./checkft.sh /etc/passwd /etc/resolv.conf /etc test.fifo /dev/tty1              
/etc/passwd: regular
/etc/resolv.conf: symbolic link
/etc: directory
test.fifo: named pipe
/dev/tty1: character device

Mostrando o conteúdo do arquivo

Se quisermos obter informações detalhadas sobre o tipo de arquivo no que diz respeito ao conteúdo, há duas maneiras de abordar as coisas. Um, via mime-type e o outro - via número mágico, os primeiros bits de um arquivo. Embora o tipo MIME tenha existido originalmente para determinar o tipo de arquivo na Internet, atualmente muitos aplicativos de desktop dependem da consulta de informações do tipo MIME para exibir corretamente ícones de arquivos e abri-los com aplicativos apropriados.

Para esse efeito, existe mimetype comando:

$ mimetype /etc/ /etc/resolv.conf  /etc/passwd test.fifo                          
/etc/:            inode/directory
/etc/resolv.conf: inode/symlink
/etc/passwd:      text/plain
test.fifo:        inode/fifo

E para realizar testes com "números mágicos" nós usaríamos file comando:

$ file /etc/ /etc/resolv.conf  /etc/passwd test.fifo                              
/etc/:            directory
/etc/resolv.conf: symbolic link to ../run/resolvconf/resolv.conf
/etc/passwd:      ASCII text
test.fifo:        fifo (named pipe)

que também pode fazer mimetypetrabalho:

$ file --mime-type /etc/ /etc/resolv.conf  /etc/passwd test.fifo                  
/etc/:            inode/directory
/etc/resolv.conf: inode/symlink
/etc/passwd:      text/plain
test.fifo:        inode/fifo

0
2017-11-10 18:14