Blue Flower

Ein Sicherungsscript das z.B. per "Geplante Tasks" ausgeführt werden kann.

Viele Parameter von 7z sind nicht so einfach zu durchschauen.

Ein paar sinnvolle werden in diesem Script aufgezeigt / verwenden.

 

Das Script kann einfach per cscript 7z.vbs gestartet werden. Dann müssen allerdings die Parameter im Script Bereich "Konfiguration" angepasst werden.

Genauso kann das Script mit Parameter gestartet werden cscript7z .vbs -p"geht keinen was an ;-)" c:\quelle d:\Sicherung

Das Script durchsucht die gängigen Pfade nach der 7z.exe-Datei. Im Notfall in der Funktion getSevenZipProg() anpassen.

Script-Link: script
 
Option Explicit
'...........................................................................................................................................................
'  7z.vbs 1.05   Autor: Michael Hölldobler hoelldobler[at]alant.de
'  Script benötigt eine Version des 7z-Packers
'  Packen:    7z.vbs <command>  -<Parameter1> -<Parameter2> -<..>. Pfad\Unterpfad\[ArchivName.7z] Quelle1 <Quelle2> <..>
'  Entpacken: 7z.vbs x <-p> Entpack-Ziel-Pfad Archiv.7z
'
' Commands:  Ohne führendes Minuszeichen. Wird kein Command angegeben wird u angenommen wenn es schon ein Archiv gibt
'   a       Dateien zum Archiv hinzufügen [Optional] 
'   u       update Achiv differnziell (differenziell)  [Optional]
'   m       Mirror Quelle auf Archiv spiegeln
'   x       Dateien entpacken  (e) Alle in den Basisordner entpacken
'   
' Parameter: <Zusätzliche Angaben zu Parameter. !ohne eckige Klammern!>
'   -p<"?">  Passwort
'   -h<"?">  Passwort mit verborgener Ordnerstrucktur   (-mhe)
'   -b       Nur Basisverzeichnis der Quellen   (-r-)
'   -v<?>    maximale Dateigröße danach wird gesplittet z.B -v100m -v1g (nicht kombinierbar mit "u")
'   -x       Selbstentpackendes Archiv.exe erzeugen   (-sfx)
'   -t<?>    fileFormat 7z (default)   -tz ZIP
'   -i<?>    Nur diese Dateien einschließen   z.B. -i*.doc (mehrfach möglich)
'   -x<?>    Diese Datei ausschließen  z.B. -x*.tmp -x*.mp3 (mehrfach möglich)
'            Eine Filter wie unter Windows mit *.* funtioniert nur bedingt. Wenn es einen Ordner mit einem Puntk im Namen gibt wird diese ebenfallst archiviert
'            Der Filter wird von * auf *.* gesetzt und der Unter-Ordner mit einem Punkt im Namen in die auszuschließenden Dateien aufgenommen.
'   -c<?>    Kompressieronsrate 0 (keine) .. 5 (default) .. 9 (maximale)
'   -n<?>    Archivname. Kann aber auch im Archiv-Pfad angegeben werden.
'   -v<?>    Dateigrö0e der einzelnen Archiv-Dateien. Es kann dann aber immer nur ein Vollbackup gemacht werden!
'   -u<?>    Anzahl der differentiellen Backups (-up0) 
'   -o<?>    Ausgabe-Ordner zum Entpacken
'
' Archiv-Pfad 
'    Immer als erster Datei-/ Ordner-Pfad angegeben z.B. c:\backup\archiv  
'    Wird die Endung mit angegeben z.B c:\backup\archiv.7z wird der Dateiname Archiv sein
'    Ohne Endung wird angenommen das es der Pfadname ist und der Dateiname wird aus der Valirablen "archivName" erstellt
' Quelle[n] 
'   Immer nach dem Archiv-Pfad angeben z.B. c:\meineDaten  c:\meineDaten\* 
'
' Generell gilt:
'   Alle Parameter mit Leerzeichen kapseln -> "mit Leerzeichen"
'   Optionale Parameter werden wie unten im Konfigurations-Teil verwendet, wenn nichts angegeben
'   Das Script kann auch ohne Parameter aufgerufen werden. Damm müssen aber alle Parameter im Konfiguration-Teil eingetragen sein
'   Es werden nur die s.O. in ()Klammern angegebenen originalen Parameter mit ausgewertet
'   Bezugsquellew: http://www.7zip.org/
'...........................................................................................................................................................

