pmor's questions

O Bash tem uma opção para diagnosticar (e opcionalmente abortar a execução) variáveis ​​"expandidas para valor vazio"?

Exemplo (hipotético):

$ bash -c 'echo $x' --xxx
bash: line 1: variable 'x' expanded to empty value

Motivo da pergunta: essa opção pode ser útil ao depurar scripts.

Por exemplo, em alguns scripts, espera-se que todas as variáveis ​​se expandam para valores não vazios. Portanto, usar uma opção para detectar (e opcionalmente abortar a execução) variáveis ​​"expandidas para valores vazios" pode ser útil para esse caso.

Já procurei por essa opção no setbuiltin , mas não encontrei nada.

De man bash(GNU bash, versão 5.2.21(1)-release (x86_64-pc-cygwin)):

set [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [-] [arg ...]
  -a  Each variable or function that is created or modified is given the export
      attribute and marked for export to the environment of subsequent commands.

export [-fn] [name[=word]] ...
export -p
      The supplied names are marked for automatic export to the environment of
      subsequently executed commands.

Aqui vemos que isso exportnão "dá o atributo de exportação" enquanto set -ao faz. Por que? É um descuido?

Pergunta extra: qual a diferença entre “exportação” e “exportação automática”? (Ambos deveriam ser "exportação"? Ambos deveriam ser "exportação automática"?)

Como exibir todos os nomes de arquivos regulares existentes em um arquivo de texto?

Exemplo:

$ cat file.txt
zzz
xxx/yyy
234 546
"abc def"
--bbb

$ cat file.txt | <one-liner>
zzz
xxx/yyy

Nesta lista de file.txtarquivos regulares zzze xxx/yyyexistem (por exemplo). Portanto, as <one-liner>exibições zzze xxx/yyy.

O que seria uma implementação disso, de preferência como um one-liner?

Eu rapidamente tentei brincar com algo parecido xargs -I {} --max-lines=1 test -f "{}". No entanto, parece que não é o caminho certo.

Cenário:

$ process(){ echo "[$1] [$2] [$3]" ; } ; export -f process

$ process "x" "" "a.txt"
[x] [] [a.txt]

Aqui vemos que o segundo argumento é uma string vazia (esperado).

$ find -name "*.txt" -print | SHELL=$(type -p bash) parallel process "x" ""
[x] [./a.txt] []
[x] [./b.txt] []
[x] [./c.txt] []

Aqui vemos que o segundo argumento é a saída de find (inesperado).

Resultado esperado:

[x] [] [./a.txt]
[x] [] [./b.txt]
[x] [] [./c.txt]

Como consertar?

Nota: se o segundo argumento for alterado de ""para "y", então a saída de find estará presente como o terceiro argumento (esperado):

$ find -name "*.txt" -print | SHELL=$(type -p bash) parallel process "x" "y"
[x] [y] [./a.txt]
[x] [y] [./b.txt]
[x] [y] [./c.txt]

Por que a saída de find não está presente como terceiro argumento com ""?

UPD: Parece que a solução é \"\":

$ find -name "*.txt" -print | SHELL=$(type -p bash) parallel process "x" \"\"
[x] [] [./a.txt]
[x] [] [./b.txt]
[x] [] [./c.txt]

No entanto, não tenho certeza se esta é a solução geral correta. Aqui está o contra-exemplo:

$ VAR="" ; find -name "*.txt" -print | SHELL=$(type -p bash) parallel process "x" "$VAR"
[x] [./a.txt] []
[x] [./b.txt] []
[x] [./c.txt] []

Cenário:

$ cat libs.txt
lib.a
lib1.a

$ cat t1a.sh
f1()
{
        local lib=$1
        stdbuf -o0 printf "job for $lib started\n"
        sleep 2
        stdbuf -o0 printf "job for $lib done\n"
}
export -f f1
/usr/bin/time -f "elapsed time %e" cat libs.txt | SHELL=$(type -p bash) parallel --line-buffer --jobs 2 f1

$ bash t1a.sh
elapsed time 0.00
job for lib.a started
job for lib1.a started
job for lib.a done
job for lib1.a done

Aqui vemos que elapsed time 0.00aparece antes da saída do comando. Por que?

Como fazer elapsed time 0.00aparecer após a saída do comando?

Cenário:

$ cat libs.txt
lib.a
lib1.a

$ cat t1a.sh
f1()
{
        local lib=$1
        stdbuf -o0 printf "job for $lib started\n"
        sleep 2
        stdbuf -o0 printf "job for $lib done\n"
}
export -f f1
cat libs.txt | SHELL=$(type -p bash) parallel --jobs 2 f1

Invocação e saída:

$ time bash t1a.sh
job for lib.a started
job for lib.a done
job for lib1.a started
job for lib1.a done

real    0m2.129s
user    0m0.117s
sys     0m0.033s

Aqui vemos que a execução de f1foi de fato em paralelo ( real 0m2.129s).

No entanto, a saída de diagnóstico parece que a execução foi sequencial.

Eu esperava a seguinte saída de diagnóstico:

job for lib.a started
job for lib1.a started
job for lib.a done
job for lib1.a done

Por que a saída de diagnóstico parece uma execução sequencial em vez de uma execução paralela?

Como corrigir a saída de diagnóstico para que pareça uma execução paralela?

Cenário:

$ tree .
.
├── x1.txt
├── x2.txt
└── x3.txt

0 directories, 3 files

$ find . -name "x1.txt" -prune -o -name "*.txt"
./x1.txt
./x2.txt
./x3.txt

$ find . -name "x1.txt" -prune -o -name "*.txt" -print0
./x2.txt./x3.txt

Aqui vemos que isso -print0afeta os resultados da pesquisa. Confuso.

Por que a presença de -print0causa find ...não é impressa x1.txt?

Por que a ausência de -print0causa find ...para imprimir x1.txt?

De man bash:

-n string
    True if the length of string is non‐zero.

Exemplos:

# expected
$ var=""; [ -n "$var" ]; echo $?
1

# unexpected?
$ var=""; [ -n $var ]; echo $?
0

Aqui vemos que -ncom uma variável sem aspas contendo uma string vazia retorna verdadeiro. Por que?

Por que é $varnecessário ser citado aqui?

diff3 em arquivos não encontra diferença:

$ grep -P '\[\[.*?\]\]' -o intro.tex | sort > A.txt
$ grep -P '\[\[.*?\]\]' -o intro.tex | sort | uniq > B.txt
$ grep '\\pnum %% \[\[' intro.tex | sed 's/\\pnum %% //' | sort > C.txt
$ diff3 A.txt B.txt C.txt | wc -l
0

diff3 em substituições de processo executando os mesmos comandos encontra uma diferença:

$ diff3 \
  <(grep -P '\[\[.*?\]\]' -o intro.tex | sort) \
  <(grep -P '\[\[.*?\]\]' -o intro.tex | sort | uniq) \
  <(grep '\\pnum %% \[\[' intro.tex | sed 's/\\pnum %% //' | sort) | wc -l
95

Por que? Alguma ideia?

Um reprodutor mínimo:

$ echo test > a
$ diff3 a a a
$ diff3 <(cat a) <(cat a) <(cat a)
====1
1:1c
  test
2:0a
3:0a

Como agrupar um comando para medir seu tempo decorrido?

Atualmente eu faço isso usando eval:

do_cmd_named()
{
  local name=$1
  local cmd=$2

  echo "$name"
  local start_time=$(date +%s)
  eval "$cmd 2>&1"
  local exit_status=$?
  local end_time=$(date +%s)
  local elapsed_time_sec=$((end_time-start_time))
  local elapsed_time_min_sec=$(date -ud "@$elapsed_time_sec" +'%M:%S')
  if [[ $exit_status -ne 0 ]]
  then
    echo "$name failed with exit status $exit_status (elapsed time $elapsed_time_min_sec)"
    return $exit_status
  else
    echo "$name done (elapsed time $elapsed_time_min_sec)"
  fi
}

job()
{
    sleep 1
}

do_cmd_named "do job" "job"

o que leva a:

do job
do job done (elapsed time 00:01)

Para meus casos, essa abordagem quase funciona. No entanto, essa abordagem é considerada ruim porque viola algumas regras do BashFAQ . Por exemplo, "não coloque código dentro de variáveis" de BashFAQ #50 (consulte também BashFAQ #48 ).

Então, a pergunta é: como fazer isso corretamente?

Como obter a scpversão?

Já tentei:

$ scp --version
scp: unknown option -- -
usage: scp [-346ABCOpqRrsTv] [-c cipher] [-D sftp_server_path] [-F ssh_config]
           [-i identity_file] [-J destination] [-l limit]
           [-o ssh_option] [-P port] [-S program] source ... target

$ man scp | grep version
<nothing>

Isso significa que scpnão tem versão?

Cenário:

$ echo "Hello World" > /dev/stderr
Hello World

$ echo "Hello World" > /dev/stdout

$ uname -a
CYGWIN_NT-10.0 xxx 3.3.4(0.341/5/3) 2022-01-31 19:35 x86_64 Cygwin

Por que echo "Hello World" > /dev/stdoutnão imprime nada? Como solucionar problemas?

UPD.

Imprime echo "Hello World"normalmente?

Sim:

$ echo "Hello World"
Hello World

Se não, você invocou exec >/dev/nullou similar no shell talvez?

Não.

UPD2. Encontrado onde parou de funcionar:

$ clang t554.c -std=c11 -pedantic -Wall -Wextra -c -S -O3 -o /dev/stdout
        .text
        <asm code>

# "exxxtern" was a typo
$ clang t554.c -std=c11 -pedantic -Wall -Wextra -c -S -O3 -o /dev/stdout
t554.c:6:3: error: use of undeclared identifier 'exxxtern'
                exxxtern int xxx;
                ^
1 error generated.


TASKING+pavel.morozkin@SPBPC023 ~
$ clang t554.c -std=c11 -pedantic -Wall -Wextra -c -S -O3 -o /dev/stdout
# nothing is printed for the 1st time

UPD3. Eu posso reproduzi-lo com clang em outra máquina:

$ clang t455.c -S -o /dev/stdout
        .text
        <asm code>

# introduce the error

$ clang t455.c -S -o /dev/stdout
t455.c:26:1: error: unknown type name 'x'
x
^
t455.c:26:2: error: expected identifier or '('
x
 ^
2 errors generated.

# fix the error

$ clang t455.c -S -o /dev/stdout
# nothing is printed

$ clang --version
clang version 8.0.1 (tags/RELEASE_801/final)

Cenário:

$ cat t0.txt
xxx
yyy

$ man grep | grep '\-\-null\-data' -A1
       -z, --null-data
              Treat the input as a set of lines, each terminated by a zero byte (the ASCII NUL character) instead of a newline.

$ grep -Pzo 'xxx\0yyy' t0.txt
<nothing>

$ grep -Pzo 'xxx\nyyy' t0.txt
xxx
yyy

Portanto, se o grep "trata a entrada como um conjunto de linhas, cada uma terminada por um byte zero", por que 'xxx\0yyy'não produz resultados?

Cenário:

$ cat t0.txt
xxx

$ grep xxx t0.txt > t0.txt
grep: t0.txt: input file is also the output

# exit status 2

$ cat t0.txt
<nothing>

Pergunta: se o arquivo de entrada também for a saída E o status existente for 2(ocorreu um erro), por que limpar o arquivo de entrada?

Este caso:

$ cat t01.txt
xxxyyyzzz

$ cat t01.txt | grep -Po '(?<=xxx).*(?=zzz)'

resulta em:

yyy

que é esperado.

No entanto, este caso:

$ cat t02.txt
xxx
yyy
zzz

$ cat t02.txt | grep -Pzo '(?<=xxx).*(?=zzz)'

resulta em:

<nothing>

o que é inesperado.

Por que e como corrigir?

Exemplo:

$ eval echo "{x,y,z}\ --opt\; "
x --opt; y --opt; z --opt;

Suponha que a 2ª lista seja {1,2,3}e seu comprimento seja igual ao comprimento da 1ª (inicial) lista.

Perguntas:

1. Como fazer bashprodutos:

x --opt 1; y --opt 2; z --opt 3;

2. Como fazer bashprodutos (ou seja, para referir os elementos da {x,y,z}lista):

x --opt x; y --opt y; z --opt z;

One-liners são os preferidos.