Ecriture d'un objet dans différents langages

Petit exercice dans le cadre d'une uniformisation de mes outils de développement : l'écriture d'un même objet, une structure de noeuds hiérarchiques, dans trois langages différents : javascript, PHP et python.

var Node = function (datas) {
    this.parentNode = null;
    this.childNodes = [];
    this.datas = datas || {};
};

Node.prototype = {

    appendChild : function (child, idx)  {
        if (child instanceof Node) {
            if (rnb.is.undef(idx)) {
                this.childNodes.push(child);
            } else {
                this.childNodes.splice(idx, 0, child);
            }
        } else {
            throw new TypeError("child is not instance of Node");
        }
    },
    
    hasChildNodes: function () {
        return this.childNodes.length > 0;
    },
    
    getChildNodes : function () {
        return this.childNodes;
    },
    
    getChildNode: function (idx) {
        if (this.childNodes[idx]) {
            return this.childNodes[idx];        
        }
        return null;
    },
    
    getFirstChild: function () {
        return this.getChildNode[0];
    },
    
    getLastChild: function () {
        return this.getChildNode[this.childNodes.length-1];
    },
    
    getParentNode: function () {
        return this.parentNode;
    },
    
    setData : function (dataName, dataValue) {
        this.datas[dataName] = dataValue;    
    },
    
    getData : function (dataName) {
        if (dataName in this.datas) {
            return this.datas[dataName];        
        }
        return null;
    },
    
    getDatas: function () {
        return this.datas;
    }
};
L'objet Node en javascript.
class Node {

    public $parentNode = NULL;
    public $childNodes = array();
    public $datas = array();
    
    public function __construct($datas=array()) {
        $this->datas = $datas;
    }
    
    public function appendChild(&$node, $idx=NULL) {
        if ($node instanceof Node) {
            $node->parentNode =& $this;
            if ($idx === NULL) {
                $this->childNodes[] =& $node;
            } else {
                array_splice($this->childNodes, $idx, 0, $node);
            }
        } else {
            throw ErrorException ("child is not instance of Node");
        }
    }
    
    public function hasChildNodes() {
        return count($this->childNodes)>0;
    }
    
    public function getChildNodes() {
        return $this->childNodes;
    }
    
    public function &getChildNode($idx) {
        if (isset($this->childNodes[$idx])) {
            return $this->childNodes[$idx];
        }
        return NULL;
    }
    
    public function &getFirstChild() {
        return $this->getChildNode[0];
    }
    
    public function &getLastChild() {
        return $this->getChildNode[count($this->childNodes)-1];
    }
    
    public function &getParentNode() {
        return $this->parentNode;
    }
    
    public function getData($dataId) {
        if (isset($this->datas[$dataId])) {
            return $this->datas[$dataId];
        }
        return NULL;
    }
    
    public function setData($dataId, $dataValue) {
        $this->datas[$dataId] = $dataValue;
    }
    
    public function getDatas() {
        return $this->datas;
    }
}
L'objet Node en PHP.
class Node:

    def __init__(self, datas=None):
        self.parentNode = None
        self.childNodes = []
        if datas is None:
            self.datas = {}
        else :
            self.datas = datas
        
    def appendChild(self, node, idx=None) :
        if isinstance(child, Node) :
            node.parentNode = self
            if idx is None :
                self.childNodes.append(node)
            else :
                self.childNodes.insert(idx, node)
        else :
            raise TypeError("child is not instance of Node")
    
    def hasChildNodes(self):
        return len(self.childNodes) > 0
    
    def getChildNodes(self):
        return self.childNodes
    
    def getChildNode(self, idx):
        if idx < len(self.childNodes) :
            return self.childNodes[idx]
        return None
    
    def getFirstChild(self):
        if self.hasChildNodes():
            return self.childNodes[0]
        return None
    
    def getLastChild(self):
        if self.hasChildNodes():
            return self.childNodes[len(self.childNodes)-1]
        return None
    
    def getParentNode(self):
        return self.parentNode
    
    def setData(self, dataName, dataValue):
        self.datas[dataName] = dataValue
    
    def getData(self, dataName):
        if dataName in self.datas:
            return self.datas[dataName]
        return None
    
    def getDatas(self):
        return self.datas
L'objet Node en python.