HTML5-Tutorium: JavaScript: Hello World 07: Unterschied zwischen den Versionen

aus GlossarWiki, der Glossar-Datenbank der Fachhochschule Augsburg
 
(3 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 2: Zeile 2:
{{HTML5-Tutorium:JavaScript:HelloWorld:Menü}}
{{HTML5-Tutorium:JavaScript:HelloWorld:Menü}}


'''Musterlösung''': [https://glossar.hs-augsburg.de/beispiel/tutorium/es5/hello_world/WK_HelloWorld06/web/index.html <code>index.html</code>],
{{In Bearbeitung}}
([https://glossar.hs-augsburg.de/beispiel/tutorium/es6/hello_world/WK_HelloWorld06/ SVN-Repository])
==JSON==
==Anwendungsfälle (Use Cases)==
Gegenüber dem [[HTML5-Tutorium:_JavaScript:_Hello_World_04|vierten Teil des Tutoriums]]
ändern sich die die Anwendungsfälle nur geringfügig.  Das Begrüßungsformular soll ''zweimal''
im Browser angezeigt werden, einmal auf Deutsch und auf Englisch. Beide Begrüßungsformulare sollen
unabhängig voneinander funktionieren. 


Ein Grundprinzip der Programmierung lautet [[Don't repeat yourself]] (DRY). Sie könnten nun einfach den vorhandenen
Bislang haben sie den CSS-Code unter Webpack-Kontrolle gestellt und damit DRY gemacht.  
Code duplizieren und entsprechend anpassen. Aber genau das würde gegen das Prinzip „Keep your code DRY“ verstoßen.
Als nächstes gehen wir das nächste Problem an: Ihr Code enthält ebenfalls Konstanten und verstößt damit gegen das
Code-Duplikation kann mit Hilfe von [[Klasse (objektorientiert)|Klassen]] vermieden werden. Sie stellen eine Art
[[Programmierprinzipien|Programmierprinzip]] „Konstante Werte gehören nicht in den Code, sondern in Konfigurationsdateien.
„Blaupause“ dar, um Objekte mit ähnlichen Eigenschaften ganz einfach erstellen zu können.


==Erstellen eines neuen Projektes==
Eine Ausnahme bilden triviale Konstanten wie <code>0</code>, <code>1</code>, <code>null</code>, <code>true</code> oder <code>false</code>, sofern sie mit großer Sicherheit nie im Code geändert werden müssen. Aber schon eine Konstante wie
<code>3.1415926</code> gehört nicht in den Code. Man verwendet stattdessen besser <code>Math.PI</code> und erhält damit
die maximal mögliche Stellenzahl. (Eventuell hängt diese von der Rechnerplattform ab.)


Erzeugen Sie wie im  [[HTML5-Tutorium:_JavaScript:_Hello_World_04|vierten Teil des Tutoriums]] ein neues Projekt,
In JavaScript-Anwendungen verwendet man [[JSON]] zur Speicherung von (konstanten) Daten und zur Initialisierung der Anwendung.
diesmal allerdings mit dem schönen Namen <code>HelloWorld05</code>“ und speichern Sie dieses wieder
Wenn ein Spiel mehrere Level hat, wir jedes Level üblicherweise in einer eigenen JSON-Datei beschrieben. Eine Level-Designerin muss
in Ihrem SVN-Repository (Achtung: <code>node_modules</code> muss existieren und auf der Ignore-Liste stehen).
im Optimalfall nicht mehr machen, als die Assets (Grafiken, Töne, 3D-Modell etc.) zu erstellen und mit Hilfe einer
JSON-Datei die Zusammenhänge zwischen den einzelnen Elementen herstellen. Es sollte nicht notwendig sein, dass sie
den Programmcode modifizieren muss, da das Level-Design schon aufwändig genug ist.  


Kopieren Sie nun aus Ihrer Lösung des vierten Teil des Tutoriums die Ordner <code>src</code> und <code>web</code>
JSON (JavaScript Object Notation) ist ein einfaches Datenformat, mit dessen Hilfe sich komplexe Objekte sehr einfach beschreiben lassen.
(jeweils samt allen darin enthaltenen Ordnern und Dateien) sowie die Dateien <code>gruntfile.js</code>,  
Eine Alternative wäre [[XML]], allerdings ist diese Auszeichnungsprache deutlich komplexer. (Ein Beispiel für XML ist
<code>package.json</code>, <code>package-lock.json</code> und <code>webpack.config.js</code>
XHMLT 1.0<ref>XHTML 1.0: https://www.w3.org/TR/2002/REC-xhtml1-20020801/</ref>, eine HTML-Variante.)
fügen Sie sie ins Wurzelverzeichnis des fünften Teils ein.  


Weisen Sie WebStorm wiederum an, die Inhalte der Ordner <code>node_modules</code> und <code>web/js</code>
Eine JSON-Datei ist im Prinzip eine JavaScript-Datei, die einen der folgenden Datentypen enthält<ref>http://www.json.org/json-de.html</ref>:
nicht auf Syntaxfehler zu überprüfen. Gegebenenfalls müssen Sie auch wieder die Dateien <code>gruntfile.js</code>
... <code>webpack.config.js</code> unter die Versionsverwaltung von SVN stellen (<code>Add to VCS</code>).


Ändern Sie in den Dateien <code>package.json</code> und <code>web/index.html</code> die Versionsnummern,
* Nullwert (<code>null</code>)
die Beschreibung und gegebenenfalls den Pfad zum Repository Ihres Projektes.
* Boolescher Wert (<code>true</code> oder <code>false</code>)
* Zahl (Ziffernfolge mit optionalem Vorzeichen und optionalen Exponenten)
* Zeichenkette (beliebige UTF-8-Zeichen, die in doppelten geraden Anführungszeichen (<code>"</code>) eingeschlossen sind)
* Array (eine durch Kommata getrennte Listen von null oder mehr JSON-Elementen; die Liste beginnt mit <code>[</code> und endet mit <code>]</code>)
* Objekt/Hasharray/Paarliste (eine durch Kommata getrennte Listen von null oder mehr Paaren; die Liste beginnt mit <code>{</code> und endet mit <code>}</code>; jedes Paar besteht aus einer Zeichenketten, die als Schlüssel fungiert, gefolgt von einem Doppelpunkt  (<code>:</code>) gefolgt von einem beliebigen JSON-Element; in einem Objekt darf derselbe Schlüsselwert nicht zweimal vorkommen)


Zu guter Letzt öffnen Sie das WebStorm-Terminal und führen den Befehl <code>npm install</code>aus.
Beachten Sie, dass die eine [[Rekursion|rekursive]] Definition ist: Arrays dürfen andere Arrays und Objekte enthalten, Objekte dürfen
Damit werden dieselben Node.js-Pakete installiert wie im vierten Teil des Tutoriums.
andere Objekte und Arrays enthalten. JSON-Elemente können also beliebig tief geschachtelt sein.


Löschen Sie die Datei <code>web/js/app.bundle.js</code> und
Andere Werte dürfen in einer JSON-Datei nicht enthalten sein. Das heißt, es gibt keine einfachen geraden Anführungszeichen (außer '''innerhalb''' von Zeichenketten), keine Kommentare, keine Funktionen etc. '''Insbesondere überflüssige Kommas sind nicht erlaubt!'''
rufen Sie anschließend <code>grunt</code> auf, um diese Datei erneut zu erzeugen.
Wenn Sie jetzt die Datei <code>index.html</code> im Browser öffnen, sollte die
Web-Anwendung so wie in Teil 4 der Aufgabe funktionieren.


==Verfeinerung der Webpack-Umgebung==
Beachten Sie bitte, dass jeden JSON-Datei auch eine
Zunächst benötigen Sie ein paar weitere Node.js-Module
JavaScript-Datei ist (die Umkehrung dieser aussage gilt nicht.). Wenn man eine JSON-Datei auswerten würde, erhielte man jedoch kein anderes Ergebnis als den Wert oder das Objekt, das in der Datei gespeichert ist.
<source lang="bash">
npm install --save-dev es6-autobind
npm install --save-dev node-sass sass-loader extract-text-webpack-plugin
</source>


Das Modul <code>es6-autobind</code> wird im Zusammenhang mit der Definition der Klasse <code>Greet</code>
Erstellen Sie in Ihrem Projekt  folgende zwei JSON-Dateien:
benötigt . Daher wird es erst später besprochen.


Im vierten Teil des Tutoriums wurde die Datei <code>initial.css</code> nicht von Webpack verwaltet,
'''src/json/config_de.json'''
sondern direkt in das Verzeichnis <code>web/css</code> eingefügt. Damit liegt auch die
<source lang="javascript">
Verantwortung für die Komprimierung dieser Datei beim Programmierer. Das soll sich ändern.
{ "html":
Sie erweitern die Webpack-Konfiguration so, dass künftig auch diese Datei unter der Kontrolle
  { "reset":   "Reset",
von Webpack steht.
    "submit":  "Begrüßung"
 
   },
===SCSS===
   
 
   "text":
Anstelle von CSS-Dateien verwenden Sie künftig SCSS-Dateien. Das ist zunächst einmal nicht weiter schwer,
   { "title":   "Hallo, Fremder!",
das jede CSS-Datei automatisch auch eine SCSS-Datei ist. Bei der Verwendung von CSS können Sie
    "question": "Wie heißen Sie?",
allerdings das Prinzip  „[[Don't repeat yourself]]“ (DRY) nicht beachten. Sie müssen für verschiedene Elemente
    "hello":   "Hallo, $1!",
ständig Informationen wiederholen (gewünschter Font, Hintergrundfarbe, Größenangaben etc.). Deshalb
    "welcome""Willkommen bei Multimedia-Programmierung!"
gibt es mehrere Projekte wie {{zB}} [[LESS]] und [[Sass]] , die den CSS-Standard erweitern, um dieses Problem
zu vermeiden. Sass verwendet allerdings eine ganz andere Syntax als CSS. Allerdings
unterstützt das Sass-Projekt auch die Sprache SCSS, die CSS einfach um weitere syntaktische Elemente ergänzt.
Zum Beispiel kann man in SCSS Konstanten definieren:
 
<source lang="CSS">
$background-color:  #C5EFFC;
</source>
 
Und nun kann man in der CSS-Datei anstelle von  <code>#C5EFFC</code> stets  <code>&#36;background-color</code>
schreiben, um die Hintergrundfarbe von bestimmten Elementen zu definieren. Wenn man nun dieses Farbe ändern will,
muss das nicht mehr bei allen Elementen einzeln passieren. Es reicht, die Farbe in der Konstantendefinition abzuändern.
Der CSS-Code ist nun DRY.
 
Leider unterstützt kein Browser SCSS direkt. Aber für was gibt es Transpiler wie Webpack, die eine SCSS-Datei
automatisch in eine CSS-Datei übersetzen können.
 
Ersetzen Sie in Ihrem Projekt die Datei <code>src/css/main.css</code> durch
drei SCSS-Dateien: <code>_config,scss</code>, <code>initial.scss</code> und </code>app.scss</code>.
 
In der Datei <code>_config,scss</code> werden alle von den anderen SCSS-Dateien benötigten Konstanten definiert.
Wenn man künftig am Layout einen Zeichensatz, eine Farbe, einen Hintergrund oder Ähnliches ändern will,
reicht es die entsprechenden Konstanten anzupassen und schon erzeugt Webpack automatisch aktualisiere
CSS-Dateien.
 
Die Datei <code>initial.scss</code> enthält möglichst wenig Code. Das ist Vorlage für die Datei <code>initial.bundle.css</code>,
die im HTML-Head-Bereich geladen vor dem Body-Inhalt werden soll.
Die eigentlichen CSS-Informationen der Web-Anwendung werden in <code>app.scss</code> gespeichert. Die zugehörigen
CSS-Anweisungen werden von Webpack wie gehabt in <code>app.bundle.js</code> integriert.
 
'''<code>src/css/_config,scss</code>'''
<source lang="CSS">
$font-family-sans: Verdana, Helvetica, sans-serif;
$font-family-serif: "Times New Roman", Times, serif;
$background-color: #C5EFFC;
</source>
 
Diese Datei kann nun mit Hilfe des SCSS-Befehls <code>@import</code>
in die anderen beiden  SCSS-Dateien eingefügt werden. Webpack (genauer gesagt das SASS-Modul von Webpack)
kennt diesen Befehl und führt im beim Erstellen der zugehörigen CSS-Dateien auch aus.
 
Der Import-Befehl ist hier notwendig, da in der Datei <code>initial.scss</code> die Konstante <code>&#36;background-color</code>
verwendet wird. Ansonsten enthält dies Datei nur den schon bekannten CSS-Code.
 
'''<code>src/css/initial.scss</code>'''
<source lang="CSS">
@import 'config';
 
body
{ background-color: $background-color;
}
 
.hidden
{ display: none;
}
</source>
 
Die Datei <code>app.scss</code> ist deutlich umfangreicher. Daher soll der zugehörige CSS-Code
ja auch erst gemeinsam mit der Datei  <code>app.bundle.js</code> geladen werden. Das meiste ist üblicher
CSS-Code, den Sie schon im vierten Teil des Tutoriums kennengelernt haben. Es gibt ein paar neue
Elemente, wie die CSS-Klassen-Elemente <code>.left</code> und <code>.right</code>, die in der HTML-Datei dieses
Tutoriums zusätzlich verwendet werden. Außerdem sehen Sie in der Datei noch ein  paar weitere SCSS-Elemente. Diese werden
im Anschluss an den folgenden code beschrieben.
 
'''<code>src/css/app.scss</code>'''
<source lang="CSS">
@import 'config';
 
html, body
{ height:           100%;
   font-size:        2vw !important;
   font-family:      $font-family-sans;
  background-color: $background-color;
}
 
html
{ display: table;
  width:  100%;
}
 
body
{ display:          table-cell;
   text-align:       center;
   vertical-align:  middle;
}
 
h1
{ padding-bottom: 0;
  margin-bottom: 0;
}
 
#section_form
{ text-align:   center;
  width:        21em;
  margin-leftauto;
  margin-right: auto;
 
  h1
  { font-size:    200%;
    margin-bottom: 0.5ex;
   }
   }
}
#section_hello
{ h1
  { font-size: 270%;
  }
}
p, label
{ font-family: $font-family-serif;
  font-size:  100%;
}
label, input, button
{ width:        10em;
  font-size:    100%;
  display:      inline-block;
  box-sizing:    border-box;
  margin-bottom: 0.5ex;
}
label
{ text-align: right;
}
@mixin panel()
{ padding: 0;
  width:  50%;
}
.left
{ float: left;
  @include panel();
}
.right
{ float: right;
  @include panel();
}
}
</source>
</source>


In diese SCSS-Datei werden folgende SCSS-Erweiterungen verwendet:
'''src/json/config_en.json'''
 
<source lang="javascript">
* Import-Befehl: <code>@import 'config';</code>
{ "html":
* Konstanten:  <code>&#36;font-family-sans</code>,  <code>&#36;font-family-serif</code>,  <code>&#36;background-color</code>
   { "reset":   "Reset",
* Verschachtelte Anweisungen: {{zB}} <code>h1</code> innerhalb von  <code>#section_form</code>
    "submit""Say hello"
* Mixins, um eine Liste von Attributen nur einmal zu definieren und und mehreren Elemente wieder verwenden zu können.
   },
 
      
Die verschachtelten Anweisungen strukturieren den CSS-Code deutlich besser. Es ist nicht mehr
   "text":
notwendig einen Selektor wie <code>#section_form</code> mehrfach zu verwenden.
   { "title":   "Hello, Stranger!",
 
    "question": "What's your name?",
Sehen Sie sich den Unterschied an. In der Datei <code>main.css</code> vom vierten Teil des Tutoriums hatten Sie
    "hello":   "Hello, $1!",
folgendes geschrieben:
     "welcome": "Welcome to Multimedia Programming!"
 
<source lang="CSS">
#section_form
{
   text-align:   center;
  width:       21em;
   margin-left:  auto;
   margin-right: auto;
}
 
#section_form > h1
{
  font-size:     200%;
   margin-bottom: 0.5ex;
}
</source>
 
Die SCSS-Variante ist deutlich strukturierter und prägnanter.
 
<source lang="CSS">
#section_form
{ text-align:   center;
   width:       21em;
  margin-left: auto;
  margin-right: auto;
 
  h1
  { font-size:     200%;
    margin-bottom: 0.5ex;
   }
   }
}
}
</source>
</source>


Insbesondere bei großen CSS-Dateien erweist sich diese kompaktere Schreibweise als vorteilhaft.
Importieren Sie die erste der beiden JSON-Dateien in Ihre Datei <code>src/js/app,js</code>,
 
indem Sie folgenden Import-Befehl einfügen:
Ein weiteres Element, das nur SCSS bietet sind die Mixins. Sie definieren zunächst ein Mixin,
das eine Folge von CSS-Attributen zusammenfasst. (Auch hier könnten wieder Verschachtelungen und
andere SCSS-Erweiterungen verwendet werden!)
 
<source lang="CSS">
@mixin panel()
{ padding: 0;
  width:  50%;
}
</source>
 
Und nun können Sie dieses Mixin in diversen andere Elemente einbinden:
 
<source lang="CSS">
.left
{ float: left;
  @include panel();
 
.right
{ float: right;
  @include panel();
}
</source>
 
In normalen CSS-Code, müssten Sie denselben Code Non-DRY formulieren:
 
<source lang="CSS">
.left
{ float:  left;
  padding: 0;
  width:  50%;
}
 
.right
{ float:  right;
  padding: 0;
  width:  50%;
}
</source>
 
Wenn Sie hier das Layout der Panels ändern wollten (andere Breite, andere Ränder etc.), müssen
Sie den CSS-Code von jedem Panel einzeln ändern. In der SCSS-Datei erfolgt die Änderung dagegen DRY: Sie ändern einfach den Mixin-Code ab. 
 
Wenn die aktuellen Browser SCSS verstehen würden, könnte sie <code>initial.scss</code> und <code>app.scss</code> direkt
vom HTML-Code aus laden. Allerdings geht das derzeit leider nicht. Somit muss Webpack angewiesen werden, CSS-Code aus den
SCSS-Dateien zu erzeugen. Dies ist mit den beiden Node.js-Modulen <code>node-sass</code> und <code>sass-loader</code>,
die Sie bereits installiert haben, ganz einfach möglich.
 
Ersetzen Sie in der Datei <code>webpack.config.js</code> folgenden Code
 
<source lang="javascript">
{ test:  /\.css$/,
  use:    [ 'style-loader',
            { loader: 'css-loader', options: { minimize: true } }
          ]
},
</source>
 
durch folgenden:
 
<source lang="javascript">
{ test:  /\.(css|scss|sass)$/,
  use:    [ 'style-loader',
            { loader: 'css-loader', options: { minimize: true } },
            'sass-loader'
          ]
}
</source>
 
Der Test wird so erweitert, dass diese Regel jetzt nicht nur für die Verarbeitung von Dateien mit der
Endung <code>.css</code> zuständig ist, sondern auch für Dateien mit den Endungen
<code>.sass</code> und <code>.scss</code>.
 
Die Liste der zugehörigen Loader wird einfach um einen Loader erweitert:  <code>sass-loader</code>.
Diese Liste wird von hinten nach vorne abgearbeitet. Das heißt, eine Datei wie beispielsweise <code>app.scss</code>
wird erst mit Hilfe des Sass-Loaders in eine CSS-Datei umgewandelt, diese wird mit Hilfe des CSS-Loaders komprimiert
und das Ergebnis dieser Datei wird mit Hilfe des Style-Loaders in die zugehörige JavaScript-Ausgabedatei integriert.
 
Jetzt müssen nur noch die zugehörigen JavaScript-Dateien erstellt werden.
 
Im <code>entry</code>-Objekt der Datei <code>webpack.config.js</code> ist bereits die Datei <code>src/js/app.js</code>
eingetragen. Für Sie wird von Webpack die Datei <code>web/js/app.bundle.js</code> erzeugt.
 
Der Name der Zieldatei wurde im <code>output</code>-Objekt von <code>webpack.config.js</code> spezifiziert.
'''Achtung:''' Überprüfen Sie, ob das <code>output</code>-Objekt folgendermaßen definiert wurde.
 
<source lang="javascript">
  output:
  { filename: '[name].bundle.js',
    path:    absolutePath('web/js')
  }
</source>
 
Im vierten Teil des Tutoriums stand der Unterpfad <code>js</code> noch im Dateinamen, was problematisch ist. 
Verbessern Sie gegebenenfalls das Output-Element.
 
Damit diese Zieldatei insbesondere den komprimierten Code der Datei <code>src/css/app.scss</code> enthält,
muss <code>src/js/app.js</code> leicht modifiziert werden.
 
Ersetzen Sie in dieser Datei den Import-Befehl
 
<source lang="javascript">
import '../css/main.css';
</source>
durch den Import-Befehl
 
<source lang="javascript">
<source lang="javascript">
import '../css/app.scss';
import * as config from '../json/config_de.json';
</source>
</source>


Die Datei <code>web/css/main.css</code> gibt es ja nicht mehr; sie wurde durch
In  <code>src/js/app/greet,js</code> fügen Sie folgenden
<code>web/css/app.scss</code> ersetzt.
Import-Befehl ein:
 
Damit auch <code>web/css/initial.scss</code> durch webpack verwaltet wird, benötigen wir eine zweite
JavaScript-Datei.
 
'''src/js/initial.js'''
<source lang="javascript">
<source lang="javascript">
import '../css/initial.scss';
import * as config from '../../json/config_de.json';
</source>
</source>


Sie sehen das richtig, die Datei <code>src/js/initial.js</code> enthält eine einzige Code-Zeile.
Beachten Sie, dass hier eine Zugriff auf das „Großvater“-Verzeichnis <code>src</code> mittel <code>../../</code> erfolgen muss.
Sie erinnern sich? Webpack dient eigentlich nur dazu JavaScript-Dateien zu packen. Also geben wir diesen
Grundsätzlich sollten Sie in Import-Befehlen immer relative Pfadnamen angeben, da sonst eine Änderung der globalen Ordnerstruktur
Tool eine JavaScript-Datei, die die gewünschte CSS-Datei einfach mittels eine ES6-Import-Befehls importiert (ES6 = EcmaScript 6).
zu massiven Problemen führen kann. Achten Sie bei Pfad-Angaben insbesondere auf Groß- und Kleinschreibung.
Fügen Sie nun in das <code>entry</code>-Objekt der Datei <code>webpack.config.js</code> vor der Zeile
Gemeinerweise macht es auf Windows-Rechnern keinen Unterschied, ob sie in einem Pfadnamen Groß- oder Kleinbuchstaben
folgende zweite Zeile ein:
verwenden. Wenn Sie die Anwendung später auf einen Linux-Server kopieren, kommt es dann allerdings zu Problemen,
weil der Server die Pfade mit den falschen Groß- oder Kleinbuchstaben nicht mehr findet. Sie sollten in Dateinamen
am Besten überhaupt keine Großbuchstaben verwenden.  


<source lang="javascript">
Wenn Sie jetzt <code>grunt</code> aufrufen und anschließend <code>index.html</code> im Browser öffnen,
initial: absolutePath('src/js/initial.js')
hat sich noch nicht viel getan.
</source>


Beachten Sie, dass in einem JavaScript-Objekt die Attribute durch Kommas voneinander getrennt werden. Fügen Sie also
Ändern Sie nun den Inhalt der <code>index.html</code>. Löschen Sie alle englischen Text-Elemente.
an passender Stelle auch noch ein Komma ein.
sie sollten sie durch die angegebenen Dummy-Texte ersetzen, notwendig wäre das aber nicht:


Wenn Sie jetzt Grunt aufrufen, sollten zwei Dateien generiert werden: <code>web/js/app.bundle.js</code> und  <code>web/js/initial.bundle.js</code>.
* <code>Hello, Stranger!</code> → <code>TITLE</code>
 
* <code>What's your name?</code> → <code>QUESTION</code>
Löschen Sie nun den Ordner <code>web/css</code> (die darin befindliche Datei <code>initial.css</code> wird nicht mehr benötigt)
* <code>Reset</code> → <code>RESET</code>
und ersetzen Sie in der Datei <code>index.html</code> die Zeile
* <code>Say hello</code> → <code>SUBMIT</code>
* <code>Hello, ...</code> → <code>HELLO</code>
* <code>Welcome to Multimedia Programming!</code> → <code>WELCOME</code>


<source lang="html">
Sie müssen außerdem noch einigen HTML-Tags zusätzlich ein <code>id</code>-Attribut zuordnen:
<link rel = "stylesheet" type = "text/css" href = "css/initial.css"/>
</source>


durch folgende Zeile:
* H1-Element: <code>&lt;h1 id="heading_form"&gt;</code>
* Label-Element: <code>&lt;label id="input_label" ..&gt;</code>
* Reset-Button:  <code>&lt;input id="button_reset" type="reset" ...&gt;</code>
* Welcome-Paragraph: <code>&lt;p id="paragraph_hello">WELCOME&lt;/p&gt;</code>


<source lang="html">
Wenn Sie jetzt die <code>index.html</code> nochmals im Browser öffnen, sehen Sie nur noch die DUMMY-Texte.
<script type = "text/javascript" src = "js/initial.bundle.js"></script>
</source>
 
Wenn Sie jetzt die Datei <code>index.html</code> im Browser öffnen, sollte sie wieder genauso funktionieren wie zuvor.
 
'''Anmerkung''': Die Datei <code>src/js/initial.js</code> könnte natürlich noch mehr machen, als einfach nur eine CSS-Datei zu laden.
Sie könnte beispielsweise eine kleine Animation einblenden (die berühmte Sanduhr, nur etwas moderner), die solange läuft, bis
die eigentliche Web-Anwendung, {{dh}}  <code>app.bundle.js</code> vollständig geladen wurde und die Animation wieder beendet.
 
===Erzeugen einer CSS-Datei===
 
Zurzeit enthält die JavaScript-Datei <code>web/js/initial.bundle.js</code> nur eine komprimierte CSS-Datei und etwas Code,
um diesen in das HTML-Dokument einzufügen. Die Google-Suche bewertet HTML-Dateien, die sauberen CSS-Code {{iAllg}} enthalten,
höher, als HTML-Datei, die nur JavaScript-Code enthalten. Daher wäre es in diesem Fall sinnvoll, die komprimierte
CSS-Datei direkt in den HTML-Code einzubinden. Das ist aber gar nicht so einfach, da Webpack keine CSS-Dateien erstellt,
sondern nur JavaScript-Dateien. Aber mit einem kleine Hack funktioniert das trotzdem.


Sie haben vor auch noch die Node.js-Module <code>extract-text-webpack-plugin</code>
Das ändert sich allerdings, wenn Sie folgende JavaScript-Befehle in die Datei <code>src/js/app.js</code> nach den
installiert. Mit diesem Sie eine CSS-Datei aus einer JavaScript-Datei extrahieren.
Import-Befehlen einfügen:


Ersetzen Sie zunächst in der Datei <code>webpack.config.js</code> den Test
<source lang="javascript">
test:  /\.(css|scss|sass)$/,
</source>
durch
<source lang="javascript">
<source lang="javascript">
test:  /app\.(css|scss|sass)$/,
const c_config_text = config.text;
</source>


Damit erreichen Sie dass diese Regel jetzt nur noch für Dateien funktioniert, die auf <code>app.css</code> oder
// Initialize the app.
<code>app.scss</code> oder <code>app.sass</code> enden. Die Datei <code>src/css/app.scss</code> in die
document.getElementById('button_reset').value
Datei <code>src/js/app.bundle.js</code> integriert werden.
  = c_config_text.reset;
document.getElementById('button_submit').value
  = c_config_text.submit;


Laden Sie zunächst die ExtractTextPlugin-Erweiterung, indem Sie in die Datei <code>webpack.config.js</code>
document.getElementById('heading_form').innerHTML
folgende zweite Zeile einfügen:
  = c_config_text.title;
<source lang="javascript">
document.getElementById('input_label').innerHTML
const ExtractTextPlugin = require('extract-text-webpack-plugin');
  = c_config_text.question;
</source>
 
Für die Datei <code>src/css/initial.scss</code> fügen Sie nun in die Liste mit den Regeln eine weitere Regel  ein (Komma nicht vergessen):
<source lang="javascript">
{ test:  /initial\.(css|scss|sass)$/,
  use:  ExtractTextPlugin.extract
        ({fallback: "style-loader",
          use:      [{ loader: 'css-loader', options: { minimize: true } },
                      'sass-loader'
                    ]
        })
}
</source>
</source>


Diese benutzt das zuvor erwähnte Plugin, um die komprimierte CSS-Datei aus der Datei <code>src/js/initial.bundle.js</code>
(Die restlichen Zeilen bleiben erhalten.)  Mit diesen fünf Befehlen speichern Sie den Inhalt des Attributs
zu extrahieren. Das erledigt sie aber nur fast. Man muss dem Plugin noch mitteilen wohin Sie die CSS-Datei speichern soll.
<code>text</code> aus der eingelesenen JSON-Datei in der Konstanten
<code>c_config_text</code>. Anschließend ersetzen Sie mit Hilfe von vier weiteren Befehle
die Dummy-Texte im der Form-Section durch sinnvolle Texte.


Dazu müssen Sie die bislang leere Plugin-Liste am Ende der Datei
Rufen Sie <code>grunt</code> auf und öffnen Sie anschließend <code>index.html</code> im Browser.
Jetzt sollten Sie deutsche Text an Stelle von Dummy-Texten sehen. Wenn Sie jetzt allerdings einen Namen eingeben
und auf den Begrüßungs-Button klicken, werden Sie englisch begrüßt und sehen einen weiteren Dummy-Text.


<source lang="javascript">
Das heißt, Sie müssen auch noch die Datei <code>src/js/app/greet.js</code> erweitern.
plugins:
[]
</source>


mit Inhalt füllen:
Ersetzen Sie in dieser Datei im Rumpf der Funktion <code>sayHello</code>
den darin enthalten Code durch folgenden Code:


<source lang="javascript">
<source lang="javascript">
plugins:
const l_config_text = config.text,
[ new ExtractTextPlugin("../css/[name].bundle.css") ]
      l_name      = document.getElementById("input_name").value;
</source>
 
Führen Sie nun <code>grunt</code> aus. Es sollte die Datei <code>web/css/initial.bundle.css</code>
erzeugt worden sein.
 
Nun müssen sie in der Datei <code>index.html</code> die Zeile
 
<source lang="html">
<script type = "text/javascript" src = "js/initial.bundle.js"></script>
 
</source>


wieder durch eine CSS-Link-Zeile ersetzen (da ja in der Datei <code>initial.bundle.js</code> kein sinnvoller Inhalt mehr enthalten ist;
document.getElementById('paragraph_hello').innerHTML
sie wurde durch das Extract-Text-Plugin  „ausgelutscht“).
  = l_config_text.welcome;
document.getElementById('heading_hello').innerHTML
  = l_config_text.hello.replace('$1', l_name);


<source lang="html">
document.getElementById('section_hello')
<link rel = "stylesheet" type = "text/css" href = "css/initial.bundle.css"/>
  .classList.remove('hidden');
document.getElementById('section_form')
  .classList.add('hidden');
</source>
</source>


Sie könnten nun noch die überflüssige Datei <code>web/js/initial.bundle.js</code> von webpack wieder entfernen lassen.
Die Funktion <code>sayHelloOnEnter</code> ändert sich dagegen nicht.
Wie das geht entnehmen Sie bitte der Seite https://stackoverflow.com/questions/37408873/delete-or-not-create-a-file-for-each-entry-in-webpack
sowie der [https://glossar.hs-augsburg.de/beispiel/tutorium/es6/hello_world/WK_HelloWorld05/ Musterlösung]. Wichtig ist das nicht.
Wenn Sie später mal eine kleine Warteanimation erstellen sollten, bräuchten Sie dieses Datei sowieso wieder.
 
==JSON==


Bislang haben sie den CSS-Code unter Webpack-Kontrolle gestellt und damit DRY gemacht.  
Nun sollte (nach einen <code>grunt</code>-Lauf) die Web-App wie gewünscht funktionieren.
Als nächstes gehen wir das nächste Problem an: Ihr Code enthält Konstanten.damit verstoßene Sie gegen ein
weiteres fundamentales [[Programmierprinzipien|Programmierprinzip]]:


''Konstante Werte sollten im Allgemeinen nicht direkt in den Code eingefügt werden, sondern als konstante Werte separat definiert werden (Ausnahme: triviale Konstanten, die sich sicher nie ändern werden, wie z.B. Vergleiche mit dem Wert 0). Konstanten, die das Programmverhalten beeinflussen, sollten im Allgemeinen beim Programmstart aus einer Konfigurationsdatei ausgelesen werden.''
Sie können jetzt testweise mal in beiden Dateien <code>app.js</code> und <code>greet.js</code>
die englischsprachige JSON-Datei landen, <code>grunt</code> laufen lassen und <code>index.html</code> öffnen.
Dann sollten Sie auf Englisch begrüßt werden. Das ist schon nicht schlecht, aber richtig DRY ist das noch nicht.
Sie müssen den Namen der JSON-Datei in '''zwei''' Dateien ändern. Also braucht es noch eine sechstes und letztes Hello-World-Tutorium ...


{{TBD}}
==Wiederverwendbarkeit==
==Wiederverwendbarkeit==
<!--
<!--

Aktuelle Version vom 12. April 2021, 17:53 Uhr

Dieser Artikel wird derzeit von einem Autor gründlich bearbeitet. Die Inhalte sind daher evtl. noch inkonsistent.

Dieser Artikel erfüllt die GlossarWiki-Qualitätsanforderungen nur teilweise:

Korrektheit: 3
(zu größeren Teilen überprüft)
Umfang: 4
(unwichtige Fakten fehlen)
Quellenangaben: 3
(wichtige Quellen vorhanden)
Quellenarten: 5
(ausgezeichnet)
Konformität: 3
(gut)

Vorlesung WebProg

Inhalt | Teil 1 | Teil 2 | Teil 3 | Teil 4 | Teil 5 | Teil 6 | Vue 1 | Vue 2 | Vue 3 | Vue 4 | Vue 5 | Vue 6

Dieser Artikel wird derzeit von einem Autor gründlich bearbeitet. Die Inhalte sind daher evtl. noch inkonsistent.

JSON

Bislang haben sie den CSS-Code unter Webpack-Kontrolle gestellt und damit DRY gemacht. Als nächstes gehen wir das nächste Problem an: Ihr Code enthält ebenfalls Konstanten und verstößt damit gegen das Programmierprinzip „Konstante Werte gehören nicht in den Code, sondern in Konfigurationsdateien.“

Eine Ausnahme bilden triviale Konstanten wie 0, 1, null, true oder false, sofern sie mit großer Sicherheit nie im Code geändert werden müssen. Aber schon eine Konstante wie 3.1415926 gehört nicht in den Code. Man verwendet stattdessen besser Math.PI und erhält damit die maximal mögliche Stellenzahl. (Eventuell hängt diese von der Rechnerplattform ab.)

In JavaScript-Anwendungen verwendet man JSON zur Speicherung von (konstanten) Daten und zur Initialisierung der Anwendung. Wenn ein Spiel mehrere Level hat, wir jedes Level üblicherweise in einer eigenen JSON-Datei beschrieben. Eine Level-Designerin muss im Optimalfall nicht mehr machen, als die Assets (Grafiken, Töne, 3D-Modell etc.) zu erstellen und mit Hilfe einer JSON-Datei die Zusammenhänge zwischen den einzelnen Elementen herstellen. Es sollte nicht notwendig sein, dass sie den Programmcode modifizieren muss, da das Level-Design schon aufwändig genug ist.

JSON (JavaScript Object Notation) ist ein einfaches Datenformat, mit dessen Hilfe sich komplexe Objekte sehr einfach beschreiben lassen. Eine Alternative wäre XML, allerdings ist diese Auszeichnungsprache deutlich komplexer. (Ein Beispiel für XML ist XHMLT 1.0[1], eine HTML-Variante.)

Eine JSON-Datei ist im Prinzip eine JavaScript-Datei, die einen der folgenden Datentypen enthält[2]:

  • Nullwert (null)
  • Boolescher Wert (true oder false)
  • Zahl (Ziffernfolge mit optionalem Vorzeichen und optionalen Exponenten)
  • Zeichenkette (beliebige UTF-8-Zeichen, die in doppelten geraden Anführungszeichen (") eingeschlossen sind)
  • Array (eine durch Kommata getrennte Listen von null oder mehr JSON-Elementen; die Liste beginnt mit [ und endet mit ])
  • Objekt/Hasharray/Paarliste (eine durch Kommata getrennte Listen von null oder mehr Paaren; die Liste beginnt mit { und endet mit }; jedes Paar besteht aus einer Zeichenketten, die als Schlüssel fungiert, gefolgt von einem Doppelpunkt (:) gefolgt von einem beliebigen JSON-Element; in einem Objekt darf derselbe Schlüsselwert nicht zweimal vorkommen)

Beachten Sie, dass die eine rekursive Definition ist: Arrays dürfen andere Arrays und Objekte enthalten, Objekte dürfen andere Objekte und Arrays enthalten. JSON-Elemente können also beliebig tief geschachtelt sein.

Andere Werte dürfen in einer JSON-Datei nicht enthalten sein. Das heißt, es gibt keine einfachen geraden Anführungszeichen (außer innerhalb von Zeichenketten), keine Kommentare, keine Funktionen etc. Insbesondere überflüssige Kommas sind nicht erlaubt!

Beachten Sie bitte, dass jeden JSON-Datei auch eine JavaScript-Datei ist (die Umkehrung dieser aussage gilt nicht.). Wenn man eine JSON-Datei auswerten würde, erhielte man jedoch kein anderes Ergebnis als den Wert oder das Objekt, das in der Datei gespeichert ist.

Erstellen Sie in Ihrem Projekt folgende zwei JSON-Dateien:

src/json/config_de.json

{ "html":
  { "reset":    "Reset",
    "submit":   "Begrüßung"
  },
    
  "text":
  { "title":    "Hallo, Fremder!",
    "question": "Wie heißen Sie?",
    "hello":    "Hallo, $1!",
    "welcome":  "Willkommen bei Multimedia-Programmierung!"
  }
}

src/json/config_en.json

{ "html":
  { "reset":    "Reset",
    "submit":   "Say hello"
  },
    
  "text":
  { "title":    "Hello, Stranger!",
    "question": "What's your name?",
    "hello":    "Hello, $1!",
    "welcome":  "Welcome to Multimedia Programming!"
  }
}

Importieren Sie die erste der beiden JSON-Dateien in Ihre Datei src/js/app,js, indem Sie folgenden Import-Befehl einfügen:

import * as config from '../json/config_de.json';

In src/js/app/greet,js fügen Sie folgenden Import-Befehl ein:

import * as config from '../../json/config_de.json';

Beachten Sie, dass hier eine Zugriff auf das „Großvater“-Verzeichnis src mittel ../../ erfolgen muss. Grundsätzlich sollten Sie in Import-Befehlen immer relative Pfadnamen angeben, da sonst eine Änderung der globalen Ordnerstruktur zu massiven Problemen führen kann. Achten Sie bei Pfad-Angaben insbesondere auf Groß- und Kleinschreibung. Gemeinerweise macht es auf Windows-Rechnern keinen Unterschied, ob sie in einem Pfadnamen Groß- oder Kleinbuchstaben verwenden. Wenn Sie die Anwendung später auf einen Linux-Server kopieren, kommt es dann allerdings zu Problemen, weil der Server die Pfade mit den falschen Groß- oder Kleinbuchstaben nicht mehr findet. Sie sollten in Dateinamen am Besten überhaupt keine Großbuchstaben verwenden.

Wenn Sie jetzt grunt aufrufen und anschließend index.html im Browser öffnen, hat sich noch nicht viel getan.

Ändern Sie nun den Inhalt der index.html. Löschen Sie alle englischen Text-Elemente. sie sollten sie durch die angegebenen Dummy-Texte ersetzen, notwendig wäre das aber nicht:

  • Hello, Stranger!TITLE
  • What's your name?QUESTION
  • ResetRESET
  • Say helloSUBMIT
  • Hello, ...HELLO
  • Welcome to Multimedia Programming!WELCOME

Sie müssen außerdem noch einigen HTML-Tags zusätzlich ein id-Attribut zuordnen:

  • H1-Element: <h1 id="heading_form">
  • Label-Element: <label id="input_label" ..>
  • Reset-Button: <input id="button_reset" type="reset" ...>
  • Welcome-Paragraph: <p id="paragraph_hello">WELCOME</p>

Wenn Sie jetzt die index.html nochmals im Browser öffnen, sehen Sie nur noch die DUMMY-Texte.

Das ändert sich allerdings, wenn Sie folgende JavaScript-Befehle in die Datei src/js/app.js nach den Import-Befehlen einfügen:

const c_config_text = config.text;

// Initialize the app.
document.getElementById('button_reset').value
  = c_config_text.reset;
document.getElementById('button_submit').value
  = c_config_text.submit;

document.getElementById('heading_form').innerHTML
  = c_config_text.title;
document.getElementById('input_label').innerHTML
  = c_config_text.question;

(Die restlichen Zeilen bleiben erhalten.) Mit diesen fünf Befehlen speichern Sie den Inhalt des Attributs text aus der eingelesenen JSON-Datei in der Konstanten c_config_text. Anschließend ersetzen Sie mit Hilfe von vier weiteren Befehle die Dummy-Texte im der Form-Section durch sinnvolle Texte.

Rufen Sie grunt auf und öffnen Sie anschließend index.html im Browser. Jetzt sollten Sie deutsche Text an Stelle von Dummy-Texten sehen. Wenn Sie jetzt allerdings einen Namen eingeben und auf den Begrüßungs-Button klicken, werden Sie englisch begrüßt und sehen einen weiteren Dummy-Text.

Das heißt, Sie müssen auch noch die Datei src/js/app/greet.js erweitern.

Ersetzen Sie in dieser Datei im Rumpf der Funktion sayHello den darin enthalten Code durch folgenden Code:

const l_config_text = config.text,
      l_name      = document.getElementById("input_name").value;

document.getElementById('paragraph_hello').innerHTML
  = l_config_text.welcome;
document.getElementById('heading_hello').innerHTML
  = l_config_text.hello.replace('$1', l_name);

document.getElementById('section_hello')
  .classList.remove('hidden');
document.getElementById('section_form')
  .classList.add('hidden');

Die Funktion sayHelloOnEnter ändert sich dagegen nicht.

Nun sollte (nach einen grunt-Lauf) die Web-App wie gewünscht funktionieren.

Sie können jetzt testweise mal in beiden Dateien app.js und greet.js die englischsprachige JSON-Datei landen, grunt laufen lassen und index.html öffnen. Dann sollten Sie auf Englisch begrüßt werden. Das ist schon nicht schlecht, aber richtig DRY ist das noch nicht. Sie müssen den Namen der JSON-Datei in zwei Dateien ändern. Also braucht es noch eine sechstes und letztes Hello-World-Tutorium ...

Wiederverwendbarkeit

TO BE DONE

Quellen

  1. Kowarschick (MMProg): Wolfgang Kowarschick; Vorlesung „Multimedia-Programmierung“; Hochschule: Hochschule Augsburg; Adresse: Augsburg; Web-Link; 2018; Quellengüte: 3 (Vorlesung)