Melhor maneira de fazer o Controle de Versão para o MS Excel

TortoiseSVN é um surpreendentemente bom cliente Windows para o sistema de controle de versões Subversion. Uma característica que eu acabei de descobrir que tem é que quando você clicar para obter uma diferença entre as versões de um arquivo Excel, ele vai abrir ambas as versões no Excel e destacar (em Vermelho) as células que foram alteradas. Isto é feito através da magia de um script vbs, descrito aqui.

Você pode achar isto útil mesmo que não use TortoiseSVN.

Depende se está a falar de dados, ou do código contido numa folha de cálculo. Embora eu tenha uma forte antipatia com o Visual Sourcesafe da Microsoft e normalmente não o recomendaria, ele se integra facilmente com acesso e Excel, e fornece o controle de fonte de módulos.

[de facto, a integração com o acesso, inclui consultas, relatórios e módulos como objectos individuais que podem ser versionados]

A ligação MSDN está aqui .

• trata o livro como qualquer outra aplicação. Lógica separada, configuração e dados.
• Código separado do manual.
• construir a IU programaticamente.
• escrever um programa de compilação para reconstrua o manual.

1. O que:

   • código (VBA)
   • Folhas De Cálculo (Fórmulas)
   • Planilhas (Valores)
   • Gráficos
   • ...

2. Porquê:

   • registo de auditoria
   • colaboração
   • comparação de versões ("diffing")
   • fusão

• Git
• Mercurial
• Subversion
Bazaar

