Shell Script UNIX-LINUX-WINDOWS

LINUX – Comando TR – Ejemplos para aprender el uso.

Publicada el 23/08/2022 por Gonzalo Reiser A.

En el caso que tengamos un texto y queramos transformar la totalidad de a a A lo haremos del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'a' 'A'

1	echo "Esto es una ejemplo de tr para el blog geekland" \| tr 'a' 'A'

En el caso que queramos reemplazar todas las vocales de una frase de minúscula a mayúscula lo podemos hacer del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'aeiou' 'AEIOU'

1	echo "Esto es una ejemplo de tr para el blog geekland" \| tr 'aeiou' 'AEIOU'

En el caso que queramos transformar la totalidad de letras mayúsculas a minúsculas lo podemos hacer del siguiente modo:

echo "Esto es una ejemplo de tr para el blog geekland" | tr 'a-z' 'A-Z' > geekland.txt

1	echo "Esto es una ejemplo de tr para el blog geekland" \| tr 'a-z' 'A-Z' > geekland.txt

Si queremos también podemos añadir una línea nueva al fichero geekland.txt que sea igual que la primera pero en minúscula siguiendo el siguiente procedimiento:

cat geekland.txt | tr 'A-Z' 'a-z' >> geekland.txt

1	cat geekland.txt \| tr 'A-Z' 'a-z' >> geekland.txt

Si ejecutamos el siguiente comando:

echo "Esto es un ejemplo de tr para el blog geekland" | tr 'a-z' 'AB'

1	echo "Esto es un ejemplo de tr para el blog geekland" \| tr 'a-z' 'AB'

Vemos que ha ocurrido lo siguiente:

La letra a se reemplaza por la A. La b por la B y a partir de aquí la c, e, f… hasta llegar la z se reemplazarán por la B.

Si queremos evitar este comportamiento podemos usar la opción -t o truncate. Si ejecutamos el mismo comando añadiendo la opción -t:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -t 'a-z' 'AB'

1	echo "Esto es un ejemplo de tr para el blog geekland" \| tr -t 'a-z' 'AB'

Vemos que ha ocurrido lo siguiente:

La letra a se reemplaza por la A. La b por la B y a partir de aquí no se reemplazará ninguna otra letra. El comportamiento ahora será de este modo gracias a la opción -t. Por lo tanto la opción -t hace que la longitud del primero de los argumentos introducidos en el comando tr sea igual que la del segundo argumento.

Nota: Con la opción -t el primero de los argumentos introducidos del comando tr tiene que tener una longitud igual o superior al segundo de los argumentos.

Si queremos borrar todas las vocales mayúsculas y minúsculas de una frase y que sean reemplazadas por un espacio en blanco lo haremos mediante la opción tr -d. Un ejemplo de lo que acabo de citar es el siguiente:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -d 'aeiou' | tr -d 'AEIOU'

1	echo "Esto es un ejemplo de tr para el blog geekland" \| tr -d 'aeiou' \| tr -d 'AEIOU'

Si quisiéramos que las vocales borradas fueran reemplazadas por espacios en blanco deberíamos haber usado el siguiente comando:

echo "Esto es un ejemplo de tr para el blog geekland" | tr 'aeiou' ' '

1	echo "Esto es un ejemplo de tr para el blog geekland" \| tr 'aeiou' ' '

Para borrar todo el contenido de una frase excepto las vocales aeiou, tendremos que usar la opción -c. La opción -c o complemento vendría a actuar como lo contrario a la orden que introducimos en el comando. Por lo tanto para borrar todas las letras que no sea vocales de una frase lo haremos del siguiente modo:

echo "Esto es un ejemplo de tr para el blog geekland" | tr -cd 'aeiou'

1	echo "Esto es un ejemplo de tr para el blog geekland" \| tr -cd 'aeiou'

Para borra todos los caracteres que no son legibles, se utiliza el siguiente comando :

head /dev/urandom | tr -cd '[:print:]\n'

1	head /dev/urandom \| tr -cd '[:print:]\n'

Nota: Mediante la opción -cd '[:print:]' estamos diciendo que se borre todo carácter que no se imprimible/legíble. Además la opción \n hará que al finalizar la tarea el cursos de la terminal quede ubicado en una nueva línea.

