IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

LPI 103.1. Treballar a la línia d'ordres

De SergiTurWiki
Share/Save/Bookmark
(S'ha redirigit des de: Ordre interna)
Dreceres ràpides: navegació, cerca

Linux Professional Institute Certificate. LPIC-1

Lpic1 large.gif
Certificat LPIC-1
Examen: 101 (torneu a la resta de temes)
Fitxers: LPI103.1_TreballarALaLiniaOrdres.pdf (LPI103.1_TreballarALaLiniaOrdres.odp), UD_8_2_comandes_inicials.pdf
Objectius: http://www.lpi.org/eng/certification/the_lpic_program/lpic_1/exam_101_detailed_objectives
Dipòsit SVN: https://svn.projectes.lafarga.cat/svn/lpi/Materials/Examen_101/103.1
Usuari: anonymous
Paraula de pas: qualsevol paraula de pas

Contingut

Objectius del tema

103.1. Treballar a la línia d'ordres
Objective.jpg
  • Objectiu: Els candidats han de ser capaços d'interactuar amb l'interpret d'ordres (shell) i les comandes que utilitzen la línia d'ordres. Aquest objectiu assumeix que l'interpret d'ordres a utilitzar és bash.
  • Pes: 4
060317 Icon - Theory of Knowledge v01 pdc.jpg

Àrees Clau de Coneixement:

  • Utilitzar ordres bàsiques de l'interpret d'ordres embolcall i seqüències d'instruccions d'una línia per a fer tasques bàsiques amb la línia d'ordres.
  • Utilitzar i modificar l'entorn de l'interpret d'ordres incloent la definició, la referència i l'exportació de les variables d'entorn.
  • Utilitzar i editar l'històric d'ordres.
  • Invocar ordres dins i fora del camí (path) definit.
Icon list.jpg

La següent és una llista parcial de fitxers, termes i utilitats utilitzades:

Fitxer:Text-editor.svg

Apunts: LPI 103.1. Treballar a la línia d'ordres

Plantilla per prendre apunts

Terminals

Consulteu Terminals, terminfo, ncurses.

Ús bàsic de la línia de comandes

Hi ha diferents intèrprets d'ordres, però els objectius de l'examen 101 de LPIC es basen en l'interpret d'ordres bash. A més la majoria d'intèrprets de comandes tenen característiques similars i proporcionen funcionalitats semblants.

Els principals intèrprets de comandes són:

  • bash: Consulteu bash
  • sh: sh o Bourne Shell, va ser un dels primers intèrprets de comandes, i era la shell per defecte a Unix quan va ser creada al 1977 per Stephen Bourne dels laboratoris AT&T de Bell. sh és encara l'interpret de comandes per defecte de root a sistemes Unix.
  • csh: La shell original de C no es gaire utilitzada a Linux. tcsh és un bon substitut de csh a Linux.
  • tcsh: Aquesta shell està basada en csh. És bastant popular, però cap de les distribucions importants de Linux la porta per defecte. Encara que és similar a bash en molts aspectes, difereix en algunes operacions, com per exemple, l'assignació de variables d'entorn.
  • ksh: L'intèrpret de comandes Korn shell (ksh) va ser dissenyat per tal de tenir les millors característiques de sh i zsh
  • dash: Són les inicials de Debian Almquist Shell un versió millorada de ash. És molt més petit que bash i té com a objectiu ser compatible amb POSIX. A Ubuntu, des de la versió 6.10, és l'interpret de comandes per defecte del sistema (enllaç simbòlic des de (bin/sh), tot i que l'intèrpret per defecte dels usuaris (login shell) continua sent bash ([1]). El canvi es va dur a terme per raons d'eficiència.

Es pot modificar la shell per defecte d'un usuari, modificant la seva compte amb la comanda usermod.

Normalment el fitxer:

/bin/sh

És un enllaç simbòlic a la shell per defecte.

$ ls -la /bin/sh
lrwxrwxrwx 1 root root 4 2009-04-26 10:41 /bin/sh -> dash

NOTA: l'exemple s'ha executat en una Ubuntu 9.04. Com podeu veure Ubuntu des de fa algunes versions utilitza dash com intèrpret de comandes per defecte.

També cal destacar que normalment al escriure guions de l'interpret de comandes (shell scripts), la primera línia s'utilitza per indicar quin és l'interpret de comandes que s'ha d'utilitzar per tal d'executar l'script:

#!/bin/sh -e

max=1440

for ini in /etc/php5/*/php.ini; do
	cur=$(sed -n -e 's/^space:*session.gc_maxlifetimespace:*=space:*\([0-9]\+\).*$/\1/p' $ini 2>/dev/null || true); 
	[ -z "$cur" ] && cur=0
	[ "$cur" -gt "$max" ] && max=$cur
...

Aquesta primera línia és anomenada shebang. L'interpret no té per què ser un interpret de línia de comandes, i per exemple es pot escriure un guió d'intèrpret de comandes amb php i per tant el shebang seria:

#!/usr/bin/php5 -q

Consulteu l'article PHP des de la línia de comandes per tal d'obtenir més detalls. També podeu consultar l'article dedicat a Shebang.

Recursos:

Però, què és un ordre?

Un ordre és el que escrivim després del PROMPT a l'intèrpret d'ordres

El format d'una ordre acostuma a ser:

ordre parametre1 parametre2 parametre3 ...

Els paràmetres poden ser opcions o informació que necessita l'ordre, poden ser obligatoris o opcionals.

Hi han 3 sistemes (estils) per a les opcions o paràmetres:

  • Unix98: Sistema de paràmetres d'un sol caràcter precedit de guió
  • GNU: proposa que les opcions siguin paraules (--palabra)
  • BSD: Lletres sense guió

Exemples:

Unix98:

$ netstat -puta

és igual a:

$netstat -p -u -t -a

o a:

$ netstat -tapu

GNU:

$ls –all = $ls -a diferent de $ls -a -l -l

FreeBSD:

$ ps aux 

Sintaxi d'un ordre

Durant el curs i als manuals de Linux parlarem de la sintaxi de les ordres. Per exemple:

cp [OPTION]... SOURCE... DIRECTORY

Els paràmetres que són opcionals es marquen entre claudàtors ([]). Els obligatoris no.

Els tres punts indiquen que és possible repetir l'opció precedent (en el exemple, es poden repetir opcions i origens -SOURCE)

La sintaxi pot ser més concreta (i complexa):

man  [-C  file]  [-d]  [-D]  [--warnings[=warnings]]  [-R  encoding]  [-L  locale]  [-m system[,...]] [-M path] [-S list] [-e extension] [-i|-I] [--regex|--wildcard]
[--names-only] [-a] [-u] [-P pager] [-r prompt] [-7] [-E  encoding]  [--no-hyphenation]  [-p  string]  [-t] [-T[device]]  [-H[browser]]  [-X[dpi]]  [-Z]  [[section] 
page ...] ...

bash

Bash és un interpret de comandes Unix escrit per al projecte GNU. El seu nom és un acrònim de Bourne-again shell, un joc de paraules que fa referència a l'interpret d'ordres Bourne shell (sh). L'interpret d'ordres sh, és un important interpret d'ordres de Unix, previ a bash i escrit per Stephen Bourne. Sh va aparèixer al 1978 i Bash va ser creat al 1987 per Brian Fox.

Bash és l'interpret del sistema operatiu GNU i pot ser executat en gairebé tots els sistemes Unix-like. És l'interpret de comandes per defecte en sistemes Linux i fins i tot en sistemes MAC OS X o Darwin.

També ha estat adaptat a Windows utilitzant el subsistema UNIX-based Applications (SUA) o l'emulació POSIX proveïda per Cygwin i MSYS. També hi han adaptacions per a MS-DOS (DJGPP) i Novell NetWare.

En la majoria de distribucions modernes bash és l'interpret de comandes per defecte i és el que ens trobarem al executar un emulador de terminal o una terminal virtual. Cal però tenir en compte que sempre podem explicitar que volem utilitzar bash executant:

$ bash

Que ens tornarà un interpret d'ordres bash.

També es pot especificar en guions de shell mitjançant el shebang.

Recursos:

Terminals

És important tenir clar la diferència entre l'intèrpret d'ordres i les terminals. Sovint s'utilitzen els termes línia de comandes, terminal, shell, intèrpret de línia d'ordres, consola com si fossin la mateixa cosa. La terminal és el component de maquinari (antigues teletypes) o el programa que executa l'interpret de comandes o shell.

Podem dir que hi ha 3 tipus de terminals:

  • Teletypes o Teleprinters: Són el antecessors del concepte de terminal modern. Van apareixer als anys 20 i els primers sistemes eren sistemes completament mecànics formats per una màquina d'escriure connectada directament a una impressora. De fet ja existien sistemes predecessors de terminals remots (per l'any 1870) com una màquina Stock_ticker_machine que enviava les cotitzacions de la borsa de Nova York mitjançant el telègraf.
  • Terminals virtuals: Són les terminals a les que podem accedir amb la combinació de tecles Ctrl+Alt+Fx on x és el número de terminal. La principal diferència amb els emuladors de terminal és que les terminals virtuals no s'executen dins d'un entorn gràfic X Window.
  • Emuladors de terminal: Són aplicacions que emulen una terminal. Normalment són aplicacions que s'executen en un entorn gràfic X Window i emulen una terminal dins de la finestra de la aplicació.

Els emuladors de terminal són aplicacions de les quals es poden executar múltiples instàncies cadascuna d'elles completament independent entre elles.

Consulteu l'article:

Terminals,_terminfo,_ncurses

Per tal d'obtenir més informació sobre terminals.

Principals emuladors de terminal

Recursos:

PROMPT

El verb to prompt en anglès vol dir preguntar, sol·licitar, indicar... En informàtica el PROMPT és el text que ens mostra l'intèrpret d'ordres cada vegada que volem executar una nova ordre. Per exemple, un prompt molt simple podria ser:

$

De fet, normalment tots els prompts contenen o el caràcter dollar ($) o el caràcter coixinet (#). El caràcter dollar ($) s'utilitza per als usuaris normals, i el caràcter coixinet (#) s'utilitza per als superusuaris (root).

De fet normalment els PROMPT són una mica més sofisticats. Una de les combinacions de PROMPT més utilitades és:

usuari@nom_maquina:PATH$

Podeu obtenir més informació a la secció PROMPTING del manual de bash:

$ man bash

Canviar el prompt

Consulteu les variables d'entorn:

Trucs i ús de la línia d'ordres

Molts usuaris troben la línia d'ordres tediosa i molt susceptible als errors. Aquesta afirmació pot ser certa si es té poca pràctica amb el teclat i si no es coneixen els trucs que et proporciona l'interpret de comandes (cal destacar, que sovint tot es qüestió de costums, ja que per molts usuaris novells el ratolí també és una eina força difícil de controlar al principi...).

En aquest apartat veurem alguns dels trucs més útils per tal de treballar amb la línia d'ordres.

Ajuda en l'acabament d'ordres (command completion)

Exemple d'ajuda en l'acabament d'ordres extret de la wikipedia anglesa.

Sense cap mena de dubte, una de les ajudes més utilitzades i que més facilita l'ús de la terminal és l'ajuda en l'acabament de comandes. La majoria d'intèrprets d'ordres moderns proporcionen aquesta ajuda que consisteix en finalitzar comandes que estan escrites de forma parcial.

Ho podeu comprovar escrivint:

$ a

Però NO premeu la tecla Enter encara! Si ara tabuleu (premeu la tecla del tabulador -->), sentireu un beep (sempre que tingueu algun tipus d'altaveus, interns o externs, i el so dels mateixos activat). Quan al prémer el tabulador us pita, això us està indicant que existeix més d'una opció per tal de completar la comanda. Si torneu a prémer el tabulador

$ a
Display all 130 possibilities? (y or n)

Us indicarà que hi ha 130 (el número que us apareixerà en el vostre cas pot variar) ordres que comencen per a, si premeu i us les mostrarà.

Si tornem a provar però aquest cop li facilitem més a l'ordinador l'elecció de la comanda:

$ if

i tabuleu 2 cops

$ if
if        ifconfig  ifdown    ifind     ifup      
sergi@sergi-desktop:~$ if

Ara us apareixerà un nombre més limitat d'opcions. Si escriviu un c extra i tabuleu haureu aconseguit escriure la comanda ifconfig.

Aquesta utilitat pot no semblat molt útil, ja que la majoria d'ordres fonamentals tenen noms curts (mv, ls, set, cd...), però altres comandes són una mica més llargues i sovint no recordem exactament com s'escriuen.

També cal tenir en compte que la majoria d'intèrprets de comandes actual també suporten completar noms de fitxers. Els noms de fitxers poden contenir fins a 255 caràcters i poden ser força complicats.

Cal tenir en compte que algunes comandes us proporcionaran ajuda fins i tot a l'hora d'escriure els paràmetres. És per exemple, el cas de apt-get. Proveu:

$ apt-get ins

i tabuleu.

NOTA: Les capacitat de autocompletar per a l'usuari root normalment estan més limitades. Podeu utilitzar sudo per tal d'evitar-ho.
NOTA: Alguns intèrprets de comandes antics no suporten command completion.

bash completion

En sistemes Debian, hi ha un paquet anomenat bash-completion que aporta la capacitat d'autocompletar extra per a certes comandes del sistema.

El fitxer /etc/bash_completion, incorpora suport extra d'autocomplementar per a certes comandes com per exemple apt-get:

$ cat /etc/bash_completion | grep apt
# Debian apt-get(8) completion.
have apt-get &&
_apt_get()
...

El bash-autocompletion s'activa al perfil de bash (fitxer ~/.bashrc):

$ cat ~/.bashrc
.
# enable programmable completion features (you don't need to enable
# this, if it's already enabled in /etc/bash.bashrc and /etc/profile
# sources /etc/bash.bashrc).
if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

Altres aplicacions poden afegir-se posant un fitxer a la carpeta /etc/bash_completion.d:

$ ls /etc/bash_completion.d/
acroread.sh  apache2.2-common  apt-file  debconf  desktop-file-validate  dkms  ooffice.sh  pon  rdiff-backup  subversion

Edició amb bash

Utilitzant una sintaxi basada en Emacs, podeu editar les línies de l'intèrpret d'ordres amb:

  • Moure's per la línia:
    • Ctrl+A: inici de línia.
    • Ctrl+E: final de línia.
    • Fletxes esquerra i dreta del teclat
    • Les fletxes més la tecla control es permeten moure'ns a dreta i esquerra de paraula en paraula.
  • Esborrar text
    • Ctrl+D: Tecla suprimir
    • Backspace
    • Ctrl+k: Esborra des del cursor fins al final de línia.
    • Ctrl+x + Bakcspace: Esborra des del cursor fins al final de línia.
  • Intercanviar text
    • Ctrl+t: intercanvia el caràcter d'abans del cursor pel de després del cursor.
  • Canviar de majúscules a minúscules:
    • Esc+U: Converteix del cursor al final de paraula en majúscules
    • Esc+L: Converteix del cursor al final de paraula en minúscules
    • Esc+C: Converteix la primera lletra (Capitalize) de la paraula sota el cursor a majúscules
  • Invocar un editor:
    • Es pot executar un editor complet per tal d'editar una línia de l'intèrpret d'ordres. Ctrl+X+Ctrl+E. S'executa l'editor definit a la variable d'entorn EDITOR o FCEDIT

Per a més exemples consulteu l'apartat Dreceres (Shortcuts).

Historial de l'interpret de comandes

La majoria d'intèrprets d'ordres mantenen un historial de les comandes que executem. L'ús més bàsic de l'historial es repetir comandes que hem executat fa poc amb la fletxa cap amunt del teclat.

Consulteu la comanda history per tal d'obtenir més informació sobre l'historial de l'intèrpret d'ordres.

Ctrl+r

L'indiquem aquí com una de les ajudes més útils que ens proporciona la línia d'ordres. Podem buscar comandes que ja em executat anteriorment amb Ctrl+r:

$ 
(reverse-i-search)`': 

si escriviu per exemple la lletra c:

us mostrarà l'última comanda de l'historial que conté la lletra c.

Per exemple per repetir l'última comanda cat podem buscar per cat.

Consulteu la comanda history per tal d'obtenir més informació sobre l'historial de l'intèrpret d'ordres.

Obtenint ajuda

Consulteu la comanda man.

Dreceres (Shortcuts)

CTRL Key Bound_____________

Ctrl + a - Salta a l'inici de la línia (Equivalent a la tecla Inicio)
Ctrl + b - Mou enrere un caràcter (equivalent a la fletxa esquerre)
Ctrl + c - Senyal de terminació de la comanda
Ctrl + d - Equivalent al botó suprimir (esborra per davant del cursor)
Ctrl + e - Salta al final de la línia (equivalent a la tecla Fin)
Ctrl + f - Mou endavant un caràcter (equivalent a la fletxa dreta)
Ctrl + k - Esborra fins al final de la línia
Ctrl + l - Neteja la pantalla. Equivalent a la comanda clear
Ctrl + r - permet cercar a l'historial d'ordres
Ctrl + R - permet cercar a l'historial d'ordres amb múltiples ocurrències.
Ctrl + u - Esborrar per darrera del cursor (equivalent a la tecla backspace)
Ctrl + xx - Intercanvia la posició entre l'inici de línia i la posició del cursor.
Ctrl + x @ - mostra el possibles noms de màquina
Ctrl + z - Suspèn/atura l'ordre

____________ALT Key Bound___________

Alt + < - Mou fins a la primera línia de la historia
Alt + > - Mou fins a la última línia de la historia
Alt + ? - Mostra les possibilitats actual de autocompletar (similar al doble tabulador)
Alt + * - Insereix totes les possibilitat d'autocompletar
Alt + / - Intenta completar el nom d'un fitxer
Alt + . - Mostra l'argument de la última ordre (o l'ordre en si si no tenia arguments). Es pot executar múltiples cops.
Alt + b - Mou a la l'inici de la paraula
Alt + c - Transforma el caràcter sota el cursor en majúscules
Alt + d - Borra des de el cursor fins al final de paraula
Alt + f - Mou al final de la paraula
Alt + l - Converteix una paraula a minúscules (des del cursos fins a final de paraula).
Alt + n - Cerca a l'historia cap endavant de forma no incremental.
Alt + p - Cerca a l'historia enrere de forma no incremental
Alt + r - Ordre de tornar a cridar
Alt + t - intercanvia dues paraules
Alt + u - Convertir la paraula (del cursor en endavant) a majúscules
Alt + back-space - Esborra la paraula des del cursos fins a l'inici de la paraula.

Recursos:

Configuració de l'interpret d'ordres bash

NOTA: Per a obtenir més detall consulteu LPI 105.1. Configuració a mida i ús de l'entorn shell

Com la gran majoria de programes a Linux, la bash es configura mitjançant fitxers de configuració (text pla). Normalment els fitxers de configuració de bash són en sí guions de l'intèrpret d'ordres.

La configuració (també de forma similar al que succeïx amb la majoria de programes Linux) es pot fer a 2 nivells:

  • Configuració d'usuari: les configuracions d'usuari normalment es realitzen en fitxers o directoris ocults que es troben a la HOME de l'usuari. En el cas de bash el fitxers que ens interessen són ~/.bashrc i ~/.profile .
  • Configuració de sistema: els fitxers de configuració generals del sistema es troben a la carpeta /etc. Per modificar la configuració general de bash cal modificar el fitxer /etc/profile.

Vegem un exemple:

Fitxer bash_profile:

case $TERM in
  xterm*)
       local BARRATITOL=’\[\033]0;\u@\h:\w\007\]’ 

       ;;
  *)
       local BARRATITOL=’’
                                                           ;;
esac
PS1="${BARRATITOL}\u@\h:\w\$ "
PS2=’’
PS4=’+’
umask 077
export LANG=ca_ES
if [ -d ~/bin ] ; then
    PATH=~/bin:"${PATH}"
fi
eval ‘dircolors‘
alias ls=’ls --color=auto’
NOTA: Cal tenir molt de compte al modificar aquest fitxers, ja que certs errors poden deixar inutilitzat el sistema.

Ordres internes i ordres externes

Les ordres que podem executar en un interpret d'ordres poden ser de 2 tipus:

  • externes: són aplicacions independents de l'interpret d'ordres i que s'executen indicant el seu camí complet o directament si es troben a la variable d'entorn PATH. Un exemple de comanda externa és la comanda ls.
  • internes: són ordres que són proporcionades pel propi intèrpret de comandes. També se les anomena built-in commands. Per aquestes ordres no trobarem una executable específic al nostre sistema de fitxers, ja que és el propi executable de l'interpret de comandes qui les proporciona.

Segurament una de les comandes internes més utilitzades és la comanda cd. Si intenteu localitzar quin és l'executable de la comanda cd:

$ whereis cd
cd: /usr/share/man/man1/cd.1posix.gz

només trobareu el manual

o

$ which cd
NOTA: Compte amb algunes comandes internes que disposen de comandes equivalents externes. Consulteu Ordres que poden ser internes i externes. En aquest cas si que trobareu el camí cap a l'executable de la comanda externa equivalent.

no reporta cap resultat. Això es degut a que no existeix executable per a la comanda cd, o millor dir, és l'executable de l'intèrpret de comandes (/bin/bash) qui ens proporciona la comanda.

NOTA: Algunes comandes internes, com la comanda cd, no funcionen correctament amb sudo per raons de seguretat

La majoria d'intèrprets de comandes ofereixen ordres internes similars, però poden haver-hi petites diferències entre intèrprets. Podeu conèixer quines són les comandes internes de bash consultant el seu manual:

$ man bash

Les comandes són (les trobareu a la secció Shell Builtin Commands):

Algunes de les comandes que s'utilitzen més habitualment són:

Podeu utilitzar l'ordre interna type per conèixer de quin tipus és un ordre:

$ type cp
cp is /bin/cp
$ type cd
cd is a shell builtin

Ordres que poden ser internes i externes

Algunes de les ordres internes tenen una ordre externa equivalent que realitza la mateixa feina.

NOTA: Aquestes comandes externes equivalents no sempre estan instal·lades en tots els sistemes.

Cal tenir en compte que encara que tinguem instal·lada una comanda externa equivalent, la comanda interna sempre té preferència respecte a la comanda externa.

L'única forma d'executar la comanda externa és indicar el seu path absolut o relatiu. Per exemple:

$ /bin/pwd
/home/sergi

En algunes ocasions les diferències entre les ordres internes i les ordres externs són molt subtils i poden causar confusió. Per exemple l'ordre pwd tracta de forma diferents els enllaços simbòlics. Ho podeu comprovar amb:

$ cd
$ ln -s /var .
$ cd var
$ pwd
/home/sergi/var
$ /bin/pwd 
/var

Variables d'entorn

Les variables d'entorn tenen un ús similar al que tenen les variables en qualsevol llenguatge de programació. En el cas dels intèrprets de comandes, les variables d'entorn contenen informació sobre l'entorn i poden ser modificades per qualsevol aplicació (incloent el propi intèrpret de comandes).

Les variables d'entorn, s'utilitzen per exemple com a llocs on emmagatzemar informació que pot ser útil per a diferents programes. És el cas de la variable d'entorn EDITOR que conté el camí cap a l'executable del nostre editor de text preferit (el que les aplicacions utilitzaran per defecte).

Quan estàs treballant en una màquina, estàs en el teu propi entorn, aquest entorn està definit per una sèrie de variables que defineixen qüestions com l'aspecte del teu prompt, el teu directori d'usuari, el teu directori de treball, el nom del teu shell, fitxers que has obert, funcions o comandes que has utilitzats,... totes aquestes informacions estan contingudes en unes variables anomenades variables d'entorn.

Consultar variables d'entorn

Amb la comanda echo podeu consultar el valor de les variables d'entorn. Per exemple:

$ echo $PATH

Podeu utilitzar també la comanda env per tal de consultar totes les variables d'entorn:

$ env

Si voleu veure el valor d'una variable en concret podeu utilitzar les ordres env i grep conjuntament:

$ env | grep PATH
PATH=.:/home/sergi/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/prova

NOTA: Observeu que podeu utilitzar el tabulador (autocompletar) per tal d'escriure les variables d'entorn. Per tant, una forma extra de consultar les variables d'entorn és:
$ $

I tabuleu dos cops

$ $ 
$_                         $IFS
$BASH                      $LANG
$bash205                   $LESSCLOSE
$bash205b                  $LESSOPEN
$bash3                     $LINENO
$BASH_ARGC                 $LINES
$BASH_ARGV                 $LOGNAME
$BASH_COMMAND              $LS_COLORS

Algunes de les variables d'entorn més utilitzades són:

Nom Funció
EDITOR Estableix el editor de text per defecte.
HOME El directori home de l'usuari
PATH Estableix els camins on es troben els executables del sistema.
PPID L'identificador del procés que ha iniciat el procés que s'està executant
PWD El directori de treball actual
SHELL El nom del l'interpret d'ordres que s'està utilitzant
UID Identificador numèric de l'usuari
USER Nom de l'usuari en el sistema
$ ($$) Identificador del procés que s'està executant
? ($?) El codi de retorn de la darrera instrucció executada

Establir i modificar variables d'entorn

Per establir una variable d'entorn escriurem:

$ SALUTACIO=Hola
$ export SALUTACIO

Observeu que la primera línia és la forma genèrica d'establir una variable a bash. Aquesta variable però no esdevé una variable d'entorn fins que no utilitzeu la comanda export. Podeu combinar les dues línies en una sola:

$ export SALUTACIO=Hola

També es pot utilitzar l'ordre interna declare:

$ declare -x

Establir variables d'entorn de forma permament

Es pot fer escrivint-les al fitxer /etc/environment. Per exemple hi trobareu el PATH del sistema:

$ cat /etc/environment 
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"

Per exemple per establir de forma permanent la variable d'entorn JAVA_HOME:

$ sudo joe /etc/environment

I afegiu la línia:

JAVA_HOME=/usr/lib/jvm/java-6-sun-1.6.0.15

Recursos:

Esborrar una variable d'entorn

Per esborrar una variable d'entorn utilitzeu l'ordre unset:

$ unset SALUTACIO
$ echo $SALUTACIO

De fet l'ordre unset permet esborrar qualsevol tipus de variable de shell i fins i tot funcions.

L'ordre unset és una ordre interna de bash. Podeu consultar l'ajuda de l'ordre al manual de bash:

$ man bash
...
        unset [-fv] [name ...]
             For  each  name,  remove the corresponding variable or function.  If no options are supplied, or the -v option is given, each name refers to a shell variable.
             Read-only variables may not be unset.  If -f is specified, each name
             or  function  is  removed  from  the environment passed to subsequent commands.  If any of RANDOM, SECONDS, LINENO, HISTCMD, FUNCNAME, GROUPS, or DIRSTACK are
             unset, they lose their special properties, even if they are subsequently reset.  The exit status is true unless a name

Es poden esborrar múltiples variables de cop:

$ unset VARIABLE1 VARIABLE2 VARIABLE3 ...

L'opció -v és l'opció per defecte (indica que només s'esborren variables). Amb l'opció -f es poden també esborrar temporalment funcions.

Cal tenir en compte que els canvis no són permanents:

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
$ unset PATH
$ echo $PATH

Si inicieu shell noves que no siguin de login la variable continuarà sense estar establerta:

$ bash 
$ echo $PATH

Les variables d'entorn es tornen a definir al iniciar una nova shell de login:

$ bash --login
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

També es pot utilitzar:

$ export -n

Establir variables d'entorn al iniciar sessió (login)

Consulteu:

LPI_105.1._Configuració_a_mida_i_ús_de_l'entorn_shell#Establir_variables_d.27entorn_al_iniciar_sessi.C3.B3_.28login.29

Establir el PATH del sistema

Consulteu PATH.

Desactivar temporalment variables d'entorn

Consulteu unset.

EDITOR

Defineix l'editor de text per defecte. En alguns sistemes l'editor de text per defecte (i l'únic que hi ha) és vi.

PATH

Les ordres basename i readlink es poden utilitzar per obtenir el nom d'un fitxer a partir del path complet i path complet a partir del nom del fitxer respectivament.

Les passes que segueix l'interpret de comandes per tal d'interpretar la comanda que li proporcionem són les següents:

  1. Primer es comprova si l'ordre és una ordre interna de l'intèrpret. Sí és així s'executa l'ordre interna.
  2. Si l'ordre no és un ordre interna, aleshores es busca l'ordre a les carpetes especificades a la variable d'entorn PATH.

Podeu consultar la variable PATH amb la comanda echo:

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

En aquest cas, com podeu veure les carpetes on l'intèrpret buscarà executables per a l'usuari sergi són:

  • /usr/local/sbin
  • /usr/local/bin
  • /usr/sbin
  • /usr/bin
  • /sbin
  • /bin
  • /usr/games

Cada carpeta està separada per dos punts (:). La majoria de les carpetes d'aquest exemple són les carpetes habituals a les que, segons l'estàndard File Hierarchy System (FHS), normalment hi trobem els executables del sistema.

Com la resta de variables d'entorn, la variable PATH pot ser diferent per a cada usuari, segons com es configuri l'entorn de cada usuari. Per posar un exemple, alguns sistemes operatius com Debian o Fedora 9, no inclouen la carpeta /sbin com a carpeta del PATH per als usuaris normals. La carpeta /sbin segons FHS està reservada per a les ordres de superusuari. Així si a Debian escriviu amb un usuari normal:

$ ifconfig
bash: ifconfig: command not found

Per consultar les IP heu d'executar:

$ /sbin/ifconfig

Com que moltes comandes poden tant modificar paràmetres claus del sistema com consultar-los (és el cas de la comanda ifconfig), a vegades pot ser més útil per als usuaris poder executar comandes com ifconfig (cal tenir en compte que només la podran executar per a consultar valors i no per a modificar-los) i per aquesta raó, /sbin, en sistemes com Ubuntu, si que està al PATH.

Per modificar la variable PATH podeu utilitzar la comanda export

$ export PATH=$PATH:/home/sergi/bin

En aquest cas afegim un nou directori al final del PATH. Ho podem fer a l'inici amb:

$ export PATH=/home/sergi/bin:$PATH
IMPORTANT: Recordeu que per tal que un fitxer sigui executable cal marcar el bit d'execució. Consulteu la comanda chmod.

El path per defecte del sistema (Ubuntu) s'estableix al fitxer /etc/environment:

$ cat /etc/environment 
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games"


Punt Barra (./)

Si us heu fixat en els exemples de l'apartat anterior, en cap cas trobareu que el directori actual de treball estigui al PATH. Com ja sabeu, la carpeta a la que estem es pot indicar amb el caràcter '.'.

Per aquesta raó si, per exemple, estem al nostre directori d'usuari i en aquest directori hi ha un executable anomenat programa si escrivim:

$ cd
sergi@sergi-desktop:~$ programa
bash: programa: command not found

Ens dirà que la comanda no ha estat trobada. Normalment això se soluciona ho bé proporcionant el camí absolut:

$ /home/sergi/programa

O bé proporcionant el camí relatiu amb punt barra (./):

$ ./programa

Per comoditat podríeu caure en la temptació d'afegir el punt al PATH amb:

$ export PATH=.:$PATH

Però es considera un problema de seguretat, ja que maliciosament algú podria col·locar programes bàsics a les vostres carpetes d'usuari. Per exemple, imagineu-vos que posant un executable amb males intencions a la vostra carpeta HOME i l'anomenen ls. Vosaltres podríeu executar aquest programa pensant-vos que executeu l'original ls si escriviu:

$ cd
$ ls
IMPORTANT: Aquesta recomanació de seguretat es fa gairebé imprescindible pel que fa a l'usuari root, ja que si posem al PATH la carpeta punt ens arrisquem a que un 
usuari espavilat aconsegueixi una escalada de privilegis mitjançant el truc abans esmentat.

CDPATH

És similar a PATH, però el que fa es determinar camins extres (a part del directori de treball) per a l'ordre cd. Vegem un exemple: si executem la comanda

$ cd a

A una carpeta on no hi ha cap subcarpeta anomenada a, aleshores cd buscara la carpeta a a qualsevol de les carpetes definides a la ]]variable d'entorn]] CDPATH. Si per exemple, CDPATH val:

$ echo $CDPATH
/home/sergi/Documents:/linux2

l'ordre cd intentarà anar a les carpetes:

/home/sergi/Documents/a

i

/linux2/a

PWD

Consulteu directori de treball.

OLDPWD

Guarda el anterior directori de treball:

$  env | grep OLDPWD
OLDPWD=/home/sergi/Documents

I podem anar amb :

$ cd $OLDPWD

o amb:

$ cd -

que equival a:

$ cd "$OLDPWD" $$ pwd

Vegeu també PWD i pwd.

HOME

Consulteu $HOME.

SHELL

Mostra quin és l'interpret d'ordres que estem utilitzant:

$ echo $SHELL
/bin/bash

PS1

Estableix el text (String) que apareix al PROMPT de la línia d'ordres quan la bash s'executa de forma interactiva.

NOTA: Tingueu en compte que el prompt és dinàmic, canvia segons la carpeta a la que estiguis o segons l'usuari que siguis, a més, és completament configurable.

Es pot modificar el PROMPT principal establint la variable d'entorn PS1.

$ export PS1="Què vols?" 
Què vols?asdasd
asdasd: command not found
Què vols?ls
carpeta1

Disposeu de les següents variables:

TODO: Traduir de l'anglès.

             \a     an ASCII bell character (07)
             \d     the date in "Weekday Month Date" format (e.g., "Tue May 26")
             \D{format}
                    the  format  is  passed to strftime(3) and the result is inserted into the prompt string; an empty format results in a locale-specific time representa‐
                    tion.  The braces are required
             \e     an ASCII escape character (033)
             \h     the hostname up to the first `.'
             \H     the hostname
             \j     the number of jobs currently managed by the shell
             \l     the basename of the shell's terminal device name
             \n     newline
             \r     carriage return
             \s     the name of the shell, the basename of $0 (the portion following the final slash)
             \t     the current time in 24-hour HH:MM:SS format
             \T     the current time in 12-hour HH:MM:SS format
             \@     the current time in 12-hour am/pm format
             \A     the current time in 24-hour HH:MM format
             \u     the username of the current user
             \v     the version of bash (e.g., 2.00)
             \V     the release of bash, version + patch level (e.g., 2.00.0)
             \w     the current working directory, with $HOME abbreviated with a tilde (uses the $PROMPT_DIRTRIM variable)
             \W     the basename of the current working directory, with $HOME abbreviated with a tilde
             \!     the history number of this command
             \#     the command number of this command
             \$     if the effective UID is 0, a #, otherwise a $
             \nnn   the character corresponding to the octal number nnn
             \\     a backslash
             \[     begin a sequence of non-printing characters, which could be used to embed a terminal control sequence into the prompt
             \]     end a sequence of non-printing characters
NOTA: Si és vol fer un canvi definitiu, possiblement modificareu els fitxers ~/.bashrc o /etc/bash.bashrc

Per a més informació podeu consultar la secció PROMPTING del manual de bash:

PS2

És tracta del prompt secundari que apareix quan es necessiten més dades per tal de completar una ordre.

El valor per defecte és ">":

$ echo $PS2
>

Podeu comprovar-ho per exemple amb una barra invertida al final de línia (indica que l'ordre continua a la línia següent):

$\
>

Canvieu el valor de la variable:

$ PS2="Què vols?"
$ \
Què vols?

O amb una canonada (pipe) incompleta:

$ echo prova |
Què vols?

O també ho podeu comprovar amb un heredoc:

$ cat <<EOF
Que vols?Hola!
Que vols?prova
Que vols?EOF
Hola!
prova

PS3

És el PROMPT que utilitza l'ordre select.

El directori de treball

Una de les variables d'entorn més importants és el directori de treball. El directori de treball és la carpeta on estem situats actualment. Cada sessió de terminal pot estar treballant en una carpeta diferent (en altres paraules, podem dir que l'entorn de treball no és exactament igual a cada sessió de terminal).

La variable d'entorn que guarda el directori de treball actual és PWD:

$ echo $PWD

PWD són les sigles de Print Working Directory. Existeix un ordre equivalent (pwd) que també ens permet consultar el directori de treball actual.

Per exemple si executeu:

$ cd
$ echo $PWD
/home/sergi

Us mostra la vostra carpeta d'usuari o HOME.

Cal tenir en compte que normalment el PROMPT de l'interpret d'ordres, sovint ja ens mostra el directori de treball actual.

cd. Modificar el directori de treball

Consulteu cd.

Directoris especials

Hi ha una sèrie de directoris que són especials i molt utilitzats, i que són coneguts per uns símbols especials:

Símbol Significat Descripció
. directori de treball. El punt sempre especifica el directori de treball. Pot semblar superflu o inútil però té força utilitats. Consulteu per exemple puntbarra.
.. El directori pare Indica un directori més amunt en l'estructura de directoris.
/ El directori arrel (root) És el directori principal i el de més amunt de l'estructura de directoris (el directori arrel no té directori pare). Recordeu que a Unix/Linux no hi ha unitats de disc (com C: o similars).
~ o la variable d'entorn HOME. Determina la carpeta principal de l'usuari. Cada usuari (excepte que s'especifiqui el contrari amb l'opció nologin) té una carpeta pròpia. Aquesta carpeta és anomenada la carpeta HOME (cada) o carpeta d'usuari.

Consulteu les ordres cd i pwd per tal de veure exemples d'ús d'aquests directoris especials.

Flux de dades (streams)

Consulteu flux de dades.

Redireccions

Consulteu redireccions.

tee

Consulteu tee.

Conductes (pipes)

Consulteu conductes.

Substitucions, expansions i construccions complexes de comandes

Podeu obtenir més informació al manual de bash

$ man bash

A la secció:

EXPANSION

o al manual de bash:

Expansió per claus {} (Brace expansion)

La millor forma d'entendre aquest tipus d'expansions és amb exemples:

 a{d,c,b}e equival a ade, ace i abe

O /usr/local/src/bash/{old,new,dist,bugs} equival a:

/usr/local/src/bash/old
/usr/local/src/bash/new
/usr/local/src/bash/dist
/usr/local/src/bash/bugs

Per tant, podem crear les quatres carpetes d'un sol cop amb:

$ mkdir /usr/local/src/bash/{old,new,dist,bugs}

La expansió per claus és la expansió prioritària (es realitza abans que cap altre expansió).

Altres exemples:

$ echo my.cnf{,.bak}
my.cnf my.cnf.bak
$ echo my.cnf{.bak,}
my.cnf.bak my.cnf
$ echo {1..3}{foo,bar}
1foo 1bar 2foo 2bar 3foo 3bar

Recursos:

Expansió per titlla

Consulteu ~.

Expansió o substitució de variables

El caràcter $ indica una variable o paràmetre i ens permet substituir el valor de la variable a la línia d'ordres.

La forma normativa d'utilitzar la expansió de variables és:

${NOM_VARIABLE}

tot i que també podem utilitzar:

$NOM_VARIABLE
NOTA: tingueu en compte que les claus permeten indicar on acaba la variable. Vegem un exemple:
$ PREFIX=in
$ echo $PREFIX
in
$ echo $PREFIXadaptat

no funciona correctament per que estem indicant la variables PREFIXadaptat

El correcte seria:

$ echo ${PREFIX}adaptat
inadaptat

Aquest mecanisme és el que ens permet consultar variables d'entorn:

$ echo $SHELL
/bin/bash

Podem establir el valor de la variable mentrestant fem la expansió:

$ echo $VARIABLE_QUE_NO_EXISTEIX
$ echo ${$VARIABLE_QUE_NO_EXISTEIX:=AraJaExisteix}
AraJaExisteix

Substitució de comandes. backsticks (cometes enrere) i parentesis

Un altre eina que ens permet fer substitucions són les cometes enrere. Si indiquem una comanda entre cometes enrere, el resultat d'aquesta comanda serà substituït a la línia de comandes. Per exemple:

$ rm `find ./ -name “*~”`

Esborrarà tots els fitxers acabats en ~.

NOTA: les cometes enrere es poden fer amb l'accent obert (intenteu fer l'accent dos cops).

Un altre exemple:

$ echo `date`
Thu Feb 6 11:07:20 CET 2009

Un altre opció és:

$(command)

En aquest cas tots els caràcters entre parèntesis s'interpretam tal qual. Amb les cometes enrere es poden utilitzar els caràcters especials com "$", "`", o "\".

Es poden concatenar comandes escapant les comentes enrere amb \.

Expansions aritmètiques

Aquest tipus de substitucions o expansions permeten avaluar expressions aritmètiques. El format és:

$(( EXPRESSION ))

Per exemple:

$ echo $((365*24))
8760

Cal tenir en compte que les expressions aritmètiques es realitzen amb enters de mida fixa.

Els operadors són molts similars als del llenguatge C:

Operador Descripció
VAR++ i VAR- post-increment i post-decrement de la variable VAR
++VAR i --VAR pre-increment and pre-decrement de la variable VAR
- i + sumes i restes unitaries
 ! i ~ negació lògica i negació binaria
** potència
*, / i % multiplication, division, remainder multiplicació, divisió i reste.
<< i >> bitwise shift (esquerre i dreta respectivament)
<=, >=, < i ><nowiki> | Operadors de comparació |- | <nowiki>| OR binari
^ OR exclusiva binaria
& AND binari
&& AND lògic
|| OR lògic
expr ? expr : expr avaluació condicional
=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^= and |= Assignacións
, Separador entre expressions

L'expressió és tractada com si estigues entre cometes dobles i es poden encavalcar expressions aritmètiques.

També es permeten variables de shell com a operands de les expressions i es poden utilitzat directament sense el símbol $ (la expansió de variables es realitza abans que la expansió aritmètica).

També es poden interpretar números en base diferent a la decimal (que és la base per defecte):

  • 0xNUMERO_HEXADECIMAL: números hexadecimals.
  • [BASE'#']: Qualsevol base entre 2 i 64

També es pot utilitzar, amb bash, la sintaxi:

$ [ EXPRESSION ]

Per exemple:

$ echo $[365*24]
8760

Recursos:

xargs

Consulteu xargs.

Comandes en segon terme. Operador &

Al executar un ordre com:

$ sleep 5

La terminal queda bloquejada fins que el procés acabi (sleep s'executa i no fa res durant els segons especificats). En aquest cas l'ordre s'executa en primer terme (foreground)

Es poden executar ordres amb segon terme (background) amb &:

$ sleep 5&
[1] 3202
$ 
[1]+  Done                    sleep 5

Llistes de comandes. Operadors ; o || &&

Una llista és una seqüència d'ordres que s'executen en una mateixa línia. Els operadors que ens permeten fer llistes són:

  • ;: és el mateix que executar les comandes separades per ; una a cada línia
  • &&: Operador AND.
  • ||:

El operador AND, funciona de la següent manera:

$ comanda1 && comanda 2

La comanda2 només s'executa sí i només si la comanda 1 s'acaba amb un codi d'acabada 0 (normalment indica sense errors). És dir totes dues comandes s'han d'executar correctament.

El operador OR, funciona de la següent manera:

$ comanda1 || comanda 2

La comanda2 només s'executa sí i només si la comanda 1 s'acaba amb un codi d'acabada diferent de 0 (normalment indica errors). Es tracta doncs, d'executar la comanda2 només si la comanda1 ha fallat (OR).

Per a més informació podeu consultar:

$ man bash

a la secció LISTS.

Estructures de control

TODO: Consultar a la resta de la wiki si no hi ha algun lloc on ja estigui fet.

Extret de la secció Compound Commands del manual de bash (man bash)

for name [ in word ] ; do list ; done
             The  list  of words following in is expanded, generating a list of items.  The variable name is set to each element of this list in turn, and list is executed
             each time.  If the in word is omitted, the for command executes list once for each positional parameter that is set (see PARAMETERS below).  The return status
             is  the exit status of the last command that executes.  If the expansion of the items following in results in an empty list, no commands are executed, and the
             return status is 0.
      for (( expr1 ; expr2 ; expr3 )) ; do list ; done
             First, the arithmetic expression expr1 is evaluated according to the rules described below under ARITHMETIC EVALUATION.  The arithmetic  expression  expr2  is
             then  evaluated repeatedly until it evaluates to zero.  Each time expr2 evaluates to a non-zero value, list is executed and the arithmetic expression expr3 is
             evaluated.  If any expression is omitted, it behaves as if it evaluates to 1.  The return value is the exit status of the last command in list  that  is  exe‐
             cuted, or false if any of the expressions is invalid.
      select name [ in word ] ; do list ; done
             The  list  of words following in is expanded, generating a list of items.  The set of expanded words is printed on the standard error, each preceded by a num‐
             ber.  If the in word is omitted, the positional parameters are printed (see PARAMETERS below).  The PS3 prompt is then displayed and  a  line  read  from  the
             standard  input.   If  the  line consists of a number corresponding to one of the displayed words, then the value of name is set to that word.  If the line is
             empty, the words and prompt are displayed again.  If EOF is read, the command completes.  Any other value read causes name to be set to null.  The  line  read
             is saved in the variable REPLY.  The list is executed after each selection until a break command is executed.  The exit status of select is the exit status of
             the last command executed in list, or zero if no commands were executed.
      case word in [ [(] pattern [ | pattern ] ... ) list ;; ] ... esac
             A case command first expands word, and tries to match it against each pattern in turn, using the same matching rules as for pathname expansion  (see  Pathname
             Expansion  below).   The word is expanded using tilde expansion, parameter and variable expansion, arithmetic substitution, command substitution, process sub‐
             stitution and quote removal.  Each pattern examined is expanded using tilde expansion, parameter and variable expansion, arithmetic substitution, command sub‐
             stitution,  and process substitution.  If the shell option nocasematch is enabled, the match is performed without regard to the case of alphabetic characters.
             When a match is found, the corresponding list is executed.  After the first match, no subsequent matches are attempted.  The exit status is zero if no pattern
             matches.  Otherwise, it is the exit status of the last command executed in list.
      if list; then list; [ elif list; then list; ] ... [ else list; ] fi
             The  if  list  is  executed.  If its exit status is zero, the then list is executed.  Otherwise, each elif list is executed in turn, and if its exit status is
             zero, the corresponding then list is executed and the command completes.  Otherwise, the else list is executed, if present.  The exit status is the exit  sta‐
             tus of the last command executed, or zero if no condition tested true.
      while list; do list; done
      until list; do list; done
             The while command continuously executes the do list as long as the last command in list returns an exit status of zero.  The until command is identical to the
             while command, except that the test is negated; the do list is executed as long as the last command in list returns a non-zero exit status.  The  exit  status
             of the while and until commands is the exit status of the last do list command executed, or zero if none was executed.

Paràmetres especials

Els podeu consultar a la subsecció:

Special Parameters

de la secció:

PARAMETERS
Paràmetre descripció
$* Conté tots els paràmetres posicionals $1, $2, $3, etc... s'utilitza en els scripts de shell per iterar els paràmetres de l'script
$@ Conté tots els paràmetres posicionals $1, $2, $3, etc... s'utilitza en els scripts de shell per iterar els paràmetres de l'script
$# Mostra el número de paràmetres posicionals
$? Mostra l'estatus de la pipeline executada de forma més recent en segon terme
$- Mostra les opcions actuals (similar a l'opció -i)
$$ Mostra l'identificador de procés de l'interpret d'ordres en execució.
$! Mostra l'identificador de procés de l'últim procés executat en segon terme

$ sleep 10& [1] 5208 $ echo $!

$0 Mostra el nom de l'script o de l'interpret d'ordres
NOTA: els paràmetres especials no es poden modificar, només es poden consultar

Vectors

Arrays
      Bash  provides  one-dimensional  array  variables.   Any variable may be used as an array; the declare builtin will explicitly declare an array.  There is no maximum
      limit on the size of an array, nor any requirement that members be indexed or assigned contiguously.  Arrays are indexed using integers and are zero-based.
      An array is created automatically if any variable is assigned to using the syntax name[subscript]=value.  The subscript is treated as an arithmetic  expression  that
      must  evaluate  to  a  number  greater  than  or  equal to zero.  To explicitly declare an array, use declare -a name (see SHELL BUILTIN COMMANDS below).  declare -a
      name[subscript] is also accepted; the subscript is ignored.  Attributes may be specified for an array  variable  using  the  declare  and  readonly  builtins.   Each
      attribute applies to all members of an array.
      Arrays are assigned to using compound assignments of the form name=(value1 ... valuen), where each value is of the form [subscript]=string.  Only string is required.
      If the optional brackets and subscript are supplied, that index is assigned to; otherwise the index of the element assigned is the last  index  assigned  to  by  the
      statement plus one.  Indexing starts at zero.  This syntax is also accepted by the declare builtin.  Individual array elements may be assigned to using the name[sub‐
      script]=value syntax introduced above.
      Any element of an array may be referenced using ${name[subscript]}.  The braces are required to avoid conflicts with pathname expansion.  If subscript is @ or *, the
      word expands to all members of name.  These subscripts differ only when the word appears within double quotes.  If the word is double-quoted, ${name[*]} expands to a
      single word with the value of each array member separated by the first character of the IFS special variable, and ${name[@]} expands each element of name to a  sepa‐
      rate  word.  When there are no array members, ${name[@]} expands to nothing.  If the double-quoted expansion occurs within a word, the expansion of the first parame‐
      ter is joined with the beginning part of the original word, and the expansion of the last parameter is joined with the last part of the original word.  This is anal‐
      ogous  to  the expansion of the special parameters * and @ (see Special Parameters above).  ${#name[subscript]} expands to the length of ${name[subscript]}.  If sub‐
      script is * or @, the expansion is the number of elements in the array.  Referencing an array variable without a subscript is equivalent to referencing element zero.
      The unset builtin is used to destroy arrays.  unset name[subscript] destroys the array element at index subscript.  Care must be taken to avoid unwanted side effects
      caused by filename generation.  unset name, where name is an array, or unset name[subscript], where subscript is * or @, removes the entire array.
      The declare, local, and readonly builtins each accept a -a option to specify an array.  The read builtin accepts a -a option to assign a list of words read from  the
      standard input to an array.  The set and declare builtins display array values in a way that allows them to be reused as assignments.

Variables de la shell

Consulteu la secció Shell Variables del manual de bash

Comandes

.

Consulteu #Directoris especials.

cd

En cada instant que estem treballant a l'interpret de comandes estem treballant en un directori específic del sistema. Aquest directori es coneix com a directori de treball. L'ordre cd ens permet modificar el directori de treball. Té la següent sintaxi:

cd [directory]

Tal i com podem veure si comprovem el seu manual:

$ man cd

que també podeu consultar a Internet a:

http://linux.die.net/man/1/cd

On:

  • [directory]: És el nou directori de treball

Per tal de fer referència a un fitxer o directori, tenim dos opcions:

  • Referència amb un camí (PATH) relatiu: el camí que indiqueu és relatiu al directori de treball en el que esteu actualment. Tots els camins que no comencen per / són relatius.
  • Referència amb un camí (PATH) absolut: el camí es relatiu a l'arrel del sistema de fitxers. L'arrel en sistemes Linux s'indica amb el símbol /.

Vegem alguns exemples. Si executem cd sense més opcions:

$ cd

Lo habitual és, si està definida la variable d'entorn $HOME, canviar al directori de treball de l'usuari (la seva HOME).

Si el directori especificat comença per barra (/), aleshores és un PATH absolut i el que fem es canviar a aquest directori (si existeix). Per exemple:

$ cd /home/pepe

Si el directori no comença per barra (/), aleshores és un camí relatiu i ens movem a la carpeta indicada des del directori de treball actual. Tingueu en compte la possibilitat d'utilitzar la variable d'entorn CDPATH.

L'ordre:

$ cd .

No canvia el directori de treball. També podem anar al directori pare amb:

$ cd ..

Cal tenir en compte que anar al directori pare pot ser una operació no clara quan hi ha [[[enllaços simbòlics]] de per mig. En aquest cas és quan l'ordre cd pot utilitzar elas paràmetres -L o -P (tractar els enllaços sinbòlics logicament o físicament respectivament).

També podem executar:

$ cd - 

Que equival a:

$ cd "$OLDPWD" && pwd

És a dir, es mou al anterior directori de treball (variable d'entorn OLPWD) i el mostra.

Per conèixer altres directoris importants, com l'arrel (/) o el punt (.) i els dos punts (..) consulteu #Directoris especials.

Consulteu també:

echo

Tal com indica el seu nom aquesta comanda repeteix/mostra per pantalla (eco) el text que li proporcionem. Per exemple:

$ echo Hola Mon!
Hola Mon!

És el típic exemple de com mostrar el text Hola Mon! per la sortida de l'interpret d'ordres.

Inicialment aquesta comanda pot semblar força inútil, però és molt útil en guions de l'interpret de comandes, ja que es tracta de la forma més bàsica de mostrar un text per pantalla.

També es pot utilitzar per tal de consultar el valor de variables d'entorn o altres variables. Per exemple, per tal de consultar la variable d'entorn PATH podem executar:

$ echo $PATH
/home/sergi/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Els caràcters especials ( *, $, \, ?,...) són interpretats per l'interpret de comandes abans de passar-los a l'ordre echo. Per evitar-ho s'utilitzen els següents caràcters;

  • cometes simples: Impedeixen la interpretació de tot el que hi ha inclòs entre les cometes simples. No confondre amb l'accent greu, que té una altra utilitat
  • cometes dobles: És permet la interpretació de $ (substitució pel seu valor), cometes simples, cometes dobles, i \ (barra invertida).
  • \: Elimina el significat del següent caràcter (només un)
metacaràcter significat
\a Alerta ( emet un so)
\b Backspace
\c Evita el salt de línia, com l'opció -n
\f Neteja la pantalla
\n Nova línia
\r Retorn de carro
\t Tabulació horitzontal

Per a que aquest caràcters d'escapament siguin interpretats haurem d'afegir l'opció -e

   echo -e “Hola a tots... \n”

Echo envia les dades directament a la sortida estàndard. Per utilitzar la sortida estàndard d'error a bash podeu utilitzar >&2:

  echo "Hi ha més d'un registre amb el DNI/NIE/Passaport: $CODE" >&2

Per no fer un salt de línia al final

$ echo -n prova

env

Consulteu variables d'entorn.

El manual diu:

$ man env
NAME
      env - run a program in a modified environment

SYNOPSIS
      env [OPTION]... [-] [NAME=VALUE]... [COMMAND [ARG]...]

Es a dir, permet executar una aplicació en un entorn modificat. La majoria de cops s'utilitza per consultar les variables d'entorn de Linux:

$ env
...
GNOME_KEYRING_SOCKET=/tmp/keyring-QkAu2b/socket
SSH_AUTH_SOCK=/tmp/keyring-QkAu2b/socket.ssh
SESSION_MANAGER=local/vlino-feina:/tmp/.ICE-unix/3637
USERNAME=vlino
DESKTOP_SESSION=default
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
GDM_XSERVER_LOCATION=local
PWD=/home/vlino
LANG=ca_ES.UTF-8
GNOME_KEYRING_PID=3624
GDM_LANG=ca_ES.UTF-8
GDMSESSION=default
HISTCONTROL=ignoreboth
SHLVL=1
HOME=/home/vlino
...

Es pot executar un guió de shell amb variables modificades:

$ env PATH=/bin guio.sh

Es poden establir múltiples variables:

$ env PATH=/bin GREETINGS="hola" guio.sh

Es poden desetablir certes variables amb el paràmetre -u:

$ env -u PATH guio.sh

O es pot executar un guió sense cap mena d'entorn heretat (l'entorn normalment s'hereta de la bash a la que executem el guió):

$ env -i guio.sh

Un cop establert l'entorn a zero es pot començar a establir variables d'entorn amb:

$ env -i PATH=/sbin guio.sh

Podeu obtenir més informació sobre l'ordre utilitzant l'ordre info:

$ info coreutils 'env invocation'

exec

La comanda exec executa un programa extern. Per exemple:

$ exec 

En la majoria de casos no és necessari utilitzar la comanda exec ja que normalment podem executar el programa desitjat escrivint simplement el seu nom (si l'executable és troba dins d'alguna de les carpetes especificades a la variable d'entorn PATH) o indicant el seu camí absolut o un camí relatiu correcte.

El programa exec té però una petita diferència. En comptes d'executar el programa indicat en un nou proces, el que fa es reemplaçar l'interpret de comandes per l'aplicació indicada. Així, quan el procés executat finalitza, la shell també finalitza (realment ha finalitzat des del moment en que hem executat el nou procés)

exit

Per finalitzar l'interpret de comandes podeu utilitzar l'ordre exit:

$ exit

En el cas que l'executeu en un emulador de terminal, l'aplicació (la finestra) es tancara. Hi ha emuladors de terminal com Gnome-terminal o Terminator entre d'altres que permeten tenir múltiples terminals obertes en una mateixa finestra utilitzant pestanyes. En aquest cas el que es tanca és la pestanya i no pas la finestra.

En el cas de terminals virtuals, la comanda exit el que fa es tornar a mostrar l'aplicació login, és a dir us permet tornar a entrar amb el mateix o un altre usuari.

NOTA: també podem finalitzar una sessió amb Crtl+d

export

Consulteu Establir variables d'entorn

pwd

Mostra el directori de treball actual (la carpeta a la que us trobeu):

$ pwd
/home/sergi

La comanda cd (change directory) ens permet modificar el directori de treball.) és la comanda que ens permet modificar el directori de treball. Per exemple:

$ cd /home/sergi/Documents

Ens canvia el directori de treball a:

/home/sergi/Documents

Cal tenir en compte que, en molts intèrprets de comandes, tindreu el PROMPT de l'interpret de comandes configurat per tal que us mostri el directori de treball al que us trobeu actualment. Per exemple, el següent prompt:

sergi@sergi-desktop:/var/lib$

Té la sintaxi:

usuari@nom_maquina:directori_de_treball$

I per tant us trobeu al directori:

/var/lib

Tal com podeu comprovar si executeu:

usuari@nom_maquina:directori_de_treball$ pwd
/var/lib
NOTA: En aquesta wiki, excepte en comptades excepcions només utilitzarem el símbol $ (dolar) per indicar el PROMPT de l'intèrpret de comandes. En els casos que 
l'usuari que ha d'executar la comanda sigui el root del sistema utilitzarem la comanda sudo en un prompt amb dollar ($) o canviarem el prompt a # (coixinet) 
que indica que estem treballant amb el superusuari.

Alguns directoris són especials i tenen símbols reservats, per exemple:

$ cd ~

Ens mou a la home del nostre usuari, tal i com podeu veure si us fixeu en el PROMPT o utilitzeu la comanda pwd:

sergi@sergi-desktop:~$
sergi@sergi-desktop:~$ pwd
/home/sergi
NOTA: Observeu que la home de l'usuari, al PROMPT, normalment s'indica amb el caràcter titlla en comptes del camí absolut.

Pwd és una ordre interna (built-in-command) de bash. Algunes de les ordres internes tenen una ordre externa equivalent que realitza la mateixa feina. Existeix una comanda externa similar a pwd però amb comportament diferent respecte als enllaços simbòlics. Consulteu Ordres que poden ser internes i externes.

set

Amb l'interpret d'ordres csh, serveix per establir les variables d'entorn. A bash però s'utilitza l'ordre export per establir les variables d'entorn a bash.

A bash, set serveix per configurar el funcionament de bash. No trobareu manual ja que es tracta d'una ordre interna i heu de consultar el manual de bash:

$ man bash

Sense opcions:

$ set 

Mostra tota la configuració de bash. També podeu utilitzar l'ordre interna shopt.

Per exemple podem configurar bash per treballar en mode emacs (per defecte):

$ set -o emacs 

O en mode vi:

$ set -o vi 

Per exemple una opció utilitzada de tant en tant és:

$ set -C

o

$ set -o noclobber

Que impedeix que un fitxer sigui sobreescrit al fer una redirecció (>).

NOTA: Un dels sentits de la paraula clobber en anglès és aixafar

La llista completa d'opcions extreta del manual de bash és:

                     allexport
                             Same as -a.
                     braceexpand
                             Same as -B.
                     emacs   Use an emacs-style command line editing interface.  This is enabled by default when the shell is interactive, unless the shell is started with
                             the --noediting option.  This also affects the editing interface used for read -e.
                     errtrace
                             Same as -E.
                     functrace
                             Same as -T.
                     errexit Same as -e.
                     hashall Same as -h.
                     histexpand
                             Same as -H.
                     history Enable command history, as described above under HISTORY.  This option is on by default in interactive shells.
                     ignoreeof
                             The effect is as if the shell command ``IGNOREEOF=10 had been executed (see Shell Variables above).
                     keyword Same as -k.
                     monitor Same as -m.
                     noclobber
                             Same as -C.
                     noexec  Same as -n.
                     noglob  Same as -f.
                     nolog   Currently ignored.
                     notify  Same as -b.
                     nounset Same as -u.
                     onecmd  Same as -t.
                     physical
                             Same as -P.
                     pipefail
                             If set, the return value of a pipeline is the value of the last (rightmost) command to exit with a non-zero status, or zero if all commands in
                             the pipeline exit successfully.  This option is disabled by default.
                     posix   Change the behavior of bash where the default operation differs from the POSIX standard to match the standard (posix mode).
                     privileged
                             Same as -p.
                     verbose Same as -v.
                     vi      Use a vi-style command line editing interface.  This also affects the editing interface used for read -e.
                     xtrace  Same as -x.


Recursos:

set -e

If you write shell scripts, you definitely need to know about two nice features that can be enabled through the set builtin:

  • set -e: Enables checking of all commands. If a command exits with an error and the caller does not check such error, the script aborts immediately. Enabling this will make your scripts more robust. But don't wait until your script is "complete" to set the flag as an afterthought, because it will be a nightmare to fix the scrip to work with this feature enabled. Just write set -e as the very first line of your code; well... after the shell bang.

set -x

  • set -x: If you are writing simple scripts that are meant to, well, script the execution of a few tasks (as opposed of being full-flown programs written in shell), set this flag to trace the execution of all commands. This will make the interpreter print each command right before it is executed, so it will aid you in knowing what is happening at any point in time.

unset

Consulteu Esborrar una variable d'entorn.

logout

Serveis per finalitzar les terminals virtuals i tornar a mostrar el login. Només es pot utilitzar en interprets de comandes que s'han iniciat amb login. Si l'executeu en un emulador de terminal, tindreu el següent resultat:

$ logout
bash: logout: not login shell: use `exit'

També podem utilitzar la comanda exit per finalitzar qualsevol tipus de terminal.

man

Consulteu l'article man.

uname

Consulteu l'article uname

time

Consulteu l'article time.

history

Consulteu l'article History.


type

L'ordre type és una ordre interna de bash que us mostra informació sobre els tipus d'ordres. Segons els manual, indica com serà interpretat un text si s'utilitza com a ordre. Vegem alguns exemples:

$ type cd
cd is a shell builtin

$ type ls
ls is aliased to `ls --color=auto'
$ type cp
cp is /bin/cp

$ type pwd
pwd is a shell builtin
$ type /bin/pwd
/bin/pwd is /bin/pwd

Consulteu l'apartat:

 ordres internes i ordres externes

per obtenir més detalls sobre els tipus d'ordres.

Type no té manual propi, heu de consultar el manual de bash:

$ man bash | grep -A 20 "type \["
      type [-aftpP] name [name ...]
             With  no  options,  indicate  how each name would be interpreted if used as a command name.  If the -t option is used, type prints a 
             string which is one of alias, keyword, function, builtin, or file if name is an alias, shell reserved  word,  function,  builtin,  or  
             disk  file, respectively.   If the name is not found, then nothing is printed, and an exit status of false is returned.  If the -p 
             option is used, type either returns the name of the disk file that would be executed if name were specified as a command name, or 
             nothing if  ``type  -t  name would  not return file.  The -P option forces a PATH search for each name, even if ``type -t name would 
             not return file.  If a command is hashed, -p and -P print the hashed value, not necessarily the file that appears first in PATH.  If the 
             -a option is used, type  prints  all of  the  places that contain an executable named name.  This includes aliases and functions, if and 
             only if the -p option is not also used.

             The table of hashed commands is not consulted when using -a.  The -f option suppresses shell function lookup, as with the command  
             builtin.
             type returns true if all of the arguments are found, false if any are not found.
...

Consulteu també:

alias

clear

$ clear

Neteja la terminal, tornant a mostra el prompt a dalt de tot de la finestra de la terminal.

Es pot fer un clear amb la combinació de tecles Ctrl+l

reset

L'ordre reset torna a configurar la terminal. Útil quan la terminal queda blocada per caràcters estranys. Per exemple si consulteu el fitxer binari:

$ cat /etc/alternatives/vi

Us apareixeran caràcters estranys i la terminal us quedarà desconfigurada. Escriviu reset (encara que no ho vegeu) i premeu enter per recuperar la terminal.

Alias d'ordres

NOTA: Aquest apartat fa referència a l'ordre alias, si voleu consultar els alias de Ldap aneu a Ldap#Soft_links_.28alias.29

L'ordre interna alias defineix abreviacions d'ordres. Per exemple es pot utilitzar per assegurar-se que certes ordres s'executen amb paràmetres concrets:

#------------------------------------------------------------------------------
# Security.
#------------------------------------------------------------------------------
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
alias ln='ln -i'

O forçar que ls treballi sempre amb colors:

$ alias ls='ls --color=auto'

Podeu consultar els alias que esteu utilitzant executant alias sense paràmetres:

$ alias
alias ls='ls --color=auto'
...

Es pot desfer un alias amb unalias:

$  unalias rm

Vegeu també l'ordre interna type i com us permet conèixer si s'apliquen alies a un ordre:

$ type ls
ls is aliased to `ls --color=auto'

Es pot executar un ordre sense utilitzar els alias que té actius posant una contrabarra davant. Per exemple per no mostrar els colors de ls:

$ \ls

Diferents sistemes d'ordres

  • Unix98 --> Sistema de paràmetres d'un sol caràcter
  • GNU --> Proposa que les opcions siguin paraules (--palabra)
  • BSD--> Lletres sense guió

Exercicis

TODO!


1. Log in as an ordinary user. 2. Create a temporary directory by typing mkdir test. (Directory and file manipulation

   commands are described in more detail in Chapter 4.)

3. Change into the test directory by typing cd test. 4. Create a few temporary files by typing touch one two three. This command creates

   three empty files named one, two, and three.

5. Type ls -l t, and without pressing the Enter key, press the Tab key. The system may

   beep at you or display two three. If it doesn’t display two three, press the Tab key
   again, and it should do so. This reveals that either two or three is a valid completion
   to your command, because these are the two files in the test directory whose file-
   names begin with the letter t.

6. Type h, and again without pressing the Enter key, press the Tab key. The system

   should complete the command (ls -l three), at which point you can press the Enter
   key to execute it. (You’ll see information on the file.)

7. Press the Up arrow key. You should see the ls -l three command appear on the

   command line.

8. Press Ctrl+A to move the cursor to the beginning of the line. 9. Press the Right arrow key once, and type es (without pressing the Enter key). The

    command line should now read less -l three.

10. Press the Right arrow key once, and press the Delete key three times. The command

    should now read less three. Press the Enter key to execute the command. (Note
    that you can do so even though the cursor isn’t at the end of the line.) This invokes
    the less pager on the three file. (The less pager is described more fully later, in
    “Getting Help.”) Because this file is empty, you’ll see a mostly empty screen.

11. Press the Q key to exit from the less pager.

Vegeu també

Gestió de Fitxers:

Els apunts d'Eva Domínguez:

https://svn.projectes.lafarga.cat/svn/iceupc/IntroduccioLinux/apuntsEvaDominguez/

Concretament consulteu:

https://svn.projectes.lafarga.cat/svn/iceupc/IntroduccioLinux/apuntsEvaDominguez/UD_8_2_comandes_inicials.pdf

Enllaços externs

OpenFPnet
IES Nicolau Copèrnic