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>
<meta http-equiv = "content-type" content = "text/html; charset = utf-8"/>
<title> Como exportar páginas da web como documentos do Excel </ititure>
</head>
<Body>
<tabela id = "Tabelaxcel" CellPacing = "0" CellPadding = "0">
<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>
<td> aaa </td>
<td> bbb </td>
<td> ccc </td>
<td> ddd </td>
<td> ee </td>
</tr>
<tr>
<td> aaa </td>
<td> bbb </td>
<td> ccc </td>
<td> ddd </td>
<td> eee </td>
</tr>
<tr>
<td> fff </td>
<td> ggg </td>
<td> hhh </td>
<Td> iii </td>
<td> jjj </td>
</tr>
</tabela>
<input type = "Button" OnClick = "JavaScript: Method1 ('Tabelaxcel');" value = "O primeiro método é importado para se destacar">
<input type = "Button" OnClick = "JavaScript: Method2 ('Tabelaxcel');" value = "O segundo método é importado para se destacar">
<input type = "button" onclick = "javascript: getxlsfromtbl ('tabelaxcel', null);" value = "O terceiro método é importado para se destacar">
<Script Language = "JavaScript">
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 = "createxls ()"> Crie </botão>
<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 é:
Copie o código da seguinte forma: // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 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:
Copie o código da seguinte forma: // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// 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.