Para borra todo lo que no sea un digito o numero se realizara con el siguiente comando :

echo "Esto es un ejemplo de tr para el blog gee1kland 1234" | tr -cd '[:digit:]\n'

1	echo "Esto es un ejemplo de tr para el blog gee1kland 1234" \| tr -cd '[:digit:]\n'

Si por lo contrario quieren borrar la totalidad de números que aparecen a la frase tan solo tendrían que eliminar la opción -c complemento y obtendrían el siguiente resultado:

echo "Esto es un ejemplo de tr para el blog gee1kland 1234" | tr -d '[:digit:]\n'

1	echo "Esto es un ejemplo de tr para el blog gee1kland 1234" \| tr -d '[:digit:]\n'

En ocasiones escribimos rápido y es posible que por error escribamos 2 caracteres repetidos de forma consecutiva. Un ejemplo de lo que acabo de citar es el siguiente:

Esto es un ejeeemplo de tr para el blog.

En el ejemplo vemos que a la palabra ejemplo le sobran dos e. Para eliminarlas lo podemos hacer con la opción -s Squeeze del siguiente modo:

echo "Esto es un ejeeemplo de tr para el blog geekland" | tr -s 'e'

1	echo "Esto es un ejeeemplo de tr para el blog geekland" \| tr -s 'e'

Si tuviéramos una frase con exceso de espacios, como por ejemplo la siguiente:

El comando    tr  es       útil                   en determinados               casos

1	El comando tr es útil en determinados casos

Y quisiéramos eliminar los espacios sobrantes lo haríamos del siguiente modo:

echo "El comando    tr  es       útil   en determinados casos" | tr -s [:space:]

1	echo "El comando tr es útil en determinados casos" \| tr -s [:space:]

Transformar los espacios en tabulaciones horizontales o verticales con TR

En el ejemplo que propondremos a continuación tenemos 3 palabras separadas por un espacio:

joan carles geekland

Si queremos transformar este espacio por un tabulación lo haremos usando la opción [:space:] y \t del siguiente modo:

echo "joan carles geekland" | tr [:space:] '\t'

1	echo "joan carles geekland" \| tr [:space:] '\t'

La opción \t añade una tabulación horizontal. Si quisiéramos añadir una tabulación vertical lo haríamos con la opción \v del siguiente modo obteniendo un resultado parecido al siguiente:

echo "joan carles geekland" | tr [:space:] '\v'

1	echo "joan carles geekland" \| tr [:space:] '\v'

Generar una nueva línea cada vez que encontremos un determinado carácter delimitador

Si tenemos una frase, que obviamente está compuesta por palabras separadas por espacio, podemos separar cada una de las palabras en una nueva línea usando la siguiente sintaxis:

echo "joan carles geekland" | tr [:space:] '\n'

1	echo "joan carles geekland" \| tr [:space:] '\n'

Obviamente este artículo únicamente detalla algunas de las opciones del comando tr.

Publicado en Unix - Linux | Deja un comentario

Lenguaje programación AWK.

Publicada el 16/08/2022 por Gonzalo Reiser A.

Articulo obtenido desde la siguiente página : «https://learnxinyminutes.com/docs/es-es/awk-es/».

Usando el buscador, puedes obtener más códigos útiles del lenguaje AWK..

AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX. Es como un Perl restringido, perfecto para tareas de procesamiento de texto y otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo desde un script de shell o usarlo como un lenguaje stand-alone para scripting.

¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX. Siempre puedes contar con él, mientras que el futuro de Perl está en duda. AWK es más fácil de leer que Perl. Para scripts sencillos de procesamiento de texto, particularmente si es para leer archivos línea a línea y dividir por delimitadores, probablemente AWK es la herramienta correcta para el trabajo.

#!/usr/bin/awk -f
# Los comentarios tienen este aspecto.
# Los programas AWK son una colección de patrones y acciones. El patrón más
# importante es BEGIN. Las acciones van en bloques delimitados por llaves.
BEGIN {
    # BEGIN correrá al inicio del programa. Es donde pones todo el código
    # preliminar antes de procesar los archivos de texto. Si no tienes archivos
    # de texto, piensa en BEGIN como el punto de entrada principal del script.
    # Las variables son globales. Asígnalas o úsalas sin declararlas.
    count = 0
    # Los operadores son justo como en C (y amigos).
    a = count + 1
    b = count - 1
    c = count * 1
    d = count / 1
    e = count % 1 # módulo
    f = count ^ 1 # exponenciación
    a += 1
    b -= 1
    c *= 1
    d /= 1
    e %= 1
    f ^= 1
    # Incremento y decremento en uno
    a++
    b--
    # Como un operador prefijo, regresa el valor modificado
    ++a
    --b
    # Nota que no hay puntación para terminar las instrucciones
    # Instrucciones de control
    if (count == 0)
        print "Iniciando count en 0"
    else
        print "Eh?"
    # O puedes usar el operador ternario
    print (count == 0) ? "Iniciando count en 0" : "Eh?"

    # Bloques formados por múltiples líneas usan llaves
    while (a < 10) {
        print "La concatenación de strings se hace " " con series " 
	print " de" " strings separados por espacios"
        print a
        a++
    }
    for (i = 0; i < 10; i++)
        print "El viejo confiable ciclo for"
    # Los operaciones de comparación son estándar...
    a < b   # Menor que
    a <= b  # Menor o igual que
    a != b  # No igual
    a == b  # Igual
    a > b   # Mayor que
    a >= b  # Mayor o igual que
    # ...así como los operadores lógicos
    a && b  # AND
    a || b  # OR
    # Además están las expresiones regulares
    if ("foo" ~ "^fo+$")
        print "Fooey!"
    if ("boo" !~ "^fo+$")
        print "Boo!"
    # Arrays
    arr[0] = "foo"
    arr[1] = "bar"
    # Desafortunadamente no hay otra manera de inicializar un array.
    # Tienes que inicializar cada posición del array.
    # También hay arrays asociativos
    assoc["foo"] = "bar"
    assoc["bar"] = "baz"
    # Y arrays multidimensionales con limitaciones que no mencionaré aquí
    multidim[0,0] = "foo"
    multidim[0,1] = "bar"
    multidim[1,0] = "baz"
    multidim[1,1] = "boo"
    # Puedes probar pertenencia a un array
    if ("foo" in assoc)
        print "Fooey!"
    # También puedes usar el operador 'in' para iterar las claves de un array
    for (key in assoc)
        print assoc[key]
    # La terminal es un array especial llamado ARGV
    for (argnum in ARGV)
        print ARGV[argnum]
    # Puedes eliminar elementos de un array.
    # Esto es útil para prevenir que AWK suponga que algunos argumentos
    # son archivos por procesar.
    delete ARGV[1]
    # El número de argumentos de la terminal está en la variable ARGC
    print ARGC
    # AWK tiene tres categorías de funciones incluidas.
    # Demostraré esas funciones posteriormente.
    return_value = arithmetic_functions(a, b, c)
    string_functions()
    io_functions()
}
# Así se define una función
function arithmetic_functions(a, b, c,     localvar) {
    # Probablemente la parte más molesta de AWK es que no hay variables locales
    # Todo es global. No es problema en scripts pequeños, pero sí para
    # scripts más grandes.

    # Hay un work-around (mmm... hack). Los argumentos de las funciones son 
    # locales para la función, y AWK permite definir más argumentos de función
    # de los que necesita, por lo que define las variables locales en la 
    # declaración como en la función de arriba. Como convención, agrega
    # espacios en blanco para distinguir los parámetros de la función de las 
    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una 
    # variable local.
    # Ahora, a demostrar las funciones aritméticas
    # La mayoría de las implementaciones de AWK tienen funciones
    # trigonométricas estándar
    localvar = sin(a)
    localvar = cos(a)
    localvar = atan2(b, a) # arcotangente de b / a
    # Y cosas logarítmicas
    localvar = exp(a)
    localvar = log(a)
    # Raíz cuadrada
    localvar = sqrt(a)
    # Trucar un flotante a entero
    localvar = int(5.34) # localvar => 5
    # Números aleatorios
    srand() # La semilla es el argumento. Por defecto usa el tiempo del sistema
    localvar = rand() # Número aleatorio entre 0 y 1.
    # Y aquí se regresa el valor
    return localvar
}
function string_functions(    localvar, arr) {
    # AWK tiene algunas funciones para procesamiento de strings,
    # y muchas dependen fuertemente en expresiones regulares.
    # Buscar y remplazar, primer instancia (sub) o todas las instancias (gsub)
    # Ambas regresan el número de matches remplazados.
    localvar = "fooooobar"
    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"
    # Buscar una cadena que haga match con una expresión regular
    # index() hace lo mismo, pero no permite expresiones regulares
    match(localvar, "t") # => 4, dado que 't' es el cuarto caracter
    # Separar con base en un delimitador
    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
    # Otras funciones útiles
    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
    substr("foobar", 2, 3) # => "oob"
    substr("foobar", 4) # => "bar"
    length("foo") # => 3
    tolower("FOO") # => "foo"
    toupper("foo") # => "FOO"
}
function io_functions(    localvar) {
    # Ya has visto print
    print "Hello world"
    # También hay printf
    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un 
    # handle de archivo cuando use algo que necesite uno. El string que usaste 
    # para esto puede ser tratada como un handle de archivo para propósitos de I/O.
    # Esto lo hace similar al scripting de shell:
    print "foobar" >"/tmp/foobar.txt"
    # Ahora el string "/tmp/foobar.txt" es un handle. Puedes cerrarlo:
    close("/tmp/foobar.txt")
    # Aquí está como correr algo en el shell
    system("echo foobar") # => muestra foobar
    # Lee una línea de la entrada estándar (stdin) y lo guarda en localvar
    getline localvar
    # Lee una línea desde un pipe
    "echo foobar" | getline localvar # localvar => "foobar"
    close("echo foobar")
    # Lee una línea desde un archivo y la guarda en localvar
    getline localvar <"/tmp/foobar.txt"
    close("/tmp/foobar.txt")
}
# Como dije al inicio, los programas en AWK son una colección de patrones y 
# acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás
# procesando líneas desde archivos o stdin.
# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a 
# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for 
# implícito, iterando sobre las líneas de estos archivos. Estos patrones y
# acciones son como instrucciones switch dentro del ciclo.
/^fo+bar$/ {
    # Esta acción se ejecutará por cada línea que haga match con la expresión
    # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.
    # Vamos a sólo mostrar la línea:
    print
    # ¡Wow, sin argumento! Eso es porque print tiene uno por defecto: $0.
    # $0 es el nombre de la línea actual que se está procesando.
    # Se crea automáticamente para ti.
    # Probablemente puedas adivinar que hay otras variables $. Cada línea es 
    # separada implícitamente antes de que se llame cada acción, justo como lo
    # hace shell. Y, como shell, cada campo puede ser accesado con $.
    # Esto mostrará el segundo y cuarto campos de la línea
    print $2, $4
    # AWK automáticamente define muchas otras variables que te ayudan a
    # inspeccionar y procesar cada línea. La más importante es NF
    # Imprime el número de campos de esta línea
    print NF
    # Imprime el último campo de esta línea
    print $NF
}
# Cada patrón es realmente un prueba de verdadero/falso. La expresión regular
# en el último patrón también es una prueba verdadero/falso, pero parte de eso
# estaba oculto. Si no le das un string a la prueba, supondrá $0, la línea que
# se está procesando. La versión completa de esto es:
$0 ~ /^fo+bar$/ {
    print "Equivalente al último patrón"
}
a > 0 {
    # Esto se ejecutará una vez por línea, mientras a sea positivo
}
# Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,
# y haciendo algo con ella, particularmente separando en un deliminator, es tan
# común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti
# sin que tengas que pedirlo. Basta con escribir los patrones y acciones 
# basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.

# Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.
# El script lee un nombre de stdin y muestra el promedio de edad para todos los
# que tengan ese nombre. Digamos que como argumento pasamos el nombre de un
# archivo con este contenido:
#
# Bob Jones 32
# Jane Doe 22
# Steve Stevens 83
# Bob Smith 29
# Bob Barker 72
#
# Éste es el script:
BEGIN {
    # Primero, pedir al usuario el nombre
    print "¿Para qué nombre quieres el promedio de edad?"
    # Recuperar una línea de stdin, no de archivos en la línea de comandos
    getline name <"/dev/stdin"
}
# Ahora, hacer match con cada línea cuyo primer campo es el nombre dado
$1 == name {
    # Aquí dentro tenemos acceso a variables útiles precargadas:
    # $0 es toda la línea
    # $3 es el tercer campo, la edad, que es lo que nos interesa
    # NF es el número de campos, que debe ser 3
    # NR es el número de registros (líneas) vistos hasta ahora
    # FILENAME es el nombre del archivo que está siendo procesado
    # FS es el campo separador, " " en este caso
    # Y muchas más que puedes conocer ejecutando 'man awk' en la terminal.

    # Llevar el registro de la suma y cuantas líneas han hecho match.
    sum += $3
    nlines++
}
# Otro patrón especial es END. Va a ejecutarse después de procesar todos los 
# archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una
# entrada a procesar. Se ejecutará después de que todos los archivos hayan sido
# leídos y procesados según las reglas y acciones que programaste. El propósito
# es usualmente para mostrar un reporte final, o hacer algo con el agregado de
# los datos que has acumulado durante la ejecución del script.
END {
    if (nlines)
        print "La edad promedio para " name " es " sum / nlines
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

#!/usr/bin/awk -f

# Los comentarios tienen este aspecto.

# Los programas AWK son una colección de patrones y acciones. El patrón más

# importante es BEGIN. Las acciones van en bloques delimitados por llaves.

BEGIN {

# BEGIN correrá al inicio del programa. Es donde pones todo el código

# preliminar antes de procesar los archivos de texto. Si no tienes archivos

# de texto, piensa en BEGIN como el punto de entrada principal del script.

# Las variables son globales. Asígnalas o úsalas sin declararlas.

count = 0

# Los operadores son justo como en C (y amigos).

a = count + 1

b = count - 1

c = count * 1

d = count / 1

e = count % 1 # módulo

f = count ^ 1 # exponenciación

a += 1

b -= 1

c *= 1

d /= 1

e %= 1

f ^= 1

# Incremento y decremento en uno

a++

b--

# Como un operador prefijo, regresa el valor modificado

++a

--b

# Nota que no hay puntación para terminar las instrucciones

# Instrucciones de control

if (count == 0)

print "Iniciando count en 0"

else

print "Eh?"

# O puedes usar el operador ternario

print (count == 0) ? "Iniciando count en 0" : "Eh?"

# Bloques formados por múltiples líneas usan llaves

while (a < 10) {

print "La concatenación de strings se hace " " con series "

print " de" " strings separados por espacios"

print a

a++

}

for (i = 0; i < 10; i++)

print "El viejo confiable ciclo for"

# Los operaciones de comparación son estándar...

a < b # Menor que

a <= b # Menor o igual que

a != b # No igual

a == b # Igual

a > b # Mayor que

a >= b # Mayor o igual que

# ...así como los operadores lógicos

a && b # AND

a || b # OR

# Además están las expresiones regulares

if ("foo" ~ "^fo+$")

print "Fooey!"

if ("boo" !~ "^fo+$")

print "Boo!"

# Arrays

arr[0] = "foo"

arr[1] = "bar"

# Desafortunadamente no hay otra manera de inicializar un array.

# Tienes que inicializar cada posición del array.

# También hay arrays asociativos

assoc["foo"] = "bar"

assoc["bar"] = "baz"

# Y arrays multidimensionales con limitaciones que no mencionaré aquí

multidim[0,0] = "foo"

multidim[0,1] = "bar"

multidim[1,0] = "baz"

multidim[1,1] = "boo"

# Puedes probar pertenencia a un array

if ("foo" in assoc)

print "Fooey!"

# También puedes usar el operador 'in' para iterar las claves de un array

for (key in assoc)

print assoc[key]

# La terminal es un array especial llamado ARGV

for (argnum in ARGV)

print ARGV[argnum]

# Puedes eliminar elementos de un array.

# Esto es útil para prevenir que AWK suponga que algunos argumentos

# son archivos por procesar.

delete ARGV[1]

# El número de argumentos de la terminal está en la variable ARGC

print ARGC

# AWK tiene tres categorías de funciones incluidas.

# Demostraré esas funciones posteriormente.

return_value = arithmetic_functions(a, b, c)

string_functions()

io_functions()

}

# Así se define una función

function arithmetic_functions(a, b, c, localvar) {

# Probablemente la parte más molesta de AWK es que no hay variables locales

# Todo es global. No es problema en scripts pequeños, pero sí para

# scripts más grandes.

# Hay un work-around (mmm... hack). Los argumentos de las funciones son

# locales para la función, y AWK permite definir más argumentos de función

# de los que necesita, por lo que define las variables locales en la

# declaración como en la función de arriba. Como convención, agrega

# espacios en blanco para distinguir los parámetros de la función de las

# variables locales. En este ejemplo, a, b y c son parámetros y localvar es una

# variable local.

# Ahora, a demostrar las funciones aritméticas

# La mayoría de las implementaciones de AWK tienen funciones

# trigonométricas estándar

localvar = sin(a)

localvar = cos(a)

localvar = atan2(b, a) # arcotangente de b / a

# Y cosas logarítmicas

localvar = exp(a)

localvar = log(a)

# Raíz cuadrada

localvar = sqrt(a)

# Trucar un flotante a entero

localvar = int(5.34) # localvar => 5

# Números aleatorios

srand() # La semilla es el argumento. Por defecto usa el tiempo del sistema

localvar = rand() # Número aleatorio entre 0 y 1.

# Y aquí se regresa el valor

return localvar

}

function string_functions( localvar, arr) {

# AWK tiene algunas funciones para procesamiento de strings,

# y muchas dependen fuertemente en expresiones regulares.

# Buscar y remplazar, primer instancia (sub) o todas las instancias (gsub)

# Ambas regresan el número de matches remplazados.

localvar = "fooooobar"

sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"

gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"

# Buscar una cadena que haga match con una expresión regular

# index() hace lo mismo, pero no permite expresiones regulares

match(localvar, "t") # => 4, dado que 't' es el cuarto caracter

# Separar con base en un delimitador

split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]

# Otras funciones útiles

sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"

substr("foobar", 2, 3) # => "oob"

substr("foobar", 4) # => "bar"

length("foo") # => 3

tolower("FOO") # => "foo"

toupper("foo") # => "FOO"

}

function io_functions( localvar) {

# Ya has visto print

print "Hello world"

# También hay printf

printf("%s %d %d %d\n", "Testing", 1, 2, 3)

# AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un

# handle de archivo cuando use algo que necesite uno. El string que usaste

# para esto puede ser tratada como un handle de archivo para propósitos de I/O.

# Esto lo hace similar al scripting de shell:

print "foobar" >"/tmp/foobar.txt"

# Ahora el string "/tmp/foobar.txt" es un handle. Puedes cerrarlo:

close("/tmp/foobar.txt")

# Aquí está como correr algo en el shell

system("echo foobar") # => muestra foobar

# Lee una línea de la entrada estándar (stdin) y lo guarda en localvar

getline localvar

# Lee una línea desde un pipe

"echo foobar" | getline localvar # localvar => "foobar"

close("echo foobar")

# Lee una línea desde un archivo y la guarda en localvar

getline localvar <"/tmp/foobar.txt"

close("/tmp/foobar.txt")

}

# Como dije al inicio, los programas en AWK son una colección de patrones y

# acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás

# procesando líneas desde archivos o stdin.

# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a

# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for

# implícito, iterando sobre las líneas de estos archivos. Estos patrones y

# acciones son como instrucciones switch dentro del ciclo.

/^fo+bar$/ {

# Esta acción se ejecutará por cada línea que haga match con la expresión

# regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.

# Vamos a sólo mostrar la línea:

# ¡Wow, sin argumento! Eso es porque print tiene uno por defecto: $0.

# $0 es el nombre de la línea actual que se está procesando.

# Se crea automáticamente para ti.

# Probablemente puedas adivinar que hay otras variables $. Cada línea es

# separada implícitamente antes de que se llame cada acción, justo como lo

# hace shell. Y, como shell, cada campo puede ser accesado con $.

# Esto mostrará el segundo y cuarto campos de la línea

print $2, $4

# AWK automáticamente define muchas otras variables que te ayudan a

# inspeccionar y procesar cada línea. La más importante es NF

# Imprime el número de campos de esta línea

print NF

# Imprime el último campo de esta línea

print $NF

}

