Verwendung von JSON-Daten innerhalb einer JavaScript-Anwendung

JSON (JavaScript Object Notation) in ein kompaktes Datenformat, mit dem komplexe Datenstrukturen abgebildet und zwischen Anwendungen ausgetauscht werden können. JSON erfreut sich zunehmender Beliebtheit, da im Vergleich zu XML weniger Verwaltungsdaten (Overhead) benötigt werden. In diesem Artikel stelle ich kurz vor, wie JSON innerhalb einer JavaScript-Anwendung verwendet werden kann.

Zunächst zeige ich die manuelle Erstellung eines JSON-Objektes. Im Anschluss gebe ich ein Beispiel dafür, wie ein JSON-Objekt durch die Instanziierung einer JavaScript-Klasse erzeugt werden kann. Im letzten Beispiel wird das JSON-Objekt durch Parsen eines JSON-Strings erzeugt.

Eine allgemeine Beschreibung des JSON-Formates ist auf JSON.org zu finden. Zudem wird in zahlreichen Artikeln auf StackOverflow das Thema JSON behandelt (JSON valid chars, Illegal characters in object or JSON key, Are there limitations for key names in JSON-files?).

Manuelle Erstellung

Im folgenden wird zunächst ein JSON-Objekt (manuell) erzeugt.
Mit Hilfe der Ausgabe-Funktion (ausgabe()) soll der Zugriff auf die einzelnen Teile des Objektes demonstriert werden.

Hinweis: ich verwende generell den UTF-8 Zeichensatz. Beim Nachprogrammieren muss dieser eventuell angepasst werden (siehe W3.org).

<html>
<head>
	<title>JavaScript und JSON</title>
	<meta charset="utf-8"/>
</head>
<body>
 
JSON-Demonstration.
<script>
/** Objekt mit dem Namen 'manuell'. */
manuell = {
  name: "Peter",
  tiernamen: ["Bello", "Miezie"],
  /* Felder können weitere Objekte enthalten. */
  auto: {
    /* Benennung der Felder ist Case-sensitiv. */
    SITZE: 4,
    kennzeichen: "A-BC-123"
  }
};
 
/** Ausgabefunktion */
function ausgabe(objekt) {
  alert(
    'Hallo!\n'
    + objekt.name + ' hat ' + objekt.tiernamen.length + ' Haustiere.\n'
    + 'Eines davon heißt: ' + objekt.tiernamen[0] + '.\n'
    + '\n'
    + 'Das Auto hat ' + objekt.auto.SITZE + ' Sitze.\n'
  );
}
 
ausgabe(manuell);
</script>
 
</body>
</html>

Objektoreintierte Programmierung in JavaScript

Zunächst werden die JavaScript-Klassen Person und Auto erstellt. Details zur Objektorientierten Programmierung mit JavaScript gibt es auf WebmasterPro.de.

/** Definition der Klassen. */
function Person(name, tiere, auto) {
	this.name      = name;
	this.tiernamen = tiere;
	this.auto      = auto;
}
function Auto(Sitze, Kennzeichen) {
	this.SITZE       = Sitze;
	this.kennzeichen = Kennzeichen;
}

Im Anschluss wird das Objekt instanziiert.

/* Objekt erzeugen. */
klasse = new Person(
             "Gerda",
             ["Fips", "Felix"],
             new Auto(7, "D-EF-456")
         );

Die Ausgabe erfolgt dann über:

ausgabe(klasse);

Parsen eines JSON-Strings

Strings, die ein JSON-Objekt repräsentieren, können mit Hilfe der jQuery-Funktion parseJSON() in ein JSON-Objekt umgeformt werden. Dabei ist zu beachten, dass die Schlüssel (keys) in Anführngszeichen stehen (also: {"name": "Gustav"} anstatt {name: "Gustav"}).

Zunächst muss jQuery in den Quelltext eingebunden werden. Dazu wird folgende Programmzeile innerhalb von <head>...</head> hinzugefügt.

<script src="http://code.jquery.com/jquery-2.1.0.min.js"></script>

Im Anschluss wird der String (hier aus der Variable json) geparst:

json =	'{'
     + '"name": "John",'
     + '"tiernamen": ["Flipper", "Blubb", "Goldie"],'
     + '"auto": {'
       + '"SITZE": 2,'
       + '"kennzeichen": "G-HI-789"'
       + '}'
     + '}';
jquery = jQuery.parseJSON(json);

Die Ausgabe der Daten erfolgt dann über:

ausgabe(jquery);

Gerade mit Referenz-Steigung in einen doppelt logarithmischen Plot in R eintragen

Ich stelle viele meiner Daten in Plots mit zwei logarithmischen Achsen dar. Oftmals kommt es in solchen Plots auf die Steigung der Kurve an, also den Exponenten eines Power laws. In solchen Fällen zeichne ich, zusätzlich zu den Daten, eine oder mehrere Geraden mit einer Referenz-Steigung ein. Dadurch kann der Betrachter abschätzen, in welchen Bereichen die Daten eher zu der einen oder der anderen Steigung tendieren. Ich fand es allerdings immer sehr mühsam diese Steigungen einzuzeichnen. Grund: Ein Teil der Anfangs- oder Endkoordinaten musste im logarithmischen Raum berechnet werden. Daher habe ich mir eine Funktion geschrieben, die mir anhand einer Anfangs-Koordinate, der Steigung, sowie einem Teil der Endkoordinate, den fehlenden Wert berechnet und die Referenz-Gerade in den Plot einzeichnet.

  1. Zunächst generiere ich Daten, die im doppelt-logarithmischen Plot eine Gerade ergeben:
    x = 1:1000
    y = x^-1.5
  2. Diese werden dann mit schön formatierten Achsen geplottet, wie im Artikel „Logarithmische Achsen in R-Plots formatieren“ beschrieben.
    library(package = "sfsmisc")
    #png("log-gerade.png", width=480, height=360)
    #par(cex =1.5, mar=c(4,4,0,0)+.01)
     
    plot(x, y, log="xy", xaxt="n", yaxt="n")
    sfsmisc::eaxis(side=1, at=10^c(0:3))
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))
     
    #dev.off()
    Darstellung einer Potenz-Funktion in einem Plot mit zwei logarithmischen Achsen.
    Darstellung einer Potenz-Funktion in einem Plot mit zwei logarithmischen Achsen.
  3. Der Exponent der von mir verwendeten Potenzfunktion ist -1.5. Daher ist auch die Steigung der Geraden m = -1.5. Nun möchte ich zusätzlich eine Gerade mit der Steigung m = -1 in den Plot eintragen. Diese soll bei am Punkt (x1 = 101, y1 = 10-1) beginnen. Enden soll die Gerade bei x2 = 2*102. Gesucht ist also die Y-Koordinate des Endpunktes (y2).

    Nun kann man:

    1. Alle vorhandenen x- und y-Werte logarithmieren (da beide Achsen logarithmisch sind).
    2. Diese Werte können in die Gleichung für die Berechnung der Steigung eingesetzt werden.
    3. Nun muss die Gleichung nach x2 aufgelöst werden (oder: die Gleichung auflösen lassen).
    4. Im Anschluss muss der x2-Wert in den Exponenten genommen werden.
    5. Über den Plot-Befehl kann nun eine Gerade zwischen den beiden Punkten (x1, y1) und (x2, y2) eingezeichnet werden.

    Diese Vorgehensweise habe ich in der Funktion refline() zusammengefasst:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    
    refline <- function(x1=NA, y1=NA, x2=NA, y2=NA, m=1, add=T, ...) {
      # Welchen Achsen (des letzten plots) sind logarithmisch?
      logX = par("xlog")
      logY = par("ylog")
     
      # Werte der logarithmischen Achsen umrechnen
      if(!is.na(x1) && logX) {x1 = log(x1)}
      if(!is.na(x2) && logX) {x2 = log(x2)}
      if(!is.na(y1) && logY) {y1 = log(y1)}
      if(!is.na(y2) && logY) {y2 = log(y2)}
     
      # Bestimmung der fehlenden Variablen
      if(is.na(x1)) {
        x1 = (y1 - y2 + m * x2) / m
        print("X1 wird berechnet")
      } else if(is.na(x2)) {
        x2 = (y2 - y1 + m * x1) / m
        print("X2 wird berechnet")
      } else if(is.na(y1)) {
        y1 = y2 + m * (x1 - x2)
        print("Y1 wird berechnet")
      } else if(is.na(y2)) {
        y2 = y1 + m * (x2 - x1)
        print(paste("Y2 wird berechnet", y2))
      }
     
      # Werte der logarithmischen Achsen umrechnen
      if(!is.na(x1) && logX) {x1 = exp(x1)}
      if(!is.na(x2) && logX) {x2 = exp(x2)}
      if(!is.na(y1) && logY) {y1 = exp(y1)}
      if(!is.na(y2) && logY) {y2 = exp(y2)}
     
      # Einzeichnen
      if(add) {
        lines(x=c(x1, x2), y=c(y1, y2), ...)
      }
     
      # Ausgabe
      data.frame(
        x1, y1, x2, y2, m
        , xmin=min(x1, x2), xmax=max(x1, x2)
        , ymin=min(y1, y2), ymax=max(y1, y2)
      )
    }

    Die Besonderheiten der Funktion refline() sind:

    • Es wird automatisch die fehlende Koordinate bestimmt.
    • Es wird erkannt, welche der Achsen logarithmisch sind.
    • Wichtige Werte der Geraden werden bei Aufruf zurückgegeben. Im Anschluss können sie verwendet werden, z.B. um Texte an die Enden der Geraden zu schreiben.
    • Die Gerade wird (auf Wunsch: add=T) in den vorigen Plot eingetragen.
    • Grafik-Parameter werden an den Plot-Befehl weitergeleitet (...).

    Nun kann refline() genutzt werden, um die oben genannte Gerade (sowie eine weitere Gerade) in den Plot einzuzeichnen. Die Variablen rl1 und rl2 dienen dazu, die Anfangs- und End-Punkte zu speichern. Mit den gespeicherten Werten werden Anschluss die Texte positioniert.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    
    #png("log-gerade_2.png", width=480, height=360)
    #par(cex =1.5, mar=c(4,4,0,0)+.01)
     
    plot(x, y, log="xy", xaxt="n", yaxt="n")
    sfsmisc::eaxis(side=1, at=10^c(0:3))
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))
     
    rl1 = refline(x1=1e1, y1=1e-1, x2=2e2, m=-1, col="red")
    text(x=rl1$x2, y=rl1$y2, labels=paste0(" Slope: ", rl1$m), adj=0, col="red")
     
    rl2 = refline(x1=8e0, y1=1e-2, x2=1e2, m=-2, col="blue")
    text(x=rl2$x2, y=rl2$y2, labels=paste0(" Slope: ", rl2$m), adj=0, col="blue")
     
    #dev.off()
    Darstellung einer Potenzfunktion mit einer Steigung von -1.5. Zusätzlich wurden Referenz-Steigungen von -1 und -2 eingezeichnet.
    Darstellung einer Potenzfunktion mit einer Steigung von -1.5. Zusätzlich wurden Referenz-Steigungen von -1 und -2 eingezeichnet.
  4. Hinweis: Als Parameter für die Funktion refline() muss ein vollständiges und ein unvollständiges Koordinaten-Tupel, sowie die gewünschte Steigung angegeben werden. Der Punkt (x2, y2) muss dabei nicht immer rechts vom Punkt (x1, y1) liegen. Vielmehr hängt es von den gewählten Werten ab, wie die Punkte zueinander liegen. Die Werte x1 und y1 bestimmen gemeinsam immer den einen Punkt und die Werte x2 und y2 gemeinsam den anderen Punkt.
  5. Wie ich oben bereits erwähnt habe, funktioniert die Berechnung des fehlenden Punktes der Gerade auch in Plots mit zwei linearen, oder nur einer logarithmischen Achse:
    Im Falle z.B. einer logarirhmischen Y-Achse werden dann nur die Y-Koordinaten logarithmiert. Hier einige Beispiele:

    # Linear
    plot(x, y)
    r1 = refline(x1=0, x2=500, y1=1, m=-0.0005, col="blue")
    text(x=r1$xmax, y=r1$ymin, labels=paste0(" Steigung: ", r1$m), adj=0)
     
    # Y-logarithmisch
    plot(x, y, log="y", yaxt="n")
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))
    r2 = refline(x1=10, x2=500, y1=1, m=-0.002, col="red")
    text(x=r2$xmax, y=r2$ymin, labels=paste0(" Steigung: ", r2$m), adj=0)

Zeichenketten in R zusammenfügen

Das Zusammenfügen von Zeichenketten (Konkatenieren von Strings) ist eine Standard-Aufgabe in allen Programmiersprachen. Auch bei der Programmierung in R wird die Funktion benötigt, wenn man z.B. Text dynamisch erzeugen lassen, oder den Wert einer Variablen an einen Text anfügen möchte. Die Funktion, die diese Aufgabe in R übernimmt, ist meiner Meinung nach etwas außergewöhnlich benannt. Mit diesem Artikel möchte ich mich selbst daran erinnern, dass sie paste() heißt.

Hier ein paar Beispiele, wie Zeichenketten (Strings) in verschiedenen Programmiersprachen zusammengefügt werden:

R
Die Funktion, mit der in R Strings zusammengefügt werden, heißt paste() (vom englischen „paste“ für „zusammenkleben“). Beispiel:

daten = c(1:10)
plot(daten, main=paste("Plot von",length(daten),"Werten."))

Mit der Funktion paste() werden durch Kommata getrennte Werte zusammengefügt. Dabei wird jedesmal ein Leerzeichen eingefügt. Wenn man die Zeichenketten ohne Leerzeichen zusammenfügen möchte, kann man entweder den Parameter sep="" setzen, oder die Funktion paste0() verwenden:

paste(sep="", "eins", "zwei") == paste0("eins", "zwei")
Java
In Java können Zeichenketten mit dem +-Operator verkettet werden:

String var = "eins";
var = var + "zwei" + "drei";
System.out.println(var);

oder mit dem +=-Operator:

String text = "Anfang";
text += "Ende";
System.out.println(text);

Sollte man sehr häufig Strings zusammenfügen, so empfiehlt sich die Verwendung eines StringBuffer-Objektes mit der Methode append() (siehe auch ChuckAndWayne-Blog):

StringBuffer b = new StringBuffer();
for (int i = 0; i<1000000; i++) {
	b.append("langer Text\n");
}
System.out.println(b);
bash
In der Bash können Variablen und Strings einfach direkt nacheinander geschrieben werden, um sie zusammenzufügen.

a="A"
b=$a"b"
echo $b
 
c="${b}c"
echo $c
 
echo $c "Bei echo können" "Leerzeichen zwischen" "den Strings sein."
 
d=$a$b
echo $d

Die bash unterstützt auch den +=-Operator:

c="Vorne"
c+=Hinten
echo $c

Für weitere Details siehe StackOverflow.

Um ganze Dateien zusammenzufügen, kann man den Befehl cat verwenden:

echo -e "Zeile 1, Datei 1\nZeile 2, Datei 1" > datei1.txt
echo -e "Zeile 1, Datei 2\nZeile 2, Datei 2" > datei2.txt
cat datei1.txt datei2.txt
PHP
In PHP können Strings mit Hilfe von . oder .= zusammengefügt werden:

<?php
$text = "Mein Text ";
$text .= "wird immer" . " " . "länger!";
echo $text;
?>
JavaScript
In JavaScript können Strings, ähnlich wie in Java, mit Hilfe des + und des +=-Operators aneinander gehängt werden:

<script>
var msg = "Nachricht";
msg += " wird";
msg = msg + " immer" + " länger";
alert(msg + "!");
</script>
C#
In C# können Strings mit Hilfe der Funktionen string.concat and string.join zusammengefügt werden. Siehe dazu den Blog von Alex James Brown.

Tabelle mit ASCII-Codes

Hin und wieder benötigt man beim Programmieren ASCII-Codes (z.B. für die Angabe von Symbolen in R-Plots). Daher zeige ich hier eine Liste der 128 ASCII-Zeichen, sowie deren Kodierung im Dezimalsystem, Hexadezimalsystem, Oktalsystem und Dualsystem. Die 128 ASCII-Zeichen umfassen 95 druckbare Zeichen und 33 Kontrollzeichen.

Weitere verwandte/ähnliche Zeichenkodierungen sind:

Zeichen/Abkürzung Dezimal Hexadezimal Oktal Binär Beschreibung
NUL 0 00 000 000 0000 Null character
SOH 1 01 001 000 0001 Start of Header
STX 2 02 002 000 0010 Start of Text
ETX 3 03 003 000 0011 End of Text
EOT 4 04 004 000 0100 End of Transmission
ENQ 5 05 005 000 0101 Enquiry
ACK 6 06 006 000 0110 Acknowledgment
BEL 7 07 007 000 0111 Bell
BS 8 08 010 000 1000 Backspace
HT 9 09 011 000 1001 Horizontal Tab
LF 10 0A 012 000 1010 Line feed
VT 11 0B 013 000 1011 Vertical Tab
FF 12 0C 014 000 1100 Form feed
CR 13 0D 015 000 1101 Carriage return
SO 14 0E 016 000 1110 Shift Out
SI 15 0F 017 000 1111 Shift In
DLE 16 10 020 001 0000 Data Link Escape
DC1 17 11 021 001 0001 Device Control 1 (often XON)
DC2 18 12 022 001 0010 Device Control 2
DC3 19 13 023 001 0011 Device Control 3 (often XOFF)
DC4 20 14 024 001 0100 Device Control 4
NAK 21 15 025 001 0101 Negative Acknowledgement
SYN 22 16 026 001 0110 Synchronous Idle
ETB 23 17 027 001 0111 End of Trans. Block
CAN 24 18 030 001 1000 Cancel
EM 25 19 031 001 1001 End of Medium
SUB 26 1A 032 001 1010 Substitute
ESC 27 1B 033 001 1011 Escape
FS 28 1C 034 001 1100 File Separator
GS 29 1D 035 001 1101 Group Separator
RS 30 1E 036 001 1110 Record Separator
US 31 1F 037 001 1111 Unit Separator
SP 32 20 040 010 0000
! 33 21 041 010 0001
34 22 042 010 0010
# 35 23 043 010 0011
$ 36 24 044 010 0100
% 37 25 045 010 0101
& 38 26 046 010 0110
39 27 047 010 0111
( 40 28 050 010 1000
) 41 29 051 010 1001
* 42 2A 052 010 1010
+ 43 2B 053 010 1011
, 44 2C 054 010 1100
45 2D 055 010 1101
. 46 2E 056 010 1110
/ 47 2F 057 010 1111
0 48 30 060 011 0000
1 49 31 061 011 0001
2 50 32 062 011 0010
3 51 33 063 011 0011
4 52 34 064 011 0100
5 53 35 065 011 0101
6 54 36 066 011 0110
7 55 37 067 011 0111
8 56 38 070 011 1000
9 57 39 071 011 1001
: 58 3A 072 011 1010
; 59 3B 073 011 1011
< 60 3C 074 011 1100
= 61 3D 075 011 1101
> 62 3E 076 011 1110
? 63 3F 077 011 1111
@ 64 40 100 100 0000
A 65 41 101 100 0001
B 66 42 102 100 0010
C 67 43 103 100 0011
D 68 44 104 100 0100
E 69 45 105 100 0101
F 70 46 106 100 0110
G 71 47 107 100 0111
H 72 48 110 100 1000
I 73 49 111 100 1001
J 74 4A 112 100 1010
K 75 4B 113 100 1011
L 76 4C 114 100 1100
M 77 4D 115 100 1101
N 78 4E 116 100 1110
O 79 4F 117 100 1111
P 80 50 120 101 0000
Q 81 51 121 101 0001
R 82 52 122 101 0010
S 83 53 123 101 0011
T 84 54 124 101 0100
U 85 55 125 101 0101
V 86 56 126 101 0110
W 87 57 127 101 0111
X 88 58 130 101 1000
Y 89 59 131 101 1001
Z 90 5A 132 101 1010
[ 91 5B 133 101 1011
\ 92 5C 134 101 1100
] 93 5D 135 101 1101
^ 94 5E 136 101 1110
_ 95 5F 137 101 1111
` 96 60 140 110 0000
a 97 61 141 110 0001
b 98 62 142 110 0010
c 99 63 143 110 0011
d 100 64 144 110 0100
e 101 65 145 110 0101
f 102 66 146 110 0110
g 103 67 147 110 0111
h 104 68 150 110 1000
i 105 69 151 110 1001
j 106 6A 152 110 1010
k 107 6B 153 110 1011
l 108 6C 154 110 1100
m 109 6D 155 110 1101
n 110 6E 156 110 1110
o 111 6F 157 110 1111
p 112 70 160 111 0000
q 113 71 161 111 0001
r 114 72 162 111 0010
s 115 73 163 111 0011
t 116 74 164 111 0100
u 117 75 165 111 0101
v 118 76 166 111 0110
w 119 77 167 111 0111
x 120 78 170 111 1000
y 121 79 171 111 1001
z 122 7A 172 111 1010
{ 123 7B 173 111 1011
| 124 7C 174 111 1100
} 125 7D 175 111 1101
~ 126 7E 176 111 1110
DEL 127 7F 177 111 1111 Delete

Quellen:

Linientypen, Symbole und Farben in R-Plots

R bietet verschiedene Möglichkeiten, seine Datenreihen in Plots unterscheidbar zu machen. Dazu gibt man in den Plot-Befehlen den zu ändernden Parameter, sowie einen Zahlenwert an. Ich vergesse allerdings immer, welche Zahl zu welcher Farbe oder zu welchem Linientyp gehört. Daher liste ich in diesem Artikel Zahlenwerte für folgende Parameter auf:

  1. Typen von Linien (lty).
    Beispiel: plot(c(1:10), type="o", lty=3).
  2. Farben (col).
    Beispiel: plot(c(1:10), type="o", col=4).
  3. Typen von Punkten / Sybole (pch; point character).
    Beispiel: plot(c(1:10), type="o", pch=5).

Linientypen

In R gibt es sechs verschiedene Typen von Linien. Die Zahlen für die Linientypen werden mit einer Periode von sechs „recycled“. Dadurch entspricht der Typ sieben (7) wieder dem Typen eins (1), eine Linie vom Typ acht (8) sieht aus wie eine Linie vom Typen zwei (2) und so weiter. Für jeden der Linien-Typen gibt es auch einen Namen (siehe auch Beschreibung des Parameters lty in der R-Hilfe zu par(): ?par):

  • 0: „blank“; unsichtbare Linie (=> wird nicht gezeichnet)
  • 1: „solid“
  • 2: „dashed“
  • 3: „dotted“
  • 4: „dotdash“
  • 5: „longdash“
  • 6: „twodash“
In R gibt es sechs verschiedene Typen von Linien, hier abwechselnd in rot und grün dargestellt. Jeder der Linientypen ist in 3 verschiedenen Größen (lwd=1-3) dargestellt. Die Werte für die Linientypen wiederholen sich in einer Periode von sechs. Daher entspricht die Angabe lty=7 der Angabe lty=1, die Angabe lty=8 entspricht der Angabe lty=2, und so weiter.
In R gibt es sechs verschiedene Typen von Linien, hier abwechselnd in rot und grün dargestellt. Jeder der Linientypen ist in 3 verschiedenen Größen (lwd=1-3) dargestellt. Die Werte für die Linientypen wiederholen sich in einer Periode von sechs. Daher entspricht die Angabe lty=7 der Angabe lty=1, die Angabe lty=8 entspricht der Angabe lty=2, und so weiter.

Das oben stehende Bild habe ich mit folgendem Code erzeugt:

1
2
3
4
5
6
7
8
# 6 Linientypen
png("linientypen.png")
par(mar=c(0,4,0,0)+.1, cex=1.5)
plot(1,1, type="n", ylim=c(0, 7), xaxt="n", xlab="", ylab="Linentyp (lty)", las=1)
abline(h=c(0:7),     lty=c(0:7), lwd=3, col=c(2,3))
abline(h=c(0:7)-0.2, lty=c(0:7), lwd=2, col=c(2,3))
abline(h=c(0:7)-0.4, lty=c(0:7), lwd=1, col=c(2,3))
dev.off()

Farben

In der Standard-Palette von R befinden sich acht verschiedene Farben. Dazu kommt noch der Wert 0, bei dem die Hintergrundfarbe als Farbe verwendet wird. Die Farben werden mit einer Periode von acht „recycled“. Durch diese fortlaufende Wiederholung, entspricht die Farbe neun (9) der Farbe eins (1), die Farbe zehn (10) wieder der Farbe zwei (2) und so weiter. Anstatt einer Zahl kann man auch direkt den RGB-Farbwert angeben (z.B. plot(1, 1, col="#000000") anstatt plot(1, 1, col=1) ). Weitere Details gibt es im Bereich „Color Specification“ in der R-Hilfe zu den Grafik-Parametern (?par).

In R gibt es acht verschiedene Farben. Hinzu kommt der Wert 0, bei dem die Hintergrundfarbe als Farbe verwendet wird (siehe diagonale Linie). Mit einer Periodenlänge von 8, werden die Farben wiederholt (wiederholte Farben sind mit einer dünnen Linie dargestellt).
In R gibt es acht verschiedene Farben. Hinzu kommt der Wert 0, bei dem die Hintergrundfarbe (hier: #eeeeee) als Farbe verwendet wird (siehe diagonale Linie). Mit einer Periodenlänge von 8, werden die Farben wiederholt (wiederholte Farben sind mit einer dünnen Linie dargestellt).

Für das vorangegangene Bild habe ich folgenden Code verwendet:

1
2
3
4
5
6
7
# 8 LinienFarben
png("linienfarben.png")
par(mar=c(0,4,0,0)+.1, cex=1.5, bg="#eeeeee")
plot(1,1, type="n", ylim=c(0, 11), xlim=c(0, 11), xaxt="n", xlab="", ylab="Linenfarbe (col)", las=1, lab=c(1,11,0))
abline(h=c(0:11), lty=1, lwd=c(rep(10,9), rep(1,9)), col=c(0:11))
abline(a=0, b=1, lwd=10, col=0)
dev.off()

Punkttypen / Symbole

Um den Punkttyp zu definieren, kann entweder ein einzelnes Zeichen oder eine Zahl angeben werden. In der Hilfe zum Befehl par() (?par oder ?graphics::par) steht dazu:

Note that only integers and single-character strings can be set as a graphics parameter (and not NA nor NULL)

Eine detaillierte Liste gibt es in der R-Hilfe zur Funktion points() (?points; Bereich „‚pch‘ values“). Hier eine kurze Zusammenfassung:

  • Zeichen 018: S-kompatible Vektor Symbole
  • Zeichen 1925: Weitere R Vektor Symbole. Die Zeichen 2125 können mit Hilfe von bg innerhalb des plot-Befehls (hier: points()) eingefärbt werden. Achtung: Die Angabe von bg innerhalb von points() hat hier eine andere Auswirkung als die Angabe von bg innerhalb von par() (z.B. par(bg="#ff00ff")). Durch letzteres setzt man die Hintergrundfarbe der gesamten Plot-Fläche.
  • Zeichen 2631: Werden ignoriert
  • Zeichen 32127: ASCII Zeichen

In der folgenden Grafik werden die die ersten 26 Zeichen dargestellt (+ zwei negative Werte).

Punkt-Typen für "pch"-Werte von -2 bis +25. Der Innernraum der Zeichen 21 bis 25 wurde durch die Angabe " bg='red' " innerhalb des Befehls "points()" rot eingefärbt.
Punkt-Typen für „pch“-Werte von -2 bis +25. Der Innernraum der Zeichen 21 bis 25 wurde durch die Angabe “ bg=’red‘ “ innerhalb des Befehls „points()“ rot eingefärbt.

Das oben stehende Bild wurde mit folgenden Befehlen erzeugt:

1
2
3
4
5
6
7
8
9
# 25 Punkt-Typen
png("punkttypen.png")
par(mar=c(0,4,0,0)+.25, cex=1.5)
plot(1, 1, type="n", ylim=c(-2, 25), xlim=c(0, 10), xaxt="n", xlab="", ylab="Punkttyp (pch)", las=1, lab=c(2,15,0))
abline(h=c(-2:25), lty=3, lwd=1, col="#cccccc")
for (typ in -2:25) {
  points(x=c(0:10), y=c(rep(typ,11)), pch=typ, bg="red")
}
dev.off()

Logarithmische Achsen in R-Plots formatieren

Im Gegensatz zu gnuplot, werden in R-Plots die logarithmische Achsen nicht sehr schön formatiert. Das Paket SFSmisc schafft hier Abhilfe. In diesem Artikel beschreibe ich Schritt für Schritt, wie man ansehnliche logarithmische Achsen für R-Plots erstellt.

  1. Als Beispiel sollen Daten geplottet werden, die in einem doppelt logarithmischen Plot eine Gerade ergeben:
    x = 1:1000
    y = x^-1.5
  2. Nun werden diese Daten mit dem Befehl plot() in einem Koordinatensystem mit logarithmischer X- und Y-Achse (log="xy") dargestellt:
    plot(x, y, log="xy")

    Dabei kann man erkennen, dass es keine kleinen Striche zur Unterteilung der Bereiche zwischen den einzelnen Größenordnungen gibt:

    Plot mit logarithmischen Achsen. Standardmäßig werden keine Striche zwischen den Größenordnungen eingezeichnet.
    Plot mit logarithmischen Achsen. Standardmäßig werden keine Striche zwischen den Größenordnungen eingezeichnet.
  3. Es ist aber durchaus üblich, den Bereich zwischen zwei Größenordnungen mit 8 kleinen Strichen zu unterteilen. Diese Striche zeigen an, an welchen Stellen 20%, 30%, 40%, 50%, 60%, 70%, 80% oder 90% der folgenden Größenordnung erreicht wurden. Um das in R zu bewerkstelligen, muss zunächst das Paket SFSmisc installiert werden (siehe dazu auch: Funktion aus einem bestimmten R-Paket laden):
    # Installation
    install.packages("sfsmisc", dependencies=T)
    # Paket laden
    library(package = "sfsmisc")
  4. Im Anschluss plotten wir die Daten erneut, aber ohne dabei die Achsen zu beschriften (xaxt="n", yaxt="n"). Die Beschriftung der Achsen wird im Anschluss mit Hilfe des Befehls eaxis() aus dem Paket SFSmisc hinzugefügt:
    plot(x, y, log="xy", xaxt="n", yaxt="n")
    sfsmisc::eaxis(side=1)   # X-Achse
    sfsmisc::eaxis(side=2)   # Y-Achse

    Im neuen Plot sind nun auf jedenfall acht Striche zur Unterteilung einer Größenordnung zu sehen:

    Erstellt man die Achsen eines Plots mit Hilfe des Befehls eaxis() aus dem Paket SFSmisc, so wird der Bereich zwischen zwei Größenordnungen in neun Teile unterteilt. Eventuell werden aber nicht nur die Zahlen für die Größenordnungen eingetragen, sondern auch für dazwischen liegende Werte (hier z.B. 5, 50 und 500).
    Erstellt man die Achsen eines Plots mit Hilfe des Befehls eaxis() aus dem Paket SFSmisc, so wird der Bereich zwischen zwei Größenordnungen in neun Teile unterteilt. Eventuell werden aber nicht nur die Zahlen für die Größenordnungen eingetragen, sondern auch für dazwischen liegende Werte (hier z.B. 5, 50 und 500).

    In diesem Beispiel wurde nicht explizit angegeben, welche Zahlen auf den Achsen zu sehen sein sollen. Daher sind nicht nur die Größenordnungen, sondern auch Werte dazwischen, als Zahlen eingetragen.

  5. Daher kann man nun noch explizit angeben, welche Zahlen sichtbar sein sollen (at=)
    plot(x, y, log="xy", xaxt="n", yaxt="n")
    sfsmisc::eaxis(side=1, at=10^c(0:3))
    sfsmisc::eaxis(side=2, at=10^c(-4,-2,0))

    In diesem Plot wurden nur Zahlen für die Größenordnungen angegeben. Auf der X-Achse wurde jede, auf der Y-Achse nur jede zweite Größenordnung mit einer Zahl versehen.
    In diesem Plot wurden nur Zahlen für die Größenordnungen angegeben. Auf der X-Achse wurde jede, auf der Y-Achse nur jede zweite Größenordnung mit einer Zahl versehen.

Apple Befehlstaste (⌘) in Blog-Artikeln verwenden

Gelegentlich muss ich an einem Apple-Gerät (meist einem iMac) arbeiten. Über meine Erfahrungen berichte ich unter anderem in diesem Blog. Daher komme ich nicht drumherum, die Befehlstaste (; Command key) in den ein oder anderen Beitrag einzufügen.

Dafür gibt es zwei Möglichkeiten:

  • Zum einen kann man das ⌘-Zeichen direkt in den Quelltext (oder das Editor-Fenster) kopieren. Das funktioniert bei mir, da ich in der Regel den UTF-8 Zeichensatz für meine Blogs und Internetseiten verwende.
  • Falls man nicht den UTF8-Zeichensaz verwendet, kann man auch den Unicode-Befehl (&#8984;) in seinen Quelltext einbauen:
    1
    
    Das &#8984;-Zeichen über den HTML-Befehl &amp;#8984; einfügen.

    Das ergibt:

    Das ⌘-Zeichen über den HTML-Befehl &#8984; einfügen.

Hinweis: Einige Browser können das Zeichen nicht darstellen (z.B. der Standard-Browser auf meinem Android-Tablet).

Die Version installierter Pakete im Terminal herausfinden

Kürzlich sollte ich einem Administrator die Version der VMware-Tools mitteilen, die auf meiner virtuellen Maschine installiert waren. Allerdings war (und ist) mir kein Befehl bekannt, mit dem ich diese Informationen direkt von Programmen des Paketes erhalten kann. Es ist aber möglich, die Version des installierten Paketes über den Debian Paketmanager (dpkg) zu ermitteln (UbuntuUsers-Forum).

Dazu lässt man sich zunächst (mit Hilfe von dpkg) eine Liste von Kurzbeschreibungen aller installierten Pakete ausgeben. Mit Hilfe von grep lässt man allerdings nur diejenigen Zeilen anzeigen, in denen der Namen des Paketes vorkommt (in meinem Falle open-vm-tools):

dpkg -l | grep open-vm-tools

In der Ausgabe kann man dann die Version ablesen:

ii  open-vm-tools  2012.05.21-724730-0ubuntu2  i386  tools and components for VMware guest systems (CLI tools)

In meinem Falle konnte der Administrator die virtuelle Maschine problemlos über den vSphere-client neu starten.

Ubuntu-Version im Terminal herausfinden

Wer ganz schnell die Version seiner Linux-Distrbution herausfinden möchte, kann dazu den Befehl lsb_release verwenden (siehe auch Ubuntu-Hilfe und UbuntuUsers-Forum). Durch diesen Befehl erhält man Informationen über allgemeine Linux Schnittstellen (Linux Standard Base; LSB), sowie Distributions-spezifische Informationen.

  • Nach der Eingabe von:
    lsb_release -a

    erhält man z.B.:

    No LSB modules are available.
    Distributor ID:	Ubuntu
    Description:	Ubuntu 12.10
    Release:	12.10
    Codename:	quantal
  • Weitere Informationen über mögliche Parameter erhält man in den Manpages (Online Manpage zu lsb_release):

    man lsb_release
  • Eine andere (weniger umfangreiche Methode) habe ich auf aphilia.info gefunden:
    cat /etc/issue

    Mit dem Resultat:

    Ubuntu 12.10 \n \l
    

Meine TeXstudio-Makros

TeXstudio wurde erstellt, um die Arbeit mit LaTeX zu vereinfachen. Eine Möglichkeit ist die Verwendung sogenannter Makros (oder Macros). Mit der Hilfe von Markos kann man umfangreiche Anweisungen ausführen lassen oder LaTeX-Anweisungen in den Quelltext einfügen. In diesem Artikel liste ich solche Markos auf, die ich derzeit verwende. Weitere Möglichkeiten von Makros werden im Handbuch von TeXstudio beschrieben.

Makros können in TeXstudio unter Makros / Makros bearbeiten verwaltet werden. Ich benutze Makros vor allem um LaTeX-Anweisungen direkt beim Tippen in meinen Quelltext einfügen zu lassen. Dazu dienen Auslöseimpulse (Trigger) und deren Abkürzungen (Abbreviations). Legt man z.B. ein Makro mit dem Trigger BILD an, so wird nach der Eingabe von BILD dieser Text durch den definierten LaTeX-Text ersetzt.

Beispiel für die ein benutzerdefiniertes Makro in TeXstudio. Nach dem speichern des Markos werden die Zeichenketten \bild und BILD beim Tippen automatisch durch den angegebenen LaTeX-Text ersetzt.
Beispiel für die ein benutzerdefiniertes Makro in TeXstudio. Nach dem speichern des Markos werden die Zeichenketten \bild und BILD beim Tippen automatisch durch den angegebenen LaTeX-Text ersetzt.

Makro: Bild einfügen

Nach der Eingabe von \bild oder BILD, werden diese Zeichenketten durch LaTeX-Befehle zum Einbinden eines Bildes ersetzt. Damit die unten stehenden Befehle funktionieren, muss in der Präambel das Paket graphicx eingebunden werden (z.B. \usepackage[pdftex]{graphicx}).

Name: Bild einfügen
Trigger: BILD
Abbreviation: \bild
LaTeX-Text:
\begin{figure}
\includegraphics[width=\textwidth]{Bilder/todo.jpg}
\caption{\textbf{XXX.}
XXX.
}
\label{Fig:XXX}
\end{figure}

Makro: Tabelle einfügen

Nach der Eingabe von \tabelle oder TABELLE, werden diese Zeichenketten durch LaTeX-Befehle für eine Tabelle ersetzt. Damit die unten stehenden Befehle funktionieren, müssen in der Präambel zwei Pakete eingebunden werden:

  • \usepackage{tabularx} – Tabelle, die automatisch an die Breite der Seite angepasst werden kann (über ein X bei der Angabe der Ausrichtung innerhalb der Tabelle).
  • \usepackage{booktabs} – Für die Befehle \toprule, \midrule und \bottomrule.
Name: Tabelle einfügen
Trigger: TABELLE
Abbreviation: \tabelle
LaTeX-Text:
\begin{table}
\caption{TabellenTitel}
\label{Tab:Parameter}
\begin{tabularx}{\textwidth}{ llX }
	\toprule
	Parameter & Typical value & Meaning\\
	\midrule
	$XXX$ & $XXX$ & XXX.\\
	$XXX$ & $XXX$ & XXX.\\
	\bottomrule
\end{tabularx}
\end{table}

Weitere Informationen zu Triggern

Trigger werden als Reguläre Ausdrücke interpretiert. Daher können sie deutlich mehr, als nur eine zu ersetzende Zeichenkette definieren:

Wenn dieser Triggertext in einem tex-Dokument geschrieben wird, so wird durch das aktuelle Makro ersetzt.

Wenn der Trigger mit (?<=etwas) anfängt, so passiert dies nur wenn "etwas" vor den restlichen Teil des Triggers geschriben wurde. Da der Triggertext kein einfacher Suchtext, sondern eine regulärer Suchausdruck ist, kann (?<=\S) verwendet werden, um Ersetzungen nach einem Wort und (?<=\s|^) um Ersetzungen vor einem Wort auszulösen. Man kann den speziellen Wert ?txs-start verwenden, um das Skript bei txs start zu starten.