La mejor manera de hacer Control de versiones para MS Excel


172

¿Qué sistemas de control de versiones ha usado con MS Excel (2003/2007)? ¿Que recomendaria y porque? ¿Qué limitaciones ha encontrado con su sistema de control de versiones mejor calificado?

Para poner esto en perspectiva, aquí hay un par de casos de uso:

  1. control de versiones para módulos VBA
  2. más de una persona está trabajando en una hoja de cálculo de Excel y pueden estar haciendo cambios en la misma hoja de trabajo, que desean fusionar e integrar. Esta hoja de trabajo puede tener fórmulas, datos, gráficos, etc.
  3. los usuarios no son demasiado técnicos y cuantos menos sistemas de control de versiones utilicen, mejor
  4. La restricción de espacio es una consideración. Idealmente, solo se guardan los cambios incrementales en lugar de toda la hoja de cálculo de Excel.

17
Google Apps / Docs no tiene la funcionalidad completa de MS Excel, que necesita para realizar un trabajo más avanzado como el modelado.
TheObserver

25
@Richie Cotton. Si esa fuera una opción práctica (es decir, usar matlab / python), TODAS las compañías financieras habrían cambiado ahora. Pedirle a las personas que analizan modelos financieros pero que no son programadores que sean programadores está, en general, lleno de peligros y es realmente poco práctico.
Anónimo tipo

1
stackoverflow.com/q/608872/107537 vea una pregunta similar aquí. Pero no aborda las hojas de trabajo en sí. Solo el código VBA.
Vijay

77
Aquellos que culpan al modelado de Excel por la crisis crediticia son probablemente los estafadores que venden intencionalmente basura como AAA. No necesita una hoja de cálculo para decirle que una inversión es una mierda. Siendo un experto en finanzas, puedo decir que la dependencia total de cualquier modelo es una forma segura de perder el culo. Además, cualquier modelo es tan bueno como las personas que lo construyeron. Si contratas a Morts para hacer el trabajo de Einsteins, lo pasarás mal.
Eric J

Si está interesado principalmente en hacer el control de versiones en las macros de VBA, vea mi respuesta aquí: stackoverflow.com/a/38297505/2146688
Chel el

Respuestas:


64

Acabo de configurar una hoja de cálculo que usa Bazaar, con registro / salida manual a través de TortiseBZR. Dado que el tema me ayudó con la parte de guardar, quería publicar mi solución aquí.

La solución para mí fue crear una hoja de cálculo que exporta todos los módulos al guardar, y elimina y vuelve a importar los módulos en abierto. Sí, esto podría ser potencialmente peligroso para convertir hojas de cálculo existentes.

Esto me permite editar las macros en los módulos a través de Emacs (sí, emacs) o de forma nativa en Excel, y confirmar mi repositorio BZR después de cambios importantes. Como todos los módulos son archivos de texto, los comandos estándar de estilo diff en BZR funcionan para mis fuentes, excepto el archivo Excel en sí.

He configurado un directorio para mi repositorio BZR, X: \ Data \ MySheet. En el repositorio están MySheet.xls y un archivo .vba para cada uno de mis módulos (es decir: Module1Macros). En mi hoja de cálculo he agregado un módulo que está exento del ciclo de exportación / importación llamado "VersionControl". Cada módulo que se va a exportar y reimportar debe terminar en "Macros".

Contenido del módulo "VersionControl":

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i%, sName$

With ThisWorkbook.VBProject
    For i% = 1 To .VBComponents.Count
        If .VBComponents(i%).CodeModule.CountOfLines > 0 Then
            sName$ = .VBComponents(i%).CodeModule.Name
            .VBComponents(i%).Export "X:\Tools\MyExcelMacros\" & sName$ & ".vba"
        End If
    Next i
End With

End Sub

Sub ImportCodeModules()

With ThisWorkbook.VBProject
    For i% = 1 To .VBComponents.Count

        ModuleName = .VBComponents(i%).CodeModule.Name

        If ModuleName <> "VersionControl" Then
            If Right(ModuleName, 6) = "Macros" Then
                .VBComponents.Remove .VBComponents(ModuleName)
                .VBComponents.Import "X:\Data\MySheet\" & ModuleName & ".vba"
           End If
        End If
    Next i
