Saltar navegación

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

Redirección y tuberias en linux - 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.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Buenos días, vamos a empezar ahora con la parte de redireccionamiento y tuberías. 00:00:01
Esta parte ya la visteis en Windows, entonces os tiene que sonar prácticamente todo lo que vimos en Windows. 00:00:07
Voy a poner las primeras transparencias porque quiero que veáis un par de dibujos que creo que se entiende bastante bien de qué va la cosa. 00:00:17
y ahora vamos a empezar viendo diferentes ejemplos y funcionamientos 00:00:25
vale, quiero que veáis aquí 00:00:31
que dentro de, me da igual que sea Linux o Windows 00:00:36
pero bueno, estoy hablando ahora de Linux 00:00:43
cuando se hablan de cualquier proceso o los comandos 00:00:45
estoy hablando 00:00:49
voy a utilizar el lápiz 00:00:51
me están hablando aquí arriba 00:00:53
de que yo tengo tres descriptores 00:00:58
¿Qué es esto de descriptores? Dentro de cuando se habla lo que digo de procesos, se habla de lo que es la entrada estándar, que este es el dibujito que creo que se entiende muy bien, es decir, todo proceso va a tener una manera en la que yo voy a introducir la información y esa entrada es la que se llama el stdin y tiene asignado el numerito 0, ¿vale? 00:01:01
Pero también tenemos lo que se llama la salida estándar. Cuando un proceso tiene que enviar sus datos, su información hacia la salida, yo voy a tener dos tipos de entre comillas salidas. 00:01:28
La salida de la información correcta que tiene asignado el numerito 1 y que se llama stdout, que por defecto, ¿cuál es la salida donde todos los procesos van a mostrar sus resultados? 00:01:41
pues obviamente por defecto va a ser el monitor 00:01:57
entonces normalmente nosotros como introducimos la información dentro de un proceso 00:02:01
o se lo decimos a un comando mediante el teclado 00:02:08
y cuando ese proceso tiene que indicarnos su solución 00:02:12
su resultado por donde lo hace por el monitor 00:02:16
pues tenemos la entrada el stdin asignado el numerito 0 00:02:20
y el stdout asignado, el numerito 1, ¿sí? 00:02:25
Pero que sepáis que hay un tercero, que es en este caso el numerito número 2, 00:02:30
que es el que se llama stdr. 00:02:36
Y resulta que cuando un proceso va a mostrarte información, te pueden mostrar dos cosas. 00:02:40
El resultado correcto de haberse ejecutado, ¿vale? 00:02:47
Y por defecto va a ser el stdout, pero también puede ocurrir que el proceso esté haciendo algo y haya producido un error. 00:02:51
¿Cómo te indica ese error? Pues te lo envía por la salida número 2, que se llama stderr. 00:03:01
Por defecto, la salida de errores también se muestra, si no le decimos nada, en el monitor. 00:03:07
De forma que tanto STDout como STDair, tanto la salida estándar como el error estándar, se me muestran en la pantalla del monitor. 00:03:15
Pues que sepáis que todos los numeritos superiores a esto, 3, 4, 5, 6, 7, 8, en este caso son conexiones que se utilizan para ficheritos. 00:03:27
Por ejemplo, si hay un proceso que tú le introduces los valores por el stdin 00:03:39
Abre un ficherito como puede ser apuntes 00:03:47
Pues el apuntes, internamente el sistema operativo le puede asignar el número 5 00:03:51
De forma que cuando él vaya a mostrar sus resultados 00:03:55
¿Dónde lo va a guardar? En el numerito 5 que corresponde al ficherito apuntes 00:04:00
¿Esto lo entendemos? 00:04:04
vale vamos a seguir uno más para adelante porque aquí tenemos un resumen de los diferentes canales 00:04:08
que nosotros tenemos y hacemos un repaso hemos dicho que el numerito 0 es la salida de perdón 00:04:21
la salida perdonarme la entrada estándar que la entrada estándar por defecto va a ser un teclado 00:04:30
tenemos el numerito 1 que se refiere a la salida estándar y la salida estándar por defecto se nos va a mostrar en el monitor 00:04:35
y luego tenemos la salida de errores, los errores que nos envía el comando, el proceso va a ser en este caso el nombre stder 00:04:46
y por defecto también se me muestra en el mismo sitio que la salida estándar, es decir en el terminal 00:04:57
Y todo lo que sea superiores a ese numerito, normalmente son descriptores refiriéndose a los ficheros. 00:05:04
¿De acuerdo? Vale. 00:05:11
Vamos a hacer en este caso un ejemplo para que vosotros entendamos. 00:05:14
Y ahora vuelvo sobre este de aquí. 00:05:19
Entonces, vamos a irnos a nuestra máquina, que esta es la que llevamos trabajando en vídeos anteriores. 00:05:21
Siempre voy a utilizar la misma máquina. 00:05:33
abrimos un terminal y lo primero que voy a hacer porque quiero que os acostumbréis a saber dónde 00:05:35
estáis voy a cambiar el prom y voy a poner por ejemplo simplemente un dólar vale porque así nos 00:05:44
acostumbramos a que si sé dónde estoy pues ya sabéis pw estoy ahí de acuerdo como ya sabemos 00:05:59
en este caso los comandos básicos estoy aquí en el s sí vale pues me voy a ir al scan a ver al 00:06:06
y vamos a ver qué es lo que tengo aquí aquí tengo un montonazo de ficheritos que ya creamos en la 00:06:15
versión anterior y por ejemplo vamos a hacer lo siguiente vamos a crear una carpeta que se va a 00:06:21
llamar en este caso sábado 28 y me voy a 00:06:32
meter en sábado 28 y voy a crear aquí 00:06:42
por ejemplo tres ficheros touch y le 00:06:47
digo aquí fichero 1 punto txt fichero 00:06:52
2.txt 00:06:58
y fichero 3.txt 00:07:00
¿de acuerdo? 00:07:04
entonces cuando yo ejecuto el comando 00:07:05
esto que estáis viendo aquí 00:07:09
esto que estamos 00:07:12
viendo aquí 00:07:17
es el 00:07:18
st de auto 00:07:24
porque aquí no me 00:07:27
está diciendo ningún error, yo le he dicho 00:07:28
que me ejecute el comando ls 00:07:30
y él me ha dicho los ficheros que dentro de la carpeta decir todo está correcto de forma que 00:07:32
esto de aquí me está mostrando la salida correcta la salida estándar y esto ya vimos que teníamos 00:07:37
asignado el numerito refiriendo refiriéndonos al std out el numerito número uno de acuerdo 00:07:44
¿Sí? Vale, pero ¿y qué pasa si yo le digo, oye, perdona, quiero que me muestres, que estaba pinchando afuera, quiero que me muestres fichero 1 y le pongo aquí 1 que no existe, punto txt. 00:07:55
le estoy diciendo al comando ls que quiero que me muestre la información de esos dos ficheros 00:08:19
le voy a poner guión gele porque quiero que veáis 00:08:25
quiero que veáis que yo a este comando le estoy indicando 00:08:30
oye, quiero que me muestres información de este ficherito y quiero que me muestres información de este ficherito 00:08:35
¿sí? ¿qué es lo que pasa? 00:08:42
pues que este ficherito de aquí sí que existe y me va a mostrar información pero cuando intente 00:08:45
buscar este ficherito no existe entonces él te va a decir oye hay un error ese ficherito que se 00:08:53
llama uno que no existe no existe y me lo dice y eso como me lo dice mediante un error sí entonces 00:08:59
Entonces, si yo ejecuto esto, quiero que veáis qué es lo que me aparece. 00:09:07
Esto de aquí, esto de aquí, me está indicando que es un error y esto de aquí me está diciendo que es correcto. 00:09:15
De forma que, perdonad, este de aquí y este de aquí son dos cosas diferentes. 00:09:31
El que está en rojo, ¿qué es? Pues en este caso, el std error, que tiene asignado el numerito 2. 00:09:41
Y este de aquí, ¿cuál es? Pues este de aquí es el std out, que tiene asignado el numerito 1. 00:09:54
Esto de aquí es correcto, es lo que me devuelve el comando de forma correcta 00:10:04
Y esto de aquí es un error que me devuelve el comando 00:10:10
Porque este ficherito no existe, me lo está diciendo 00:10:18
Oye, ls no puede acceder a a porque no existe el fichero 00:10:21
¿Entendéis lo que es el stder y el stdout? 00:10:25
¿De acuerdo? ¿Sí? 00:10:30
¿Y cómo sirve y para qué sirve el stdin para la entrada? 00:10:31
Pues la entrada sirve para informar, en este caso, de lo que yo le quiero dar al comando. 00:10:37
Por ejemplo, si yo hago esto de aquí, le digo cat y le doy al intro, 00:10:43
él me está pidiendo que yo escriba cosas. 00:11:02
y lo pongo aquí, hola 00:11:04
y me pongo adiós 00:11:07
entonces, ¿de dónde está esperando el que yo lo introduzca datos? 00:11:10
pues en este caso estoy escribiendo del teclado 00:11:15
entonces este, perdonadme 00:11:17
control c 00:11:20
y lo quitamos, eso ya lo veremos 00:11:22
entonces, yo tengo la entrada, ahora veremos muy claro para qué es la entrada estándar 00:11:30
con un comando que da mucho juego 00:11:35
vale pero eso lo veremos más adelante vale vamos a seguir con las transparencias y vamos a ver qué 00:11:38
opciones nosotros tenemos entonces nosotros vimos estas opciones que nosotros tenemos aquí 00:11:44
esto os tiene que sonar porque lo vimos ya dentro de windows yo tengo diferentes tipos 00:11:52
de redireccionamiento que es eso de redireccionamiento yo puedo decirle que me 00:11:59
vuelvo a aquí ahora si yo le hago un ls si yo no digo nada donde os he dicho que por defecto 00:12:06
se me muestra la salida en pantalla en este terminal sí pero qué pasa si en lugar de que 00:12:36
se me muestre aquí que es en pantalla yo quiero que esta información de salida se me vaya a otro 00:12:42
pues yo puedo utilizar lo que se llaman el redireccionamiento vale es redirigir imaginaros 00:12:50
que yo tengo una canalización de agua que por defecto esa canalización va a un tanque pues yo 00:12:58
puedo redirigir vale poniendo digamos que una canalización y en lugar de ir al tanque pues 00:13:05
que vaya a otro tipo de depósito entonces yo puedo redirigir tanto la salida como la de 00:13:13
errores de acuerdo entonces vamos a ver cómo puedo hacerlo y vamos a ver aquí 00:13:20
primeramente si yo utilizo un mayor y un nombre de fichero repito un mayor y un nombre de fichero 00:13:28
le estoy diciendo que me va a coger la salida estándar, y lo que va a hacer es enviarla a este ficherito que yo he puesto después del mayor. 00:13:36
Si ese fichero no existe, lo crea. 00:13:51
Pero si ese fichero ya existe, machaca lo que hay dentro con lo nuevo que yo le he dicho. 00:13:57
¿Sí? Pues vamos a verlo 00:14:04
Vamos yendo uno por uno para que veáis 00:14:06
Si nos vamos a la máquina 00:14:09
¿Qué pasa si yo le digo un ls? 00:14:13
Ya hemos dicho que esto se me muestra en pantalla, ¿verdad? 00:14:17
Pero ¿qué pasa si yo no quiero que se me muestre en pantalla? 00:14:20
Voy a hacer una cosa 00:14:24
Voy a utilizar esta opción para que se me muestre en una columna solo 00:14:25
¿De acuerdo? 00:14:30
Entonces, ¿qué pasa si yo esto le digo un mayor? 00:14:31
si os acordáis que numerito tiene asignado la salida estándar tiene asignado el numerito 1 00:14:34
así que esto y esto es lo mismo entonces quiero que entendáis que si yo no digo nada 00:14:43
El poner un mayor, ¿vale? Y pongo aquí mi fichero 1.txt y poner un 1 y un mayor, mi fichero 1.txt, es lo mismo, porque si yo no pongo nada aquí, él entiende que lo que va a haber aquí es un 1, ¿de acuerdo? 00:14:53
vale, pues 00:15:23
¿qué le digo con esto? 00:15:24
si yo le digo, oye, quiero que me muestre 00:15:26
el ls 00:15:28
vamos a hacerlo bien 00:15:29
de fichero asterisco 00:15:31
y en lugar de mostrármelo 00:15:34
por pantalla, quiero que lo guarde 00:15:37
en un fichero, quiero redirigir 00:15:39
la salida a un fichero 00:15:41
si yo le pongo aquí 00:15:43
fichero 00:15:45
le pongo salida 00:15:47
1.txt 00:15:49
¿Ves que él no me ha mostrado nada en pantalla? 00:15:51
¿Por qué no me ha mostrado nada en pantalla? 00:15:56
Porque en lugar de mostrar el resultado en la pantalla 00:15:58
Yo le he dicho que me la redirija 00:16:02
Es decir, no me la envíes a la pantalla 00:16:06
Envíamelo al fichero que yo te diga 00:16:07
Y lo ha enviado este fichero 00:16:10
Como este fichero no existe 00:16:11
Fijaros que me lo ha creado aquí 00:16:13
Yo lo tengo aquí 00:16:15
¿Sí? 00:16:18
Me ha creado el ficherito. Si yo le digo que me diga que contiene el ficherito, que este comando ya lo conocemos, fijaros que me dice que contiene el resultado de ejecutar un ls-1 fichero. ¿Lo veis? ¿Sí? 00:16:19
Pero ¿y qué pasa si yo ahora hago esto? Yo le digo echo, quiero que veáis lo que contiene el salida. ¿Qué pasa si yo le digo echo hola y le digo mayor y le digo salida? ¿Qué es lo que va a pasar aquí? 00:16:34
Aquí lo que me va a pasar es que como salida txt ya existe porque contiene esto de aquí, me va a machacar, me va a sobrescribir todo lo que hay dentro de salida para meterme, en este caso, esto de aquí. 00:16:52
De forma que si yo esto lo ejecuto, no me muestra nada en pantalla, porque le estoy diciendo que en lugar de mostrarme hola en pantalla, se redirija, se envíe a el ficherito salida.txt. 00:17:15
Si yo le digo que me diga qué es lo que hay en salida, qué es lo que ha hecho, pues obviamente habéis visto que antes tenía esto, y ahora, ¿qué es lo que contiene? 00:17:30
hola me ha machacado entendéis cómo funciona el redireccionamiento sí pero quiero que veáis 00:17:42
también que si yo lo ejecuto este fichero de aquí sí y le digo oye ls fichero 1 punto txt y no existe 00:17:52
punto txt si quiero que veáis qué va a pasar veis que antes no me había mostrado nada lo hago lo 00:18:06
hago como éste no me muestra nada porque porque en salida 1 que me ha metido por la información 00:18:14
de ese fichero vale si queréis verlo más si le pongo un l para que me lo muestre en formato 00:18:21
detallado veis que me muestra el resultado del ls pero qué pasa si yo hago esto f1 y le digo 00:18:27
no existe punto txt qué es lo que ha hecho lo voy a hacer con el 2 con el fichero 2 porque 00:18:37
quiero que veáis que me queda machacado si yo le digo cat de salida efectivamente me ha metido 00:18:46
dentro del salida 1 el resultado correcto es decir me ha redirigido la salida correcta el 00:18:56
std out el que tiene el numerito 1 pero qué ha pasado con el error qué ha pasado con este 00:19:05
fichero que es un error pues este fichero no me lo ha guardado en el fichero porque cuando yo le 00:19:13
digo un mayor y le digo o le digo un 1 y un mayor, sólo me redirige la salida correcta, sólo me 00:19:20
redirige la salida correcta. Los errores los sigue mostrando en pantalla. Quiero que lo veáis, ¿de 00:19:29
acuerdo? Esto de aquí es un error y por lo tanto este error tiene asignado el numerito 2 y no se 00:19:36
me redirige porque como yo aquí vale no he puesto nada esto es lo mismo que poner un 1 y un mayor 00:19:47
de acuerdo si vale vamos a seguir un poquito con la transparencia 00:19:57
y vamos a ver la segunda opción y en la segunda opción nosotros tenemos exactamente igual pero 00:20:03
con dos mayores los dos mayores funciona exactamente igual que el de arriba el de un 00:20:10
mayor lo que pasa que en lugar del si el fichero existe en lugar de sobre escribirlo lo que hace 00:20:16
es añadir agregar la información a ese fichero pues vamos a ver cómo funciona si nosotros nos 00:20:24
vamos y le decimos tenemos a este fichero verdad os acordáis qué pasa si yo le digo eco 00:20:33
o la caracola y en lugar de decirle un mayor le digo dos mayores a la salida 00:20:44
si yo le digo que me muestre quiero que veáis qué es lo que ha pasado antes salida contenía 00:20:51
esta única línea, ¿sí? Pero como yo le he dicho hola caracola y le he dicho los dos mayores, ¿qué es lo que ha hecho? 00:20:59
Pues lo que ha hecho el mayor es añadir al ficherito dejando todo lo que había, ¿sí? 00:21:15
Entonces, quiero que veáis que ha dejado lo que había y ha añadido lo que yo le he dicho que añada. Funciona exactamente igual. Si este fichero no existe, lo crea, pero si existe, en lugar de sobreescribir, lo añade porque tenemos los dos mayores. ¿Entendemos esto? Vale. 00:21:22
Vamos a continuar para ver las otras opciones 00:21:46
Nos vamos al siguiente 00:21:50
Y aquí me están hablando de que exactamente igual que antes yo tengo el mayor 00:21:51
Pero ahora explícitamente le pongo en delante un 2 00:21:58
¿Os acordáis que quiere decir el 2? 00:22:03
Representa la salida de errores 00:22:06
Entonces, ¿qué es lo que hace esto? 00:22:08
Pues lo que hace es redirigir los errores al ficherito que yo le indiqué. 00:22:10
Entonces, fijaros que yo lo puedo juntar esto como a mí me da la gana. 00:22:17
Le digo, oye, la salida correcta va a ir a un fichero y los errores van a ir a otro fichero. 00:22:21
Entonces, para los errores tengo que poner delante del mayor un 2, que representa la salida de errores. 00:22:27
Y ya que estoy, vamos a ver esta de aquí abajo. 00:22:36
¿Qué quiere decir esto de aquí? Hemos dicho que quiere decir que vamos a redirigir los errores hacia un fichero, que hemos dicho que ese es el ejemplo que hemos visto aquí. 00:22:38
Pero que sepáis que si yo pongo este dispositivo, ¿vale? Raya def null, lo que le estoy diciendo es que cojas todos los errores y que los envíes a un agujero negro, como si fuese a la papelera. 00:22:49
entonces, ¿qué estoy diciendo con eso? 00:23:06
que los errores no me los muestre por pantalla 00:23:09
¿sí? 00:23:12
entonces, hay un dispositivo especial 00:23:13
que está dentro de la carpetita 00:23:15
dev, que se llama 00:23:17
null, que todo lo que yo envíe 00:23:19
ahí, es como si fuese un agujero 00:23:21
negro, desaparece 00:23:23
¿sí? entonces, cuando vosotros 00:23:24
queréis decirle que no queréis hacer nada 00:23:27
con los errores, que no lo queréis ver 00:23:29
que no os interesa, pues 00:23:31
esto se utiliza un montonazo 00:23:33
Y decir, oye, cógeme los errores y envíamelos al infinito y más allá. No quiero ni verlos. ¿De acuerdo? Entonces, descartar. Siempre que queráis tener esa posibilidad de enviar algún agujerito negro para que se pierda, dispositivo raya dev, raya null. ¿De acuerdo? Vamos a ver ejemplos de cómo funciona esto. 00:23:35
no vamos aquí 00:23:56
hemos dicho 00:24:02
voy a partir en este caso de 00:24:05
este ficherito de aquí 00:24:07
este ficherito de aquí 00:24:09
este comando de aquí 00:24:11
hemos dicho que me va a devolver 00:24:13
dos cosas 00:24:15
en rojo voy a poner 00:24:17
lo que me ha devuelto como error 00:24:19
y en 00:24:21
verde voy a poner 00:24:24
la salida, el stdout 00:24:25
repito, en rojo 00:24:28
la salida de errores y en verde la salida correcta el std out sí qué pasa si yo hago esto le oye 00:24:29
quiero que la salida de errores quiero que se envíe por ejemplo a salida error 1 punto txt 00:24:39
qué es lo que ha pasado para que lo veamos pues fijaros que como yo le he dicho aquí 00:24:50
digo oye quiero que este comando quiero que el error me lo envíes en este caso así ficherito 00:25:04
y qué es lo que ha hecho pues resulta que el salida air que es lo que contiene pues contiene 00:25:16
justamente solo el error del fichero yo no sé si veis aquí arriba que lo teníamos en rojo 00:25:24
Este de aquí arriba era el error que me daba y resulta que este error es el que le hemos dicho que ahora se almacena en un ficherito, ¿sí? 00:25:35
¿De acuerdo? Pero como yo no le he dicho nada respecto a la salida normal, pues la salida normal, ¿dónde se sigue enviando? Pues la salida normal se sigue enviando, lo mostramos aquí, se sigue enviando a la salida estándar. 00:25:46
¿Y yo puedo enviar la salida a un sitio y los errores a otro? Pues sí. ¿Cómo lo podríamos hacer? Yo le puedo decir lo siguiente. Digo, mira, me vas a mandar la salida normal, que va a ser salida correcta. 00:26:05
entonces que le estoy diciendo con esto le estoy diciendo oye quiero que la salida correcta la 00:26:27
almacenes dentro del fichero salida correcta punto txt que repito he puesto aquí uno para 00:26:34
que lo veáis pero poner uno y no poner nada es exactamente lo mismo repito esto de aquí el 1 00:26:40
si yo no pongo nada él entiende que por defecto es un 1 sí entonces le estoy indicando que por 00:26:49
un lado me coja la salida correcta y me la guarda en este fichero y además estoy diciendo que los 00:26:56
errores se me guarden en esta salida sí entonces si yo esto lo ejecutó no me muestra nada en 00:27:04
pantalla pero si yo ahora le digo oye quiero que me muestres la salida correcta y qué es lo que 00:27:13
me muestra pues obviamente la parte correcta del fichero oye del comando si yo le digo ahora que 00:27:20
me muestre la salida de errores 1 que me está mostrando pues en este caso los errores sí 00:27:27
entonces repito la salida correcta que la teníamos aquí como yo le he dicho que la salida correcta 00:27:36
ahora se guarde en un fichero donde se me son donde se me ha guardado la salida correcta pues 00:27:46
fijaros que en el fichero correspondiente como yo ahora le he dicho arriba dijimos que el error que 00:27:54
también por defecto se me mostraba en la salida que es lo que ha hecho esta parte de aquí pues 00:28:01
le hemos dicho oye ahora quiero que la salida en lugar de que me lo muestre en pantalla quiero que 00:28:08
el almacén es pues en la salida y es efectivamente lo que ha hecho aquí me entendéis para que es el 00:28:14
1 y el 2 de acuerdo vale y qué pasa si yo ahora hago esto qué pasa si yo le digo oye quiero que 00:28:20
la salida la muestres vale solo la salida correcta que repito el poner un 1 y no ponerlo es exactamente 00:28:34
igual. Veis que el error se me muestra, ¿verdad? Pero imaginaros que el error yo no lo quiero ver, 00:28:42
lo quiero descartar, no quiero verlo, ¿vale? Lo quiero enviar a la basura, no quiero que me lo 00:28:48
muestre. ¿Qué es lo que puedo decirle? Digo, oye, quiero que la salida de errores y la voy a enviar 00:28:53
a un dispositivo que está dentro de la carpeta dev, que es un dispositivo especial que se llama 00:29:00
null. Y quiero que veáis qué es lo que ha pasado. ¿Veis que no se me muestra nada en pantalla? ¿Por 00:29:05
¿Por qué? Porque me ha cogido el error que yo tenía y por decirlo de alguna manera me lo ha enviado a la papelera. 00:29:12
Esto es lo que hace este de aquí. Lo descarta. Lo envía, en este caso, lo que os digo, pongo siempre el ejemplo de un agujero negro. 00:29:22
Es decir, todo lo que yo envíe ahí desaparece. No se muestra ni aparece en ningún sitio. 00:29:33
¿Sí? ¿De acuerdo? Vale. ¿Qué pasa si yo hago esto? ¿Qué me muestra esto en pantalla? No me muestra nada. Le estoy diciendo, oye, ejecútame un comando, ejecútame este comando, y tanto la salida correcta como la de errores no me la muestres. 00:29:38
Entonces, ¿qué estoy haciendo aquí? Pues con perdón en gilipollas, ¿vale? Esto no sirve para nada 00:30:15
Si yo ejecuto un comando y tanto la salida como la de errores no la muestro 00:30:19
¿Vale? A no ser, obviamente, que sea un comando que ejecuta una acción y no muestre nada en pantalla 00:30:25
Pues entonces os puede interesar, pero aquí en este ejemplo esto no sirve de mucho, la verdad 00:30:32
¿Sí? Vale, vamos a seguir con la transparencia y vamos a ver qué otras opciones tenemos 00:30:37
vale, hemos visto los cuatro 00:30:44
pues ahora que sepáis que tenéis 00:30:54
unas alternativas que se utilizan mucho 00:30:56
y son estas de aquí 00:30:58
y aquí hago una pausa del vídeo 00:30:59
y sigo en el siguiente para que no se me alargue mucho 00:31:01
vamos a tener por un lado 00:31:04
que yo le puedo decir 00:31:06
este comando 00:31:08
¿vale? esta alternativa 00:31:09
¿qué le digo con esta alternativa? 00:31:12
le estoy diciendo 00:31:15
que la salida 00:31:16
me la guardes en un ficherito 00:31:18
Hasta aquí bien, ¿no? Exactamente igual que teníamos arriba. Pero este de aquí, que es el que me interesa, me dice, oye, las opciones que tenemos es que la salida de errores, el 2, me la vas a enviar y ¿ves que me pone el ambersangium 1? 00:31:20
quiere decir al mismo sitio que la entrada estándar sí entonces qué es lo que hace esta 00:31:40
instrucción me coge tanto de la salida correcta tanto la salida correcta como la de errores y 00:31:50
me la envía al mismo fichero eso es lo que hace redirigir la salida correcta y la de errores al 00:31:58
el mismo fichero sí pero con la peculiaridad de que solamente he puesto un mayor quiere decir 00:32:07
que si no existe el fichero lo crea y si existe lo machaca y vuelve a escribir con lo nuevo es 00:32:15
decir sobre escribe sí pero esto que estoy poniendo aquí arriba es decir esto que os he puesto aquí 00:32:21
arriba es exactamente lo mismo que se suele utilizar porque es mucho más cómodo es exactamente 00:32:29
lo mismo que esto de aquí si yo pongo el anver sand y le pongo mayor y un fichero le estoy 00:32:36
diciendo lo mismo que tanto la salida correcta como la de la de errores se me redirijan en este 00:32:42
caso al mismo fichero si son las dos maneras de hacer exactamente lo mismo porque se utiliza 00:32:49
la de abajo porque es mucho más cómodo vale entendéis esto es redirigir nosotros el ejemplo 00:32:56
que hemos puesto ahora ha sido la entrada correcta a un fichero y el error a otro fichero 00:33:03
pues este de aquí abajo y ya nos quitamos de encima esto hace exactamente lo mismo pero en 00:33:10
lugar vale redirige tanto la salida como los errores al mismo fichero pero en este caso si 00:33:19
el fichero existe qué es lo que va a hacer pues en lugar de sobre escribir agrega si funciona 00:33:26
exactamente igual pues vamos a ver cómo funciona esto de aquí y con esto terminamos este vídeo y 00:33:33
luego seguimos qué pasa si yo tengo voy a borrar uy va perdón voy a borrar los ficheros de salida 00:33:41
todos los que sean salida 00:33:53
vale 00:33:54
¿qué pasa si yo tengo esto? 00:33:57
yo le digo, oye, ls 00:33:59
y le digo 00:34:00
menos l 00:34:03
y le digo fichero 00:34:04
1.txt 00:34:07
fichero 3.txt 00:34:10
¿sí? 00:34:14
pongo aquí 00:34:16
yo que sé 00:34:17
cagada 1 00:34:19
y otra más 00:34:24
pero voy a poner 00:34:34
otra más 00:34:40
que pongo 00:34:41
adiós 00:34:42
¿sí? 00:34:50
¿qué es lo que quiero que veáis con esto? 00:34:51
primeramente 00:34:55
esto de aquí me va a mostrar la información 00:34:55
correcta porque existe 00:35:00
este de aquí me va a mostrar la información 00:35:01
de este fichero porque existe 00:35:04
pero este de aquí no existe 00:35:05
este de aquí no existe y este de aquí no existe 00:35:08
¿sí? de forma que estos tres de aquí 00:35:13
va a ser error y estos tres 00:35:18
estos dos de aquí va a ser la salida correcta 00:35:22
¿sí? ¿de acuerdo? entonces este de aquí 00:35:27
va a ser la salida 1 STD OUT 00:35:32
Y este va a ser la salida 2, que va a ser STDR. ¿De acuerdo? Pues vamos a ver cómo me lo muestra. Fijaros que me dice, me muestra los errores y luego me muestra la salida correcta. 00:35:37
Fijaros que siempre aglutina los errores por un lado y la salida correcta por otro. 00:35:58
¿Qué pasa si yo quiero decirle que tanto la salida de errores como la salida correcta, los dos, se me envían a un único fichero? 00:36:05
Pues le podemos decir, en este caso, como hemos visto antes, 00:36:14
le digo, oye, quiero que la salida normal la envíes a fichero 1.txt. 00:36:17
Voy a poner esto más grande a ver si nos cabe en una línea. 00:36:24
Que yo creo que sí. 00:36:28
Vale. 00:36:31
Fichero 1.txt. 00:36:32
Le voy a llamar f1 solo para que nos quepa bien. 00:36:34
Y ahora la salida de errores. 00:36:38
Y para decirle que los errores también se me vayan a donde está la salida estándar, le pongo un anversan. 00:36:40
Vale. 00:36:52
Y un 1. 00:36:52
Con eso le estoy diciendo que, oye, quiero que la salida de errores se me redirija y esto es al mismo sitio que la salida estándar. 00:36:53
Y la salida estándar, por defecto, ¿dónde se ha enviado? 00:37:18
Pues se ha enviado a F1. 00:37:22
Así que le estoy diciendo que la salida de errores se me envíe al mismo sitio que el F1. 00:37:24
Si lo probamos, efectivamente no me ha mostrado nada en pantalla. 00:37:31
Si yo le hago un catahora de F1, pues fijaros que me aglutina los errores y luego la salida correcta. 00:37:36
¿Sí? 00:37:46
Pero que sepáis que esto y esto, si le pongo el Ambersan y le pongo aquí F1, esto y lo anterior es lo mismo. 00:37:46
Porque el Ambersan le está diciendo, oye, quiero que me cojan los dos, la salida estándar y las errores, y las dos me las lleves a ese ficherito. 00:38:02
De forma que si yo le digo que me muestre, me muestra exactamente lo mismo. 00:38:09
sí pues que sepáis que si yo quiero poner aquí un mayor es lo mismo es lo último que habíamos visto 00:38:12
en la transparencia en lugar como ya existe el fichero f1 punto txt en lugar de sobre escribir 00:38:21
me añade entonces si yo le doy cuando yo le diga ahora el cap en lugar de mostrarme estas líneas 00:38:28
de aquí en lugar de mostrarme estás aquí me va a mostrar esto dos veces esto lo que ya había y esto 00:38:35
lo que hay ahora es decir esto es lo que había antes de ejecutar el comando y esto es lo que 00:38:45
ha añadido el último comando porque ha añadido es decir que he cogido este comando y en el este 00:38:55
comando como le he dicho que quiero añadir lo que ha hecho es añadirme al fichero correspondiente 00:39:05
¿De acuerdo? ¿Entendemos esto? 00:39:11
Son las diferentes opciones que nosotros tenemos 00:39:16
Vale, pues voy a dejarlo aquí y vamos a terminar en el siguiente vídeo 00:39:19
Venga, un saludo 00:39:23
Idioma/s:
es
Autor/es:
Fernando Herrero Núñez
Subido por:
Fernando Jesús H.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
19
Fecha:
30 de diciembre de 2022 - 20:47
Visibilidad:
Público
Centro:
IES EL CAÑAVERAL
Duración:
39′ 25″
Relación de aspecto:
1.85:1
Resolución:
1920x1040 píxeles
Tamaño:
108.58 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid