<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	xmlns:series="http://unfoldingneurons.com/"
	>

<channel>
	<title>Guggat emol Blog &#187; Kleine Aufgabe um mit JavaScript Events rumzuspielen</title>
	<atom:link href="http://www.baldenhofer.eu/blog/tag/grundlagen/feed" rel="self" type="application/rss+xml" />
	<link>http://www.baldenhofer.eu/blog</link>
	<description>Roland bloggt über IT, Programmieren und Linux</description>
	<lastBuildDate>Tue, 25 Oct 2011 22:53:01 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3</generator>
		<item>
		<title>Kleine Aufgabe um mit JavaScript Events rumzuspielen</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/kleine-aufgabe-um-mit-javascript-events-rumzuspielen</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/kleine-aufgabe-um-mit-javascript-events-rumzuspielen#comments</comments>
		<pubDate>Thu, 28 May 2009 08:13:23 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[JavaScript]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=1212</guid>
		<description><![CDATA[Hier eine kleine Aufgabe: Du hast eine HTML Seite auf der eine Eingabemöglichkeit (z.B. eine Textarea oder ein Input Field) vorhanden ist. Fokus setzen Wenn du die HTML Seite lädst, wird der Cursor zuerst in dieses Eingabefeld positioniert. Ausgabe der eingegebenen Zeichen Wenn du in dem Eingabefeld etwas eingibst, dann wird jedes eingegebene Zeichen in [...]]]></description>
			<content:encoded><![CDATA[<p>Hier eine kleine Aufgabe:<br />
Du hast eine HTML Seite auf der eine Eingabemöglichkeit (z.B. eine Textarea oder ein Input Field) vorhanden ist.</p>
<h3>Fokus setzen</h3>
<p>Wenn du die HTML Seite lädst, wird der Cursor zuerst in dieses Eingabefeld positioniert.</p>
<h3>Ausgabe der eingegebenen Zeichen</h3>
<p>Wenn du in dem Eingabefeld etwas eingibst, dann wird jedes eingegebene Zeichen in einem Ausgabebereich (paragraph oder so&#8230;) erscheinen. Im Startzustand werden die Zeichen einfach wieder so ausgegeben wie sie vom Anwender eingegeben worden sind.</p>
<h3>Sonderfall Text falschrum ausgeben</h3>
<p>Wenn die Checkbox &#8220;Falschrum&#8221; angeklickt wird, dann werden alle eingegebenen Zeichen verkehrt herum in dem Ausgabefeld ausgegeben.</p>
<h3>Lösungsschritte</h3>
<ul>
<li>Schreibe zuerst auf, welche Mittel du zur Umsetzung einsetzten willst.</li>
<li>Beschreibe jede Datei die du erstellen willst.</li>
<li>Beschreibe welche Events du abfangen willst und warum du diese abfangen willst.</li>
<li>Schreibe die einzelnen Funktionen in Pseudocode. Also was muss bei der Initialisierung geschehen? Was wenn eine Taste gedrückt wurde?</li>
<li>Programmiere zuerst alles ausser den Sonderfall.</li>
<li>Wenn das klappt programmiere den Sonderfall.</li>
<li>Stelle die Ergebnisse auf das Blog damit andere es auch sehen können. (Natürlich nur, wenn du auf das Blog Zugriff hast wie Jozo zum Beispiel <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' />  )</li>
</ul>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/kleine-aufgabe-um-mit-javascript-events-rumzuspielen/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Aufbau und Funktionsweise einer Festplatte</title>
		<link>http://www.baldenhofer.eu/blog/unterricht/aufbau-und-funktionsweise-einer-festplatte</link>
		<comments>http://www.baldenhofer.eu/blog/unterricht/aufbau-und-funktionsweise-einer-festplatte#comments</comments>
		<pubDate>Fri, 22 May 2009 10:44:09 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Unterricht]]></category>
		<category><![CDATA[festplatte]]></category>
		<category><![CDATA[Grundlagen]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=1133</guid>
		<description><![CDATA[Jozo hat in seinem Artikel 10 Fragen zu den letzten Unterkapiteln mit ein paar Abkürzungen um sich geworfen Ich habe dabei gesehen, dass ihm der Aufbau und die Funktionsweise einer Festplatte nicht so ganz klar ist. Hier also mein Versuch, die Festplatte etwas ausführlicher zu erklären. Festplatte als Gerät (Device) Wenn du eine Festplatte kaufst [...]]]></description>
			<content:encoded><![CDATA[<p>Jozo hat in seinem Artikel <a href="http://www.baldenhofer.eu/blog/azubi-ecke/10-fragen-zu-den-letzten-unterkapiteln">10 Fragen zu den letzten Unterkapiteln</a> mit ein paar Abkürzungen um sich geworfen <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' /><br />
Ich habe dabei gesehen, dass ihm der Aufbau und die Funktionsweise einer Festplatte nicht so ganz klar ist.<br />
Hier also mein Versuch, die Festplatte etwas ausführlicher zu erklären.</p>
<h3>Festplatte als Gerät (Device)</h3>
<p>Wenn du eine Festplatte kaufst und in deinen Computer einbaust, wird diese zuerst einmal als Gerät erkannt.<br />
In Linux spricht man von Devices. Beispielsweise wird eine <a href="http://de.wikipedia.org/wiki/ATA/ATAPI">ATA (Advanced Technology Attachment)</a> Festplatte als /dev/hda erkannt und in dir als Blockdevice angeboten.<br />
<img src="/images/blog/festplatte/hd_oben.jpg" alt="Gute alte ATA Festplatte" /><br />
Das Device, also das Gerät als solches, ist die oberste Ebene der Speicherzuteilung. Du kannst in einen dicken Rechner mehr als eine Festplatte hineinschrauben und erhälst somit mehr Speicherkapazität.<br />
Bisher ist alles ganz einfach oder?</p>
<h4>Festplattensteuerung</h4>
<p>Wenn du dir deine Festplatte mal genauer anschaust, wirst du ein paar Chips vorfinden.<br />
<img src="/images/blog/festplatte/hd_unten.jpg" alt="Chips auf der guten alten ATA Festplatte" /><br />
In diesem Bild habe ich die Festplatte von unten fotografiert. Du kannst hier recht gut die verschiedenen Chips erkennen.<br />
Auf der Festplatte ist ein kleiner <a href="http://de.wikipedia.org/wiki/Mikrocontroller">Microcontroller</a> untergebracht der die Steuerung der Festplattenmechanik und die Datenübertragung zum Computer verwaltet.<br />
Weiterhin ist dort ein <a href="http://de.wikipedia.org/wiki/Festwertspeicher">ROM (Read Only Memory) Baustein</a> eingebaut, in dem sich die Steuerungslogik der Festplatte befindet.<br />
Deine Festplatte ist also ein kleiner Roboter, der in der Lage ist die Daten auf den einzelnen Platten zu verwalten.<br />
Bei den meisten Festplatten ist außerdem noch ein <a href="http://de.wikipedia.org/wiki/Random_Access_Memory">RAM (Random Access Memory)</a> als Datencache eingebaut worden.<br />
Dieses RAM speichert die von der Festplatte gelesenen Daten zwischen und ermöglicht so eine deutlich schnellere Lieferung der Daten an den Computer.</p>
<h4>Datenübertragungsschnittstelle</h4>
<p>Deine Festplatte muss irgendwie die Daten an den Computer übertragen können. Dazu hat sie Steckanschlüsse die du mit deinem Computer verbindest.<br />
<img src="/images/blog/festplatte/hd_anschluss.jpg" alt="Anschlüsse der guten alten ATA Festplatte" /><br />
Über diese Anschlüsse kommuniziert also der Computer mit der Festplatte.</p>
<h3>Platten und Köpfe</h3>
<p>Wenn du die Festplatte öffnest (mach das nur wenn du sie eh wegwerfen willst <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' />  ) dann wirst du die Platten und die Schreib-Leseköpfe der Festplatte finden.<br />
Ich habe die Festplatte heute zerstört und aufgebrochen. So sehen die Innereien der Festplatte aus:<br />
<img src="/images/blog/festplatte/hd_zylinder_spiegel.jpg" alt="Platten und Schreib-Lesekopf der Festplatte" /><br />
Du kannst eine Platte und die Leseköpfe recht gut erkennen.<br />
Die Daten werden auf der glatten, elektromagnetischen Oberfläche (Platte) abgelegt. Der Schreib-Lesekopf gleitet über die Oberfläche und kann die magnetischen Unterschiede erkennen.<br />
Also magnetisch = 1 und unmagnetisch = 0.<br />
Die Platten werden durch einen Motor angetrieben und drehen sich während des Betriebs mit sehr hohen Umdrehungszahlen.<br />
In den meisten Festplatten gibt es mehrere Platten und Schreib-Leseköpfe.<br />
Auch in der von mir zerstörten Festplatte ist das so:<br />
<img src="/images/blog/festplatte/zylinder_kopf.jpg" alt="Mehrere Platten" /><br />
<img src="/images/blog/festplatte/zylinder_detail.jpg" alt="Andere Platten Ansicht" /><br />
Wenn du die Schreib-Leseköpfe ausbaust, wirst du etwas Ähnliches, wie auf dem folgenden Bild, vorfinden:<br />
<img src="/images/blog/festplatte/kopf_detail.jpg" alt="Schreib-Leseköpfe" /><br />
In dieser Festplatte waren zwei Platten und vier Köpfe vorhanden.<br />
Das bedeutet, dass alle Oberflächen der Platten von den Köpfen abgetastet (gelesen und beschrieben) werden können.</p>
<h3>Wie funktioniert das jetzt?</h3>
<p>Wenn die Festplatte unter Spannung gesetzt wird, also wenn du den Rechner einschaltest, wird zuerst einmal die Festplattensteuerung aktiviert.<br />
Da es sich hierbei um einen Microcontroller handelt, wird der Program Counter (PC) des Microcontrollers zuerst auf die Startposition im ROM gesetzt.<br />
Dort findet der Microcontroller den ersten Befehl. Beispielsweise kann da stehen <strong>Starte den Motor für die Platten</strong><br />
Der Microcontroller schaltet dann den Motor für die Platten ein und die Platten beginnen sich zu drehen.<br />
Der nächste Befehl kann <strong>Warte bis die Platten die Endgeschwindigkeit erreicht haben</strong> lauten.<br />
Durch die Rotation wird ein Luftkissen auf der Oberfläche der Platten erzeugt. Die Schreib-Leseköpfe gleiten auf diesem Luftkissen und berühren die Oberfläche der Festplatte somit nicht.<br />
Das macht man, damit die Schreib-Leseköpfe die Oberfläche nicht zerkratzen und selbst nicht mechanisch abgenutzt werden.<br />
Ansonsten hättest du nach ein paar Betriebsstunden keine Leseköpfe mehr <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' /><br />
Wenn die Drehzahl erreicht ist, kann der Microcontroller die Schreib-Leseköpfe in die Platten einführen und das Lesen und Schreiben kann beginnen.<br />
Weiterhin wird der Microcontroller mit dem Computer zu kommunizieren anfangen.</p>
<h3>Cylinder Head Sector (CHS) Aufteilung</h3>
<p>Bei der <a href="http://de.wikipedia.org/wiki/Cylinder_Head_Sector">CHS</a> geht es darum, die Plattenoberflächen so aufzuteilen, dass die gespeicherten Daten auch wieder gefunden werden können.<br />
Schauen wir uns nochmal eine Skizze an, bei der die Platten, Zylinder und die Köpfe einer Festplatte gezeigt werden:<br />
<img src="/images/blog/festplatte/FestplatteKopfPlatte.png" alt="Skizze von Kopf und Zylinder" /><br />
In diesem Beispiel findest du drei Zylinder und fünf Köpfe. (Ok, ich war zu faul einen sechsten Kopf zu malen <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' />  )<br />
Du kannst hier also auf fünf Oberflächen Daten unterbringen.<br />
Wenn du dir die Festplatte von Oben anschaust, wirst du folgende Aufteilung vorfinden:<br />
<img src="/images/blog/festplatte/FestplatteZylinderSektor.png" alt="Skizze eines Sektors und einer Spur" /><br />
Deine Köpfe können auf den Platten an verschiedenen Positionen halt machen.<br />
Du kannst also auf parallel zueinander geordneten Spuren (Tracks) Daten ablegen.<br />
Diese Tracks werden Zylinder genannt.<br />
Jeder Zylinder ist wiederum in Sektoren unterteilt.<br />
Ein Sektor kannst du dir wie ein Kuchenstück vorstellen. Du kannst deinen Zylinder z.B. in 64 Kuchenstücke (Sektoren) aufschneiden.<br />
Auf deiner Platte kannst du somit auf z.B. 1024 Zylindern jeweils 64 Sektoren anlegen und dort Daten ablegen.<br />
Die Festplattenkapazität ergibt sich somit aus den Zylindern * Heads * Sektoren * Bytes pro Sektor.</p>
<h3>Logical Blog Addressing (LBA)</h3>
<p>Bei der <a href="http://de.wikipedia.org/wiki/Logical_Block_Addressing">LBA Methode</a> wird die Adressierung der Festplatte anders aufgeteilt.<br />
Die einzelnen Blöcke, in denen die Daten hinterlegt sind, werden hierbei logisch geordnet und dein Computer braucht sich nicht um die physische Geometrie der Festplatte kümmern.<br />
Somit kann der Computer z.B. Block 4242 direkt adressieren und muss sich nicht dafür interessieren auf welchem Zylinder und welchem Kopf zugegriffen werden muss.<br />
Das erledigt der Microcontroller der Festplatte für ihn.</p>
<h3>Fazit</h3>
<p>Eine Festplatte ist ein mechanisches Gebilde, das auf magnetischen Platten die Daten ablegt.<br />
Je nach Festplattensteuerung ist die Ansteuerung für den Computer über die physischen Eigenschaften der Festplatte gesteuert (CHS) oder es wird die Physik von der Festplattensteuerung versteckt und der Computer kann mit logischen Werten (LBA) zugreifen.<br />
Der Unterschied zwischen CHS und LBA liegt darin, dass der Microcontroller der Festplatte die Zugriffssteuerung vereinfacht und somit weniger Komplexität auf der Controller-Seite des Computers vorhanden ist.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/unterricht/aufbau-und-funktionsweise-einer-festplatte/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Einleitung des IT-Handbuchs für Fachinformatiker</title>
		<link>http://www.baldenhofer.eu/blog/azubi-ecke/gruende-fuer-verschiedene-fachrichtungen-bei-fachinformatikern</link>
		<comments>http://www.baldenhofer.eu/blog/azubi-ecke/gruende-fuer-verschiedene-fachrichtungen-bei-fachinformatikern#comments</comments>
		<pubDate>Mon, 11 May 2009 09:42:28 +0000</pubDate>
		<dc:creator>Jozo</dc:creator>
				<category><![CDATA[Azubi-Ecke]]></category>
		<category><![CDATA[Handbuch für Fachinformatiker]]></category>
		<category><![CDATA[bücher]]></category>
		<category><![CDATA[Fachinformatiker]]></category>
		<category><![CDATA[Grundlagen]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=996</guid>
		<description><![CDATA[Beschreibung im IT-Handbuch für Fachinformatiker Die theoretische Informatik betrachtet insbesondere die mathematisch-logischen Grundlagen, die der Verwendung und Programmierung von Computern zugrunde liegen. Somit ist der Schwerpunkt in dieser Fachrichtung die Mathematik Die technische Informatik beschreibt die elektronisch-technischen Eigenschaften der Bauteile, aus denen Computer zusammengesetzt sind. Dabei liegt der Schwerpunkt besonders in der Schaltalgebra, Digitaltechnik, Robotik, [...]]]></description>
			<content:encoded><![CDATA[<h3>Beschreibung im IT-Handbuch für Fachinformatiker</h3>
<ul>
<li>Die theoretische Informatik betrachtet insbesondere die mathematisch-logischen Grundlagen, die der Verwendung und Programmierung von Computern zugrunde liegen. Somit ist der Schwerpunkt in dieser Fachrichtung die Mathematik</li>
<li>Die technische Informatik beschreibt die elektronisch-technischen Eigenschaften der Bauteile, aus denen Computer zusammengesetzt sind. Dabei liegt der Schwerpunkt besonders in der Schaltalgebra, Digitaltechnik, Robotik, Systemmodellierung, sowie Hardware- und Systembeschreibung. Weiteres unter <a href="http://de.wikipedia.org/wiki/Technische_Informatik">teschnische Informatik auf Wikipedia</a></li>
<li>In der praktischen Informatik geht es im Großen und Ganzen um die Programmierung von Computern und die Mittel, die dazu erforderlich sind. Also z.B. um das Einsetzen von Betriebssystemen und Programmiersprachen-Compilern im praktischen Einsatz. Die Praktische Informatik sorgt für eine Vermittlung zwischen Theoretischer und Angewandter Informatik. man könnte also sagen, dass in der praktischen Informatik passende Lösungen für Anwender erstellt werden.<a href="http://www.informatik.uni-mainz.de/306.php"> Infos zum Studiengang praktische Informatik an der Uni Mainz</a></li>
<li>Die Angewandte Informatik ist das Teilgebiet der Informatik, welches Kenntnisse aus der Informatik anwendet, um diese dann für andere Wissenschaften oder Anwendungsgebiete herzustellen.  Zusätzliche Kenntnisse aus den anderen Fachrichtungen werden hier auch benötigt. <a href="http://de.wikipedia.org/wiki/Angewandte_Informatik">Angewandte Informatik</a> bei Wikipedia</li>
</ul>
<h3>Berufsgruppen</h3>
<p>Folgende Themengebiete sind sowohl für &#8220;Anwendungsentwickler&#8221; und &#8220;Systemintegratoren&#8221; wichtig.</p>
<ul>
<li>Mathematische und technische Grundlagen</li>
<li>Netzwerkgrundlagen</li>
<li>Betriebssystemgrundlagen</li>
<li>Windows</li>
<li>Linux und UNIX</li>
<li>Grundlagen der Programmierung</li>
<li>Projektmanagement</li>
<li>Datenbanken</li>
<li>XML</li>
<li>Weitere Datei- und Datenformate</li>
</ul>
<p>&#8220;Anwendungsentwickler erstellen hauptsächlich Software, welche vorgegebenen Anforderungen entsprechen muss.<br />
Der Schwerpunkt von &#8220;Systemintegratoren&#8221; liegt bei der Hardware und Netzwerktechnik.<br />
Je tiefer man in die jeweilige Fachrichtung geht desto komplexer werden sie und umso mehr unterschieden sich die Aufgabenbereiche. Daher ist auch eine Trennung der beiden Berufsgruppen ziemlich sinnvoll.</p>
<h3>Weitere Berufsgruppen</h3>
<p>IT-Systemelektronikern und IT-Systemkaufleuten sind Gemeinsamkeiten mit den anderen Fachinformatikern in den Grundlagen vorzufinden. Ansonsten sind diese Berufsfelder auch eine Spezialisierung. Vorallem im Bereich der Telekommunikationstechnik, was auch der Grund dafür ist, dass die meisten “IT-Systemelektroniker” für Telefongesellschaften beschäftigt sind.<br />
IT-Systemkaufleute sind im wesentlichen Kundenberater. Sie verfügen über technisches Know-how um eine Beratung optimal durchführen zu können. Weiterhin sind umfangreiche auch u.a. kaufmänische Techniken vorhanden um auch IT-Projkete “Betriebswirtschaftlich”(Analyse, Beratung, Marketing, Vertrieb usw.) zu betreuen.</p>
<h3>Was schliesse ich aus der Einleitung</h3>
<p>Die IT ist also eine Branche in der ebenfalls verschiedene Berufe bzw. Bereiche vorkommen, wie in anderen Branchen auch. Somit werden für jeden Beruf zwar gewisse allgemeine Grundkenntnisse verlangt, doch sobald es in die Tiefe der einzelnen Fachbereiche geht wird auch das notwendigen Wissen spezieller. Und diese notwendigen Kenntnisse erhält man in den einzelnen Ausbildungsberufen bzw. Studiengängen.</p>
<p>Der wissenschaftliche und technische Fortschritt haben zwar dazu beigetragen den Computer zu optimieren, die Grundfunktion ist aber prinzipiell identisch wie bei den ersten Modellen.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/azubi-ecke/gruende-fuer-verschiedene-fachrichtungen-bei-fachinformatikern/feed</wfw:commentRss>
		<slash:comments>3</slash:comments>
	
		<series:name><![CDATA[Handbuch für Fachinformatiker]]></series:name>
	</item>
		<item>
		<title>Aufgabe Ratespiel um Mengenlehre zu verwenden</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-ratespiel-um-mengenlehre-zu-verwenden</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-ratespiel-um-mengenlehre-zu-verwenden#comments</comments>
		<pubDate>Thu, 07 May 2009 04:18:24 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Unterricht]]></category>
		<category><![CDATA[Fachinformatiker]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[Mengenlehre]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=993</guid>
		<description><![CDATA[Zu den Grundlagen bei der Ausbildung zum Fachinformatiker gehört es dazu sich ein wenig mit der Mengenlehre auszukennen. Die große Frage ist da natürlich &#8220;Wieso soll ich Mengenlehre können, wenn ich doch nur programmieren will?&#8221; Und die Antwort darauf ist relativ einfach: Manchmal braucht man diese Grundfertigkeit um ein Programmierproblem zu lösen. Ratespiel Lass uns [...]]]></description>
			<content:encoded><![CDATA[<p>Zu den Grundlagen bei der Ausbildung zum Fachinformatiker gehört es dazu sich ein wenig mit der Mengenlehre auszukennen.<br />
Die große Frage ist da natürlich &#8220;Wieso soll ich Mengenlehre können, wenn ich doch nur programmieren will?&#8221;<br />
Und die Antwort darauf ist relativ einfach:<br />
Manchmal braucht man diese Grundfertigkeit um ein Programmierproblem zu lösen.</p>
<h3>Ratespiel</h3>
<p>Lass uns mal ein kleines Ratespiel basteln.<br />
In diesem Ratespiel geht es darum, dass der Computer sich ein paar Zufallszahlen zusammenkratzt und der Spieler diese erraten soll.<br />
Wenn der Spieler alle Zufallszahlen erraten hat, hat er gewonnen.</p>
<h4>Dokumentation</h4>
<p>Lese diese Aufgabe hier komplett durch und schreibe eine Dokumentation die alle benötigten Funktionen beinhaltet. Beschreibe zuerst die mathematischen Zusammenhänge der drei Mengen. Mach dir klar welche Komponenten du nacheinander erstellen musst.<br />
Beispielsweise kann die Highscore Verwaltung unabhängig vom Spiel erstellt werden. Du kannst also zuerst das Spiel erstellen und dann den Highscore. Oder anders herum.</p>
<h4>Initialisierung</h4>
<p>Erstelle mit JavaScript die notwendige Oberfläche.<br />
Diesmal muss der Anwender ein Eingabefeld bekommen, in dem er die jeweilige zu ratendene Zahl eingeben kann. Wenn er dies getan hat, drückt er den &#8220;Rate&#8221; Button und der Rechner kontrolliert, ob diese Zahl mit einer der zu erratenden übereinstimmt.<br />
Die Obermenge (also alle möglichen zu ratenden Zahlen) werden in einer Liste dargestellt.<br />
Die bisher verwendeten Zahlen sind eine Teilmenge und werden in einer zweiten Liste dargestellt.<br />
Falls der Anwender richtige Zahlen erraten hat, werden diese in einer dritten Liste dargestellt. Die Schnittmenge der erratenen Zahlen und der falsch geratenen Zahlen ergibt die Menge der Zahlen die der Anwender bisher eingegeben hat.<br />
Für Meldungen baust du wieder ein id=&#8221;message&#8221; Feld ein.<br />
Als Letztes soll noch eine Ausgabe erfolgen, die angibt wie häufig bisher eine Zahl geraten wurde.</p>
<h4>Verwaltung der Obermenge und der bisher verwendeten Zahlen</h4>
<p>Wenn der Anwender eine Zahl verwendet hat, wird diese in der Obermengenliste entfernt. Du musst also eine Funktion schreiben, die kontrolliert ob die geratene Zahl eine Teilmenge der Obermenge ist. Oder anders gesagt, du musst die Schnittmenge der bisher geratenen und der Obermenge durchführen.<br />
Falls dem so ist, wird sie aus der Obermengenliste entfernt und kontrolliert ob sie Teil der zu erratenden Untermenge ist.<br />
Falls die verwendete Zahl nicht in der Obermenge vorkommt, muss eine entsprechende Meldung ausgegeben werden. Also &#8220;Diese Zahl ist nicht innerhalb der möglichen zu erratenden Zahlen enthalten. Entweder hast du die Zahl schon verwendet oder sie liegt außerhalb des erlaubten Bereichs&#8221;.<br />
Die geratene Zahl wird entweder in der Liste der falsch geratenen Zahlen oder in der Liste der korrekt erratenen Zahlen geführt.</p>
<h4>Zählen</h4>
<p>Jedesmal wenn eine Zahl erraten wurde, wird der Spielzugzähler um eins erhöht und dargestellt.<br />
Logischerweise hat der Spieler gewonnen, der am wenigsten Spielzüge benötigt hat.</p>
<h4>Highscore Verwaltung</h4>
<p>Wenn der Spieler alle Zahlen erraten hat, wird die aktuelle Highscore Tabelle vom Server geladen und entsprechend angepasst. Das bedeutet, dass du auf dem Server die aktuelle Highscore Liste speichern musst. Diese muss vom Client geladen und manipuliert werden können. Hier darfst du frei entscheiden ob der Client diese Liste direkt verändert, oder einfach nur das Ergebnis zum Server schickt. Wichtig ist nur, dass der Client am Ende die Top 10 der besten Spieler anzeigt.</p>
<h3>Fazit</h3>
<p>Da wir uns mit Mengenlehre ein wenig auskennen, konnten wir die Verhältnisse der einzelnen Mengen (Obermenge und die Teilmengen Ergebnisse und falsch gewählte Zahlen) hiermit beschreiben. Wir können uns die einzelnen Mengen gut vorstellen. Dieses Beispiel zeigt, dass es sich auszahlt ein wenig Mengenlehre verstanden zu haben.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-ratespiel-um-mengenlehre-zu-verwenden/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Aufgabe Eingaben überprüfen Erweiterungen</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-eingaben-ueberpruefen-erweiterungen</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-eingaben-ueberpruefen-erweiterungen#comments</comments>
		<pubDate>Mon, 04 May 2009 08:28:07 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Unterricht]]></category>
		<category><![CDATA[Grundlagen]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=953</guid>
		<description><![CDATA[Bei der letzten Aufgabe wurden Werte zwischen -10 und 100 als erlaubte Werte definiert. Die Eingabeüberprüfung konnte daher mit dem ersten Tastendruck erfolgen. Was passiert wenn folgende Werte erlaubt sein sollen? -100 bis -20 0 bis 100 Aufgabe Schreibe eine neue Eingaberoutine, eine dafür angepasste HTML Seite, und was du sonst noch so brauchst um [...]]]></description>
			<content:encoded><![CDATA[<p>Bei<a href="http://www.baldenhofer.eu/blog/guggat_emol/aufgabe-eingaben-ueberpruefen-erweiterungen"> der letzten Aufgabe </a>wurden Werte zwischen -10 und 100 als erlaubte Werte definiert.<br />
Die Eingabeüberprüfung konnte daher mit dem ersten Tastendruck erfolgen. Was passiert wenn folgende Werte erlaubt sein sollen?</p>
<ul>
<li>-100 bis -20</li>
<li>0 bis 100</li>
</ul>
<h3>Aufgabe</h3>
<p>Schreibe eine neue Eingaberoutine, eine dafür angepasste HTML Seite, und was du sonst noch so brauchst um dieses Problem zu lösen.<br />
Beschreibe zuerst, was diesmal die Knackpunkte sind und schreibe entsprechend auf auf was du achten musst.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-eingaben-ueberpruefen-erweiterungen/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Lösungsvorschlag um Eingabefelder während der Eingabe mit JavaScript zu überprüfen</title>
		<link>http://www.baldenhofer.eu/blog/guggat_emol/loesungsvorschlag-um-eingabefelder-waehrend-der-eingabe-mit-javascript-zu-ueberpruefen</link>
		<comments>http://www.baldenhofer.eu/blog/guggat_emol/loesungsvorschlag-um-eingabefelder-waehrend-der-eingabe-mit-javascript-zu-ueberpruefen#comments</comments>
		<pubDate>Wed, 29 Apr 2009 14:59:30 +0000</pubDate>
		<dc:creator>Jozo</dc:creator>
				<category><![CDATA[Guggat emol]]></category>
		<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[JavaScript]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=961</guid>
		<description><![CDATA[Hier ein Lösungsvorschlag für die Aufgabe aus dem Artikel Eingabefelder während der Eingabe prüfen. Um diese Anwendung zu realisieren reicht HTML und JavaScript aus. Ausserdem arbeiten wir auf Client -Seite, und deswegen passt JavaScript doch eigentlich auch ganz gut. Für die Realisierung habe ich mal eine &#8220;eingabe.html&#8221; Seite erstellt welche wie erwünscht ein einfaches Eingabefeld [...]]]></description>
			<content:encoded><![CDATA[<p>Hier ein Lösungsvorschlag für die Aufgabe aus dem Artikel <a href="http://www.baldenhofer.eu/blog/it/programmieren/aufgabe-eingabefelder-waehrend-der-eingabe-ueberpruefen">Eingabefelder während der Eingabe prüfen</a>.</p>
<p>Um diese Anwendung zu realisieren reicht HTML und JavaScript aus. Ausserdem arbeiten wir auf Client -Seite, und deswegen passt JavaScript doch eigentlich auch ganz gut.</p>
<p>Für die Realisierung habe ich mal eine &#8220;eingabe.html&#8221; Seite erstellt welche wie erwünscht ein einfaches Eingabefeld beinhaltet und wie folgt aussieht.</p>
<div class="geshi no html">
<ol>
<li class="li1">
<div class="de1">&lt; !DOCTYPE html PUBLIC &quot;-//W3C//DTD XHTML 1.0 Strict//EN&quot; &quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd&quot;&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;html xmlns=&quot;http://www.w3.org/1999/xhtml&quot; xml:lang=&quot;de&quot; lang=&quot;de&quot;&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;head&gt;
</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &lt;title&gt;Eingabeoberfläche&lt;/title&gt;
</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &lt;script type=&quot;text/javascript&quot; src=&quot;initialize.js&quot;&gt;&lt;/script&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;/head&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;body onload=&quot;initialize();&quot;&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;p id=&quot;message&quot;&gt;Bitte gebe Zahlen zwischen -10 und 100 ein.&lt;/p&gt;
</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &lt;form&gt;
</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &lt;input type=&quot;text&quot; name=&quot;name&quot; id=&quot;input&quot; /&gt;
</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &lt;/form&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;/body&gt;
</div>
</li>
<li class="li1">
<div class="de1">&lt;/html&gt;</div>
</li>
</ol>
</div>
<p>Die JavaScript Datei mit dem Namen &#8220;initialize.js&#8221;, befüllt unsere HTML-Seite mit dem passenden Event &#8220;onkeyup&#8221;. Weiterhin befindet sich die Funktion inputCheck(), welche die Eingabe überprüft, ebenfalls in dieser Datei. Die Trennung der Initialiserung und der Funktion hab auch ich mir bei diesem kleinen Beispiel gespart. Hier nun die initialize.js</p>
<div class="geshi no javascript">
<ol>
<li class="li1">
<div class="de1"><span class="coMULTI">/**</span></div>
</li>
<li class="li1">
<div class="de1"><span class="coMULTI">&nbsp;* Schreibt den Event onkeyup in das Input-Feld.</span></div>
</li>
<li class="li1">
<div class="de1"><span class="coMULTI">&nbsp;*/</span></div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">function</span> initialize<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw2">var</span> inputField = document.<span class="me1">getElementById</span><span class="br0">&#40;</span><span class="st0">&quot;input&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; inputField.<span class="me1">setAttribute</span><span class="br0">&#40;</span><span class="st0">&quot;onkeyup&quot;</span>,<span class="st0">&quot;inputCheck();&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1"><span class="coMULTI">/**</span></div>
</li>
<li class="li1">
<div class="de1"><span class="coMULTI">&nbsp;* Die Funktion welche die Prüfung der Zahlen durchführt und passende Meldungen</span></div>
</li>
<li class="li1">
<div class="de1"><span class="coMULTI">&nbsp;* in den Paragraphen mit der id=&quot;message&quot; schreibt.</span></div>
</li>
<li class="li1">
<div class="de1"><span class="coMULTI">&nbsp;*/</span></div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">function</span> inputCheck<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw2">var</span> eingabe = document.<span class="me1">getElementById</span><span class="br0">&#40;</span><span class="st0">&quot;input&quot;</span><span class="br0">&#41;</span>.<span class="me1">value</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw2">var</span> messageField = document.<span class="me1">getElementById</span><span class="br0">&#40;</span><span class="st0">&quot;message&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="co1">// ist das eingabefeld leer wird wie die Ursrpüngliche Meldung angegeben.</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">if</span><span class="br0">&#40;</span>eingabe == <span class="st0">&quot;&quot;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; messageField.<span class="me1">innerHTML</span> = <span class="st0">&quot;Bitte gebe Zahlen zwischen -10 und 100 ein.&quot;</span>; </div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><span class="kw1">else</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="co1">// Ist die Eingabe kleiner oder gleich -11 &nbsp;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">if</span><span class="br0">&#40;</span>eingabe <span class="sy0">&lt;</span> = <span class="nu0">-11</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; messageField.<span class="me1">innerHTML</span> = <span class="st0">&quot;Die Zahl &quot;</span> +eingabe+ <span class="st0">&quot; ist zu klein&quot;</span>; </div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><span class="kw1">else</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="co1">// Ist die Eingabe kleiner oder gleich 100 und grösser oder gleich -10 </span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="co1">// ist das im gültigen Bereich.</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">if</span><span class="br0">&#40;</span>eingabe <span class="sy0">&lt;</span>= <span class="nu0">100</span> <span class="sy0">&amp;&amp;</span> eingabe <span class="sy0">&gt;</span>= <span class="nu0">-10</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; messageField.<span class="me1">innerHTML</span> = <span class="st0">&quot;Die Zahl &quot;</span> +eingabe+ <span class="st0">&quot; ist ok&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><span class="kw1">else</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="co1">// Ist die Eingabe grösser oder gleich 101, ist die Zahl zu gross</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">if</span><span class="br0">&#40;</span>eingabe <span class="sy0">&gt;</span>= <span class="nu0">101</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; messageField.<span class="me1">innerHTML</span> = <span class="st0">&quot;Die Zahl &quot;</span> +eingabe+ <span class="st0">&quot; ist zu gross&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span><span class="kw1">else</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="co1">// Falls die Eingabe keine Zahl ist (is Not a Number) wird ein unerlaubter </span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp;<span class="co1">// Wert gemeldet.</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw1">if</span><span class="br0">&#40;</span>isNaN<span class="br0">&#40;</span>eingabe<span class="br0">&#41;</span><span class="br0">&#41;</span><span class="br0">&#123;</span> </div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; messageField.<span class="me1">innerHTML</span> = eingabe+<span class="st0">&quot; ist ein unerlaubter Wert&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="br0">&#125;</span></div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
</ol>
</div>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/guggat_emol/loesungsvorschlag-um-eingabefelder-waehrend-der-eingabe-mit-javascript-zu-ueberpruefen/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Globale Variablen in JavaScript</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/globale-variablen-in-javascript</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/globale-variablen-in-javascript#comments</comments>
		<pubDate>Sat, 04 Apr 2009 05:58:11 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Unterricht]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[Variablen]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=834</guid>
		<description><![CDATA[Ich habe schon ein paar mal auf den Variablen in JavaScript rumgehackt. Doch irgendwie glaube ich, es kann helfen wenn man ab- und zu mal darüber schreibt. Vor kurzem bin ich über folgendes Konstrukt gestolpert: // some code &#8230;. function sayHello&#40;&#41;&#123; &#160; &#160; hello=&#34;huhu&#34;; &#160; &#160; alert&#40;&#34;hello&#34;&#41;; &#125; Ok, es war eine andere Funktion und [...]]]></description>
			<content:encoded><![CDATA[<p>Ich habe schon ein paar mal auf den Variablen in JavaScript rumgehackt. Doch irgendwie glaube ich, es kann helfen wenn man ab- und zu mal darüber schreibt.<br />
Vor kurzem bin ich über folgendes Konstrukt gestolpert:</p>
<div class="geshi no javascript">
<ol>
<li class="li1">
<div class="de1"><span class="co1">// some code</span></div>
</li>
<li class="li1">
<div class="de1">&#8230;.</div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">function</span> sayHello<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; hello=<span class="st0">&quot;huhu&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw3">alert</span><span class="br0">&#40;</span><span class="st0">&quot;hello&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
</ol>
</div>
<p>Ok, es war eine andere Funktion und alles war viel komplizierter. Aber die Aussage bleibt die Gleiche.<br />
Die Variable <strong>hello</strong> wird dem Wert &#8220;huhu&#8221; zugewiesen. Wenn du deine Fehlerkonsole öffnest, wirst du beim Ausführen dieses Codes eine Information erhalten.<br />
Diese Information besagt, dass eine Variable nicht initialisiert wurde.<br />
Eben, hello wurde nicht richtig deklariert. Was wir hier eigentlich wollen ist:</p>
<div class="geshi no javascript">
<ol>
<li class="li1">
<div class="de1"><span class="co1">// some code</span></div>
</li>
<li class="li1">
<div class="de1">&#8230;.</div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">function</span> sayHello<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw2">var</span> hello=<span class="st0">&quot;huhu&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw3">alert</span><span class="br0">&#40;</span><span class="st0">&quot;hello&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
</ol>
</div>
<p>Jetzt weiss der JavaScript Interpreter, dass es sich um eine lokale Variable handelt.<br />
Keine Information mehr in der Fehlerkonsole.</p>
<h3>Aber das ist nicht mal das Problem!</h3>
<p>Wenn man sportlich genug ist und es für unmännlich hält die Informationen in der Fehlerkonsole zu betrachten, dann ist die nicht Deklaration der hello-Varialben nicht so schlimm.<br />
Nur die Welt ist wie immer ein wenig grösser und komplexer.<br />
Die Variable hello ist nicht deklariert worden und der JavaScript Interpreter definiert nun, dass diese Variable eine globale Variable ist.<br />
Ok, sagt der Cowboy. Wenn ich nur ein Script schreibe weiss ich ja, dass ich nur eine hello Variable habe.<br />
Was unser Cowboy aver vergisst, ist dass unsere Scripte in andere Scripte eingebunden werden können.<br />
Programme haben die dumme Angewohnheit im Lauf der Entwicklung immer komplexer zu werden.<br />
Wenn du globale Variablen generierst, kannst du die Auswirkungen nicht überschauen. Es kann durchaus vorkommen, dass die globale Variable mehrfach in unterschiedlichen Funktionen verwendet wird.<br />
Und dann läuft plötzlich nichts mehr.<br />
Dann beginnt die Fehlersuche und der Frust.<br />
Sei also vorsichtig und erstelle immer korrekt deklarierte Variablen. Wenn eine Variable wirklich globall, also von überall aus erreichbar, sein soll, dann deklariere sie auch so.<br />
In unserem Monsterbeispiel können wir z.B. schreiben:</p>
<div class="geshi no javascript">
<ol>
<li class="li1">
<div class="de1"><span class="co1">// some code</span></div>
</li>
<li class="li1">
<div class="de1">&#8230;.</div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">var</span> hello=<span class="st0">&quot;huhu&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">function</span> sayHello<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw3">alert</span><span class="br0">&#40;</span><span class="st0">&quot;hello&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
</ol>
</div>
<p>oder</p>
<div class="geshi no javascript">
<ol>
<li class="li1">
<div class="de1"><span class="co1">// some code</span></div>
</li>
<li class="li1">
<div class="de1">&#8230;.</div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">var</span> hello = <span class="st0">&quot;&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="kw2">function</span> sayHello<span class="br0">&#40;</span><span class="br0">&#41;</span><span class="br0">&#123;</span></div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; hello = <span class="st0">&quot;huhu&quot;</span>;</div>
</li>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw3">alert</span><span class="br0">&#40;</span><span class="st0">&quot;hello&quot;</span><span class="br0">&#41;</span>;</div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
</ol>
</div>
<p>Und schon ist Lehrer Roland glücklich und zufrieden.<br />
Wir tippen zwar ein bisschen mehr, aber nun haben wir eher das Gefühl der Kontrolle <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' />  </p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/globale-variablen-in-javascript/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Gegen Schnittstellen (Interfaces) Programmieren</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/gegen-schnittstellen-interfaces-programmieren</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/gegen-schnittstellen-interfaces-programmieren#comments</comments>
		<pubDate>Sat, 28 Mar 2009 06:46:51 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[Interface]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=754</guid>
		<description><![CDATA[Es gibt in der IT eine wichtige Regel: Programmiere immer gegen Schnittstellen, nicht gegen Implementationen Toller Spruch gell? Was will uns diese Aussage sagen? Schau dir mal schnell die Abhängigkeiten dieser Klassen an: Direkte Verbindung von Klassen (ClassA und ClassB) Klasse A greift direkt auf Klasse B zu und verwendet die Methode getDataFromB(). Im Prinzip [...]]]></description>
			<content:encoded><![CDATA[<p>Es gibt in der IT eine wichtige Regel:<br />
<strong>Programmiere immer gegen Schnittstellen, nicht gegen Implementationen</strong><br />
Toller Spruch gell?</p>
<h3>Was will uns diese Aussage sagen?</h3>
<p>Schau dir mal schnell die Abhängigkeiten dieser Klassen an:<br />
<img src="/images/blog/grundlagen/directImplementation.png" alt="Klassen mit direkter Implementierung" /></p>
<h3>Direkte Verbindung von Klassen (ClassA und ClassB)</h3>
<p>Klasse A greift direkt auf Klasse B zu und verwendet die Methode getDataFromB().<br />
Im Prinzip ist damit nichts falsch. Die Daten von B sind versteckt und eigentlich ist doch alles gut oder?<br />
Naja, fast&#8230;</p>
<h4>Direkte Instanziierung der Klasse B</h4>
<p>Die Klasse A muss wissen, dass es Klasse B gibt. Sie muss die Klasse B instanziieren bevor sie sie verwenden kann und ist eng an Klasse B gebunden.<br />
Stell dir vor, Klasse B ist dafür geschrieben worden, seine Daten direkt aus dem Dateisystem zu beziehen. Klasse A zeigt die Daten dann schön an.<br />
Wenn wir jetzt nicht mehr Daten aus dem Dateisystem sondern über einen Webservice beziehen wollen, müssen wir eine andere Klasse B schreiben.<br />
Der Datenaustausch zu Klasse A mit getDataFromB() bleibt unverändert. Aber da wir nun in Klasse A nicht mehr auf Klasse B sondern auf eine ClassBWebservice zugreifen müssen, wird es kompliziert.<br />
Wir müssen zum Beispiel in Klasse A beide Klassen bekannt machen und verwalten. Also irgendwie einen Würgarround wie der hier:<br />
<img src="/images/blog/grundlagen/classAKnowsEverything.png" alt="Klasse A weiss alles" /><br />
Eklig gell?<br />
Die Klasse A muss alles über Klasse B wissen. Wir haben eine feste Kopplung zwischen den Klassen und eine Erweiterung oder Veränderung wird dazu führen, dass wir viele langweilige Stunden mit dem Flicken unseres schlechten Designs zubringen.<br />
Über die Testbarkeit und den Komplexitätsanstieg innerhalb unserer Applikation möchte ich gar nicht nachdenken!</p>
<p>Puh, erst mal wieder beruhigen&#8230;<br />
Schau dir nochmal das erste Bildchen an. Da habe ich Klasse E von Klasse D und die wiederum von Klasse C abgeleitet. Auch hier habe ich nicht gegen Interfaces programmiert sondern fröhlich abgeleitet.<br />
Auch das ist doch normalerweise super oder? Die drei Klassen haben alle die Methode getSomething() und wir mussten die nur einmal tippen und testen.<br />
Nie bin ich zufrieden <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_wink.gif' alt=';)' class='wp-smiley' /><br />
Bei der Krankheit der Ableiterittis haben wir das Problem, dass eventuell mal die Basisklasse eine Veränderung erfährt. Das bedeutet, dass wir eventuell ClassC gar nicht selbst erstellt haben, sondern jemand den wir gar nicht kennen. Wenn dieser Jemand nun die Implementierung seiner Klasse ändert, bricht unser Ableitungskartenhaus zusammen. Es gibt kaum üblere Fehler, als nach einem Jahr sich wieder um seinen alten Mist kümmern zu müssen da nach einem Update der Basisklassen einfach gar nichts mehr zusammenpasst.</p>
<h3>Glaubst du mir dass eine direkte Kopplung nicht so gut ist?</h3>
<p>Falls ja, dann schau dir mal das folgende Gemälde an:<br />
<img src="/images/blog/grundlagen/interfaces.png" alt="Einsatz eines Interfaces." /><br />
Ich habe jetzt ein Interface, also eine Schnittstelle zwischen ClassA und unseren ClassB Klassen eingebaut.<br />
Eine Schnittstelle ist eine Vereinbarung zwischen zwei Komponenten und beschreibt wie die Komponenten miteinander Daten und Funktionen austauschen sollen. Diese Vereinbarung sollte sich im Normalfall nicht mehr ändern. Ansonsten erweitern wir das Interface und vereinbaren weitere Schnittstellen. Die Entwickler der Klasse A können ihre Methoden &#8220;gegen die Deklaration im Interface&#8221; programmieren. Die Kollegen der Klasse B realisieren bei sich die Methoden und bieten somit eine sichere und eindeutig definierte Schnittstelle an.<br />
Wir haben zwar eine Beschreibung mehr eingeführt, der Mehraufwand hilft uns aber über das Interface beliebig Klassen miteinander zu verbinden.<br />
Zum Abschluss kannst du hier unser Interface mit ein paar mehr Klassen sehen:<br />
<img src="/images/blog/grundlagen/interfaceUsage.png" alt="Beispiel von mehreren Klassen die unser Interface verwenden." /><br />
Hier wird das Interface dazu verwendet die einzelnen Klassen B mit einer Testklasse zu überprüfen. Die SuperView zeigt unsere Daten noch viel toller an und erwartet die gleiche Interface Deklaration.<br />
Auf der anderen Seite wird eine Datenbankzugriffsklasse eingeführt. Die Methode getDataFromB() kann von der gleichen Testklasse überprüft werden, wie bei der Klasse B. Wir haben eine saubere Vereinbarung zwischen den betroffenen Komponenten.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/gegen-schnittstellen-interfaces-programmieren/feed</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>foreach Schleife</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/foreach-schleife</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/foreach-schleife#comments</comments>
		<pubDate>Thu, 19 Mar 2009 13:26:45 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[for]]></category>
		<category><![CDATA[foreach]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[PHP]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=572</guid>
		<description><![CDATA[Ich habe dir unter Arrays erklärt, dass bei PHP assoziative Arrays zum Einsatz kommen. Da man sehr häufig den Inhalt der Arrays aufsteigend bearbeiten muss, haben die klugen PHP Entwickler uns die foreach Schleife entwickelt. Wenn du also ein Array hast, z.B. $friends = array(&#8220;Karl&#8221; =&#62; &#8220;22.03.78&#8243;, &#8220;Brunhilde&#8221; =&#62; &#8220;12.12.56&#8243;, &#8220;Oda&#8221; =&#62; &#8220;23.04.68&#8243;, &#8220;Tonda&#8221; =&#62; [...]]]></description>
			<content:encoded><![CDATA[<p>Ich habe dir unter <a href="http://www.baldenhofer.eu/blog/it/programmieren/arrays-in-php">Arrays</a> erklärt, dass bei PHP assoziative Arrays zum Einsatz kommen. Da man sehr häufig den Inhalt der Arrays aufsteigend bearbeiten muss, haben die klugen PHP Entwickler uns die <a href="http://de3.php.net/foreach">foreach Schleife</a> entwickelt.</p>
<p>Wenn du also ein Array hast, z.B. <span class="code">$friends = array(&#8220;Karl&#8221; =&gt; &#8220;22.03.78&#8243;, &#8220;Brunhilde&#8221; =&gt; &#8220;12.12.56&#8243;, &#8220;Oda&#8221; =&gt; &#8220;23.04.68&#8243;, &#8220;Tonda&#8221; =&gt; &#8220;01.11.89&#8243;, &#8220;Gretchen&#8221; =&gt; &#8220;27.04.89&#8243;);</span>, dann kannst du über alle Schlüssel die dazugehörigen Werte auslesen.</p>
<div class="geshi no php">
<div class="head">foreach($friends as $name =&gt; $birthday){</div>
<ol>
<li class="li1">
<div class="de1">&nbsp; &nbsp; <span class="kw3">echo</span> <span class="st0">&quot;Freund &quot;</span><span class="sy0">.</span><span class="re1">$name</span> <span class="st0">&quot;hat am &quot;</span><span class="sy0">.</span><span class="re1">$birthday</span><span class="sy0">.</span><span class="st0">&quot; Geburtstag<span class="es0">\n</span>&quot;</span><span class="sy0">;</span></div>
</li>
<li class="li1">
<div class="de1"><span class="br0">&#125;</span></div>
</li>
</ol>
</div>
<p>Die Schlüssel werden an die Variable $name übergeben. Die Werte werden an die Variable $birthday übergeben.<br />
Mit der foreach() Schleife wird die Schreibweise der<a href="http://www.baldenhofer.eu/blog/it/programmieren/die-for-schleife"> for() Schleife</a> erweitert und für den Umgang mit assoziativen Arrays vereinfacht.</p>
<h3>Aufgabe</h3>
<p>Bau die hier dargestellte foreach() Schleife für $friends so um, dass anstatt mit foreach mit einer while-Schleife alle Freunde ausgegeben werden.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/foreach-schleife/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Arrays in PHP</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/arrays-in-php</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/arrays-in-php#comments</comments>
		<pubDate>Thu, 19 Mar 2009 08:54:03 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[array]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[PHP]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=570</guid>
		<description><![CDATA[In PHP werden sehr gerne und sehr häufig Arrays verwendet. Das Array in PHP ist sehr mächtig. Im PHP: Arrays &#8211; Manual ist ausführlich beschrieben wie Arrays in PHP verwendet werden. Eine Übersicht über die Array Zugriffsfunktionen ist unter der PHP: Arrays &#8211; Manual Übersicht Seite zu finden. Bitte schau dir diese Seiten genau an, [...]]]></description>
			<content:encoded><![CDATA[<p>In PHP werden sehr gerne und sehr häufig Arrays verwendet.</p>
<p>Das Array in PHP ist sehr mächtig. Im <a href="http://de.php.net/array">PHP: Arrays &#8211; Manual</a> ist ausführlich beschrieben wie Arrays in PHP verwendet werden. Eine Übersicht über die Array Zugriffsfunktionen ist unter der <a href="http://de.php.net/array">PHP: Arrays &#8211; Manual Übersicht</a> Seite zu finden. Bitte schau dir diese Seiten genau an, bevor du dich auf Arrays in PHP stürzt.</p>
<h2>Grundlegende Eigenschaften von Arrays</h2>
<p>Mit Arrays kannst du Werte in einer Liste anordnen. Beispiel:</p>
<p>Du willst jeden Tag eine Temperaturmessung durchführen und die aktuelle Temperatur in einer Liste darstellen.</p>
<p>Tag 0 =&gt; 20°C<br />
Tag 1 =&gt; 19°C<br />
Tag 2 =&gt; 16°C<br />
Tag 3 =&gt; 23°C<br />
Tag 4 =&gt; 22°C</p>
<p>Du kannst hier ein einfaches Array verwenden, in dem du die Temperaturen einträgst:</p>
<p><span class="code">$temperatures = array(20,19,16,23,22);</span><br />
Wenn du jetzt wissen willst, wie warm es am Tag 3 war, dann kannst du mit <span class="code">echo $temperatures[3];</span> die Temperatur auslesen.<br />
Dein Array beinhaltet 5 Werte, die du mit 0,1,2,3,4 auslesen kannst. Die Zahlen 0,1,2,3,4 sind die Schlüssel (Key) die auf die Werte (value) verweisen. Dein Array besteht somit aus Key =&gt; Value einträgen.</p>
<h2>Assoziative Arrays</h2>
<p>In einem einfachen Array werden die Werte über numerische Schlüssel wiedergefunden. Unsere Temperaturen wurden mit den numerischen Werten 0,1,2,3,4 erreicht.</p>
<p>Bei <a href="http://de.wikipedia.org/wiki/Assoziatives_Array">assoziativen Arrays</a> kann man nicht nur mit numerischen Werten auf die Values des Arrays zugreifen. Man kann sprechendere Schlüssel verwenden.</p>
<p>Beispiel:</p>
<p>Du hast Freunde, zu denen du das Geburtsdatum abspeichern willst. Deine Freunde werden mit dem Vornamen bestimmt. (Blödes Beispiel, aber immerhin ein Beispiel <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_smile.gif' alt=':)' class='wp-smiley' />  )</p>
<p>Hier sind deine Freunde: Karl =&gt; 22.03.78, Brunhilde =&gt; 12.12.56, Oda =&gt; 23.04.68, Tonda =&gt; 01.11.89, Gretchen =&gt; 27.04.89</p>
<p>Cool wäre doch, wenn man mit <span class="code">echo $friends["Oda"]</span> den Geburtstag von Oda erhalten könnte. Und genau das klappt mit PHP.<br />
Die assoziativen Arrays können wie folgt befüllt werden:<br />
<span class="code">$friends = array(&#8220;Karl&#8221; =&gt; &#8220;22.03.78&#8243;, &#8220;Brunhilde&#8221; =&gt; &#8220;12.12.56&#8243;, &#8220;Oda&#8221; =&gt; &#8220;23.04.68&#8243;, &#8220;Tonda&#8221; =&gt; &#8220;01.11.89&#8243;, &#8220;Gretchen&#8221; =&gt; &#8220;27.04.89&#8243;);</span><br />
Du kannst sogar noch einen weiteren Freund in dein Array einfügen indem du <span class="code">$friends["Jasmin"] = &#8220;13.03.80&#8243;;</span> schreibst.</p>
<h2>Arrays in Arrays</h2>
<p>Wenn du jetzt nicht nur den Geburtstag deines Freundes abspeichern willst, sondern auch noch sein Lieblingsessen das du ihm oder ihr zum Geburtstag kochen willst, kannst du dein Array entsprechend erweitern.</p>
<div class="geshi no php">
<div class="head">$friends = array();</div>
<ol>
<li class="li1">
<div class="de1"><span class="re1">$karl</span> <span class="sy0">=</span> <span class="kw3">array</span><span class="br0">&#40;</span><span class="st0">&quot;22.03.78&quot;</span><span class="sy0">,</span> <span class="st0">&quot;Käsespätzle&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div>
</li>
<li class="li1">
<div class="de1"><span class="re1">$jasmin</span> <span class="sy0">=</span> <span class="kw3">array</span><span class="br0">&#40;</span><span class="st0">&quot;13.03.80&quot;</span><span class="sy0">,</span> <span class="st0">&quot;Dampfnudel&quot;</span><span class="br0">&#41;</span><span class="sy0">;</span></div>
</li>
<li class="li1">
<div class="de1"><span class="re1">$friends</span><span class="br0">&#91;</span><span class="st0">&quot;Karl&quot;</span><span class="br0">&#93;</span> <span class="sy0">=</span> <span class="re1">$karl</span><span class="sy0">;</span></div>
</li>
<li class="li1">
<div class="de1"><span class="re1">$friends</span><span class="br0">&#91;</span><span class="st0">&quot;Jasmin&quot;</span><span class="br0">&#93;</span> <span class="sy0">=</span> <span class="re1">$jasmin</span><span class="sy0">;</span></div>
</li>
</ol>
</div>
<h3>Aufgabe</h3>
<p>Nimm das erzeugte $friends Array und gebe es mit <span class="code">print_r($friends);</span> aus. Schau dir die erzeugte Struktur an. Wie kannst du auf das Lieblingsessen von Karl zugreifen?</p>
<h2>Sortieren der Values von Arrays</h2>
<p>Wenn du ein Array sortieren willst, gibt es verschiedene Ansätze.</p>
<p>Zuerst einmal gibt es die <a href="http://de.php.net/manual/de/function.sort.php">sort() Funktion</a> in PHP. Diese Funktion nimmt die Values des Arrays und sortiert sie nach bestimmten Kriterien. VORSICHT! Es wird hierbei ein neues Array erzeugt in dem neue Schlüssel vergeben werden. Wenn du also ein assoziatives Array hast, in dem deine Keys keine numerischen Werte beinhalten, gehen deine Keys verloren.</p>
<h3>Aufgabe</h3>
<p>Erzeuge ein assoziatives Array, z.B. <span class="code">$namen = array(&#8220;Roland&#8221; =&gt; &#8220;Baldenhofer&#8221;, &#8220;Gert&#8221; =&gt; &#8220;Gertchen&#8221;, &#8220;Aaal&#8221; =&gt; &#8220;Adelbert&#8221;); und sortiere es mit sort(). Gebe das Ergebnis mit print_r() aus. Erkennst du den neu sortierten Aufbau deines Arrays?</span></p>
<h2><span class="code">Sortieren der Values unter Beibehaltung der Schlüssel</span></h2>
<p><span class="code">Wenn du nun deine Schlüssel beibehalten willst, deine Werte dennoch sortieren willst, dann kannst du die Funktion <a href="http://de.php.net/manual/de/function.asort.php">asort()</a> verwenden.</span></p>
<h3><span class="code">Aufgabe</span></h3>
<p><span class="code">Sortiere das $namen Array mit asort() und schau dir das Ergebnis an.</span></p>
<h2><span class="code">Sortieren der Keys</span></h2>
<p><span class="code">Sehr häufig möchtest du die Schlüssel eines Arrays sortieren und dann in richtiger Reihenfolge ausgeben. Hierfür ist die <a href="http://de.php.net/manual/de/function.ksort.php">ksort() Funktion</a> sinnvoll.</span></p>
<h3><span class="code">Aufgabe</span></h3>
<p><span class="code">Sortiere das $namen Array mit ksort() und schau dir das Ergebnis an.</span></p>
<p><span class="code">Arrays sind in PHP ziemlich komplexe Gebilde. Schau sie dir genau an und versuche zu verstehen wie sie funktionieren. Assoziative Arrays sind sehr mächtige Werkzeuge und sind daher entsprechend komplex. Wenn die Verarbeitung von Arrays mal Schwierigkeiten macht, überlege dir genau was eigentlich hinter diesen assoziativen Arrays steckt.<br />
</span></p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/arrays-in-php/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Kleiner Kurzeinschub zum Attributmodellieren</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/kleiner-kurzeinschub-zum-attributmodellieren</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/kleiner-kurzeinschub-zum-attributmodellieren#comments</comments>
		<pubDate>Tue, 17 Mar 2009 20:29:48 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Unterricht]]></category>
		<category><![CDATA[Grundlagen]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=689</guid>
		<description><![CDATA[Auf den Artikel Klasse hat Fritz sich gemeldet und eine kleine Diskussion zwischen Ute und sich begonnen. Ok, also wirklich nur eine kleine Diskussion&#8230; Er meinte, dass er dann wohl wahr und die Mädel dann wohl &#8230; sind. Daraufhin hat sich Ute gemeldet und war der Meinung je nach Programmierer ist er dann eher Falsch [...]]]></description>
			<content:encoded><![CDATA[<p>Auf den Artikel <a href="http://www.baldenhofer.eu/blog/it/programmieren/klasse">Klasse</a> hat Fritz sich gemeldet und eine kleine Diskussion zwischen Ute und sich begonnen. Ok, also wirklich nur eine kleine Diskussion&#8230;</p>
<p>Er meinte, dass er dann wohl wahr und die Mädel dann wohl &#8230; sind.</p>
<p>Daraufhin hat sich Ute gemeldet und war der Meinung je nach Programmierer ist er dann eher Falsch und sie ist dann Wahr.</p>
<p>Das hat mich darauf  gebracht mal kurz über die Modellierung von Attributen zu schreiben.</p>
<h3>Vorsicht beim Typvergeben</h3>
<p>Klar, der Witz mit Wahr und Falsch ist schon ziemlich bekannt. Aber dennoch. Je nachdem was du modellierst kannst du hinterher in ziemlichen Problemstellungen hängen bleiben.</p>
<p>Ich habe zum Beispiel mal für eine Bausparkasse programmieren dürfen. Die Leute dort waren nicht ganz so offen wie andere Menschen auf der Straße. In denen ihrer Welt gab es zum Beispiel eine true / false Entscheidung für die Information ob eine Ehe vorliegt. Was wir jedoch zusätzlich einbauen mussten war, dass die Ehe nur zwichen Mann und Frau, also zwischen true and false (oder war es false and true? <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_wink.gif' alt=';)' class='wp-smiley' />  ) stattfinden durfte.<br />
Ich hatte den Vorschlag gebracht, dass es wohl sinnvoll wäre auf die Gesetzeslage zu schauen und dann das System so zu bauen, dass auch true mit true und false mit false verheiratet sein darf.<br />
Dies wurde abgelehnt. Wir mussten dafür Sorge tragen dass true nie mit true und false nie mit false verkehren.<br />
Tja, vier Monate später wurde ein Gesetz erlassen, dass in Deutschland nun auch Männlein mit Männlein und Frau mit Frau eine Ehe eingehen dürfen.<br />
Der Aufwand um die Routinen wieder anzupassen war um etliches Größer als wenn wir gleich diese Option zumindest vorgesehen hätten.</p>
<p>Ein weiteres Problem kann darin bestehen, dass ein boolean nicht ausreicht und eventuell ergänzt werden muss.<br />
Hier ist es oft sinnvoller wirklich von true und false abzusehen und ein Enum, also eine Aufzählung zu verwenden.<br />
Dann kann man nämlich eine FRAU, MANN, KIND, JUGENDLICHER, NICHT_BESTIMMT, ALIEN einführen.<br />
Und schon kann man die Streiterei um Mann und Frau vergessen <img src='http://www.baldenhofer.eu/blog/wp-includes/images/smilies/icon_wink.gif' alt=';)' class='wp-smiley' /><br />
Je nachdem wo man sich befindet und was später noch alles mit dem Attribut passieren könnte, ist ein kurzer Check immer sehr lohnend.</p>
<p>Weil wahr ist falsch wenn nicht falsch gelle?  </p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/kleiner-kurzeinschub-zum-attributmodellieren/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Objekte</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/objekte</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/objekte#comments</comments>
		<pubDate>Fri, 13 Mar 2009 06:30:27 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[objekt]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=520</guid>
		<description><![CDATA[Wir haben die Eigenschaften unserer Datenmodelle in Klassen abgebildet. Wir haben somit Schablonen erstellt, die es uns erlauben Ausschnitte der realen Welt zu beschreiben. Mit Hilfe dieser Schablonen können wir nun unterschiedliche Datensätze erstellen. Wir können beispielsweise unsere Personenadresse Schablone verwenden und einzelne Personen anlegen. Dies wird bei den meisten Programmiersprachen mit dem new Operator [...]]]></description>
			<content:encoded><![CDATA[<p>Wir haben die Eigenschaften unserer Datenmodelle in <a href="http://www.baldenhofer.eu/blog/guggat_emol/klasse">Klassen</a> abgebildet. Wir haben somit Schablonen erstellt, die es uns erlauben Ausschnitte der realen Welt zu beschreiben.<br />
Mit Hilfe dieser Schablonen können wir nun unterschiedliche Datensätze erstellen. Wir können beispielsweise unsere Personenadresse Schablone verwenden und einzelne Personen anlegen. Dies wird bei den meisten Programmiersprachen mit dem <span class="code">new</span> Operator durchgeführt. Der new Operator nimmt die Schablone (die Klassendefinition) und fordert vom Betriebssystem den notwendigen Speicherplatz an. Beispiel in PHP:</p>
<p lang="php">$person1 = new PersonAddress();<br />
$person2 = new PersonAddress();</p>
<p>Hiermit sind zwei Objekte angelegt worden, die jeweils der Klassenschablone PersonAddress entsprechen.</p>
<p>Mit</p>
<pre lang="php">$person1-&gt;setVorname("Roland");</pre>
<p>kann nun dem ersten Objekt die Eigenschaft Vorname mit &#8220;Roland&#8221; belegt werden.</p>
<h2>Zusammenfassung</h2>
<p>Objekte nehmen das Verhalten der jeweiligen Klassen an und erlauben uns die einzelnen Datensätze und Eigenschaften der realen Welt in Programmen zu verwenden. Objekte sind Datencontainer die den Vorschriften der Klassenschablonen genügen. Jedes Objekt, dass von einer Klasse instanziiert wurde, reagiert nach außen hin gleich. Es beinhaltet jedoch normalerweise unterschiedliche Datensätze.</p>
<p>Wir werden in den nächsten Programmieraktionen sehr häufig mit Objekten und Klassen zu tun haben. Du wirst dieses Thema also mit &#8220;Learning by doing&#8221; erlernen.</p>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/objekte/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
		<item>
		<title>Klasse</title>
		<link>http://www.baldenhofer.eu/blog/it/programmieren/klasse</link>
		<comments>http://www.baldenhofer.eu/blog/it/programmieren/klasse#comments</comments>
		<pubDate>Mon, 09 Mar 2009 03:41:07 +0000</pubDate>
		<dc:creator>Roland</dc:creator>
				<category><![CDATA[Programmieren]]></category>
		<category><![CDATA[Grundlagen]]></category>
		<category><![CDATA[klasse]]></category>

		<guid isPermaLink="false">http://www.baldenhofer.eu/blog/?p=521</guid>
		<description><![CDATA[Bei der Programmierung werden Eigenschaften der realen Welt abstrahiert und für den jeweiligen Einsatzbereich beschrieben. Ein Beispiel: Wir wollen in einer Adressverwaltung eine Personenadresse beschreiben. Abstrahieren einer Personenadresse Nehmen wir mal einen normalen Menschen und versuchen ihn zu beschreiben. So ein normaler Mensch ist ein ziemlich komplexes Gebilde. Es ergibt ziemlich wenig Sinn für die [...]]]></description>
			<content:encoded><![CDATA[<p>Bei der Programmierung werden Eigenschaften der realen Welt abstrahiert und für den jeweiligen Einsatzbereich beschrieben. Ein Beispiel:</p>
<p>Wir wollen in einer Adressverwaltung eine Personenadresse beschreiben.</p>
<h2>Abstrahieren einer Personenadresse</h2>
<p>Nehmen wir mal einen normalen Menschen und versuchen ihn zu beschreiben. So ein normaler Mensch ist ein ziemlich komplexes Gebilde. Es ergibt ziemlich wenig Sinn für die Adressverwaltung einen Menschen wirklich beschreiben zu wollen. Wir benötigen ansonsten unendlich viele Eingabewerte, die für den Wohnort dieses Menschen nicht notwendig sind.</p>
<p>Ein kleiner Ausschnitt aus den Eigenschaften eines Menschen:</p>
<ul>
<li>Name (klingt gut für die Adressverwaltung)</li>
<li>Vorname (auch nicht schlecht)</li>
<li>Geschlecht (kann bei der Anschrift helfen)</li>
<li>Alter (Hä? Wozu bei einer Adressverwaltung?)</li>
<li>Nationalität (Ich Schwabe wohne in Baden. Wen interessiert das?)</li>
<li>Gewicht (Ja, ich bin für den aktuellen BMI einfach zu jung&#8230;)</li>
<li>Hautfarbe (???)</li>
<li>Religionszugehörigkeit (Bei einer Adresse?)</li>
<li>Hobbies (klar, was noch?)</li>
<li>Straße (Ja, das klingt gut)</li>
<li>Hausnummer (Auch schön)</li>
<li>Wohnort (genau!)</li>
<li>Postleitzahl (Macht das Versenden einfacher)</li>
<li>Schulabschluss (Hey, jetzt gehts wieder los&#8230;)</li>
</ul>
<p>Um nun eine Adressverwaltung für Deutschland zu bauen, kann also der Vorname, Nachname, das Geschlecht, die Straße, die Postleitzahl, die Hausnummer und der Wohnort ausreichen. Alle anderen Angaben gehen uns nichts an und helfen uns auch nicht weiter.</p>
<p>Wir können also jede Personenadresse klassifizieren und die angegebenen Eigenschaften zusammenfassen.</p>
<h2>Ok, jetzt haben wir eine Struktur und dann?</h2>
<p>Der Unterschied zu einer Datenstruktur ist bei der Klasse, dass wir die Eigenschaften vor anderen Programmteilen verstecken und nur über definierte Methoden auf die Eigenschaften Zugriff gewähren.</p>
<p>Der Vorname darf dann nur durch die Methode setVorname(vorname) gesetzt werden. Und der Vorname darf nur durch die Methode getVorname ausgelesen werden.</p>
<p>Die Kapselung ermöglicht uns, dass wir alle Setmethoden sicher gestalten können. Das bedeutet, niemand kann uns in die Eigenschaft Vorname ein Datum eintragen. Oder der Vorname kann nur dann verwendet werden, wenn auch ganz sicher ein Wert eingeschrieben ist. Wir können also verhindern, dass der Vorname einen leeren Wert besitzt. Unser Programm wird hierdurch stabiler und sicherer.</p>
<h2>Modellieren der Klasse Personenadresse</h2>
<p>Wir erstellen nun eine Schablone (Klasse) die uns eine Personenadresse beschreibt. Dort sind keine Daten drin, es handelt sich nur um die benötigte Beschreibung einer Personenadresse.</p>
<p>Wir fügen die Attribute ein:<br />
<img src="/images/blog/grundlagen/PersonenAdresseStructure.png" alt="PersonenAdresse Datenstrukturdarstellung" /><br />
Und wir fügen zu den Attributen die Zugriffsmethoden ein:<br />
<img src="/images/blog/grundlagen/PersonenAdresseKlasse.png" alt="PersonenAdresse Klasse die Attribute und Zugriffmethoden enthält." /><br />
Jetzt haben wir eine Schablone die beschreibt, wie auf Personenadressen zugegriffen werden soll und welche Eigenschaften für die jeweilige Personenadresse zutreffen. Die einzelnen Attribute sind vor einem direkten Zugriff geschützt. Wir können die einzelnen Methoden so schreiben, dass nur sinnvolle Werte in die Attribute, z.B. in den Vornamen, eingetragen werden.</p>
<h2>Ein paar interessante Links</h2>
<p>Hier ein paar Links, die sich zum Thema Klassen auslassen:</p>
<ul>
<li><a href="http://de.wikipedia.org/wiki/Klasse_(objektorientierte_Programmierung)">Wiki Klasse<br />
</a>Beschreibt die Eigenschaften von Klassen.</li>
<li><a href="http://wwwbruegge.in.tum.de/teaching/ws02/GrProg/folien/03_Klassen_Objekte.pdf">Grundlagen Objekte</a><br />
Eine Beschreibung wie Objekte und Klassen zusammen hängen</li>
</ul>
<hr /><h2>Ähnliche Beiträge</h2><ul></ul><hr /><small>www.baldenhofer.eu © seit 2009 <br />
Dieser Feed kommt vom <a href="http://www.baldenhofer.eu/blog">Guggat emol Blog</a>, viel Spa&#223; beim Lesen! &#220;ber  Links zu Artikeln freuen wir uns, jedoch bitte bindet nicht einfach unsere Inhalte in eure Seite ein, danke. Hinweis für Feedleser: Beiträge, die Quellcode enthalten sind auf der Webseite meist besser lesbar, als in einem Feed-Reader. 
<br /> 4e3744397ab2a417f811b29573bcbef4)</small>]]></content:encoded>
			<wfw:commentRss>http://www.baldenhofer.eu/blog/it/programmieren/klasse/feed</wfw:commentRss>
		<slash:comments>7</slash:comments>
	
		<series:name><![CDATA[Grundlagen]]></series:name>
	</item>
	</channel>
</rss>