# Cada patrón es realmente un prueba de verdadero/falso. La expresión regular

# en el último patrón también es una prueba verdadero/falso, pero parte de eso

# estaba oculto. Si no le das un string a la prueba, supondrá $0, la línea que

# se está procesando. La versión completa de esto es:

$0 ~ /^fo+bar$/ {

print "Equivalente al último patrón"

}

a > 0 {

# Esto se ejecutará una vez por línea, mientras a sea positivo

}

# Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,

# y haciendo algo con ella, particularmente separando en un deliminator, es tan

# común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti

# sin que tengas que pedirlo. Basta con escribir los patrones y acciones

# basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.

# Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.

# El script lee un nombre de stdin y muestra el promedio de edad para todos los

# que tengan ese nombre. Digamos que como argumento pasamos el nombre de un

# archivo con este contenido:

# Bob Jones 32

# Jane Doe 22

# Steve Stevens 83

# Bob Smith 29

# Bob Barker 72

# Éste es el script:

BEGIN {

# Primero, pedir al usuario el nombre

print "¿Para qué nombre quieres el promedio de edad?"

# Recuperar una línea de stdin, no de archivos en la línea de comandos

getline name <"/dev/stdin"

}

# Ahora, hacer match con cada línea cuyo primer campo es el nombre dado