Dim sourceFolders, excludeFilter, includeFilter, sevenZipProg
dim destination, cmd, password, fileFormat, filesize, noSubdir, compression, fileSuffix
Dim fso, wsh, sfx, noListing, updateAchiv, outputDir, destinationDiff, quiet
Dim oArgs, extract, f, archivName, diffName, diffCount
dim s, stmp2, s3, stmp, i, j, k

'--------------------------------------------------------------------------------------
'----- Konfiguration ------------------------------------------------------------------
'--------------------------------------------------------------------------------------

' Quellverzeichnisse
' Wichtig: Bei den Quellpfaden keinen abschließende Backslashes angeben !
' ---------------------------------------------------------------------------
sourceFolders = Array("d:\persoenliche Daten", "c:\test") '"c:\data","c:\Users\[user]\Documents", "d:\data"

' Ausschluss-Dateien
' ------------------
excludeFilter = Array()

' Nur bestimmte Dateitypen packen
' -> "" "*" alle Dateien außer excludeFilter
' -> "*.doc", "*.xls", "*.pdf"
' -------------------------------
includeFilter = Array("*")


' Das Zielverzeichnis
' -------------------
destination = "x:\testbackup"
'destination = ""

' Arrchiv-Name für Vollbackup 
' ---------------------------------------------------------------------------------------------------------
archivName = "Sicherung"

' Archiv-Namenserweiterung bei differenziellem Backup in das Archiv
'-------------------------------------------------------------------
diffName = "_diff_?"
'max. Anzahl der differenziellem Backup's. Leer oder 0 wird nur ein diff Backup erstellt und immer wieder dieses verwendet
diffCount = "50"
'Platzhalter für den Zähler im diff. Backup
Const diffWildcard = "?"


' Archiv-Format
' -------------
' -> "7z" oder "zip"
fileFormat = "7z"

' Passwort angeben
' -> "?" -> öffnet ein Eingabefenster
' -----------------------------------
password = "" '"0815 ist als Passwort nicht OK"

' Blick ins Archiv verwehren (Dateiliste)
' -> False oder True - Explorer kann nicht hineinschauen (Sowieso nur bei *.zip)
' ------------------------------------------------------------------------------
noListing = False

' maximale Datei-Größe
' -> "" 100k (Kilobyte) 100m (Megabyte) 2g (Gigabytes)
' ----------------------------------------------------
filesize = ""

'Kompressionsrate
' -> 5 Vorgabe 0 (keine), 1, 3 ,(5 default) ,7 ,9
'--------------------------------------
compression = ""

' Selbstentpackendes Archiv erzeugen
' -> False oder True (exe wird erzeugt. 7zip wird nicht mehr benötigt zu eintpacken des Archivs)
' ----------------------------------------------------------------------------------------------
sfx = False

'Keine Unterverzeichnisse der Quellverzeichnisse sichern
' -> True kein Unterverzeichnisse archivieren. Wurde in der Quellenangabe nur der * angegeben muss dieser auf *.* erweitert werden
' -> False => Mit Unterverzeichnisen sichern
'-------------------------------------------------------
noSubdir = false

' entpacken (extrahieren) in folgendes Verzeichnis
'--------------------------------------------------
outputDir = ""


'Keine Popups ausgeben
'---------------------
quiet = False

'Vorgegebener Befehl
'---------------------
cmd = ""
'--------------------------------------------------------------------------------------
'----- ENDE Konfiguration -------------------------------------------------------------
'--------------------------------------------------------------------------------------

