¿Hay alguna manera de insertar y reventar todas las variables de entorno en un script por lotes?

10

¿Hay alguna manera de insertar y reventar todas las variables de entorno en un script por lotes? Por ejemplo, me gustaría hacer algo como esto:

pushEnvironmentVariables
call "%VS140COMNTOOLS%\vsvars32.bat"
(do some stuff...)
popEnvironmentVariables
pushEnvironmentVariables
call "%VS90COMNTOOLS%\vsvars32.bat"
(do some other stuff...)
popEnvironmentVariables
batch environment-variables שלומי שטיין
fuente

Respuestas:

13

Utilice setlocal, consulte setlocal /?o ss64.com/nt/setlocal

Setlocal
call "%VS140COMNTOOLS%\vsvars32.bat"
(do some stuff...)
Endlocal
Setlocal
call "%VS90COMNTOOLS%\vsvars32.bat"
(do some other stuff...)
Endlocal

Para guardar el estado variable actual que podría hacer

set >MyVarStatus.txt

y restaurar más tarde con

@Echo off
For /f "tokens=1* delims==" %%A in (
  'findstr /V "^Path" MYVarStatus.txt '
) Do Set %%A=%%B

esto excluiría las variables de ruta.

LotPings
fuente
Usted excluye PATH, solo por ejemplo o por alguna razón. Estoy especialmente interesado en push / pop la variable de ruta. ¿Hay algo que hable en contra de la copia de seguridad / restauración PATH?
Lobo
De hecho, tanto un ejemplo como en caso de cambios importantes se aplicaron a la ruta mientras tanto una precaución. @wolf
LotPings
Bueno, no puede estar seguro en todos los casos, pero si tiene que agregar algo a la ruta solo para una sesión específica, definitivamente está interesado en restaurar la ruta después. No tendría que hacer esto si no hubiera herramientas externas que llamen a otras herramientas y esperen que estén en el camino.
Lobo
1
El código está abierto a cambios, si uno quiere restaurar todo el entorno simplemente reemplace findtr con tipo
LotPings
Gracias, solo quería asegurarme de no pasar por alto nada importante.
Lobo
1

Un poco tarde a la escena pero aquí va de todos modos. A continuación se muestra una implementación de una estructura de datos de pila en secuencias de comandos por lotes de Windows.

caracteristicas:

  • Debe llamar a la subrutina : InitializeStack antes de usar la pila.
  • Empuje elementos en la pila llamando a : Subrutina de inserción .
  • Haga estallar elementos de la pila llamando a la subrutina Pop .
  • La variable $ Count siempre contendrá el recuento de elementos en la pila.
  • La variable $ Top siempre contendrá el elemento más reciente agregado a la pila.
  • La variable $ Bottom siempre contendrá el primer elemento agregado a la pila.
  • Puede volcar el contenido de la pila llamando a la subrutina : DumpStack .
  • El tipo de elementos que puede insertar en la pila es cualquier cosa que pueda almacenarse en una variable. Por ejemplo, Call: Push "String 1" , Call: Push "% 1" , Call: Push "% MyVariable%" , etc.

Utilizo la pila en mis archivos por lotes para realizar un seguimiento de las llamadas de subrutina. Cada subrutina en mis archivos por lotes comienza con Call: Push% 0 , que empuja el nombre de la subrutina actual a la pila y termina con Call: Pop .

Algunos pueden encontrar una eliminación excesiva para las secuencias de comandos por lotes, pero disfruté creándolo y espero que alguien lo encuentre útil, disfruten .

@Echo Off
Cls
SetLocal
SetLocal EnableExtensions
SetLocal EnableDelayedExpansion

Call :InitializeStack

Call :Push "String 1"
Call :Push "String 2"
Call :Push "String 3"
Call :Pop

Echo Total items in stack = !$Count!
Echo Top of stack         = !$Top!
Echo Bottom of stack      = !$Bottom!
Call :DumpStack

Goto End

:InitializeStack
:------------------------------------------------------------
Set "$Stack[0]=0"
Set "$Count=!$Stack[0]!"
Set "$Top="
Set "$Bottom="
Exit /b

:DumpStack
:------------------------------------------------------------
If !$Stack[0]! EQU 0 (
  Echo Stack is empty.
) Else (
  Echo.
  Echo Stack Dump
  Echo ----------
  For /l %%a In (!$Stack[0]!,-1,1) Do (Echo !$Stack[%%a]!)
)
Exit /b

:Push <String>
:------------------------------------------------------------
Set /a "$Stack[0]+=1"
Set "$Count=!$Stack[0]!"
Set "$Top=%~1"
Set "$Bottom=!$Stack[1]!"
Set "$Stack[!$Stack[0]!]=!$Top!"
Exit /b

:Pop
:------------------------------------------------------------
If !$Stack[0]! EQU 0 (
  Echo "Stack is empty."
) Else (
  Set "$Stack[!$Stack[0]!]="
  Set /a "$Stack[0]-=1"
  Set "$Count=!$Stack[0]!"
  If !$Stack[0]! GTR 0 (
    For %%a In (!$Stack[0]!) Do Set "$Top=!$Stack[%%a]!"
    Set "$Bottom=!$Stack[1]!"
  ) Else (
    Set "$Top="
    Set "$Bottom="
  )
)Exit /b

:PushAllEnvironmentVariables
:------------------------------------------------------------
For /f "Tokens=* Delims=" %%a In ('Set') Do Call :Push "%%a"
Exit /b

:PopAllEnvironmentVariables
:------------------------------------------------------------
For /l %%a In (!$Stack[0]!,-1,1) Do (Set !$Stack[%%a]!)
Exit /b

:End

Entonces, para enviar todas las variables de entorno, puede llamar a: PushAllEnvironmentVariables, para restaurar todas las variables de entorno, puede llamar a: PopAllEnvironmentVariables

Safwan
fuente
Esto parece, de un vistazo, ser algo que tal vez requirió un esfuerzo para desarrollarse, y tal vez podría ser útil para alguien. ¿Puedes explicar cómo esto proporciona una respuesta a esta pregunta ?
Scott
Veo su punto, para impulsar todas las variables de entorno que puede usar: For /f "Tokens=* Delims=" %%a In ('Set') Do Call :Push "%%a" Para restaurar todas las variables de entorno que puede usar: For /l %%a In (!$Stack[0]!,-1,1) Do (Set !$Stack[%%a]!) He actualizado la respuesta para incluir 2 subrutinas que implementen esto.
Safwan