shell - script - #/bin/sh que significa

encabezados de shell-script(#!/bin/sh vs#!/bin/csh) (3)

¿Por qué todos los archivos de script comienzan con

#!/bin/sh

o con

#!/bin/csh

Es eso requerido? ¿Cuál es el propósito de esto? ¿Y cuál es la diferencia entre los dos?

El #! line le dice al kernel (específicamente, la implementación de la llamada al sistema execve ) que este programa está escrito en un lenguaje interpretado; la ruta de acceso absoluta que sigue identifica al intérprete. Los programas compilados para el código de máquina comienzan con una secuencia de bytes diferente, en la mayoría de Unixes modernos, 7f 45 4c 46 ( ^? ELF ) que los identifica como tales.

¡Puedes poner una ruta absoluta a cualquier programa que quieras después del #! , ¡siempre que ese programa no sea en sí mismo un #! guión. El kernel reescribe una invocación de

./script arg1 arg2 arg3 ...

donde ./script comienza con, digamos, #! /usr/bin/perl #! /usr/bin/perl , como si la línea de comando hubiera sido realmente

/usr/bin/perl ./script arg1 arg2 arg3

O, como has visto, puedes usar #! /bin/sh #! /bin/sh para escribir un script destinado a ser interpretado por sh .

El #! la línea solo se procesa si invocas directamente la secuencia de comandos ( ./script en la línea de comando); el archivo también debe ser ejecutable ( chmod +x script ). Si haces sh ./script el #! la línea no es necesaria (y se ignorará si está presente), y el archivo no tiene que ser ejecutable. El objetivo de la función es permitirle invocar directamente programas de idiomas interpretados sin tener que saber en qué idioma están escritos (¡ grep ''^#!'' /usr/bin/* - descubrirá que hay muchos los programas de valores están usando esta característica).

Aquí hay algunas reglas para usar esta característica:

El #! deben ser los primeros dos bytes en el archivo. En particular, el archivo debe estar en una codificación compatible con ASCII (por ejemplo, UTF-8 funcionará, pero UTF-16 no) y no debe comenzar con una "marca de orden de bytes", o el kernel no lo reconocerá como una #! guión.
¡El camino después de #! debe ser una ruta absoluta (comienza con / ). No puede contener espacios, tabulaciones o caracteres de nueva línea.
Es un buen estilo, pero no obligatorio, para poner un espacio entre el #! y el / . No pongas más de un espacio allí.
¡No puedes poner variables de shell en el #! línea, no serán expandidos.
Puede poner un argumento de línea de comando después de la ruta absoluta, separado de él por un espacio simple. Al igual que la ruta absoluta, este argumento no puede contener espacios, tabulaciones o caracteres de nueva línea. A veces esto es necesario para hacer que las cosas funcionen ( #! /usr/bin/awk -f ), a veces es útil ( #! /usr/bin/perl -Tw ). Lamentablemente, no puede poner dos o más argumentos después de la ruta absoluta.
¡Algunas personas te dirán que uses #! /usr/bin/env interpreter #! /usr/bin/env interpreter lugar de #! /absolute/path/to/interpreter #! /absolute/path/to/interpreter Esto es casi siempre un error. Hace que el comportamiento de su programa dependa de la variable $PATH del usuario que invoca el script. Y no todos los sistemas tienen env en primer lugar.
Los programas que necesitan privilegios setuid o setgid no pueden usar #! ; deben compilarse para código de máquina. (Si no sabes qué es setuid , no te preocupes por esto).

Con respecto a csh , se relaciona con el sabor del sustituto de té avanzado Nutrimat. Tiene (o mejor dicho, las implementaciones modernas de sh han alcanzado) una serie de ventajas sobre sh para el uso interactivo, pero usarlo (o su descendiente tcsh ) para la creación de scripts es casi siempre un error . Si es nuevo en las secuencias de comandos de shell en general, le recomiendo que lo ignore y se concentre en sh . Si está utilizando un pariente csh como su shell de inicio de sesión, cambie a bash o zsh , de modo que el lenguaje de comando interactivo sea el mismo que el lenguaje de scripting que está aprendiendo.

Esto define qué shell (intérprete de comandos) está utilizando para interpretar / ejecutar su script. Cada shell es ligeramente diferente en la forma en que interactúa con el usuario y ejecuta scripts (programas).

Cuando escribe un comando en el indicador de Unix, está interactuando con el shell.

Por ejemplo, #!/bin/csh refiere a la C-shell, /bin/tcsh la t-shell, /bin/bash la shell de bash, etc.

Puedes decir qué consola interactiva estás usando

echo $SHELL

comando, o alternativamente

env | grep -i shell

Puede cambiar el shell de su comando con el comando chsh .

Cada uno tiene un conjunto de comandos ligeramente diferente y una manera de asignar variables y su propio conjunto de construcciones de programación. Por ejemplo, la sentencia if-else con bash se ve diferente a la que aparece en C-shell.

Esta página puede ser de interés ya que "traduce" entre los comandos / sintaxis bash y tcsh.

El uso de la directiva en el script de shell le permite ejecutar programas utilizando un shell diferente. Por ejemplo, uso el shell tcsh forma interactiva, pero a menudo ejecuto scripts bash usando / bin / bash en el archivo de script.

Aparte:

Este concepto se extiende a otros scripts también. Por ejemplo, si programa en Python pondría

#!/usr/bin/python

en la parte superior de tu programa Python

Esto se conoce como Shebang :

http://en.wikipedia.org/wiki/Shebang_(Unix)

#! intérprete [opcional-arg]

Un shebang solo es relevante cuando un script tiene el permiso de ejecución (por ejemplo, chmod u + x script.sh).

Cuando un shell ejecuta el script, usará el intérprete especificado.

Ejemplo:

#!/bin/bash # file: foo.sh echo 1 $ chmod u+x foo.sh $ ./foo.sh 1