Types¶

Alle im Framework definierten generellen Typen, Objekte, Strukturen sind im Namespace Alvine.Types zusammengefasst.

Version¶

Mit Hilfe des Versionsobjektes lässt sich die Version des Frameworks abfragen und gegen eine Mindestanforderung prüfen.

// Neue Version aus Zeichenkette erstellen
version = new Alvine.Types.Version('3.2.1');

// Neue Version aus integer erstellen
version = new Alvine.Types.Version(3,2,1);

//Nur Hautversionsnummer (ergibt 2.0.0)
version = new Alvine.Types.Version('2');

Eine Version kann gegen eine Andere mit der Funktion Version.compareTo() geprüft werden. Diese Methode gibt 1 zurück, wenn das Objekt größer als der übergebene Wert ist und -1 im umgekehrten Fall. 0 wird zurück gegeben, wenn die beiden Versionen identisch sind.

version = new Alvine.Types.Version(4,3,18);
if(version.compareTo(new Alvine.Types.Version(3,3,2))>0) {
   // ... code
};

Observer¶

Das Observer-Objekt nimmt neben einer Callback-Funktion noch weitere Argumente auf. Dieses Objekt dient als Übergabe-Objekt für die verschiedenen Observer Pattern.

observer = new Alvine.Types.Observer(function() {
                    // ...
                        }, 'arg1', 'arg2', ...); // arg1, arg2, ... wird an update als Parameter übergeben
observer.update(subject);

Über die Methoden Observer.addTag(tag) können dem Observer Tags zugeordnet werden und per Observer.removeTag(tag) wieder entfernt werden. Der Parameter tag kann entweder eine Zeichenkette oder ein Array von Zeichenketten sein. Mit Observer.getTags() kann eine Collection der Tags geholt werden.

ObserverList¶

Das ObserverList-Objekt kann von Objekten benutzt werden um das Observer-Pattern zu implementieren.

obj = {
   this.observers = new Alvine.Types.ObserverList();
   }

obj.prototype.attachObserver = function (observer) {
    this.observers.attach(observer);
    return this;
};

obj.prototype.detachObserver = function (observer) {
    this.observers.detach(observer);
    return this;
};

obj.changeValue(newValue) {
    this.observers.notify(this);
}

Queue¶

Mit Hilfe einer Queue lässt sich eine Datenstruktur nach dem FIFO-Prinzip abbilden.

queue = new Alvine.Types.Queue()
// Wert einfügen
queue.push('rot')
// Weiteren Wert
queue.push('blau')
// Weiteren Wert
queue.push('schwarz')

// Ersten Wert holen
queue.poll();
// -> rot
queue.poll();
// -> blau
queue.poll();
// -> schwarz
queue.poll();
// -> Exception, da die Queue leer ist

Über die Methode Queue.isEmpty() kann geprüft werden, ob sich noch Elemente in der Queue befinden.

Die Methode Queue.peek() liefert wie Queue.poll() das nächste Element, allerdings wird es nicht aus der Queue entfernt. Damit ist es möglich einen Blick in die Queue zu werfen, ohne diese zu verändern.

Node¶

Mit Hilfe einer Node lässt sich eine Baumstruktur abbilden. Im folgenden Beispiel wird folgende Baumstruktur abgebildet:

| Fahrzeuge
|-- Land
|   |- Auto
|   |- Fahrrad
|-- Wasser

Das Node-Objekt ist von Map abgeleitet und beherscht dadurch alle Methoden von Map inklusive der Observer-Logik.

root = new Alvine.Types.Node()
root.set('type','Fahrzeuge');

// Das Root-Element erhält zwei Kinder
land = new Alvine.Types.Node();
land.set('type','Land');
root.appendChild(land);

wasser = new Alvine.Types.Node();
wasser.set('type','Wasser');
root.appendChild(wasser);

// Die Landfahrzeuge werden noch untergliedert
auto = new Alvine.Types.Node();
auto.set('type','Auto');
land.appendChild(auto);

