Ejemplos integrados de Bash

builtin candidato_builtin arg … en bash solo le permite llamar a bash incorporados. Es decir, incluso si existe un comando o función externa también llamado candidato_builtin (o algo más creativo), bash lo ignorará y solo intentará ejecutar el comando interno junto con sus argumentos.

Con incorporado, puede estar seguro de que está ejecutando un bash incorporado en lugar de algún comando o función externa que simplemente está flotando en su entorno esperando ser llamado por un programador de bash. Sin embargo, si alguien anula la función incorporada, es posible que desee desarmarla.

De manera similar a la forma en que le gustaría cambiar el comportamiento predeterminado de un comando externo como curl en bash, builtin le permite evitar el caso de que haya declarado una función con el mismo nombre que declare.

Además de permitirle ejecutar comandos integrados directamente, se puede usar para probar si un nombre es integrado.

builtin builtin

Builtin es un builtin. ¡Estupendo! ¿Qué tal esto?

builtin builtinf

Como habrás adivinado, la línea de comando incorporada anterior devuelve un estado de salida distinto de cero, sucedió algo malo.

bash: builtin: builtinf: not a shell builtin

De acuerdo, builtinf no es un builtin. Quizás en una versión futura de bash cuando tenga un incorporado llamado builtinf.

Si aún no está seguro de cómo usar el servicio integrado o desea ver cómo se ve la página de ayuda, esto es para usted.

Ayuda incorporada

Echar un vistazo a la página de ayuda para builtin es un buen lugar para comenzar si está interesado en aprender cómo funciona el builtin o necesita una revisión.

$ help builtin
builtin: builtin [shell-builtin [arg …]]
Execute shell builtins.
Execute SHELL-BUILTIN with arguments ARGs without performing command
lookup.  This is useful when you wish to reimplement a shell builtin
as a shell function, but need to execute the builtin within the function.
Exit Status:
Returns the exit status of SHELL-BUILTIN, or false if SHELL-BUILTIN is
not a shell builtin..

Debería tener un conocimiento básico de cómo se puede usar incorporado en un script bash a estas alturas. Veamos algunos ejemplos.

Ejemplos que usan builtin

Antes de comenzar con cualquier ejemplo, decidamos si necesitamos una lista de verificación rápida. Es decir, si alguna de las siguientes afirmaciones es cierta, es posible que necesite incorporarse.

  1. Ha definido una función con el mismo nombre que una función incorporada que aparece en la lista de funciones incorporadas de bash en un intento de extender el comportamiento incorporado predeterminado
  2. Desea llamar explícitamente a una función incorporada por su nombre para evitar llamar a una función con el mismo nombre involuntariamente
  3. Desea comprobar si un nombre es incorporado para evitar nombrar una función con el mismo nombre que un incorporado.

A continuación se muestran ejemplos que usan builtin para extender el comportamiento predeterminado de cualquier builtin.

Ejemplo integrado: 1 unalias para gobernarlos a todos (unalias)

En la parte inferior de las listas de elementos integrados de bash hay un elemento integrado llamado unalias, que es como no establecido para los alias. Suponga que desea que unalias ignore cualquier argumento y simplemente descarte cualquier alias en el entorno, gobierne todos. Resulta que Unalias tiene esa opción. Además, se volvería redundante si tuviera que escribirlo cada vez, así que analicemos todo en una función. Así es cómo.

Comandos

unalias() {
builtin ${FUNCNAME} -a
}

Prueba

alias flat=‘echo flat’
flat
unalias
flat

Producción

flat
bash: flat: command not found
Footnotes

Puede argumentar que podríamos salirse con la nuestra usando un alias en lugar de una función. Podría, pero el resultado sería una función única, es decir, unalias volvería a su comportamiento predeterminado después de una llamada.

Ejemplo integrado: 2 ecos con o sin color (eco)

En algún lugar cerca de la mitad de la lista de elementos integrados de bash, hay un elemento integrado llamado echo. Quizás hayas oído hablar de él. Tengo una corazonada que tienes. Sin embargo, es posible que no hayas oído hablar de cecho.sh , un script que escribí para hacer eco con el color. Sin preocupaciones. Vamos a hacer algo similar en este ejemplo usando builtin para llamar a echo.

Comandos

