Ver el código de «Programación básica de scripts en Linux»

Nun principio, podemos dicir que basicamente os scripts non son mais que unha secuencia de comandos escritos nun ficheiro de texto. Sen embargo, os intérpretes de comandos de Linux inclúen toda unha serie de estruturas que dan lugar a un auténtico linguaxe de programación, con variables, instrucións e comandos de entrada/saída, estruturas de control, subprogramas, paso de parámetros, etc.

== Aspectos básicos ==

* O primeiro que deberemos introducir no script é unha liña na que se indique para que intérprete de comandos está programado. Hai que ter en conta que os distintos shells teñen funcións e estruturas de control distintas. A sintaxe será: '''''#!ruta_shell'''''
  #!/bin/bash

* A continuación introduciremos liñas con comandos e estruturas permitidas no shell que esteamos programando.
* O carácter '''#''' permítenos introducir un comentario, xa que o shell ignorará todo o introducido a continuación.
* A extensión habitual dun ficheiro de script en Linux é .sh, aínda que tamén é frecuente non poñerlles ningunha extensión.

== Definición de variables ==
* Podemos definir unha variable coa instrución: '''''variable=valor'''''
* Para acceder ao valor da variable introducimos o carácter '''$''' antes do nome da mesma: '''''echo $variable'''''
* Tamén podemos introducir o valor da variable dentro dunha cadea maior, tendo en conta que:
** Se englobamos a cadea entre comiñas dobres, o shell substituirá a variable polo seu valor.
** Se englobamos a cadea entre comiñas simples, o shell non fará ningunha substitución e mostrará o texto que se indica
** Se englobamos a cadea entre comiñas invertidas, o shell interpretará a cadea como un comando e devolverá o resultado (o mesmo se consigue con '''''$(comando)'''''):
  var=mundo
  echo “hola, $var” # mostra hola, mundo
  echo 'hola, $var' # mostra hola, $var
  echo `ls` # mostra o contido do directorio actual

== Avaliación de expresións ==

* Se queremos que ''bash'' avalíe o contido dunha expresión aritmética e devolva o seu resultado usaremos a sintaxe ''$((expresión))'':
  p = $((p+3)) #suma 3 á variable p
* Tamén podemos utilizar a sentencia '''''let'''''
* A sintaxe para avaliar expresións condicionais (que devolven 1 ou 0) é '''''[ [expresión] ]''''', onde a expresión pode ser:
** Unha comparación con =, !=, <, <=, >, >=
** A negación dunha expresión: ''! expresión''
** O and ou or de varias expresións (deben encerrarse entre parénteses):'' expresión1 && expresión2'', ''expresión1 || expresión2
''

== Paso de parámetros ==

* En moitos casos interesaranos que o script poida recibir parámetros na liña de comandos, e acceder a eles dende o script. Para facelo, utilizaremos a seguinte sintaxe:
** '''$#''' devolve o número de parámetros que se lle pasou ó script
** '''$@''' devolve a cadea con todos os parámetros
** '''$0''' devólvenos o nome do propio script que se está executando
** '''$n''' devolve o valor do parámetro n pasado ó script
** '''Shift [n]''' é unha instrución que despraza cara a “esquerda” todos os parámetros recibidos no script, é dicir, o $2 pasa a ser o $1, $3 pasa a $2, etc. Pódese indicar como parámetro de shift o número de posicións que nós queremos desprazar (por defecto 1).
* Tamén podemos ler parámetros da entrada estándar dentro do script  coa función '''''read''''':
  read NOME # le da entrada estándar a variable NOME

== Control de fluxo ==

* Tamén podemos incluír dentro dos scripts as sentencias típicas de control de fluxo condicionais e iterativas de calquera linguaxe de programación:
* '''IF''':
  if [ condición1 ]; then acción1
  else   if  [ condición2 ]; then acción2
         else acción
         fi
  fi
* '''TEST''': Permite avaliar unha expresión e ver se é verdadeira ou falsa. Utilízase con frecuencia nas condicións do if. A expresión pode ser:
  -r ficheiro			o ficheiro existe e se pode ler
  -w ficheiro		        o ficheiro existe e se pode escribir
  -x ficheiro			o ficheiro existe e se pode executar
  -f ficheiro			o ficheiro existe e é un ficheiro normal
  -d ficheiro			o ficheiro é un directorio
  -c ficheiro			é un ficheiro especial de tipo carácter
  -b ficheiro			é un ficheiro especial de tipo bloque
  -s ficheiro			o ficheiro ten un tamaño maior que cero
  -z s1	   		        a lonxitude da cadea s1 é cero
  -n s1			        a lonxitude da cadea s1 non é cero
  s1 = s2			as dúas cadeas son iguais
  s1 != s2		        as dúas cadeas son distintas
  s1				a cadena s1 existe
  n1 –eq n2		        n1 e n2 teñen o mismo valor numérico
  n1 –ne n2		        n1 e n2 teñen distinto valor numérico
  n1 –gt n2		        n1 ten un valor maior que n2
  n1 –lt n2		        n1 ten un valor menor que n2
  n1 –ge n2	        	n1 ten un valor maior ou igual que n2
  n1 –le n2	        	n1 ten un valor menor ou igual que n2
  -a				And lóxico
  -o				Or lóxico
* '''CASE''':
  case variable in
  patrón1) comandos a executar se variable coincide con patrón1;;
  patrón2) comandos a executar se variable coincide con patrón2;;
  ...
  esac
** Cada patrón posible do case pode ser:
*** Un valor constante, numérico ou de cadea
*** Un conxunto de valores constantes, separados por |
*** Un rango de valores, separando o mínimo e o máximo por -
*** Patrón por defecto, con *

* '''Comando1 && Comando2''': Executa Comando2 só se Comando1 ten éxito (código de saída 0)
* '''Comando1 || Comando2''': Executa Comando2 só se Comando1 non ten éxito (código de saída distinto de 0)
* '''FOR''':
  for variable in lista-valores
  do
  Instrucións a executar
  done
**Onde a lista de valores pode ter:
*** Un conxunto de valores separados por espazos
*** O resultado dun comando entre ``
*** O conxunto de parámetros do script ($@)
* '''WHILE/UNTIL''':
  while condición               until condición
  do                            do
  Comandos a executar           Comandos a executar
  done                          done

* '''BREAK E CONTINUE''': Estas sentenzas permiten saír do bucle e pasar á seguinte iteración respectivamente
* '''EXIT''': Sae do script
* '''SLEEP''': Fai unha pausa do número de segundos indicado

== Definición de funcións ==

* Unha función permite englobar un conxunto de comandos baixo un nome que podemos invocar dende o script
* Sintaxe:
  function nome ()
  {
      comandos a executar
  }
* A sentenza '''''return''''' permite saír da función
* Podemos indicar opcionalmente o valor de retorno da función
* Para invocar a función, simplemente introduciremos o seu nome seguido dos posibles parámetros, que se recollerán na función da mesma forma que se recollen no script, como $1, $2, etc.