fahrrad = new Alvine.Types.Node();
fahrrad.set('type','Fahrrad');
land.appendChild(fahrrad);

Mit Node.getLevel() kann der aktuelle Level der Node im Baum geholt werden. Die Root-Node hat den Level 0.

Node.getParent() kann das übergeordnete Node-Objekt geholt werden. Beim Root-Objekt ergibt die Antwort undefined.

Die Methode Node.hasChildren() liefert true zurück, wenn die Node Kindelemente besitzt. Mit Node.hasChild(node) kann dagegen geprüft werden ob die Node ein spezielles Kind besitzt.

Neue Kinder können über die Methode Node.appendChild(node) hinzugefügt werden. Der Parameter node muss vom Typ Alvine.Types.Node sein. Mit der Methode Node.removeChild(node) lassen sich Kinder wieder entfernen. Eine Liste mit allen Kindern erhält man über Node.getChildren(). Das Ergebnis ist vom Type Alvine.Types.NodeList.

Eine besondere Funktion ist die Methode Node.getNodeList(). Diese erlaubt es den gesamten baum als flache Liste zu durchlaufen. Über die Option filter kann die Liste auf bestimmte Elemente beschränkt werden. Möchte man die Node für Landfahrzeuge holen, so kann man folgendermassen schreiben:

root.getNodeList({
    filter:function(obj){
        return (obj.get('type')==='Land')?true:false;
    }
    })

Möchte man bei einem Match auch noch alle Kinder zum Ergebnis hinzuziehen, so schreibt man folgendermaßen

nodeList = root.getNodeList({
    filter:function(obj){
        return (obj.get('type')==='Land')?true:false;
    },
    appendChildrens: true
})

Mit der Methode fahrrad.getNodeListOfParents() erhält man eine NodeList-Liste mit allen Nodes bis zum Root-Element.

NodeList¶

Das NodeList-Objekt ist eine Collection die auf Node-Objekte beschränkt ist.

createNodeListFromMap¶

Die Hilsmethode Alvine.Types.createNodeListFromMap(data, idName, parentName) erlaubt es eine flache Struktur aus einer API in einen Bau (Node) zu überführen. Das folgende Beispiel definiert einen Baum mit der folgenden Struktur:

├─ 4 
│  ├─ 3
│  │  ├─ 1
│  │  └─ 8
│  └─ 9
│
├─ 5 
│  └─ 2
└─ 6
    └─ 7

Mit folgendem Code wird dann die Node-Struktur erstellt. Beim Aufruf von createNodeListFromMap(data,'cid','parentID') ist der wzeite Parameter der Name der ID und der dritte Parameter der Name mit der Referenz auf die Elternnode.


// Die von der API übermittelten Daten haben folgende Struktur:
data = {
    "1": {"cid": 1, "parentID": 3},
    "2": {"cid": 2, "parentID": 5},
    "3": {"cid": 3, "parentID": 4},
    "4": {"cid": 4, "parentID": 0},
    "5": {"cid": 5, "parentID": 0},
    "6": {"cid": 6, "parentID": 0},
    "7": {"cid": 7, "parentID": 6},
    "8": {"cid": 8, "parentID": 3},
    "9": {"cid": 9,"parentID": 4}
}

// Umwandeln der flachen Struktur in einen Baum aus Nodes
nodes = Alvine.Types.createNodeListFromMap(data,'cid','parentID');

Map¶

Eine Map optimiert den Zugriff auf Objektfunktionen mittels Map.set(key, value) und Map.get(key, default)

map = new Alvine.Types.Map()
// Key/Value setzen
map.set('marke','bmw')
// Weiteren Wert
map.set('farbe','rot')

// Werte holen
map.get('farbe');
// -> rot

Über einen zweiten Parameter kann ein Default-Wert definiert werden. Ist in der Map der entsprechenden Schlüssel nicht definiert wird der Defaultwert zurückgegeben.

map = new Alvine.Types.Map()
// Werte holen
map.get('leistung','700');
// -> 700 (leistung ist kein Schlüssel in der Map)

