Computer

Datenbanken können unter MS-SQL unterschiedliche Kompatibiliätslevel haben. Dieser Level gibt an, mit welcher SQL-Version die entsprechende Datenbank kompatibel ist. Unterschiede der Level treten zum Beispiel bei der „ORDER BY“-Abfrage auf. Per Transact-SQL können Sie mit sp_dbcmptlevel () einer Datenbank einen Level zuweisen.

[ @dbname = ] name
Der Name der Datenbank, deren Kompatibilitätsgrad geändert werden soll. Datenbanknamen müssen den Regeln für Bezeichner entsprechen. name ist ein Wert vom Datentyp sysname; der Standardwert ist NULL.

[ @new_cmptlevel = ] version
Die SQL Server-Version, mit der die Datenbank kompatibel sein soll. version ist ein Wert vom Datentyp tinyint; der Standardwert ist NULL. Folgende Werte sind zulässig:

80 = SQL Server 2000
90 = SQL Server 2005
100 = SQL Server 2008

Rückgabecodewerte
0 = Erfolg oder 1 = Fehler

Beispiel
Wir möchten der Datenbank Mitglieder den Kompatibilitätsgrad der auf „80“ ändern:

EXEC sp_dbcmptlevel Mitglieder, 80;
GO

Abfragen des Kompatibilitätslevels:
Im Fehlerfalle bei der Portierung von Datenbanken auf ein anderes Zielsystem kann der Kompatibilitätslevel eine Fehlerquelle darstellen. So fragen Sie alle Datenbaken auf einem SQL-Server ab und stellen den Level fest:

use master
go

DECLARE name_cursor CURSOR FOR
SELECT name, cmptlevel FROM sysdatabases

DECLARE @dbname sysname
DECLARE @compver tinyint

OPEN name_cursor
FETCH NEXT FROM name_cursor INTO @dbname, @compver
WHILE @@FETCH_STATUS = 0
BEGIN

IF @compver < 80
BEGIN

select @dbname, @compver
–EXEC sp_dbcmptlevel @dbname, 80
END

FETCH NEXT FROM name_cursor INTO @dbname, @compver
END

CLOSE name_cursor
DEALLOCATE name_cursor
select * from sysdatabases

Automatisches setzen des Kompatibilätslevels, wenn dieser unter 80 ist.

use master
go

DECLARE name_cursor CURSOR FOR
SELECT name, cmptlevel FROM sysdatabases

DECLARE @dbname sysname
DECLARE @compver tinyint

sysdatabases

OPEN name_cursor
FETCH NEXT FROM name_cursor INTO @dbname, @compver
WHILE @@FETCH_STATUS = 0
BEGIN

IF @compver < 80
BEGIN
EXEC sp_dbcmptlevel @dbname, 80
END

FETCH NEXT FROM name_cursor INTO @dbname, @compver
END

CLOSE name_cursor
DEALLOCATE name_cursor

select * from sysdatabases

Das Timer-Objekt in einer Windows-Form ist altbekannt und wird in vielen Anwendungen zu Steuerung oder als „Time-Out“ zur überwachung eingesetzt. In einer Konsolenanwendung steht der Programmierer gelegentlich auch vor dem Problem, dass eine Anwendung überwacht werden muss und man auf einen Time-Out reagieren muss. Was liegt da also näher, als mit einem Timer zu arbeiten? Doch die Tool-Box hält keinen Timer bereit. Also muss einer selbst programmiert werden. Dies ist einfacher, als gedacht, denn System enthält bereits System.Timers. Auf dieser Basis kann sehr schnell ein Timer realisiert werden.
Wir starten in der Main und legen „new System.Timers.Timer“ an. Nun weisen wir „aTimer“ ein Intervall von 5000 Millisekunden zu und starten das ganze („Enabled = true“). Wichtig ist der KeepAlive-Aufruf am Ende der Main.
Nun legen wir eine weitere Funktion (static void) an. Im „OnTimedEvent“ wird dann die eigentliche Timer-Abhandlung untergebracht. In unserem Fall begnügen wir uns mit dem Klassiker der Programmierung: Der Ausgabe von „Hello World!“ in der Konsole.
Wie wir sehen können, ist so ein Timer keine Arbeit und sehr schnell programmiert.

