Cet article décrit la méthode d'exportation Excel par JavaScript. Partagez-le pour votre référence. La méthode de mise en œuvre spécifique est la suivante:
La copie de code est la suivante: <html xmlns = "http://www.w3.org/1999/xhtml">
<adal>
<meta http-equiv = "contenu-type" contenu = "text / html; charset = utf-8" />
<Title> Comment exporter les pages Web sous forme de documents Excel </TITME>
</ head>
<body>
<table id = "TableExcel" Cellpacing = "0" CellPadding = "0">
<tr>
<td Colspan = "5" Align = "Center"> Comment exporter les pages Web sous forme de documents Excel </td>
</tr>
<tr>
<TD> Titre de la colonne 1 </td>
<TD> Titre de la colonne 2 </td>
<TD> Titre de la colonne 3 </td>
<TD> Titre de la colonne 4 </td>
<TD> Titre de la colonne 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 = "bouton" onClick = "javascript: méthode1 ('TableExcel');" Value = "La première méthode est importée dans Excel">
<input type = "bouton" onClick = "javascript: méthode2 ('TableExcel');" Value = "La deuxième méthode est importée dans Excel">
<entrée type = "bouton" onClick = "javascript: getxlsfromtbl ('TableExcel', null);" Value = "La troisième méthode est importée dans Excel">
<Script linguisse = "javascript">
Fonction Method1 (tableId) {// Copiez la table entière pour exceller
var curtbl = document.getElementByidx_x_x (tableId);
var oxl = new activeXObject ("Excel.Application");
// Créer un objet AX Excel
var owb = oxl.workbooks.add ();
// Obtenez l'objet de classeur
var osheet = owb.activeSheet;
// Activez la feuille actuelle
var sel = document.body.CreateExtrange ();
sel.movetoelementText (curtbl);
// déplace le contenu dans la table vers TexTrange
sel.select ();
// sélectionnez tous les contenus dans Textrange
sel.execcommand ("copie");
// Copiez le contenu dans Textrange
Osheet.paste ();
// Collez dans l'Excel actif
oxl.visible = true;
// Définissez un attribut excel visible
}
Fonction Method2 (TableID) // Lisez chaque cellule de la table dans Excel
{
var curtbl = document.getElementByidx_x_x (tableId);
var oxl = new activeXObject ("Excel.Application");
// Créer un objet AX Excel
var owb = oxl.workbooks.add ();
// Obtenez l'objet de classeur
var osheet = owb.activeSheet;
// Activez la feuille actuelle
var lenr = curtbl.Rows.length;
// Obtenez le nombre de lignes dans le tableau
pour (i = 0; i <lenr; i ++)
{
var lec = curtbl.Rows (i) .Cells.length;
// Obtenez le nombre de colonnes par ligne
pour (j = 0; j <lec; j ++)
{
Osheet.Cells (I + 1, J + 1) .Value = Curtbl.Rows (i) .Cells (J) .InnerText;
//Affectation
}
}
oxl.visible = true;
// Définissez un attribut excel visible
}
function getxlsfromtbl (innteblid, inwindow) {
essayer {
var allstr = "";
var curstr = "";
// alert ("getxlsfromtbl");
if (innteBlid! = null && innteblid! = "" && innteblid! = "null") {
curstr = getTbldata (innteblid, inwindow);
}
if (curstr! = null) {
allstr + = curstr;
}
autre {
alert ("Le tableau que vous souhaitez exporter n'existe pas!");
retour;
}
var filename = getExCelfileName ();
DOFILEExport (nom de fichier, allstr);
}
catch (e) {
alert ("Exception s'est produite dans l'exportation:" + e.name + "->" + e.description + "!");
}
}
fonction gettbldata (intbl, inwindow) {
var lignes = 0;
// alert ("getTbldata is" + inwindow);
var tblDocument = document;
if (!! inwindow && inwindow! = "") {
if (! document.all (inwindow)) {
retourner null;
}
autre {
tblDocument = EVAL_R (Inwindow) .Document;
}
}
var curtbl = tblDocument.getElementByidx_x_x (indbl);
var outstr = "";
if (curtbl! = null) {
pour (var j = 0; j <curtbl.Rows.length; j ++) {
// alert ("J est" + j);
for (var i = 0; i <curtbl.Rows [j] .cells.length; i ++) {
// alerte ("i est" + i);
if (i == 0 && lignes> 0) {
outstr + = "";
lignes - = 1;
}
outstr + = curtbl.Rows [J] .Cells [i] .InnerText + "";
if (Curtbl.Rows [J] .Cells [i] .colspan> 1) {
pour (var k = 0; k <curtbl.Rows [j] .Cells [i] .colspan - 1; k ++) {
outstr + = "";
}
}
if (i == 0) {
if (lignes == 0 && curtbl.Rows [j] .cells [i] .rowspan> 1) {
lignes = curtbl.Rows [j] .Cells [i] .rowspan - 1;
}
}
}
outstr + = "";
}
}
autre {
outstr = null;
alert (indbl + "n'exister!");
}
retour outstr;
}
fonction getExCelfileName () {
var d = new Date ();
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";
// alerte (nom de fichier);
Nom de fichier de retour;
}
fonction dofileExport (innome, instr) {
var xlswin = null;
if (!! document.all ("glbHidefrm")) {
xlswin = glbHideFrm;
}
autre {
Var largeur = 6;
var hauteur = 4;
var overpara = "Left =" + (window.screen.width / 2 - largeur / 2)
+ ", top =" + (window.screen.height / 2 - hauteur / 2)
+ ", Scrollbars = no, width =" + width + ", height =" + height;
xlswin = window.open ("", "_blank", Overpars);
}
xlswin.document.write (instant);
xlswin.document.close ();
xlswin.Document.execCommand ('Saveas', True, innome);
xlswin.close ();
}
</cript>
</docy>
</html>
Ce qui suit est le problème de traiter la fermeture des processus Excel
Copiez le code comme suit: // Problèmes de destruction dans JavaScript (Exemple d'objet ActiveX)
// ---------------------------------------------------------
<cript>
var strSavelocation = 'file: /// e: /1.xls'
function createExls () {
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 (strSavelation);
var sheet = wk.Worksheets (1);
sheet.cells (1, 1) .value = 'Test String';
wk.saveas (strSavelocation);
wk.saved = true;
excel.quit ();
}
</cript>
<body>
<bouton onClick = "CreateExls ()"> Créer </futton>
<bouton onclick = "writexls ()"> Réécrivez </futton>
</docy>
Dans cet exemple, aucune exception ne se produit lors de l'exploitation du fichier local. - Au plus, il y a juste quelques ordures de mémoire. Cependant, si StrSavellocation est une URL distante, une information d'accès aux fichiers local sera enregistrée et une seule instance (distante) peut être utilisée pour activer le document Excel et le stocker. Donc, si vous cliquez sur le bouton "Réécrire" à plusieurs reprises, une exception apparaîtra.
- Notez qu'il s'agit d'un code simplifié pour une instance d'un fichier partagé lors du fonctionnement dans SPS. Par conséquent, ce n'est pas une discussion ennuyeuse "académique", et c'est un problème pratique en ingénierie.
La solution à ce problème est compliquée. Cela implique deux problèmes:
① Libération de bons locaux
② Libération de l'instance d'objet ActiveX
Commençons par le problème "défaillance" des objets dans JavaScript. Autrement dit:
① Un objet ne sera pas valide en dehors du contexte dans lequel il vit.
② Un objet global ne sera pas valide s'il n'est pas exécuté (référencé).
Par exemple:
Copy the code as follows: //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Quand l'objet JavaScript échouera-t-il
// ---------------------------------------------------------
fonction testObject () {
var _obj1 = new object ();
}
fonction testObject2 () {
var _obj2 = new object ();
retour _OBJ2;
}
// Exemple 1
testObject ();
// Exemple 2
TestObject2 ()
// Exemple 3
var obj3 = testObject2 ();
obj3 = null;
// Exemple 4
var obj4 = testObject2 ();
var arr = [obj4];
obj3 = null;
arr = [];
Dans ces quatre exemples:
- "Exemple 1" construit _OBJ1 dans la fonction testObject (), mais lorsque la fonction quitte, il a quitté le contexte de la fonction, donc _OBJ1 est invalide;
- Dans "Exemple 2", un objet _OBJ2 est également construit dans TestObject2 () et évanoui, donc l'objet a un environnement de contexte (et une durée de vie) "en dehors de la fonction", mais comme la valeur de retour de la fonction n'est pas "maintenue" par d'autres variables, _OBJ2 est immédiatement invalide;
- Dans "Exemple 3", le _OBJ2 construit par testObject2 () est détenu par la variable externe OBJ3. À l'heure actuelle, jusqu'à ce que la ligne de code "obj3 = null" prenne effet, _OBJ2 ne sera pas invalide car la relation de référence disparaît.
- Pour la même raison que dans l'exemple 3, _obj2 dans "Exemple 4" ne sera pas invalide après la ligne de code "arr = []".
Cependant, "l'échec" de l'objet n'attend pas d'être "libéré". À l'intérieur de l'exécution JavaScript, il n'y a aucun moyen de dire à l'utilisateur exactement "Quand l'objet sera-t-il publié". Cela dépend du mécanisme de récupération de la mémoire de JavaScript. «Cette stratégie est similaire au mécanisme de recyclage de .NET.
Dans l'exemple d'exemple d'opération Excel précédent, le propriétaire de l'objet, c'est-à-dire "Excel.exe", ne se produira qu'après "la libération de l'instance d'objet ActiveX". Les verrous de fichiers et les informations d'autorisation d'autorisation du système d'exploitation sont liés au processus. Donc, si l'objet est uniquement "échoué" et non "non", alors d'autres processus auront des problèmes lors du traitement des fichiers et se référant aux informations d'autorisation du système d'exploitation.
- Certaines personnes disent que c'est un bug dans le mécanisme JavaScript ou com. En fait, ce n'est pas le cas. Cela est causé par une relation complexe entre le système d'exploitation, IE et JavaScript, plutôt qu'un problème indépendant.
Microsoft a exposé une stratégie pour résoudre ce problème: appeler de manière proactive le processus de recyclage de la mémoire.
Un processus collectiongarbage () (généralement appelé le processus GC) est fourni dans (Microsoft) JScript. Le processus GC est utilisé pour nettoyer le "désalignement de l'objet défaillant" dans le Current IE, c'est-à-dire le processus de destructeur d'appel de l'objet.
Dans l'exemple ci-dessus, le code qui appelle la procédure GC est:
Copy the code as follows: //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Méthode d'appel standard des procédures GC lors du traitement de l'objet ActiveX
// ---------------------------------------------------------
function writexls () {
//(légèrement...)
excel.quit ();
Excel = null;
setTimeout (collectiongarbage, 1);
}
La première ligne de code appelle la méthode excel.quit () pour faire avorter et quitter le processus Excel. Pour le moment, comme l'environnement JavaScript a une instance d'objet Excel, le processus Excel ne s'aborte pas réellement.
La deuxième ligne de code rend Excel Null pour effacer les références d'objet, "invalidant" l'objet. Cependant, comme l'objet est toujours dans le contexte de la fonction, si la procédure GC est appelée directement, l'objet ne sera toujours pas nettoyé.
La troisième ligne de code utilise SetTimeout () pour appeler la fonction CollectRarbage, et l'intervalle de temps est défini sur «1», ce qui a fait que le processus GC se déroule après l'exécution de la fonction writexls (). De cette façon, l'objet Excel répond à deux conditions de "peut être nettoyé par GC": aucune référence et quittant le contexte.
L'utilisation des procédures GC est très efficace dans les environnements JS à l'aide d'objet ActiveX. Certains objets potentiels ActiveX incluent XML, VML, OWC (Office Web Componet), Flash et même VBarray dans JS.
De ce point de vue, car l'architecture Ajax adopte XMLHTTP et doit également répondre à la fonction "sans commutation de page", appeler activement le processus GC à des moments appropriés vous offrira une meilleure expérience d'efficacité en utilisant l'interface utilisateur.
En fait, même avec le processus GC, le problème Excel susmentionné ne sera pas complètement résolu. Parce que IE cache également les titres d'autorisation. La seule façon de rendre les informations d'autorisation d'autorisation de la page est de "passer à une nouvelle page", donc en fait, dans le projet SPS mentionné précédemment, la méthode que j'ai utilisée n'était pas GC, mais le code suivant:
Copy the code as follows: //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Code de commutation de page utilisé lors du traitement de l'objet ActiveX
// ---------------------------------------------------------
function writexls () {
//(légèrement...)
excel.quit ();
Excel = null;
// Le code suivant est utilisé pour résoudre un bogue dans IE Call Excel, la méthode fournie dans MSDN:
// setTimeout (collectiongarbage, 1);
// Étant donné que l'état de confiance de la page Web ne peut pas être effacé (ou synchronisé) provoquera Saveas () et d'autres méthodes
// non valide la prochaine fois que vous l'appelez.
emplacement.reload ();
}
Enfin, une note supplémentaire sur GC: lorsque le formulaire IE sera minimisé, IE l'appellera activement une fois.
Fonction CollectRarbage (). Cela fait que l'utilisation de la mémoire s'améliore considérablement après la minimisation de la fenêtre IE.
J'espère que la description de cet article sera utile à la programmation Web de chacun basée sur JavaScript.