End With

End Sub

A continuación, tenemos que configurar enlaces de eventos para abrir / guardar para ejecutar estas macros. En el visor de código, haga clic derecho en "ThisWorkbook" y seleccione "Ver código". Es posible que deba desplegar el cuadro de selección en la parte superior de la ventana de código para cambiar de la vista "(General)" a la vista "Libro de trabajo".

Contenido de la vista "Libro de trabajo":

Private Sub Workbook_Open()

ImportCodeModules

End Sub

Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)

SaveCodeModules

End Sub

Me instalaré en este flujo de trabajo durante las próximas semanas y publicaré si tengo algún problema.

¡Gracias por compartir el código de VBComponent!


55
Cuando vuelva a importar, también puede verificar el tipo de módulo. ThisWorkbook.VBProject.VBComponents.Item (i) .Type es 1 para un módulo estándar, 2 para un módulo de clase, 3 para un formulario de usuario y 100 para un módulo de documento (ya sea el libro o una hoja).
Jon Crowell

44
Hay un error en el código de importación. Como está eliminado e importa módulos, cambia el orden de los módulos, por lo que le faltan algunos cada vez. Debe cambiar el bucle For para ir hacia atrás a través de la matriz. por ejemplo, para i = .VBComponents.Count To 1 Step -1
Tmdean

2
En Excel 2013, es necesario habilitar "Acceso de confianza al modelo de objetos de proyecto de VBA" en el Centro de confianza, de lo contrario, obtendrá un Error 1004 muy inútil si intenta ejecutar este código.
Robin Green

8
Este script anterior está lejos de ser perfecto. El sub importCodeModules () tiene errores y produce módulos duplicados. Además, deberá editar cada libro de trabajo para agregar los eventos open y before_save. Esto es inaceptable. Después de buscar en la web durante mucho tiempo, finalmente encontré algo que realmente funciona (que se refiere aquí ). Tiene código de importación, exportación, formato de código y más. La exportación se realiza automáticamente al guardar y no es necesario editar ningún libro de trabajo existente.
CodeKid

55
Ese es un excelente hallazgo! Sugeriría usar eso en lugar de mi script anterior. Lo escribí una vez y lo usé por un tiempo, satisfizo mis necesidades. Para alguien que usa Excel y VBA diariamente, un programa o proyecto dedicado a esa exportación sería mucho más apropiado. ¡Gracias por compartir!
Demosthenex

42

TortoiseSVN es un cliente de Windows sorprendentemente bueno para el sistema de control de versiones Subversion. Una característica que acabo de descubrir que tiene es que cuando hace clic para obtener una diferencia entre las versiones de un archivo de Excel, abrirá ambas versiones en Excel y resaltará (en rojo) las celdas que se cambiaron. Esto se hace a través de la magia de un script vbs, descrito aquí .

Puede resultarle útil incluso si NO utiliza TortoiseSVN.


3
Es increíble saber que TortoiseSVN se puede comparar como una característica incorporada ^^
Nam G VU

2
¿Es esto lo mismo con el archivo de Word?
Nam G VU

3
Acabo de probar, esto también está disponible para el archivo de Word. Genial ^^
Nam G VU

No parece funcionar para el código VB. ¿Alguna solución para eso?
manpreet singh

10

Permítanme resumir lo que le gustaría controlar la versión y por qué:

  1. Qué:

    • Código (VBA)
    • Hojas de cálculo (fórmulas)
    • Hojas de cálculo (valores)
    • Gráficos
    • ...
  2. Por qué:

    • Registro de auditoría
    • Colaboración
    • Comparación de versiones ("diffing")
    • Fusionando

Como otros han publicado aquí, hay un par de soluciones además de los sistemas de control de versiones existentes, tales como:

  • Git
  • Mercurial
  • Subversión
  • Bazar