Const cSpace = " "
Const cBSlash = "\"
Const cSlash = "/"
Const cDQ = """"
Const cC = "%COMSPEC% /C "
Const cHeader = "7-Zip Backup-Script"
Set fso = CreateObject("Scripting.FileSystemObject")
Set wsh = CreateObject("WScript.Shell")
Set oArgs = WScript.Arguments

' 7z-Pfad ermitteln
getSevenZipProg()

' Startparameter verarbeiten
openArgs()
setPara()
run7z()

set fso = nothing
Set wsh = nothing
Set oArgs = nothing

'---------------------------------------------------------------------------------------
'--- Funktionen ------------------------------------------------------------------------
'---------------------------------------------------------------------------------------

Function openArgs()
  Dim sOA, i, j, k
  Dim fDestination
  fDestination = False
	
  If oArgs.Count = 0 Then
    'Abfangen wenn kein Argument übergeben wurde
  Else
    For i = 0  To oArgs.Count - 1
      On Error Resume Next
      sOA = LCase(oArgs(i))
      select case sOA
        case "a", "u","m", "x", "e": cmd = sOA
        case  "b", "h","l", "rn", "t": cmd = sOA 'b (Benchmark): h (Hash) command, l (List contents of archive), rn (Rename), t (Test integrity of archive)
        case Else
          if Left(sOA, 1) = "/" Then sOA = replace(sOA, "/", "-", 1, 1, vbTextCompare) '/ ist auch erlaubt wird hier in ein Parameter-Steuerzeichen umgewandelt
          if Left(sOA, 1) = "-" Then          'Parameter
            sTmp = Left(sOA, 2)
            stmp2 = Right(oArgs(i),Len(oArgs(i)) - 2)
            Select Case sTmp                
              case "-b": noSubdir = True
              case "-c": compression = stmp2
              Case "-h": fNoListing = true
              Case "-i" 'Datei-Filter +
                if stmp2 <> vbnullString then
                  j = UBound(includeFilter) + 1
                  ReDim Preserve includeFilter(j)
                  includeFilter(j) = stmp2
                end if
              case "-n": archivName = stmp2
              case "-o": outputDir = stmp2
              Case "-p" 'Passwort
                If stmp2 = "?" Then stmp2 = InputBox("Passwort eingeben" & VbCrLf & "Wird nicht verschlüsselt angezeigt", "Passwort-Abfrage")
                password = stmp2
              case "-r": if stmp2 = "-" then noSubdir = True
              Case "-t" 'Packformat
                If stmp2 = "z" or stmp2 = "zip" Then
                  fileFormat = "zip"
                Else
                  fileFormat = "7z"
                End If
              Case "-u": 
							  if IsNumeric(stmp2) then
							    diffCount = stmp2 'Anzahl Backups
								elseif stmp2 = "q0" then
								  updateAchiv = " -uq0" 'Mirror
								end if
              Case "-v": filesize = stmp2 'Dateigröße nachdem gesplittet wird
              Case "-x" 'Datei-Filter -
                if stmp2 <> vbnullString then
                  j = UBound(excludeFilter) + 1
                  ReDim Preserve excludeFilter(j)
                  excludeFilter(j) = stmp2
                end if
              case "-?":
                s = "Commands: Ohne führendes Minuszeichen. Wird kein Command angegeben wird in das Archiv gespeichert" & vbCrLf & _
                    " a        Dateien zum Archiv hinzufügen [Optional]" & vbCrLf & _ 
                    " u        update Achiv differnziell (differenziell)  [Optional]" & vbCrLf & _
                    " m        Mirror Quelle auf Archiv spiegeln" & vbCrLf & _
                    " e        Dateien entpacken   (e) Alle in den Basisordner entpacken" & vbCrLf & _
                    "Parameter: Zusätzliche Angaben ohne ekige Klammern!" & vbCrLf & _
                    " -p<""?"">   Passwort (Leerzeichen müssen gekapselt werden "" "")"  & vbCrLf & _                      
                    " -h<""?"">   Passwort mit verborgener Ordnerstrucktur   (-mhe)" & vbCrLf & _
                    " -b        Nur Basisverzeichnis der Quellen   (-r-)" & vbCrLf & _
                    " -v<?>     maximale Dateigröße danach wird gesplittet z.B. -v100m -v1g" & vbCrLf & _
                    "           (nicht kombinierbar mit 'u')" & vbCrLf & _
                    " -x        Selbstentpackendes Archiv.exe erzeugen   (-sfx)" & vbCrLf & _
                    " -t<?>     Dateiformat 7z (default)   -tz ZIP"  & vbCrLf & _
                    " -i<?>     Nur diese Dateien einschließen   z.B. -i*.doc (mehrfach möglich)" & vbCrLf & _
                    " -x<?>     Diese Datei ausschließen   z.B. -x*.tmp -x*.mp3 (mehrfach möglich)" & vbCrLf & _
                    "           Eine Filter wie unter Windows mit *.* funtioniert nur bedingt." & vbCrLf & _
                    "           Wenn es einen Ordner mit einem Puntk im Namen gibt wird dieser" & vbCrLf & _
                    "           ebenfallst archiviert. Der Filter wird von * auf *.* gesetzt und" & vbCrLf & _
                    "           der Unter-Ordner mit einem Punkt im Namen in die auszuschließenden" & vbCrLf & _
                    "           Dateien aufgenommen." & vbCrLf & _
                    " -c<?>     Kompressieronsrate 1 3 (5) 7 9" & vbCrLf & _
                    " -v<?>     Dateigrö0e der einzelnen Archiv-Dateien. Es kann dann aber immer nur" & vbCrLf & _
                    "           ein Vollbackup gemacht werden!" & vbCrLf & _
                    " -u<?>     Anzahl der differentiellen Backups" & vbCrLf & _
                    " -n<?>     Archivname kann aber auch im Archiv-Pfad angegeben werden." & vbCrLf & _
                    "           Archiv-Pfad c:\backup\archiv" & vbCrLf & _
                    "           Mit angegebener Endung z.B c:\backup\archiv.7z" & vbCrLf & _
                    "           wird der Dateiname Archiv sein" & vbCrLf & _
                    "           Wird keien Endung angegeben wird angenommen es ist der Pfadname" & vbCrLf & _
										" -o        Ausgabe-Ordner zum entpacken" & vbCrLf & _        
                    "scsript 7z.vbs a -p""gheimes Passwort"" -narchiv.7z c:\backuporder c:\quelle1 ""c:\2. quelle""" & vbCrLf & _
                    "scsript 7z.vbs -narchiv.7z c:\backuporder c:\quelle1 ""c:\2. quelle""" 
                    wscript.echo s
                    wscript.quit                
              Case Else
                sTmp = Left(sOA, 3)
                select case sOA
                  case "-mhe": fNoListing = True
                  case "-sfx": sfx = True 'Selbstentpackendes Archiv
                  case "-mhe": fNoListing = True									
                End select
            End select
          else
            'Da die Command's nur einem Buchstaben bestehen und diese schon abgefangen wurdern
            'wird erwartet dass alle Parameter mit einem "-" bzw "/" beginnen
            'Die erste Angabe ist das Ziel-Archiv alle weiteren sind Quellen
            If Not fDestination Then
              if right(sOA, 1) = cBSlash then
               destination = left(sOA, len(sOA) - 1)
              elseif right(sOA, 2) = "7z" then
                fileFormat = "7z"
                archivName = ExtractFileName(sOA, true)
                j = InStrRev (sOA, archivName, -1, vbTextCompare)                
								
                destination = left(sOA, j - 2)
                fileSuffix = ".7z"                
              elseif right(sOA, 3) = "zip" then
                fileFormat = "zip"
                archivName = ExtractFileName(sOA, true)
                j = InStrRev (sOA, archivName, -1, vbTextCompare)                
                destination = left(sOA, j - 2)
                fileSuffix = ".zip"                
              else
                destination = sOA
              end if
              fDestination = True
            Else                                '2 ff die Quellen
              j = UBound(sourceFolders) + 1
              ReDim Preserve sourceFolders(j)
              sourceFolders(j) = sOA
            End If
          end if
      end select
      On Error Goto 0
    Next
  End If