Se a sua única preocupação é o código VBA nos seus livros de trabalho, então a abordagem Demosthenex acima propõe ou VbaGit (https://github.com/brucemcpherson/VbaGit trabalhar muito bem e são relativamente simples de implementar. As vantagens são que você pode confiar em sistemas de controle de Versão bem comprovados e escolher um de acordo com suas necessidades (dê uma olhada https://help.github.com/articles/what-are-the-differences-between-svn-and-git/ para uma breve comparação entre o Git e o Subversion).

Se não só se preocupa com o código, mas também com os dados nas suas folhas (valores"hardcoded" e resultados de fórmulas), pode usar uma estratégia semelhante para isso: serializar o conteúdo das suas folhas em algum formato de texto (via Range.Value) e usar um sistema de controle de versão existente. Aqui está um post muito bom blog sobre isso: https://wiki.ucl.ac.uk/display/~ucftpw2/2013/10/18/Using+git+for+version+control+of+spreadsheet+models+-+part+1+of+3

No entanto, a comparação de planilhas é um problema algorítmico não trivial. Existem algumas ferramentas, como o Microsoft Planilha Comparar (https://support.office.com/en-us/article/Overview-of-Spreadsheet-Compare-13fafa61-62aa-451b-8674-242ce5f2c986), Exceldiff (http://exceldiff.arstdesign.com/) e DiffEngineX ([62]} https://www.florencesoft.com/compare-excel-workbooks-differences.html mas é outro desafio integrar estas comparações com um sistema de controlo de versões como o Git.

Trabalhando em @Demosthenex trabalho, @Tmdean e @Jon Crowell comentários inestimáveis! (+1 Eles)

Gravo ficheiros de módulos no git\ dir ao lado da localização do livro de trabalho. Muda isso para o teu gosto.

Isto não irá acompanhar as alterações ao Código do Livro de trabalho. Por isso, cabe-te a ti sincronizá-los.

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

E depois no Módulo de manual:

Private Sub Workbook_Open()

    ImportCodeModules

End Sub

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

    SaveCodeModules

End Sub

Levando a resposta do @Demosthenex um passo mais longe, se você também gostaria de manter o controle do código em seus objetos do Microsoft Excel e UserForms você tem que ficar um pouco complicado.

Primeiro alterei a minha função SaveCodeModules() para explicar os diferentes tipos de código que pretendo 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

As formas de Utilização podem ser exportadas e importadas tal como o código VBA. A única diferença é que dois arquivos serão criados quando um formulário é exportado (você terá um arquivo .frm e um .frx para cada UserForm). Um destes contém o software que você escreveu e o outro é um arquivo binário que (tenho certeza) define o layout do formulário.

Microsoft Excel Objects (meos) (significando Sheet1, Sheet2, ThisWorkbook etc) pode ser exportado como um arquivo .cls. No entanto, quando você quiser obter este código de volta para o seu livro de trabalho, se você tentar importá-lo da mesma forma que você faria um módulo VBA, você vai obter um erro se essa folha já existe no livro de trabalho.

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

No caso de você estar confuso com a entrada dir para ambas as funções, isso é apenas o seu repositório de código! Então, você chamaria essas funções como:

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

Uma coisa que se pode fazer é ter o seguinte trecho no seu livro de trabalho:

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

Depois, pode usar o Subversion para manter o controlo de versões. Por exemplo, usando a interface da linha de comandos do Subversion com o comando 'shell' dentro do VBA. Isso bastava. Até estou a pensar fazer isto sozinho.

Eu uso o git , e hoje eu portei isto (git-xlsx-textconv) para o Python, uma vez que o meu projecto é baseado no código Python, e interage com os ficheiros Excel. Isto funciona pelo menos para .arquivos xlsx, mas acho que vai funcionar para .xls também. Aqui está a ligação github. Eu escrevi duas versões, uma com cada linha em sua própria linha, e outra onde cada célula está em sua própria linha (a última foi escrita porque git diff não gosta de embrulhar linhas longas por por omissão, pelo menos aqui no Windows).

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

Se quiser que o script esteja disponível para muitos repos diferentes, então use algo assim:

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

O Meu .GITATTRIBUTES ficheiro:

*.xlsx diff=xlsx

Se estiver a olhar para um ambiente de escritório com utilizadores regulares não técnicos de escritório, O Sharepoint é uma alternativa viável. Você pode configurar pastas de documentos com o controle de versão ativado e checkins e checkouts. Torna-o mais freindlier para utilizadores de escritório regulares.

Utilize qualquer uma das ferramentas padrão de controlo de versões, como o SVN ou o CVS. As limitações dependeriam do objectivo. Além de um pequeno aumento no tamanho do repositório, eu não enfrentei nenhum problema

Em resposta ao sharepoint de Resposta da mattlant só funcionará bem como um controlo de versões se a funcionalidade de controlo de versões estiver ligada na biblioteca de documentos. além disso, esteja ciente de que qualquer código que chama outros arquivos por caminhos relativos não vai funcionar. e, finalmente, quaisquer links para arquivos externos irão quebrar quando um arquivo é salvo no sharepoint.

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

Http://team-foundation-server.blogspot.com/2009/07/tf84037-there-was-problem-initializing.html

Depois de procurar por idades e experimentar muitas ferramentas diferentes, encontrei a minha resposta para o problema do controlo de versões VBA aqui: https://stackoverflow.com/a/25984759/2780179

É uma adição excel simples para a qual o código pode ser encontrado aqui

Não existem módulos duplicados após a importação. Ele exporta seu código automaticamente, assim que você salvar seu livro de trabalho, sem modificar qualquer workbooks existentes. Vem junto com um código vba formatação.

Na verdade, há apenas um punhado de soluções para rastrear e comparar mudanças no código macro - a maioria deles já foram nomeados aqui. Tenho navegado pela web e encontrei esta nova ferramenta que vale a pena mencionar:

Controlo de versões XLTools para macros VBA

• Controlo de versões para folhas de Excel e módulos VBA
• antevisão e diferenças antes de cometer uma versão
Muito bom para o trabalho colaborativo de vários usuários no mesmo arquivo (faixa que mudou o que/quando / Comentários)
• Comparar as versões e realçar as alterações no código Linha-A-Linha
• adequado para utilizadores que não são conhecedores de tecnologia, ou conhecedores de Excel, já agora
• o histórico da versão é armazenado no repositório Git no seu próprio PC-qualquer versão pode ser facilmente recuperada

Versões de código VBA lado a lado, as alterações são visualizadas

Gostaria de recomendar uma grande ferramenta de código aberto chamada Rubberduck que tem o controlo de versões do código VBA incorporado. Experimenta!

Pode ter tentado usar o XML do Excel da Microsoft no contentor zip (.xlsx and .xslm) para controle de versão e descobriu que o vba foi armazenado no vbaProject.bin (que é inútil para o controle de versão).

A solução é simples.

1. Abra o ficheiro excel com o LibreOffice Calc
2. In LibreOffice Calc
   1. ficheiro
   2. gravar como
   3. gravar como tipo: folha de cálculo ODF (.ods)
3. Fechar LibreOffice Calc
4. mudar o nome do novo ficheiro extensão de arquivo de .ods para .zip
5. crie uma pasta para a folha de cálculo numa área mantida pelo GIT
6. extrair o fecho para dentro da pasta git
7. comprometa - se com o GIT

Quando repetir isto com a próxima versão da folha de cálculo, terá de se certificar de que os ficheiros da pasta correspondem exactamente aos do contentor zip (e não deixe nenhuns ficheiros apagados para trás).

Existe também um programa chamado Beyond Compare que tem um arquivo Excel bastante bom comparar. Encontrei uma imagem em chinês que mostra brevemente isto:

Origem da imagem Original

Depende do nível de integração que você quer, eu usei Subversion/TortoiseSVN que parece bom para uso simples. Eu também adicionei em palavras-chave, mas parece haver um risco de corrupção de arquivo. Há uma opção no Subversion para fazer a palavra-chave substituições comprimento fixo e, tanto quanto eu entendo, vai funcionar se o comprimento fixo é mesmo, mas não estranho. Em qualquer caso, você não tem qualquer tipo útil de funcionalidade diff, eu acho que há produtos comerciais que vão fazer 'diff'. Sim. encontrar algo que fez diff baseado na conversão de coisas para texto simples e comparar isso, mas não foi muito agradável.

Ele deve funcionar com a maioria dos VCS (dependendo de outros critérios que você pode escolher SVN, CVS, Darcs, TFS, etc), No entanto ele vai realmente o arquivo completo (porque é um formato binário), o que significa que a pergunta "O que mudou" não é tão fácil de responder.

Você ainda pode confiar em mensagens de log se as pessoas completá - las, mas você também pode tentar os novos formatos baseados em XML do Office 2007 para ganhar um pouco mais de visibilidade (embora ainda seria difícil de arrancar através das toneladas de XML, mais AFAIK o ficheiro XML é comprimido no disco, por isso você precisa de um gancho de pré-commit para o desbloquear para que o diff de texto funcione correctamente).

Escrevi uma folha de cálculo controlada com revisão usando VBA. Ele é mais orientado para relatórios de engenharia, onde você tem várias pessoas trabalhando em uma conta de Material ou cronograma e, em algum momento, você quer criar uma revisão instantânea que mostra adições, del e atualizações do rev. anterior

Nota: é um livro de trabalho com opção de macro que você precisa assinar para transferir do meu site (você pode usar OpenID)

Todo o código está desbloqueado.

Controlado Por Rev Folha de cálculo