Si su única preocupación es el código VBA en sus libros de trabajo, entonces el enfoque que Demosthenex propone anteriormente o VbaGit ( https://github.com/brucemcpherson/VbaGit ) funcionan muy bien y son relativamente simples de implementar. Las ventajas son que puede confiar en sistemas de control de versiones bien probados y elegir uno de acuerdo con sus necesidades (consulte https://help.github.com/articles/what-are-the-differences-between-svn-and -git / para una breve comparación entre Git y Subversion).

Si no solo se preocupa por el código sino también por los datos en sus hojas (valores "codificados" y resultados de fórmulas), puede usar una estrategia similar para eso: serializar el contenido de sus hojas en algún formato de texto (a través de Range.Value) y usar un sistema de control de versiones existente. Aquí hay una muy buena publicación de blog sobre esto: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+spreadsheet+models+-+part + 1 + de + 3

Sin embargo, la comparación de hojas de cálculo es un problema algorítmico no trivial. Existen algunas herramientas, como la Comparación de hojas de cálculo de Microsoft ( https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986 ), Exceldiff ( http://exceldiff.arstdesign.com/ ) y DiffEngineX ( https://www.florencesoft.com/compare-excel-workbooks-differences.html ). Pero es otro desafío integrar estas comparaciones con un sistema de control de versiones como Git.

Finalmente, debe conformarse con un flujo de trabajo que se adapte a sus necesidades. Para un flujo de trabajo Git for Excel simple y personalizado, eche un vistazo a https://www.xltrail.com/blog/git-workflow-for-excel .


Actualización 2020: voté por su sugerencia de xltrail.com/git-xl, una extensión de código abierto de git que produce vba source diff entre commits, aunque limitada, me salva de las importaciones y exportaciones propensas a errores
chingNotCHing

9

Depende de si se trata de datos o del código contenido en una hoja de cálculo. Si bien tengo un fuerte disgusto por Visual Sourcesafe de Microsoft y normalmente no lo recomendaría, se integra fácilmente tanto con Access como con Excel, y proporciona control de fuente de los módulos.

[De hecho, la integración con Access incluye consultas, informes y módulos como objetos individuales que se pueden versionar]

El enlace de MSDN está aquí .


44
Uno de los secretos mejor guardados: no sabía que VSS podría hacer eso. +1
Preocupado por TunbridgeWells

Yo tampoco lo sabía. Pero de todos modos, VSS es un montón de cosas ... y me mantendría alejado de él.
GUI Junkie

Me emocioné y pasé una hora buscando esto en la red, pero parece que MS dejó de admitirlo en Excel 2003. Puede que tenga suerte si está trabajando con Access VBA, pero no lo busqué.
cosecha316

1
¿podría usar el complemento de edición para desarrolladores de Office ?: brandon.fuller.name/archives/2003/11/07/10.26.30
Mitch Wheat

7

No conozco una herramienta que lo haga bien, pero he visto una variedad de soluciones locales. El hilo común de estos es minimizar los datos binarios bajo el control de versiones y maximizar los datos textuales para aprovechar el poder de los sistemas SCC convencionales. Para hacer esto:

  • Trate el libro de trabajo como cualquier otra aplicación. Lógica separada, configuración y datos.
  • Código separado del libro de trabajo.
  • Construya la IU mediante programación.
  • Escriba un script de compilación para reconstruir el libro de trabajo.

¿Por qué pasar por todas estas tonterías cuando todo lo que necesita es un control de origen que maneje objetos binarios? SVN puede hacer esto.
Codificador desconocido

15
Porque no puedes fusionar objetos binarios
igelineau

6

Trabajando sobre el trabajo de @Demosthenex, @Tmdean y @Jon Crowell comentarios invaluables! (+1 ellos)

Guardo los archivos del módulo en git \ dir junto a la ubicación del libro. Cambia eso a tu gusto.

Esto NO hará un seguimiento de los cambios en el código del libro de trabajo. Entonces depende de usted sincronizarlos.

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i As Integer, name As String

With ThisWorkbook.VBProject
    For i = .VBComponents.count To 1 Step -1
        If .VBComponents(i).Type <> vbext_ct_Document Then
            If .VBComponents(i).CodeModule.CountOfLines > 0 Then
                name = .VBComponents(i).CodeModule.name
                .VBComponents(i).Export Application.ThisWorkbook.Path & _
                                            "\git\" & name & ".vba"
            End If
        End If
    Next i
End With

End Sub

Sub ImportCodeModules()
Dim i As Integer
Dim ModuleName As String

With ThisWorkbook.VBProject
    For i = .VBComponents.count To 1 Step -1

        ModuleName = .VBComponents(i).CodeModule.name

        If ModuleName <> "VersionControl" Then
            If .VBComponents(i).Type <> vbext_ct_Document Then
                .VBComponents.Remove .VBComponents(ModuleName)
                .VBComponents.Import Application.ThisWorkbook.Path & _
                                         "\git\" & ModuleName & ".vba"
            End If
        End If
    Next i
End With

End Sub

Y luego en el módulo Libro de trabajo:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

Private Sub Workbook_BeforeSave(ByVal SaveAsUI As Boolean, Cancel As Boolean)

    SaveCodeModules

End Sub

6

Llevando la respuesta de @Demosthenex un paso más allá, si desea realizar un seguimiento del código en sus Objetos de Microsoft Excel y Formularios de usuario, debe ponerse un poco complicado.

Primero modifiqué mi SaveCodeModules()función para tener en cuenta los diferentes tipos de código que planeo exportar:

Sub SaveCodeModules(dir As String)

'This code Exports all VBA modules
Dim moduleName As String
Dim vbaType As Integer

With ThisWorkbook.VBProject
    For i = 1 To .VBComponents.count
        If .VBComponents(i).CodeModule.CountOfLines > 0 Then
            moduleName = .VBComponents(i).CodeModule.Name
            vbaType = .VBComponents(i).Type

            If vbaType = 1 Then
                .VBComponents(i).Export dir & moduleName & ".vba"
            ElseIf vbaType = 3 Then
                .VBComponents(i).Export dir & moduleName & ".frm"
            ElseIf vbaType = 100 Then
                .VBComponents(i).Export dir & moduleName & ".cls"
            End If

        End If
    Next i
End With

End Sub

Los UserForms se pueden exportar e importar al igual que el código VBA. La única diferencia es que se crearán dos archivos cuando se exporte un formulario (obtendrá un .frmy un .frxarchivo para cada UserForm). Uno de ellos contiene el software que ha escrito y el otro es un archivo binario que (estoy bastante seguro) define el diseño del formulario.

Microsoft Excel Objetos (MEO) (que significa Sheet1, Sheet2, ThisWorkbooketc.) se pueden exportar como un .clsarchivo. Sin embargo, cuando desee recuperar este código en su libro de trabajo, si intenta importarlo de la misma manera que lo haría con un módulo VBA, recibirá un error si esa hoja ya existe en el libro de trabajo.

Para solucionar este problema, decidí no intentar importar el archivo .cls a Excel, sino leer el .clsarchivo en Excel como una cadena, y luego pegar esta cadena en el MEO vacío. Aquí está mi ImportCodeModules:

Sub ImportCodeModules(dir As String)

Dim modList(0 To 0) As String
Dim vbaType As Integer

' delete all forms, modules, and code in MEOs
With ThisWorkbook.VBProject
    For Each comp In .VBComponents

        moduleName = comp.CodeModule.Name

        vbaType = .VBComponents(moduleName).Type

        If moduleName <> "DevTools" Then
            If vbaType = 1 Or _
                vbaType = 3 Then

                .VBComponents.Remove .VBComponents(moduleName)

            ElseIf vbaType = 100 Then

                ' we can't simply delete these objects, so instead we empty them
                .VBComponents(moduleName).CodeModule.DeleteLines 1, .VBComponents(moduleName).CodeModule.CountOfLines

            End If
        End If
    Next comp
End With

' make a list of files in the target directory
Set FSO = CreateObject("Scripting.FileSystemObject")
Set dirContents = FSO.getfolder(dir) ' figure out what is in the directory we're importing

' import modules, forms, and MEO code back into workbook
With ThisWorkbook.VBProject
    For Each moduleName In dirContents.Files

        ' I don't want to import the module this script is in
        If moduleName.Name <> "DevTools.vba" Then

            ' if the current code is a module or form
            If Right(moduleName.Name, 4) = ".vba" Or _
                Right(moduleName.Name, 4) = ".frm" Then

                ' just import it normally
                .VBComponents.Import dir & moduleName.Name

            ' if the current code is a microsoft excel object
            ElseIf Right(moduleName.Name, 4) = ".cls" Then
                Dim count As Integer
                Dim fullmoduleString As String
                Open moduleName.Path For Input As #1

                count = 0              ' count which line we're on
                fullmoduleString = ""  ' build the string we want to put into the MEO
                Do Until EOF(1)        ' loop through all the lines in the file

                    Line Input #1, moduleString  ' the current line is moduleString
                    If count > 8 Then            ' skip the junk at the top of the file

                        ' append the current line `to the string we'll insert into the MEO
                        fullmoduleString = fullmoduleString & moduleString & vbNewLine

                    End If
                    count = count + 1
                Loop

                ' insert the lines into the MEO
                .VBComponents(Replace(moduleName.Name, ".cls", "")).CodeModule.InsertLines .VBComponents(Replace(moduleName.Name, ".cls", "")).CodeModule.CountOfLines + 1, fullmoduleString

                Close #1

            End If
        End If

    Next moduleName
End With

End Sub

En caso de que esté confundido por la direntrada a ambas funciones, ¡ese es solo su repositorio de código! Entonces, llamarías a estas funciones como:

SaveCodeModules "C:\...\YourDirectory\Project\source\"
ImportCodeModules "C:\...\YourDirectory\Project\source\"

Una nota rápida: no he tenido suerte con el control de versiones real con UserForms debido a los archivos binarios. Si crea varias ramas en su repositorio de git, es posible que no pueda fusionarlas si está trabajando con UserForms
dslosky

5

Uso git , y hoy porté esto (git-xlsx-textconv) a Python, ya que mi proyecto se basa en el código de Python e interactúa con archivos de Excel. Esto funciona para al menos archivos .xlsx , pero creo que también funcionará para .xls . Aquí está el enlace de github. Escribí dos versiones, una con cada fila en su propia línea y otra donde cada celda está en su propia línea (la última se escribió porque a git diff no le gusta ajustar las líneas largas de forma predeterminada, al menos aquí en Windows).

Este es mi archivo .gitconfig (esto permite que el script diferente resida en el repositorio de mi proyecto):

[diff "xlsx"]
    binary = true
    textconv = python `git rev-parse --show-toplevel`/src/util/git-xlsx-textconv.py

si desea que el script esté disponible para muchos repositorios diferentes, use algo como esto:

[diff "xlsx"]
    binary = true
    textconv = python C:/Python27/Scripts/git-xlsx-textconv.py

mi archivo .gitattributes :

*.xlsx diff=xlsx

3

Una cosa que podría hacer es tener el siguiente fragmento en su Libro de trabajo:

Sub SaveCodeModules()

'This code Exports all VBA modules
Dim i%, sName$

    With ThisWorkbook.VBProject
        For i% = 1 To .VBComponents.Count
            If .VBComponents(i%).CodeModule.CountOfLines > 0 Then
                sName$ = .VBComponents(i%).CodeModule.Name
                .VBComponents(i%).Export "C:\Code\" & sName$ & ".vba"
            End If
        Next i
    End With
End Sub

Encontré este fragmento en Internet.

Luego, puede usar Subversion para mantener el control de la versión. Por ejemplo, utilizando la interfaz de línea de comandos de Subversion con el comando 'shell' dentro de VBA. Eso lo haría. Incluso estoy pensando en hacer esto yo mismo :)


Creo que este es un excelente enfoque. El control de origen del código de Excel solo puede ocurrir con la descomposición. Esto inferiría un enfoque de construcción también. Code Cleaner puede hacer esto por ejemplo (freeware, creo) appspro.com/Utilities/CodeCleaner.htm pero igualmente su código es equivalente.
políglota el

Traté de modificar esto para que funcione con Microsoft® Excel® para Mac 2011 Versión 14.4.1. La línea que llama al método Exportar silenciosamente no hace nada (independientemente de los directorios OS X bien formados que utilicé).
DA Vincent

3

Me gustaría recomendar una gran herramienta de código abierto llamada Rubberduck que tiene incorporado el control de versiones del código VBA. ¡Pruébelo!


2

Si está buscando un entorno de oficina con usuarios no técnicos de oficina regulares, Sharepoint es una alternativa viable. Puede configurar carpetas de documentos con control de versiones habilitado y registros y salidas. Lo hace más sencillo para los usuarios habituales de la oficina.


2

en respuesta a la respuesta de Mattlant: Sharepoint funcionará bien como control de versión solo si la función de control de versión está activada en la biblioteca de documentos. Además, tenga en cuenta que cualquier código que llame a otros archivos por rutas relativas no funcionará. y finalmente cualquier enlace a archivos externos se romperá cuando se guarde un archivo en sharepoint.


1

Utilice cualquiera de las herramientas de control de versiones estándar como SVN o CVS. Las limitaciones dependerán de cuál sea el objetivo. Aparte de un pequeño aumento en el tamaño del repositorio, no tuve ningún problema


1

Deberías probar DiffEngineX. Se puede llamar mediante programación y también desde la línea de comandos tomando argumentos de la línea de comandos. No solo compara las celdas de las hojas de cálculo de Excel, sino también las macros de Visual Basic incrustadas en los libros. También compara los nombres y comentarios definidos por Excel, que muchas herramientas freeware pierden. Se puede descargar desde

http://www.florencesoft.com/excel-differences-download.html

Estoy seguro de que su sistema de control de versiones tiene una opción o cuadro para que pueda llamar automáticamente a DiffEngineX con sus libros de Excel originales y modificados.


12
Debe mencionar en su respuesta que está afiliado a este producto comercial.
Hans Olsson


1

Después de buscar edades y probar muchas herramientas diferentes, he encontrado mi respuesta al problema de control de versiones de vba aquí: https://stackoverflow.com/a/25984759/2780179

Es un complemento simple de Excel para el que se puede encontrar el código aquí

No hay módulos duplicados después de la importación. Exporta su código automáticamente, tan pronto como guarde su libro de trabajo, sin modificar ningún libro de trabajo existente . Viene junto con un formateador de código vba.


1

En realidad, solo hay un puñado de soluciones para rastrear y comparar cambios en el código macro, la mayoría de los cuales ya se mencionaron aquí. He estado navegando por la web y encontré esta nueva herramienta que vale la pena mencionar:

Control de versiones de XLTools para macros VBA

  • control de versiones para hojas Excel y módulos VBA
  • Vista previa y cambios de diferencia antes de confirmar una versión
  • ideal para el trabajo colaborativo de varios usuarios en el mismo archivo (rastrea quién cambió qué / cuándo / comentarios)
  • compare versiones y resalte cambios en el código línea por línea
  • adecuado para usuarios que no son expertos en tecnología, o expertos en Excel para el caso
  • el historial de versiones se almacena en el repositorio de Git en su propia PC; cualquier versión se puede recuperar fácilmente

Versiones de código VBA una al lado de la otra, se visualizan los cambios


0

Es posible que haya intentado usar Excel XML de Microsoft en el contenedor zip (.xlsx y .xslm) para el control de versiones y descubrió que vba estaba almacenado en vbaProject.bin (que no sirve para el control de versiones).

La solución es simple.

  1. Abra el archivo de Excel con LibreOffice Calc
  2. En LibreOffice Calc
    1. Expediente
    2. Guardar como
    3. Guardar como tipo: hoja de cálculo ODF (.ods)
  3. Cerrar LibreOffice Calc
  4. cambie el nombre de la extensión del archivo nuevo de .ods a .zip
  5. crear una carpeta para la hoja de cálculo en un área mantenida GIT
  6. extraer el zip en su carpeta GIT
  7. comprometerse con GIT

Cuando repita esto con la próxima versión de la hoja de cálculo, tendrá que asegurarse de que los archivos de la carpeta coincidan exactamente con los del contenedor zip (y no deje ningún archivo eliminado).


2
Sin embargo, este enfoque está lleno de riesgos. Si posteriormente utiliza una función en Excel que no está implementada en Libre o que no se "asigna" a Libre y viceversa, este enfoque se interrumpirá. Esto funcionará, estoy seguro, para hojas de cálculo simples, pero se debe tener mucho cuidado. PW
Phil Whittington

0

También hay un programa llamado Beyond Compare que tiene una buena comparación de archivos Excel. Encontré una captura de pantalla en chino que muestra brevemente esto:

Beyond Compare: comparación de dos archivos de Excel (chino)
Fuente de imagen original

Hay una prueba de 30 días en su página


0

Encontré una solución muy simple para esta pregunta que satisface mis necesidades. Agrego una línea al final de todas mis macros que exporta un *.txtarchivo con el código de macro completo cada vez que se ejecuta. El código:

ActiveWorkbook.VBProject.VBComponents("moduleName").Export"C:\Path\To\Spreadsheet\moduleName.txt"

(Se encuentra en los Tutoriales de Tom , que también cubre algunas configuraciones que puede necesitar para que esto funcione).

Como siempre ejecutaré la macro cada vez que esté trabajando en el código, tengo la garantía de que git recogerá los cambios. La única parte molesta es que si necesito pagar una versión anterior, tengo que copiar / pegar manualmente *.txten la hoja de cálculo.


-1

Depende del nivel de integración que desee, he usado Subversion / TortoiseSVN que parece estar bien para un uso simple. También he agregado palabras clave, pero parece haber un riesgo de corrupción de archivos. Hay una opción en Subversion para hacer que las sustituciones de palabras clave tengan una longitud fija y, por lo que entiendo, funcionará si la longitud fija es par pero no impar. En cualquier caso, no obtienes ningún tipo útil de funcionalidad diff, creo que hay productos comerciales que harán 'diff'. Encontré algo que difería en función de convertir cosas a texto plano y comparar eso, pero no fue muy agradable.


-1

Debería funcionar con la mayoría de VCS (dependiendo de otros criterios, puede elegir SVN, CVS, Darcs, TFS, etc.), sin embargo, en realidad será el archivo completo (porque es un formato binario), lo que significa que la pregunta "qué cambió" es No es tan fácil de responder.

Todavía puede confiar en los mensajes de registro si las personas los completan, pero también puede probar los nuevos formatos basados ​​en XML de Office 2007 para obtener más visibilidad (aunque aún sería difícil eliminar toneladas de XML, más AFAIK el archivo XML está comprimido en el disco, por lo que necesitaría un enlace previo a la confirmación para descomprimirlo para que el diff de texto funcione correctamente).


-1

Escribí una hoja de cálculo controlada por revisión usando VBA. Está más orientado a los informes de ingeniería en los que tiene varias personas trabajando en una Lista de materiales o Programa y luego, en algún momento, desea crear una revisión de instantánea que muestre adiciones, eliminaciones y actualizaciones de la revisión anterior.

Nota: es un libro habilitado para macros que debe iniciar sesión para descargar desde mi sitio (puede usar OpenID)

Todo el código está desbloqueado.

Hoja de cálculo controlada por Rev


-1

Mi empresa realiza una cantidad considerable de trabajo en la automatización de las soluciones de Microsoft Office, así que escribí un archivo .DLL que exportará el origen de una solución cada vez que se guarde una plantilla. Crea una carpeta llamada Origen como elemento secundario de la carpeta donde se guarda la plantilla, y debajo de Origen crea una carpeta con el mismo nombre que el Proyecto VBA. En la carpeta del proyecto, exporta todo el código fuente para módulos, clases y formularios de usuario. Este arreglo se eligió para facilitar la administración de la fuente de grandes colecciones de plantillas. La DLL puede desbloquear proyectos bloqueados para obtener acceso al proyecto VBA si tiene un archivo de configuración local o un archivo de configuración global disponible. Con esta herramienta en uso, los desarrolladores pueden trabajar en las plantillas a su gusto y usar su herramienta de control de revisiones favorita para administrar su trabajo.


Chad: recomiendo leer esta publicación, de la que me enteré recientemente: stackoverflow.com/help/promotion . Su respuesta parece violar el "No se lo digas, ¡muéstralo!" principio.Usted habla sobre su empresa y una solución que se le ocurrió, y hace una serie de referencias a un archivo DLL, pero no nos muestra cómo lo hizo ni siquiera proporciona acceso a la DLL. Como tal, esta respuesta no está en el espíritu de este sitio web.
Colm Bhandal
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.