End Function

Function setPara()
  'Das Script kann auch ohne Parameter gestartet werden, da alle Parameter auch innerhlab des Script's angegeben werden können    
  'Destination und Archv-Name analysieren
	
  if destination = vbNullString then
    sTmp = "Kein Ziel-Pfad für das Archiv angegeben "
    if quiet then
      wscript.echo sTmp
    else
      wsh.PopUp sTmp, 60, cHeader, vbOKOnly + vbExclamation  
    end if
    WScript.Quit
  elseif ubound(sourceFolders) = -1 then
    sTmp = "Kein Dateien/Ordner zum Archiveren angegeben"
    if quiet then
      wscript.echo sTmp
    else
      wsh.PopUp  sTmp, 60, cHeader, vbOKOnly + vbExclamation  
    end if
    WScript.Quit      
  end if
  
  fileSuffix = ExtractFileSuffix(destination, True)  
  if (fileSuffix = ".zip" or fileSuffix = ".7z") then
    'In destination wurde schon der Archiv-Name angegeben    
    archivName = ExtractFileName(destination, true)    
    destination = ExtractFilePath(destination)  
  elseif archivName <> vbNullString Then
    fileSuffix = ExtractFileSuffix(archivName, True)    
    if (fileSuffix = ".zip" or fileSuffix = ".7z") then
      archivName = ExtractFileName(archivName, true)
    
    end if     
    'destination = ExtractFilePath(destination)  
  elseif  Right(destination, 1) = cBSlash then
    destination = Right(destination, Len(destination) - 1)
    
  end if  
  if archivName = vbNullString then archivName = "backup"  
  if fileSuffix = vbNullString then
    fileSuffix = ".7z"
  elseif not (fileSuffix = ".zip" or fileSuffix = ".7z") then 
    fileSuffix = ".7z"
  end if
  ' Prüfen ob das Ziel-Laufwerk vorhanden ist.  
  sTmp = UCase(Left(destination, 1))
  If Not fso.DriveExists(sTmp & ":") Then
    wsh.PopUp "Laufwerk '" & sTmp & ":' nicht vorhanden !", 60, cHeader, vbOKOnly + vbExclamation  
    WScript.Quit
  ElseIf Not fso.folderexists(destination) Then
    sTmp = cC & "md " & wrap(destination)
    wsh.run sTmp, 0, True
  End If
  If fileFormat = vbNullString Then
    fileFormat = " -t7z"    
  else
    fileFormat = " -t" & fileFormat
  end if
  
  If password <> vbNullString Then
    password = wrap(password)
    If fNoListing Then
      password = " -mhe=on -p" & password
    Else
      password = " -p" & password
    End If
  End If

  If filesize <> vbNullString And CStr(filesize) <> "0" Then
    If IsNumeric(filesize) Then filesize = filesize & "m"
    filesize = " -v" & filesize
  Else
    filesize = vbNullString
  End If

  If compression <> vbNullString Then compression = " -mx" & compression

  if noSubdir then
    noSubdir = " -r-"
    prepFilterNoSubdirectories
  else
    noSubdir = vbNullString
    If UBound(includeFilter) >= 0 Then
      if includeFilter(0) = "*" then
        includeFilter = ""
        for i = 0 To UBound(sourceFolders)
          sourceFolders(i) = wrap(sourceFolders(i) & "\*")
        next
      else
        includeFilter = wrap(includeFilter)
        includeFilter = " -ir!" & Join(includeFilter, " -ir!")
      end If
    Else
      includeFilter = ""
    End If
  end if
  If UBound(excludeFilter) >= 0 Then
    excludeFilter = wrap(excludeFilter)
    excludeFilter = " -xr!" & Join(excludeFilter, " -xr!")
  Else
    excludeFilter = ""
  End If

  If ubound(sourceFolders) > -1 Then sourceFolders = cSpace & Join(sourceFolders, cSpace)
  If outputDir <> vbNullString Then outputDir = " -o" & wrap(outputDir)
  If sfx Then
    Const cD = "7z.sfx"     'Grafische Entpackoberfläche
    'Const cW = "7zCon.sfx" 'Dos
    'Const cW = "7zS.sfx"   'Windows version for installers.
    'Const cW = "7zSD.sfx"  'Windows version for installers (uses MSVCRT.dll)
    stmp = ExtractFilePath(sevenZipProg) & cD
    If Not fso.FileExists(stmp) Then
      i = wsh.PopUp("Die Datei '" & sTmp & "' im 7zip-Packerpfad " & vbcrlF & stmp  & vbcrlF & _
                    "wurde nicht gefunden." & vbcrlF & "Normales Archiv erzeugen." , 10 , _
                    "Selbstenpakendes Archiv *.exe", vbYesNo + vbQuestion)
      If i = vbno Then
        Wscript.Quit
      End If
      sfx = vbNullString
    Else
      sfx = " -sfx" & wrap(stmp)
    filesize = vbNullString
    End If
  Else
    sfx = vbNullString
  End If
  
  if diffWildcard = vbNullString then diffWildcard = "?"  
  if diffCount <> vbNullString then 
    if IsNumeric(diffCount) then
      if cInt(diffCount) = 0 then       
        diffCount = vbNullString
      elseIf InStr(1, diffName, diffWildcard, vbTextCompare) = 0 Then 
        diffName = diffName & diffWildcard             
      end If
      If cmd = vbNullString Then cmd = "u" 
    else
      diffCount = vbNullString
    end if
  end if
  if diffCount = vbNullString  then diffName = replace(diffName, diffWildcard, vbNullString, 1, -1, vbTextCompare)

  sTmp = destination & cBSlash & archivName & fileSuffix
  f = fso.FileExists(sTmp)
  extract = False
  
  select case cmd
    case "a" 'Dateinen anhängen
      cmd = iif(f, "u", "a")
    case "m" 'Mirror. Dateien spiegeln
      if f then
        cmd = "u"
        updateAchiv = " -uq0" 'Mirror-Switch Datnen werden gespiegelt 
      else
        cmd = "a"
      end if
    case "u" 'update Achiv differnziell
      if f then        
        if diffCount <> vbNullString then
          sTmp = destination & cBSlash & archivName & replace(diffName, diffWildcard, addLeadingZero(diffCount), 1, -1, vbTextCompare) & fileSuffix
          if fso.FileExists(sTmp) then  
            'Maximale Anzahl erreicht alle um 1 umbenennen            
            for i = 1 to diffCount - 1
              'Die diff-Archive um eins nach unten verschieben
              sTmp = destination & cBSlash & archivName & replace(diffName, diffWildcard, addLeadingZero(i + 1), 1, -1, vbTextCompare) & fileSuffix
              sTmp2 =  archivName & replace(diffName, diffWildcard, addLeadingZero(i) , 1, -1, vbTextCompare) & fileSuffix
              s = cC & "REN " & wrap(sTmp) & " " & wrap(sTmp2)
              wsh.Run s, 0, True
            next
            destinationDiff = destination & cBSlash & archivName & replace(diffName, diffWildcard, addLeadingZero(diffCount), 1, -1, vbTextCompare) & fileSuffix
            s = cC & "DEL /F /Q " & wrap(destinationDiff)
            wsh.Run s, 0, True                        
          else
            destinationDiff = wrap(getDiffmaxFileName(False))            
          end if
        else        
          sTmp = destination & cBSlash  & archivName & diffName & fileSuffix
          if fso.FileExists(sTmp) then
            s = cC & "DEL /F /Q " & wrap(sTmp)
            wsh.Run s, 0, True
          end if
          destinationDiff = wrap(sTmp)
        end if
        'p - File exists in archive, but is not matched with wildcard.
        'q - File exists in archive, but doesn't exist on disk.
        'r - File doesn't exist in archive, but exists on disk.
        'x - File in archive is newer than the file on disk.
        'y - File in archive is older than the file on disk.
        'z - File in archive is same as the file on disk
        'w - Can not be detected what file is newer (times are the same, sizes are different)
        '0   Ignore file (don't create item in new archive for this file)
        '1   Copy file (copy from old archive to new)
        '2   Compress (compress file from disk to new archive)
        '3   Create Anti-item (item that will delete file or directory during extracting). This feature is supported only in 7z format
        updateAchiv = " -u- -up0q3r2x2y2z0w2!" & destinationDiff
      end if
    case "e"
      cmd = "e"
      extract = true
		 
      destinationDiff = wrap(getDiffmaxFileName(true))
    case "x"
      cmd = "x"
      destinationDiff = wrap(getDiffmaxFileName(True))
      extract = true
    case ""
       if f then
         if outputDir <> vbNullString then
           cmd = "x"
         else
           cmd = "u"
         end if
       else
         cmd = "a"
       end if
  end select
  cmd = cSpace & cmd
  
  destination = cSpace & wrap(destination & cBSlash & archivName & fileSuffix)