using System;
using System.Collections.Generic;
using System.Text;
using System.Timers;

namespace konsolentest
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Timers.Timer aTimer = new System.Timers.Timer();

            // Hook up the Elapsed event for the timer.
            aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

            // Setze das Intervall auf 5 Sekunden (5000 milliseconds).
            aTimer.Interval = 5000;
            aTimer.Enabled = true;

            Console.WriteLine("EINGABETASTE drücken um die Konsole zu beenden.");
            Console.ReadLine();

            // Lass den Timer aktiv bis die Main beendet wird
            GC.KeepAlive(aTimer);

        }

        // Hier folgen die Anweisungen im im Timer
        private static void OnTimedEvent(object source, ElapsedEventArgs e)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Wer pflegt schon gerne Meta-Tags bei Dokumenten? Keiner. Es wird vergessen, es wird nur ungern getan und wenn überhaupt, sind die Daten alles andere als brauchbar. Doch gerade Suchmaschinen werten diese Meta-Daten gewissentlich aus und nehmen diese Daten in ihren Suchindex auf. Also ist es an der Zeit, in einem Intranet oder auf der eigenen Webpräsenz die vorhandenen PDFs zu aktualisieren. Beim vorhandenen Projekt konnten gewisse Tags wie „Autor“, „Titel“ und einige Keywords aus einer Datenbank abgefragt werden, so dass nur noch das PDF mit den übergebenen Daten aktualisiert werden musste. Weitere Aufgabenstellung: Das PDF sollte nicht neu generiert und das Dateidatum sollte nicht geändert werden. Um es vorweg zu nehmen. Nicht alles konnte so eingehalten werden.PDFs mit neuen Meta-Tags zu versehen ist per C# nicht machbar. Es gibt jedoch ein Open Source-Projekt namens „pdftk“, das ein kostenloses Kommandozeilentool zur Verfügung stellt, über das die Meta-Tags ausgelesen und neu beschrieben werden können. Jedoch wird dabei ein neues PDF erstellt. Weitere Informationen über „pdftk“ finden sie im Internet. Laden sie sich die kleine Exe herunter und speichern sie diese am besten im Windows/System32-Ordner. Dann haben sie stndig Zugriff auf die Datei.Zur Funktion: Wir übergeben einen Pfad und einen PDF-Namen an die Funktion. Ferner unsere Meta-Tags.Im ersten Schritt fügen wir den PDF-Pfad zusammen und lesen das Dateidatum des PDFs für die spätere Wiederherstellung aus. Dann kommt „pdftk“ zum Einsatz. Es fordert eine kleine Textdatei mit bestimmten Aufbau für die aktualisieren der Meta-Daten (näheres finden Sie in der Doku von „pdftk“). Wir lesen die Original-Meta-Daten nicht aus, sondern erzeugen gleich eine Textdatei mit den Meta-Daten. Achtung: Auch hier sind die Umlaute ein Problem. Sie werden über eine separate Funktion in Hex umgeschlüsselt.Wenn die Text-Datei erzeugt ist, wird per Commandozeile „pdftk“ angesprochen. Der Commandozeile wird der PDF-Originalname, das Textfile, einige Parameter und der Ausgabe-Dateiname („NEW_“) übergeben. Damit legt das Tool los und erzeugt ein neues PDF.Nach getaner Arbeit löschen wir das Original-PDF, benennen das neue PDF mit dem alten Namen um und versehen es mit dem Original-Dateidatum. Und fertig sind die suchmaschinenoptimierten Meta-Tags für das PDF.

private static void pdf_attribut(string sPfad, string sPDFQuellname, string sTitle, string sAuthor, string sSubject, string sKeywords)
{

try
  {
   //Pfad hinzufügen
   string sOriginalname = sPDFQuellname;
   sPDFQuellname = sPfad + sPDFQuellname;
  
   //Prüfe Datei und speichere das Dateidatum
   System.IO.FileInfo file = null;
   file = new System.IO.FileInfo(sPDFQuellname);               
   string sAltesDatum = file.LastWriteTime.ToString();               
   Console.WriteLine("Datei " + sPDFQuellname + " hat das Dateidatum: " + sAltesDatum);               

   //Erzeuge die pdf-info-Datei               
   string sPDFInfoFilename = @"pdfinfo.txt";               
   StreamWriter myWriter = File.CreateText(sPDFInfoFilename);               
   myWriter.WriteLine("InfoKey: Title");               
   myWriter.WriteLine(SetUmlaute("InfoValue: " + sTitle));               
   myWriter.WriteLine("InfoKey: Author");               
   myWriter.WriteLine(SetUmlaute("InfoValue: " + sAuthor));               
   myWriter.WriteLine("InfoKey: Subject");               
   myWriter.WriteLine(SetUmlaute("InfoValue: " + sSubject));               
   myWriter.WriteLine("InfoKey: Keywords");               
   myWriter.WriteLine(SetUmlaute("InfoValue: " + sKeywords));               
   myWriter.Close();               

   //Erzeuge das neue PDF               
   string sCommand = "";               
  
   //Pfad zur Exe von pdftk    
   string sPfad_pdftk = "c:pdftk.exe";               
   sCommand = sPDFQuellname + " update_info " + sPDFInfoFilename + " output  " + sPfad + "NEW_" + sOriginalname;               

   //Command zur Erstellung des neuen PDF               
   ProcessStartInfo info = new ProcessStartInfo(sPfad_pdftk, sCommand);               
   Process p = Process.Start(info);               
   p.WaitForExit();               
   Console.WriteLine("Neues PDF für " + sPDFQuellname + " erstellt. Result: " + p.ExitCode + " (0=OK)");               

   //Lösche die Originaldatei               
   file.Delete();               
   Console.WriteLine("Originaldatei gelöscht.");                               

   //Neues PDF auf alten Namen umnennen               
   File.Move(sPfad + "NEW_" + sOriginalname, sPDFQuellname);               
   Console.WriteLine("Originaltitel wiederhergestellt.");               

   //Altes Datum der neuen Datei verpassen               
   file = new System.IO.FileInfo(sPDFQuellname);               
   DateTime altesdatum = DateTime.Parse(sAltesDatum);               
   file.LastWriteTime = altesdatum;               
   Console.WriteLine("Originaldatum wiederhergestellt.");           
 }           
 catch (Exception ex)           
 {               
  Console.WriteLine("FEHLER in pdf_attribut bei Datei: " + sPDFQuellname);               
  logfile("FEHLER in pdf_attribut bei Datei: " + sPDFQuellname);           

 }
}

private static string SetUmlaute(string value)       
{           
  value = value.Replace("ü", "ü");           
  value = value.Replace("ä", "ä");           
  value = value.Replace("ö", "ö");           
  value = value.Replace("ß", "ß");           
  value = value.Replace("ü", "Ü");           
  value = value.Replace("ö", "Ö");           
  value = value.Replace("ä", "Ä");           
  return value;       
}

Wenn ihr Windows öfters einmal temporär stehen bleibt, einfriert oder sonst wie muckt, kann natürlich ein Virus im System sein. Es kann aber auch einfach sein, dass eine Windows-Systemdatei beschädigt ist. Um so etwas zu überprüfen, bietet sich das Windows-eigene Tool „System File Checker“ oder kurz „sfc“ an. Es prüft alle wichtigen Systemdaten und fordert im Fehlerfalle die Windows-CD zur Reparatur an.Wenn das Systemdatei-überprüfungsprogramm feststellt, dass eine von ihm überprüfte Datei überschrieben oder beschädigt  wurde, versucht „sfc“ die Datei mit der korrekte Version der Datei aus dem Cache-Ordner zu ersetzen. Bei dem Cache-Ordner handelt es sich um einen versteckten Systemordner namens „Dllcache“ im Verzeichnis „%Systemroot%System32Dllcache“. Ist der Ordner nicht vorhanden, fordert „sfc“ die Windows-Installations-CD an.Starten können Sie sfc durch die Eingabe von „sfc“ unter „Start/Ausführen“. Sie müssen dazu als Administrator oder als Mitglied der Gruppe der Administratoren angemeldet sein. Bei „sfc“ handelt es sich um ein Kommandozeilen-Tool, das folgende Parameter übernehmen kann:

