Bash Shelll

batch-file
#batch-file
Tabla de contenido
Acerca de 1
Capítulo 1: Comenzando con el archivo por lotes 2
Observaciones 2
Examples 2
Abrir un símbolo del sistema 2
Edición y visualización de archivos por lotes 3
Obteniendo ayuda 4
Capítulo 2: Aleatorio en archivos por lotes 5
Examples 5
Números al azar 5
Generando números aleatorios dentro de rango específico 5
Generando números aleatorios mayores que 32767 5
Pseudoaleatorio 6
Alfabetos al azar 6
Pseudoaleatorio y uniforme al azar en lote 6
Distribución pseudoaleatoria 6
Distribución uniforme 7
Capítulo 3: Añadir retraso al archivo por lotes 8
Introducción 8
Examples 8
Se acabó el tiempo 8
Se acabó el tiempo 8
Pausa 9
Silbido 9
Silbido 9
Dormir 10
Dormir 10
Capítulo 4: Archivo de lote argumentos de línea de comando 11
Examples 11
Argumentos de línea de comando suministrados a archivos por lotes 11

Archivos por lotes con más de 9 argumentos 11
Cambiando argumentos dentro de paréntesis 12
Capítulo 5: Archivos por lotes e híbridos Powershell 14
Examples 14
Ejecutar Powershell con archivos temporales 14
Use el comando POWERSHELL para ejecutar el comando Powershell de 1 línea 14
Powershell / batch híbrido sin archivos temporales 15
Capítulo 6: Buscar cadenas en lote 16
Examples 16
Búsqueda de cadenas básicas 16
Usando los resultados de búsqueda 16
Capítulo 7: Cambiando directorios y listando sus contenidos 17
Sintaxis 17
Observaciones 17
Examples 17
Para visualizar el directorio actual 17
Para cambiar el directorio actual (sin cambiar las unidades) 17
Navegando a un directorio en una unidad diferente 18
Cómo mostrar todas las carpetas y archivos en un directorio 18
Cambio de unidad sin CD / D 18
Para cambiar el directorio actual a la raíz de la unidad actual 19
Capítulo 8: Comentarios en archivos por lotes 20
Introducción 20
Sintaxis 20
Examples 20
Uso de REM para comentarios 20
Uso de etiquetas como comentarios 20
Uso de variables como comentarios 21
Bloquear comentarios 21
Comenta en la línea del código 21
Lote y comentario híbrido WSF 22
Capítulo 9: Creando archivos usando Batch 23

Introducción 23
Sintaxis 23
Observaciones 23
Examples 23
Redireccion 23
Eco para crear archivos 24
Guardando la salida de muchos comandos 25
Capítulo 10: Diferencias entre Batch (Windows) y Terminal (Linux) 27
Introducción 27
Observaciones 27
Examples 27
Comandos de lotes y sus equivalentes de Bash 27
Variables de lote y su equivalente de golpe 30
Capítulo 11: Directorio de pila 32
Sintaxis 32
Parámetros 32
Observaciones 32
Examples 32
Eliminar archivos de texto 32
Imprimir pila de directorios 32
Capítulo 12: Eco 34
Introducción 34
Sintaxis 34
Parámetros 34
Observaciones 34
Examples 34
Mostrando mensajes 34
Ajuste de eco 35
Obtención y configuración 35
Echo saca todo literalmente. 36
Echo de salida a archivo 36

@Echo off 38
Encendiendo el eco en los soportes internos 38
Capítulo 13: Errores en el procesador cmd.exe 39
Introducción 39
Observaciones 39
Examples 39
Confusión de paréntesis 39
Porque 39
Solución 39
Personaje de escape inadecuado 40
Porque 40
Soluciones 40
Extra 40
Extensión de archivo DEL 41
Porque 41
Solución 41
Capítulo 14: Escapar de personajes especiales 42
Introducción 42
Examples 42
Escapar con caret (^) 42
Escapando del caret 43
Problema de seguridad 43
Personajes especiales FIND y FINDSTR 43
ENCONTRAR 43
FINDSTR 43
Personajes especiales de FOR / F 44
PARA / F 44
Caracteres extra especiales 45
Escapar a través de la tubería 45
Capítulo 15: Evitar las limitaciones aritméticas en los archivos por lotes. 46
Introducción 46
Examples 46
Usando PowerShell 46
Usando jscript 46
Emulación de cálculos a lápiz y papel, implementaciones de funciones matemáticas. 47
Capítulo 16: Funciones 48
Observaciones 48
Examples 48
Función simple 49
Función con parámetros 49
Función que utiliza setlocal y endlocal 49
Combinándolos a todos 49
Funciones anónimas en archivos por lotes. 50
Llamando funciones desde otro archivo por lotes 50
Capítulo 17: Híbridos por lotes y JSCript 52
Introducción 52
Examples 52
JScript incrustado en un archivo por lotes 52
Ejecutar JScript con archivos temporales 52
Capítulo 18: Híbridos por lotes y VBS 54
Introducción 54
Examples 54
Ejecutar VBS con archivo (s) temporal (s) 54
Incruste código vbscript en un archivo por lotes sin usar archivos temporales 55
Capítulo 19: Macros de archivos por lotes 56
Introducción 56
Examples 56
Macro basica 56
Comentarios 56
$ Usos de caracteres 56
Comando separador 56
Argumentos de línea de comando 56

Macros en secuencia de comandos 57
Capítulo 20: Mandatos por lotes obsoletos y sus reemplazos 58
Examples 58
DEPURAR 58
ADJUNTAR 59
BITSADMIN 59
Capítulo 21: Manejo de archivos en archivos por lotes 60
Introducción 60
Examples 60
Creando un archivo en lote 60
Cómo copiar archivos en lote 60
Mover archivos 60
Borrando archivos 61
Copiar archivos sin xcopy 61
Edición de la línea n de un archivo 62
Capítulo 22: Mejores prácticas 64
Introducción 64
Examples 64
Citas 64
Ejemplos y soluciones 64
Ejemplo A 64
Solución A 64
Ejemplo B 64
Solución B 65
Código de espagueti 65
Ejemplos y soluciones 65
Ejemplo A 65
Solución A 65
Ejemplo B 66
Capítulo 23: Para bucles en archivos por lotes 67
Sintaxis 67
Observaciones 67
Examples 67
Recorriendo cada línea en un conjunto de archivos 67
Visitar directorios de forma recursiva en un árbol de directorios 68
Renombrando todos los archivos en el directorio actual 68
Iteración 69
Capítulo 24: Privilegios elevados en archivos por lotes 70
Examples 70
Solicitud de privilegios elevados en un acceso directo 70
Solicitando privilegios elevados en tiempo de ejecución 71
Solicitar privilegios elevados de tiempo de ejecución sin solicitud de UAC 71
Capítulo 25: Redirección de entrada y salida. 74
Sintaxis 74
Parámetros 74
Observaciones 74
Examples 74
Un ejemplo... 74
Redirigir el carácter especial con la expansión retrasada habilitada 75
Escribir en un archivo 75
Capítulo 26: Si declaraciones 77
Sintaxis 77
Observaciones 77
Sintaxis de 1 línea 77
Sintaxis multilínea 77
Examples 78
Comparando números con la declaración IF 78
Comparando cuerdas 78
Comparando Errorlevel 78
Compruebe si el archivo existe 79
Si existe variable / conjunto 79
Capítulo 27: Utilizando Goto 80
Introducción 80
Sintaxis 80
Parámetros 80
Observaciones 80
Examples 80
Programas de ejemplo 80
Goto con variable 81
Capítulo 28: Variables en archivos por lotes 82
Examples 82
Declaración 82
Notas sobre las comillas. 82
Espacios en variables 82
Usando comillas para eliminar espacios 82
Uso 83
Sustitución Variable 83
Declarar múltiples variables 85
Usando una variable como una matriz 85
Operaciones sobre variables 86
Configuración de variables desde una entrada 88
Creditos 90
Acerca de
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: batch-file
It is an unofficial and free batch-file ebook created for educational purposes. All the content is
extracted from Stack Overflow Documentation, which is written by many hardworking individuals at
Stack Overflow. It is neither affiliated with Stack Overflow nor official batch-file.
The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.
Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to info@zzzprojects.com
https://riptutorial.com/es/home 1
Capítulo 1: Comenzando con el archivo por
lotes
Observaciones
Desde Microsoft Technet:
Con los archivos por lotes, que también se denominan programas por lotes o scripts,
puede simplificar las tareas rutinarias o repetitivas. Un archivo por lotes es un archivo
de texto sin formato que contiene uno o más comandos y tiene una extensión de
nombre de archivo .bat o .cmd. Cuando escribe el nombre del archivo en el símbolo
del sistema, Cmd.exe ejecuta los comandos de forma secuencial a medida que
aparecen en el archivo.
Nombres y extensiones de archivos por lotes
Extensión Observaciones
.murciélago Esta extensión se ejecuta con MS-DOS y todas las versiones de Windows.
.cmd Utilizado para archivos por lotes en la familia de Windows NT
.btm La extensión utilizada por 4DOS y 4NT.
Para comprender la diferencia entre .cmd y .bat , consulte aquí .
Evite los nombres que ya son el nombre de los comandos incorporados. como tracert Hay una
utilidad llamada tracert.exe . Por lo tanto, evite nombrar un archivo por lotes tracert.bat
Ejecutar archivo por lotes
La forma más fácil de ejecutar un archivo por lotes es simplemente haciendo doble clic en su
icono. O pegue la ruta completa del archivo en un símbolo del sistema, o simplemente su nombre,
si el símbolo del sistema se inició desde el directorio de archivos por lotes, luego ingrese.
Ejemplo:
C:\Foo\Bar>test.bat
C:\Foo\Bar>C:\Foo\Bar\Baz\test.bat
Examples
Abrir un símbolo del sistema
El símbolo del sistema viene preinstalado en todos los sistemas operativos Windows NT,
Windows CE, OS / 2 y eComStation, y existe como cmd.exe , normalmente ubicado en
C:\Windows\system32\cmd.exe
En Windows 7, las formas más rápidas de abrir el símbolo del sistema son:
• Presione Win , escriba "cmd" y luego presione Entrar .
• Presione Win + R , escriba "cmd" y luego presione Entrar .
• Si tiene una ventana de explorador abierta, escriba "cmd" en la barra de direcciones para
abrir una solicitud en el directorio seleccionado actualmente.
• Haga clic con el botón derecho en una carpeta en el Explorador mientras mantiene
presionada la tecla Mayús y seleccione "Abrir ventana de comandos aquí".
También se puede abrir navegando al ejecutable y haciendo doble clic en él.
En algunos casos, es posible que necesite ejecutar cmd con permisos elevados, en este caso,
haga clic derecho y seleccione "Ejecutar como administrador". Esto también se puede lograr
presionando Control + Shift + Enter en lugar de Enter cuando se utiliza el modo 1 de los puntos
anteriores.
Edición y visualización de archivos por lotes
Cualquier editor ASCII puede editar archivos por lotes. Aquí puede encontrar una lista de editores
que pueden sintaxis resaltar la sintaxis por lotes. También puede usar el bloc de notas
predeterminado que se incluye con Windows para editar y ver un archivo por lotes, aunque no
ofrece resaltado de sintaxis.
Para abrir el bloc de notas:
• Presione Win + R , escriba notepad y luego presione Entrar .
Alternativamente, la forma más "primitiva" de crear un archivo por lotes es redirigir la salida desde
la línea de comandos a un archivo, por ejemplo.
echo echo hello world > first.bat
que escribe echo hello world en el archivo first.bat .
Puede editar un archivo por lotes haciendo clic derecho en el archivo y seleccionando "Editar" en
el menú contextual.
Para ver el contenido de un archivo por lotes desde un símbolo del sistema, ejecute el siguiente
comando:
type first.bat
También puede comenzar a editar su archivo por lotes con el bloc de notas desde el símbolo del
sistema escribiendo
notepad first.bat
Obteniendo ayuda
Para obtener ayuda sobre un comando de archivo por lotes, puede utilizar la ayuda incorporada.
Abra un símbolo del sistema (cuyo archivo ejecutable es cmd.exe ) e ingrese help para ver todos
los comandos disponibles.
Para obtener ayuda para cualquiera de estos comandos, escriba help seguida del nombre del
comando.
Por ejemplo:
help help
Mostrará:
Provides help information for Windows commands.
HELP [command]
command - displays help information on that command.
Algunos comandos también mostrarán ayuda si son seguidos por /? .
Tratar:
help /?
Nota:
Help solo mostrará la ayuda para los comandos internos .
Lea Comenzando con el archivo por lotes en línea: https://riptutorial.com/es/batch-

file/topic/1277/comenzando-con-el-archivo-por-lotes
Capítulo 2: Aleatorio en archivos por lotes
Examples
Números al azar
Usando la variable dinámica %Random% , podemos obtener un entero aleatorio de 0 a 32767. Por
ejemplo:
echo %random%
Obviamente, esto devuelve un número entero de 0 a 32767. Pero a veces queremos que esté en
un rango específico, digamos de 1 a 100.
Generando números aleatorios dentro de rango específico

El método básico para hacerlo se detalla a continuación.
set /a result=(%RANDOM%*max/32768)+min
donde max es el número superior que se puede generar, y min es el número más pequeño que se
puede generar. Tenga en cuenta que no obtendrá ningún número decimal porque set /a
redondea automáticamente. Para generar un número aleatorio decimal, intente esto:
set /a whole=(%RANDOM%*max/32768)+min
set /a decimal=(%RANDOM%*max/32768)+min
echo %whole%.%decimal%
Generando números aleatorios mayores que 32767

Si intentas
set /a whole=(%RANDOM%*65536/32768)+1
lo más probable es que obtengas números aleatorios que son impares.
Para generar números más grandes que 32767, aquí hay un método mejor.
set /a result=%random:~-1%%random:~-1%%random:~-1%%random:~-1%%random:~-1%%random:~-1%
El código anterior extrae el carácter 1 de cada %random% . Pero esto se hace a propósito.
Dado que el número random podría ser un número de un dígito, la extracción de los últimos 2
dígitos no funcionará. Por eso solo extraemos el último carácter. En este caso, tenemos un 6
%random:~-1% , que genera el máximo de 999999 y el mínimo de 000000 ; es posible que deba ajustar
esto para que se ajuste a sus necesidades.
Pseudoaleatorio
cmd.exe genera la semilla en función del momento en que se inició la sección de cmd , por lo que si
inicia la sección de mutliple casi al mismo tiempo, es posible que el resultado no sea lo
suficientemente aleatorio.
Alfabetos al azar
Desafortunadamente, los lotes no tienen un método incorporado para generar alfabetos, pero al
usar %random% y for ciclo, podemos 'generar' alfabetos.
Esta es una idea simple de cómo funciona esto.
set /a result=(%random%*26/32768)+1
for /f "tokens=%result%" %%I in ("A B C D E F G H I J K L M N O P Q R S T U V W X Y Z") do (
echo %%I
)
• El primer set /a declaración genera un número aleatorio N entre 1 y 26