End Function

Function run7z()
	' Parameter für 7Zip anpassen
	 On Error Resume Next
	'-y       sag ja zu allem
	'-mx5     Kompressionrate (0-nicht komprimieren...5-default...9-maximal)
		'-mmt=on  Multiprozessoer ein
		'-ssw     auch geöffnete Dateien kopieren (wenn möglich)
	
	If extract Then
		'wsh.CurrentDirectory = destination 'Ordner zum Entpacken festlegen
		stop
		s = sevenZipProg & cmd & " -y"  & password & outputDir & destination
		i = wsh.Run(s, 1, True)
		s = ExtractFileSuffix(destination, true)
		' Gibt es ein diff Backup?        
		if fso.FileExists(destinationDiff) then
			s = sevenZipProg & cmd & " -y"  & password & outputDir & " " & wrap(destinationDiff)
			wsh.Run s, 1, True
		end if
		stmp2 = "Archiv '" & destination & "' wurde nach '" & replace(outputDir, "-o", vbNullString, 1, -1, vbTextCompare)  & "' entpackt."
	else
		s = sevenZipProg & cmd & " -ssw" & password & fileFormat & compression & noSubdir  & excludeFilter & includeFilter & filesize & sfx & updateAchiv & destination & sourceFolders
		'--- Folgende Zeile muss für den produktiven Betrieb auskommentiert werden. Nur für Test ---
		s = InputBox ("7zip", "Nur zur Info / Test", s)
		i = wsh.Run(s, 1, True)
		stmp2 = "7-Zip hat die Dateien nach '" & Iif(destinationDiff = vbNullString, destination, destinationDiff & "' (diff.) ") & " gepackt."
	end if
	
	'Exit Codes
	Select case i
		case 0 s = "No error"
		case 1 s = "Warning (Non fatal error(s)). For example, one or more files were locked by some other application, so they were not compressed."
		case 2 s = "Fatal error"
		case 7 s = "Command line error"
		case 8 s = "Not enough memory for operation"
		case 255 s = "User stopped the process"
	end select
	
	if i = 0 then
		s = stmp2
		j = vbInformation   
	elseif i = 1 then
		s = stmp2 & " (mit Warnungen)" & vbCrLf & stmp2
		j = vbExclamation 
	else
		s = "Fehler sind aufgetreten:"  & vbCrLF & stmp2
		j =  vbCritical 
	end if
	if quiet then
		wscript.echo s
	else
		wsh.popup s, 6, cHeader, vbOKOnly + j
	end if
