Explicação detalhada das instâncias de exportação de JavaScript Exporting Excel

Autor：Eve Cole Data da Última Atualização：2025-03-26 14:16:01

Este artigo descreve o método de exportação do Excel por JavaScript. Compartilhe para sua referência. O método de implementação específico é o seguinte:

A cópia do código é a seguinte: <html xmlns = "http://www.w3.org/1999/xhtml">

<head>

<title> Como exportar páginas da web como documentos do Excel </ititure>

</head>

<Body>

<tr>

<td colspan = "5" align = "center"> Como exportar páginas da web como documentos do Excel </td>

</tr>

<tr>

<Td> Título 1 da coluna 1 </td>

<Td> Título 2 da coluna </td>

<Td> Título da coluna 3 </td>

<Td> Título da coluna 4 </td>

<Td> Título da coluna 5 </td>

</tr>

<tr>

</tr>

<tr>

</tr>

<tr>

</tr>

</tabela>

Função Method1 (TableId) {// Copie a tabela inteira para Excel

var curtbl = document.getElementbyidx_x_x (tabelaId);

var oxl = new ActiveXObject ("Excel.Application");

// Crie o objeto AX Excel

var owb = oxl.workbooks.add ();

// Obtenha o objeto da pasta de trabalho

var heet = owb.activheet;

// Ative a folha atual

var sel = document.body.createTexTrange ();

Sel.movetoElementText (Curtbl);

// mova o conteúdo da tabela para o textrange

Sel.Select ();

// Selecione todo o conteúdo do textrange

sel.execCommand ("cópia");

// Copie o conteúdo no textrange

osheet.Paste ();

// Cole no Excel ativo

oxl.visible = true;

// defina o atributo visível do Excel

}

Função Method2 (TableId) // Leia cada célula na tabela no Excel