echo() { { local candidate_color candidate_color=${1} local line line=${@:2} }
echo-color() {
case ${candidate_color} in
blue) builtin echo 34
yellow) builtin echo 33
green) builtin echo 32
*) builtin echo 0
esac
}
builtin echo -n -e “e[$( ${FUNCNAME}-color )m${line}e[0m”
}

Prueba

echo yellow asdf  echo green asdf asdf  echo white asdf

Producción

asdfasdf asdfasdf
Footnotes

Basado en cecho.sh. Puede agregar otros colores en la función de color de eco. Puede modificar la última línea de eco incorporada para que se ajuste a su comportamiento predeterminado deseado o al esquema de manejo de opciones para el eco.

Ejemplo integrado: 3 solo un comando (comando)

El comando es incorporado. Como incorporado, nos permite controlar si se llama a una función, comando externo o incorporado en el caso de que más de uno comparta el mismo nombre. A diferencia de lo incorporado, el comando ejecuta comandos externos y elementos integrados, que es lo mismo que cualquier cosa que no sea una función. ¿Qué pasa si queremos eliminar los elementos integrados del comando? Ahí es donde entra en juego la función incorporada.

Tenga en cuenta que los comandos integrados tienen mayor prioridad que los comandos externos. Es decir, el intérprete comprobará si hay un comando incorporado antes de buscar un comando externo.

Consider the case of echo.

Es un comando interno y externo. Sin embargo, cuando corremos

command echo something

Se utilizará el eco incorporado. ¿Como sabemos?

Si ejecuta qué eco, verá algo como / usr / bin / echo. Además, / usr / bin / echo –help muestra una página de manual, donde el eco incorporado no lo hace. Entonces corremos

command echo –help
And get back
 
–help

Gracias por la ayuda echo. Al menos ahora sabemos que los archivos incorporados se ejecutan antes que los comandos externos.

Ahora veamos cómo podemos usar builtin para modificar el comando para ejecutar solo comandos externos por diversión.

Comandos

command() {
! which ${1} || { $( which ${_} ) ${@:2} return ${?} }
builtin ${@}
}

Prueba

command echo –help # now displays a man page

Aquí mostramos cómo modificar el comando incorporado para probar solo comandos externos. A continuación, intentemos divertirnos como hacer que sea difícil desarmar variables y funciones.

Ejemplo integrado: 4 deshabilitar desarmado (desarmado, integrado)

Para deshabilitar el desarmado necesitamos anular desarmado e incorporado usando una función. En este ejemplo, le mostraremos cómo.

Comandos

builtin() { echo fake builtin }
unset() { echo fake unset }

Ahora que tenemos la función que necesitamos para anular unset y builtin, es hora de probar que nuestra solución funciona. ¡Aquí vamos!

Test 0: behavior in most settings
{
foo=bar
echo ${foo} # bar
unset foo
echo ${foo} #
builtin unset foo
echo ${foo} #
}
 
Test 1: with unset disabled
 
{
builtin() { true }
unset() { true }
foo=bar
echo ${foo} # bar
unset foo
echo ${foo} # bar
builtin unset foo
echo ${foo} # bar
}

Tenga en cuenta que además de anular unset con una función, también necesitamos anular el incorporado para evitar que un comando omita nuestra función de unset.

Ejemplo de bash: 5 fuentes con ruta de inclusión (fuente)

Source es una función integrada de bash que le permite incluir otro archivo en su script y ejecutarlo con argumentos. ¿Qué sucede si queremos cambiar el directorio de origen a una ubicación que no sea nuestro directorio de trabajo? Se puede hacer. ¡Así es cómo!

Comandos

source() {
builtin source ${source_dir-.}/${1}.sh ${@:2}
}
 
Test
 
{
source() {
builtin source ${source_dir-.}/${1}.sh ${@:2}
}
source_dir=sources
test -d “sources” || mkdir -pv ${_}
echo “a() { echo a } a” &gt ${source_dir}/a.sh
echo “b() { echo b $( a ) } b” &gt ${source_dir}/b.sh
echo “c() { echo c $( b ) } c” &gt ${source_dir}/c.sh
source a
source b
source c
}

Producción

a
b a
c b a

Aquí mostramos que puede ejecutar su propio comando fuente. Te recomiendo que pongas algo así en tu plantilla si quieres una fuente personalizada para reducir las pulsaciones de teclas en tus scripts bash.

Ejemplo integrado 6: builtin -p para enumerar las funciones internas de bash

Oye, tal vez estés enfermo y cansado de tener que buscar elementos integrados de bash. Como sabe, otros comandos le permiten listar opciones usando la opción -p. Desafortunadamente, el sistema integrado todavía no ofrece esa opción.

Script
 
#!/bin/bash
## test-builtins
## version 0.0.1 – initial
##################################################
builtins() {
cat &lt&lt EOF
alias
bind
builtin
caller
command
declare
echo
enable
help
let
local
logout
mapfile
printf
read
readarray
source
type
typeset
ulimit
unalias
EOF

}
generate-disable-builtins-script() {
local builtin
test ! -f “script” || rm -v ${_} 1&gt/dev/null
for builtin in $( builtins )
do
echo ${builtin}() { true }” &gt&gt script
done
}
test-builtins() {
generate-disable-builtins-script
}
##################################################
if [ ${#} -eq 0 ]
then
true
else
exit 1 # wrong args
fi
##################################################
test-builtins
##################################################
## generated by create-stub2.sh v0.1.2
## on Wed, 28 Aug 2019 13:45:00 +0900
## see &lthttps://github.com/temptemp3/sh2&gt
##################################################

Fuente test-builtins.sh

Comandos

{
curl https://raw.githubusercontent.com/temptemp3/ba.sh/master/test-builtins.sh
 -O –silent
. test-builtins.sh
. script
rm ${_}
declare -p
}

Producción

# silence is golden

Aquí mostramos cómo puede deshabilitar todas las funciones incorporadas. Para la salida de nuestro comando incorporado -p propuesto, simplemente ejecute los archivos incorporados desde test-builtins.sh. La implementación completa se dejará al lector como un ejercicio.

Comandos

{
curl https://raw.githubusercontent.com/temptemp3/ba.sh/master/test-builtins.sh
 -O –silent
. test-builtins.sh
builtin() { test ! ${1}= “-p” || { builtins return } builtin{,} ${@} }
builtin -p
}

Producción

alias
bind
builtin
caller
command
declare
echo
enable
help
let
local
logout
mapfile
printf
read
readarray
source
type
typeset
ulimit
unalias

Ejemplo integrado: 7 deshabilitar la lista de alias

Supongamos que en un shell restringido en algún lugar del universo bash, la lista de alias está deshabilitada. A continuación, se explica cómo puede deshabilitar la lista de alias mediante funciones.

Comandos

alias ()
{
test ! ${1}= “-p” || {
true
return
}
builtin alias ${1}=${@:2}
}
 
Test
 
{
alias bash “echo bad bad bash”
alias -p bash
bash
}

Producción

bad bad bash

Ejemplo integrado: 8 usando habilitado

Como recordará, deshabilitamos las funciones incorporadas usando las funciones anteriores. Resulta que puede obtener el mismo trabajo usando el comando enable incorporado. Así es cómo.

Comandos

disable() {
builtins() { enable | cut ‘-d ‘ ‘-f2’ }
local builtin
for builtin in $( builtins )
do
test ! ${builtin}= “enable” || continue
test ! ${builtin}= “continue” || continue
test ! ${builtin}= “local” || continue
test ! ${builtin}= “shopt” || continue
test ! ${builtin}= “shift” || continue
test ! ${builtin}= “return” || continue
test ! ${builtin}= “read” || continue
echo “disabling ${builtin} …”
enable -n ${builtin}
done
}
 
Test
 
{
disable
enable
}

Producción

disabling . …
disabling : …
disabling [
disabling alias
disabling bg
disabling bind
disabling break
disabling builtin
disabling caller …
disabling cd
disabling command
disabling compgen
disabling complete
disabling compopt …
disabling declare
disabling dirs
disabling disown
disabling echo
disabling eval
disabling exec
disabling exit
disabling export
disabling false
disabling fc
disabling fg
disabling getopts
disabling hash
disabling help
disabling history
disabling jobs
disabling kill
disabling let
disabling logout
disabling mapfile …
disabling popd
disabling printf
disabling pushd
disabling pwd
disabling readarray …
disabling readonly
disabling set
disabling source
disabling suspend
disabling test
disabling times
disabling trap
disabling true
disabling type
disabling typeset
disabling ulimit
disabling umask
disabling unalias
disabling unset
disabling wait
enable continue
enable enable
enable local
enable read
enable return
enable shift
enable shopt

Aquí le mostramos cómo deshabilitar (la mayoría) de las funciones integradas mediante la habilitación integrada. Puede optar por desactivar el resto al final del ciclo.

Línea de fondo

Builtin ayuda a modificar el comportamiento del shell en bash. Aquí mostramos algunas formas en las que se puede usar buitlin, como deshabilitar las funciones de los comandos incorporados o los comandos por completo. Aún así, hay temas intactos, como la carga de nuevos comandos integrados a través de la carga dinámica, que pueden cubrirse en una fecha posterior.

Leave a Comment

Your email address will not be published. Required fields are marked *

Hazlo Linux