End Function

function getDiffmaxFileName(fExtract)
  if diffCount = vbNullString then
	  getDiffmaxFileName = destination & cBSlash  & archivName & diffName & fileSuffix
	else
		for i = 1 to diffCount
			sTmp = destination & cBSlash & archivName & replace(diffName, diffWildcard, addLeadingZero(i), 1, -1, vbTextCompare) & fileSuffix
			if not fso.FileExists(sTmp) then               
			 exit for
			else
				sTmp2 = sTmp 
			end if  
		next            
		getDiffmaxFileName = iif(fExtract = true, sTmp2, sTmp)
	end if
end Function


Function wrap(v)
  Dim i, s, va
  va = v
  If IsArray(va) Then
    for i = 0 To UBound(va)
      s = Replace(va(i), cSlash, cBSlash, 1, -1, vbTextCompare)
      If InStr(1, s, cSpace, vbTextCompare) Then
        va(i) = cDQ & s & cDQ
      Else
        va(i) = s
      End If
    Next
  ElseIf va <> vbNullString Then
    va = Replace(va, cSlash, cBSlash, 1, -1, vbTextCompare)
    If InStr(1, va, cSpace, vbTextCompare) Then va = cDQ & va & cDQ
  End If
  wrap = va
End Function

Function ChrAnsi(v)
  Dim a, b
  'ASCII ist OK
  ChrAnsi = False
  For a = 1 To Len(v)
    b = asc(Mid(v, a, 1))
    If b > 126 Then
    ChrAnsi = True 'Ansi-Zeichensatz
    Exit For
  End If
  Next