„/Scannow“: überprüft alle geschützten Systemdateien und ersetzt falsche oder beschädigte Systemdateien durch die Dateien aus dem DllCache. Fordert ggfls. die Windows-CD an.
„/Scanonce“: Sfc fügrt einen Scan der Dateien erst nach einem Neustart und dann nur einmalig durch.
„/Scanboot“: Führt dazu, dass „sfc“ bei jedem Start des Computers einen Scan der Systemdateien durchführt.
„/Revert“: Mit diesem Parameter setzen Sie „sfc“ auf die Standardeinstellungen zurück (keine überprüfung der geschützten Dateien beim Start des Computers).
„/Purgecache“: Leert den Dateicache und überprüft sofort alle geschützten Systemdateien. Für diesen Parameter ist ein Zugriff auf die Windows-CD erforderlich.
„/Cachesize=x“: Legt die Größe des Dateicaches in Megabyte fest. Die Standardgröße des Dateicaches von „sfc“ beträgt 50 MB. Der Parameter erfordert einen Neustart des Computers. Danach muss der Befehl /purgecache ausgeführt werden, um die Größe des Caches auf der Festplatte festzulegen.

Registrierungsschlüssel:
Scanonce: Setzt den DWORD-Wert für SfcScan auf „2“. Pfad: HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionWinlogon
Scanboot: Setzt den DWORD-Wert für SfcScan auf 1. Pfad: HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionWinlogon
Cachesize: Setzt den DWORD-Wert SfcQuota auf x. Pfad: HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionWinlogon

Weitere Registrierungsschlüssel:
SFCShowProgress:  REG_DWORD 0 = aus, 1 = ein
Bestimmt, ob beim Ausführen von SFC eine Bildschirmausgabe erfolgen soll.

Per Systemeinstellung ist der Cache des Vergleichsordner auf 50 MB gesetzt. In der Praxis nimmt der Ordner gerne 200 bis 300 Megabyte Speicherplatz in Anspruch. In diversen Foren streitet man sich darüber, ob das Löschen des Ordners per „sfc /purgecache“ eine gute Idee ist.