• La instrucción for /f selecciona el elemento N th de una lista de la A a la Z.
○Devolver el resultado
Uno puede poner un total de 31 artículos en 1 for bucle, y prácticamente artículos ilimitados
usando [este método]. ( Lote - para orden de parámetros de bucle
Pseudoaleatorio y uniforme al azar en lote
Distribución pseudoaleatoria
De acuerdo con esta respuesta de desbordamiento de pila , el usuario CherryDT señaló este
código:
set /a num=%random% %% 100
No da una distribución uniforme.
La variable dinámica interna %random% hace da una distribución uniforme, pero el código de
seguridad no será un azar uniformado. Este código genera un número aleatorio entre 0 ~ 99, pero
el resultado no será uniforme. 0 ~ 67 ocurrirán más de 68 ~ 99 desde 32767 MOD 100 = 67 .
Para generar una distribución aleatoria uniforme usando el código anterior, entonces se debe
cambiar 100 . Aquí hay un método para obtener un número que crea una distribución uniforme.
32767 mod (32767 / n)
donde n es un número entero, entre 0 ~ 32767, el resultado puede ser decimal y puede no
funcionar por lotes.
Distribución uniforme
set /a result=(%RANDOM%*100/32768)+1
Este método generará una distribución uniforme. Evita el uso de % , que es más como "resto" y
luego "módulo" en un script por lotes. Sin usar % , el resultado será uniforme.
Alternativamente, aquí hay un método ineficiente, pero uniforme.
set /a test=%random%
if %test% geq [yourMinNumber] (

if %test% leq [yourMaxNumber] (
rem do something with your random number that is in the range.
)
)
Cambie [yourMinNumber] y [yourMaxNumber] acuerdo con sus propios valores.
Lea Aleatorio en archivos por lotes en línea: https://riptutorial.com/es/batch-

file/topic/10841/aleatorio-en-archivos-por-lotes
Capítulo 3: Añadir retraso al archivo por lotes
Introducción
Este tema le enseñará una de las muchas cosas útiles que debe saber en el lenguaje de scripting,
archivo por lotes; Agregar un retraso / pausa / tiempo de espera a su archivo por lotes.
Examples
Se acabó el tiempo
Se acabó el tiempo
La forma más sencilla de hacer una demora o pausa durante un cierto tiempo, es con el comando
estándar TIMEOUT . Para hacer un tiempo de espera que dura exactamente un minuto escribimos:
timeout /t 60
Ahora, ¿qué está pasando aquí?
En primer lugar, usamos el comando TIMEOUT con el parámetro /T (que simplemente significa
tiempo de espera) y luego especificamos la cantidad de segundos a esperar. En este caso ... 60
segundos.
Timeout con el parámetro / NOBREAK
Si tomamos el ejemplo de antes y lo ejecutamos en un archivo BATCH: timeout /t 60 y mientras

espera esos 60 segundos, realmente puede interrumpir el timeout presionando cualquier tecla del
teclado. Para evitar esto, simplemente agregamos el parámetro /NOBREAK al final del mismo.
timeout /t 60 /nobreak
Al hacer esto, tendrá un tiempo de espera de 60 segundos y, si desea interrumpir el tiempo de

espera, deberá presionar (CTRL-C) en el teclado.
Tiempo de espera silencioso
Cuando está haciendo un tiempo de espera se mostrará:
Waiting for X seconds, press a key to continue ...

or
Waiting for X seconds, press CTRL+C to quit ... [This is with the /NOBREAK parameter]
Para ocultar el mensaje, use el argumento NUL (Para la explicación de NUL : haga clic aquí )
timeout /t 60 > nul
or
timeout /t 60 /nobreak > nul
Pausa
Para hacer que su script se detenga, simplemente use el comando PAUSE .
PAUSE
Esto mostrará el texto Press any key to continue . . . A continuación, agregue una nueva línea
en la entrada del usuario.
Digamos que queremos crear un programa "Hello World" y después de hacer clic en algo en
nuestro teclado, queremos que salga del programa con el comando EXIT .
echo Hello World

pause
exit
Aquí usa el comando ECHO para decir "Hola Mundo". Luego usamos el comando PAUSE que muestra
Press any key to continue . . . y luego usamos el comando EXIT para terminar la secuencia de
comandos BATCH actual.
Cuando está en pausa se mostrará:
Press any key to continue . . .
Ocultar el mensaje "Presione cualquier tecla para continuar ...
Para ocultar el mensaje, redirigimos la salida a un dispositivo especial llamado nul . Esto no es
realmente un dispositivo real, pero todo lo que le enviemos se desecha.
pause > nul
Silbido
Silbido
Uno de los comandos más utilizados para demorar durante cierto tiempo es hacer ping .
Uso básico
PING -n 1 -w 1000 1.1.1.1
REM the -n 1 flag means to send 1 ping request.

REM the -w 1000 means when the IP(1.1.1.1) does not respond, go to the next command
REM 1.1.1.1 is an non-existing IP so the -w flag can ping a delay and go to next command
Esto generaría lo siguiente en su archivo / consola por lotes:
C:\Foo\Bar\Baz>ping -n -w 1000 1.1.1.1
Pinging 1.1.1.1 (Using 32 bytes of data)

Request timed out
Ping statistics for 1.1.1.1

Packets: Sent = 2,Received = 0, Lost = 1(100% loss)
Ocultar el texto con eco
Simplemente agregue >nul en la parte posterior del comando para redirigirlo a nulo.
ping -n w 1000 1.1.1.1 >nul
Esto no produciría nada.
Dormir
Dormir
En sistemas Windows más antiguos, el timeout no está disponible. Sin embargo, podemos usar el
comando sleep .
Uso
sleep 1
Muy autoexplicativo; dormir durante 1 segundo. Sin embargo, sleep modo de espera es un
comando deperactado y debe reemplazarse por el tiempo de espera .
Disponibilidad
Este comando está disponible en el antiguo sistema de Windows. También SLEEP.exe se incluye
en 2003 Resource Kit.
Para usar sleep.exe , coloque el archivo ejecutable en la carpeta %Windir%\System32 . Entonces

puedes usarlo como comando normal.
Lea Añadir retraso al archivo por lotes en línea: https://riptutorial.com/es/batch-

file/topic/9123/anadir-retraso-al-archivo-por-lotes
Capítulo 4: Archivo de lote argumentos de
línea de comando
Examples
Argumentos de línea de comando suministrados a archivos por lotes
Los argumentos de línea de comando del archivo de lote son valores de parámetros enviados al
iniciar el lote. Deben incluirse entre comillas si contienen espacios. En un archivo por lotes en
ejecución, los argumentos se utilizan para varios propósitos, es decir, la redirección a :labels ,
variables de configuración o comandos en ejecución.
Los argumentos se mencionan en el archivo por lotes usando %1, %2, ..., %9 .
@echo off
setlocal EnableDelayedExpansion
if not "%1"=="" (
set "dir=%~1" & set "file=%~2"
type !dir!\!file! | find /n /i "True" >nul^
&& echo Success! || echo Failure
)
exit /b
C:\Users\UserName> test.bat "C:\Temp\Test Results" "Latest.log"

Success!
Notas:
• En el ejemplo anterior, las comillas dobles se eliminan utilizando el modificador de

argumento %~1 .
• Las cadenas largas se dividen en varias líneas usando ^ , y hay un espacio antes del
carácter en la siguiente línea.
Archivos por lotes con más de 9 argumentos
Cuando se suministran más de 9 argumentos, se puede usar el comando shift [/n] , donde /n
significa comenzar en el enésimo argumento, n está entre cero y ocho.
Bucle a través de argumentos:
:args
set /a "i+=1"
set arg!i!=%~1
call echo arg!i! = %%arg!i!%%
shift
goto :args
Tenga en cuenta que, en el ejemplo anterior, la variable de expansión retardada i se utiliza para
asignar valores de argumento a la matriz de variables. El comando de call permite mostrar dichos
valores variables dentro del bucle.
Contando argumentos:
for %%i in (%*) do (set /a ArgCount+=1)

echo %ArgCount%
Establecer una variable en el argumento n:
set i=5
call set "path%i%=%%~i"
Cambiando argumentos dentro de paréntesis
Vamos a tener el siguiente example.bat y lo llamamos con los argumentos 1 , 2 y 3 :
@echo off
(
shift
shift
echo %1
)
Como la expansión de la variable cambiará después de que se alcance el contexto de los

corchetes finales, la salida será:
Como esto podría ser un problema al desplazar entre paréntesis para acceder al argumento,
deberá usar la llamada:
@echo off
(
shift
shift
call echo %%1
)
Ahora la salida será 3 . A medida que se usa el comando CALL (que dará lugar a una expansión de
variable adicional) con esta técnica, los argumentos de acceso también se pueden parametrizar:
@echo off
set argument=1
shift
shift
call echo %%%argument%
con expansión retrasada:
@echo off
setlocal enableDelayedExpansion
set argument=1
shift
shift
call echo %%!argument!
la salida será
Lea Archivo de lote argumentos de línea de comando en línea: https://riptutorial.com/es/batch-

file/topic/4981/archivo-de-lote-argumentos-de-linea-de-comando
Capítulo 5: Archivos por lotes e híbridos
Powershell
Examples
Ejecutar Powershell con archivos temporales
Esto ha sido mencionado en otros temas híbridos una y otra vez. El método de la vieja escuela,
pero fácil de ejecutar Powershell es por:
• echo del script Powershell en un script temporal

• Ejecutar el script temporal
• Opcionalmente eliminar el script temporal.
Este es un script de ejemplo.
@echo off
echo powershell-command>Temp.ps1
echo another line>>Temp.ps1
rem echo the script into a temporary file
powershell -File Temp.ps1

rem execute the temporary script
del Temp.ps1
rem Optionally remove the temporary script
El método anterior requiere toneladas de declaraciones de echo si se requiere un script largo, aquí
hay un mejor método sugerido por @Aacini
@echo off
setlocal
rem Get the number of the "<resource>" line

for /F "delims=:" %%a in ('findstr /N "<resource>" "%~F0"') do set "start=%%a"
rem Skip such number of lines and show the rest of this file
(for /F "usebackq skip=%start% delims=" %%a in ("%~F0") do echo %%a) > Temp.ps1
powershell -File Temp.ps1

del /f /s /q Temp.ps1
goto :EOF
<resource>
PS
Powershell script
Use el comando POWERSHELL para ejecutar el comando Powershell de 1
línea
Usando el comando POWERSHELL , podemos ejecutar un comando de 1 línea directamente desde un

script por lotes, sin ningún archivo temporal.
Aquí está la sintaxis.
powershell.exe -Command <yourPowershellCommandHere>
También es posible que desee incluir otras banderas, como -Nologo para mejorar el resultado real.
Powershell / batch híbrido sin archivos temporales
Este es el enfoque propuesto por el usuario rojo de stackoverflow que también puede manejar los
argumentos de la línea de comando:
<# : batch portion

@echo off & setlocal
(for %%I in ("%~f0";%*) do @echo(%%~I) | ^

powershell -noprofile "$argv = $input | ?{$_}; iex (${%~f0} | out-string)"
goto :EOF
: end batch / begin powershell #>
"Result:"
$argv | %{ "`$argv[{0}]: $_" -f $i++ }
llamado así:
psbatch.bat arg1 "Esto es arg2" arg3
Producirá:
Result:
$argv[0]: C:\Users\rojo\Desktop\test.bat
$argv[1]: arg1
$argv[2]: This is arg2
$argv[3]: arg3
Lea Archivos por lotes e híbridos Powershell en línea: https://riptutorial.com/es/batch-

file/topic/10711/archivos-por-lotes-e-hibridos-powershell
Capítulo 6: Buscar cadenas en lote
Examples
Búsqueda de cadenas básicas
El comando FIND puede escanear archivos grandes línea por línea para encontrar una cadena
determinada. No admite comodines en la cadena de búsqueda.
find /i "Completed" "%userprofile%\Downloads\*.log" >> %targetdir%\tested.log
TYPE scan2.txt | FIND "Failed" /c && echo Scan failed || echo Scan Succeeded
El comando FINDSTR tiene un mayor alcance de funciones y admite la búsqueda de expresiones

regulares (REGEX) con caracteres comodín en la cadena de búsqueda.
FINDSTR /L /C:"Completed" Results.txt
echo %%G | findstr /r /b /c:"[ ]*staff.*" >nul && echo Found!
Consulte las fuentes de ayuda de FIND y FINDSTR para obtener más información.
Usando los resultados de búsqueda
La siguiente secuencia de comandos muestra una técnica de archivos divididos más avanzada,
donde la función FOR recorre una lista de archivos en un directorio, y cada contenido de archivo
se canaliza a FINDSTR que busca una cadena que contiene la subcadena var precedida por un
número indefinido de espacios y reemplazada por cualquier extra texto. Una vez encontrado, el
archivo buscado se reemplaza por uno nuevo que contiene solo la parte de texto sobre la cadena
de búsqueda.
@echo off
setlocal enabledelayedexpansion
pushd "%temp%\Test"
for %%G in ("*.txt") do (set "break="
(for /f "tokens=*" %%H in (%%~G) do (
if not defined break (
echo %%H | findstr /r /b /c:"[ ]*var.*" >nul && set break=TRUE || echo %%H )
)) >> %%~nG_mod.txt
del %%~G & ren %%~nG_mod.txt %%G )
popd
exit /b
Tenga en cuenta que la configuración de break=TRUE permite salir del ciclo FOR del archivo
buscado, una vez que se encuentra la primera aparición de la cadena de búsqueda.
Lea Buscar cadenas en lote en línea: https://riptutorial.com/es/batch-file/topic/5476/buscar-

cadenas-en-lote
Capítulo 7: Cambiando directorios y listando
sus contenidos
Sintaxis
• echo% cd% - muestra la ruta actual del directorio
• cd "C: \ ruta \ a \ algunos \ directorio" -cambia la ruta del directorio
• cd "% variable_containing_directory_path%" - también cambia la ruta del directorio
• cd / d E: - cambie a E: unidad desde una unidad diferente
• cd / - cambia el directorio de nuevo a la unidad actual
• echo %__CD__% : muestra la ruta actual del directorio con una barra diagonal inversa (sin
documentar)
• echo% = C:% - El directorio actual de la unidad C: (no documentada)
• echo% = D:% - El directorio actual de la unidad D: si se ha accedido a la unidad D: en la

sesión CMD actual (sin documentar)
Observaciones
¿Por qué es importante y cuáles son sus usos y ventajas?
• para abrir un archivo o aplicación en un directorio usando batch

• para crear y escribir y leer archivos en un directorio utilizando lotes
• para saber y enumerar todas las carpetas
• para saber dónde se está ejecutando su archivo por lotes
Examples
Para visualizar el directorio actual
Formato y uso:
echo %cd%
%cd% es una variable del sistema que contiene la ruta del directorio actual
Para cambiar el directorio actual (sin cambiar las unidades)
Formato:
cd "<path>"
Ejemplo:
cd "C:\Program Files (x86)\Microsoft Office"
cdes una abreviatura de chdir y los dos comandos se comportan exactamente de la misma
manera. En aras de la coherencia, cd se utilizará en todo este tema.
Para navegar al directorio un nivel por encima del directorio actual, especifique el directorio del
sistema ..
cd ..
Para navegar a un directorio que está dentro del directorio actual, simplemente cd al nombre de la
carpeta sin escribir la ruta completa (incluya el nombre del directorio entre comillas si contiene
espacios).
Por ejemplo, para ingresar C:\Program Files (x86)\Microsoft Office mientras se encuentra en el
directorio C:\Program Files (x86) , se puede usar la siguiente sintaxis:
cd "Microsoft Office"
cd "C:\Program Files (x86)\Microsoft Office"
Navegando a un directorio en una unidad diferente
cd por sí solo no permitirá que un usuario se mueva entre unidades. Para moverse a una unidad
diferente, se debe especificar la opción /d .
por ejemplo, moviéndose de C:\Users\jdoe\Desktop a D:\Office Work
cd /d "D:\Office Work"
Cómo mostrar todas las carpetas y archivos en un directorio
Uso para enumerar todas las carpetas y archivos en el directorio actual: dir
También se puede especificar un directorio de destino: dir C:\TargetPath
Al especificar una ruta con espacios, debe estar entre comillas: dir "C:\Path With Spaces"
Cambio de unidad sin CD / D
Pushd "D:\Foo"
Dir
Popd
Pushd cambiará el directorio al directorio siguiente (en este caso D: \ Foo. Popd regresa al directorio
original.
Para cambiar el directorio actual a la raíz de la unidad actual
Formato:
cd/
cd/ está configurado para cambiar el directorio actual a la raíz de la unidad actual
Lea Cambiando directorios y listando sus contenidos en línea: https://riptutorial.com/es/batch-

file/topic/7132/cambiando-directorios-y-listando-sus-contenidos
Capítulo 8: Comentarios en archivos por
lotes
Introducción
Los comentarios se utilizan para mostrar información en un script por lotes.
Sintaxis
• movimiento rápido del ojo
• &MOVIMIENTO RÁPIDO DEL OJO
• ::
• & ::
• Ir a: Etiqueta
Comments. You can also use |>< ,etc.
:Etiqueta
Examples
Uso de REM para comentarios
REM This is a comment
• REM es el comando oficial de comentarios.
Uso de etiquetas como comentarios
::This is a label that acts as a comment
El doble de colon :: comentario se muestra arriba no está documentado como un comando

comentario, pero es un caso especial de una etiqueta que actúa como un comentario.
Precaución : cuando las etiquetas se usan como comentarios dentro de un bloque de código
entre corchetes o for comando, el procesador de comando espera que cada etiqueta sea seguida
por al menos un comando, por lo que cuando se realiza un salto a la etiqueta tendrá algo que
ejecutar.
El shell cmd intentará ejecutar la segunda línea incluso si está formateada como una etiqueta (y
esto provoca un error ):
(
echo This example will fail
:: some comment
)
Cuando se trabaja dentro de bloques de código entre corchetes, es definitivamente más seguro
usar REM para todas las líneas de comentarios.
Uso de variables como comentarios
También es posible utilizar variables como comentarios. Esto puede ser útil para evitar
condicionalmente que se ejecuten comandos:
@echo off
setlocal
if /i "%~1"=="update" (set _skip=) Else (set _skip=REM)
%_skip% copy update.dat
%_skip% echo Update applied
...
Cuando se utiliza el fragmento de código anterior en un archivo por lotes, las líneas que
comienzan con %_skip% solo se ejecutan si se llama al archivo por lotes con la update como
parámetro.
Bloquear comentarios
El formato de archivo por lotes no tiene una sintaxis de comentarios de bloque, pero hay una
solución fácil para esto.
Normalmente, cada línea de un archivo por lotes es leída y luego ejecutada por el analizador,
pero se puede usar una instrucción goto para saltar un bloque de texto sin formato (que se puede
usar como un comentario de bloque):
@echo off
goto :start
A multi-line comment block can go here.

It can also include special characters such as | >
:start
Dado que el analizador nunca ve las líneas entre la goto :start y :start , puede contener texto
arbitrario (incluidos los caracteres de control sin la necesidad de escapar) y el analizador no
generará un error.
Comenta en la línea del código
Para comentar en la misma línea que el código, puede usar &:: o &rem . También puedes usar && o
|| para reemplazar & .
Ejemplo:
@echo off
echo This is a test &::This is a comment
echo This is another test &rem This is another comment
pause
Una curiosidad : el comando SET permite comentarios en línea limitados sin &rem :
set "varname=varvalue" limited inline comment here
Limitaciones:
• la sintaxis con comillas dobles set "varname=varvalue" o set "varname=" ,

• un comentario en línea no puede contener ninguna cita doble,
• cualquier cmd caracteres venenosos | < > & debe ser correctamente escapado como ^| ^<
^> ^& ,
• los paréntesis ( ) deben escaparse correctamente como ^( ^) dentro de un bloque de
código entre corchetes.
Lote y comentario híbrido WSF
 ), solo funciona en
WSF.
Código ¿Éxito tanto en el lote como en el FSM?
 Falso: la etiqueta de cierre solo funciona para el FSM
--> Falso
Lea Comentarios en archivos por lotes en línea: https://riptutorial.com/es/batch-

file/topic/3152/comentarios-en-archivos-por-lotes
Capítulo 9: Creando archivos usando Batch
Introducción
Una característica útil de los archivos por lotes es poder crear archivos con ellos. Esta sección
muestra cómo crear archivos usando código de lote.
Sintaxis
• echo (escribe aquí lo que quieras en el ser) >> (nombre de archivo)
• eco (nombre de variable) >> (nombre de archivo)
Observaciones
Si existe un archivo, > sobrescribirá el archivo y >> agregará al final del archivo. Si un archivo no
existe, ambos crearán un nuevo archivo.
Además, el comando echo agrega automáticamente una nueva línea después de su cadena.
Asi que
echo 1 > num.txt

echo 1 > num.txt
echo 2 >> num.txt
creará el siguiente archivo:
1
2
No esta:
1 1 2
1 2
Además, no puede modificar una sola línea en un archivo de texto. Debe leer todo el archivo,
modificarlo en su código y luego escribir nuevamente en todo el archivo.
Examples
Redireccion
Formato:
[command] [> | >>] [filename]
> guarda la salida de [comando] en [nombre de archivo].
>> agrega la salida de [comando] a [nombre de archivo].
Ejemplos:
1. echo Hello World > myfile.txt guarda "Hello World" en myfile.txt
2. echo your name is %name% >> myfile.txt agrega "su nombre es xxxx" en myfile.txt
3. dir C:\ > directory.txt guarda el directorio de C: \ en directory.txt
Eco para crear archivos
Formas de crear un archivo con el comando echo:
ECHO. > example.bat (creates an empty file called "example.bat")
ECHO message > example.bat (creates example.bat containing "message")

ECHO message >> example.bat (adds "message" to a new line in example.bat)
(ECHO message) >> example.bat (same as above, just another way to write it)
Si desea crear un archivo a través del comando ECHO , en un directorio específico de su

computadora, podría tener un problema.
ECHO Hello how are you? > C:\Program Files\example.bat
(This will NOT make a file in the folder "Program Files", and might show an error message)
Pero entonces, ¿cómo lo hacemos? Bueno, en realidad es extremadamente simple ... Al escribir
una ruta o nombre de archivo que tiene un espacio incluido en su nombre, recuerde usar
"comillas"
ECHO Hello how are you? > "C:\Program Files\example.bat"

(This will create "example.bat" in the folder "Program Files")
Pero, ¿qué sucede si desea crear un archivo que genere un archivo nuevo?
ECHO message > file1.bat > example.bat
(example.bat is NOT going to contain "message > file1.bat")

example.bat will just contain "message"... nothing else
Entonces, ¿cómo hacemos esto? Bueno para esto usamos el símbolo ^
ECHO message ^> file1.bat > example.bat
(example.bat is going to contain "message > file1.bat")
Lo mismo ocurre con otras cosas en lote
El siguiente paso requiere que usted tenga algún conocimiento sobre las variables y las
declaraciones:
Haga clic aquí para conocer las variables | Haga clic aquí para obtener más información
sobre las declaraciones if y else.
Variables:
SET example="text"
ECHO %example% > file.bat
(This will output "text" to file.bat)
si no queremos que se muestre "texto", sino simplemente% example% luego escriba:
ECHO ^%example^% > file.bat

(This will output "%example%" to file.bat)
Declaraciones IF / ELSE:
ELSE statements are written with "pipes" ||
IF ^%example^%=="Hello" ECHO True || ECHO False > file.bat
(example.bat is going to contain "if %example%=="Hello" echo True")

[it ignores everything after the ELSE statement]
para dar salida a toda la línea, entonces hacemos lo mismo que antes.
IF ^%example^%=="Hello" ECHO True ^|^| ECHO False > file.bat
This will output:

IF %example%=="Hello" ECHO True || ECHO False
Si la variable es igual a "Hola", entonces dirá "Verdadero", ELSE dirá "Falso"
Guardando la salida de muchos comandos
Usando muchos comandos ECHO para crear un archivo por lotes:
(
echo echo hi, this is the date today
echo date /T
echo echo created on %DATE%
echo pause >nul
)>hi.bat
El intérprete de comandos trata toda la sección entre paréntesis como un solo comando, luego
guarda toda la salida en hi.bat .
hi.bat ahora contiene:
echo hi, this is the date today

date /T
echo created on [date created]
pause >nul
Lea Creando archivos usando Batch en línea: https://riptutorial.com/es/batch-

file/topic/7129/creando-archivos-usando-batch
Capítulo 10: Diferencias entre Batch
(Windows) y Terminal (Linux)
Introducción
Batch y Bash son bastante diferentes. Los indicadores de lote se indican con una / , mientras que
los indicadores de bash usan un - . La capitalización es importante en bash, pero (casi) no en
lote. Los nombres de variables por lotes pueden contener espacios, los nombres de variables
bash no pueden. En última instancia, ambas son formas de manipular e interactuar con la línea de
comandos. No es sorprendente que exista una superposición de tamaño razonable entre las
capacidades de los dos sistemas.
Observaciones
• bitsadmin está en desuso en favor de los BITS del cmdlet de PowerShell pero aún funciona
a partir de Windows 10 versión 1607
• certutil separa los pares de dígitos hexadecimales con un espacio, por lo que md5sum
devolverá un valor de ejemplo de d41d8cd98f00b204e9800998ecf8427e , mientras que certutil
muestra el mismo valor que d4 1d 8c d9 8f 00 b2 04 e9 80 09 98 ec f8 42 7e
• Para cd en otro disco (por ejemplo, de C: a D :) se debe usar el indicador /d
• del no puede borrar carpetas, use rm lugar
• grep es mucho más poderoso que find y findstr , es casi no es justo para compararlos; find
no tiene capacidades de findstr regulares y findstr tiene capacidades de findstr
extremadamente limitadas ( [az]{2} no es una sintaxis válida, pero [az][az] es)
• for bucles en el símbolo del sistema de Windows solo se pueden usar nombres de variables
de un solo carácter; Esta es la única vez que los nombres de las variables por lotes
distinguen entre mayúsculas y minúsculas
• for bucles en el símbolo del sistema también use la variable forma %A lugar de %A% ; for
bucles en lotes, use la variable forma %%A
• md crea automáticamente los directorios principales necesarios, mientras que mkdir necesita
la -p para hacerlo
• rem no puede usarse como un carácter de comentario en línea a menos que esté precedido
por un &
• :: no se puede usar como un comentario en línea en absoluto, y tampoco se debe usar
dentro de un bloque de código (conjunto de paréntesis)
• Tenga en cuenta que algunos comandos de Windows como ping todavía se usan - como
indicadores
Examples
Comandos de lotes y sus equivalentes de Bash
Lote Golpetazo Descripción
Muestra la ayuda para el

command /? man command
comando.
bitsadmin wget o curl Descarga un archivo remoto
Obtiene la suma de
certutil -hashfile
file_name MD5
md5sum file_name comprobación MD5 de
file_name
cd pwd Muestra el directorio actual
Cambia el directorio actual al

cd directory cd directory
especificado.
cls clear Borra la pantalla
Copia un archivo o archivos de

copy cp una ruta de origen a una ruta de
destino
Muestra la fecha o la establece

date date
según la entrada del usuario.
del rm Borra un archivo o archivos
Muestra una lista de archivos y

dir ls directorios en el directorio
actual.
echo echo Muestra texto en la pantalla.
exit return Sale de un script o subrutina.
Cierra la línea de comandos o

exit logout
el terminal.
Compara el contenido de dos

fc diff
archivos.
Busca nombre_archivo para la

find "string" file_name grep "string" file_name
cadena
Busca nombre_archivo para la

findstr "string" file_name grep "string" file_name
cadena
for /F %A in (fileset*) do for item in fileset*; do; Hacer algo por cada archivo en
something something; done un conjunto de archivos.
for /F %A in ('command') `command` Devuelve la salida de un
do something comando.
for /L %A in for item in `seq first Comienza al principio y cuenta

(first,increment,last) do increment last`; do; por incremento hasta que llega
something something; done
al último.
Busca archivos que coincidan

forfiles find
con ciertos criterios
if [ "variable"="value" ];
if "%variable%"=="value" (
then Compara dos valores
ipconfig ifconfig Muestra información de IP
md mkdir Crea nuevas carpetas
mklink ln -s Crea un enlace simbólico.
Muestra una pantalla de salida

more more
a la vez.
Mueve un archivo o archivos de

move mv una ruta de origen a una ruta de
destino
Pausa la ejecución del script

read -p "Press any key to
pause
continue" hasta que el usuario presiona
un botón
Elimina la entrada superior de la

popd popd pila de directorios y va al nuevo
directorio superior
Agrega el directorio actual a la

pushd pushd pila de directorios y va al nuevo
directorio superior
ren mv Renombra archivos
Comentarios una línea de

rem o :: #
código
rd rmdir Elimina directorios vacíos
Elimina directorios
rd /s rm -rf independientemente de si
estaban vacíos o no
set variable=value variable=value Establece el valor de la variable
en valor.
Realiza operaciones
matemáticas (el lote solo puede
set /a variable=equation variable=$((equation))
usar números enteros de 32
bits)
set /p read -p "promptstring" Obtiene la entrada del usuario y

variable=promptstring variable la almacena en variable
Desplaza los argumentos por 1

shift shift
(o n si se proporciona)
Ordena la salida
sort sort
alfabéticamente por línea
Muestra una lista de procesos

tasklist ps
en ejecución.
Mata el proceso con PID

taskkill /PID processid kill processid
processid
time /t date Muestra la hora actual
Muestra el contenido de un
type cat
archivo.
Busca el directorio actual y el

where which PATH para un archivo o
comando
Muestra el nombre y el grupo

whoami id
del usuario actual.
Variables de lote y su equivalente de golpe
%variable% $variable Una variable regular
Una variable dentro de un bloque de código cuando

!variable! $variable setlocal enabledelayedexpansion está setlocal
enabledelayedexpansion
%errorlevel% o Devuelve el estado del comando anterior: 0 si tiene éxito, 1

$?
ERRORLEVEL (o algo más) si no
$1 , $2 , $3 ,
%1 , %2 , %3 , etc. Los parámetros dados a un guión.
etc.
%* $* Todos los parámetros dados a un script
Lea Diferencias entre Batch (Windows) y Terminal (Linux) en línea:

https://riptutorial.com/es/batch-file/topic/8362/diferencias-entre-batch--windows--y-terminal--linux-
Capítulo 11: Directorio de pila
Sintaxis
• PUSHD [camino]
• POPD
Parámetros
Parámetro Detalles
camino El directorio para navegar a
Observaciones
• El uso de pushd sin parámetros imprimirá la pila.
• El comando popd sobrescribirá el valor actual del directorio actual.
Examples
Eliminar archivos de texto
El siguiente ejemplo muestra cómo puede usar el comando pushd y el comando popd en
un programa por lotes para cambiar el directorio actual desde el que se ejecutó el
programa por lotes y luego volver a cambiarlo:
@echo off
rem This batch file deletes all .txt files in a specified directory
pushd %1
del *.txt
popd
cls
echo All text files deleted in the %1 directory
Obtenido de https://technet.microsoft.com/en-us/library/cc771180%28v=ws.11%29.aspx
Imprimir pila de directorios
Para imprimir la pila de directorios, use el comando pushd sin ningún parámetro:
@echo off
cd C:\example\
pushd one
pushd ..\two
pushd ..\..
pushd
echo Current Directory: %cd%
echo:
popd
pushd three
pushd
echo Current Directory: %cd%
Salida:
C:\example\two
C:\example\one
C:\example
Current Directory: C:\
C:\example\two
C:\example\one
C:\example
Current Directory: C:\example\two\three
Lea Directorio de pila en línea: https://riptutorial.com/es/batch-file/topic/4288/directorio-de-pila
Capítulo 12: Eco
Introducción
echo puede ser usado para controlar y producir salida.
Sintaxis
• ECHO [ON | APAGADO]
• Mensaje de ECHO
• ECHO (mensaje
• ECO(
Parámetros
Parámetro Detalles
ON | APAGADO Puede estar ON o OFF (no distingue mayúsculas y minúsculas)
mensaje Cualquier cadena (excepto ON u OFF cuando se usa sin ( )
Observaciones
• También mostrará una cadena vacía. Sin embargo, esto es más lento que el echo( ya
echo.
que echo. Buscará un archivo llamado "echo". Solo si este archivo no existe, el comando
funcionará, pero esta verificación lo hará más lento.
• echo: se comportará como echo( , a menos que el message vea como una ruta de archivo, por
ejemplo echo:foo\..\test.bat . En este caso, el intérprete verá echo:foo como nombre de
carpeta, tira echo:foo\..\ (porque aparece solo para ingresar al directorio echo:foo luego
dejarlo nuevamente) luego ejecute test.bat , que no es el comportamiento deseado.
Examples
Mostrando mensajes
Para mostrar "algo de texto", use el comando:
echo Some Text
Esto dará salida a la cadena de Some Text seguido de una nueva línea.
Para mostrar las cadenas On y Off (mayúsculas y minúsculas) o la cadena vacía, utilice a ( lugar
de espacios en blanco:
echo(ON
echo(
echo(off
Esto dará como resultado:
ON
off
También es común usar echo. para mostrar una línea en blanco, pero vea las observaciones de
por qué esta no es la mejor idea.
Para mostrar texto sin incluir un CR / LF, use el siguiente comando:
<nul set/p=Some Text
Este comando intentará establecer la variable llamada cadena vacía en la entrada del usuario
siguiendo una solicitud. El archivo nul se redirige al comando con <nul , por lo que el comando se
rendirá tan pronto como intente leerlo y solo quedará la cadena de solicitud. Debido a que el
usuario nunca escribió una nueva línea, no hay salto de línea.
Ajuste de eco
La configuración de eco determina si el eco de comando está activado o desactivado. Esto es lo

que parece un programa de ejemplo con el comando que se hace eco en (predeterminado):
C:\Windows\System32>echo Hello, World!

Hello, World!
C:\Windows\System32>where explorer
C:\Windows\System32\explorer.exe
C:\Windows\System32>exit
Esto es lo que parece con eco apagado :
Hello, World!
C:\Windows\System32\explorer.exe
Obtención y configuración
Para obtener (mostrar) la configuración de eco, use echo sin parámetros:
> echo
ECHO is on.
Para establecer la configuración de eco, use echo con on u off :
> echo off
> echo
ECHO is off.
> echo on
> echo
ECHO is on.
Tenga en cuenta que con estos ejemplos, la solicitud ha sido representada por > . Cuando se
cambia la configuración de eco, el aviso aparecerá y desaparecerá, pero eso hace que los
ejemplos no estén claros.
Tenga en cuenta que es posible evitar que un comando se repita incluso cuando el eco está
activado, colocando un carácter @ antes del comando.
Echo saca todo literalmente.
Las cotizaciones se darán como están:
echo "Some Text"
"Some Text"
Los tokens de comentario son ignorados:
echo Hello World REM this is not a comment because it is being echoed!
Hello World REM this is not a comment because it is being echoed!
Sin embargo, el echo seguirá generando variables (consulte Uso de variables ) y los caracteres
especiales seguirán teniendo efecto:
echo hello && echo world
hello
world
Echo de salida a archivo
Formas de crear un archivo con el comando echo:
echo. > example.bat (creates an empty file called "example.bat")
echo message > example.bat (creates example.bat containing "message")

echo message >> example.bat (adds "message" to a new line in example.bat)
(echo message) >> example.bat (same as above, just another way to write it)
Salida a ruta
Un pequeño problema que puede encontrar al hacer esto:
echo Hello how are you? > C:\Users\Ben Tearzz\Desktop\example.bat
(This will NOT make a file on the Desktop, and might show an error message)
Pero entonces, ¿cómo lo hacemos? Bueno, en realidad es extremadamente simple ... Al escribir
una ruta o nombre de archivo que tiene un espacio incluido en su nombre, recuerde usar
"comillas"
echo Hello how are you? > "C:\Users\Ben Tearzz\Desktop\example.bat"

(This will make a file on MY Desktop)
Pero, ¿qué sucede si desea crear un archivo que genere un archivo nuevo?
echo message > file1.bat > example.bat
(This is NOT going to output:

"message > file1.bat" to example.bat
Entonces, ¿cómo hacemos esto?
echo message ^> file1.bat > example.bat
(This will output:

"message > file1.bat" to example.bat
Lo mismo ocurre con otras cosas en lote
Si no ha aprendido qué son las variables y las declaraciones, lo más probable es que no
comprenda lo siguiente: haga clic aquí para obtener información sobre las variables | Haga
clic aquí para conocer las declaraciones "if"
Variables:
set example="text"
echo %example% > file.bat
(This will output "text" to file.bat)
si no queremos que se muestre "texto", sino simplemente% example% luego escriba:
echo ^%example^% > file.bat

(This will output "%example%" to file.bat)
otras declaraciones:
else = ||
if ^%example^%=="Hello" echo True || echo False > file.bat
(This will output:
if %example%=="Hello" echo True
Para dar salida a toda la línea escribimos:
if ^%example^%=="Hello" echo True ^|^| echo False > file.bat
This will output:

if %example%=="Hello" echo True || echo False
Si la variable es igual a "Hola" entonces dirá "Verdadero", sino dirá "Falso"
@Echo off
@echo off evita que se muestren la solicitud y el contenido del archivo por lotes, de modo que solo
se vea la salida. La @ hace que la salida del comando echo off oculte.
Encendiendo el eco en los soportes internos
En el siguiente ejemplo, el echo on tendrá efecto después de que se llegue al final del contexto de
paréntesis:
@echo off
(
echo on
echo ##
)
echo $$
Para "activar" el eco en un contexto de corchetes (incluidos los comandos FOR y IF ) puede usar la
macro FOR / f :
@echo off
setlocal
:: echo on macro should followed by the command you want to execute with echo turned on
set "echo_on=echo on&for %%. in (.) do"
(
%echo_on% echo ###
)
Lea Eco en línea: https://riptutorial.com/es/batch-file/topic/3981/eco
Capítulo 13: Errores en el procesador
cmd.exe
Introducción
Este tema se centrará en los errores causados por los errores del procesador. Estas son las
cosas en las que nos centraríamos en la causa y la solución del problema.
Observaciones
En el ejemplo de la Extensión de archivo DEL , el usuario X. Liu advierte que este error no se
producirá cuando la extensión del archivo en el comando DEL sea inferior a 3 caracteres.
Examples
Confusión de paréntesis
Desde este sitio web, el OP ha notado un problema.
Porque
Considere el siguiente fragmento de código.
if 1==1 (
set /a result = 2*(3+4)
)
A primera vista, puede pensar que CMD.exe lo procesaría así:
• La condición es verdadera, ejecute el bloque de código.

• Establecer el valor del resultado variable a 14
• Continuar
Sin embargo, el proceso CMD.exe es así:
• La condición es verdadera, ejecute el bloque de código.

• Calcule 2*(3+4 , el ) después de que 4 se procese al final de if bloque de código
• Un azar ) ha aparecido!
El segundo paso devolvería un error de Unbalanced parentheses .
Solución
De acuerdo con un set /? de CMD.exe alemán set /? , tendríamos que citar operaciones
aritméticas. Aquí hay un ejemplo.
Anterior Resultado
set /a result=2+5*4 set /a result="2+5*4"
Por cierto, de acuerdo con un set /? CMD.exe en inglés set /? , se requieren comillas si los
operadores lógicos o de módulo están presentes en la expresión (aunque esto no es un paso
obligatorio ).
Personaje de escape inadecuado
En esta pregunta de desbordamiento de pila , el usuario txtechhelp encontró un problema con el

carácter ^ que podría causar un problema de seguridad.
Porque
anyInvaildCommand ^
Nota: ¡Asegúrate de que el caret ( ^ ) sea el último carácter! ¡Cualquier CR\LF adicional no
funcionará en absoluto!
El caret busca al siguiente personaje para escapar. Sin embargo, ya no hay más personajes
disponibles para escapar, por lo que cmd recorre infinitamente, buscando un personaje para
escapar. En este proceso de "bucle", cmd.exe consumirá la memoria de su computadora. Y poco a
poco devorando toda la memoria, llevando la computadora a las rodillas.
Este problema puede llevar a preocupaciones de seguridad más graves, ya que uno podría
ingresar el código en la computadora desbloqueada.
Soluciones
• Usar la página de códigos UTF-16 podría resolver este problema. Solo UTF-8 o ASCII
causaría el error.
• Asegúrese de que haya un CR\LF adicional en el archivo, o simplemente no use caret al final
del archivo.
Extra
Este error parece estar resuelto en Windows 10.
Extensión de archivo DEL
Este error fue informado por steve2916 desde este hilo del Foro de Microsoft Windows.
Porque
Considere una carpeta con tales archivos.
TestA.doc
TestB.doc
TestC.docx
TestD.docx
Si queremos eliminar todos los archivos .doc en este directorio, generalmente haríamos:
del *.doc
Sin embargo, este comando también elimina los archivos .docx . Lo mismo sucede en las
extensiones de archivo con este patrón.
Presentar un Archivo b
Cualquier nombre. a B C Otro nombre. abc d
Como podemos ver, siempre que la cadena de extensión de archivo contenga la cadena utilizada
en el comando del , se eliminará el archivo. Tenga en cuenta que este error solo se produce
cuando la cadena de extensión utilizada en el comando del tiene al menos tres caracteres. Por
ejemplo, del *.do no elimina A.doc o A.docx .
Solución
En el hilo, el usuario MicroCompsUnltd notó que el uso de Powershell resolvería el problema.
Lea Errores en el procesador cmd.exe en línea: https://riptutorial.com/es/batch-

file/topic/10694/errores-en-el-procesador-cmd-exe
Capítulo 14: Escapar de personajes
especiales
Introducción
En todos los cmd.exe y DOS versiones de DOS , algunos caracteres están reservados para un uso
específico (por ejemplo, redirección de comandos). Este tema tratará sobre cómo utilizar los
caracteres especiales sin problemas.
Examples
Escapar con caret (^)
La mayoría de los caracteres especiales se pueden escapar utilizando el símbolo de intercalación

( ^ ). Echa un vistazo al siguiente ejemplo.
echo > Hi
echo ^> Hi
Este primer comando no generaría > Hi porque > es un carácter especial, lo que significa redirigir
la salida a un archivo. En este caso, el archivo se llama "Hola".
Sin embargo, en el segundo comando, > Hi se emitirá sin ningún problema porque caret ( ^ ) le
dice al > que deje de funcionar como el comando "redirigir la salida al archivo", ahora > es solo un
carácter normal.
Aquí hay una lista de caracteres especiales que se pueden escapar (tomar y editar desde la
página de Rob van der Woude)
Resultado
Personaje Observaciones
Escapado
^ ^^
Y ^&
< ^<
> ^>
| ^|
\ ^\
! ^^! Solo es necesario cuando DelayedExpansion está
Resultado
Escapado
activado
Escapando del caret

Los carets se pueden apilar hasta el escape de otros carets, considere el siguiente ejemplo.
Entrada Salida
^& Y
^^^& ^&
^^^^^& ^^ &
Nota: Los caretes en forma de negrita se escapan.
Problema de seguridad
Un poco fuera de tema aquí, pero esto es muy importante! ¡Un escape de careta no deseado al
final del archivo podría causar una pérdida de memoria!
any-invalid-command-you-like-here ^
¡Este comando perdería toda la memoria, haciendo que el sistema sea completamente
inutilizable ! Vea aquí para más información.
Personajes especiales FIND y FINDSTR
En find y findstr , hay algunos caracteres especiales que requieren cierta precaución.
ENCONTRAR
Solo hay un personaje que necesita escapar: " cita. Para escapar, simplemente agregue otra cita
junto a ella. Así que " convierte en "" . Bastante simple.
FINDSTR
Findstrviene con un montón de personajes para escapar, así que ten mucho cuidado. Usando \ ,
podemos escapar de caracteres especiales. Aquí hay una lista de personajes especiales para
escapar
Personaje Resultado Escapado
\ \\
El \[
] \]
" \"
. \.
* \*
? \?
Personajes especiales de FOR / F
PARA / F
En una declaración FOR /F , algunos personajes deben escapar, aquí una lista (tomada y editada
de la página de Rob van der Woude)
Resultado
Escapado
Solo es necesario en los corchetes de FOR /F , a menos que

' ^
se especifique usebackq .
Solo es necesario en los paréntesis de FOR /F , cuando se

` ^
especifica usebackq
, ^, ┒
; ^; ┃
┣ Debe escaparse entre paréntesis de FOR /F , incluso si

= ^=
está entre comillas dobles
( ^( ┃
) ^) ┙
Caracteres extra especiales
Aquí hay una lista de otros caracteres especiales, que requieren (s) / pueden necesitar escapar,
pero no se mencionan anteriormente.
Resultado
Escapado
% %%
Mark Stang menciona este truco en el grupo de noticias

[LF] ^ [LF]
alt.msdos.batch .
Escapar a través de la tubería
Cuando hay una expresión con una tubería, el cmd comienza con dos hilos en ambos lados de la
tubería y la expresión se analiza dos veces (para cada lado de la tubería), por lo que es necesario
doblar el caret.
En el lado izquierdo:
echo ^^^&|more
En el lado derecho:
break|echo ^^^&
Lea Escapar de personajes especiales en línea: https://riptutorial.com/es/batch-

file/topic/10693/escapar-de-personajes-especiales
Capítulo 15: Evitar las limitaciones
aritméticas en los archivos por lotes.
Introducción
Los archivos por lotes solo permiten cálculos de enteros de 32 bits, aunque esto se puede omitir
con diferentes enfoques.
Examples
Usando PowerShell
Como el powershell se instala de forma predeterminada en todos los sistemas de Windows a

partir de 7/2008, se puede utilizar para cálculos más complejos:
@echo off
set "expression=(2+3)*10/1000"
for /f %%# in ('"powershell %expression%"') do set result=%%#
echo %result%
Tenga en cuenta las comillas dobles adicionales en for /f que evitan que los corchetes entren en
conflicto con la sintaxis de comando for.
El problema potencial es que powershell es mucho más lento que usar wsh / vbscript / jscript
debido a la carga de .net framerwork
Usando jscript
WSH/JScriptse instala en todos los sistemas de Windows desde NT, por lo que su uso para
cálculos más complejos lo hace bastante portátil. JScript es más fácil de combinar con un archivo
por lotes:
@if (@codesection==@batch) @then

@echo off
set "expression=2*(2+3)/1000"
for /f %%# in ('cscript //nologo //e:jscript "%~f0" "%expression%"') do set
result=%%#
echo %result%
:: more batch code
exit /b %errorlevel%
@end
WScript.Echo(eval(WScript.Arguments(0)));
Con este enfoque, puede poner todo su código en un solo archivo. Es más rápido que usar
powershell. Aquí y aquí se pueden encontrar scripts más avanzados (que se pueden usar como
archivos externos).
Emulación de cálculos a lápiz y papel, implementaciones de funciones

matemáticas.
1. Aquí se puede encontrar la biblioteca matemática más completa que emula los cálculos con
lápiz y papel y permite trabajar con números más grandes.
2. Aquí hay otros ejemplos de emulaciones de lápiz y papel: AGREGAR , Comparación ,
Multiplicar
3. Algunas implementaciones de funciones matemáticas se pueden encontrar aquí .
Lea Evitar las limitaciones aritméticas en los archivos por lotes. en línea:
https://riptutorial.com/es/batch-file/topic/10702/evitar-las-limitaciones-aritmeticas-en-los-archivos-
por-lotes-
Capítulo 16: Funciones
Observaciones
Puede agregar variables de inicio a la función agregando <parameter> a su etiqueta. Se puede
acceder a estas variables iniciales con %n donde n es el número de la variable inicial ( %1 para el
primero, %2 para el segundo. Este método %n funciona para% 1 -% 9. Para el parámetro 10 - 255,
necesitará para utilizar el comando Shift ).
Por ejemplo:
:function <var1> <var2>
Una vez que use call :function param1 param2 , se puede acceder a param1 con %1 , y param2 con %2
.
Nota: el <parameter> no es estrictamente necesario, pero ayuda con la legibilidad.
Un buen truco que es útil cuando hay muchas variables volando es usar setlocal y endlocal junto
con %n . setlocal y endlocal esencialmente hacen que la función sea su propia instancia separada
del símbolo del sistema, las variables establecidas solo endlocal en el marco.
Si está usando setlocal y endlocal , y está devolviendo valores globales, use esto.
endlocal & set var=variable
Esto establece el valor global var a variable . Puede encadenar estos juntos para múltiples
variables.
endlocal & set var=variable & set var2=variable number 2
Esto establece la variable global var a variable y el valor global var2 a variable number 2 .
Dado que el código en bloques de códigos también se realiza simultáneamente, también puede
hacerlo.
if "%var%"=="" (
endlocal
set %~2=10
)
Pero, no puedes hacer esto.
if "%var%"=="" (
set %~2=10
endlocal
)
Examples
Función simple
call :FunctionX
rem More code...
:FunctionX
rem Some code here.
goto :eof
Esta es una función muy simple. Las funciones son comandos en el programa que realizan varios
comandos a la vez. Las funciones se crean creando una etiqueta y colocando un código en ella, y
una vez que se hace, se agrega goto :eof o exit /b <ErrorlevelYou'dLike> que vuelve al lugar
donde se invocó. Las funciones se invocan con call :functionname adparams .
Función con parámetros
call :tohex 14 result

rem More code...
:tohex <innum> <outvar>

set dec=%1
set outvar=%~2
rem %n and %~n are functionally identical, but %~n is slightly safer.
goto :eof
Esto toma los parámetros adicionales de la call como si la función fuera un archivo por lotes
separado.
Nota: el <parameter> no es necesario, pero ayuda con la legibilidad.
Función que utiliza setlocal y endlocal
set var1=123456789
set var2=abcdef
call :specialvars
echo %var1%, %var2%
rem More code...
:specialvars
setlocal
set var1=987654321
set var2=fedcba
endlocal
goto :eof
Cuando se encuentran dentro de la sección setlocal , endlocal section, las variables se separan
de las variables de la persona que llama, por lo tanto, por qué% var1% y% var2% no se
cambiaron.
Combinándolos a todos
set importantvar=importantstuff
call :stuff 123 var1
rem More code...
:stuff <arg1> <arg2>

setlocal
set importantvar=%~1
echo Writing some stuff into %~2!
endlocal
set %~2=some stuff
setlocal
set importantvar=junk
endlocal
goto :eof
Esto utiliza la función básica, setlocal y endlocal y argumentos para crear una pequeña función
extraña.
Funciones anónimas en archivos por lotes.
La técnica de funciones anónimas utiliza el hecho de que el comando CALL usa GOTO internamente
cuando se llama a la subrutina y se abusa de la impresión de mensajes de ayuda con la
expansión doble variable :
@echo off
setlocal
set "anonymous=/?"
call :%%anonymous%% a b c 3>&1 >nul
if "%0" == ":%anonymous%" (
echo(
echo Anonymous call:
echo %%1=%1 %%2=%2 %%3=%3
exit /b 0
)>&3
Puede llamar a una función anónima solo si se define después del contexto de CALL (o después de
terminar los paréntesis si la CALL se ejecuta entre paréntesis). No se puede llamar desde un script
externo , pero es una llamada de función más lenta de lo normal.
Llamando funciones desde otro archivo por lotes
Permite tener el siguiente archivo llamado library.cmd :
@echo off
echo -/-/- Batch Functions Library -/-/-
:function1
echo argument1 - %1
goto :eof
Para ejecutar solo : function1 sin el código del resto del archivo, debe poner una etiqueta :
function1 en el llamador y usarlo así:
@echo off
call :function1 ###

:function1
library.bat %*
La salida será (el código fuera de la función en library.cmd no se ejecuta):
argumento1 - ###
Para más información verifique esto .
Lea Funciones en línea: https://riptutorial.com/es/batch-file/topic/7646/funciones
Capítulo 17: Híbridos por lotes y JSCript
Introducción
JScript es en realidad el superconjunto de Javascript (es la versión 1.8.1, por lo que algunas de
las funciones más recientes no están disponibles), y se pueden incrustar en un script por batch
para ampliar las funciones de batch scripts por batch . Por lo general, las técnicas de incrustación
utilizan las directivas de JScript (que no forman parte del estándar oficial de Javascript) para
separar el lote y el código de JScript. JScript le permite trabajar con objetos Com / ActiveX, así
como con objetos WMI además del Javascript estándar.
Examples
JScript incrustado en un archivo por lotes
Este siguiente ejemplo es creado por el usuario Michael Dillon a partir de esta respuesta .
Considere el siguiente script:
@set @junk=1 /*
@echo off
cscript //nologo //E:jscript %0 %*
goto :eof
*/
//JScript aka Javascript here
Este fragmento de script hace:
• Ejecute el comando cscript que se llama a sí mismo con todos los argumentos
proporcionados.
• Como la parte después de @set @junk=1 se comenta ( /* y */ son comentarios válidos de

JScript),
• JScript los ignorará.
• Nota: Necesitamos la parte @set @junk=1 porque el archivo por lotes no reconoce /*
como un comando, pero una declaración de set será una solución alternativa. JScript
reconocerá /* como un comentario, por lo que el otro archivo por batch no será
ejecutado por el motor de JScript.
Puede agregar su JScript después de */ y comenzar a extender sus scripts de archivos por lotes.
Ejecutar JScript con archivos temporales
Como se mencionó aquí , el método de la vieja escuela para ejecutar otro script es mediante el
uso de archivos temporales. Simplemente haga echo en un archivo y luego ejecútelo (y elimínelo
opcionalmente).
Aquí está el concepto básico:
@echo off
echo //A JS Comment > TempJS.js
echo //Add your code>>TempJS.js
cscript //nologo //e:cscript.exe TempJS.js
del /f /s /q TempJS.js
Pero esto requeriría muchas declaraciones de echo para crear un JScript relativamente grande.
Aquí hay un método mejor por Aacini.
@echo off
setlocal

(for /F "usebackq skip=%start% delims=" %%a in ("%~F0") do echo %%a) > TempJS.js
cscript //nologo //e:cscript.txt TempJS.js

del /f /s /q TempJS.js
goto :EOF
<resource>
JScript
JScript
JScript
Lea Híbridos por lotes y JSCript en línea: https://riptutorial.com/es/batch-file/topic/10578/hibridos-

por-lotes-y-jscript
Capítulo 18: Híbridos por lotes y VBS
Introducción
Batch son capaces de ejecutarse con la funcionalidad VBS , lo que aumenta aún más su
confiabilidad. Por ejemplo, VBS puede lidiar con decimales, espacios y algunas otras operaciones
avanzadas que no se pueden realizar por batch . También es capaz de trabajar con objetos WMI y
ActiveX.
Examples
Ejecutar VBS con archivo (s) temporal (s)
El método de la vieja escuela para ejecutar otra secuencia de comandos de un batch es hacer
echo la secuencia de comandos en otra ubicación, y luego ejecutarlo.
Este método se puede representar así:
@echo off
rem VBS below
echo your vbs > TempVBS.vbs
echo other vbs>>TempVBS.vbs
rem End of VBS
cscript //nologo TempVBS.vbs

del /f /s /q TempVBS.vbs
El método anterior requeriría mucho echo (vbs) >> TempVBS.vbs , así que aquí hay una manera de
acortarlo. (código de Aacini)
@echo off
setlocal

(for /F "usebackq skip=%start% delims=" %%a in ("%~F0") do echo %%a) > Program.vbs
cscript //nologo Program.vbs

del /f /s /q Program.vbs
exit /b
<resource>
your vbs
another line of vbs
El último método es mediante el uso de streams . Un archivo puede tener algunas secuencias. Y
cada flujo puede contener información diferente.
@echo off
echo vbs >%0:stream1

rem This command redirect "vbs" into the stream1 of this script, then we can call it later
cscript %0:stream1 //nologo

rem if you like, you can clear the stream1 of this file by:
type nul>%0:stream1
Incruste código vbscript en un archivo por lotes sin usar archivos temporales
Aquí hay un ejemplo con la técnica (hack) inventada por el usuario Liviu de los foros de dostips :
@echo off
echo Printed by CMD.EXE
cscript //nologo "%~f0?.wsf" //job:JS //job:VBS
----END OF BATCH CODE---

<package>
<job id="JS">
<script language="VBScript">
WScript.Echo("Printed by VBScript"):
</script>
</job>
<job id="VBS">
<script language="JScript">
WScript.Echo("Printed by JScript");
</script>
</job>
</package>
Dado que la ejecución del archivo wsf con el host del script de Windows es sensible a la
extensión, puede ejecutar un archivo con cualquier extensión agregando ?.wsf al final del archivo
(que es el núcleo del hack). Si bien el ejemplo de Liviu es probablemente más robusto, el código
anterior es una versión más simplificada. Como a wsh no le importan las cosas que están fuera
del nodo <package> no está obligado a poner todo en comentarios xml. Aunque hay que tener
cuidado con los símbolos de redirección ( < y > )
Lea Híbridos por lotes y VBS en línea: https://riptutorial.com/es/batch-file/topic/10061/hibridos-por-

lotes-y-vbs
Capítulo 19: Macros de archivos por lotes
Introducción
En un símbolo del sistema, puede usar DOSKEY para crear macros. En un archivo por lotes
puede definir una variable que se puede llamar como un fragmento de código e incluso pasarle
argumentos.
Examples
Macro basica
Usando DOSKEY , podemos crear macros para simplificar la escritura de muchos comandos en el
símbolo del sistema. Echa un vistazo al siguiente ejemplo.
DOSKEY macro=echo Hello World
Ahora, si escribe macro en el símbolo del sistema, devolverá Hello World .
Comentarios
Desafortunadamente, la macro DOSKEY no admite comentarios, pero hay una solución.
;= Comment
;= Comment
;= Remember to end your comment with ;=
;=
$ Usos de caracteres
Hay 3 usos del carácter $ en una macro DOSKEY .
Comando separador
$T es el equivalente de & en un script por lotes. Uno puede unir comandos juntos como tal.
DOSKEY test=echo hello $T echo world
Argumentos de línea de comando

Como bash (no por batch ), usamos $ para indicar el argumento de la línea de comandos.
$1 refiere al primer argumento de línea de comando
$2 refiere al segundo argumento de línea de comandos, etc.
$* refiere a todos los argumentos de la línea de comandos
Macros en secuencia de comandos
macros DOSKEY no funcionan en un script por lotes. Sin embargo, podemos usar una
DOSKEY
pequeña solución.
set DOSKEYMacro=echo Hello World

%DOSKEYMacro%
Este script puede simular la función macro. También se pueden usar los símbolos ( & ) para unir
comandos, como $T en DOSKEY .
Si desea una "macro" relativamente grande, puede probar una función simple o echar un vistazo
a otros temas de funciones aquí .
Lea Macros de archivos por lotes en línea: https://riptutorial.com/es/batch-file/topic/10791/macros-

de-archivos-por-lotes
Capítulo 20: Mandatos por lotes obsoletos y
sus reemplazos
Examples
DEPURAR
DEBUG comando DEBUG se usó para crear archivos binarios / ejecutables desde un archivo por lotes.
El comando aún está disponible en versiones de Windows de 32 bits, pero es capaz de crear
archivos binarios solo con instrucciones de 16 bits, lo que lo hace inutilizable para máquinas de
64 bits. Ahora CERTUTIL se usa para ese propósito, que permite decodificar / codificar archivos
binarios / multimedia de formatos HEX o BASE64. Ejemplifique con un archivo que crea un
archivo de icono:
@echo off
del /q /f pointer.jpg >nul 2>nul

certutil -decode "%~f0" pointer.jpg
hh.exe pointer.jpg
-----BEGIN CERTIFICATE-----
/9j/4AAQSkZJRgABAgAAZABkAAD/7AARRHVja3kAAQAEAAAAMgAA/+4ADkFkb2Jl
AGTAAAAAAf/bAIQACAYGBgYGCAYGCAwIBwgMDgoICAoOEA0NDg0NEBEMDg0NDgwR
DxITFBMSDxgYGhoYGCMiIiIjJycnJycnJycnJwEJCAgJCgkLCQkLDgsNCw4RDg4O
DhETDQ0ODQ0TGBEPDw8PERgWFxQUFBcWGhoYGBoaISEgISEnJycnJycnJycn/8AA
EQgACgAKAwEiAAIRAQMRAf/EAFsAAQEBAAAAAAAAAAAAAAAAAAAGBwEBAQAAAAAA
AAAAAAAAAAAAAAEQAAIBAwQDAAAAAAAAAAAAAAEDAgARBSExIwQSIhMRAQEBAAAA
AAAAAAAAAAAAAAARIf/aAAwDAQACEQMRAD8A13PZ5eIX3gO8ktKZfFPksvQ8r4uL
ecJmx1BMSbm8D6UVKVcg/9k=
-----END CERTIFICATE-----
Aquí es lo mismo con el formato hexadecimal:
@echo off
(echo 0000 ff d8 ff e0 00 10 4a 46 49 46 00 01 02 00 00 64) >pointer.hex

(echo 0010 00 64 00 00 ff ec 00 11 44 75 63 6b 79 00 01 00) >>pointer.hex
(echo 0020 04 00 00 00 32 00 00 ff ee 00 0e 41 64 6f 62 65) >>pointer.hex
(echo 0030 00 64 c0 00 00 00 01 ff db 00 84 00 08 06 06 06) >>pointer.hex
(echo 0040 06 06 08 06 06 08 0c 08 07 08 0c 0e 0a 08 08 0a) >>pointer.hex
(echo 0050 0e 10 0d 0d 0e 0d 0d 10 11 0c 0e 0d 0d 0e 0c 11) >>pointer.hex
(echo 0060 0f 12 13 14 13 12 0f 18 18 1a 1a 18 18 23 22 22) >>pointer.hex
(echo 0070 22 23 27 27 27 27 27 27 27 27 27 27 01 09 08 08) >>pointer.hex
(echo 0080 09 0a 09 0b 09 09 0b 0e 0b 0d 0b 0e 11 0e 0e 0e) >>pointer.hex
(echo 0090 0e 11 13 0d 0d 0e 0d 0d 13 18 11 0f 0f 0f 0f 11) >>pointer.hex
(echo 00a0 18 16 17 14 14 14 17 16 1a 1a 18 18 1a 1a 21 21) >>pointer.hex
(echo 00b0 20 21 21 27 27 27 27 27 27 27 27 27 27 ff c0 00) >>pointer.hex
(echo 00c0 11 08 00 0a 00 0a 03 01 22 00 02 11 01 03 11 01) >>pointer.hex
(echo 00d0 ff c4 00 5b 00 01 01 01 00 00 00 00 00 00 00 00) >>pointer.hex
(echo 00e0 00 00 00 00 00 00 06 07 01 01 01 00 00 00 00 00) >>pointer.hex
(echo 00f0 00 00 00 00 00 00 00 00 00 00 01 10 00 02 01 03) >>pointer.hex
(echo 0100 04 03 00 00 00 00 00 00 00 00 00 00 01 03 02 00) >>pointer.hex
(echo 0110 11 05 21 31 23 04 12 22 13 11 01 01 01 00 00 00) >>pointer.hex
(echo 0120 00 00 00 00 00 00 00 00 00 00 00 11 21 ff da 00) >>pointer.hex
(echo 0130 0c 03 01 00 02 11 03 11 00 3f 00 d7 73 d9 e5 e2) >>pointer.hex
(echo 0140 17 de 03 bc 92 d2 99 7c 53 e4 b2 f4 3c af 8b 8b) >>pointer.hex
(echo 0150 79 c2 66 c7 50 4c 49 b9 bc 0f a5 15 29 57 20 ff) >>pointer.hex
(echo 0160 d9 ) >>pointer.hex
certutil -decodehex "pointer.hex" pointer.jpg

hh.exe pointer.jpg
Como puede ver, el hex requiere un archivo temporal adicional y las expansiones de formato
hexadecimal son más grandes
ADJUNTAR
APPEND fue un comando en msdos que permitía usar archivos de recursos / medios como si
estuvieran en el mismo directorio. El comando todavía está disponible en las versiones de 32 bits
de Windows, pero parece que no está funcionando. En algunas fuentes (incluyendo microsofts) se
señala que el comando es reemplazado por DPATH, pero no es del todo cierto. A pesar de que el
mensaje de ayuda de DPATH apunta al comando APPEND, su sintaxis es igual a PATH . Los
directorios enumerados en DPATH se pueden usar con la redirección de entrada o el comando de
tipo :
@echo off
dpath %windir%
set /p var=<win.ini
echo using dpath with input redirection:
echo %var%
echo.
echo using dpath with type command:
type win.ini
BITSADMIN
BITSADMIN se utilizó para transferir documentos, descargar sitios web, descargar archivos de sitios
web, etc. Este comando es un comando obsoleto y puede eliminarse en las próximas
actualizaciones de Windows. Para evitar este problema, use el nuevo BIT cmdlet Powershell BIT
cmdlet .
Aquí hay un código de ejemplo que utiliza BITSADMIN .
@echo off
Bitsadmin /create /download Stackoverflow.com
rem download the website StackOverflow.com
Lea Mandatos por lotes obsoletos y sus reemplazos en línea: https://riptutorial.com/es/batch-

file/topic/10109/mandatos-por-lotes-obsoletos-y-sus-reemplazos
Capítulo 21: Manejo de archivos en archivos
por lotes
Introducción
En este tema, aprenderá cómo crear, editar, copiar, mover y eliminar archivos en lotes.
Examples
Creando un archivo en lote
Puede haber varias razones por las que desea crear un archivo de texto por lotes. Pero
cualquiera que sea la razón, así es como lo haces.
Si desea sobrescribir un archivo de texto existente, use > . Ejemplo:
@echo off
echo info to save > text.txt
Pero si desea agregar texto a un archivo de texto ya existente, use >> . Ejemplo:
@echo off
echo info to save >> text.txt
Si necesita guardar varias líneas de texto en un archivo use ()>text.txt Ejemplo:
@echo off
(echo username
echo password)>text.txt
Cómo copiar archivos en lote
Es posible que desee copiar archivos de un lugar a otro. En este ejemplo te enseñaremos.
Puedes usar el comando xcopy . La sintaxis es xcopy c:\From C:\To
Ejemplo:
@echo off
xcopy C:\Folder\text.txt C:\User\Username\Desktop
También hay interruptores que puede utilizar. Si desea verlos, abra el símbolo del sistema
mediante Start Menu -> Accessories -> Command Prompt y luego escriba xcopy /?
Mover archivos
Usando el comando mover, puedes mover archivos:
@echo off
cd C:\Foo\Bat\Baz
move /Y Meow.bat "Meow Folder" >nul
Meow.bat representa qué archivo mover. La "Carpeta Meow" mueve Meow.bat a la Meow Folder . /Y
dice no pedir confirmación. Reemplazando eso con /-Y hace que el archivo por lotes solicite
confirmación. El >nul oculta la salida del comando. Si no tuviera >nul , generaría:
1 File Moved
Borrando archivos
Usando el comando DEL (alias para ERASE ), uno puede eliminar archivos.
@echo off
del foo.ext
Este comando eliminará foo.ext del directorio actual. También se puede especificar la ruta y el
archivo, como:
del C:\Foo\Bar\Baz.ext
Pero siempre es ideal poner comillas ( " ) alrededor de las rutas, vea aquí la razón.
Hay algunas banderas disponibles para DEL .
Bandera Función
/P Solicita al usuario antes de eliminar el (los) archivo (s)
/F Eliminar forzosamente los archivos de solo lectura
/S Eliminar archivo (s) en subdirectorios
/Q Previene el aviso del usuario
/A Filtro: Sólo eliminar archivo atribuido específico,
usando el - carácter significa no atribuido como ese tipo.
Copiar archivos sin xcopy
En este ejemplo , el usuario BoeNoe mostró cómo usar el comando xcopy para copiar archivos.
También hay un comando adicional llamado copy .
Aquí hay un ejemplo simple:
copy foo.ext bar.ext
Esto copia foo.ext a bar.ext , y crea bar.ext cuando no existe. También podemos especificar rutas
al archivo, pero siempre es ideal colocar comillas ( " ) alrededor de las rutas, consulte aquí el
motivo.
También hay muchas banderas disponibles para copy , ver copy /? o help copy en un símbolo del
sistema para ver más.
Edición de la línea n de un archivo
El archivo por lotes no viene con un método incorporado para reemplazar la línea n de un archivo,
excepto replace y append ( > y >> ). Usando for bucles, podemos emular este tipo de función.
@echo off
set file=new2.txt
call :replaceLine "%file%" 3 "stringResult"
type "%file%"
pause
exit /b
:replaceLine <fileName> <changeLine> <stringResult>

setlocal enableDelayedExpansion
set /a lineCount=%~2-1
for /f %%G in (%~1) do (

if !lineCount! equ 0 pause & goto :changeLine
echo %%G>>temp.txt
set /a lineCount-=1
)
:changeLine
echo %~3>>temp.txt
for /f "skip=%~2" %%G in (%~1) do (

echo %%G>>temp.txt
)
type temp.txt>%~1
del /f /q temp.txt
endlocal
exit /b
• La secuencia de comandos principal llama a la función replaceLine , con el nombre de

archivo / la línea a cambiar / y la cadena a reemplazar.
• La función recibe la entrada.
○ Se realiza un bucle a través de todas las líneas y echo a un archivo temporal antes de
la línea de reemplazo
○ Se hace echo la línea de reemplazo del archivo.
○ Continúa la salida al resto del archivo.
○ Copia el archivo temporal al archivo original.
○ Y elimina el archivo temporal.
• La secuencia de comandos principal recupera el control y type el resultado.
Lea Manejo de archivos en archivos por lotes en línea: https://riptutorial.com/es/batch-

file/topic/9253/manejo-de-archivos-en-archivos-por-lotes
Capítulo 22: Mejores prácticas
Introducción
Este tema se centrará en las cosas que uno debe (no es obligatorio) hacer en un archivo por
lotes. El uso de estas "mejores prácticas" puede mejorar el efecto y la función de un archivo por
lotes.
Examples
Citas
La mayoría de los scripts de lotes en línea vienen con muchos problemas de cotización.
Ejemplos y soluciones
Ejemplo A
if %var%==abc echo Test
Este código funciona: cuando el contenido de %var% no contiene espacio ni otros caracteres
especiales. Ahora supongamos que %var% contiene 1 espacio en blanco. Ahora cmd.exe ve:
if ==abc echo Test
Esto causaría un error porque cmd.exe no entiende esta sintaxis.
Solución A
if "%var%"=="abc" echo Test
Al usar comillas, cmd.exe ve el %var% completo (incluido el espacio y los caracteres especiales)
como una sola cadena normal. Sin embargo, este no es el método de comparación más seguro.
El más seguro usa echo , pipe y findstr .
Ejemplo B
cd C:\User\Spaced Name\Spaced FileName.txt
cd
solo cambiaría el directorio a C:\User\Spaced , ya que cd solo acepta un argumento de ruta.
Solución B
Simplemente agregando comillas alrededor de la ruta, el problema se resolvería.
cd "C:\User\Spaced Name\Spaced FileName.txt"
También hay algunos ejemplos que funcionan mejor usando comillas, como el set /a declaración,
etc. Pero cuando se trabaja en cadenas que contienen espacios o caracteres especiales,
generalmente es muy seguro usar comillas.
Código de espagueti
El código de Spaghetti significa un fragmento de código que usa muchas estructuras, a menudo
confusas. Tales como GOTO s, excepciones y código inconsistente.
Ejemplos y soluciones
Ejemplo A
@echo off
set /a counter=0
:Loop
set /a counter=%counter% + 1
echo %counter%
if %counter% equ 10 goto :exit

goto :Loop
:exit
Este programa viene con muchos saltos, lo que nos hace más difícil saber qué está haciendo
exactamente el script.
Solución A
@echo off
for /l %%G in (0,1,10) echo %%G
Usando menos GOTO , redujimos mucho la cantidad de código, y podemos enfocarnos en el código
real.
Ejemplo B
Considere las siguientes afirmaciones.
:endGame
if %player1Score% gtr %player2Score% goto :player1wins
if %player1Score% lss %player2Score% goto :player2wins
goto :tie
:player1wins
echo player 1 wins
goto :eof
:player2wins
echo player 2 wins
goto :eof
:tie
echo tie
goto :eof
Este fragmento de código requiere un montón de instrucciones goto y puede ser confuso para
depurar. Para simplificar estas declaraciones, podemos usar el comando de call . Aquí está el
script anterior en una mejor condición.
:endGame
if %player1Score% gtr %player2Score% call :message player 1 wins
if %player1Score% lss %player2Score% call :message player 2 wins
if %player1Score% equ %player2Score% call :message tie
goto :eof
:message
echo %*
goto :eof
Ambos scripts generan exactamente el mismo resultado, pero el nuevo script es mucho más corto
y claro.
Lea Mejores prácticas en línea: https://riptutorial.com/es/batch-file/topic/10746/mejores-practicas
Capítulo 23: Para bucles en archivos por
lotes
Sintaxis
• para / l %% p in (startNumber, increment, endNumber) comando do
• para / f %% p en (nombre de archivo) comando do
• para / f %% p en ("textStrings") do comando
• para / f %% p en ('comando') comando do
• para / r drive: \ path %% p in (set) do command
• para / d %% p en (directorio) comando do
Observaciones
El comando for acepta opciones cuando se usa el indicador /f . Aquí hay una lista de opciones
que se pueden usar:
• delims=x caracteres delimitadores para separar tokens
• skip=n Número de líneas a omitir al principio del archivo y cadenas de texto
• eol=; Carácter al inicio de cada línea para indicar un comentario.
• tokens=n Elementos numerados para leer de cada línea o cadena para procesar
• usebackq usa otro estilo de cita:
Use comillas dobles para nombres de archivo largos en "archivos"
Utilice comillas simples para 'textStrings'
Usa las comillas de vuelta para `command`
Examples
Recorriendo cada línea en un conjunto de archivos
Lo siguiente hará eco de cada línea en el archivo C:\scripts\testFile.txt . Las líneas en blanco
no serán procesadas.
for /F "tokens=*" %%A in (C:\scripts\testFile.txt) do (

echo %%A
rem do other stuff here
)
Un ejemplo más avanzado muestra cómo se puede usar la derivación en el ciclo FOR de un
conjunto restringido de archivos para redirigir la ejecución por lotes, mientras se guarda el
contenido buscado en un archivo:
@echo off
for /f %%i in ('dir "%temp%\test*.log" /o:-d /t:w /b') do (

set "last=%temp%\%%i"
type !last! | find /n /i "Completed" >nul 2>&1 >> %temp%\Completed.log ^
&& (echo Found in log %%i & goto :end) || (echo Not found in log %%i & set "result=1"))
:: add user tasks code here

if defined result echo Performing user tasks...
:end
echo All tasks completed
exit /b
Tenga en cuenta el tiempo en que las cadenas de comando se dividen en varias líneas de código
y los grupos de comandos están separados por paréntesis
Visitar directorios de forma recursiva en un árbol de directorios
for /r comando for /r se puede usar para visitar recursivamente todos los directorios en un árbol
de directorios y ejecutar un comando.
@echo off
rem start at the top of the tree to visit and loop though each directory
for /r %%a in (.) do (
rem enter the directory
pushd %%a
echo In directory:
cd
rem leave the directory
popd
)
Notas:
• para / r - Recorrer archivos (subcarpetas Recurse).

• pushd - Cambie el directorio / carpeta actual y almacene la carpeta / ruta anterior para usar
con el comando POPD.
• popd : cambie el directorio de nuevo a la ruta / carpeta almacenada más recientemente por
el comando PUSHD.
Renombrando todos los archivos en el directorio actual
Lo siguiente usa una variable con un bucle for para renombrar un grupo de archivos.
SetLocal EnableDelayedExpansion
for %%j in (*.*) do (
set filename=%%~nj
set filename=!filename:old=new!
set filename=Prefix !filename!
set filename=!filename! Suffix
ren "%%j" "!filename!%%~xj"
)
Al definir el nombre de la variable %%j y asociarlo con todos los archivos actuales (*.*) , Podemos
usar la variable en un bucle for para representar cada archivo en el directorio actual.
Cada iteración (o paso) a través del bucle procesa un archivo diferente del grupo definido (que
podría haber sido cualquier grupo, por ejemplo, *.jpg o *.txt ).
En el primer ejemplo, sustituimos el texto: la cadena de texto "old" se reemplaza por la cadena de
texto "new" (si, pero solo si, el texto "old" está presente en el nombre del archivo).
En el segundo ejemplo, agregamos texto: el texto "Prefijo" se agrega al inicio del nombre del
archivo. Esto no es una sustitución. Este cambio se aplicará a todos los archivos del grupo.
En el tercer ejemplo, nuevamente agregamos texto: el texto "Sufijo" se agrega al final del nombre
del archivo. De nuevo, esto no es una sustitución. Este cambio se aplicará a todos los archivos
del grupo.
La línea final realmente maneja el cambio de nombre.
Iteración
for /L %%A in (1,2,40) do echo %%A
Esta línea se repetirá del 1 al 39, aumentando en 2 cada vez.
El primer parámetro, 1 , es el número inicial.
El segundo parámetro, 2 , es el incremento.
El tercer parámetro, 40 , es el máximo.
Lea Para bucles en archivos por lotes en línea: https://riptutorial.com/es/batch-file/topic/3695/para-

bucles-en-archivos-por-lotes
Capítulo 24: Privilegios elevados en archivos
por lotes
Examples
Solicitud de privilegios elevados en un acceso directo
Muchas tareas requieren privilegios elevados. Puede elevar los privilegios de usuario al nivel de
administrador para su tiempo de ejecución por lotes utilizando un acceso directo:
1. Presione alt + y el archivo por lotes en una carpeta seleccionada para crear un acceso
directo.
2. Haga clic derecho y seleccione "Propiedades".
3. Seleccione la pestaña "Acceso directo".
4. Haga clic en "Avanzado".
5. Habilitar "Ejecutar como administrador".
6. Haga clic en "Aceptar" dos veces.
Solicitando privilegios elevados en tiempo de ejecución
El siguiente archivo por lotes abrirá una solicitud de UAC que le permitirá aceptar privilegios de
administrador elevados para la sesión por lotes. Agregue su código de tareas a :usercode sección
:usercode del lote, para que se ejecuten con privilegios elevados.
@echo off
setlocal EnableDelayedExpansion
:: test and acquire admin rights
cd /d %~dp0 & echo/
if not "%1"=="UAC" (
>nul 2>&1 net file && echo Got admin rights || (echo No admin rights & ^
MSHTA "javascript: var shell = new ActiveXObject('shell.application');
shell.ShellExecute("%~snx0", 'UAC', '', 'runas', 1);close();"))
:: re-test admin rights
echo/ & >nul 2>&1 net file && (echo Got admin rights & echo/) || (echo No admin rights.
Exiting... & goto :end)
:usercode
:: add your code here
echo Performing admin tasks
echo Hello >C:\test.txt
:end
timeout /t 5 >nul
exit /b
Solicitar privilegios elevados de tiempo de ejecución sin solicitud de UAC
Como ejemplo anterior, este script solicita elevación si es necesario. Le pedimos al usuario las
credenciales para evitar el aviso de UAC.
@echo off
cls & set "user=" & set "pass="
:: check if we have administrative access
:: ------------------------------------------------------------------------
whoami /groups | find "S-1-5-32-544">NUL 2>&1 && goto:gotAdmin
echo/
echo/ Testing administrative privileges
echo/
echo/ Please enter administrative credentials
echo/
:: get user
:: ------------------------------------------------------------------------
set/P user="* User:: "
if "%user%" EQU "" exit/B 1
:: get password
:: ------------------------------------------------------------------------
<NUL set/p=* password& call:getPass pass || exit/B 1
if "%pass%" EQU "" exit/B 1
:: check if credential has administrative privileges

:: this call can be removed
:: ------------------------------------------------------------------------
call:askIsAdmin "%user%", "%pass%" || goto:notAdmin
:: run elevated without UAC prompt

:: with the previous call enabled, we are sure credentials are right
:: without it, this will fail if credentials are invalid
:: ------------------------------------------------------------------------
call:elevateScript "%user%", "%pass%"
exit/B 0
:gotAdmin
echo(
echo( You have administrative rights.
echo(
timeout /T 7
exit/B 0
:notAdmin
echo(
echo( Invalid credential or non administrative account privileges
echo(
timeout /T 7
exit/B 1
:: invoke powershell to get the password

:: ------------------------------------------------------------------------
:getPass
SetLocal
set "psCmd=powershell -Command "$pwd = read-host ':' -AsSecureString;
$BSTR=[System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($pwd);
[System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)""
for /F "usebackq delims=" %%# in (`%psCmd%`) do set "pwd=%%#"
if "%pwd%" EQU "" EndLocal & exit/B 1
EndLocal & set "%1=%pwd%"
doskey /listsize=0 >NUL 2>&1 & doskey /listsize=50 >NUL 2>&1 & rem empty keyboard
buffer
exit/B 0
:: check if credential has administrative privileges
:: ------------------------------------------------------------------------
:askIsAdmin
SetLocal & set "u=%~1" & set "p=%~2" & set/A ret=1
set "psCmd=powershell -Command "$p='%p%'^|convertto-securestring -asplaintext -force;$c=new-
object -typename system.management.automation.pscredential('%u%',$p^);start-process
'powershell' '-Command "write-host ([Security.Principal.WindowsPrincipal]
[Security.Principal.WindowsIdentity]::GetCurrent(^)^).IsInRole([Security.Principal.WindowsBuiltInRole]:
-credential $c -passthru -wait;""
for /F "usebackq delims=" %%# in (`%psCmd%`) do @set "result=%%#"
echo %result% | find /I "true">NUL 2>&1 && set/A ret=0
EndLocal & exit/B %ret%
exit/B 1
:: run elevated without UAC prompt

:: ------------------------------------------------------------------------
:elevateScript
SetLocal & set "u=%~1" & set "p=%~2"
set "_vbs_file_=%TEMP%\runadmin.vbs"
echo set oWS ^= CreateObject^("wScript.Shell"^)>"%_vbs_file_%"
echo strcmd="C:\Windows\system32\runas.exe /user:%COMPUTERNAME%\%u% " +
"""%~dpnx0""">>"%_vbs_file_%"
echo oWS.run strcmd, 2, false>>"%_vbs_file_%"
echo wScript.Sleep 100>>%_vbs_file_%
echo oWS.SendKeys "%p%{ENTER}">>%_vbs_file_%
if exist "%TEMP%\runadmin.vbs" (set "_spawn_=%TEMP%\runadmin.vbs") else (set
"_spawn_=runadmin.vbs")
ping 1.1.1.1 -n 1 -w 50 >NUL
start /B /WAIT cmd /C "cls & "%_spawn_%" & del /F /Q "%_spawn_%" 2>NUL"
EndLocal & set "pass="
exit/B 0
Lea Privilegios elevados en archivos por lotes en línea: https://riptutorial.com/es/batch-

file/topic/4898/privilegios-elevados-en-archivos-por-lotes
Capítulo 25: Redirección de entrada y salida.
Sintaxis
• [comando] [[> | >> | <| 2> | 2 >>] archivo]
• [[> | >> | <| 2> | 2 >>] archivo] [comando]
Parámetros
Parámetro Detalles
mando Cualquier comando válido.
> Escriba STDOUT en el archivo.
>> Agregue STDOUT al archivo.
< Lea el archivo a STDIN .
2> Escribe STDERR al archivo.
2>> STDERR al archivo.
expediente La ruta a un archivo.
Observaciones
• Puede agregar tantas redirecciones diferentes como desee, siempre que el símbolo y el
archivo de la redirección permanezcan juntos y en el orden correcto.
Examples
Un ejemplo...
@echo off
setlocal
set /p "_myvar=what is your name?"
echo HELLO!>file.txt
echo %_myvar%!>>file.txt
echo done!
pause
type file.txt
endlocal
exit
Ahora file.txt se ve como:
HELLO!
John Smith!
(Suponiendo que escribiste John Smith como tu nombre).
Ahora la consola de su archivo por lotes se ve así:
what is your name?John Smith

done!
Press any key to continue...
HELLO!
John Smith!
(y debería salir tan rápido que es posible que no pueda ver nada después de la solicitud. Press
any key to coninue... )
Redirigir el carácter especial con la expansión retrasada habilitada
¡Este ejemplo hace eco del carácter especial ! en un archivo. Esto solo funcionaría cuando
DelayedExpansion esté deshabilitado. Cuando la expansión retrasada está habilitada, deberá
utilizar tres caracteres y un signo de exclamación como este:
@echo off
echo ^^^!>file
echo ^>>>file
goto :eof
^> is the text

>> is the redirect operator
pause
endlocal
exit /b
Este código hará eco del siguiente texto en el archivo.
!
>
como
^^^ escapes the ! and echos it into the file

^> escapes the > and echos it into the file
Escribir en un archivo
@echo off
cls
echo Please input the file path, surrounded by "double quotation marks" if necessary.
REM If you don't want to redirect, escape the > by preceding it with ^
set /p filepath=^>
echo Writing a random number

echo %RANDOM% > %filepath%
echo Reading the random number
type %filepath%
REM Successive file writes will overwrite the previous file contents
echo Writing the current directory tree:
> %filepath% tree /A
echo Reading the file
type %filepath%
REM nul is a special file. It is always empty, no matter what you write to it.
echo Writing to nul
type %windir%\win.ini > nul
echo Reading from nul
type nul
echo Writing nul's contents to the file

type nul > %filepath%
echo Reading the file
type %filepath%
Lea Redirección de entrada y salida. en línea: https://riptutorial.com/es/batch-

file/topic/7502/redireccion-de-entrada-y-salida-
Capítulo 26: Si declaraciones
Sintaxis
• if [/ i] StringToCompare1 == StringToCompare2 (commandA) else (commandB)
• si errorlevel 1 (commandA) else (commandB)
• si% errorlevel% == 1 (commandA) else (commandB)
• si existe Nombre de archivo (commandA) else (commandB)
• si se define VariableName (commandA) else (commandB)
Observaciones
Hay algunas sintaxis para elegir en una sentencia if . Usaremos if string1==string2 como
ejemplo.
Sintaxis de 1 línea
• if string1==string2 commandA
• if string1==string2 (commandA)
• if string1==string2 (commandA) else (commandB)

• if string1==string2 (commandA) else commandB
• if string1==string2 (commandA)else (commandB)

• if string1==string2 (commandA)else commandB
Sintaxis multilínea
if string1==string2 (
commandA
)
if string1==string2 (
commandA
) else (
commandB
)
Todavía hay algunas sintaxis adicionales disponibles.
Examples
Comparando números con la declaración IF
SET TEST=0
IF %TEST% == 0 (
echo TEST FAILED
) ELSE IF %TEST% == 1 (
echo TEST PASSED
) ELSE (
echo TEST INVALID
)
Comparando cuerdas
IF "%~1" == "-help" (
ECHO "Hello"
)
donde %1 refiere al primer argumento de la línea de comando y ~ elimina todas las comillas que se
incluyeron cuando se llamó al script.
Comparando Errorlevel
If Errorlevel 1 (
Echo Errorlevel is 1 or higher
REM The phrase "1 or higher" is used because If Errorlevel 1 statement means:
REM If %Errorlevel% GEQ 1
REM Not If %Errorlevel% EQU 1
)
If "%Errorlevel%"=="1" (
Echo Errorlevel is 1
)
El script anterior verificará la variable Errorlevel (incorporada). El operador not puede ser utilizado.
Set "Test=%Errorlevel%"
If "%Test%" == "1" (
Echo Errorlevel is 1
)
Este también funciona.
Tenga en cuenta que algunos comandos no afectan el nivel de error :
• Descanso
• Eco
• Endlocal
• por
• Si
• Pausa
• Movimiento rápido del ojo
• Rd / Rmdir
• Conjunto
• Título
Los siguientes comandos configuran pero no borran errorlevel :
• Cls
• Ir
• Llaves
• Popd
• Cambio
Los siguientes comandos establecen códigos de salida pero no el nivel de error :
• Rd / Rmdir
Los siguientes comandos establecen errorlevel pero no los códigos de salida :
• Md / Mkdir
Compruebe si el archivo existe
If exist "C:\Foo\Bar.baz" (
Echo File exist
)
Esto comprueba si el archivo C: \ Foo \ Bar.baz existe. Si esto existe, se hace eco de archivos
existe el Not operador también se puede añadir.
Si existe variable / conjunto
If Defined Foo (
Echo Foo is defined
)
Esto comprobaría si una variable está definida o no. Una vez más, el Not puede utilizarse el
operador.
Lea Si declaraciones en línea: https://riptutorial.com/es/batch-file/topic/5475/si-declaraciones
Capítulo 27: Utilizando Goto
Introducción
Goto es simple. Mediante el uso de declaraciones goto simples, puede moverse a cualquier lugar
que desee en su código. También se puede usar para hacer funciones (Mostrado en cómo hacer
funciones).
Sintaxis
• goto: Etiqueta
• goto Label
• goto: EOF
Parámetros
Parámetro Detalles
:Label Cualquier etiqueta que sea válida (definida por :<LabelName> )
Una etiqueta predefinida que sale de la secuencia de comandos actual de la

:EOF
función (igual que exit /b )
Observaciones
Entonces, en otras palabras, si el número que insertó el jugador es 1, volverá a: Nombre parte del
código.
así que si la entrada es igual a 1, vuelva a la línea con: Nombre
Asegúrese de que si usa esto, la palabra comienza con el Colen (:).
Examples
Programas de ejemplo
Por ejemplo:
echo Hello!
pause >nul
:Name
echo What Is Your Name
set /p Input=Name:
echo so %Input% Is Your Name, right?
echo Rename?
echo 1 For Yes
echo 2 For No
set /p Input=Rename:
if %Input%=1 goto Name
Otro ejemplo:
@echo off
echo 1 or 2?
set /p input=Choice:
if %input%=1 goto Skip
echo You Chose 1
pause >nul
echo So time for stuff
pause >nul
echo Random Stuf
pause >nul
:Skip
echo So that's it.
pause >nul
Goto con variable
Goto acepta el uso del valor variable para actuar como la etiqueta para ir a.
Ejemplo:
@echo off
echo a = 1
echo b = 2
set /p "foo=Enter option:"

goto %foo%
Sin embargo, debe verificar la entrada para que no vaya a algún lugar que no exista. Ir a una
etiqueta indefinida terminará su script por lotes al instante.
Lea Utilizando Goto en línea: https://riptutorial.com/es/batch-file/topic/9164/utilizando-goto
Capítulo 28: Variables en archivos por lotes
Examples
Declaración
Para crear una variable simple y asignarla a un valor o cadena, use el comando SET :
SET var=10
Aquí, el código declara una nueva variable var con un valor de 10 . Por defecto, todas las
variables se almacenan internamente como cadenas; esto significa que el valor 10 no es diferente
de foo1234 o Hello, World!
Notas sobre las comillas.

Las comillas utilizadas se incluirán en el valor de la variable:
SET var="new value" <-- %var% == '"new value"'
Espacios en variables
El lenguaje por lotes considera que los espacios son partes aceptables de los nombres de
variables. Por ejemplo, set var = 10 resultará en una variable llamada var que contiene el valor 10
(note el espacio adicional a la derecha de var y la izquierda de 10).
Usando comillas para eliminar espacios

Para evitar espacios, utilice comillas alrededor de toda la tarea; El nombre y valor de la variable.
Esto también evita los espacios finales al final de la línea (el carácter ␣ denota un espacio):
SET␣var=my␣new␣value␣ <-- '%var%' == 'my new value '

SET␣"var=my␣new␣value"␣ <-- '%var%' == 'my new value'
Además, utilice comillas al unir varias declaraciones con & o | - alternativamente, ponga el
símbolo directamente después del final del valor de la variable:
SET var=val & goto :next <-- '%var%' == 'val '

SET "var=val" & goto :next <-- '%var%' == 'val'
SET var=val& goto :next <-- '%var%' == 'val'
Uso
echo %var%
Este código hará eco del valor de var
Si se usa setLocal EnableDelayedExpansion , lo siguiente setLocal EnableDelayedExpansion el valor de

var (la expresión estándar% var% no funcionará en ese contexto).
echo !var!
En los archivos por lotes, las variables se pueden usar en cualquier contexto, incluidas partes de
comandos o partes de otras variables. No puede llamar a una variable antes de definirla.
Usando variables como comandos:
set var=echo
%var% This will be echoed
Usando variables en otras variables:
set var=part1
set %var%part2=Hello
echo %part1part2%
Sustitución Variable
A diferencia de otros lenguajes de programación, en un archivo por lotes una variable se sustituye
por su valor real antes de que se ejecute el script por lotes. En otras palabras, la sustitución se
realiza cuando el script de comandos lee el script en la memoria, no cuando el script se ejecuta
más tarde.
Esto permite el uso de variables como comandos dentro del script, y como parte de otros
nombres de variables en el script, etc. El "script" en este contexto es una línea o bloque de
código, rodeado de paréntesis: () .
¡Pero este comportamiento significa que no puedes cambiar el valor de una variable dentro de un
bloque!
SET VAR=Hello
FOR /L %%a in (1,1,2) do (
ECHO %VAR%
SET VAR=Goodbye
)
imprimirá
Hello
Hello
ya que (como se ve, al ver la ejecución del script en la ventana de comandos) se evalúa para:
SET VAR=Hello
FOR /L %%a in (1,1,2) do (
echo Hello
SET VAR=Goodbye
)
En el ejemplo anterior, el comando ECHO se evalúa como Hello cuando el script se lee en la
memoria, por lo que el script repetirá Hello para siempre, sin embargo, se realizan muchos pasos
a través del script.
La forma de lograr el comportamiento variable más "tradicional" (de la variable que se está
expandiendo mientras se ejecuta el script) es habilitar la "expansión retrasada". Esto implica
agregar ese comando a la secuencia de comandos antes de la instrucción de bucle
(generalmente un bucle FOR, en una secuencia de comandos por lotes), y usar un signo de
exclamación (!) En lugar de un signo de porcentaje (%) en el nombre de la variable:
SET VAR=Hello
FOR /L %%a in (1,1,2) do (
echo !VAR!
SET VAR=Goodbye
)
endlocal
imprimirá
Hello
Goodbye
La sintaxis %%a in (1,1,2) hace que el bucle se ejecute 2 veces: en la primera ocasión, la variable
lleva su valor inicial de 'Hola', pero en la segunda pasada a través del bucle, después de haber
ejecutado la segunda La instrucción SET como la última acción en la 1ª pasada, ha cambiado al
valor revisado 'Adiós'.
Sustitución avanzada de variables
Ahora, una técnica avanzada. El uso del comando CALL permite al procesador de comandos por
lotes expandir una variable ubicada en la misma línea del script. Esto puede ofrecer una
expansión multinivel, mediante el uso repetido de LLAMADAS y modificadores.
Esto es útil en, por ejemplo, un bucle FOR. Como en el siguiente ejemplo, donde tenemos una
lista numerada de variables:
"c:\MyFiles\test1.txt" "c:\MyFiles\test2.txt" "c:\MyFiles\test3.txt"
Podemos lograr esto usando el siguiente bucle FOR:
for %%x in (%*) do (
set /a "i+=1"
call set path!i!=%%~!i!
call echo %%path!i!%%
)
endlocal
Salida:
c:\MyFiles\test1.txt
Tenga en cuenta que la variable !i! primero se expande a su valor inicial, 1, luego la variable
resultante,% 1, se expande a su valor real de c:\MyFiles\test1.txt . Esta es la doble expansión de
la variable i . En la siguiente línea, i es nuevamente doble expandido, mediante el uso del
comando CALL ECHO junto con el prefijo variable %% , luego se imprime en la pantalla (es decir, se
muestra en la pantalla).
En cada paso sucesivo a través del bucle, el número inicial se incrementa en 1 (debido al código
i+=1 ). Por lo tanto, aumenta a 2 en la 2ª pasada a través del bucle, y a 3 en la 3ª pasada. Por lo
tanto, la cuerda hizo eco a la pantalla altera con cada paso.
Declarar múltiples variables
Cuando se definen múltiples variables al comienzo del lote, se puede usar una forma de definición
corta empleando una cadena de reemplazo .
@echo off
set "vars=_A=good,_B=,_E=bad,_F=,_G=ugly,_C=,_H=,_I=,_J=,_K=,_L=,_D=6
set "%vars:,=" & set "%"
for /f %%l in ('set _') do echo %%l

exit /b
_A=good
_D=6
_E=bad
_G=ugly
Observe en el ejemplo anterior, las variables se ordenan alfabéticamente de forma nativa, cuando
se imprimen en la pantalla.
Usando una variable como una matriz
Es posible crear un conjunto de variables que pueden actuar de forma similar a una matriz
(aunque no son un objeto de matriz real) utilizando espacios en la instrucción SET :
@echo off
SET var=A "foo bar" 123
for %%a in (%var%) do (
echo %%a
)
echo Get the variable directly: %var%
Resultado:
A
"foo bar"
123
Get the variable directly: A "foo bar" 123
También es posible declarar su variable utilizando índices para que pueda recuperar información
específica. Esto creará múltiples variables, con la ilusión de una matriz:
@echo off
SET var[0]=A
SET var[1]=foo bar
SET var[2]=123
for %%a in (0,1,2) do (
echo !var[%%a]!
)
echo Get one of the variables directly: %var[1]%
Resultado:
A
foo bar
123
Get one of the variables directly: foo bar
Tenga en cuenta que en el ejemplo anterior, no puede hacer referencia a var sin indicar cuál es el
índice deseado, porque var no existe en sí mismo. Este ejemplo también utiliza la setlocal
enabledelayedexpansion junto con los puntos de exclamación en !var[%%a]! . Puede ver más
información sobre esto en la Documentación de alcance de sustitución variable .
Operaciones sobre variables
set var=10
set /a var=%var%+10
echo %var%
El valor final de var es 20.
La segunda línea no funciona dentro de un bloque de comando utilizado, por ejemplo, en una
condición IF o en un bucle FOR, ya que se necesitaría una expansión retardada en lugar de una
expansión de variable de entorno estándar.
Aquí hay otra, mejor manera de trabajar también en un bloque de comando:
set var=10
set /A var+=10
echo %var%
El entorno del símbolo del sistema admite valores enteros de 32 bits firmados:
• suma + y +=
• resta - y -=
• multiplicación * y *=
• división / y /=
• módulo de división % y %=
• &
• bitwise o |
• bit a bit NO ~
• XOR a nivel de bit ^
• desplazamiento a la izquierda en modo de bits <<
• desplazamiento a la derecha en modo de bits >>
• ! NO lógico !
• Menos unario -
• agrupando con ( y )
El intérprete de comandos de Windows no admite valores enteros de 64 bits o valores de coma

flotante en expresiones aritméticas.
Nota: El operador % debe escribirse en un archivo por lotes como %% para que se interprete como
operador.
En una ventana de indicador de comando que ejecuta el set /A Value=8 % 3 línea de comando set
/A Value=8 % 3 asigna el valor 2 a la variable de entorno Value y adicionalmente genera 2 .
En un archivo por lotes se debe escribir set /A Value=8 %% 3 para asignar el valor 2 a la variable de
entorno Value y no se genera nada, respectivamente, para manejar STDOUT (salida estándar).
Un set /A Value=8 % 3 líneas set /A Value=8 % 3 en un archivo por lotes daría como resultado un
mensaje de error. Falta el operador en la ejecución del archivo por lotes.
El entorno requiere el interruptor /A para operaciones aritméticas, no para variables de cadena

ordinarias.
Cada cadena en la expresión aritmética después del set /A es si un número o un operador se

interpreta automáticamente como el nombre de una variable de entorno.
Por esa razón, se hace referencia al valor de una variable con %variable% o con !variable! no es
necesario cuando el nombre de la variable consiste solo en caracteres de palabra (0-9A-Za-z_),
donde el primer carácter no es un dígito, lo que es especialmente útil dentro de un bloque de
comando que comienza con ( y termina con una coincidencia ) .
Los números se convierten de cadena a entero con la función C / C ++ strtol con base cero, lo que
significa una determinación automática de base que puede fácilmente dar resultados inesperados.
Ejemplo:
set Divided=11
set Divisor=3
set /A Quotient=Divided / Divisor
set /A Remainder=Divided %% Divisor
echo %Divided% / %Divisor% = %Quotient%

echo %Divided% %% %Divisor% = %Remainder%
set HexValue1=0x14
set HexValue2=0x0A
set /A Result=(HexValue1 + HexValue2) * -3
echo (%HexValue1% + %HexValue2%) * -3 = (20 + 10) * -3 = %Result%
set /A Result%%=7
echo -90 %%= 7 = %Result%
set OctalValue=020
set DecimalValue=12
set /A Result=OctalValue - DecimalValue
echo %OctalValue% - %DecimalValue% = 16 - 12 = %Result%
La salida de este ejemplo es:
11 / 3 = 3
11 % 3 = 2
(0x14 + 0x0A) * -3 = (20 + 10) * -3 = -90
-90 %= 7 = -6
020 - 12 = 16 - 12 = 4
Las variables no definidas en la evaluación de la expresión aritmética se sustituyen con el valor 0.
Configuración de variables desde una entrada
Usando el interruptor /p con el comando SET puede definir variables desde una entrada.
Esta entrada puede ser una entrada de usuario (teclado):
echo Enter your name :

set /p name=
echo Your name is %name%
Que se puede simplificar así:
set /p name=Enter your name :

echo Your name is %name%
O puede obtener la entrada de un archivo:
set /p name=< file.txt
en este caso, obtendrá el valor de la primera línea de file.txt
Obtener el valor de varias líneas en un archivo:
(
set /p line1=
set /p line2=
set /p line3=
) < file.txt
Lea Variables en archivos por lotes en línea: https://riptutorial.com/es/batch-

file/topic/3528/variables-en-archivos-por-lotes
Creditos
S.
Capítulos Contributors
No
BoeNoe, Clijsters, Community, DavidPostill, Derpcode,

Comenzando con el
1 geisterfurz007, Jeffrey Lin, loadingnow, Mee, rudicangiotti,
archivo por lotes
sambul35, Scott Beeson, Sourav Ghosh, stark, SteveFest, ths
Aleatorio en archivos
2 SteveFest
por lotes
Añadir retraso al
3 SteveFest, Tearzz, wizzwizz4
archivo por lotes
Archivo de lote
4 argumentos de línea DavidPostill, LotPings, npocmaka, sambul35
de comando
Archivos por lotes e

5 npocmaka, SteveFest
híbridos Powershell
Buscar cadenas en
6 sambul35
lote
Cambiando
7 directorios y listando Aravind .KEN, SomethingDark, SteveFest, wizzwizz4
sus contenidos
0x90h, BoeNoe, DavidPostill, Gábor Bakos, JosefZ, LotPings,

Comentarios en
8 SachaDee, SomethingDark, Sourav Ghosh, Stephan, SteveFest
archivos por lotes
, wasatchwizard
Creando archivos Aravind .KEN, David Starkey, fruitSalad266, J03L, LeoDog896,

9
usando Batch loadingnow, Tearzz
Diferencias entre
10 Batch (Windows) y SomethingDark, SteveFest
Terminal (Linux)
11 Directorio de pila DavidPostill, wizzwizz4
DavidPostill, fruitSalad266, Keith Hall, npocmaka,

12 Eco
SomethingDark, Tearzz, wizzwizz4
Errores en el
13 SteveFest, X. Liu
procesador cmd.exe
Escapar de
14 personajes npocmaka, SteveFest
especiales
Evitar las
limitaciones
15 npocmaka
aritméticas en los
archivos por lotes.
16 Funciones ender_scythe, npocmaka, SteveFest
Híbridos por lotes y

JSCript
Híbridos por lotes y

VBS
Macros de archivos
19 SteveFest
por lotes
Mandatos por lotes

20 obsoletos y sus npocmaka, SteveFest
reemplazos
Manejo de archivos
21 BoeNoe, LeoDog896, SteveFest
en archivos por lotes
22 Mejores prácticas SteveFest
Para bucles en David Starkey, DavidPostill, Ed999, Mee, sambul35,

23
archivos por lotes SomethingDark, SteveFest
Privilegios elevados
24 DavidPostill, elzooilogico, sambul35
en archivos por lotes
Redirección de
25 cascading-style, SomethingDark, SteveFest, wizzwizz4
entrada y salida.
26 Si declaraciones npocmaka, Ozair Kafray, SomethingDark, SteveFest
27 Utilizando Goto LeoDog896, SteveFest
DavidPostill, Ed999, Jay, Jeffrey Lin, Mee, Mofi, SachaDee,

Variables en
28 sambul35, SomethingDark, SteveFest, Tearzz, ths, Toomaja,
archivos por lotes
wasatchwizard, wizzwizz4

Bash Shelll

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Bash Shelll

Încărcat de

Drepturi de autor:

Formate disponibile

batch-file

Capítulo 1: Comenzando con el archivo por lotes 2

Abrir un símbolo del sistema 2

Edición y visualización de archivos por lotes 3

Capítulo 2: Aleatorio en archivos por lotes 5

Generando números aleatorios dentro de rango específico 5

Generando números aleatorios mayores que 32767 5

Pseudoaleatorio y uniforme al azar en lote 6

Capítulo 3: Añadir retraso al archivo por lotes 8

Capítulo 4: Archivo de lote argumentos de línea de comando 11

Argumentos de línea de comando suministrados a archivos por lotes 11

Cambiando argumentos dentro de paréntesis 12

Capítulo 5: Archivos por lotes e híbridos Powershell 14

Ejecutar Powershell con archivos temporales 14

Use el comando POWERSHELL para ejecutar el comando Powershell de 1 línea 14

Powershell / batch híbrido sin archivos temporales 15

Capítulo 6: Buscar cadenas en lote 16

Búsqueda de cadenas básicas 16

Usando los resultados de búsqueda 16

Capítulo 7: Cambiando directorios y listando sus contenidos 17

Para visualizar el directorio actual 17

Para cambiar el directorio actual (sin cambiar las unidades) 17

Navegando a un directorio en una unidad diferente 18

Cómo mostrar todas las carpetas y archivos en un directorio 18

Cambio de unidad sin CD / D 18

Para cambiar el directorio actual a la raíz de la unidad actual 19

Capítulo 8: Comentarios en archivos por lotes 20

Uso de REM para comentarios 20

Uso de etiquetas como comentarios 20

Uso de variables como comentarios 21

Comenta en la línea del código 21

Lote y comentario híbrido WSF 22

Capítulo 9: Creando archivos usando Batch 23

Eco para crear archivos 24

Guardando la salida de muchos comandos 25

Capítulo 10: Diferencias entre Batch (Windows) y Terminal (Linux) 27

Comandos de lotes y sus equivalentes de Bash 27

Variables de lote y su equivalente de golpe 30

Capítulo 11: Directorio de pila 32

Eliminar archivos de texto 32

Imprimir pila de directorios 32

Capítulo 12: Eco 34

Echo saca todo literalmente. 36

Echo de salida a archivo 36

Encendiendo el eco en los soportes internos 38

Capítulo 13: Errores en el procesador cmd.exe 39

Personaje de escape inadecuado 40

Extensión de archivo DEL 41

Capítulo 14: Escapar de personajes especiales 42

Escapar con caret (^) 42

Escapando del caret 43

Personajes especiales FIND y FINDSTR 43

Personajes especiales de FOR / F 44

Caracteres extra especiales 45

Escapar a través de la tubería 45

Emulación de cálculos a lápiz y papel, implementaciones de funciones matemáticas. 47

Capítulo 16: Funciones 48

Función con parámetros 49

Función que utiliza setlocal y endlocal 49

Funciones anónimas en archivos por lotes. 50

Llamando funciones desde otro archivo por lotes 50

Capítulo 17: Híbridos por lotes y JSCript 52

JScript incrustado en un archivo por lotes 52