Die Map.toString() Funktion gibt alle Key/Values als Zeichenkette aus. Über die Eigenschaften Map.keyValueSeparator (Standard :) und Map.entrySeparator (Standard ,) können die Trennzeichen definiert werden.

map.toString()
// -> "marke:bmw,farbe:rot"

Möchte man Änderungen an einer Map überwachen, so kann man mittels eines Observers-Objektes eine Funktion an die Map anhängen.

observer = new Alvine.Types.Observer(function(map) {
                            console.log('updated');
                        });
// -> updated

// Observer einhängen
map.attachObserver(observer);

// ruft die im Observer definierte Callback-Funktion auf.
map.set('key','value')
// -> updated

Achtung

Die Observer werden nur bei Änderungen an der Map aufgerufen und nicht bei Änderungen von Objekten die in der Map eingetragen sind.

obj = {}

// update() wird nicht aufgerufen
map.set('key', obj);

// update() wird nicht aufgerufen
obj.new='3';

Alle Observer lassen sich über die Methode Map.detachObservers(recursive) entfernen. Wird für den Parameter recursive true übergeben, so wird die Map rekursiv durchlaufen.

Eine Map kann auch auf bestimmte Objekte eingeschränkt werden. So kann über den Konstruktor der Name von Objekten die erlaubt sind angegeben werden. Wird ein anderer Wert übergeben, so wird eine Exception geschmissen.

map = new Alvine.Types.Map('Alvine.Util.UUID');
map.set(key, new Alvine.Util.UUID());
// -> OK
map.set(key, 'string value');
// -> exception

Die Anzahl der Einträge kann über Map.getCount() abgefragt werden. Über Map.containKey(key) kann geprüft werden, ob ein Schlüssel in der Map vorhanden ist und mit Map.getKeys() lassen sich alle Schlüssel holen.

Objekte die man mit dieser Einschränkung benutzen will, müssen die Eigenschaft objectName besitzen.

obj = {
    objectName: 'myName';
}
map = new Alvine.Types.Map('myName');

Alternativ zum Namen kann man auch ein Funktionsobjekt übergeben. Die Prüfung erfolgt dann nicht über die Zeichenkette, sondern über den instanceof Operator.

function myname() {
}

Map = new Alvine.Types.Map(myname);

Die beiden Funktionen Map.checkLimitation(objectName/Instance) und Map.isLimitToObject(object) zeichnen für die Überprüfung verantwortlich.

Um über ein Map zu iterieren lässt sich die Methode Map.each(callback) verwenden.

map = new Alvine.Types.Map();
map.each(function(obj, index) {
// ...
});

Über die Methode Map.promoteNotification() kann man das Benachrichtigen der Observer deaktivieren und mit Map.promoteNotification() wieder einschalten. Wird die Methode mit dem Parameter true übergeben, so wir das Verhalten auch bei Einträgen die eine Map oder Colection sind rekursive durchgeführt.

map = new Alvine.Types.Map();
map.preventNotification(true);
// Keine Notification an Observer senden
map.set('k','v');

map.promoteNotification(true);  
// Notification wird gesendet
map.set('k','v');

Collection¶

Eine Collection ist im wesentlichen ein erweitertes Array und kann beliebige Objekte und Werte aufnehmen.

collection = new Alvine.Types.Collection();
collection.append(new Alvine.Util.UUID());
collection.append('Hans Mustermann');
collection.append('Berlin');
collection.append(1425);
collection.append(4.5);
collection.toString();
// -> 7e571823-2c11-4237-84e6-82374cb54878,Hans Mustermann,Berlin,1425,4.5

Das Trennzeichen bei der Ausgabe ist im Standard ein Komma, dies kann aber über die Eigenschaft separator geändert werden.

Eine Collection kann auch auf bestimmte Objekte eingeschränkt werden. So kann über den Konstruktor der Name von Objekten die erlaubt sind angegeben werden. Wird ein anderer Wert übergeben, so wird eine Exception geschmissen.

collection = new Alvine.Types.Collection('Alvine.Util.UUID');
collection.append(new Alvine.Util.UUID());
// -> OK
collection.append('string value');
// -> exception

Objekte die man mit dieser Einschränkung benutzen will, müssen die Eigenschaft objectName besitzen.

obj = {
    objectName: 'myName';
}
collection = new Alvine.Types.Collection('myName');

Alternativ zum Namen kann man auch ein Funktionsobjekt übergeben. Die Prüfung erfolgt dann nicht über die Zeichenkette, sondern über den instanceof Operator.

function myname() {
}

collection = new Alvine.Types.Collection(myname);

Die beiden Funktionen Collection.checkLimitation(objectName/Instance) und Collection.isLimitToObject(object) zeichnen für die Überprüfung verantwortlich.

Um über eine Collection zu iterieren, kann die Methode Collection.each(callback) verwendet werden. Die Methode erwartet eine Callbackfuntion die mit den in der Collection gespeicherten Werten und Schlüsseln aufgrufen wird.

collection.each(function(value, key) {
    // 
});

Eine weitere wichtige Methode ist Collection.contains(). Diese Methode prüft ob ein Wert in der Collection enthalten ist. Die Prüfung, ob ein Wert enthalten ist, erfolgt über den identisch Operator ===.

version = new Alvine.Types.Version('1.2.3');
collection = new Alvine.Types.Collection();
collection.append('Hans Mustermann');
collection.append('Berlin');
collection.append(version);
collection.append(1425);
collection.append(4.5);

collection.contains(1425);
// -> true
collection.contains(4.5);
// -> true
collection.contains(4.9);
// -> false
collection.contains('München');
// -> false
collection.contains('Berlin');
// -> true
collection.contains(version);
// -> true
collection.contains(new Alvine.Types.Version('1.2.3'));    
// -> false

Einträge aus der Collection entfernt man mit der Methode Collection.remove().

Möchte man Änderungen an einer Collection überwachen, so kann man mittels eines Observers-Objektes eine Funktion an die Map anhängen.

observer = new Alvine.Types.Observer(function(collection) {
                        console.log('updated');
                    });
    // -> updated

// Observer einhängen
collection.attachObserver(observer);

// ruft die im Observer definierte Callback-Funktion auf.
collection.append('value')
// -> updated

Achtung

Die Observer werden nur bei Änderungen an der Collection aufgerufen und nicht bei Änderungen von Objekten die in der Collection hängen.

Alle Observer lassen sich über die Methode Collection.detachObservers(recursive) entfernen. Wird für den Parameter recursive true übergeben, so wird die Collection rekursiv durchlaufen.

Über die Methode Collection.preventNotification kann man das benachrichtigen der Observer deaktivieren und mit Collection.promoteNotification wieder einschalten. Wird die Methode mit dem Parameter true übergeben, so wir das Verhalten auch bei Einträgen die eine Map oder Colection sind rekursive durchgeführt.

collection = new Alvine.Types.Collection();
collection.preventNotification(true);
// Keine Notification an Observer senden
collection.append('...');

collection.promoteNotification(true);   
// Notification wird gesendet
collection.append('...');

Objektreferenz¶

Colection(limitToObject)

Beschreibung

Neue Collection erstellen

Parameter-Liste

limitToObject (String)

Beschränkung der Objekte der Collection auf diesen Objekttyp

Rückgabewert

Gibt ein neues Object vom Typ Collection zurück.

Colection.attachObserver(observer)

Beschreibung

Neuen Observer anfügen

Parameter-Liste

observer (Alvine.Types.Observer)

Neuer zu benachrichtigender Observer

Rückgabewert

Die aktuelle Collection (this)

Colection.containsObserver(observer)

Beschreibung

Prüfung ob ein Observer enthalten ist.

Parameter-Liste

observer (Alvine.Types.Observer)

Zu prüfender Observer

Rückgabewert

true oder false

Colection.detachObserver(observer, recursive)

Beschreibung

Entfernt einen Observer

Parameter-Liste

observer (Alvine.Types.Observer)

Zu entfernender Observer

recursive (Boolean)

Falls true, so wird der Observer für die enthaltenden Objekte, sofern diese die Methode detachObserver implementiert haben ebenfalls entfernt.

Rückgabewert

Dieses Objekt

Colection.detachObservers(recursive)

Beschreibung

Alle Observer entfernen

Parameter-Liste

recursive (Boolean)

Falls true, so werden alle Observer für die enthaltenden Objekte, sofern diese die Methode detachObservers implementiert haben ebenfalls entfernt.

Rückgabewert

Dieses Objekt

Colection.preventNotification(recursive)

Beschreibung

Schaltet die Benachrichtigung aus

Parameter-Liste

recursive (Boolean)

Falls true, so wird die Benachrichtigung der Observer für die enthaltenden Objekte, sofern diese die Methode promoteNotification implementiert haben ebenfalls ausgeschalten.

Rückgabewert

Dieses Objekt

Colection.isNotificationPrevented()

Beschreibung

Gibt zurück, ob die Benachrichtigung ein- oder ausgeschaltet ist.

Rückgabewert

true oder false

Colection.promoteNotification(recursive)

Beschreibung

Benachrichtigung der Observer wieder einschalten

Parameter-Liste

recursive (Boolean)

Falls true, so wird die Benachrichtigung der Observer für die enthaltenden Objekte, sofern diese die Methode promoteNotification implementiert haben ebenfalls eingeschaltet.

Rückgabewert

Dieses Objekt

Colection.notifyObserver()

Beschreibung

Observer informieren

Rückgabewert

Dieses Objekt

Colection.isLimitToObject(object)

Beschreibung

Prüft, ob das Objekt gespeichert werden kann. Liegt keine Limitierung der Collection vor, so gibt diese Funktion true zurück.

Parameter-Liste

object (Objekt)

Zu prüfendes Objekt

Rückgabewert

true oder false

Colection.remove(value)

Beschreibung

Prüft ob der übergebene Wert in der Collection enthalten ist und entfernt - falls gefunden - diesen Wert.

Parameter-Liste

value (Mixed)

Zu entfernender Wert

Rückgabewert

Dieses Objekt

Colection.removeIndex(index)

Beschreibung

Element vom spezifiziertem Index entfernen.

Parameter-Liste

index (index)

Index

Rückgabewert

Dieses Objekt

Colection.checkLimitation(objectName)

Beschreibung

Es wird bei Nichtübereinstimmung von objectName mit dem definierten Typ eine Alvine.Exception geworfen.

Parameter-Liste

objectName (String)

Name des zu prüfenden Objekts

Rückgabewert

Dieses Objekt

Colection.append(value)

Beschreibung

Neuen Wert an das Ende der Liste anhängen. Ist die Collection auf einen Objekttyp eingeschränkt, so wird bei Nichtübereinstimmung von value mit dem definierten Typ eine Alvine.Exception geworfen.

Parameter-Liste

value (Mixed)

Anzuhängender Wert

Rückgabewert

Dieses Objekt

Colection.contains(value)

Beschreibung

Überprüfung, ob der übergebene Wert in der Collection vorhanden ist. Zur Prüfung der Übereinstimmung wird der === Operator verwendet.

Parameter-Liste

value (Mixed)

Zu überprüfender Wert

Rückgabewert

true oder false

Colection.getCount()

Beschreibung

Anzahl der Einträge (alias zu getLength)

Rückgabewert

Anzahl der Einträge

Colection.clear()

Beschreibung

Alle Einträge aus der Collection entfernen

Rückgabewert

Dieses Objekt

Colection.getClone()

Beschreibung

Kopie der Collection erstellen

Rückgabewert

Kopie der Collection

Colection.getLength()

Beschreibung

Anzahl der Elemente (alias getCount)

Rückgabewert

Anzahl der Elemente

Colection.toString()

Beschreibung

Erstellen einer Zeichenkette mit den Werten der Liste und getrennt durch ein Trennzeichen

Rückgabewert

Zeichenkette mit den Werten der einzelnen Einträge, verknüft durch das angegebenen Trennzeichen.

Colection.toJSON()

Beschreibung

Diese interne Funktion wird von JSON.stringify aufgerufen und gibt ein Array mit den Elementen zurück.

Rückgabewert

Array mit den einzelnen Einträgen

Colection.each(callback)

Beschreibung

Durchlauf der Collection und aufruf des Callbacks für jeden Eintrag Dem Callback werden drei Parameter übergeben (currentValue [, index [, array]]) => { }

Parameter-Liste

callback (function)

Callbackfunktion

Rückgabewert

Dieses Objekt

Colection.getIndex(index)

Beschreibung

Rückgabe eines Wertes am spezifischen Index

Parameter-Liste

index (integer)

Index

Rückgabewert

Wert am Index oder undefined

Colection.setIndex(index, data)

Beschreibung

Setzen eines spezifischen Indexes. Der übergebene Wert muss - wenn die Collection eingeschränkt ist ein bestimmtes Objekt sein.

Parameter-Liste

index (integer)

Position an der die Daten eingefügt werden sollen

data (mixed)

Einzufügende Daten

Rückgabewert

Dieses Objekt

ID¶

Das ID-Objekt wird mit einem eindeutigen Wert initialisiert und ist besonders für zufällige ID für DOM-Objekte sinnvoll. Die ID ist nur innerhalb einer Webseite eindeutig und nicht kryptografisch abgesichert. Für eine eindeutigere ID sollte man auf die UUID zurückgreifen.

id = new ID();
id.toString()
// -> Mzn6

ID()

Beschreibung

Erstellt neue zufällige ID

Rückgabewert

Neues Objekt mit initialisierter ID

ID.toString()

Beschreibung

ID als Zeichenkette

Rückgabewert

ID als Zeichenkette

ID.getClone()

Beschreibung

ID werden nicht geklont, deshalb gibt diese Methode sich selbst und keine Kopie zurück

Rückgabewert

Eigenes Objekt

Object¶

Im Objekt-Namespace sind generelle Funktionen und Objekte zur Verwaltung und zum Handling von Objekten zusammengefasst. Das Objekt Alvine.Types.Objekt dient als SammelObjekt für alle abgeleiteten Objekte im Framework und stellt grundlegende Funktionen bereit.

object = new Alvine.Types.Object();

// Gibt das Objekt als json-Zeichenkette zurück.
object.toString()
// -> {}

Die Objektklasse wird folgendermaßen als Prototyp-Objekt verwendet:

MyObject.prototype = new Alvine.Types.Object();
MyObject.prototype.constructor = MyObject;

Jedes Objekt besitzt neben der toString-Methode auch eine Object.toJsonString() Methode. Diese Methode wandelt das Objekt in ein JSON um. Intern wird die Methode JSON.stringify(this) verwendet. Die Methode JSON.stringify() serialisiert entweder das Objekt selbst, oder, falls das Objekt eine Methode toJSON()

Wichtig

Die Schreibweise von toJSON ist entscheidend! Es gibt auch die Methode toJson(), die ist aber deprecated und ein Alias zu toJsonString()

Funktionen¶

initAlvineObject()¶

Diese Methode initialisiert ein eigenes Objekt mit der Eigenschaft objectName und weißt Standardwerte zu. Außerdem ruft die Methode testIsCalledAsConstructor() auf.

Um en neues Objekt zu definieren sollte diese Funktion direkt nach der Funktionsdeklaration stehen.

function MyObject(options) {
    Alvine.Types.initAlvineObject.call(this, 'MyObject', namespace, options);
}

MyObject.prototype.getDefaults = function() {
    return {
       key : 'value'
    };
};

MyObject.prototype = new Alvine.Types.Object();
MyObject.prototype.constructor = MyObject;