Wenn Sie die Dateiinfos zu beliebigen Dateien per Programm ändern möchten, stehen Sie erstmal vor einem Problem. Denn an diese Informationen kommen Sie nicht über das File-Objekt. Gerade für Suchmaschinen (beispielsweise im lokalen Intranet) sind diese Parameter jedoch sehr wichtig. Microsofts SharePoint beispielsweise indexiert alle Office-Dokumente nicht nur nach dem Inhalt, sondern eben auch anhand dieser Properties.
Im vorliegenden Beispiel haben wir hunderte von Dokumenten und eine Datenbank, in der die Meta-Informationen zu den betreffenden Files vorgehalten werden. Mit dem Einsatz von SharePoint müssen diese Meta-Informationen dem Dokument zugeordnet werden. Da dies eine einmalige Aktion ist, eignet sich hierfür einen Konsolenanwendung, die eine SQL-Abfrage durchführt, das Dokument öffnet und dann manipuliert. Im vorliegenden Beispiel beschränken wir uns auf die Manipulation der Properties.
Microsoft hat vor Jahren eine DLL namens „dsofile.dll“ veröffentlicht. Entgegen der Dokumentation kann die DLL nicht nur lesen, sondern die Properties auch speichern. Unter dem Knowledgebase-Artikel („http://support.microsoft.com/kb/224351/de“) können Sie die DLL kostenlos downloaden. Mit dabei sind zwei Beispiele, unter anderem eine VB6-Demo.
Laden Sie sich die DLL herunter, entpacken Sie die ZIP-Datei und registrieren Sie die DLL. In Visual Studio sollte nun unter „Verweise“ / „COM“ die DLL aufgeführt sein. Dann können Sie auf dsoFile zugreifen.

using System;
using System.Collections.Generic;
using System.Text;
using DSOFile;

namespace Intranet_Attribute
{
    class Program
    {
        static void Main(string[] args)
        {

            //Datei holen
            String filename = @"G:mein_pfad_zur_datei est.txt";

            try
            {

                DSOFile.OleDocumentProperties mydso = new DSOFile.OleDocumentProperties();
                mydso.Open(filename, false, dsoFileOpenOptions.dsoOptionDefault);
                DSOFile.SummaryProperties properties = mydso.SummaryProperties;

                //An den Filename kommen wir ebenfalls
                string name = mydso.Name;

                //Properties neu bestücken
                properties.Title = "Mein Titel";
                properties.Subject = "Mein Betreff";
                properties.Author = "Mein Autor";

                properties.Category = "Kathegorie";
                properties.Keywords = "Stichwörter";
                properties.Comments = "Kommentar";

                //änderungen speichern
                mydso.Save();
                return;
            }
            catch (Exception ex)
            {
                System.Environment.Exit(1);
            }

        }
    }
}

Wenn Sie die Properties einer Datei ändern, ändert sich auch das Datum der Datei im Dateisystem. So können Sie das Datum der Datei erhalten: öffnen Sie das File VOR dem ändern durch DSOFile mit:
file = new System.IO.FileInfo(filename);
Speichern Sie das Datum des Dokumentes in einer Datei:
string sAltesDatum = file.LastWriteTime.ToString();
ändern Sie die Properties der Datei entsprechend und ändern dann nach dieser Manipulation das Dokumentendatum aus der Variable „sAltesDatum“.

file = new System.IO.FileInfo(filename);

DSOFile.OleDocumentProperties mydso = new DSOFile.OleDocumentProperties();
mydso.Open(filename, false, dsoFileOpenOptions.dsoOptionDefault);
DSOFile.SummaryProperties properties = mydso.SummaryProperties;

//Altes Datum speichern
string sAltesDatum = file.LastWriteTime.ToString();

//Properties neu bestücken
properties.Title = "Mein ganz neuer Titel";

//Änderungen speichern
mydso.Save();

//Das Datum der Datei ändern
DateTime altesdatum = DateTime.Parse(sAltesDatum);
file.LastWriteTime = altesdatum;

Es sind die kleinen Batch-Dateien, die einem Spass bereiten. Sie bieten großen Nutzen und erleichtern die Arbeit erheblich. Vor allem, wenn sie automatisiert ihren Dienst verrichten und der Anwender oder Administrator die Arbeit und ihre Existenz vergessen kann.

Das Datum und die Uhrzeit bereitet in der Batch-Verarbeitung große Probleme. über die Variable DATE und TIME kann zwar die Zeit abgefragt werden, doch Zugriff auf einzelne Teilbereiche des Ausgabestrings haben wir nicht.

Stunde ermitteln
Diese Ausgabe ist noch relativ einfach gelöst. Die Variable „hour“ wird über eine Art „substring“ über den Befehl „time“ bestückt und steht so dem Skript zur Verfügung.

set hour=%time:~0,2%

Der Zugriff auf weitere Teile wie die Minute, Sekunde oder ein zusammengesetzter Wert kann nach diesem Schema ebenfalls erzeugt werden.

Datum ermitteln
Nach der Vorgehensweise der oben besprochenen Stundenermittelung können wir auch das Datum ermitteln. Um ein zusammengesetztes Datum rückwärts beispielsweise für die Bezeichnung von Logfiles zu ermitteln, kann das Datum wie folgt ermittelt werden:

set datum = %date:~10,4%%date:~4,2%%date:~7,2%
echo %datum%

Probleme mit englischsprachigem Betriebsystem
Die oben aufgeführte „Substring-Methode“ führt beim Einsatz auf einem englischsprachigem Betriebsystem unweigerlich zu Problemen. Der Befehl muss dort angepasst werden. Wenn wir vor einer solchen Aufgabe stehen, sollten wir uns gleich einer eleganteren Methode der Zerlegung zuwenden. Wir zerlegen das Datum über eine For-Schleife und setzen die Teile wieder anhand einer Regel zu einem String namens CDATE zusammen:

REM *** Deutsches Betriebsystem. Liefert CDATE= YYYY-MM-DD
FOR /F „tokens=1,2,3,4 delims=/. “ %%a in (‚date/T‘) do set CDATE=%%d-%%c-%%b

REM *** Englishes Betriebsystem. Liefert CDATE= YYYY-MM-DD
FOR /F „tokens=1,2,3,4 delims=/. “ %%a in (‚date/T‘) do set CDATE=%%c-%%b-%%a

Wie sie sehen können, wird das Datum am Ende der For-Schleife per „set CDATE=%%c-%%b-%%a“ zusammengebaut. Hier können Sie den Bindestrich durch einen Punkt ersetzen oder gänzlich weglassen.

Wir testen das Ganze einfach einmal, indem wir den Inhalt des aktuellen Dateiverzeichnisses in ein Logfile mit dem Tagesdatum schreiben:

FOR /F „tokens=1,2,3,4 delims=/. “ %%a in (‚date/T‘) do set CDATE=%%d-%%c-%%b
dir  >> „c: emp\%CDATE%.log“

Wie wir gesehen haben, dienen Funktionen dazu, Programmcode auszulagern, der öfters in einem Programmlauf benutzt oder benötigt wird. Bald werden Sie vor dem Problem stehen, dass eine Funktion auch einen Wert zurückgeben soll. Einfaches Beispiel: Eine Funktion erhält zwei Werte die sie addieren und das Ergebnis zurückliefern soll. Das Schlüsselwort ist „return“.

<script type="text/javascript">

function Berechne(a,b)
{
  return a+b;
}

function start()
{
  alert(Berechne(5,6));
}
</script>

Was passiert in unserem Beispiel? Im Body onload starten wir die Funktion „start“. Diese führt nur einen „alert“ aus. Allerdings mit dem Parameter „Berechne(5,6)“, der innerhalb des Klammerpaares der Alert-Funktion (alert ist also AUCH EINE Funktion) steht. Somit wird die eigene Funktion „Berechne“ ausgeführt. Diese erwartet die Variablen „a“ und „b“ als übergabe, was wir mit den Werten „5“ und „6“ erfüllt haben. In der Funktion finden wir nur ein „return“ gefolgt von der Berechnung „a+b“. Das heisst, die Funktion gibt die Summe dieser Berechnung zurück. Da die Funktion per „alert“ aufgerufen wurde, wird der Funktion „alert“ die Summe übergeben und „alert“ schreibt Ihnen korrekter Weise „11“ auf den Bildschirm.

Sie sind nicht dazu gezwungen, Berechnungen neben dem „return“ durchzuführen. Sie hätten in der Funktion genauso gut Variablen anlegen können, Berechungen durchführen und dann am Ende den Wert der Funktion zurückgeben können.

In der Regeln findet das Schlüsselrot „return“ immer am Ende einer Funktion seinen Platz. Dies muss aber nicht immer so sein. Sie können mit „return“ auch eine Funktion abbrechen. Im folgenden Beispiel haben wir gleich eine Kontrollabfrage eingebaut. Die Funktion soll den Wert der Variable a durch b dividieren. Da Divisionen durch Null nicht erlaubt sind, prüfen wir nun in der Funktion den Wert von „b“. Ist dieser kleiner „1“, brechen wir die Funktion ab. Ansonsten gibt die Funktion die Division zurück.

function Dividiere(a,b)
{
    if (b < 1) return;
      return a/b;
}

Funktionen sind die Zusammenfassung von Befehlen zu einer Einheit. Es stellt sich sofort die Frage, warum man überhaupt eine Funktion programmiert. Diese ist schnell beantwortet. Sie werden in Ihren Skripten immer öfters an den Punkt stoßen, so Sie den gleichen Code öfters ausführen müssen. Vielleicht mit einigen geänderten Parametern, doch prinzipiell führen Sie den gleichen Code aus. Dann bietet sich eine Funktion an. Sie müssen so den Code nicht ständig neu schreiben. Somit wird Ihr gesamter Code kürzer, weniger fehleranfällig und der gesamte Code ist besser nachvollziehbar.

In JavaScript werden Funktionen immer nach folgendem Muster geschrieben:

function [Funktionsbezeichnung] ([optionale Parameter])
{
    //die Anweisungen
}

Der Aufruf einer Funktion erfolgt an beliebiger Stelle in Ihrem Skript oder auch aus einer anderen Funktion heraus. Der Aufruf erfolgt über die Funktionsbezeichnung gefolgt von den beiden runden Klammern („()“) und gefolgt von einem Semikolon („;“). Dies ist der „Mindestaufruf“. Wenn eine Funktion Parameter benötigt, werden diese in der runden Klammer mit übergeben.

Die Funktionsbezeichnung ist frei von Ihnen wählbar. Dennoch müssen Sie einige Regeln beachten:

1. Die Funktionsbezeichnung MUSS mit einem Buchstaben oder dem Unterstrich („_“) beginnen.
2. Die Bezeichnung darf nicht auf ein gültiges JavaScript-Schlüsselwort lauten.
3. Leerzeichen sind nicht erlaubt. Von Sonderzeichen ist dringend abzuraten!

Es ist dringend anzuraten, die Funktionsbezeichnung „sprechend“ zu wählen. Dies erhöht die Lesbarkeit des Codes enorm. Groß- und Kleinschreibung ist erst einmal Ihnen überlassen. Wichtig ist, dass Sie die Funktion genau so aufrufen, wie definiert. JavaScript unterscheidet zwischen Groß- und Kleinschreibung. Wenn Sie fremde Skripts analysieren, werden Sie oft sehen, dass Funktionsbezeichungen klein beginnen und ein weiteres Wort dann Großgeschrieben wird. Also beispielsweise „holeDaten()“ oder „gibBerechnung()“. Sehr oft ist auch „denglisch“ Trumpf. „getZinsrechnung()“ oder „makeIrgendwas()“. Ob das sehr glücklich ist, soll jeder selbst entscheiden. Wenn Sie Funktionen entdecken, die „ghd24rfrhsfc“ oder „j32r7hfbh4“ heissen, so bedeutet dies, dass der Programmierer NACH der Programmierung die Funktionsnamen geändert hat mit dem Ziel, die Nachvollziehbarkeit seines Codes zu erschweren. Sicherlich wird er seinen Quellcode so nicht programmiert haben (was aber auch nicht auszuschließen ist).

Eine gern gestellte Aufgabe in der Programmierung ist die Berechung der Fakultät. Noch einmal kurz zur Erinnerung: Die Fakultät einer Zahl ist das Produkt aller Zahlen bis zur gesuchten Zahl. Also die Fakultät von 6 (Schreibweise: „6!“) ist 1 * 2 * 3 * 4 * 5 * 6. Und das Ergebnis lautet: 720. Auch hier würde sich eine For-Schleife anbieten, doch auch mittels While-Schleife können wir das Ergebnis erzielen.
Zu unserem Beispiel. Wir fragen eine Zahl mittels Prompt ab, deren Fakultät wir gerne berechnen möchten. Auch hier haben wir keinerlei Sicherheit, dass der User keine Falscheingabe tätigt.
Wir legen zwei weitere Variablen („fakultaet“ und „lauf“) an, die wir beide sofort mit einer „1“ initalisieren. Nun folgt die While-Schleife mit den Bedingung „lauf <= eingabe“. Wenn die Eingabe des Users größer Null ist, trifft die Bedingung zu. Selbst bei der Eingabe einer „1“, auch wenn dieser Durchlauf wenig Sinn macht.
Widmen wir uns dem Schleifeninhalt. In der ersten Zeile berechnen wir nun die Fakultät anhand des Durchlaufes, der beim ersten Schleifendurchlauf „1“ beträgt. Danach erhöhen wir die Laufvariable „lauf“ um „1“ auf „2“. Wenn die Usereingabe der Fakutätsberechnung größer als „1“ war, erfolgt ein weiterer Schleifendurchlauf, da „lauf“ nun den Wert „2“ hat. Wieder erfolgt die Berechung. In diesem Schritt sind wir bei „1“ aus dem ersten Durchlauf mit „*2“ aus dem zweiten Durchlauf.
Die Schleife wird nun sooft durchlaufen, bis die Laufvariable „lauf“ größer als die Eingabe ist, bei Fakultät 6 zum Beispiel also bei „7“. Wenn die Schleife abgebrochen wird, erfolgt die Ausgabe der Variablen.
Beachten Sie bitte, dass Sie mit While-Schleifen gerne auch „Endlosschleifen“ generieren, also Schleifen, die bis unendlich laufen. Wenn Sie dies produzieren, hilft Ihnen nur noch, den Browser zu schließen.

<script type="text/javascript">// <![CDATA[


var eingabe = prompt("Geben Sie bitte eine Zahl ein, deren Fakultät Sie berechnen möchten",""); 
var fakultaet = 1;
var lauf = 1;

while (lauf <= eingabe)
{
  fakultaet = fakultaet * lauf;
  lauf++;
}
document.write("Die Fakultät von " + eingabe + " lautet: " + fakultaet);
</script>

Schleifen sind in allen Programmiersprachen sehr wichtig. Oftmals müssen mehrere Durchläufe innerhalb des Programmflusses ermöglicht werden, so dass Schleifen zum Einsatz kommen. Bei der While-Schleife handelt es sich um eine „kopfgesteuerte“ Schleife. Kopfgesteuert? So bezeichnet man diese Schleifenart, da am Anfang der Schleife („Kopf“) die eigentliche Steuerung erfolgt. Doch fangen wir in unserem Beispiel erst einmal weiter oben an. Auch in diesem Beispiel haben wir innerhalb des Body-Containers keinen Code. Die Textausgabe erzeugen wir mittels „document.write“. In diesem Beispiel geben wir der Textausgabe gleich noch einen H1-Tag mit, so dass die überschrift  möglichst groß von dem auszugebenden Browser dargestellt wird.
Dann legen wir eine Variable „lauf“ an, die gleich mit dem Wert „10“ initialisiert wird. Es folgt die While-Schleife mit der Bedingung „lauf > 0“. In unserem Fall ist schon beim ersten Durchgang die Bedingung erfüllt, da „lauf“ im ersten Durchlauf den Wert „10“ hat. Wäre „lauf“ nicht größer Null, so würde die Anweisung innerhalb der Schleife erst gar nicht ausgeführt werden.
Doch die Bedingung trifft zu, und die Anweisungen innerhalb der Schleife werden ausgeführt. Wieder erfolgt eine Ausgabe in das Dokument. „Durchlauf: “ + lauf + “
“ führt zu der Ausgabe „Durchlauf: 10“ und einen Zeilenumbruch, da der Wert der Variable „lauf“ noch bei „10“ liegt. Jetzt folgt „lauf –;“. Dies ist eine Kurzschreibweise von „lauf = lauf – 1“ was bedeutet, weise lauf den Wert von lauf zu und ziehe Eins ab. Also 10 = 10 – 1, was nach Adam Riese „9“ ergibt. Jetzt hat unsere Variable den Wert 9 und die Anweisungen der Schleife ist beendet. Jetzt wird die Bedingung neu geprüft. „Lauf“ hat nun den Wert „9“, ist also größer „0“ und die Schleife wird erneut ausgeführt … Interessant wird die Schleife erst beim Wert „1“. Dann nämlich wird sie ebenfalls ausgeführt und die Variable „lauf“ nimmt den Wert „0“ an. Bei der nächsten Prüfung der Variable im Schleifenkopf trifft nun die Bedingung („lauf > 0“) nicht mehr zu und die Schleife wird abgebrochen. Der Programmfluss setzt sich nach der Schleife mit dem Text „Das ist das Ende“ fort.
While-Schleifen werden normalerweise dann eingesetzt, wenn von vorneherein nicht klar ist, wie viel Durchlaufe die Schleife leisten soll. In diesem Fall wäre eine For-Schleife die bessere Wahl gewesen.

<script type="text/javascript">// <![CDATA[

document.write("<H1>Jetzt wird gezählt ...</H1>");
var lauf = 10;
while (lauf > 0)
{
   document.write("Durchlauf: " + lauf + ");
  lauf --;
}
document.write("<H2>Das ist das Ende</H2>");
</script>