$1 == name {

# Aquí dentro tenemos acceso a variables útiles precargadas:

# $0 es toda la línea

# $3 es el tercer campo, la edad, que es lo que nos interesa

# NF es el número de campos, que debe ser 3

# NR es el número de registros (líneas) vistos hasta ahora

# FILENAME es el nombre del archivo que está siendo procesado

# FS es el campo separador, " " en este caso

# Y muchas más que puedes conocer ejecutando 'man awk' en la terminal.

# Llevar el registro de la suma y cuantas líneas han hecho match.

sum += $3

nlines++

}

# Otro patrón especial es END. Va a ejecutarse después de procesar todos los

# archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una

# entrada a procesar. Se ejecutará después de que todos los archivos hayan sido

# leídos y procesados según las reglas y acciones que programaste. El propósito

# es usualmente para mostrar un reporte final, o hacer algo con el agregado de

# los datos que has acumulado durante la ejecución del script.

END {

if (nlines)

print "La edad promedio para " name " es " sum / nlines

}

Publicado en Unix - Linux | Deja un comentario

LINUX – Poniendo color a nuestros SCRIPTS.

Publicada el 10/08/2022 por Gonzalo Reiser A.

También existe la posibilidad de darle un toque más visual a aquello que imprimimos por pantalla; eso se logra mediante la inclusión de Etiquetas de color y mediante el mostrado de la cadena mediante el comando echo -e «cadena». Una etiqueta de color siempre tiene que ser almacenada en una variable y tienen que tener la siguiente estructura:

variable='\e[${codigo_color}m'

1	variable='\e[${codigo_color}m'

Los colores que se quieren especificar poseen un código númerico en concreto; es decir no se puede especificar un color como Rojo, negro, etc… Se tratan de códigos algo complejos de memorizar, es por ello que os listo a continuación cada color con su correspondiente código:

Negro         --> 0;30 
Gris oscuro   --> 1;30
Gris claro    --> 0;37
Azul          --> 0;34 
Azul claro    --> 1;34
Verde         --> 0;32 
Verde claro   --> 1;32
Cyan          --> 0;36 
Cyan claro    --> 1;36
Rojo          --> 0;31 
Rojo claro    --> 1;31
Morado        --> 0;35 
Morado claro  --> 1;35
Marrón        --> 0;33 
Amarillo      --> 1;33 
Blanco        --> 1;37
No color      --> 0

Negro --> 0;30

Gris oscuro --> 1;30

Gris claro --> 0;37

Azul --> 0;34

Azul claro --> 1;34

Verde --> 0;32

Verde claro --> 1;32

Cyan --> 0;36

Cyan claro --> 1;36

Rojo --> 0;31

Rojo claro --> 1;31

Morado --> 0;35

Morado claro --> 1;35

Marrón --> 0;33

Amarillo --> 1;33

Blanco --> 1;37

No color --> 0

Queremos mostrar esta cadena con diferentes colores; para ello crearemos cuatro variables llamadas ROJO, CYAN, VERDE y BLANCO y haremos que la palabra vamos se muestre en rojo, las palabras a probar se muestren en cyan, la palabra diferentes se muestre en verde y por último la palabra colores se muestre en blanco.El código para lograr dicho sería el siguiente:

