Referencia vim

Una chuletilla de VI iMproved (vim)

La mejor forma de entender qué hace cada cosa es… probándola 😉

Desplazamiento

  • Letra a letra: h / j / k / l
  • Palabras: inicio de palabra w / b, final e / ge
  • Comienzo / final línea: ^ / $
  • Letra dentro de una línea: fx / Fx
  • Avance en páginas: Ctrl-F / Ctrl-B
  • Paréntesis (o llave o corchete) asociado: %
  • Línea del fichero: xG / 😡 (G / :$ va directo al final del fichero), x% (porcentaje del fichero)
  • Saltos: Ctrl-O / Ctrl-I
  • marcas: mx, ‘x (marcas en minúscula son locales al fichero actual, en mayúscula permiten navegar por diferentes ficheros)

Información

  • :set number / nonumber: mostrar número de línea

Búsquedas

  • /patron ,  ?patron . n (siguiente aparición) \< y \> representan el comienzo y final de una palabra (para buscar palabras completas)
  • /patron/+2 -> la segunda linea despues de patron
  • :set ignorecase
  • :set hlsearch (destacar apariciones)
  • Palabra actual: * /  #
  • Reemplazar -> :%s_patron_sustitucion_g (cambiando g por c pide confirmación)
  • global -> :[rango]g/patron/comando – aplica comando en las lineas que dentro de rango coinciden con patrón
  • :grep -> buscar en varios ficheros. :cn mueve a la siguiente aparición
  • [I: -> mostrar las definiciones en ficheros incluidos que coinciden con la función actual

Insertar texto (i): I / A. Pulsando Ctl+n autocompleta en base a las palabras que haya en el documento.

Digrafos (Ctl+k): permiten introducir caracteres no soportados por defecto. Por ejemplo, ã sería Ctl+k ~ a

Abreviaturas

:ab sr señor

Asociar teclas

:map! â \^{a}

(map! aplica a los modos inserción y línea de comandos, map a normal, visual y selección)

Borrar (d). El texto borrado se lleva a un buffer (algo así como “Cortar”)

  • dl (x), dh (X)
  • dw
  • dd
  • d$ (D)
  • di< / dit borrar tag-blocks (util para HTML / XML)
  • text-objects: borrar cadenas entre comillas (di”), entre llaves (diB), paréntesis (dib)

Cambiar (c) / Sustituir (r)

  • cl (s)
  • cw
  • cc (S)
  • c$
  • R
  • Repetir el último cambio: .
  • cambiar mayúsculas / minúsculas: ~ (se puede usar con un bloque visual)

Deshacer (u), rehacer (Ctrl-R), :earlier 5m (volver al estado del fichero hace 5 minutos)

Formato de líneas:

Las variables tw y fo controlan el ajuste automático de línea. Por ejemplo, para 90 columnas:

:set tw=90
:set fo+=t
# Para desabilitar el ajuste, usar set fo-=t

Si el texto ya está insertado, se puede ajustar párrafo a párrafo con el comando gqap

Modo visual:

  • letra a letra (v), líneas (V), rectángulo/columnas (Ctrl-V), cambio de lado (o)
  • rx: rellena el bloque con la letra x
  • > / < : indenta el bloque
  • text objects: vi’, viB, vib…

El modo columna (Ctrl-V) es util para indentar con espacios, o para eliminar el principio de varias lineas que comienzan con el mismo texto.

Copiar (y): yw, yy; “*yy (portapapeles).

Pegar (Colocar): p/P, “*p (portapapeles),

Registros: “xyy (copiar al registros x), “xp (pegar registro x), “xd (cortar al registro x). Los registros numerados contienen un histórico automático de lo que se ha copiado con yy a secas. Por ejemplo, “0p pega lo último copiado. :reg muestra los registros. Más sobre registros.

Destaque de sintaxis:

  • :syntax enable

Autocompletado

  • “omni”: ctl-x ctl-o

Ficheros:

  • (:w)rite, :wall
  • (:q)uit, :qall
  • :wq, :wqall
  • (:n)ext file
  • (:p)revious file

Edición varios ficheros a la vez: ventanas y pestañas

  • :next, :previous, Ctl-^
  • :split, vim -O / :vsplit : división horizontal / vertical (mismo fichero). Para desplazarse simultaneamente en las ventanas, hay que ejecutar :set scrollbind en cada una
  • Ctrl-w Ctrl-w: cambiar de ventana en secuencia
  • Ctrl-w h / j / k / l : desplazarse de una ventana a otra
  • Ctrl-+ / Ctrl– : cambiar tamaño ventana
  • :tabedit, :tab split, vim -p
  • gt: cambiar de pestaña en secuencia, :tabp / Ctrl-RePag, :tabN / Ctrl-AvPag
  • :close

Macros

  • qxcomandosq: grabar macro en registro x (los mismos de más arriba)
  • @x: ejecutar macro x
  • @@: ejecutar última macro

Plugins interesantes:

  • pathogen: gestor de plugins
  • syntaxtic: corrección de errores en codigo
  • CtrlP: busqueda por ficheros

Atajos teclado tmux

Tmux, reencarnación moderna de screen digna de ser probada.

Los atajos deben precederse con Control-b (puede cambiarse, por ejemplo al clásico Control-a de screen).

Por ejemplo, para cambiar de panel (atajo “o”), tendríamos que teclear “Control-b o”

Algunos atajos interesantes que vienen “de serie” son…

? “ayuda” (lista de atajos en uso)
c crear ventana
% dividir ventana actual en dos paneles verticales
número ir a ventana (por número 😉 )
, renombrar ventana actual
[ cambiar a modo selección (según modo de edición. Por defecto, )
] pegar lo copiado en el modo selección (por defecto, “copiar y pegar” sólo funciona “localmente”, es decir, entre sesiones de tmux en un mismo ordenador)
p / n ventana anterior / siguiente
o siguiente panel
; último panel
q lista de paneles (se puede elegir uno tecleando su número)
z “maximizar” panel (zoom)
M-cursor cambiar tamaño panel
M-1..M-5 Elegir distribución: equitativa horizontal (1) o vertical (2), en celdas (5)
espacio cambiar disposición paneles ventana actual (horizontal/vertical)
w lista de ventanas.
r redibujar
& matar ventana actual
d desconectar de la sesión tmux (se puede reconectar ejecutando tmux attach)
: prompt para ejecutar comandos, por ejemplo source-file ~/.tmux.conf (recargar configuración después de modificarla)

Para usar el portapapeles de las X, hace falta añadir en ~/.tmux.conf algo del estilo…

# "pegar" desde portapapeles X a buffer tmux
bind C-y run "tmux set-buffer \"$(xclip -o)\"; tmux paste-buffer"

# "copiar" desde buffer tmux a portapapeles X

# opción A: usar C-b C-w para copiar al portapapeles lo que se ha copiado en el "modo copia"
# con "xclip -i", tmux deja de responder al prefijo...
# bind C-w run "tmux save-buffer - | xsel -i -b"

# opción B: dentro del "modo copia", reutilizar el atajo M-w para copiar en el portapapeles X
bind -t emacs-copy M-w copy-pipe "xsel -i -b"

xclip por defecto usa el portapapeles “primario” (el de el botón medio del ratón), por eso si queremos usar el portapapeles “moderno” (el de “Control-C Control-V”) hay que especificárselo con “-selection c”. Más sobre xclip…

Sugerencia: usar xsel en vez de xclip con tmux

Los atajos se pueden definir en la tabla global, con “bind”, o en una tabla en concreto, con “bind -t”

Depurar código con gdb


> gdb programa

# especificar los argumentos del programa
run argumentos

# se pueden especificar puntos de parada usando fichero y linea,
# el nombre de una funcion, o clase y método
break fichero.c:linea
break nombre_funcion
break clase::metodo

# listado de puntos de parada
info breakpoints

# eliminar punto de parada X
delete breakpoint X
# eliminar todos
delete breakpoints

watch
awatch 

# Inspeccionar variables
display variable
print variable

# mostrar codigo fuente "alrededor" de la línea en ejecución
list 

# Control de ejecución
# siguiente linea, sin entrar en la llamada (atajo: "n")
next
# siguiente, entrando dentro de la llamada (atajo: "s")
step
# proseguir (atajo: "c")
continue

# Imprimir la pila de llamadas (atajo: "bt")
backtrace

#Recorrer la pila de llamadas
up

# gdb también permite "tracear" el código, con los "tracepoint commands"

Recuperar contactos iPhone

Al sincronizar con iTunes por defecto se hace una copia de seguridad automática de los datos del iPhone, incluyendo los contactos. Pero a veces ocurre que al restaurar esa copia de seguridad los contactos no se restablecen.

En esos casos no todo está perdido: se puede acceder a los contactos del backup siguiendo los siguientes pasos:

  • Abrir el fichero 31bb7ba8914766d4ba40d6dfb6113c8b614be442.mddata (que está dentro del backup que hace iTunes) con sqlite3
  • Configurar la salida de sqlite con los comandos “.header on”, “.mode csv” y “.output contactos.csv”
  • Ejecutar la siguiente consulta en sqlite: “select First, Last ,Organization, Department, Note, ABMultiValue.value from ABPerson, ABMultiValue where ABMultiValue.record_id = ABPerson.ROWID;”
  • Salir (“.quit”)

Con esto tendremos en el fichero contactos.csv un volcado de los contactos según se guardaron en el backup. A partir de aquí se puede procesar ese fichero para adaptarlo al formato de la herramienta que vayamos a usar para introducirlos de nuevo en el iPhone (Google Contacts, Address Book, Outlook…)

Como siempre, es mucho más sencillo hacer múltiples backups antes del desastre que intentar restaurar datos después del desastre. Por eso es conveniente habilitar la sincronización de los contactos con algún programa externo (nuevamente Outlook, Address Book, Google Contacts o similares) y hacer copias de seguridad tanto del iPhone como de los datos de esos programas extrernos (Google Contacts permite exportar los contactos en formato csv y vcal)

Configuración interfaces de red en Debian

# The loopback network interface
auto lo
iface lo inet loopback

# interfaz principal
auto eth0
iface eth0 inet dhcp

auto eth1
iface eth1 inet static
        address 192.168.33.34
        netmask 255.255.255.0
        network 192.168.33.0
        broadcast 192.168.33.255
        gateway 192.168.33.1
        # dns-* options are implemented by the resolvconf package, if installed
        dns-nameservers 192.168.33.1 8.8.8.8
        dns-search my.domain.com

Restablecer arranque Windows 7

Las herramientas de recuperación integradas en el disco de instalación de Windows 7 ofrecen la opción de intentar reparar automáticamente el arranque de Windows.

A veces esa opción no consigue recuperar el arranque. En estos casos, aún quedan algunas opciones antes de reinstalar desde cero.

Si hemos tomado la precaución de crear una imagen del sistema, podemos recuperarla con estas mismas herramientas de recuperación. Hay que tener cuidado, ya que en este proceso se pueden perder datos (la imagen del sistema se “sobreescribe” en la partición destino). Además, todo volverá al estado en que se encontraba en la fecha en que se tomó la imagen (lo cual puede ser bueno o malo :-p )

Otra posibilidad es usar la línea de comandos, desde las herramientas de recuperación.

No están disponibles todos los comandos de shell de Windows 7, pero sí varios que resultan útiles en estas situaciones de rescate: bootrec.exe, chkdsk, diskpart, sfc, bcdedit…

Comandos útiles diskpart:

help
list disk
list partition
select disk 
select partition
active
delete partition

Con la siguiente secuencia de comandos se comprueba la partición de sistema (generalmente, C:, en nomenclatura Windows / DOS), se restablece el sector de arranque y se regenera el menú de arranque.

chkdsk c:
bootrec /FixMbr
bootrec /FixBoot
bootsect.exe /nt60 all /force
bootrec.exe /rebuildbcd

Si se han perdido / corrompido archivos de sistema, puedes recurrir a sfc:

sfc /scannow /offbootdir=c:\ /offwindir=c:\windows

Ampliación disco duro: clonar particiones Windows Linux

Al poner un disco duro más grande en el ordenador nos suele interesar conservar todo lo que teníamos en el anterior disco, tanto datos como sistema operativo y aplicaciones.

En el mercado hay infinidad de soluciones para “clonar” discos duros. Aunque a veces funcionan estupendamente, otras veces fallan o se eternizan. Sobre todo, en esquemas mixtos que mezclan particiones de Linux y de Windows, o incluso volúmenes LVM.

Por eso, el protocolo que suelo utilizar es algo más manual:

  1. Arrancar Linux con un Live CD (o DVD). Recrear la tabla de particiones (incluyendo volúmenes lógicos, si los hay) en el nuevo disco, usando fdisk o parted
  2. Particiones Linux: “formatearlas” en el nuevo disco, con el mismo sistema de ficheros. Después, basta con copiar todos los ficheros (por ejemplo, con el estupendo rsync)
  3. Particiones Windows: lo más fácil para clonar la partición de sistema Windows es usar una herramienta específica, como puede ser Clonezilla o EaseUs Diskcopy (ambas gratuitas). Diskcopy no permite crear particiones sobre la marcha. Si el disco origen sólo tiene un par de particiones Windows, no pasa nada: al seleccionar el espacio sin particionar como destino, Diskcopy crea automáticamente una nueva partición idéntica a la original. Si no nos conviene copiar todas las particiones originales secuencialmente, nos quedamos “desamparados”. De ahí que resulte más práctico particionar el nuevo disco antes de usarlo. Así, podemos elegir origen y destino cómodamente

Para aprovechar el espacio extra, podemos ampliar las particiones del nuevo disco. En el caso de Linux es trivial, ya que la copia la hacemos con herramientas básicas como rsync. Con lo cual, no hace falta que las particiones origen y destino tengan el mismo tamaño.

En el caso de particiones Windows, dependemos de la potencia de la herramienta. Clonezilla, por ejemplo, permite clonar a una partición más amplia. En cualquier caso, una forma de hacerlo es: al particionar el nuevo disco, crear la partición destino con el mismo tamaño que la origen, pero dejando espacio detrás. Una vez clonada, se puede cambiar el tamaño de la partición con herramientas como gparted. Aunque esté formateada como NTFS, amplia tanto el tamaño de la partición en sí como el del sistema de ficheros, con lo que al arrancar Windows reconoce perfectamente la unidad con el nueva tamaño.

Antes de dar el cambiazo definitivo, otro punto clave es replicar el gestor de arranque. Si utilizamos grub, basta con reinstalarlo a mano. Si queremos que se encargue Windows, podemos recurrir a las herramientas de recuperación del CD de instalación de Windows.

Awk

Límites numéricos de awk: mawk parece que tiene la impresión de enteros limitada a 32 bits con signo, mientras gawk no:

> mawk '{a=11111111111111111111+10; printf "%d", a}'
2147483647
> gawk '{a=11111111111111111111+10; printf "%d", a}'
11111111111111110656

En general, la aritmética de awk es en IEEE double (de ahí el error en la suma al pasar a enteros)

> mawk '{a=11111111111111111111+10; print a}'
1.11111e+19
> gawk '{a=11111111111111111111+10; print a}'
11111111111111110656

Observamos también que por defecto gawk evita el formato científico para imprimir enteros.

Bash

Aspectos básicos

“Depurar” código bash

Lo más directo es habilitar las trazas mediante el parámetro -x de bash (equivalente a la opción xtrace). Se puede refinar definiendo algunas variables:

# xtrace -> imprimir trazas
set -o xtrace
# version abreviada de la linea anterior
set -x
# noglob -> impedir el procesamiento de metacaracteres en nombres de fichero ("globbing")
set -o noglob
set -f  
# verbose -> imprimir las líneas de código según se van leyendo
set -o verbose 
set -v  
# nounset -> abortar al intentar usar una variable no definida
set -o nounset
set -u
# cambiando la variable PS4 se puede personalizar las trazas. Por ejemplo, añadir el número de línea
export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'

Variables

Valores por defecto: con “:-” se asigna el valor a la variable. Con “:=” simplemente se retorna el valor por defecto (cuando la variable no tiene valor), esto es, no se modifica la variable.

login="pepe"
export login="pepe"
echo ${login}
echo ${login:=login no definido}
echo ${login:-invitado}

Cadenas

linea="tres tristes"
linea+=" tigres"
echo ${linea}

# Subcadenas
${linea:posicion:longitud}
${linea: -posicion:longitud} # ojo al espacio antes de "-", es importante

# Eliminar subcadenas
f="/usr/lib/libkewl.so" 
# borrar por el principio
${linea#*/}  # elimina la subcadena de menor longitud, comenzando por el principio
${linea##*/} # elimina la subcadena de mayor longitud
# borrar por el final
${linea%/*}  # elimina la subcadena de menor longitud, comenzando por el final
${linea%/*}  # elimina la subcadena de mayor longitud, comenzando por el final

# Sustitucion
${linea/patron/sustitucion} # primera aparicion
${linea//patron/sustitucion} # todas apariciones

# Longitud cadena
${#string}
expr length $string

# tests con cadenas
# cadena vacia / no vacia
[ -z "${s1}" ]  # cadena vacia
[ -n "${s2}" ]  # cadena no vacia

# Pertenencia
[[ "${linea}" == *tristes* ] ]

# Split / join
# usando sustitución
readonly DIR_SEP="/"
array=(${f//${DIR_SEP}/ })
second_dir="${array[1]}"
# usando IFS
hora="HH:MM:SS"
IFS=":" read -ra campos <<< "${hora}" 
# Para agrupar palabras en una linea (por ejemplo, con nombres que incluyen espacios), cambiar el separador IFS a \n (escapandolo con $):
IFS=$'\n'

Control de flujo

Condiciones: dentro de [ ] para seguir el estándar POSIX (“clásico”). Para usar las bondades de la extensión del estándar, meter la condición dentro de [[ ]].

También se puede comparar directamente el código de retorno (sin corchetes)

Operadores “clásicos”:

  • ==, != comparacion cadenas, -z longitud cero, -n longitud no cero
  • -f fichero, -d directorio, -r lectura, -w escritura, -x ejecutable
  • -eq -gt -lt -ne -ge -le: comparacion numerica

Operadores de la extensión del estándar:

  • =~ expresiones regulares
if [ cond ]; then
        b1
elif [[ "${linea}" == *tristes* ] ]; then
        b2
elif grep -qF "string" file; then
    echo 'file contains "string"'
else
        b3
fi

for x in SECUENCIA; do
   echo $x
done

case PATTERN in
        p1)
        ;;
...
        pm)
        ;;
        *)
        ;;
esac

Aritmética

Tradicionalmente se hacían con expr o bc, pero hoy en día suele ser más práctico usar los “dobles paréntesis”:

(( a ++ ))
(( x = a>3?1:0 ))

# si queremos hacer la asignación fuera de los dobles paréntesis,
# hay que añadir un dolar:
Z=$(( x + 4 ))

# número aleatorio
x=$RANDOM

# módulo
let "x %= 100"

Límites numéricos de bash (ver también los límites de awk)

Vectores (arrays)

Empiezan en 0

#operaciones basicas
a[3]=X
echo ${a[3]}
# longitud
${#arrayname[@]}
# se puede crear un array facilmente con ():
a=(1 2 3 4)

Se puede asignar tal cual una “lista” separada por espacios:
declare -a nombres
nombres=(paco pablo pato)

Esto se puede combinar con la sintaxis “salida de un comando”, $(), para llegar al combo ($( )):

nombres=($(ls))

Patrón “lista de directorios”

for d in $(ls -d */); do
...
done

Patrón “glob” (operar recursivamente partiendo de un directorio)

find d -exec cmd1 {} \; -exec cmd2 {} \;

Patrón “fichero de configuración”

En bash, es preferible escribir el fichero de configuración en bash y “cargarlo” con source (o su abreviatura, “.”), a usar otra sintaxis y tener que parsearlo como texto…

Patrón “procesamiento de patrones”

Con el operador =~ es bastante simple:

# para no tener que escapar la expresion regular, lo mejor es meterla en una variable
my_regex="([[:alpha:][:blank:]]*)- ([[:digit:]]*) - (.*)$"

if [[ "$CDTRACK" =~ ${my_regex} ]]; then
        echo Track ${BASH_REMATCH[2]} is ${BASH_REMATCH[3]}
        mv "$CDTRACK" "Track${BASH_REMATCH[2]}"
fi

# BASH_REMATCH contiene los emparejamientos de la ultima expresion regular

Patrón “diccionario”

Los diccionarios se conocen en bash como “arrays asociativos”

# -A -> array asociativo
declare -A rutas
rutas[pepe]="/users/g1/pepe"
clave="pepe"
echo ${rutas[${clave}]}
rutas=([marcos]="/users/g1/marcos")
rutas+=([lucas]="/users/g3/lucas")
# asignación múltiple
rutas([pedro]="/users/g2/pedro" [antonio]="/users/g1/antonio")
# clave con espacios
rutas["jose luis"]="/users/tic/jl"
echo ${rutas[antonio]}
ruta=${rutas[antonio]}
# todos los valores
echo ${rutas[@]}
# todas las claves
echo ${!rutas[@]}

# patrón "imprimir diccionario"
for usuario in "${!rutas[@]}"; do
    echo "${usuario} ${rutas[$user]}"
done

Redirecciones

Redirección básica: salida (“>”), entrada (“<") Añadir: ">>”

“Triple redireccion”: pasa una cadena por la entrada estándar

echo 1234X-D | sudo joe -c “passwd”
sudo joe -c “passwd <<< 1234X-D" Usar procesos en vez de ficheros (Process substitution) Con <() se conecta la entrada estándar de un comando con la salida estándar de los comandos dentro de los paréntesis. Sustitución de comando por su salida: [code] # clasica FILES=`ls` # contemporanea en linea. Ventajas: se pueden anidar varias FILES=$(ls) # contemporanea a array (Asignar el resultado a un array) FILES=($(ls)) [/code] # Añadir una cabecera a una lista para que column formatee la cabecera y la lista column -t <(echo "Permisos i user group count fecha hora nombre") <(ls -l | sed 1d) # Opciones: >() o <() (sin espacio entre el < o el > y los parentesis)
comm <(ls -l) <(ls -al)

“Punteros”

p=x
x=2
# Imprime x
echo $p
eval p=\$$p
# Imprime 2
echo $a

Paralelismo

El clasico “&” y los coprocesos (coproc)

Expresiones estilo C

# Solo operacion (no se usa el valor de retorno)
(( a = 20 )) # mantener todos los espacios
(( a ++ ))
(( x = a>3?1:0 ))
echo $x # imprime 1
# Para valor de retorno hay que añadir $
Z=$(( x + 4 ))

Patrón “procesar parámetros”

* Procesar parametros del script con getopts
# El primer parametro es la lista de switches que se aceptan, un “:” despues de una letra indica que ese
# switch acepta un parametro, por ejemplo -b hola
while getopts “:ab:cd” Option
do
case $Option in
b) echo “b” parameter is $OPTARG

esac
done

* Secuencias de números
for i in `seq 1 20`…
for i in {1..20}…
# Con ceros delante
for i in `seq -f %03.0f 1 10`…
for i in `printf ‘%03d ‘ {0..123}`…

Proceso de texto

Leer líneas

Bash FAQ 001

read / mapfile / readarray

cat fichero | while read -r linea; do
   echo "${linea}"
done
# fuera del bucle, la variable linea no está accesible
echo ${linea}

# readarray funciona como un alias de mapfile
declare -a lineas
mapfile lineas < fichero
echo ${lineas[1]}

En ambos casos, ojo con las subshells

Patrón “leer columnas”

# con read
# ojo: como las tuberías crean subshells, 
# no se puede acceder desde fuera del bucle a las variables leidas...
cat fichero | while read C1 C2 C3; do
   echo $C2
done

Declarando una variable como array, es “facil” sacar los campos de una linea en bash:

declare -a TEST
TEST=(a b c d)
echo ${TEST[0]}
# a
TEST=(1 b c d)
echo ${TEST[0]}
# 1
# Con triple redireccion:
read C1 C2 <<< "Campo1 Campo2"
# O bien, usar la redireccion simple, en lugar de un pipe:
while read C1 C2; do .... done < fichero

Curiosidades

Hidden features of bash

Mis favoritas:

  • Alt + . (último parámetro)
  • ${SECONDS}
  • ${RANDOM}
  • TMOUT

Operaciones con conjuntos en shell

Bash one-liners

Página principal GNU Bash

Bash hackers Wiki

Bash FAQ (en “Greycat’s Wiki”)

Documentación sobre Bash en StackOverflow Documentation

sed

Expresiones regulares en sed: para usarlos como metacaracteres, hay que “escapar” +, (, ), ?

“ak* \+xx\?” -> “akkk xx3”

Sustitución reutilizando el patron

# Caso sencillo: 1 solo patron. Se puede usar &:
# Añadir parantesis a cada secuencia de numeros
sed 's/[0-9]*/(&)/'

# Para varios patrones, se marcan los patrones a reutilizar con parentesis,
# y se utiliza \1, \2 para referenciar cada patron encontrado:
# Intercambiar el primer campo con el segundo. Por ejemplo, Type: abc-123 se convierte en Type: 123-abc
sed 's/Type: \([a-z]*\)-\([0-9]*\)/Type: \2 \1/'
# Elimina el path de una url, dejando solo hasta el hostname
sed "s_\(http://[a-z0-9A-Z.\-]*/\)\(.*\)_\1_"

Extraer cadenas de una linea

Con egrep (grep -E) se puede imprimir la parte de una linea que coincida con un patron.

Por ejemplo, para extraer las temperaturas de una linea…

echo "Temp1: 37.2 C Temp2: 40.0 C" | grep -Eo '[0-9\.]+[[:punct:]]?[ ]?[CF]+'

Inserción de texto

# Añadir texto al final de una linea
sed '/^wheel/ s_$_,newWheelUser_' /etc/group

Con i inserta un texto antes de la linea actual, con a despues. En ambos casos introduce un salto de linea. Por eso, para que inserte en la misma linea hay que recurrir a la sustitucion:

> sed iabcd
  fge
  abcd
  fge
> sed aabcd
  geg
  geg
  abcd
> sed s/^/abcd/g
   geg
   abcdgeg

# Añadir una linea al final de varios ficheros de texto
sed -i '$aexit 0' *
# Añadirla al principio (con salto de línea 😉
sed -i '1i. /home/group-bashrc\n' /home/*/.bashrc

Para ejecutar varios comandos sed en una línea, separar con “;”

sed "s/NODE/$NODE/g;s/IP/$IP/g" < $TEMPLATE

UNIX Stream EDitor (sed) Cheat Sheet

Reinstalar grub a mano

Puede ocurrir que perdamos el arranque de grub (por ejemplo, al instalar Windows después de Linux). Algunas distribuciones incluyen entre las opciones de sus discos de instalación la opción “rescate” (Rescue), dentro de la cual puede aparecer la recuperación automática de Grub.

Arrancando desde un Live CD, también se puede reinstalar grub “manualmente”:

  1. Montar la partición raíz (por ejemplo, en /mnt/linux)
  2. Ligar los sistemas de ficheros /dev, /proc y /sys dentro de /mnt/linux (usando “mount -o bind”)
  3. “Teletransportarnos” a /mnt/linux con “chroot /mnt/linux” (una de las múltiples chuladas de Linux ^_^)
  4. Instalar grub: “grub-install /dev/sda” (suponiendo que ese sea el disco duro en el cual queremos instalarlo)

Screen

Combinaciones útiles:

# Por defecto, la tecla de "llamar la atención" de screen es Control-a (abreviado ^a)
# Ayuda
^a ?
# crear ventana
^a c
# cambiar a la siguiente ventana
^a^n
#  cambiar a la ventana anterior
^a^p
# cambiar a la ventana enésima (0<= N <= 9)
^a N
# desconectar de sesion
^a d
# cerrar todas las ventanas y salir
^a ^\
# mostrar sesiones activas
screen -ls
# reconectarse a una sesion
screen -r id_sesion
# Cambiar el título de la ventana
^a A
# Mostrar información
^a i
# Ir al principio de la línea :-p
^a a