7z Archiv Packen / Entpacken

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.
<div>
<div>
<div>Script-Link: <a href="/download/wsh/7z.vbs" target="_blank" title="geziptes Script" data-cke-saved-href="download/wsh/7z.vbs"><img src="/images/stories/windows/thumbs/script.jpg" alt="script" width="16" height="19" style="vertical-align: text-bottom; border: 0px none;" data-cke-saved-src="images/stories/windows/thumbs/script.jpg" /></a></div>
<div> </div>
</div>
</div>

<div style="background: #ffffff; overflow: auto; width: auto; border: solid gray; border-width: .1em .1em .1em .8em; padding: .2em .6em;">
<pre style="margin: 0; line-height: 125%;">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
</pre>
</div>
Commandline Aufruf von 7z.exe <a href="http://sevenzip.sourceforge.jp/chm/cmdline/switches/index.htm" data-cke-saved-href="http://sevenzip.sourceforge.jp/chm/cmdline/switches/index.htm">Alle Schalter erklärt in Englisch</a>
<table border="0" class="cke_show_border" cellspacing="3" cellpadding="5">
<tbody>
<tr>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td valign="top">-p</td>
<td valign="top">Passwort</td>
<td>Wird ohne ein Leerzeichen nach dem Optionsschalter angegeben. Sollte das PW ein Leerzeichen enthalten dann muss es mit Anführungszeichen gekapselt werden.</td>
</tr>
<tr>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td colspan="3">Spezielle Parameter fürs Packen</td>
</tr>
<tr>
<td>-sfx</td>
<td> </td>
<td>Ein selbstenpackendes Archiv erzeugen (*.exe)</td>
</tr>
<tr>
<td>-mhe</td>
<td> </td>
<td>
<div>Betrachten der Dateiliste und Struktor des Archivs unterbinden</div>
</td>
</tr>
<tr>
<td valign="top">-m{0..9}</td>
<td> </td>
<td>-m{Parameters}: Kompressionsrate (0-nicht komprimieren...5-default...9-maximal)</td>
</tr>
<tr>
<td valign="top"> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td valign="top">
<div>-t{ArrchiveType}</div>
</td>
<td> </td>
<td>ohne Angabe dieses Parameters wird der Archiv-Typ nach Dateiendung verwendet. 
<div>Mögliche Archivtypen: 7z, split, zip, gzip, bzip2, tar</div>
</td>
</tr>
<tr>
<td> </td>
<td> </td>
<td> </td>
</tr>
<tr>
<td colspan="3">Entpacken Parameter</td>
</tr>
<tr>
<td>-o</td>
<td> </td>
<td>Zielordner für die zu entpackenden Dateien</td>
</tr>
<tr>
<td> </td>
<td> </td>
<td> </td>
</tr>
</tbody>
</table>
<div> </div>
Packen:
<div>Befehl: a (Packen) 
<div>Archiv-Datei: z.B c:\sicherung\daten.7z Quell-Daten: Datei.Liste durch Leerzeichen getrennt. Platzhalter möglich * (Asterix) und ? </div>
7z.exe a -p "geheimes Passwort" -mhe Zieldatei (mit .7z als Prefix) Quell-Datei1 Quell-Datei2 ...</div>
 
<div>Entpacken: </div>
<div>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)</div>
<div>x (entpacken in die relative Ordnerstrucktur der Original-Pfade) 
<div>Archiv-Datei: z.B c:\sicherung\daten.7z</div>
Zielpfad: z.B  c:\test </div>
<div>7z.exe x -p "geheimes Passwort" -oZielordner 7Zip-Archiv.</div>
<div> </div>