Stack Exchange
Melhor forma de escrever uma função JavaScript
Qual a melhor forma de escrita da função a seguir?
Esta?
function DOMtoString(document_root) {
    var html = '',
        node = document_root.firstChild;
    while (node) {
        switch (node.nodeType) {
        case Node.ELEMENT_NODE:
            html += node.outerHTML;
            break;
        case Node.TEXT_NODE:
            html += node.nodeValue;
            break;
        case Node.CDATA_SECTION_NODE:
            html += '<![CDATA[' + node.nodeValue + ']]>';
            break;
        case Node.COMMENT_NODE:
            html += '<!--' + node.nodeValue + '-->';
            break;
        case Node.DOCUMENT_TYPE_NODE:
            // (X)HTML documents are identified by public identifiers
            html += "<!DOCTYPE " + node.name + (node.publicId ? ' PUBLIC "' + node.publicId + '"' : '') + (!node.publicId && node.systemId ? ' SYSTEM' : '') + (node.systemId ? ' "' + node.systemId + '"' : '') + '>\n';
            break;
        }
        node = node.nextSibling;
    }
    return html;
}

Ou esta?
function DOMtoString(a) {
    var b = "",
        c = a["firstChild"];
    while (c) {
        switch (c["nodeType"]) {
            case Node["ELEMENT_NODE"]:
                b += c["outerHTML"];
                break;
            case Node["TEXT_NODE"]:
                b += c["nodeValue"];
                break;
            case Node["CDATA_SECTION_NODE"]:
                b += "<![CDATA[" + c["nodeValue"] + "]]>";
                break;
            case Node["COMMENT_NODE"]:
                b += "<!--" + c["nodeValue"] + "-->";
                break;
            case Node["DOCUMENT_TYPE_NODE"]:
                b += "<!DOCTYPE " + c["name"] + (c["publicId"] ? " PUBLIC \"" + c["publicId"] + "\"" : "") + (!c["publicId"] && c["systemId"] ? " SYSTEM" : "") + (c["systemId"] ? " \"" + c["systemId"] + "\"" : "") + ">";
                break;
        }
        c = c["nextSibling"];
    }
    return b;
}


O que você vê de positivo na segunda versão. A impressão que tenho é que a primeira (com os nomes maiores e comentários) é a original e a segunda passou por um minificador de código.

Usa a notação com ponto para propriedades defenidas e a notação com colchetes/parenteses retos em propriedades programáticas, que recebes via  variáveis.
Ou seja no caso de document_root.firstChild a notação com ponto é o uso correto, mais usado.
No caso de 
var prop = element.tagName == 'INPUT' ? 'value' : 'innerHTML';
var valor = element[prop];

deves usar a notação com colchetes/parenteses retos, que é a única maneira de aceder a propriedades do elemento/objeto que variam programáticamente.

Amigos, entendi perfeitamente as explicações, e @Hugomg,  a segunda versão passou sim por um minificador, vc adivinhou! :D. Como pretendo usar a versão minificada, gostaria de saber se irá funcionar da mesma forma que a primeira versão?

@Cloud.NET em termos programáticos (ou seja de leitura do programa) é indiferente. Podes usar qualquer um deles. Mas se precisares de descobrir problemas no código o primeiro é bem melhor de trabalhar/ler.

OK. Então em termos de funcionalidade, tanto faz usar um ou outro que vão funcionar da mesma forma e chegar ao mesmo objetivo pretendido, correto?

@Cloud.NET correto. Mas repara que se o objetivo dessa segunda versão é minificar o código usar ["..."] traz mais caracteres ao código que não usar. Sugiro que uses outro minificador como o UglifyJS.

♦, muito obrigado pela sugestão de minificador.

Claramente a primeira está melhor escrita porque tem nomes de variáveis melhores.  O código deve ser auto documentável. Por isso pode-se afirmar que o primeiro é melhor.
O estilo de acesso ao membros de Node como membros de objeto (no primeiro) e não elementos do array (no segundo) parece ser um pouco mais legível, mas é gosto. O uso como membro do array só seria interessante se precisasse usar uma variável como "índice" de acesso, o que não é o caso.
Fora isto não vejo diferenças relevantes.
Ambos funcionam perfeitamente de forma idêntica. É só uma questão de legibilidade. O segundo carregará de forma ligeiramente mais rápida por ser menor, mas o ganho é ínfimo neste caso.

Até onde sei, a melhor forma é usar a notação com ponto para o uso normal dos objetos e a notação com colchetes quando vamos modificar o objeto programaticamente.. 
No seu caso portanto a 1a notação é mais correta. Caso vc queira acesso a todos os membros do objeto, remover ou adicioná-los, vc pode usar a notação por colchetes.