{

var curtbl = document.getElementbyidx_x_x (tabelaId);

var oxl = new ActiveXObject ("Excel.Application");

// Crie o objeto AX Excel

var owb = oxl.workbooks.add ();

// Obtenha o objeto da pasta de trabalho

var heet = owb.activheet;

// Ative a folha atual

var lenr = curtbl.rows.length;

// Obtenha o número de linhas na tabela

para (i = 0; i <lenr; i ++)

{

var lenc = curtbl.Rows (i) .Cells.Length;

// Obtenha o número de colunas por linha

para (j = 0; j <lenc; j ++)

{

keet.Cells (i + 1, j + 1) .Value = Curtbl.Rows (i) .Cells (j) .innerText;

//Atribuição

}

oxl.visible = true;

// defina o atributo visível do Excel

}

função getxlsfromtbl (intblid, inwindow) {

tentar {

var alltr = "";

var curstr = "";

// alert ("getXlsFromTBl");

if (intblid! = null && intblid! = "" && intblid! = "null") {

curstr = gettbldata (intblid, inwindow);

}

if (curstr! = null) {

Allstr += Curstr;

}

outro {

alerta ("A tabela que você deseja exportar não existe!");

retornar;

}

var filename = getExcelFilename ();

dofileExport (nome do arquivo, Allstr);

}

Catch (e) {

alerta ("Exceção ocorreu na exportação:" + e.name + "->" + e.Description + "!");

}

função gettbldata (intbl, inwindow) {

var linhas = 0;

// alert ("gettbldata é" + inwindow);

var tblDocument = document;

if (!! inwindow && inwindow! = "") {

if (! document.all (inwindow)) {

retornar nulo;

}

outro {

tbldocument = avala_r (inwindow) .document;

}

var curtbl = tbldocument.getElementbyidx_x_x (intbl);

var strottr = "";

if (curtbl! = null) {

for (var j = 0; j <curtbl.rows.length; j ++) {

// alert ("j is" + j);

for (var i = 0; i <curtbl.rows [j] .Cells.Length; i ++) {

// alert ("i é" + i);

if (i == 0 && linhas> 0) {

exttr += "";

linhas -= 1;

}

Outstr + = Curtbl.Rows [J] .Cells [i] .innerText + "";

if (curtbl.rows [j] .Cells [i] .Colspan> 1) {

for (var k = 0; k <curtbl.rows [j] .Cells [i] .colspan - 1; k ++) {

exttr += "";

}

if (i == 0) {

if (linhas == 0 && curtbl.rows [j] .cells [i] .rowspan> 1) {

linhas = curtbl.Rows [j] .Cells [i] .Rowspan - 1;

}

exttr += "";

}

outro {

exttr = null;

alerta (intbl + "não existe!");

}

return fortr;

}

função getExCelfilename () {

var d = new Date ();

var curyear = d.getyear ();

var curmont = "" + (d.getMonth () + 1);

var Curdate = "" + d.getDate ();

var curhour = "" + d.gethours ();

var Curminute = "" + D.GetMinutes ();

var cursecond = "" + d.getSeconds ();

if (curmonth.length == 1) {

curmonth = "0" + curmonth;

}

if (Curdate.Length == 1) {

Curdate = "0" + Curdate;

}

if (curhour.length == 1) {

curhour = "0" + curhour;

}

if (Curminute.Length == 1) {

Curminute = "0" + Curminute;

}

if (cursecond.length == 1) {

Cursecond = "0" + Cursegundo;

}

var filename = "leo_zhang" + "_" + curyear + curmonth + coceira + "_"

+ CURHOUR + CURMINUTE + CURSEGOND + ".CSV";

// alerta (nome do arquivo);

nome do arquivo de retorno;

}

function dofileExport (inname, instrum) {

var xlswin = null;

if (!! document.all ("glbhidefrm")) {

xlswin = glbhidefrm;

}

outro {

var largura = 6;

altura var = 4;

var OpenPara = "Left =" + (Window.screen.width / 2 - largura / 2)

+ ", top =" + (window.screen.height / 2 - altura / 2)

+ ", scrollbars = não, width =" + width + ", altura =" + altura;

xlswin = window.open ("", "_blank", openpara);

}

xlswin.document.write (Instr);

xlswin.document.close ();

xlswin.document.execCommand ('Saveas', verdadeiro, inname);

xlswin.close ();

}

</Script>

</body>

</html>

A seguir, o problema de lidar com o fechamento do processo do Excel

Copie o código da seguinte forma: // Problemas de destruição no JavaScript (Exemplo de objeto ActiveX)

// ---------------------------------------------------------

<Cript>

var strSavelocation = 'arquivo: /// e: /1.xls'

função createxls () {

var Excel = new ActiveXObject ("Excel.Application");

var wk = excel.workbooks.add ();

WK.SAVEAS (Strsavelocation);

wk.saved = true;

Excel.Quit ();

}

function writexls () {

var Excel = new ActiveXObject ("Excel.Application");

var wk = excel.workbooks.open (strsavelocation);

var sheet = wk.worksheets (1);

Sheet.Cells (1, 1) .Value = 'String de teste';

WK.SAVEAS (Strsavelocation);

wk.saved = true;

Excel.Quit ();

}

</script>

<Body>

<button onclick = "writexls ()"> rewrite </butut>

</body>

Neste exemplo, nenhuma exceção ocorre ao operar o arquivo local. -Na maioria, há apenas algum lixo de memória. No entanto, se o Strsavelocation for um URL remoto, uma credencial de acesso a arquivos local será salva e apenas uma instância (remota) poderá ser usada para permitir o documento do Excel e armazená -lo. Portanto, se você clicar no botão "Reescrever" repetidamente, uma exceção aparecerá.

- Observe que este é um código simplificado para uma instância de um arquivo compartilhado ao operar no SPS. Portanto, não é uma discussão chata "acadêmica" e é um problema prático na engenharia.

A solução para esse problema é complicada. Envolve duas questões:

① Liberação de vouchers locais

② Liberação da instância do objeto ActiveX

Vamos começar com o problema de "falha" dos objetos no JavaScript. Simplificando:

① Um objeto será inválido fora do contexto em que vive.

② Um objeto global será inválido se não for executado (referenciado).

Por exemplo:

Copie o código da seguinte forma: // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// Quando o objeto JavaScript falhará

// ---------------------------------------------------------

função testObject () {

var _obj1 = new Object ();

}

função testObject2 () {

var _obj2 = new Object ();

retornar _obj2;

}

// Exemplo 1

testObject ();

// Exemplo 2

testObject2 ()

// Exemplo 3

var obj3 = testObject2 ();

obj3 = nulo;

// Exemplo 4

var obj4 = testObject2 ();

var arr = [obj4];

obj3 = nulo;

arr = [];

Nestes quatro exemplos:

- "Exemplo 1" constrói _obj1 no função testObject (), mas quando a função sai, ele deixou o contexto da função, então _obj1 é inválido;

- Em "Exemplo 2", um objeto _obj2 também é construído em testObject2 () e desmaiado, portanto o objeto tem um ambiente de contexto (e vida útil) "fora da função", mas como o valor de retorno da função não é "mantido" por outras variáveis, _obj2 é imediatamente inválido;

- Em "Exemplo 3", o _obj2 construído pelo testObject2 () é mantido pela variável externa Obj3. No momento, até que a linha de código "obj3 = null" entre em vigor, _obj2 não será inválido porque o relacionamento de referência desaparece.

- Pelo mesmo motivo que no Exemplo 3, _obj2 em "Exemplo 4" não será inválido após a linha de código "arr = []".

No entanto, o "fracasso" do objeto não espera ser "liberado". Dentro do tempo de execução do JavaScript, não há como dizer ao usuário exatamente "quando o objeto será lançado". Isso depende do mecanismo de recuperação de memória do JavaScript. “Essa estratégia é semelhante ao mecanismo de reciclagem no .NET.

No código de exemplo de operação anterior do Excel, o proprietário do objeto, ou seja, "Excel.exe", ocorrerá apenas após "a liberação da instância do objeto ActiveX". Os bloqueios de arquivo e as credenciais de permissão do sistema operacional estão relacionados ao processo. Portanto, se o objeto for apenas "falhou" e não "liberação", outros processos terão problemas ao processar arquivos e se referir às credenciais de permissão do sistema operacional.

- Algumas pessoas dizem que este é um bug no JavaScript ou no Mecanismo Com. Na verdade, não é. Isso é causado por uma relação complexa entre OS, ou seja, JavaScript, em vez de um problema independente.

A Microsoft expôs uma estratégia para resolver esse problema: chamar proativamente o processo de reciclagem de memória.

Um processo colecionGarbage () (geralmente chamado de processo GC) é fornecido no JScript (Microsoft). O processo GC é usado para limpar o "desalinhamento do objeto com falha" no IE atual, ou seja, o processo de destruidor de chamar o objeto.

No exemplo acima, o código que chama o procedimento GC é:

// Método de chamada padrão dos procedimentos GC ao processar o objeto ActiveX

// ---------------------------------------------------------

function writexls () {

//(um pouco...)

Excel.Quit ();

excel = nulo;

setTimeout (Collectgarbage, 1);

}

A primeira linha de código chama o método Excel.Quit () para fazer o processo do Excel abortar e sair. No momento, como o ambiente JavaScript possui uma instância do objeto Excel, o processo do Excel não é realmente abortado.

A segunda linha de código torna o Excel NULL para limpar as referências de objetos, "invalidando" o objeto. No entanto, como o objeto ainda está no contexto da função, se o procedimento GC for chamado diretamente, o objeto ainda não será limpo.

A terceira linha de código usa o setTimeout () para chamar a função Collectgarbage, e o intervalo de tempo é definido como '1', o que apenas faz com que o processo GC aconteça após a execução da função writexls (). Dessa maneira, o objeto do Excel atende a duas condições de "pode ser limpo por GC": nenhuma referência e deixando o contexto.

O uso de procedimentos GC é muito eficaz em ambientes JS usando o objeto ActiveX. Alguns objetos ActiveX em potencial incluem XML, VML, OWC (Office Web Commonet), Flash e até VBARRAY em JS.

Desse ponto de vista, porque a arquitetura do Ajax adota o XMLHTTP e também precisa atender ao recurso "sem comutação de página", chamar ativamente o processo GC em momentos apropriados fornecerá uma melhor experiência em eficiência usando a interface do usuário.

De fato, mesmo com o processo GC, o problema do Excel acima mencionado não será completamente resolvido. Porque o IE também armazena credenciais de permissão. A única maneira de fazer com que as credenciais de permissão da página sejam atualizadas é "mudar para uma nova página", então, de fato, no projeto SPS mencionado anteriormente, o método que usei não foi o GC, mas o código a seguir:

// Código de comutação de página usado ao processar o objeto ActiveX

// ---------------------------------------------------------

function writexls () {

//(um pouco...)

Excel.Quit ();

excel = nulo;

// O código a seguir é usado para resolver um bug no IE Call Excel, o método fornecido no MSDN:

// setTimeout (Collectgarbage, 1);

// Como o estado confiável da página da web não pode ser limpo (ou sincronizado) fará com que o SAVEAS () e outros métodos sejam

// inválido da próxima vez que você ligar.

localização.reload ();

}

Finalmente, uma nota suplementar sobre o GC: quando o formulário do IE for minimizado, o IE o chamará ativamente uma vez.

Função collectgarbage (). Isso faz com que o uso da memória melhore significativamente após a minimização da janela do IE.

Espero que a descrição deste artigo seja útil para a programação da Web de todos com base no JavaScript.