End Function

Function addLeadingZero(number)
  if diffCount > 9 then
    number = "0" & number 
  elseif diffCount > 99 then
    number = "00" & number
  elseif diffCount > 999 then
    number = "000" & number
  end if 
  addLeadingZero = number
End Function

Function getSevenZipProg()
  Const c7Z = "7z.exe"
  ' sevenZipProg = "PFAD_ZUR_7z.EXE" 'eintragen falls sie nicht gefunden wird
  sevenZipProg = wsh.ExpandEnvironmentStrings("%ProgramFiles%") & "\7-Zip\" & c7Z 'c:\Programme
  If Not fso.FileExists(sevenZipProg) Then
    sevenZipProg = wsh.ExpandEnvironmentStrings("%ProgramFiles(x86)%") & "\7-Zip\" & c7Z 'c:\Program Files (x86)
    If Not fso.FileExists(sevenZipProg) Then
      sevenZipProg = wsh.ExpandEnvironmentStrings("%SystemDrive%") & "\7-Zip\" & c7Z 'c:\
      If Not fso.fileexists(sevenZipProg) Then
        sevenZipProg = Replace(WScript.ScriptFullName ,WScript.ScriptName, vbNullString, 1, -1, vbTextCompare) & c7Z 'Scriptpfad
        If Not fso.FileExists(sevenZipProg) Then
          sevenZipProg = Replace(WScript.ScriptFullName ,WScript.ScriptName, vbNullString, 1, -1, vbTextCompare) & "7-Zip\" & c7Z 'Scriptpfad
          If Not fso.FileExists(sevenZipProg) Then
          wsh.popup  c7Z & " wurde nicht gefunden", 10, , vbExclamation + vbSystemModal
            Wscript.Quit
          End If
        End If
      End If
    End If
  End If
  sevenZipProg = wrap(sevenZipProg)
End Function

Function Iif(v, vTrue, vFalse)
  If v Then
    Iif = vTrue
  Else
   Iif = vFalse
  End If
End Function

