Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Redirección y tuberias en linux (II) - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 30 de diciembre de 2022 por Fernando Jesús H.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

continuamos con el redireccionamiento recordamos que estoy en esta carpetita que habíamos creado 00:00:00
sábado 28 y que teníamos ahí f1 f fichero 1 fichero 2 fichero 3 voy a borrar el fichero 1 00:00:09
para partir por los que teníamos y tenemos esos tres ficheros vale fichero 1 fichero 2 y fichero 00:00:16
3 mal vimos en este caso que había reclamamiento de entrada de salida y de errores estuvimos viendo 00:00:27
el de salida y el de errores y estuvimos haciendo ejemplos como este diciendo oye quiero mostrar 00:00:35
fichero 1 y no existe y aquí el fichero 1 sí que me lo iba a mostrar y él no existe era un error 00:00:44
así que aquí teníamos los dos canales y hacíamos lo siguiente oye quiero que la salida vaya en este 00:00:54
caso a salida ok punto txt y quiero que los errores vayan a la salida mal punto txt vale 00:01:01
no sé si recordáis que hicimos eso esto de dejar aquí un espacio lo que queráis vale yo son manías 00:01:13
mías entonces qué es lo que ha pasado que me ha creado uno que se llama salida ok y otro que se 00:01:21
llama salida mal si esto lo que vimos antes pues aquí comentaros que tener cuidado con el orden 00:01:29
que pongáis me explico voy a partir de este primer ejemplo que ya lo tenemos hecho pero voy a decirle 00:01:38
que la salida vaya la salida correcta vaya este de aquí y le voy a decir que los errores vayan 00:01:47
al mismo sitio que la salida yo no sé si recordáis que hacía esto si yo le hago un 00:01:57
cut de salida ok pues me ponía tanto los errores vale como la salida correcta dentro del fichero 00:02:03
esto es lo que vimos antes si yo recuerdo pone primero todos los errores y luego en este caso 00:02:13
la salida correcta pero qué pasa si yo hago lo contrario digo mira vale pues voy a hacer lo 00:02:19
mismo pero voy a decirle primero este de aquí y luego la salida ok sí y qué ha pasado aquí 00:02:25
fijaros que me está mostrando la salida de errores porque porque influye el orden en el 00:02:38
que lo pongáis cuidado con eso por favor entonces qué es lo que le estamos diciendo aquí aquí le 00:02:48
estamos diciendo que la salida de errores se me vaya al mismo sitio que la salida estándar y la 00:02:54
salida estándar cuál es por la pantalla así que poner esto y no poner nada lo mismo le estoy 00:03:02
diciendo repito le estoy diciendo oye quiero que los errores los envíes al mismo sitio que 00:03:08
la salida estándar y cuál es la salida estándar ahora pues la salida estándar que nosotros tenemos 00:03:15
ahora en la pantalla vale en este caso como lo queréis llamar me da igual que sea pantalla 00:03:20
terminal me da igual sí por eso que es lo que me muestra aquí aquí lo que me está mostrando es el 00:03:28
error pues en pantalla y luego que le digo pues luego le estoy diciendo que la salida correcta 00:03:39
se me guarda en este fichero de forma que si yo le digo que me diga la salida ok pues solamente 00:03:49
me va a mostrar la salida correcta si entonces repito por favor cuidado lo he cerrado 00:03:59
cuidado con poner 00:04:06
como ponéis el orden 00:04:17
por favor 00:04:19
estábamos en IES Cañaveral 00:04:20
y en el sábado 28 00:04:25
estábamos aquí 00:04:26
y estamos viendo que lo que nos dice 00:04:27
la salida ok 00:04:31
¿de acuerdo? 00:04:32
vale 00:04:35
vamos a ver más cosas 00:04:35
ya hemos visto que podemos mandar por un lado 00:04:38
la salida y por otro los errores o que podemos enviar las dos cosas al mismo sitio sí vale 00:04:45
cuando yo especificó cosas como ésta en el que decíamos que la salida va a un sitio está de aquí 00:04:51
cuando yo le digo que la salida va a un sitio y el error va a otro como aquí estoy especificando 00:05:04
dónde va cada uno me da igual poner uno delante y otro después es decir aquí el orden sí que me da 00:05:09
pero cuidado cuando yo pongo que los dos van a un mismo sitio como hemos visto antes pero en 00:05:13
este caso cuando yo estoy indicando la salida normal la salida correcta y la salida de errores 00:05:19
me da igual poner este aquí que esté aquí de acuerdo porque estoy especificando los dos por 00:05:28
separado de acuerdo vale vamos a seguir viendo cuáles las opciones que nos quedan hemos visto 00:05:36
la salida y la salida de errores y qué pasa con la entrada pues para que entendáis cómo funciona 00:05:44
la entrada voy a hacer un kit kat aquí y vamos a ver un comando no lo voy a explicar completo pero 00:05:49
voy a ver un comando que se llama tr el comando tr se utiliza para sustituir un conjunto de 00:05:58
caracteres por otros vale por ejemplo el ejemplo más claro que tenéis imaginaros que yo pongo eco 00:06:05
o la caracola sí pues si yo pongo en este caso de coro caracolas si yo pongo el comando tr y 00:06:11
yo al comando tr le digo yo quiero cambiar la a por un 5 si eso lo que le estoy diciendo veis 00:06:27
que hay el tr se me queda ahí el cursor diciendo vale pues escríbeme lo que tú quieras dios vale 00:06:38
pues hola fernando pues quiero que veáis qué es lo que ha hecho me ha cogido la y me la ha 00:06:44
sustituido por en 5 me ha cogido la y me ha sustituido por en 5 si yo sigo poniendo me 00:06:56
dice venga introduce me otra línea porque él está esperando a que yo le dé como entrada a 00:07:02
través del teclado la información pues yo le digo hola caracola y qué es lo que ha hecho pues 00:07:08
volvemos a ver aquí que lo que ha hecho es cambiar la letra por un 5 la letra por un 5 la letra por 00:07:16
un 5 y la letra por un 5 si entonces este comando me permite sustituir no solamente un carácter sino 00:07:24
un conjunto de caracteres. ¿Cómo le puedo yo especificar un conjunto de caracteres? 00:07:33
Os hago otro ejemplo. Yo le digo, oye, quiero tr y le voy a poner entre corchetes un rango 00:07:38
de caracteres. Le digo, quiero que me cambies de la a y tiene que ser un rango que siempre 00:07:44
va de menor a mayor. No puedo poner z, tiene que ser de a a la z. Pues quiero que, esto 00:07:52
le estoy diciendo, quiero que me cambies todas las letras que vayan desde la a hasta la z 00:07:58
El guión quiere decir hasta y en este caso son minúsculas. Y ahora le voy a decir, quiero que me la cambies de la A a la Z mayúscula. Entonces, ¿qué le estoy diciendo aquí? Le estoy diciendo, esto es lo que quiero que me busques para cambiar y esto es por lo que quiero que me busques. 00:08:03
Entonces, como yo he puesto entre corchetes, para poner entre corchetes le pongo un conjunto de caracteres. 00:08:25
Si pongo el primer carácter, un guión y el último, va a ser todos los caracteres comprendidos entre el primero y el último. 00:08:33
¿Sí? Entonces, aquí lo que le estoy diciendo es que, oye, desde la A minúscula hasta la Z minúscula, es decir, A, B, C, D, E, E, bla, bla, bla, bla, bla, bla. 00:08:41
pues quiero que me lo sustituyas 00:08:53
por de la A mayúscula 00:08:56
a la Z mayúscula 00:08:58
¿vale? ¿entendéis que hace esto? 00:09:00
¿vale? 00:09:03
si yo le doy aquí al intro 00:09:04
uy, perdonadme 00:09:06
si no he salido, espérate, control C 00:09:08
control C porque estaba ejecutando 00:09:10
todavía el test anterior 00:09:12
así que 00:09:14
espérate que lo voy a copiar, que no tengo gana de 00:09:16
copiamos 00:09:18
y pegamos 00:09:23
¿vale? 00:09:25
se queda ahí esperando 00:09:26
le digo, vale, pues hola 00:09:27
Fernando 00:09:29
pues que es lo que ha hecho, fijaros que es lo que ha hecho 00:09:33
me está cambiando 00:09:36
pues todo la he ido por a ver 00:09:37
me dice, oye 00:09:39
la H por H mayúscula 00:09:42
la O minúscula por la O mayúscula 00:09:44
voy a cambiar el color 00:09:46
la L 00:09:47
joder, estoy cogiendo yo aquí 00:09:54
el blue 00:09:58
cojo la A 00:10:01
cojo la F minúscula por la F minúscula 00:10:05
Cojo la E por la E mayúscula, es decir, me está cambiando todas las minúsculas por mayúsculas. 00:10:08
¿Que yo quiero seguir escribiendo? Pues me va a convertir. 00:10:13
Pero repito, ¿de dónde me está esperando los datos? De la entrada estándar. 00:10:17
Y la entrada estándar, que es por defecto el numerito 0 y es el teclado. 00:10:21
¿Sí? Vale. Entonces, una última CTRL-C para salir de aquí y una última observación. 00:10:27
¿Qué pasa si yo quiero decir las vocales? Yo le pongo A, E, I, O. 00:10:34
y quiero que me lo cambie por 1, 2, 3, 4 y 5 00:10:38
entonces, ¿qué es lo que va a hacer? 00:10:43
me va a cambiar 00:10:47
me va a cambiar la SAS 00:10:48
por 1 00:10:55
la SES 00:10:57
por 2 00:10:59
la I por 3 00:11:00
la O por 4 00:11:02
y la U por 5 00:11:05
eso es lo que me va a hacer 00:11:07
entonces, si yo esto lo ejecuto 00:11:08
yo le pongo aquí 00:11:11
Antonio Cervantes Cuevas. 00:11:12
Pues, ¿qué es lo que me ha hecho? 00:11:22
Me lo estoy inventando, ¿eh? 00:11:23
¿Qué es lo que me ha hecho aquí? 00:11:26
Pues la A. 00:11:28
Uy, perdón. 00:11:29
La A por un 1. 00:11:31
La O por un 4. 00:11:34
La I por un 3. 00:11:36
La O por un 4. 00:11:38
Vais viendo que me está sustituyendo cada vocal por su correspondiente número en el orden en el que nosotros lo hemos puesto. 00:11:39
La U por un 5, la E por un 2 y la A por un 1. 00:11:47
¿Entendéis este comando? 00:11:52
Entonces, ¿cómo le podría yo decir? 00:11:55
Imaginaros que vamos a hacer un ficherito. 00:11:58
Le digo, oye, nano y vamos a crear un ficherito que sea nombres alumnos. 00:11:59
Y vamos a creer aquí, yo que sé, lo que me dé la gana. Antonio, Luis, Carol, Eva, Natalia, Carmen, Nuria, Alejandra, ¿vale? 00:12:11
yo que sé, esto es de aquí 00:12:40
otra vez Luis 00:12:41
¿de acuerdo? 00:12:43
pues imaginaos que tenemos esto, ya sabéis 00:12:48
que para salir, control x 00:12:50
quiere guardar los cambios, s de sí 00:12:52
nombre del ficherito 00:12:54
ese es el que tiene, intro 00:12:56
y ya lo tenemos guardado, de forma que si yo le 00:12:58
digo nombres alumnos 00:13:00
esto es lo que tengo, ¿sí? 00:13:03
¿qué pasa si yo quiero convertir 00:13:04
este fichero? 00:13:06
es decir, todo lo que hay en este fichero 00:13:08
quiero que me lo sustituya 00:13:10
todos los caracteres en minúscula por mayúsculas. 00:13:12
Yo le podría decir lo que teníamos aquí antes. 00:13:18
El tr, az, az mayúscula. 00:13:21
Pero, ¿y cómo le digo yo que en lugar de que los valores me lo coja del teclado, 00:13:25
quiero que me lo coja de un fichero? 00:13:31
Pues para eso tenemos aquí el que nos queda, el menor. 00:13:33
Yo con el menor le estoy diciendo, 00:13:37
oye, los datos de entrada con los que vas a trabajar no va a ser el teclado, o sea, no esperes los datos del teclado, sino que directamente te los voy a enviar de un ficherito, ¿vale? 00:13:39
Que se llama nombres.txt. Entonces, ¿qué es lo que estoy haciendo aquí? Aquí lo que estoy haciendo es que todo el contenido de este ficherito, que es nombre alumnos, que es este de aquí, ¿sí? 00:13:51
Lo que estoy haciendo es, se los voy a pasar como si yo los hubiese escrito, se los voy a pasar al comando tr. 00:14:09
Entonces, ¿qué es lo que va a hacer el comando tr? 00:14:21
Me va a coger como entrada todo el contenido de este ficherito y lo que va a hacer es, me va a sustituir todo lo que está en minúscula por mayúscula y me lo va a mostrar en pantalla. 00:14:23
¿Sí? Entonces si yo esto lo ejecuto, pues vamos a ver si efectivamente, fijaros que ya no me pide nada por pantalla, sino que automáticamente en lugar de obtener del teclado me lo ha cogido de ese ficherito. 00:14:36
Me ha convertido todo de minúscula a mayúscula y ha terminado. ¿Me seguís? ¿Sí? Pues ese es el que nos quedaba. 00:14:51
Que sepáis que yo le puedo decir, oye, quiero que eso, en lugar de que me lo muestres por pantalla, quiero que me lo guardes, nombres, mayúsculas, punto txt, pero bien escrito. 00:14:59
mayúsculas 00:15:18
si yo le doy 00:15:22
no me ha mostrado nada, ¿por qué? 00:15:24
porque le he dicho 00:15:27
que me coja 00:15:28
y que en lugar de mostrármelo en la salida 00:15:31
me lo guarde en este fichero 00:15:35
de forma que si yo hago un cat de ese fichero 00:15:37
pues fijaros que contiene 00:15:39
el ficherito en mayúsculas 00:15:44
¿de acuerdo? 00:15:47
¿De acuerdo? Entendemos para qué es el redireccionamiento de entrada, pero puedo juntar entrada con salida, como habéis visto. ¿De acuerdo? ¿Sí? Vale. Esto en cuanto a los redireccionamientos. Pues ahora vamos a pasar, en este caso, a las tuberías o a los pipes. ¿Y qué es eso de las tuberías o los pipes? 00:15:48
Voy a mostrar aquí, porque quiero que veáis el dibujito, y quiero que veáis aquí qué es lo que tenemos. 00:16:09
Me dice, primeramente, ¿qué es una tubería? 00:16:20
Me dice, una tubería es una secuencia de uno o más comandos separados por la barra vertical. 00:16:24
¿Sí? 00:16:32
Lo podéis ver en este caso, como bien dice, una tubería. 00:16:33
¿Qué quiere decir esto? 00:16:38
escribimos por aquí si yo tengo este comando de aquí este comando me va a 00:16:39
producir una salida si me va a mostrar la información de esta carpetita de 00:16:47
aquí si yo no digo nada donde se me va a mostrar la salida pues en pantalla 00:16:53
verdad sí pues en lugar de decirle que se mal que se me lo muestre porque 00:16:58
nosotros tendríamos aquí el monitor vale y aquí es donde se me mostraría 00:17:03
Pues en lugar de decirle que se me muestre por pantalla, le estoy diciendo, oye, espérate, que en lugar de que esto lo muestres por pantalla, no quiero que lo muestres por pantalla, sino que quiero que se lo envíes al siguiente comando. 00:17:09
Y esto es lo que está haciendo aquí la tubería. Este de aquí está haciendo esta tubería de aquí. Lo quito y lo vuelvo a dibujar. Es decir, este de aquí lo que está haciendo es hacer una tubería para decirle, oye, la salida de este comando se la vas a enviar como entrada a este comando. 00:17:23
Entonces veis que aquí la salida de este proceso, de este comando, se la voy a pasar mediante una tubería y se va a convertir en los datos de entrada para el siguiente comando. 00:17:50
Y el siguiente comando, en este caso es el less. Y el less ya vimos que me muestra el contenido de lo que yo le pase pantalla a pantalla, que es lo que utiliza la ayuda de Linux. 00:18:05
Y fijaros que aquí de nuevo está representado cada uno de los canales. El 0 la entrada, el 1 la salida y el 2 la de los errores. 00:18:22
¿De acuerdo? Entonces repito, cuando yo utilizo este pipe, esta tubería, estoy haciendo que la salida del comando que está a su mano izquierda se lo pase al comando que está a mano derecha como la entrada a ese comando, como la información a ese comando. 00:18:42
¿Sí? ¿De acuerdo? 00:19:01
Y aquí me dicen, porque quiero que lo veáis, ¿vale? 00:19:04
Quiero que leáis esto que me pone aquí abajo. 00:19:08
Me dice, oye, si el redireccionamiento de la salida se usa en el medio de una tubería, 00:19:11
la salida irá al fichero. 00:19:18
Me explico. Ahora lo vamos a hacer para que lo veáis. 00:19:22
Me voy a salir de aquí y me voy a ir... 00:19:25
Si yo hago esto, digo, oye, vamos a poner un ls menos l de lo que hay aquí, ¿vale? 00:19:32
Esto bien, ¿verdad? 00:19:44
Pero, ¿y qué pasa si yo esto hago una tubería y le digo, oye, en lugar de que lo muestres por pantalla, se lo quiero pasar a un comando? 00:19:45
Y, por ejemplo, ya que hemos visto muy, muy, muy por encima el comando tr, digo, quiero que se lo pases al comando tr 00:19:54
Y quiero que me cambies las letras minúsculas por las letras mayúsculas. 00:20:00
¿Qué es lo que hace esto? 00:20:08
Pues fijaros que lo que ha hecho es que me ha cogido la salida de este comando, que es esta de aquí. 00:20:12
Pero ¿y a quién se la ha pasado? 00:20:25
Se la ha pasado al comando TR. 00:20:27
No la ha mostrado en pantalla, sino que se la ha pasado el comando tr. 00:20:31
De forma que este comando tr, ¿qué es lo que hace? 00:20:36
Pues con todo esto que le llega, me coge todas las letras minúsculas y me las convierte en mayúsculas. 00:20:40
Pues esto es lo que me ha mostrado aquí. 00:20:46
¿De acuerdo? 00:20:49
¿Entendéis qué quiere decir esto? 00:20:51
¿Qué pasa si yo ahora, en lugar de hacer esto, voy a hacer esto de aquí? 00:20:54
es decir, esto sabemos que hace 00:20:59
pero en lugar de hacer esto 00:21:02
yo le voy a poner 00:21:03
ls y le pongo 00:21:05
aquí salida ok 00:21:08
y le pongo la tubería 00:21:09
¿qué estoy haciendo ahí? 00:21:11
¿veis que el tr no me ha 00:21:17
hecho nada? ¿por qué? 00:21:18
porque cuidado 00:21:19
porque yo aquí le he dicho, oye 00:21:20
cógeme el comando ls y me lo 00:21:23
guardas en este ficherito 00:21:26
¿sí? y el resultado 00:21:27
Pero es que aquí no hay resultado, ya la he guardado en un fichirito 00:21:29
Es decir, aquí ya no le va a pasar nada 00:21:32
Aquí, no hay nada que pasarle 00:21:35
¿Me explico? 00:21:36
Entonces, sí que puedo hacer 00:21:39
En lugar de esto 00:21:41
Sí que puedo decirle 00:21:42
Oye, y una vez que me has mostrado esto 00:21:45
Que me lo muestras en pantalla 00:21:47
Pues ahora lo quiero guardar 00:21:49
En salida, yo que sé, ok 00:21:50
Y entonces ahora sí 00:21:53
Si yo le hago un cat de salida ok 00:21:54
Pues tendré la información 00:21:57
en mayúscula 00:21:59
¿me entendéis? 00:22:01
¿sí? 00:22:03
vale, ¿qué es lo que podemos hacer? 00:22:05
yo no sé si os acordáis que vimos 00:22:07
el comando tri 00:22:09
creo recordar 00:22:13
¿qué pasa si yo le digo tri? 00:22:14
y le digo de 00:22:18
y es cañaveral 00:22:19
para decirle que solamente me muestre los directorios 00:22:22
¿vale? 00:22:25
Veis que me ha mostrado toda la estructura de directorios, ¿vale? Y estas son, pues fijaros que sigo subiendo, sigo subiendo porque hay muchas carpetas, ¿sí? 00:22:27
¿Vale? Pues yo esto se lo puedo pasar a una tubería. Y le digo, mira, quiero que esto, por ejemplo, que se lo pases al comando para que me lo pongas todo en mayúscula, ¿vale? 00:22:40
Y me lo muestra todo en mayúscula, ¿sí? 00:23:00
Pero es que además, esto se lo puedo seguir pasando a otro. 00:23:03
Digo, mira, ahora quiero que, pues yo qué sé, vuelvo a ejecutar un tr y le digo, oye, mira, quiero que me cambies, yo qué sé, los números del 0 al 9 y quiero que me lo cambies, pues yo qué sé. 00:23:08
por 00:23:28
todo me lo va a cambiar por un 1 00:23:32
yo que sé, este de aquí 00:23:35
¿vale? entonces veis que 00:23:40
aquí me ha cambiado 1, 1 00:23:42
1, 1, 1, es decir, me ha cambiado 00:23:44
todos los números 00:23:46
todos los 0 a 1 por 1, 1, 1 00:23:46
entonces quiero que veáis que yo puedo ir 00:23:50
poniendo y además yo le puedo poner 00:23:52
aquí, oye 00:23:54
muéstrame la información poquito a poco 00:23:54
de forma que me va 00:23:58
mostrando la información 00:24:00
poquito a poco 00:24:01
¿vale? estoy pulsando la barra espaciadora 00:24:03
para bajar de línea a línea 00:24:05
entonces, ¿qué quiero que veáis? 00:24:07
quiero que veáis que yo puedo juntar aquí 00:24:10
¿vale? todos los pipes 00:24:12
que a mí me dé la gana 00:24:14
es decir, ejecútame un comando 00:24:16
ejecutado, ¿vale? 00:24:18
otro comando 00:24:20
tercer comando 00:24:22
y cuarto comando 00:24:24
¿qué es lo que hace 00:24:27
este de aquí? 00:24:29
Lo ponemos. La salida de este comando se la voy a pasar a este otro como entrada. 00:24:31
Este comando, si yo no pusiese más, me mostraría la información por defecto en la pantalla. 00:24:46
Pero como yo tengo otro pipe, le digo, oye, quiero que la salida de este comando se la envíes a este otro como entrada. 00:24:51
como tengo otro más, le digo, oye, quiero que la salida de este comando 00:25:00
en lugar de que se la envíes a pantalla, se la envíes 00:25:06
a este comando de aquí, ¿sí? y como este 00:25:09
ya no tiene más a que enviar, ¿dónde lo envía por 00:25:14
defecto? al std out, es decir 00:25:18
a la pantalla, es decir, al terminal 00:25:22
¿de acuerdo? entonces yo puedo juntar tantos pipelines como a 00:25:25
me dé la gana entendemos esto esto me permite dentro de linux y dentro de 00:25:30
windows también aunque en windows menos a no ser que utilice powers el que me 00:25:37
ofrece un juego impresionante de acuerdo yo puedo juntar aquí y extraer toda la 00:25:42
información que yo quiera entendemos qué quiere decir esto 00:25:47
de acuerdo hago otro ejemplo yo le puedo decir 00:25:53
Por ejemplo, quiero que me muestres los nombres en mayúsculas. 00:25:59
¿Sí? 00:26:06
Y yo no sé si os acordáis de que esto... 00:26:08
Tengo este comando. No sé si os acordáis. 00:26:13
Digo, pues mira, ordenamelo aleatoriamente. 00:26:17
¿Me seguís? 00:26:20
Y este comando, ahora quiero, por ejemplo, pasárselo al gead. 00:26:22
Y quiero que me muestre los cinco primeros. 00:26:27
¿Sí? 00:26:31
Y me muestra los cinco primeros. 00:26:32
Y ahora, de estos cinco primeros, quiero que me muestres los dos últimos. 00:26:35
Y me muestra los dos últimos. 00:26:41
¿Me vais siguiendo? 00:26:44
¿Sí? 00:26:46
Y esto de aquí, quiero que me lo guardes en un ficherito que se llame f2.txt. 00:26:47
Y me lo guarda en f2.txt. 00:26:54
Entonces, quiero que veáis todo lo que puedo juntar aquí. 00:26:57
Yo puedo jugar aquí con todo lo que yo quiera. 00:27:02
Yo le puedo decir, oye, cógeme, uy, perdonadme, cógeme este ficherito. 00:27:07
Es un comando, segundo comando, tercer comando, cuarto comando y el redireccionamiento. 00:27:14
Entonces, repito que es lo que hace esto. 00:27:22
me está cogiendo el resultado del primer comando 00:27:25
perdonad, el resultado del primer comando 00:27:30
y se lo está pasando al segundo como entrada 00:27:33
¿qué es lo que va a hacer el suv? 00:27:36
coge lo que le pasa a este comando de aquí 00:27:38
y lo muestra de forma aleatoria 00:27:40
pero resulta que en lugar de mostrarlo por pantalla 00:27:43
se lo tiene que pasar al siguiente comando 00:27:46
el siguiente comando recibe 00:27:49
lo que ha hecho el suv 00:27:51
que es coger y desordenar de forma aleatoria las líneas de ese fichero 00:27:54
y me va a coger y me va a mostrar las cinco primeras. 00:28:02
Pero en lugar de mostrarlo por pantalla, esas cinco primeras líneas se las va a pasar al tail. 00:28:06
El tail recibe esas cinco primeras líneas y de esas cinco primeras líneas, ¿cuál me va a coger? 00:28:14
Pues las dos últimas. 00:28:20
Y esas dos últimas, en lugar de mostrarlo por pantalla, ¿qué es lo que va a hacer? Pues lo va a abordar en este ficherito. ¿Me entendéis? ¿De acuerdo? 00:28:21
Por ejemplo, vamos a suponer que yo tengo el ficherito nombres mayúsculas. 00:28:30
¿Cómo haríais para decir que esta es la línea 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 y 11? 00:28:50
Pues yo solamente quiero que me muestre de la línea 5, 6 y 7. Es decir, 1, 2, 3, 4, 5, 6 y 7. Es decir, ¿cómo hacéis para decirle que os muestre solo estas tres líneas? ¿Cómo sería? 00:29:01
Es decir, esto es pregunta, imaginaros que yo lo pregunto en el examen. Oye, quiero obtener de este ficherito de la línea 5 a la línea 7 con un solo comando, ¿vale? Una sola línea de instrucción. ¿Cómo lo haríamos? Pues imaginaros que yo puedo hacer lo siguiente. 00:29:21
Tenéis varias opciones, ¿eh? Pero primeramente voy a coger y le voy a decir que me muestre del fichero, por ejemplo, estas líneas. 00:29:41
¿Estas líneas cuáles son? 1, 2, 3, 4, 5, 6, 7. Las primeras 7 líneas. ¿Sí? Pues, ¿cómo se lo digo? 00:29:55
Digo, oye, muéstrame las siete primeras líneas del ficherito, nombre mayúsculas, ¿sí? Ya tengo aquí las primeras siete. Ahora, ¿cuáles quiero? Yo quiero estas tres, ¿verdad? 00:30:04
¿Y estas tres cuáles son? Las tres últimas, ¿verdad? Pues yo este resultado se lo puedo pasar a un comando que me muestra las tres últimas. ¿Qué comando me muestra las últimas líneas de lo que yo le diga? Pues yo le digo el tail menos tres. 00:30:26
y efectivamente tengo aquí el resultado 00:30:49
que yo os pido, oye, cógeme las líneas del 5 al 7 00:30:54
y guárdamelas en un fichero, ¿vale? pues 3 líneas 00:30:59
punto txt 00:31:02
¿me seguís como va funcionando esto? 00:31:05
¿sí? ¿lo veis? 00:31:09
vale, una aclaración 00:31:13
Cuando nosotros vimos el comando tail o cuando nosotros vimos el comando head, ¿lo veis? 00:31:16
Pues nosotros en el comando tail o en el comando head siempre le poníamos el nombre del ficherito que quiero que me muestre. 00:31:26
Pues quiero que veáis aquí. 00:31:33
Yo le he dicho, oye, quiero que me muestres las siete primeras líneas y obviamente le he dicho el nombre del fichero 00:31:39
Porque le tengo que decir un nombre de fichero 00:31:47
Pero resulta que aquí no le he dicho un nombre de fichero 00:31:49
¿Veis dónde estoy? 00:31:54
¿Por qué no le he dicho ahí un nombre de fichero? 00:31:56
Porque automáticamente la salida de este comando 00:31:58
Va a ser la entrada de este 00:32:03
Así que él automáticamente lo va a coger de la entrada estándar 00:32:06
¿Sí? 00:32:09
Por eso aquí no le pongo el nombre de fichero 00:32:12
Porque ya se lo está pasando el anterior 00:32:13
No obstante, quiero que veáis que este comando y este comando son exactamente igual. 00:32:15
Y quiero que veáis que es lo que he puesto. 00:32:31
Cuando yo tengo aquí este comando, le digo, oye, muéstrame las primeras siete líneas. 00:32:36
Y se la vas a pasar al comando tail. 00:32:55
Pues quiero que veáis que aquí en el comando tail he puesto esto de aquí. ¿Qué representa este guión? Este guión representa que va a coger la entrada de lo que le viene del comando anterior. 00:32:57
Es decir, que la salida de este es como si me crease un fichero temporal, ¿vale? 00:33:18
Y la salida de este comando, para indicar que este ficherito, o sea, que el ficherito lo va a coger de la salida anterior, le tengo que poner un guión. 00:33:30
Pero fijaros que si no pongo nada, él lo entiende perfectamente. 00:33:40
¿Por qué os explico esto? 00:33:45
Porque hay comandos que tú le vas a tener que indicar dos ficheritos. 00:33:47
Pues para decirle que uno de los ficheritos es el resultado del comando anterior, pues que sepáis que para decirle cada vez que pongáis un guión, le estáis diciendo que esa parte la coge de aquí, ¿vale? 00:33:51
Me explico. Imaginaros que esta salida me la guarda en un ficherito temporal que se llame temporal.txt, ¿sí? Pues este ficherito es como si lo pusiese aquí. Es como si yo estuviese escribiendo tail-3 temporal.txt, ¿de acuerdo? 00:34:03
Entonces, repito, esto y esto de aquí arriba es exactamente igual, ¿vale? Entonces, si lo veis más claro que para decirle un guión, el guión es para decirle, oye, coge el ficherito resultado de la salida anterior, salida anterior, guión, ¿de acuerdo? 00:34:29
Y una vez que me ha mostrado los tres primeros, lo guardamos en el tres líneas punto txt. 00:34:47
¿Sí? ¿Entendemos esto? 00:34:54
Vale. 00:34:57
Pues vamos a seguir un poquito para adelante. 00:34:59
Y vamos a ver que, cuidado con el orden, ¿vale? 00:35:04
En las transparencias pongo un ejemplo muy claro para que veáis que no es lo mismo dependiendo de cómo ponga yo los comandos en las tuberías, 00:35:11
tú verías, porque os comento, tenéis un comando, vamos a hacer el ejemplo con el nombres mayúsculas, ¿vale? 00:35:19
Si yo hago cat nombres mayúsculas, tengo este de aquí, ¿sí? 00:35:28
Yo no sé si recordáis que el cat tenía una opción que se llamaba guión n, que lo que me hace es numerar las líneas, ¿lo veis? 00:35:36
pues imaginaros que yo voy a hacer esto 00:35:44
por ejemplo 00:35:49
si yo le digo que me enumere las líneas 00:35:52
y que me muestre 00:36:05
las 5 últimas 00:36:07
me pone 8, 9, 10, 11, 12 00:36:11
¿lo veis? 00:36:17
pero no es lo mismo que si yo le digo 00:36:18
oye, muéstrame las cinco últimas líneas de nombres mayúsculas y le digo un cat menos n. 00:36:20
Quiero que veáis que el resultado sí que me dice Alejandra, Fernando, Luis y Pedro, 00:36:32
pero aquí influye en la manera en que ejecuto las tuberías, ¿de acuerdo? 00:36:38
Entonces, simplemente que tengáis en cuenta consideraciones como esta, ¿de acuerdo? 00:36:44
Entonces, me queda explicar una tontería. Bueno, sí, la voy a explicar aquí aunque se me vayan 10 minutos más. Me queda un comando que lo voy a mostrar aquí, que es el último que vamos a ver en cuanto a reaccionamiento a tuberías, que es el siguiente. 00:36:50
Este lo hemos visto, este lo hemos visto, este de aquí. ¿Cómo funciona este comando? Este comando, fijaros que me dice envía la salida de un comando a dos sitios a la vez, a un fichero y a pantalla. 00:37:08
¿Vale? Fijaros cómo funciona. Es ti, las opciones, que solamente os voy a pedir esta opción, guión a. Ahora vamos a ver dos ejemplos para que lo veáis. Fijaros este de aquí que yo tengo. Voy a quitar esto de su momento. Le digo, oye, quiero que me ejecutes el comando ls. Y se lo paso al comando ti. ¿Qué es lo que hace el comando ti? 00:37:30
El comando t lo envía a dos sitios, ¿sí? Lo envía a dos sitios. Lo envía a la salida estándar, que es esta de aquí, a la salida estándar, es decir, a pantalla. 00:37:51
y además lo guarda en el ficherito que le hemos puesto ahí, fich.txt, ¿sí? Hace las dos cosas en uno, ¿sí? 00:38:08
Si yo no le digo nada, si este ficherito de aquí existe, lo que hace es sobrescribirlo. 00:38:18
Pero si yo no quiero que sobrescriba, sino que lo añada, para eso tenemos esta opción, la opción guión a, ¿sí? 00:38:24
En la siguiente transparencia lo veis con un dibujito que para mí está muy claro de cómo funciona. Podéis ver el comando T como si fuese lo de la canalización que nosotros tenemos aquí. Lo pongo por aquí. Es decir, esta tubería. ¿Qué es lo que hace el comando T? 00:38:33
El comando ti, cuando yo pongo aquí el ti, me dice, vale, lo voy a mandar por un lado, ¿vale? A un ficherito que yo te diga. Y por otro, ¿vale? Lo voy a mandar a pantalla. Entonces, lo envía a dos sitios a la vez. 00:38:52
Entonces, fijaros aquí abajo que me dice, oye, quiero que me ejecutes el comando ls y se lo voy a pasar al comando ti. Entonces, el comando ti lo va a mostrar en dos sitios, por pantalla y además lo va a guardar en este ficherito. 00:39:09
Pero fijaros que además me dice 00:39:29
Oye, pues la parte que va a la pantalla 00:39:32
No la envíes a la pantalla 00:39:34
Sino que envíasela al comando less 00:39:35
¿Sí? 00:39:38
Entonces, el comando t 00:39:41
La verdad es que está chulísimo 00:39:43
Entonces vamos a ver un ejemplo de cómo funciona el comando t 00:39:44
Salgo de aquí 00:39:48
Imaginaros 00:39:54
Que yo le digo 00:39:59
Oye, quiero que me muestres 00:40:01
El ficherito 00:40:04
nombres mayúsculas 00:40:06
esto me muestra los nombres en mayúsculas 00:40:09
vamos a decirle que nos muestre los tres primeros 00:40:11
para que no sea tan grande 00:40:14
quiero que me muestre los tres primeros nombres 00:40:16
y ahora, mediante la tubería 00:40:21
se lo voy a pasar al comando ti 00:40:24
y al comando ti le voy a poner 00:40:26
salida1.txt 00:40:29
y quiero que veáis que hace esto 00:40:35
me lo sigue mostrando en pantalla 00:40:37
pero además me ha creado 00:40:40
un ficherito que se llama 00:40:42
salida1.txt 00:40:44
¿sí? 00:40:45
entonces, ¿qué es lo que ha hecho? me lo ha enviado 00:40:47
a dos sitios 00:40:50
¿vale? este comando 00:40:51
¿qué es lo que ha hecho? 00:40:54
por un lado, me lo envía 00:40:55
a la salida 00:40:58
hemos visto que me lo pone en pantalla 00:40:59
y por otro lado 00:41:02
me lo guarda en este ficherito 00:41:04
Es decir, me hace dos operaciones en una. ¿Lo veis? ¿Sí? Pero es que también puedo hacer cosas como esta. Le digo, oye, quiero que no me lo machaques, quiero que me lo añadas, quiero que me lo añadas ahora, ¿vale? La A es para que si existe el fichero me lo añadas. 00:41:06
Y además, quiero que lo que muestres en pantalla, pues quiero que me lo conviertas de mayúscula, por ejemplo, a minúsculas, ¿sí? Vamos a ver qué hace este comando. 00:41:25
¿Qué es lo que ha hecho este comando? 00:41:40
Primeramente, me ha mostrado las tres líneas del ficherito 00:41:45
Se la ha pasado al comando ti 00:41:50
Y el comando ti, ¿qué es lo que va a hacer? 00:41:54
Como le hemos dicho aquí, la opción guión a 00:41:57
Es decir, queremos añadir al ficherito salida.txt el resultado de este comando 00:42:00
Es decir, este comando se lo va a pasar aquí 00:42:06
Así que las tres primeras líneas de nombre mayúsculas, ¿a quién se le va a añadir? Al ficherito salida1.txt. El salida1.txt ya tenía tres líneas, así que ¿ahora cuántas va a tener? Pues otras tres. 00:42:09
¿Sí? Pero es que además, para decirle que, oye, además me vas a mostrar la salida en pantalla, pero además, ¿vale? Es decir, pero en lugar de mostrarlo en pantalla, se lo vas a pasar al siguiente comando. 00:42:22
¿Y qué es lo que hace el siguiente comando? Pues me convierte, en este caso, las mayúsculas a minúsculas. 00:42:40
Pero mi pregunta es, ¿en salida 1.txt qué ha metido? ¿Las mayúsculas o las minúsculas? 00:42:48
Porque esto lo ha convertido después. Así que si yo le digo que me haga un cat de salida 1, fijaros que están lo que teníamos antes. 00:42:55
esto es lo que había antes 00:43:05
y esto es lo que ha añadido ahora del comando ti 00:43:08
entonces teníamos 00:43:11
este comando 00:43:15
y hemos visto que teníamos lo de antes 00:43:18
y teníamos lo que ha añadido este comando 00:43:23
este comando que es lo que ha añadido 00:43:26
pues ha añadido esto de aquí 00:43:28
¿de acuerdo? 00:43:32
Y además, repito, como lo muestra en pantalla, no quiero que lo muestres en pantalla, sino que se lo pases a este comando y este comando lo que ha hecho es mostrarnos los tres primeros nombres en minúscula. ¿Entendéis esto? ¿Sí? Entonces, hay veces que está muy bien utilizar el comando t, porque me hace dos cosas en una. Es una tubería en forma de t, que lo envía a dos sitios diferentes, a pantalla y a un fichero. ¿De acuerdo? ¿Sí? Vale. 00:43:33
Pues solamente me queda un comando 00:44:03
Que lo he metido aquí, pero bueno 00:44:05
Que sepáis que tenéis un comando 00:44:06
Que lo he metido en estas transparencias 00:44:09
Pero no sé muy bien por qué 00:44:12
Pero en fin 00:44:13
Imaginaros que nosotros tenemos esto 00:44:13
Nano 00:44:16
Listado 1.txt 00:44:18
Y tenemos una serie de valores ordenados 00:44:23
Que tengo aquí 00:44:26
4, pero ordenados alfabéticamente 00:44:31
así que yo voy a tener aquí 00:44:35
Albacete, que no lo estoy poniendo ordenado 00:44:37
Cuenca 00:44:42
Barcelona 00:44:46
yo qué sé, me lo estoy inventando 00:44:51
yo tengo esos valores 00:44:59
pues imaginaros que yo Cuenca 00:45:06
Lo tengo tres veces repetidas 00:45:10
Galicia lo tengo cinco veces repetidas 00:45:13
¿Vale? 00:45:16
Porque imaginaros que yo tengo nombres de alumnos 00:45:18
O nombres de departamentos 00:45:20
Y yo quiero quitar los repetidos 00:45:22
Es decir, yo quiero que me muestre este ficherito 00:45:24
Pero que las líneas que están repetidas no me las repita 00:45:27
Porque yo solamente quiero ver cuántos departamentos hay, por ejemplo 00:45:30
O cuántos nombres diferentes tiene mi empresa 00:45:33
O yo qué sé 00:45:36
entonces si yo tengo este ficherito que tiene que estar ordenado 00:45:37
tenéis este comando que se llama unic 00:45:42
que si yo le digo el nombre del ficherito 00:45:45
pues fijaros que es lo que me hace 00:45:47
me muestra el contenido de ese ficherito 00:45:48
pero quitando las líneas repetidas 00:45:52
que única condición tenéis que tener 00:45:54
que ese ficherito tiene que estar ordenado 00:45:57
y lo único que hace este comando es quitar las líneas repetidas 00:46:00
¿de acuerdo? 00:46:04
¿sí? 00:46:06
Vale, pues con esto terminamos en este caso los redireccionamientos y ahora vamos a pasar a las segundas transparencias de comandos básicos de Linux. 00:46:07
Venga, un saludo. 00:46:16
Idioma/s:
es
Autor/es:
Fernando Herrero Núñez
Subido por:
Fernando Jesús H.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
13
Fecha:
30 de diciembre de 2022 - 20:49
Visibilidad:
Público
Centro:
IES EL CAÑAVERAL
Duración:
46′ 18″
Relación de aspecto:
1.85:1
Resolución:
1920x1040 píxeles
Tamaño:
111.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid