petit DOMBUILDER via innerHTML, une version avec la possibilité de passer un objet définissant les attributs , et les noeuds devrait être ajouté, car, il est parfois plus difficile de créer un chaine de caracthere plutot, que un objet , et inversement ....

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
(function(spaceName){
    /*------------------------priver-----------------------*/
 
    //element servant a créer les élément html, via innerHTML
    var element = document.createElement('div'),
        isIE = /msie/i.test(navigator.userAgent),
        parent;//parent référencant tout les élément créer depuis une cahine de caractere
 
    //vide le contenue de element
    function iniElement(){
         element.innerHTML = '';
    }
    //céer des élements depuis une string
    function create(str){
        iniElement();
        var wrap = /^<(thead|tbody|tfoot|colg|cap)/i.test(str) ? [ 1, "<table>", "</table>" ]
            : /^<tr/i.test(str) ? [ 2, "<table><tbody>", "</tbody></table>" ]
            : /^(<td|<th)/i.test(str) ? [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] 
            : /^<opt/i.test(str) ? [ 1, "<select multiple='multiple'>", "</select>" ]
            : /^<leg/i.test(str) ? [ 1, "<fieldset>", "</fieldset>" ]
            : /^<col/i.test(str) ? [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] : null;
 
        parent = element;
        if(wrap){
            parent.innerHTML = wrap[1] + str + wrap[2];
            //on définit ele, le dernier parent 
            while (wrap[0]--)
			    parent = parent.lastChild;
        }else
            //sinon on remplit dans la reférence de element de la chaine html
            parent.innerHTML =  str;
    }
 
    //inser un élement a partir d'une sible et d'une position(before)
    function insert(el, sible, before){
        if(before){
            sible.parentNode.insertBefore(el, sible);
        }else sible.appendChild(el);
    }
 
    //insertion des élement via une string
    function insertHTML(el, str, before){
        create(str); 
        var elem;    
        while (parent.childNodes[0]){
            elem = parent.removeChild(parent.childNodes[0]);
            insert(elem, el, before);
        }       
    }
 
    //insertion des élement via un tableau
    function insertArray(el, array, before){
        for(var i = 0, l = array.length; i < l; i++)
            getFuncInsertion(array[i])(el, array[i], before);
    }
 
    //insertion des élement via une JSON
    function insertJSON(el, object, before){
        var tag = object.tag,
            items = object.items;
        delete object.tag;
        delete object.items;
        var _el = document.createElement(tag);
        for(var i in  object)
            spaceName.setAttribute(_el, i, object[i]); 
        if(items)
            getFuncInsertion(items)(_el, items);
        object.tag = tag;
        object.items = items;
        insert(_el, el, before);
    }
 
    //insertion des élement via  noeud HTML, ou une collection HTML(nodeList)
    function insertNod(el, els, before){
        els = els.length ? els : [els];
        for(var i = 0, l = els.length; i < l; i++)
            insert(els[i], el, before);
    }
 
    function getFuncInsertion(els){
        return typeof els == 'string' ? insertHTML : els.constructor == Object ? insertJSON : els instanceof Array ? insertArray : insertNod;
    }
 
    //création d'un objet d'acces rapide au propriété accéssible uniquement comme propriété du noeud    
    var camelGroupe = ['colSpan', 'rowSpan', 'vAlign', 'dateTime', 'accessKey', 'tabIndex', 'encType', 'maxLength', 'readOnly', 'longDesc', 'cellPadding', 'cellSpacing', 'frameBorder', 'useMap', 'id'];
    for (var i = 0, c, isCamel = {'class' : 'className', 'className' : 'className', id : 'id'}; c = camelGroupe[i]; i++)
        isCamel[c.toLowerCase()] = c;
 
    //création d'un objet d'acces rapide au propriété accéssible uniquement comme propriété du noeud, et dont dont les valeur de typoe bool doivent avoir une notation XHTML     
    var boolGroupe = ['compact', 'nowrap', 'ismap', 'declare', 'noshade', 'checked', 'disabled', 'readonly', 'multiple', 'selected', 'noresize', 'defer'];
    for (var i = 0, c, isBool = {}; c = boolGroupe[i]; i++)
        isBool[c] = c;
 
    /*------------------------publique-----------------------*/
 
    //par forcement nécessaire, mais pour etre en 'harmonie' avec toute les autres fonctions
    spaceName.getHTML = function(el){
        return el.innerHTML;
    }
 
       spaceName.getOutherHTML = function(el){
        iniElement();
        element.appendChild(el.cloneNode(true));
        return element.innerHTML; 
    }
 
    spaceName.getAttribute = function(el, attr){
        if(attr == 'style')
            return el.style.cssText;
        var camel, bool;
        return r = isIE || (camel = isCamel[attr]) || (bool = isBool[attr]) ? el[camel || bool || attr] : el.getAttribute(attr);
    }
 
    spaceName.setAttribute = function(el, attr, value){
        if(attr == 'style'){
            el.style.cssText = value;
            return;
        }
        var camel = isCamel[attr], 
            bool = isBool[attr];
        if(bool && !value){
            el[bool] = null;
        }else if(isIE || camel || bool){
            el[camel || bool || attr] = bool || value;
        }else el.setAttribute(attr, value);
    }
 
    spaceName.removeAttribute = function(el, attr){
        if(attr == 'style'){
            el.style.cssText = '';
            return;
        }
        var camel = isCamel[attr], 
            bool = isBool[attr];
        if(isIE || camel || bool){
            el[camel || bool || attr] = null;
        }else el.removeAttribute(attr);
    }
 
    spaceName.setHTML = function(el, els){
        el.innerHTML = '';
        (typeof els == 'string' ? insertHTML : insertNod)(el, els);
    }
 
    spaceName.append = spaceName.insertIntoLast = function(el, els){
        getFuncInsertion(els)(el, els);
    }
 
    spaceName.prepend = spaceName.insertBefore = function(el, els){
        getFuncInsertion(els)(el, els, true);
    }
 
    spaceName.insertIntoFirst = function(el, els){
        var ele; 
        getFuncInsertion(els)((ele = el.childNodes[0]) ? ele : el, els, !!ele);
    }
 
    spaceName.insertAfter = function(el, els){
        var ele; 
        getFuncInsertion(els)((ele = el.nextSibling) ? ele : el.parentNode, els, !!ele);
    }
 
    spaceName.createElement = function(els){
        create(els);
        var els = Array.prototype.slice.call(parent.childNodes);
        return els.length - 1 ? els : els[0];
    }
})(window)//->remplacer windows par votre espace de nom
Les insertions acceptent des chaines de caractères, un nœud HTML, ou un tableau de nœuds HTML, et peuvent ètre appliqué à n'importe qu'elle noeud (tr, tbody, select ect...)

getAttribute et setAttribute normalise l'accession et la modification des attributs

Voici la list des fonctions:
- getHTML
- getOutherHTML
- setHTML
- append / insertIntoLast
- prepend / insertBefore
- insertIntoFirst
- insertAfter
- createElement
- getAttribute
- setAttribute
- removeAttribute


petit example en supossant que l'element est une balise tr :

append(document.getElementById('elementTR'), '<td>test</td>');


La technique utilisé est expliqué dans la source, mais le plus étonnant , c'est que ses fonctions sont plus rapide que innerHTML, et bcp plus rapide que en passant par les fonctions du dom.
le faite de passé par un élément privé et non intégré au dom, de le remplir par une chaine HTML, puis de récupérer les élément généré, est bcp plus rapide !! bizarre !!

voilà voilà , bye !