' Damit 7-Zip keine Unterordner in das Archiv kopiert muss der include Filter nach sourceFolders übertagen werden
function prepFilterNoSubdirectories()
  dim i, j, k, s, fExclude, oFolder, oSubFolder, arr, re
  for i = 0 to UBound(includeFilter)
    if includeFilter(i) = ("*") then includeFilter(i) = ("*.*")
  next
  For i = 0 To UBound(sourceFolders)
    Set oFolder = fso.GetFolder(sourceFolders(i))
    for each oSubfolder in oFolder.SubFolders
      For j = 0 To UBound(includeFilter)
        s = replace(replace(includeFilter(j), "+", "\+"),".", "\.", 1, -1, vbTextCompare) 'Quantoren kapseln
        s = replace(s, "*", ".*", 1, -1, vbTextCompare) 'Quantoren Asterix für Regex anpassen
        Set re = new regexp
        re.pattern = s
        re.IgnoreCase = True
        if re.Test(oSubfolder.Name) then
          k = ubound(excludeFilter) + 1
          redim preserve excludeFilter(k)
          excludeFilter(k) = oSubfolder.Name
          fExclude = true
        end if
        set re = nothing
      next
    next
    set oFolder = Nothing
  next

  j = UBound(includeFilter) + 1
  i = UBound(sourceFolders) + 1
  ReDim arr((i * j) - 1)
  For i = 0 To UBound(sourceFolders)
    for j = 0 To UBound(includeFilter)
      s = sourceFolders(i) & cBSlash & includeFilter(j)
      arr(i + j) = s
    Next
  Next
  sourceFolders = wrap(arr)
  includeFilter = vbnullstring
End Function

Function ExtractFileName(sFilePath, fTrimSuffix)
  Dim i, s
  If Not IsNull(sFilePath) Then
    sFilePath = Replace(sFilePath, cSlash, cBSlash, 1, -1, vbTextCompare)
    i = InStrRev(sFilePath, gcBSlash, -1, vbTextCompare)
    s = right(sFilePath, len(sFilePath) - i)
    if fTrimSuffix = true then
      i = InStrRev(s, ".", -1, vbTextCompare)
      if i > 0 then s = left(s, i - 1)
    end if
  else
    s = sFilePath
  End If
  ExtractFileName = s
End Function

Function ExtractFileSuffix(sFilePath, fDot)
  Dim i, s
  If Not IsNull(sFilePath) Then
    sFilePath = Replace(sFilePath, cSlash, cBSlash, 1, -1, vbTextCompare)
    i = InStrRev(sFilePath, ".", -1, vbTextCompare)
    s = right(sFilePath, len(sFilePath) - i + iif(fDot, 1, 0))
  else
    s = sFilePath
  End If
  ExtractFileSuffix = s
End Function

Function ExtractFilePath(sFilePath)
  sFilePath = Replace(sFilePath, cSlash, cBSlash, 1, -1, vbTextCompare)
  ExtractFilePath = Left(sFilePath,  InStrRev(sFilePath, cBSlash))
  If Left(ExtractFilePath, 1) = cDQ Then ExtractFilePath = Right(ExtractFilePath, Len(ExtractFilePath) - 1)
End Function

Commandline Aufruf von 7z.exe
Alle Schalter erklärt in Englisch

     
-p Passwort Wird ohne ein Leerzeichen nach dem Optionsschalter angegeben. Sollte das PW ein Leerzeichen enthalten dann muss es mit Anführungszeichen gekapselt werden.
     
Spezielle Parameter fürs Packen
-sfx   Ein selbstenpackendes Archiv erzeugen (*.exe)
-mhe  
Betrachten der Dateiliste und Struktor des Archivs unterbinden
-m{0..9}   -m{Parameters}: Kompressionsrate (0-nicht komprimieren...5-default...9-maximal)
     
-t{ArrchiveType}
  ohne Angabe dieses Parameters wird der Archiv-Typ nach Dateiendung verwendet.
Mögliche Archivtypen: 7z, split, zip, gzip, bzip2, tar
     
Entpacken Parameter
-o   Zielordner für die zu entpackenden Dateien
     
 

Packen:

Befehl: a (Packen)
Archiv-Datei: z.B c:\sicherung\daten.7z
Quell-Daten: Datei.Liste durch Leerzeichen getrennt. Platzhalter möglich * (Asterix) und ?
7z.exe a -p "geheimes Passwort" -mhe Zieldatei (mit .7z als Prefix) Quell-Datei1 Quell-Datei2 ...

 

Entpacken:
Befehl:
e (entpacken ohne Rücksicht auf die Quellpfade. Es wird in den Zielordner entpackt. Gleiche Datei-Namen im Archiv für dazu das Dateien überschrieben werden)
x (entpacken in die relative Ordnerstrucktur der Original-Pfade)
Archiv-Datei: z.B c:\sicherung\daten.7z
Zielpfad: z.B  c:\test
7z.exe x -p "geheimes Passwort" -oZielordner 7Zip-Archiv.