#!/bin/bash
###COMENZAMOS CREANDO VARIABLES CON COLORES###
ROJO='\e[0;31m'
CYAN='\e[0;36m'
VERDE='\e[0;32m'
BLANCO='\e[1;37m'
#PASAMOS A MOSTRAR EL TEXTO CON COLORES. MUY IMPORTANTE HACER ECHO CON EL PARAMETRO -e
echo -e "${ROJO}Vamos ${CYAN}a probar ${VERDE}diferentes ${BLANCO}colores"

#!/bin/bash

###COMENZAMOS CREANDO VARIABLES CON COLORES###

ROJO='\e[0;31m'

CYAN='\e[0;36m'

VERDE='\e[0;32m'

BLANCO='\e[1;37m'

#PASAMOS A MOSTRAR EL TEXTO CON COLORES. MUY IMPORTANTE HACER ECHO CON EL PARAMETRO -e

echo -e "${ROJO}Vamos ${CYAN}a probar ${VERDE}diferentes ${BLANCO}colores"

Publicado en Unix - Linux | Deja un comentario

BASH -Script verificar correcta ejecución.-

Publicada el 10/08/2022 por Gonzalo Reiser A.

El siguiente script intenta crear un subdirectorio tmp/project en el directorio actual. En la condición de la sentencia if verificamos si el valor de la variable $? es diferente de 0. Si ese es el caso, imprimimos un mensaje de error y salimos del script con el código de salida 1. La rama else imprime un mensaje exitoso y se ejecuta solo si el valor de $? es 0

#!/bin/bash
  
mkdir tmp/project

if [[ $? -ne 0 ]] ; then
    echo "Unable to create directory tmp/project"
    exit 1
else
    echo "Directory tmp/project created successfully"
fi

#!/bin/bash

mkdir tmp/project

if [[ $? -ne 0 ]] ; then

echo "Unable to create directory tmp/project"

exit 1

else

echo "Directory tmp/project created successfully"

Publicado en Unix - Linux | Deja un comentario

BASH – LINUX ver fecha de caducidad de un certificado SSL (Plugin NAGIOS para renovar certificado SSL).-

Publicada el 19/07/2022 por Gonzalo Reiser A.

Para la correcta ejecución debe tener instalado OPENSSL . El SCRIPT solicita 4 argumentos para su ejecución :

1 = Nombre servidor 2=Puerto 3=Días WARNING 4=Días CRITICAL

#!/bin/bash
servidor=$1
puerto=$2
warning=$3
critical=$4
hasta=echo | openssl s_client -connect $servidor.dominio.cl:$puerto 2>/dev/null | openssl x509 -noout -dates | cut -d "=" -f2 | awk 'NR==2{print $0}'
vence=date -d "$hasta" +%Y%m%d
START=date -d $(date +"%Y%m%d") +%s
END=date -d $vence +%s
((dife=$END-$START))
((dias=$dife/(60*60*24)))
if [ "$dias" -le "$warning" ] && [ "$dias" -ge "$critical" ]; then
     echo "WARNING - Quedan $dias para VENCER"
     exit 1
elif [ "$dias" -le "$critical" ]; then
     echo "CRITICAL - Quedan $dias para VENCER"
     exit 2
else
     echo "OK - Quedan $dias para VENCER"
     exit 0
fi
echo "UNKNOWN - Error Interno"
     exir

Para ejecutarlo se debe dar permisos de ejecución :

chmod u+x check_cert.sh

Para ejecutarlo :

./check_cert.sh volcan01 443 20 10

Se obtiene el siguiente resultado :

OK – Quedan 129 días para VENCER

Publicado en Unix - Linux | Deja un comentario

LINUX – Comando TR – Ejemplos para aprender el uso.

Transformar los espacios en tabulaciones horizontales o verticales con TR

Generar una nueva línea cada vez que encontremos un determinado carácter delimitador

Lenguaje programación AWK.

LINUX – Poniendo color a nuestros SCRIPTS.

BASH -Script verificar correcta ejecución.-

BASH – LINUX ver fecha de caducidad de un certificado SSL (Plugin NAGIOS para renovar certificado SSL).-

Comentarios recientes

Archivos