In diesem Artikel wird die Methode zum Exportieren von Excel durch JavaScript beschrieben. Teilen Sie es für Ihre Referenz. Die spezifische Implementierungsmethode lautet wie folgt:
Die Codekopie lautet wie folgt: <html xmlns = "http://www.w3.org/1999/xhtml">
<kopf>
<meta http-äquiv = "content-type" content = "text/html; charset = utf-8"/>
<titels> So exportieren Sie Webseiten als Excel -Dokumente </title>
</head>
<body>
<table id = "tableExcel" cellpacing = "0" cellpadding = "0">
<tr>
<td colspan = "5" Align = "Center"> So exportieren Sie Webseiten als Excel -Dokumente </td>
</tr>
<tr>
<td> Spalte Titel 1 </td>
<td> Spalte Titel 2 </td>
<td> Spalte Titel 3 </td>
<td> Spalte Titel 4 </td>
<td> Spalte Titel 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: method1 ('tableExcel');" value = "Die erste Methode wird in Excel importiert">
<Eingabe type = "button" onclick = "JavaScript: method2 ('tableExcel');" value = "Die zweite Methode wird in Excel importiert">
<input type = "button" onclick = "JavaScript: getXlsfromtbl ('tableExcel', null);" value = "Die dritte Methode wird in Excel importiert">
<Script Language = "JavaScript">
Funktionsmethode1 (tableId) {// Die gesamte Tabelle kopieren
var curtbl = document.getElementByIdx_x_x (tableId);
var oxl = new ActiveXObject ("excel.application");
// AX -Objekt Excel erstellen
var owb = oxl.workbooks.add ();
// das Arbeitsmappenobjekt holen
var osheet = owb.activeSheet;
// das aktuelle Blatt aktivieren
var sel = document.body.createTextrange ();
Sel.MovetoelementText (Curtbl);
// Verschieben Sie den Inhalt im Tisch in Textrange
sel.select ();
// Wählen Sie alle Inhalte in Textrange aus
sel.execcommand ("kopieren");
// Kopieren Sie den Inhalt in Textrange
osheet.paste ();
// Einfügen in den aktiven Excel ein
oxl.visible = true;
// Setzen Sie das sichtbare Attribut von Excel
}
Funktionsmethode2 (TabelleID) // Lesen Sie jede Zelle in der Tabelle in Excel
{
var curtbl = document.getElementByIdx_x_x (tableId);
var oxl = new ActiveXObject ("excel.application");
// AX -Objekt Excel erstellen
var owb = oxl.workbooks.add ();
// das Arbeitsmappenobjekt holen
var osheet = owb.activeSheet;
// das aktuelle Blatt aktivieren
var lenr = curtbl.rows.length;
// Holen Sie sich die Anzahl der Zeilen in der Tabelle
für (i = 0; i <lenr; i ++)
{
var lenc = curtbl.rows (i) .cells.length;
// Erhalten Sie die Anzahl der Spalten pro Zeile
für (j = 0; j <lenc; j ++)
{
osheet.cells (i + 1, j + 1) .Value = curtbl.rows (i) .cells (j) .InNeText;
//Abtretung
}
}
oxl.visible = true;
// Setzen Sie das sichtbare Attribut von Excel
}
Funktion getXlsfromtbl (intblid, Inwindow) {
versuchen {
var Allstr = "";
var curstr = "";
// alert ("getXlsfromtbl");
if (intblid! = null && intblid! = "" && intblid! = "null") {
curstr = getTbldata (intblid, Inwindow);
}
if (curstr! = null) {
Allstr += Curstr;
}
anders {
ALERT ("Die Tabelle, die Sie exportieren möchten, exportiert nicht!");
zurückkehren;
}
var Filename = getExcelfileName ();
DofileExport (Dateiname, Allstr);
}
fangen (e) {
alert ("Ausnahme im Export aufgetreten:" + e.name + "->" + e.description + "!");
}
}
Funktion getTBlData (intbl, inwindow) {
var rows = 0;
// alarm ("GettBldata ist" + inwindow);
var tbldocument = document;
if (!! inwindow && inwindow! = "") {
if (! document.all (inwindow)) {
null zurückkehren;
}
anders {
tBlDocument = Eval_r (Inwindow) .Document;
}
}
var curtbl = tbldocument.getElementByIdx_x_x (intbl);
var outstr = "";
if (curtbl! = null) {
für (var j = 0; j <curtbl.rows.length; j ++) {
// alert ("j is" + j);
für (var i = 0; i <curtbl.rows [j] .cells.length; i ++) {
// alarm ("i ist" + i);
if (i == 0 && Zeilen> 0) {
überstr += "";
Zeilen -= 1;
}
überstr + = curtbl.rows [j] .Cells [i] .InNerText + "";
if (curtbl.rows [j] .cells [i] .colspan> 1) {
für (var k = 0; k <curtbl.rows [j] .cells [i] .colspan - 1; k ++) {
überstr += "";
}
}
if (i == 0) {
if (rows == 0 && curtbl.rows [j] .cells [i] .rowspan> 1) {
Zeilen = curtbl.rows [j] .Cells [i] .Rowspan - 1;
}
}
}
überstr += "";
}
}
anders {
überstr = null;
alarm (intbl + "nicht existieren!");
}
Rückkehr;
}
Funktion getExcelneName () {
var d = neues Datum ();
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) {
Curtonth = "0" + Curmonth;
}
if (curdate.length == 1) {
Curdate = "0" + Curdate;
}
if (curhour.length == 1) {
Curhour = "0" + Curhour;
}
if (curminute.length == 1) {
currinute = "0" + curminute;
}
if (cursecond.length == 1) {
cursecond = "0" + cursecond;
}
var fileName = "leo_zhang" + "_" + curyear + Curmonth + Curdate + "_"
+ curhour + curminute + cursecond + ".csv";
// alarm (Dateiname);
Rückgabe Dateiname;
}
Funktion dofileExport (Inname, Instrument) {
var xlswin = null;
if (!! document.all ("glbhidefrm")) {
xlswin = glbhidefrm;
}
anders {
var width = 6;
var Höhe = 4;
var openPara = "links =" + (window.screen.width / 2 - Breite / 2)
+ ", top =" + (window.screen.height / 2 - Höhe / 2)
+ ", Scrollbars = no, width =" + width + ", height =" + Höhe;
xlswin = window.open ("", "_Blank", OpenPara);
}
xlswin.document.write (instration);
xlswin.document.close ();
xlswin.document.execcommand ('Saveas', true, Inname);
xlswin.close ();
}
</Script>
</body>
</html>
Das Folgende ist das Problem des Umgangs mit Excel -Prozessverschlüssen
Kopieren Sie den Code wie folgt: // Zerstörungsprobleme in JavaScript (ActiveX -Objektbeispiel)
// ---------------------------------------------------------
<Script>
var strsavelocation = 'Datei: /// e: /1.xls'
Funktion createxls () {
var excel = new ActiveXObject ("excel.application");
var wk = excel.workbooks.add ();
wk.saveas (strsavelocation);
wk.saved = true;
excel.quit ();
}
Funktion writexls () {
var excel = new ActiveXObject ("excel.application");
var wk = excel.workbooks.open (strsavelocation);
var Sheet = wk.worksheets (1);
Blatt.Cells (1, 1) .Value = 'Test String';
wk.saveas (strsavelocation);
wk.saved = true;
excel.quit ();
}
</script>
<body>
<button onclick = "createxls ()"> create </button>
<button onclick = "writexls ()"> Umschreiben </button>
</body>
In diesem Beispiel tritt keine Ausnahme beim Betrieb der lokalen Datei auf. -Am meisten gibt es nur etwas Speichermüll. Wenn Strsavelocation jedoch eine Remote -URL ist, wird ein lokaler Anmeldeinformationen für Dateien gespeichert, und es kann nur eine (Remote-) Instanz verwendet werden, um das Excel -Dokument zu aktivieren und zu speichern. Wenn Sie also wiederholt auf die Schaltfläche "Umschreiben" klicken, wird eine Ausnahme angezeigt.
- Beachten Sie, dass dies ein vereinfachter Code für eine Instanz einer gemeinsamen Datei beim Betrieb in SPS ist. Daher ist es keine "akademische" langweilige Diskussion und es ist ein praktisches Problem im Ingenieurwesen.
Die Lösung für dieses Problem ist kompliziert. Es beinhaltet zwei Probleme:
① Veröffentlichung lokaler Gutscheine
② Freisetzung der ActiveX -Objektinstanz
Beginnen wir mit dem "Fehler" -Problem von Objekten in JavaScript. Einfach sagen:
① Ein Objekt ist außerhalb des Kontextes, in dem es lebt, ungültig.
② Ein globales Objekt ist ungültig, wenn es nicht ausgeführt wird (verwiesen).
Zum Beispiel:
Kopieren Sie den Code wie folgt: // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Wann fällt JavaScript -Objekt fehl?
// ---------------------------------------------------------
Funktion testObject () {
var _obj1 = neues Objekt ();
}
Funktion testObject2 () {
var _obj2 = neues Objekt ();
return _obj2;
}
// Beispiel 1
testObject ();
// Beispiel 2
testObject2 ()
// Beispiel 3
var obj3 = testObject2 ();
obj3 = null;
// Beispiel 4
var obj4 = testObject2 ();
var arr = [obj4];
obj3 = null;
arr = [];
In diesen vier Beispielen:
- "Beispiel 1" konstruiert _obj1 im Funktion testObject (), aber wenn die Funktion ausgeht, hat sie den Kontext der Funktion gelassen, sodass _obj1 ungültig ist;
- In "Beispiel 2" wird ein Objekt _obj2 auch in testObject2 () konstruiert und ohnmächtig, sodass das Objekt eine Kontextumgebung (und eine Lebensdauer) "außerhalb der Funktion" hat, aber da der Rückgabewert der Funktion nicht von anderen Variablen "gehalten" wird, ist _OBJ2 sofort ungültig.
- In "Beispiel 3" wird die von TestObject2 () konstruierte _obj2 von der externen variablen OBJ3 gehalten. Zu diesem Zeitpunkt ist _OBJ2 nicht ungültig, weil die Referenzbeziehung nicht ungültig ist, bis die Codezeile "obj3 = null" wirksam wird.
- Aus dem gleichen Grund wie in Beispiel 3 ist _obj2 in "Beispiel 4" nach der Codezeile "arr = []" nicht ungültig.
Der "Fehler" des Objekts wartet jedoch nicht, "freigegeben" zu werden. In der JavaScript -Laufzeit gibt es keine Möglichkeit, dem Benutzer genau zu sagen, dass "wann das Objekt veröffentlicht wird". Dies hängt vom JavaScript -Speicherwiederherstellungsmechanismus ab. »Diese Strategie ähnelt dem Recycling -Mechanismus in .NET.
Im vorherigen Excel -Operation -Beispielcode wird der Eigentümer des Objekts, dh "excel.exe", erst nach "Freigabe der ActiveX -Objektinstanz" auftreten. Die Dateisperrungen und die Berechtigungsnachweise des Betriebssystems beziehen sich auf den Prozess. Wenn das Objekt also nur "fehlgeschlagen" und nicht "freigegeben" ist, haben andere Prozesse Probleme beim Verarbeiten von Dateien und bei der Verweise auf die Berechtigungsnachweise des Betriebssystems.
- Einige Leute sagen, dies ist ein Fehler im JavaScript- oder COM -Mechanismus. Eigentlich ist es nicht. Dies wird eher durch eine komplexe Beziehung zwischen OS, IE und JavaScript als durch ein unabhängiges Problem verursacht.
Microsoft hat eine Strategie zur Lösung dieses Problems enthüllt: Aufrufen des Speicherrecyclingprozesses proaktiv.
Ein Collectgarbage () -Prozess (normalerweise als GC -Prozess bezeichnet) wird in (Microsoft) Jscript bereitgestellt. Der GC -Prozess wird verwendet, um die "fehlgeschlagene Objektfehlausrichtung" im aktuellen IE zu beseitigen, dh dem Destruktor -Prozess, das Objekt aufzurufen.
Im obigen Beispiel lautet der Code, der die GC -Prozedur aufruft,:
Kopieren Sie den Code wie folgt: // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Standardaufrufmethode von GC -Prozeduren bei der Verarbeitung von ActiveX -Objekt
// ---------------------------------------------------------
Funktion writexls () {
//(leicht...)
excel.quit ();
excel = null;
setTimeout (Collectgarbage, 1);
}
Die erste Codezeile ruft die Excel.Quit () -Methode auf, um den Excel -Prozess abbrechen und beenden. Da die JavaScript -Umgebung zu diesem Zeitpunkt eine Excel -Objektinstanz hat, fällt der Excel -Prozess nicht tatsächlich ab.
Die zweite Codezeile macht Excel null, um Objektreferenzen zu löschen und so das Objekt "ungültig zu machen". Da sich das Objekt jedoch noch im Funktionskontext befindet, wird das Objekt immer noch nicht gereinigt, wenn die GC -Prozedur direkt aufgerufen wird.
Die dritte Codezeile verwendet setTimeout (), um die CollectGarbage -Funktion aufzurufen, und das Zeitintervall wird auf '1' gesetzt, wodurch der GC -Prozess nur nach Ausführung der Funktion writexls () stattfindet. Auf diese Weise erfüllt das Excel -Objekt zwei Bedingungen von "kann von GC aufgeräumt werden": keine Referenz und Verlassen des Kontextes.
Die Verwendung von GC -Prozeduren ist in JS -Umgebungen mithilfe von ActiveX -Objekt sehr effektiv. Einige potenzielle ActiveX -Objekte umfassen XML, VML, OWC (Office Web Componet), Flash und sogar Vbarray in JS.
Aus dieser Sicht bietet die AJAX -Architektur XMLHTTP und muss auch die Funktion "No Page Switching" erfüllen. Wenn Sie den GC -Prozess zu angemessenen Zeiten aktiv aufrufen, erhalten Sie eine bessere Effizienzerfahrung mit der Benutzeroberfläche.
Tatsächlich wird das oben erwähnte Excel -Problem auch beim GC -Prozess nicht vollständig gelöst. Weil dh auch Berechtigungsnachweise zwischengeschnitten werden. Die einzige Möglichkeit, die Berechtigungsnachweise der Seite zu aktualisieren, besteht darin, "auf eine neue Seite umzusteigen". Tatsächlich war die von mir verwendete Methode nicht GC, sondern der folgende Code:
Kopieren Sie den Code wie folgt: // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Seitenschaltcode, die bei der Verarbeitung von ActiveX -Objekt verwendet wird
// ---------------------------------------------------------
Funktion writexls () {
//(leicht...)
excel.quit ();
excel = null;
// Der folgende Code wird verwendet, um einen Fehler in IE Call Excel zu lösen, der in MSDN angegebenen Methode:
// setTimeout (COMMANTGARBAG, 1);
// Da der vertrauenswürdige Zustand der Webseite nicht gelöscht (oder synchronisiert) werden kann, wird Saveas () und andere Methoden dazu führen
// Das nächste Mal ungültig, wenn Sie es anrufen.
location.reload ();
}
Schließlich wird eine ergänzende Anmerkung zu GC: Wenn das IE -Formular minimiert wird, nennt der IE es aktiv einmal.
COLLECTGARBAGE () -Funktion. Dadurch wird die Speicherverwendung nach dem minimierten IE -Fenster erheblich verbessert.
Ich hoffe, dass die Beschreibung in diesem Artikel basierend auf JavaScript für die Webprogrammierung aller hilfreich ist.