Este artículo describe el método de exportación de Excel por JavaScript. Compártelo para su referencia. El método de implementación específico es el siguiente:
La copia del código es la siguiente: <html xmlns = "http://www.w3.org/1999/xhtml">
<Evista>
<meta http-equiv = "content-type" content = "text/html; charset = utf-8"/>
<title> Cómo exportar páginas web como documentos de Excel </title>
</ablo>
<Body>
<table id = "tableExcel" cellPacing = "0" CellPadding = "0">
<tr>
<td colspan = "5" align = "centro"> Cómo exportar páginas web como documentos de Excel </td>
</tr>
<tr>
<TD> Título de la columna 1 </td>
<TD> Título de la columna 2 </td>
<TD> Título de la columna 3 </td>
<TD> Título de la columna 4 </td>
<TD> Título de la columna 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>
</table>
<input type = "button" onClick = "javaScript: método1 ('tableExcel');" valor = "El primer método se importa a Excel">
<input type = "button" onClick = "javaScript: Method2 ('tableExcel');" valor = "El segundo método se importa a Excel">
<input type = "button" onClick = "javaScript: getxlsFromTbl ('tableExcel', null);" valor = "El tercer método se importa a Excel">
<Script language = "javaScript">
Método de función1 (TableID) {// Copiar la tabla completa para sobresalir
var curtbl = document.getElementByIdx_x_x (tableID);
var oxl = new ActiveXObject ("Excel.Application");
// Crear objeto Axe Excel
var owb = oxl.workbooks.add ();
// Obtener el objeto de libro de trabajo
var osheet = owb.activesheet;
// Activar la hoja actual
var sel = document.body.createTextrange ();
Sel.movetoElementText (Curtbl);
// Mueve el contenido en la tabla a Textrange
sel.select ();
// Seleccione todos los contenidos en Textrange
sel.execCommand ("copia");
// Copiar el contenido en Textrange
OSheet.paste ();
// Pega en el Excel activo
oxl.visible = true;
// establecer el atributo visible de Excel
}
Método de función2 (TableID) // Leer cada celda en la tabla en Excel
{
var curtbl = document.getElementByIdx_x_x (tableID);
var oxl = new ActiveXObject ("Excel.Application");
// Crear objeto Axe Excel
var owb = oxl.workbooks.add ();
// Obtener el objeto de libro de trabajo
var osheet = owb.activesheet;
// Activar la hoja actual
var lenr = Curtbl.rows.length;
// Obtener el número de filas en la tabla
para (i = 0; i <lenr; i ++)
{
var lenc = Curtbl.Rows (i) .Cells.length;
// Obtener el número de columnas por fila
para (j = 0; j <lenc; j ++)
{
Osheet.Cells (i + 1, j + 1) .Value = Curtbl.Rows (i) .Cells (j) .inntext;
//Asignación
}
}
oxl.visible = true;
// establecer el atributo visible de Excel
}
función getxlsFromTbl (intblid, inWindow) {
intentar {
var allStr = "";
var curstr = "";
// alerta ("getxlsFromTbl");
if (intblid! = null && intblid! = "" && intblid! = "null") {
curstr = gettblData (intblid, inWindow);
}
if (curstr! = null) {
allstr += curstr;
}
demás {
alerta ("la tabla que desea exportar no existe!");
devolver;
}
var filename = getExcEfLeName ();
dofileExport (nombre de archivo, allstr);
}
Catch (e) {
alerta ("La excepción ocurrió en la exportación:" + E.Name + "->" + E.Description + "!");
}
}
función getTblData (intbl, inWindow) {
var filas = 0;
// alerta ("gettbldata is" + inwindow);
var tblDocument = document;
if (!! inwindow && inwindow! = "") {
if (! document.all (inWindow)) {
regresar nulo;
}
demás {
tblDocument = eval_r (inWindow) .document;
}
}
var curtbl = tblDocument.getElementByIdx_x_x (intbl);
var outstr = "";
if (Curtbl! = Null) {
para (var j = 0; j <curtbl.rows.length; j ++) {
// alerta ("j is" + j);
para (var i = 0; i <curtbl.rows [j] .cells.length; i ++) {
// alerta ("i is" + i);
if (i == 0 && filas> 0) {
outstr += "";
filas -= 1;
}
OUTSTR + = CURTBL.ROWS [j] .Cells [i] .inntext + "";
if (Curtbl.rows [J] .Cells [i] .colspan> 1) {
para (var k = 0; k <curtbl.rows [j] .cells [i] .colspan - 1; k ++) {
outstr += "";
}
}
if (i == 0) {
if (filas == 0 && curtbl.rows [j] .cells [i] .rowspan> 1) {
filas = Curtbl.Rows [J] .Cells [i] .RowsPan - 1;
}
}
}
outstr += "";
}
}
demás {
outstr = null;
alerta (intbl + "no existir!");
}
regreso fuera de la salida;
}
función getExcEfLeName () {
var d = nueva fecha ();
var curyear = d.getyear ();
var curmonth = "" + (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" + cursecond;
}
var filename = "Leo_zhang" + "_" + Curyear + Curmonth + Curdate + "_"
+ Curhour + Curminute + CurSecond + ".CSV";
// alerta (nombre de archivo);
devolver el nombre de archivo;
}
función dofileExport (inname, instr) {
var xlswin = nulo;
if (!! document.all ("glbhidefrm")) {
xlswin = glbhidefrm;
}
demás {
ancho var = 6;
altura var = 4;
var freenpara = "Left =" + (Window.screen.Width / 2 - Ancho / 2)
+ ", top =" + (Window.screen.Height / 2 - Altura / 2)
+ ", ScrollBars = no, width =" + width + ", altura =" + altura;
xlswin = window.open ("", "_blank", openpara);
}
xlswin.document.write (instr);
xlswin.document.close ();
xlswin.document.execcommand ('Saveas', True, Inname);
xlswin.close ();
}
</script>
</body>
</html>
El siguiente es el problema de tratar con el cierre del proceso de Excel
Copie el código de la siguiente manera: // Problemas de destrucción en JavaScript (ejemplo de objeto ActiveX)
// ---------------------------------------------------------
<script>
var strsavelation = 'file: /// e: /1.xls'
función createExls () {
var Excel = new ActiveXObject ("Excel.Application");
var wk = Excel.WorkBooks.Add ();
wk.saveas (strsavelation);
wk.saved = true;
Excel.quit ();
}
función writexls () {
var Excel = new ActiveXObject ("Excel.Application");
var wk = Excel.WorkBooks.open (strsavelation);
VAR Hoja = Wk.Worksheets (1);
sheet.cells (1, 1) .Value = 'String de prueba';
wk.saveas (strsavelation);
wk.saved = true;
Excel.quit ();
}
</script>
<Body>
<botón onClick = "createExls ()"> Crear </botón>
<Button onClick = "writexls ()"> Reescribir </botón>
</body>
En este ejemplo, no se produce excepción al operar el archivo local. -En la mayoría, solo hay algo de basura de memoria. Sin embargo, si STRSavelation es una URL remota, se guardará una credencial de acceso de archivo local, y solo se puede usar una instancia (remota) para habilitar el documento de Excel y almacenarlo. Entonces, si hace clic en el botón "Reescribir" repetidamente, aparecerá una excepción.
- Tenga en cuenta que este es un código simplificado para una instancia de un archivo compartido cuando funciona en SPS. Por lo tanto, no es una discusión aburrida "académica", y es un problema práctico en ingeniería.
La solución a este problema es complicada. Implica dos cuestiones:
① Lanzamiento de cupones locales
② Liberación de la instancia de objeto ActiveX
Comencemos con el problema de "falla" de los objetos en JavaScript. En pocas palabras:
① Un objeto no será válido fuera del contexto en el que vive.
② Un objeto global no será válido si no se ejecuta (referenciado).
Por ejemplo:
Copie el código de la siguiente manera: // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// cuando fallará el objeto JavaScript
// ---------------------------------------------------------
función testObject () {
var _obj1 = nuevo objeto ();
}
función testObject2 () {
var _obj2 = nuevo objeto ();
return _obj2;
}
// Ejemplo 1
testObject ();
// Ejemplo 2
testObject2 ()
// Ejemplo 3
var obj3 = testObject2 ();
obj3 = nulo;
// Ejemplo 4
var obj4 = testObject2 ();
var arr = [obj4];
obj3 = nulo;
arr = [];
En estos cuatro ejemplos:
- "Ejemplo 1" construye _obj1 en la función testObject (), pero cuando la función sale, ha dejado el contexto de la función, por lo que _obj1 no es válido;
- En "Ejemplo 2", un objeto _OBJ2 también se construye en testObject2 () y se desmaya, por lo que el objeto tiene un entorno de contexto (y vida útil) "fuera de la función", pero dado que el valor de retorno de la función no está "retenido" por otras variables, _obj2 es inmediatamente inválido;
- En "Ejemplo 3", el _OBJ2 construido por testObject2 () está en poder de la variable externa OBJ3. En este momento, hasta que la línea de código "obj3 = nulo" surte efecto, _obj2 no será inválida porque la relación de referencia desaparece.
- Por la misma razón que en el Ejemplo 3, _obj2 en "Ejemplo 4" no será inválido después de la línea de código "arr = []".
Sin embargo, el "fracaso" del objeto no espera ser "liberado". Dentro del tiempo de ejecución de JavaScript, no hay forma de decirle al usuario exactamente "cuándo se lanzará el objeto". Esto depende del mecanismo de recuperación de memoria de JavaScript. “Esta estrategia es similar al mecanismo de reciclaje en .NET.
En el código de ejemplo de Operación de Excel anterior, el propietario del objeto, es decir, "Excel.exe", solo ocurrirá después de la "liberación de la instancia de objeto ActiveX". Los bloqueos de archivo y las credenciales de permiso del sistema operativo están relacionadas con el proceso. Entonces, si el objeto solo está "fallido" y no "liberan", entonces otros procesos tendrán problemas al procesar archivos y referirse a las credenciales de permiso del sistema operativo.
- Algunas personas dicen que este es un error en el mecanismo JavaScript o COM. En realidad, no lo es. Esto es causado por una relación compleja entre OS, IE y JavaScript, en lugar de un problema independiente.
Microsoft ha expuesto una estrategia para resolver este problema: llame proactivamente al proceso de reciclaje de memoria.
Se proporciona un proceso CollectGarbage () (generalmente conocido como el proceso GC) en JScript (Microsoft). El proceso de GC se utiliza para limpiar la "desalineación de objetos fallido" en el IE actual, es decir, el proceso destructor de llamar al objeto.
En el ejemplo anterior, el código que llama al procedimiento GC es:
Copie el código de la siguiente manera: // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Método de llamadas estándar de los procedimientos GC al procesar el objeto ActiveX
// ---------------------------------------------------------
función writexls () {
//(levemente...)
Excel.quit ();
Excel = nulo;
setTimeOut (recolectionGarbage, 1);
}
La primera línea de código llama al método Excel.quit () para hacer que el proceso de Excel aborta y salga. En este momento, dado que el entorno JavaScript tiene una instancia de objeto de Excel, el proceso de Excel en realidad no aborta.
La segunda línea de código hace que Excel nula para borrar las referencias de los objetos, así que "invalidando" al objeto. Sin embargo, dado que el objeto todavía está en el contexto de la función, si el procedimiento GC se llama directamente, el objeto aún no se limpiará.
La tercera línea de código usa setTimeOut () para llamar a la función de recolección de basura, y el intervalo de tiempo se establece en '1', lo que solo hace que el proceso GC ocurra después de ejecutar la función writexls (). De esta manera, el objeto Excel cumple dos condiciones de "puede ser limpiado por GC": sin referencia y dejar el contexto.
El uso de procedimientos GC es muy efectivo en entornos JS utilizando el objeto ActiveX. Algunos objetos potenciales de ActiveX incluyen XML, VML, OWC (Componente web de Office), Flash e incluso VBarray en JS.
Desde este punto de vista, debido a que la arquitectura AJAX adopta XMLHTTP y también necesita cumplir con la característica de "sin conmutación de páginas", llamar activamente el proceso GC en los momentos apropiados le dará una mejor experiencia de eficiencia utilizando la interfaz de usuario.
De hecho, incluso con el proceso GC, el problema de Excel mencionado no se resolverá por completo. Porque IE también almacena credenciales de permiso. La única forma de actualizar las credenciales de permiso de la página es "cambiar a una nueva página", por lo que, de hecho, en el proyecto SPS mencionado anteriormente, el método que utilicé no fue GC, sino el siguiente código:
Copie el código de la siguiente manera: // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// código de conmutación de página utilizado al procesar el objeto ActiveX
// ---------------------------------------------------------
función writexls () {
//(levemente...)
Excel.quit ();
Excel = nulo;
// El siguiente código se usa para resolver un error en IE Call Excel, el método proporcionado en MSDN:
// settimeout (coleccionador de basura, 1);
// Dado que el estado confiable de la página web no se puede borrar (o sincronizar) hará que Saveas () y otros métodos sean
// Inválido la próxima vez que lo llame.
ubicación.reload ();
}
Finalmente, una nota complementaria sobre GC: cuando se minimiza el formulario IE, es decir, lo llamará activamente una vez.
Función CollectGarbage (). Esto hace que el uso de la memoria mejore significativamente después de que se minimice la ventana IE.
Espero que la descripción en este artículo sea útil para la programación web de todos basada en JavaScript.