Como fazer o oposto de shift no zsh?

shift -premoverá o último elemento da matriz, conforme man zshbuiltins:

shift [ -p ] [ n ] [ name ... ]

Os parâmetros posicionais ${n+1} ... são renomeados para $1 ..., onde n é uma expressão aritmética cujo padrão é 1. Se algum nome for fornecido, as matrizes com esses nomes serão deslocadas em vez dos parâmetros posicionais.

Se a opção -p for fornecida, os argumentos serão removidos (removidos) do final em vez do início do array.

Sua função desejada initpode ser:

function init {
    shift -p
    print -r -- "$@"
}

Como @Gairfowl disse nos comentários, em zsh, você faria:

argv[-1]=()

Para remover o último argumento (substituí-lo por uma lista vazia).

Até

argv[1]=()

Ou ainda:

1=()

Às vezes pode ser preferível a shift(abreviação de shift 1, abreviação de shift 1 argv, sendo este último específico do zsh), pois não reclama se $argvnão tiver elemento.

Observe que seu:

function tail() {
    shift 1
    echo $@
}

Deveria ser escrito:

tail() {
  (( $# == 0 )) || shift
  echo -E - "$@"
}

Ou compatível com Korn:

function tail {
  (( $# == 0 )) || shift
  print -r - "$@"
}

Se o objetivo é imprimir os argumentos restantes, separados por espaços e seguidos por uma nova linha.

Sem as aspas, argumentos vazios seriam ignorados; sem -, isso não funcionaria corretamente se o primeiro argumento começasse com -; sem -E/ -r, não funcionaria corretamente para argumentos contendo barras invertidas.

Para o seu init:

init() {
  argv[-1]=()
  print -r -- "$@"
}

Embora você também possa fazer¹:

init() print -r -- "$@[1,-2]"

O Zsh também adicionou recentemente a ${array:offset:length}forma alternativa de fatiamento de array para compatibilidade com o ksh93, então uma variante compatível com o ksh93 poderia ser:

function init {
  print -r -- "${@:1:${#}-1}"
}

Observe a chave ao redor de #which, sem which no zsh (e unless na emulação sh ou ksh), $#-1seria considerado como ${#-}1o comprimento do $-parâmetro (usando o operador no estilo csh $#param) seguido por 1. ${@:1:$# - 1}Também funcionaria.

zshtambém suporta ${var:offset:-length}à la bash, então você também pode usar print -r -- "${@:1:-1}".

Cuidado, pois eles relatam um erro se a lista de argumentos estiver vazia, o mesmo que no ksh93 ou bash.

${@:1:#-1}também funciona em versões atuais de zsh, assim como echo $(( # ))gera o mesmo que echo $(( $# )), mas eu evitaria isso, pois não está documentado e #é usado em vários operadores em expressões aritméticas. Em particular $(( #var )), , expande para o valor do caractere do primeiro caractere em $var(semelhante a $(( '$var' ))em ksh), então alguém pode argumentar que $(( #- ))deve expandir para o valor do caractere do primeiro caractere em $-.

unset 'array[i]'funciona no zsh para compatibilidade com o ksh, mas no ksh, os arrays não são arrays reais, mas mais como arrays associativos com chaves limitadas a números inteiros positivos, enquanto no zsh eles são arrays normais como em todos os outros shells não semelhantes ao Korn, então emular o comportamento do ksh nãounset 'array[i]' desfaz a definição do elemento (o que não faria sentido para arrays normais), mas o define como uma string vazia, mesmo que esse seja o último elemento no array.

Em zsh:

$ a=({1..5})
$ unset 'a[3]' 'a[-1]'
$ print -r - $a[4]
4
$ typeset -p a
typeset -a a=( 1 2 '' 4 '' )

$a[4]ainda assim 4, os elementos não definidos foram substituídos pela string vazia.

Comparando com ksh93 ou bash com seu design de array peculiar:

$ a=({0..5})
$ unset 'a[3]' 'a[-1]'
$ print -r - "${a[4]}"
4
$ typeset -p a
typeset -a a=([0]=0 [1]=1 [2]=2 [4]=4)

Isso (e o fato de que os índices de array começam em 0 em vez de 1) é uma das razões pelas quais no ksh e seus clones (como o bash), os parâmetros posicionais não podem ser mapeados para um array (como a maioria dos outros shells, como csh, fish, rc, zsh fazem), e eu suspeito que o fato de que não é possível unset 'argv[i]'no zsh, exceto para o último elemento (embora ele ainda não o desfaça , mas substitua pela string vazia) pode ter algo a ver com a compatibilidade do ksh.

array[first,last]=(new values)

(se ,lastfor omitido, é o mesmo que array[first,first]) é em si uma atribuição de fatia de array, semelhante ao que você pode conseguir perlcom sua splicefunção , por exemplo, não se limita a desconfigurar o último elemento (como perl's pop), você também pode fazer:

• array[1,0]=(new elements)para inserir elementos na frente (como perl's unshift)
• array[3,5]=()para remover elementos do meio.
• array+=(more)ou array[3]+=(more)para inserir elementos no final ou depois de um determinado índice.

O que falta em comparação aos equivalentes do Perl é a capacidade de recuperar os elementos que são removidos ao mesmo tempo em que são removidos.

Por exemplo, perlpara @last2 = splice @array, -2inserir os dois últimos elementos, @last2é preciso escrever: last2=( "${(A@)array[-2,-1]}" ); array[-2,-1]=()(que pode ser abreviado para last2=( $array[-2,-1] ); array[-2,-1]=()se não houver nenhum elemento vazio que precise ser preservado).

Mas estou divagando...

^{¹ Beware "$@[-2,-1]"expande para uma lista de um elemento vazio em vez de uma lista vazia. Isso não faz diferença para print -r --quem imprime uma linha vazia em ambos os casos, mas no caso geral, isso pode ser indesejável e seria contornado usando "${(A)@[-2,-1]}". Se não houver nenhum elemento vazio que precise ser preservado, $@[-2,-1](sem as aspas) é o suficiente.}