Websites [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== - Websites ======



++++Lernziele|

   * Grob wissen, was das **Internet** ist.
   * Wissen, welche Dinge durch die Einführung des Internets revolutioniert wurden und welchen Einfluss dies auf die Gesellschaft hatte.
   * Wissen, wofür **HTML** steht und was es (nicht) ist.
   * Das Grundgerüst einer Website mit HTML erstellen können. Zum Beispiel: Was gehört in *head*, was in *body*.
   * Den Unterschied von Block- und Inline-Elementen beschreiben können.
   * Die wichtigsten HTML-Elemente kennen und anwenden können.
   * Für jedes dieser HTML-Elemente wissen, ob es sich um ein Block- oder Inline-Element handelt.
   * Wissen, wofür **CSS** steht und wozu man es benötigt.
   * Die Fachbegriffe von CSS kennen.
   * Mithilfe der wichtigsten CSS-Befehle eine Website stylen können:
     * Hintergrundfarbe
     * Schriftfarbe
     * Schriftart und Schriftgrösse
     * Ränder
     * Abstände
     * Grösse von Bild
   * Mithilfe von `id` oder `class` einzelne resp. ausgewählte Elemente stylen.

++++

**Hauptziel** dieses Blocks ist, zu verstehen, wie eine Website aufgebaut ist. Dies erreichen wir, indem wir Schritt für Schritt  Websiten (nach)bauen.

{{ :gf_informatik:web_sca:web_i_websites.pdf |Slides: Web I - Websites}}

Einfacher Online-Compiler für Websiten: [[https://www.programiz.com/html/online-compiler/|Programiz]]

===== - Grundgerüst einer Website =====

**Ziele:**

   * Editor für Erstellen von Website installieren und kennenlernen
   * Einfaches Grundgerüst der Website erstellen

**Ziele:**

   * Editor für Erstellen von Website installieren und kennenlernen
   * Einfaches Grundgerüst der Website erstellen

==== Auftrag I ====

  1. **Visual Studio Code** (kurz **VSCode**): Falls der Editor VSCode noch nicht installiert ist, lade diesen herunter und installiere diesen: [[https://code.visualstudio.com]]\\ \\
  1. **Erstelle einen Ordner** mit Namen "website\_ksr" und speichere an einem passendenden Ort auf deinem Computer.\\ \\
  1. Starte nun VSCode und **öffne** darin diesen Ordner: Datei > Ordner öffnen > Ordner "website\_ksr" suchen und öffnen.\\ \\
  1. Klicke auf das Symbole (1) oben links, um den "Explorer" zu öffnen. Darin, also im Feld (2), siehst du alle Files und Unterordner, die im geöffneten Ordner vorhanden sind. Mit (3) kannst du darin neue Files und Unterordner erstellen. Mit Doppelklick auf ein File, wird dieses im Feld (4) geöffnet.
{{ :gf_informatik:web_sca:vscode_index.png?400 |}}
  1. Erstelle nun ein **neues File**, welches *zwingend* den Namen **index.html** haben muss.\\ \\
  1. Öffne nun index.html in VSCode und erstelle darin das **Grundgerüst** der Website. Tippe dazu folgendes ab (nicht copy paste):<WRAP classes #id width :code>
<code html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Titel der Website</title>
</head>
<body>
    Hier kommt der Inhalt der Website hinein.
</body>
</html>
</code>
{{ :gf_informatik:web_sca:html_tattoo_head_body.png?nolink&300 |}}
</WRAP>
  1. Verschaffe dir einen **Überblick** über den HTML-Code oben:<WRAP classes #id width :list>
  * HTML besteht aus vielen **Tags**. Die meisten HTML-Elemente haben einen Start- und einem Endtag.
  * Der HTML-Körper beginnt mit dem Starttag `<body>` und endet mit dem Endtag `</body>`. Dieser beinhaltet den **Inhalt** der Website, also das, was im Hauptfenster des Browsers angezeigt wird.
    * Der HTML-Kopf (zwischen `<head>` und `</head>`) beinhaltet Einstellungen und zusätzliche Informationen, die nicht im Hauptfenster des Browsers angezeigt wird, z.B.:
       * `<title>Titel der Website</title>`: Speichert Titel der Seite, wird in der Titelleiste des Browsers angezeigt
       * `<meta charset="UTF-8">`: sorgt dafür, dass z.B. Umlaute ä,ö,ü richtig angezeigt werden\\ \\
</WRAP>
   1. Gratulation, du hast deine erste Website erstellt! **Öffne** sie nun **im Browser:** Navigiere im File Explorer deines Computers (nicht von VSCode) zu deiner Website (also index.html) und öffne diese per Doppelklick. Nun sollte die Website im Browser angezeigt werden.
   1. Spiele nun herum und versuche folgende Dinge zu erzeugen, hole dir dafür Hilfe aus dem Internet:
     1. Überschriften mit `h1,h2,...`
     1. Fette und kursive Schrift
     1. Ein Bild anzeigen

<box 100% round green|**Tipp: Arbeiten mit VSCode**>
Wenn man mit VSCode arbeitet, sollte man *nicht* einzelne Files mit Doppelklick öffnen. Besser öffnet man wie oben beschrieben den **ganzen Ordner**. Jetzt kann diesen in der "Explorer"-Ansicht direkt verwalten: Files bearbeiten, neue Files und Ordner erstellen, ...
</box>

<box 100% round orange|**Tipp: index.html**>
Die Hauptseite jeder Website trägt den Namen `index.html`. Wähle deshalb immer diesen Namen, ganz egal, um was es bei der Website geht.
</box>



===== - Website erstellen mit HTML =====

**Ziel** von diesem Block ist, die wichtigsten **HTML-Elemente** kennenzulernen und mit ihnen eine **Website nachzubauen**.

==== Auftrag II ====

   1. Studiere die **Theorie** unten. **Probiere** alle dort vorgestellten Elemente (ausser `<div>` kurz in deinem HTML-File der letzten Aufgabe aus. Ziel hier ist, dass du **selbständig** herausfindest, wie das genau funktioniert. Du kannst dir dafür jede erdenkliche Hilfe holen (Google, KI, ...), aber am Schluss musst du verstehen, wie es funktioniert!\\ \\
   1. Kopiere dann den reinen **Text der Website** in den Body des Files "index.html", welches du im letzten Kapitel erstellt hast.<WRAP classes #id width :code>
++++Inhalt Website (click me!)|
GMS an der Kanti Romanshorn

Kanti Romanshorn, die innovative Schule im Grünen.

Hier geht es zur echten Website der KSR (https://www.ksr.ch).

Überblick

Während ihrer vierjährigen Ausbildungszeit an der KSR erleben unsere Schülerinnen und Schüler neben dem regulären Unterricht (Grundlagenfächer ab dem 1. Ausbildungsjahr, Schwerpunktfach zusätzlich ab dem 2. Ausbildungsjahr und Ergänzungsfach ab dem 3. Ausbildungsjahr) Spezialtage und Spezialwochen. Diese dienen, wie auch die Maturaarbeit, zur vertieften Auseinandersetzung mit ausgewählten Themenbereichen.
Die gesamte Ausbildung an der Kanti Romanshorn ist ausgerichtet auf die bewusste Förderung der nötigen Kompetenzen, um unsere Schülerinnen und Schüler optimal auf ein späteres Studium, die Arbeitswelt und anspruchsvolle Aufgaben in der Gesellschaft vorzubereiten.

Fächer

Das Fächerangebot an der KSR ist bewusst sehr breit angelegt. Die Grundlagenfächer sind für alle Schülerinnen und Schüler obligatorisch. Weiter wählen alle Schülerinnen und Schüler jeweils ein Schwerpunkt- und ein Ergänzungsfach.

Schwerpunktfächer GMS

Ab dem zweiten Ausbildungsjahr setzt das Schwerpunktfach ein. Zur Wahl stehen an unserer Schule folgende Fächer bzw. Fächerkombinationen:

Biologie und Chemie
Italienisch
Latein
Physik und Anwendungen der Mathematik
Spanisch
Wirtschaft und Recht
Bildnerisches Gestalten (ab 2021)

Ergänzungsfächer GMS

Mit dem Start des Ergänzungsfachs im dritten Ausbildungsjahr der Kanti Romanshorn ist die Fächerzusammensetzung komplett. Zur Wahl stehen an unserer Schule folgende Ergänzungsfächer bzw. Fächerkombinationen:

Anwendungen der Mathematik
Bildnerisches Gestalten
Geografie
Geschichte
Informatik
Musik
Naturwissenschaften plus (umfasst Projekte aus der Biologie, Chemie und Physik)
Philosophie/Ethik
Psychologie/Pädagogik
Sport
Wirtschaft und Recht
++++</WRAP>
   1. Lade das **Bild** herunter und kopiere es in den Ordner, in dem sich das index.html-File befindet: {{ :gf_informatik:web_sca:img_xlarge.jpeg?200 |}}
   1. Wende dann dein im Theorieteil gelerntes Wissen über HTML-Elemente an, um den Inhalt der **Website so zu gestalten**, dass diese genau so aussieht wie in der Vorlage: {{ :gf_informatik:web_sca:website_ksr_html.png?200 |}} Achtung: Mache nicht zu viele Schritte auf einmal. Gehe stattdessen **wie folgt vor:**
     1. Setze ein **einziges** HTML-Element um (z.B. h1-Überschrift)
     1. **Speichere** das HTML-File.
     1. Zeige die Website im Browser an / **Lade die Website neu**:<WRAP classes #id width :code>
     * Window: F5 (Achtung: ev. muss Fn drücken)
     * macOC: CMD + R
</WRAP>
     1. Stelle sicher, dass HTML-Element **richtig umgesetzt** wurde. Gehe erste dann weiter zum nächsten Element.




Studiere falls nötig die Hilfen unten.

++++Hilfe zu Überschriften|
Die Hauptüberschrift ist "GMS an der Kanti Romanshorn". Dafür verwendet man den `<h1>` Tag. Die anderen Überschriften sind Überschriften 2. und 3. Ordnung, deshalb verwendet man für diese `<h2>` und `<h3>`.
++++

++++Hilfe zu Paragraphen/Fliesstext|
Meist ist es eine gute Idee, Fliesstext mit dem Paragraphen-Tag `<p>` zu versehen. Damit stellt man sicher, dass er auf einer neuen Zeile beginnt und das darauffolgende HTML-Element auf einer neuen Zeile beginnt.
++++

++++Hilfe zu Listen|
Es gibt unnummerierte (`<ul>`) und nummerierte (`<ol>`) Listen. Für die einzelnen Punkte der Liste verwendet man das `<li>`-Tag.

<code html>
Unnummerierte Liste:
<ul>
    <li>Erstes Element</li>
    <li>Zweites Element</li>
    <li>Drittes Element</li>
</ul>

Nummerierte Liste:
<ol>
    <li>Erstes Element</li>
    <li>Zweites Element</li>
    <li>Drittes Element</li>
</ol>
</code>
++++

==== Theorie zu HTML-Elementen ====

Als erstes ist es wichtig, den Unterschied zwischen Block-Elementen und Inline-Elementen zu verstehen. **Block-Elemente** sind die Bausteine einer Webseite, die in der Regel den grössten Teil des Inhalts ausmachen. Sie nehmen standardmässig die volle Breite des Elements ein, in dem sie sich befinden und beginnen auf einer neuen Zeile. Im Gegensatz zu Block-Elementen fügen sich **Inline-Elemente** nahtlos in den Textfluss einer Seite ein, ohne eine neue Zeile zu beginnen. Sie nehmen nur so viel Platz ein, wie sie benötigen, und ermöglichen so eine reibungslose Einbettung von Text und anderen Inline-Elementen.

Die wichtigsten **Block-Elemente** sind:

   * Das `<p>`-Element dient zur Darstellung von **Paragraphen** (Absätzen). Jeder Absatz beginnt auf einer neuen Zeile.
   * `<h1>, <h2>, <h3>, ... <h6>`: Diese Elemente repräsentieren **Überschriften** unterschiedlicher Hierarchieebenen.
   * `<ul>, <ol>, <li>`: **Listen** werden in HTML mit diesen Elementen erstellt. `<ul>` und `<ol>` sind Container für Listenpunkte `<li>`.
   * (`<div>`: Dieses Element steht für "Division" und wird in der Regel als Container verwendet, um HTML-Inhalte zu gruppieren oder zu strukturieren.)

Die wichtigsten **Inline-Elemente** sind:

   * Mit `<em>` resp. `<strong>` kann Text **betont** ('emphasis') resp. stark betont werden. Der entsprechende Text wird kursiv resp. fett dargestellt.

Gewisse Tags benötigen **Attribute**, um zusätzliche Informationen angeben zu können:

   * **Hyperlinks** (Tag `<a>` für anchor) benötigen das Attribut *href* (hyper reference). Mit diesem gibt man an, auf welche Website man beim Klick weitergeleitet werden soll: `<a href="http://ksr.ch">Beim Link angezeigter Text.</a>`
   * Ein **Bild** fügt man wie folgt ein: `<img src="bild.jpg"/>`. Mit dem Attribut *src* (source) gibt man den Pfad zum Bild an. Befindet sich das Bild *im gleichen Ordner* wie das index.html File, so kann man einfach den Namen des Bildes inkl. Dateiendung (typischerweise .jgp oder .png) angeben. Von allen bisher betrachteten HTML-Elementen ist dieses das einzige, welches *kein Endtag* verlangt.

<box 100% round green|**Tipp: Arbeiten mit VSCode**>
VSCode ist ein hervorragender Editor mit vielen Features. Sehr praktisch ist, dass man **mehrere Zeilen gleichzeitig bearbeiten** kann. Dies ist zum Beispiel praktisch, um alle Elemente einer Liste gleichzeitig mit Tags zu versehen.
Um den Cursor gleichzeitig auf mehreren Zeilen zu haben: Ctrl+Alt+Up/Down (Windows) resp. Opt+Cmd+Up/Down (macOS).

Allgemein verfügt VSCode über viele Shortcuts:

   * Windows: [[https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf]]
   * macOS:   [[https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf]]

Sammlung wichtigster VSCode Shortcuts:

   * Mehrere Cursor: Ctrl+Alt+Up/Down / Opt+Cmd+Up/Down
   * Code Formatieren: Shift + Alt + F / Shift + Option + F

Sammlung wichtigster allgemeinder Shortcuts:

   * Speichern: CTRL + S / CMD + S
   * Select All: CTRL + A / CMD + A
   * Cut, Copy, Paste: CTRL + X,C,V / CMD + X,C,V
   * Fenster wechseln: ALT + Tab / CMD + Tab

</box>

===== - Website stylen mit CSS =====

**Ziel:** Website von vorherigem Auftrag mithilfe von CSS stylen.

==== Auftrag III ====

   1. Erstelle für deine **KSR-Website** vom letzten Auftrag eine **CSS-Datei** mit Namen `style.css` und füge binde sie im HTML-File ein. Wie geht das? -> Slides oder Theorie unten.\\ \\
   1. **Style** nun die Website im CSS-File so, dass sie **wie unten angegeben** aussieht. Farben, Abstände usw. sollen einigermassen übereinstimmen. Die benötigte Theorie findet man unten und in den Slides. Hilfe erhältst du unterhalb des Bildes.
   {{ :gf_informatik:web_sca:website_ksr_html_css.png?&200 |}}

++++Hilfe zu Abständen|

Vermeide manuelle Zeilenumbrüche mit `<br>`. Arbeite stattdessen mit **margins**.

Beispiel: Betrachte folgenden Codeausschnitt:
<code html>
<h2>Titel</h2>
<p>Ich bin ein Absatz.</p>
</code>
Falls der Abstand zwischen der h2-Überschrift und dem Absatz nicht gross genug ist, solltest du die Margin von h2-Überschriften (primär) und/oder der Absätze ändern. Dies hat auch den Vorteil, dass die Abstände zwischen h2 und p immer einheitlich sein werden, falls diese mehrfach vorkommen im Dokument.

++++

++++Hilfe zu Überschriften|

Um die Überschriften hinzukriegen ("Balken" mit genügend Abstand), musst du mit padding, margin und border arbeiten. Siehe dazu auch das Beispiel in den Slides.

++++
==== Theorie CSS ====

Mit **HTML** erstellen wir den //Inhalt// für unsere Webseite. Damit diese aber auch ansprechend dargestellt wird, **formatieren** wir sie mittels **Cascading Style Sheets** (CSS). Das Zusammenspiel zwischen HTML und CSS wird in den folgenden Grafiken visualisiert:

{{ :gf_informatik:web:html_css.png?400 |}}

{{ :gf_informatik:web_sca:html_css_3.jpg?400 |}}

=== Einbindung von CSS in HTML ===

Das CSS wird in einer separaten Datei (zum Beispiel `style.css`) gespeichert. Um unsere Webseite zu formatieren, verweisen wir im `head` der HTML-Datei wie folgt darauf:

<code html>
<html>
  <head>
    <title>Titel</title>
    <link rel="stylesheet" href="style.css" />
  </head>
  ...
</html>
</code>

Die Trennung von Formatierung und Inhalten ermöglicht es, dasselbe Format und den gleichen Stil auf viele verschiedene Seiten anzuwenden. Beispielsweise muss eine Zeitungs-Website ihr Format nur einmal definieren (und der Browser es nur einmal herunterladen), und es wird dann auf jeden Artikel angewendet.

=== Selektoren und Formatierungsregeln ===

Jede **CSS-Regel** besteht aus zwei Teilen:
  * dem **Selektor** - er bestimmt, für //welche// Elemente die Regel gilt, und
  * den **Formatierungsregeln** - diese definieren, wie die gewählten Elemente //aussehen// sollen und ist von Form: `<Attribut>:<Wert>`

Der einfachste Selektor besteht einfach aus dem HTML-Element (also dem Tag-Namen). Es gibt noch andere Selektoren, auf die wir hier nicht eingehen. Nach dem Selektor folgen geschweifte Klammern, die die Formatierungseigenschaften enthalten. Jede Eigenschaft wird gefolgt von einem Doppelpunkt, dem gewünschten Wert, und einem Semikolon.

== Beispiel 1 ==

Mit `<strong>...</strong>` können wir Text hervorheben, indem wir diesen fett erscheinen lassen. Nun wollen wir, dass dieser Text zusätzlich einen roten Hintergrund hat. Dazu fügen wir folgende CSS-Regel hinzu:
<code css>
strong {
  background-color: red;
}
</code>
Nach einem Reload zeigt unsere Webseite nun `<strong>` Elemente mit rotem Hintergrund an.

== Beispiel 2 ==

Ein etwas ausgereifteres CSS-File könnte wie folgt aussehen:
<code css>
body {
  background-color: lightgrey;
  font-family: sans-serif;
}
h3 {
  font-size: 5mm;
  color: darkgrey;
}
strong {
  background-color: red;
  padding: 1mm;
  border: 1px dashed black;
}
</code>

Wird diese in eine HTML-Datei eingebunden, sieht diese wie folgt aus:

<HTML>
<div style="border: 1px solid #ccc; border-radius: 4px; padding: 9.5px">
  <div style="background-color: lightgrey; font-family: sans-serif; padding: 8px;">
    <h1 style="border: 0;">Title</h1>
    <h3 style="font-size: 5mm; color: darkgrey; border: 0;">Section heading</h3>
    <p>My first paragraph, it's so <strong style="background-color: red; padding: 1mm; border: 1px dashed black;">strong</strong>!</p>
  </div>
</div>
</HTML>

=== Weiterführende Links ===

Die Website [[https://wiki.selfhtml.org/wiki/CSS|SelfHTML]] bietet sowohl eine **Einführung in CSS** als auch ein **Nachschlagewerk** für die tausenden von Eigenschaften, Layouts, und Tricks.
    * mehr zu [[https://wiki.selfhtml.org/wiki/Grafik/Farbe|Farben]]
    * mehr zu [[https://wiki.selfhtml.org/wiki/CSS/Wertetypen/Ma%C3%9Fangaben|Grössenangaben]]
    * mehr zu [[https://wiki.selfhtml.org/wiki/CSS/Tutorials/Typografie|Schriftformatierung]]

===== - Eigene Website (Auftrag IV) ======

=== Auftrag in Kürze ===
Erstelle mit HTML und CSS eine einfache Website, in der du etwas präsentierst, dass für die KlassenkollegInnen interessant sein dürfte.

**Zeit: 5L**

Beispiele:

   * Lieblingsrezept
   * Website zu deiner Kunst (Zeichnungen, Musik, \ldots)
   * Website zu dir


=== Auftrag im Detail ===

   1. Überlege dir ein Thema. Spreche es mit deinem **Lehrer** ab.
   2. Erstelle einen **neuen Ordner** für das Projekt mit Namen `fritz_meier_1mh`. Verwende also deinen Vornamen, Nachnamen und Klasse. Nur Kleinbuchstaben und Underlines anstelle Leerzeichen.
   3. Öffne diesen Ordner im VSCode und erstelle darin die folgenden Files: `index.html` und `style.css`.
   4. Schreibe jetzt den **Code** für deine Website.
   5. **Abgabe:**
      1. Erstelle ein **Zip-File** aus deinem Projektordner.
      1. Zip mit deinem Namen und Klasse **benennen** im Format `fritz_meier_1mh`.
      1. Abgabe per **Teams-Abgabe**. 

=== Kriterien ===

   * Muss mind. zwei Bilder enthalten
   * Muss verschiedene Überschriften beinhalten.
   * Inhalt muss korrekt und gut sein.
   * Korrekte Sprache, Rechtschreibung
   * Ansprechende Gestaltung mit CSS. Verwende die bisher gelernten Regeln.
   * Startseite muss `index.html` heissen.
   * Alle Dateien der Website befinden sich im gleichen Ordner. Keine Unterordner!
   * Darf keine absoluten Pfade enthalten. Korrekt: `<img src="my_image.png">` (relativer Pfad), Falsch: `<img src="C:\Benutzer\Fritz\Schule\Informatik\Web\Rezept\my_image.png">` (absoluter Pfad).

=== Bewertung ===

   * Der Auftrag muss *bestanden* werden.
   * Es gibt keine Note dafür. Dein HTML & CSS Knowhow wird in einer Prüfung überprüft. Dieses Projekt dient also der Prüfungvorbereitung.
   * Falls der Auftrag mehrheitlich aber nicht ganz zufriedenstellend erfüllt wurde, muss dieser punktuell nachgebessert werden.
   * Falls der Auftrag nicht zufriedenstellend ausgeführt wurde, muss eine neue Website zu einem neuen, vom Lehrer vorgegebenen Thema erstellt werden.

=== Optionale Features ===

   * Andere Medien als Bilder: Videos, Musik
   * Verwende JavaScript. Beispiel: Rezept, in dem man Anzahl Personen angeben soll, dann werden Mengenangaben entsprechend berechnet.
   * Responsive (andere Darstellung z.B. auf Smartphone)
   * Website mit mehreren Seiten (Navigation zw. Seiten)
   * ...



===== - JavaScript (optional) =====

Die weltweit am meisten verwendete Programmiersprache ist JavaScript, die Sprache, mit denen man Webseiten programmieren kann. 

==== JS einbinden ====

Erstelle ein File `script.js` (js für JavaScript) im gleichen Ordner wie das `index.html` File. Binde das JS-File nun im HTML ein, in dem du in dessen *head* die folgende Zeile hinzufügst:
<code html>
<html>
<head>
    ....
    <script src="script.js"></script>
</head>
<body>
    ....
</body>
</html>
</code>

Alle Sprachelemente wie Variablen, Schleifen, Verzweigungen und Funktionen gibt es auch in JavaScript - der Syntax (die Sprachregeln) sind nur etwas anders. Im folgenden Codeblock werden für alle kurze Beispiele gemacht.

==== Bemerkungen und Tipps ====

   * Alle Codezeilen müssen mit **Semikolon** enden.
   * Anstelle von Einrückungen wie in Python arbeitet man mit **geschwungenen Klammern** `{...}`, um Codeblöcke zu kennzeichnen.
   * Verwende **AutoComplete** in VSCode: Um z.B. eine for-Schleife zu programmieren, tippe `for`, wähle dann "$\square$ for" aus und drücke Enter und schon hast du das Grundgerüst für eine for-Schleife.
   * Verwende **ChatGPT** o.ä.
   * **Konsole im Browser:** Im JS-Code kannst du mit `console.log(...)` dort etwas ausgeben. Auch Fehler werden dort angezeigt. Die Browser-Konsole öffnet man wie folgt: Rechte Maustaste und ...
     * Chrome: "Untersuchen" -> "Konsole"
     * Safari (Mac): "Element-Informationen" -> "Konsole"


==== JavaScript Basics ====

Hier werden die wichtigsten Sprachelemente von JavaScript ganz kurz erklärt:

<code javascript>
// IN KONSOLE AUSGEBEN (quasi das print() von JavaScript)
console.log(42);

// VARIABLEN & KONSTANTEN
let x = 42; // Variablen benötigen let
const y = 43; // Konstanten sind wie Variablen, ausser dass sie sich nicht verändern lassen.
// im Zweifelsfall: einfach let verwenden

// WHILE-SCHLEIFE
let i = 0;
while (i < 10) {
    console.log(i);
}

// FOR-SCHLEIFE
for (let i = 0; i < 10; i++) {
    console.log(i);
}

// VERZWEIGUNG
x = 42;
if (x > 0) {
    console.log("Zahl positiv");
} else if (x === 0) {
    console.log("Zahl Null");
} else {
    console.log("Zahl negativ");
}

// FUNKTION
function mySquare(x) { // Deklaration der Funktion
    return x*x;
}

let sq = mySquare(5); // Funktionsaufruf
console.log(sq);

</code>

==== Beispiele für JS ====

=== Eingabe / Input ===

Im **HTML**-File:
<code html>
<input type="number" id="inputNumber" placeholder="Gib eine Zahl ein" onchange="handleKeyPress(event)">
// gibt andere types: wie text, date, password
// onchange="handleKeyPress(event)": JS-Funktion handleKeyPress wird aufgerufen, sobald Enter gedrückt wird
// alternativen zu onchange:
   // oninput: Aufruf sobald Input geändert
   // onkeydown, onkeyup
   // on...
</code>

Im **JavaScript**-File:
<code javascript>
function handleKeyPress(event) {
    let inputNr = document.getElementById("inputNumber"); // identifiziert HTML-Element über dessen ID
    console.log(inputNr.value); // und gibt dessen Wert aus
}
</code>

=== HTML-Element mit JS ändern ===

<code html>
<p>Die Zahl: <span id="spanNr"></span></p>
</code>

<code javascript>
// kann in JS über id direkte auf Element zugreifen:
spanNr.textContent = 41;
</code>

++++Alternative Methode|

Alternativ kann man mit `document.getElementById()` auf ein Element zugreifen, dieses in einer Variable speichern und über diese dann den Wert ändern.

Vorteil: Code etwas einfacher nachvollziehbar, gerade wenn länger ist.

Nachteil: mehr Code 

++++
==== Auftrag: Dies und das ====

**Idee:** Einfache Website mit JavaScript programmieren, die einige kleine (mehr oder weniger) nützliche Tools beinhaltet:

{{ :gf_informatik:web_sca:diesunddas_1.png?300 |}}
{{ :gf_informatik:web_sca:diesunddas_2.png?300 |}}

**Vorgehen:**

   1. **Zusammen "Schnapps-Bier-Sirup"** programmieren.
   1. Selber einige der restlichen Tool programmieren. Tipps:
      1. Siehe Tutorial oben und Tipps unten.
      1. Recherchiere selbst im Internet
      1. verwende AI (auf sinnvolle Art und Weise)
   1. Website mit CSS **stylen**
   1. eigene Idee(n) einbauen

++++Tipps Clicker|

   * Erstelle im JavaScript-Code eine Variable, z.B. `counter`, die zählt, wie oft man bereits geklickt hat.
   * Erstelle im HTML einen Button.
   * Über den Event `onclick` (ganz ähnlich wie `onchange` beim SBS) wird beim Klicken auf den Button ...
   * ... eine Funktion im JavaScript-Code aufgerufen, die die Variable `counter` um $1$ erhöht.
   * Vergesse auch nicht, den `counter` anzuzeigen.

++++

++++Tipps No Click no Fun|

   * Für die Wahrscheinlichkeit: mit `Math.random()` erzeugst du Zufallszahlen zwischen $0$ und $1$, z.B. $0.4159567158853703$. Wenn diese Zahl unter einem gewissen Wert ist, z.B. $0.1$ (also $10%$), wird counter zurückgesetzt.

++++

++++Tipps Würfel|

   * Mit `Math.floor(Math.random() * 6) + 1;` erzeugst du eine zufällige natürliche Zahl im Bereich von $1$ bis und mit $6$.
   * Für Anzeige des Würfels: verwende HTML-Element **canvas**. Recherchiere online.

++++

++++Tipps Buchstabenzähler|

   * Verwende ein Textfeld (textarea)

++++

===== - Fortgeschrittene Ausrichtung von HTML-Elementen (optional) =====

Bisher sind die Blockelemente wie Überschriften, Paragraphen usw. immer direkt *untereinander angeordnet* worden. Oftmals möchte man aber mehr Kontrolle über die Anordnung von HTML-Elementen haben und zum Beispiel mehrere Blockelemente nebeneinander haben. In modernen Websites ist es auch üblich, dass sich die Anordnung von Elementen je nach Bildschirmgrösse ändert, zum Beispiel:

^ **Breiter Bildschirm** (z.B. Laptop) ^ **Mittlerer Bildschirm** (z.B. Tablet) ^ **Schmaler Bildschirm** (z.B. Smartphone) ^
|{{:gf_informatik:web_sca:flex_breit.png?300|}} | {{:gf_informatik:web_sca:flex_mittel.png?200|}} | {{:gf_informatik:web_sca:flex_schmal.png?100|}}|

Zwei gängige Methoden dafür sind **Flexbox** oder **Grid**, welche beide hier kurz vorgestellt werden.

Für beide Methoden ist es üblich, mit dem **div**-Tag zu arbeiten. Dieses wird verwendet, um einen Block von Inhalten zu *gruppieren* und zu *strukturieren*. Es hat keine eigene Bedeutung oder Standardformatierung, dient aber als Container für andere Elemente und ermöglicht eine gezielte Gestaltung mit CSS oder eine Manipulation mit JavaScript.
==== Flexbox ====

{{youtube>phWxA89Dy94?}}
=== Getting Started ===

Es erlaubt eine einfache und flexible Anordnung von Elementen in einer Zeile oder Spalte.

Im HTML-Dokument erstellt man dafür mit dem div-Tag einen Container:
<code html>
<div class="container">
    <div class="item">Element 1</div>
    <div class="item">Element 2</div>
    <div class="item">Element 3</div>
</div>
</code>
Diesen Container kann man nun im CSS-File stylen. Um Flexbox zu aktivieren, füge folgenden Eintrag hinzu:

<code css>
.container{ /* da container class ist, muss Punkt vor Selektor schreiben */
    display: flex; /* flexbox aktivieren */
}
</code>
Nun werden die drei Elemente nicht mehr untereinander sondern nebeneinander angezeigt. Die Items können nun über ihren eigenen Selektor gestylt werden.

=== Ausrichtung ===

Flexbox arbeitet mit zwei Achsen: Einer **Hauptachse** und einer **Kreuzachse**. Standardmässig zeigt die Hauptachse horizontal nach rechts und die Kreuzachse vertikal nach unten. Elemente werden der *Hauptachse* entlang angeordnet. Man kann die beiden Achsen auch vertauschen und umdrehen:
<code css>
.container{
    display: flex;
    flex-direction: column; /* row, row-reverse, ... */
}
</code>

Inhalt wird standardmässig links- und oben-bündig ausgerichtet. Dies kann man wie folgt anpassen:
<code css>
.container{
    display: flex;
    justify-content: center; /* Ausrichten entlang Hauptachse */    
    height: 80vh; /* Setzt Höhe des Containers auf 80% Fenstergrösse */
    align-items: center; /* Ausrichten entlang Kreuzachse */
}
</code>

Werte für **justify-content:**
^ Wert ^ Beschreibung ^
|flex-start (Standard)|Links ausgerichtet|
|flex-end	|Rechts ausgerichtet|
|center	|Zentriert|
|space-between	|Erster & letzter Item am Rand, dazwischen gleichmässiger Abstand|
|space-around	|Gleichmässige Abstände um jedes Item|
|space-evenly	|Gleichmässige Abstände zwischen allen Elementen|

Werte für **align-items:**
^stretch (Standard)	^Items dehnen sich gleichmäßig^
|flex-start	|Oben ausgerichtet|
|flex-end	|Unten ausgerichtet|
|center	|Mittig ausgerichtet|
|baseline	|Orientierung an der Textbasis|
Achtung, damit man zum Beispiel etwas in der Mitte des Fensters platzieren kann, muss man dem Container eine genügend hohe Hohe verleihen, z.B. mit `height: 80vh;`.

=== Flex-Wrap ===

Standardmässig werden alle Elemente auf *einer Zeile* dargestellt. Mit *flex-wrap* kann man sie umbrechen:

<code css>
.container {
    display: flex;
    flex-wrap: wrap; /* Erlaubt Zeilenumbruch */
    align-content: center; /* nur aktiviert falls flex-wrap: wrap */
}
</code>

^Wert^Beschreibung^
|nowrap (Standard)	|Alle Elemente bleiben in einer Zeile|
|wrap	|Elemente umbrechen in die nächste Zeile|
|wrap-reverse	|Umbruch, aber in umgekehrter Reihenfolge|

Falls `flex-wrap: wrap;`, so wird die Ausrichtung entlang der Kreuzachse mit `align-content` anstelle `align-items` festgelegt.

=== Social Distancing ===

Zwischen den Elementen fügt man wie folgt einen **Abstand** hinzu:
<code css>
.container {
    display: flex;
    gap: 3em;
}
</code>

=== Kontrolle über einzelne Flex-Items ===

**Flex-grow** bestimmt, wie viel Platz ein Element im Vergleich zu anderen einnimmt. Im folgenden Beispiel teilen sich alle Items den gesamten zur Verfügung stehenden Platz zu gleichen Teilen:
<code css>
.item{
    flex-grow: 1
}
</code>
Falls ebenfalls der gesamte Platz gebraucht werden soll, das dritte Element aber doppelt so breit sein soll wie das erste, so schreibt man:
<code html>
<div class="container">
    <div class="item" id="item-1">Element 1</div> <!-- jedes Element erhält eigene ID um einzeln anzusprechen -->
    <div class="item" id="item-2">Element 2</div>
    <div class="item" id="item-3">Element 3</div>
</div>
</code>

<code css>
#item-1{
    flex-grow: 1;
}
#item-3{
    flex-grow: 3;
}
</code>

**Flex-shrink** bestimmt, ob ein Element schrumpfen darf, wenn nicht genug Platz da ist.
<code css>
.item {
  flex-shrink: 0; /* Verhindert das Schrumpfen */
}
</code>
Je grösser der angegebene Wert, desto *schneller schrumpft* es im Vergleich zu den anderen Elementen.

**Flex-basis** legt die Grundgrösse eines Elements fest.

<code css>
.item {
  flex-basis: 100px; /* Jedes Item startet mit 100px Breite */
}
</code>

=== Beispiel: Mehrere Bilder nebeneinander ===

Im folgenden Beispiel werden drei Bilder nebeneinander platziert.

**HTML:**
<code html>
<div class="container">
    <img src="image_1.jpg" alt="Image 1">
    <img src="image_2.jpg" alt="Image 2">
    <img src="image_3.jpg" alt="Image 3">
</div>
</code>

**CSS:**
<code css>
.container {
    display: flex; /* Aktiviert das Flexbox-Layout */
    flex-wrap: wrap; /* Erlaubt das Umbruchverhalten bei kleinen Bildschirmen */
    justify-content: center; /* Zentriert die Bilder */
    gap: 10px; /* Abstand zwischen den Bildern */
}

.container img {
    width: 300px; /* Grösse der Bilder */
}
</code>


==== Grid Layout ====

Mithilfe des **Grid Layout Modules** kann man seiner Website ein Raster zugrundelegen, welches sich dynamisch anpasst, z.B. wenn man die Fenstergrösse des Browsers verändert oder die Website auf einem Smartphone anschaut. Einzelne Elemente der Website können dann den Zellen des Rasters zugeordnet werden:

{{ :gf_informatik:web_sca:grid_layout.png?400 |}}


=== Grid Einrichten ===

Erzeuge im Body des HTML-Seite ein div-Element und weise diesem die Klasse 'Container' zu:
<code html>
<body>
    <div class="container">
        <!-- Füge hier alle Elemente hinzu, die im Grid angezeigt werden sollen -->
    </div>
</body>
</code>
**Klassen** sind **Selektoren**, genau so wie Elemente (h1, h2, strong, ...). Wir können diese also dann im CSS-File stylen:
<code css>
.container{
    property: value;
}
</code>
Beachte, dass vor einer Klasse im CSS immer ein Punkt geschrieben werden muss.

Die **Grundeinstellungen** im CSS für ein 4x3-Grid sehen wie folgt aus:
<code css>
body{
    margin: 0; /* damit kein Rand um Grid-Container */
}

.container {
    display: grid;
    width: 100vw; /* 100% der verfügbaren Breite */
    height: 100vh; /* 100% der verfügbaren Höhe */

    grid-template-columns: 1fr 2fr 2fr; /* drei Spalten, wobei die 2. und 3. beide doppelt so breit sind wie erste */
    grid-template-rows: 60px 1fr 1fr 50px; /* vier Zeilen, erste und letzte haben fix angegebene Höhe, ... */
    
    gap: 10px; /* gap um Elemente des Grids */
}
</code>
Nun wollen wir dem Grid ein **Elemente** hinzufügen, wie: header, footer, sidebar oder content.
Machen wir ein Beispiel:
<code html>
<div class="container">
    <div class="content">Content</div>
</div>
</code>

<code css>
.content{
    grid-column: 2 / 3; /* erste Zahl: in welcher Zeile beginnt, zweite Zahl: in welcher aufhört */
    grid-row: 2;
}
</code>
Mit `grid-column` und `grid-row` kann angegeben werden, über welchen Bereich des Rasters sich das Element erstreckt. Alternativ kann man auch `grid-column-start, grid-column-end, ...` verwenden.

=== Responsive Grid ===

Typischerweise möchte man, dass sich das Grid anpasst, wenn man eine Website auf einem kleineren Bildschirm wie einem Smartphone anschaut. Mit der folgenden **Medienabfrage** kann man angeben, wie sich die Darstellung ändern soll, wenn die Breite des Viewports unter einen gewissen Wert fällt:
<code css>
@media only screen and (max-width: 500px) {
    /* überschreibe hier für alle Selektoren, für die sich etwas ändern soll, die entsprechenden Werte, wie z.B. */
    .container{
        grid-template-columns: 1fr;
        /* ... */
    }
}
</code>
Falls ein Element in einer gewissen Situation gar nicht mehr angezeigt werden soll, z.B. die Sidebar in der Mobile-View, passe einfach seine `visibiliy` an:
<code css>
display: none;
</code>

Mehr Infos über **Medienabfragen (Media Queries)** wie diejenigen im Beispiel oben findest du zum Beispiel unter:
   * https://wiki.selfhtml.org/wiki/CSS/Media_Queries
   * https://www.w3schools.com/cssref/css3_pr_mediaquery.php

Die Website responsive zu machen ist ein wenig mühsam, wenn man die Ranges der einzelnen Grid Elemente wie oben beschrieben mit `grid-column` und `grid-row` festlegt, da man dann die CSS-Einträge sämtlicher Grid Elemente anpassen muss. Alternativ kann man mit `grid-template-areas` arbeiten, dann muss man nur Veränderungen im Eintrag für `.container{...}` vornehmen. Dazu muss man den Elementen einen Namen zuweisen und kann dann über die Namen die Zuteilung der Zellen vornehmen:
<code css>
.container {
    ...
    grid-template-areas: 
    "h h h"
    ...
    ;
    ...
}

.header{
    grid-area: h;
}
</code>
==== - Flexbox ====
===== Lösungen LP =====