Über die Defaults werden die Eigenschaften des Objektes festgelegt, die mittels options überschrieben werden können. Wichtig: Die Defaults geben die möglichen Werte vor, über options können keine Eigenschaften angelegt werden.

obj = new MyObject();
// obj.key enthält value

obj = new MyObject({key: 'myvalue'})    
// obj.key enthält myvalue

obj = new MyObject({nokey: 'novalue'})    
// obj.nokey ist undefined

testIsCalledAsConstructor()¶

Diese Methode prüft ob die Funktion als Objekt-Konstruktor aufgerufen wurde und ob das Objekt von Alvine.Types.Objekt abgeleitet wurde. Treffen die Erwartungen nicht zu, so wird eine Exception geworfen.

serialize/unserialize¶

Die Json-Methoden erlauben es aus Objekten einfache Strings zu erstellen und diese Daten auszutauschen. Allerings gehen hier viele Informationen verloren. Aus diesem Grund gibt es die Methoden Alvine.Types.serialize() und Alvine.Types.unserialize().

Alvine.Types.serialize('Das ist ein Test!');
// -> s:17:"Das ist ein Test!";

Methodenreferenz¶

serialize(value)

Beschreibung

Serialisieren von Daten

Parameter-Liste

value (mixed)

Zu serialisierende Variable

Rückgabewert

Zeichenkette mit der serialiserten Repräsentanz.

unserialize(data)

Beschreibung

Unserialisieren von Daten

Parameter-Liste

data (string)

serialisierte Variable

Rückgabewert

Aus der Unserialisierung gewonnener Wert.

clone¶

Die Funktion Alvine.Types.clone() kopiert eine Datenstruktur und erstellt somit ein neues Objekt. Objekte die eine Object.getClone() Methode besitzen werden durch diese Methode geclont. Bei den anderen wird durch alle Properties gelaufen und kopiert. In diesem Fall werden Eigenschaften nur dann kopiert wenn die Methode Object.hasOwnProperty true zurück gibt.

map = new Alvine.Types.Map()
clone = Alvine.Types.clone(map)

Type¶

Im Type Namespace sind Hilfsfunktinen wie Alvine.Types.Type.getType() gebündelt.

getType¶

Mit der Funktion Alvine.Types.Type.getType() kann der Type einer Variable genauer als mit typeof bestimmt werden.

Alvine.Types.Type.getType(4)
// -> "number"
Alvine.Types.Type.getType(new Alvine.Types.Version(1))
// -> "object"
Alvine.Types.Type.getType(2)
// -> "number"
Alvine.Types.Type.getType()
// -> "undefined"
Alvine.Types.Type.getType(1)
// -> "number"
Alvine.Types.Type.getType([1,2])
// -> "array"
Alvine.Types.Type.getType({})
// -> "object"
Alvine.Types.Type.getType(this)
// -> "global"
Alvine.Types.Type.getType(window)
// -> "global"

Über ein true-Flag als zweiter Parameter kann zudem auf die ObjektName Eigenschaft der Alvine-Framework-Objekte zugegriffen werden. Besitzt das Objekt die objectName Eigenschaft, so wird diese zurückgegeben.

Alvine.Types.Type.getType(new Alvine.Types.Map(), true)
// -> "Alvine.Types.Map"

Typprüfung¶

isString¶

Mit der Funktion Alvine.Types.Type.isString() kann geprüft werden ob der Wert eine Zeichenkette ist.

if(Alvine.Types.isString(value)) { ....

isObject¶

Mit der Funktion Alvine.Types.Type.isObject() kann geprüft werden ob der Wert ein Objekt ist.

if(Alvine.Types.isObject(value)) { ....

isSimple¶

Prüfen ob der Type einer Variable eine Zeichenkette, eine Zahl, ein Boolean oder undefined oder null ist.

if(Alvine.Types.isSimple(value)) {

isArray¶

Prüfen ob der Type einer Variable ein Array ist.

if(Alvine.Types.isArray(value)) {