注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

天涯倦客的博客

祝福你朋友永远快乐!

 
 
 

日志

 
 

js操作table元素,表格的行列新增、删除汇集  

2012-11-14 22:46:44|  分类: JS |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

/************ TableTool.js ****************************************************************************************************************** 
    ************************************************************** 快速索引 *************************************************************** 
    表格行、列删除 
    【一】、 doTableRowDelete 说明:默认根据当前事件指向的对象,向上寻找TR,进行删除(可选参数:表格对象;删除的行的行号,按升序方式以逗号分割,如2,3,5;向上遍历TD几次,默认为1次) 
     
    合并表格 ****** 
    【一】、  conbainTableRow  说明:纵向单元格的内容相同的合并,传入表格对象,需要合并的列,(可选的参数,从第几行开始); 
    【二】、  combineCell  说明:横向单元格合并,传入单元格内一对象,(可选的参数,合并几个单元格<向右>;是否保留原单元格的值); 
         
    单元格与行的移动 ****** 
    【一】、  moveUp  说明:进行上移,(可选参数,最上移动到第几行,默认为第零行;需要移动的行或者td对象或者td内的子对象,默认获取当前事件指向的行) 
    【二】、  moveDown  说明:进行下移,(可选参数,最低移动到倒数第几行,默认为倒数第零行;需要移动的行或者td对象或者td内的子对象,默认获取当前事件指向的行) 
    【三】、  moveCell  说明:行交换,表格对象、交换的行的行号  
     
    赋值单元格样式 ****** 
    【一】、 cloneStyle  说明:将模板单元格的样式COPY到目标单元格上,模板单元格,要修正样式的单元格     
     
    新增行、列 ******  
    【一】、  insertTableRow  说明:新增行,表格对象,添加行的内容的数组(可选参数,每个单元格的colSpan的数组参数,默认取前一行的属性; 添加到的行的行号,默认是最后一行) 
    【二】、  insertTableCol  说明:新增列,表格对象,添加行的内容的数组(可选参数,每个单元格的rowSpan的数组参数,默认取前一列的属性;添加到的列的列号,默认是最后一列) 
     
    获取表格中一行的元素 ****** 
    【一】、  doGetRowObj  说明: 获取表格中行内的元素 ,表格对象,行号,(可选参数,是否copy对象,默认为false;是否获取单元格对象,默认false) 
     
    其他验证与参数获取 ****** 
    【一】、  doFetchBaseCols   说明:获取列号在表格内行中的实际位置,表格对象,列号;返回一个数组,记录每行中指定的单元格的cellIndex 
    【二】、  doFetchEffectCells  说明:获取插入当前行,被影响到rowSpan属性的单元格集合 
    【三】、  calculateSpanWidth 说明:计算Span的宽度,根据当前span外的单元格的宽度,(可选参数:容器对象,容器对象为空时,取当前document,即遍历页面上所有的Span对象) 
     
    ******************************************************************************************************************************************* 
    ***********************************************************************************************************************************************/ 
      
    /** 
    * 删除表格的行 
    * 
    * tdCount 根据当前event事件向上追溯TD对象几次,默认为1次  
    *  
    * 说明:event事件需要附着在将要删除的TD内部,且不能有多重TD的嵌套;否则需要指定嵌套几层TD对象 
    */ 
    function doTableRowDelete(){  
        var tablObj = arguments[0];  
        var trIndexs = arguments[1];  
        var tdCount = arguments[2]==undefined?1:parseFloat(arguments[2]);  
        if(trIndexs==undefined){  
            tdCount = tdCount-1;   
            var tdObj = event.srcElement;  
            var trObj,tableObj;  
            while(tdCount > 0){  
                tdCount--;  
                while(tdObj.tagName != 'TD'){  
                    tdObj = tdObj.parentNode;  
                }  
                tdObj = tdObj.parentNode;  
            }  
            while(tdObj.tagName != 'TD'){  
                tdObj = tdObj.parentNode;  
            }  
            trObj = tdObj.parentNode;  
            tableObj = trObj.parentNode;  
            if(tableObj.tagName != 'TABLE'){  
                tableObj = tableObj.parentNode;  
            }  
            var cellIndex = tdObj.cellIndex;  
            var rowIndex = trObj.rowIndex;  
            var effectCells = doFetchEffectCells(tableObj,rowIndex);  
            for(var i=0;i<effectCells.length;i++){  
                effectCells[i].rowSpan = effectCells[i].rowSpan - 1;  
            }  
            tableObj.deleteRow(rowIndex);  
        }else{  
            var delIndexArr = trIndexs.split(",");  
            for(var i=delIndexArr.length-1;i>-1;i--){  
                tablObj.deleteRow(delIndexArr[i]);  
            }  
        }  
        isDeleteFlag = true;  
        return isDeleteFlag;  
    }  
      
    /** 
    * 删除表格的列 
    * 
    * tdCount 根据当前event事件向上追溯TD对象几次,默认为1次  
    *  
    * 说明:event事件需要附着在将要删除的TD内部,且不能有多重TD的嵌套;否则需要指定嵌套几层TD对象 
    */ 
    function doTableColDelete(){  
        var isDeleteFlag = false;  
        var tdCount = arguments[0]==undefined?1:parseFloat(arguments[0]);  
        var tdObj = event.srcElement;  
        while(tdCount!=0){  
            tdCount--;  
            while(tdObj.tagName != 'TD'){  
                tdObj = tdObj.parentNode;  
            }  
        }  
        var trObj = tdObj.parentNode;  
        var tableObj = trObj.parentNode;  
        var cellIndex = tdObj.cellIndex;  
        var rowIndex = trObj.rowIndex;  
        tableObj.deleteRow(rowIndex);  
        isDeleteFlag = true;  
        return isDeleteFlag;  
    }  
      
    /** 
    * 根据Span外最临近的TD的宽度计算重置当前Span的宽度 
    * 
    * obj 可以是页面上一个容器对象,TR、TD、TABLE,此项为空,则会遍历页面上所有的Span对象 
    */ 
    function calculateSpanWidth(){  
        var obj = arguments[0];   
        var spanObjs;  
        if(obj!=undefined){   
            spanObjs = obj.getElementsByTagName('span');  
        }else{  
            spanObjs = document.getElementsByTagName('span');  
        }  
        for(var i=0;i<spanObjs.length;i++){  
            var tdObj = spanObjs[i].parentNode;  
            while(tdObj.tagName!='TD'&&typeof(tdObj)=='Object'){  
                tdObj = tdObj.parentNode;  
            }  
            if(tdObj.tagName=='TD'){  
                var offsetWidth = tdObj.offsetWidth;  
                spanObjs[i].style.width = offsetWidth-5;  
            }   
        }  
    }  
      
    /** 
     * 合并表格中纵向相邻单元格的内容相同的项 
     * 
     * tableObj 表格对象(必须) 
     * combainCols 需要合并的列 (格式:从小到大,连续的用-分割,独立的用逗号; 例如:1-5,7,9) 
     * beginRowIndex 从第几行开始合并, 默认从第零行开始 
     */ 
    function conbainTableRow(){  
        var tableObj = arguments[0];  
        var combainCols = arguments[1];  
        var beginRowIndex = arguments[2]==undefined?0:arguments[2];  
          
        //var beginColIndex = arguments[3]==undefined?0:arguments[3];  
        var colsArr = combainCols.split(",");  
        var cols = new Array();  
        var index = 0;  
        for(var i=0;i<colsArr.length;i++){  
            var indexChar = colsArr[i].indexOf("-");  
            if(indexChar!=-1){  
                var beginIndex = parseInt(colsArr[i].substring(0,indexChar));  
                var endIndex = parseInt(colsArr[i].substring(indexChar+1));  
                for(var j=beginIndex;j<=endIndex;j++){  
                    cols[index++] = j;  
                }  
            }  
            else{  
                cols[index++] = parseInt(colsArr[i]);  
            }  
        }   
        if(tableObj.rows.length>beginRowIndex){  
            var modelArr = new Array();  
            for(var i=beginRowIndex;i<tableObj.rows.length;i++){  
                var row = tableObj.rows[i];  
                for(var k=cols.length-1;k>=0;k--){  
                    var j = cols[k];  
                    if(modelArr[j]==undefined){  
                        modelArr[j] = row.cells[j];  
                    }else{  
                        if(row.cells[j].outerText == modelArr[j].outerText){  
                            modelArr[j].rowSpan = modelArr[j].rowSpan + 1;  
                            row.deleteCell(j);  
                        }else{  
                            modelArr[j] = row.cells[j];  
                        }  
                    }  
                }  
            }  
        }  
    }  
      
    /** 
     * 行上移 
     * 
     *minRowIndex 向上移动到的最小行号,默认时零 
     * Elm 可以缺省,如果当前需要移动的行与激发本函数的位置有比较复杂的关系时,需要自行指名tr对象或者当前行的td对象传入 
     *  
     * 返回,移动成功返回true,如果当前时第minRowIndex行则返回false 
     */ 
    function moveUp(){  
        //传入的对象  
        var minRowIndex = arguments[0]==undefined?0:arguments[0];  
        //传入的对象  
        var Elm = arguments[1];  
        //返回值  
        var isSuccess = false;  
        //表格对象  
        var myTable;  
        if(Elm==undefined){  
            Elm=event.srcElement;  
        }  
        while(Elm&&Elm.tagName!="TR"){  
            Elm=Elm.parentElement;     
        }  
        //当前行号  
        var x = Elm.rowIndex;  
        //获取表格对象  
        myTable = Elm.parentElement;  
        if(myTable.tagName!='TABLE'){  
            myTable = myTable.parentNode;  
        }  
        //移到上一行  
        if (x > minRowIndex){  
            moveCell(myTable, x, x-1);  
            isSuccess = true;  
        }  
        return isSuccess;  
    }  
 
   /** 
     * 行下移 
     * 
     *minRowIndex 向下移动到表格的倒数几行,默认是零,即表格的最后一行 
     * Elm 可以缺省,如果当前需要移动的行与激发本函数的位置有比较复杂的关系时,需要自行指名tr对象或者当前行的td对象传入 
     *  
     * 返回,移动成功返回true,如果当前时最后一行则返回false 
     */ 
    function moveDown(){  
            //传入的对象  
            var minRowIndex = arguments[0]==undefined?0:arguments[0];  
            //传入的对象  
            var Elm = arguments[1];  
            //返回值  
            var isSuccess = false;  
            //表格对象  
            var myTable;  
            if(Elm==undefined){  
                Elm=event.srcElement;  
            }  
            while(Elm&&Elm.tagName!="TR"){  
                Elm=Elm.parentElement;     
            }  
            //当前行号  
            var x = Elm.rowIndex;  
            //获取表格对象  
            myTable = Elm.parentElement;  
            if(myTable.tagName!='TABLE'){  
                myTable = myTable.parentNode;  
            }  
            var tableLength = myTable.rows.length;  
            //移到下一行  
            if (x < tableLength-minRowIndex-1){  
                moveCell(myTable, x, x+1);  
                isSuccess = true;  
            }  
            return isSuccess;  
    }  
 
    /** 
     * 行交换,处理了checkbox丢值的问题 
     * 
     *myTable 表格对象 
     * a 行号 
     * b 行号 
     */ 
    function moveCell(myTable, a, b){  
          var e2 = myTable.rows[a].all.tags("input");  
          var e3 = myTable.rows[b].all.tags("input");  
          var arr = [];  
          //遍历a行的所有input控件  
          for(i = 0; i < e2.length; i++) {  
              if(e2[i].type == "checkbox"){  
                  //对所有checkbox控件添加到数组中  
                  arr.push(e2[i], e2[i].checked);  
              }  
          }  
          //遍历b行的所有input控件  
          for(i = 0; i < e3.length; i++) {  
              if(e3[i].type == "checkbox"){  
                  //对所有checkbox控件添加到数组中  
                  arr.push(e3[i], e3[i].checked);  
              }  
          }  
          myTable.moveRow(a, b);  
          //对数组中所有元素获得对象并对引用的对象赋原值  
          while(arr.length > 0){  
              arr.shift().checked = arr.shift();  
          }  
    }  
      
    /** 
    *替换单元格的样式为传入的单元格样式 
    * 
    *tdObj 模板单元格 
    *targetTdObj 目标替换的单元格 
    * 
    */ 
    function cloneStyle(){  
        //单元格中对象  
        var tdObj = arguments[0];  
        //合并列数  
        var targetTdObj = arguments[1];  
        //克隆传入的对象  
        var tempObj = tdObj.cloneNode(false);  
        //克隆目标对象  
        var targetHtml = targetTdObj.innerHTML;  
        //横向合并的个数  
        var colspan = targetTdObj.colSpan;  
        //纵向合并的个数  
        var rowspan = targetTdObj.rowSpan;  
        //宽度  
        var width = targetTdObj.width;  
          
        //行对象  
        var  rowObj = tdObj.parentNode;  
        //替换当前单元格  
        rowObj.replaceChild(tempObj, targetTdObj);  
        //for(var i=0;i<targetObj.childNodes.length;i++){  
        //  tempObj.appendChild(targetObj.childNodes[i]);  
        //}  
        tempObj.innerHTML = targetHtml;  
        tempObj.colSpan = colspan;  
        tempObj.rowSpan = rowspan;  
        tempObj.width = width;  
    }  
 
    /** 
     * 合并单元格,TODO:行合并暂未实现 
     * 
     * obj 单元格中对象 
     * colspan 合并列数 
     * rowspan 合并的行数 
      *keepFlag 是否保留每个单元格的值 
     */ 
    function combineCell(){  
        //单元格中对象  
        var obj = arguments[0];  
        //合并列数  
        var colspan = arguments[1]==undefined?1:arguments[1];  
        //合并的行数  
        var rowspan = arguments[2]==undefined?1:arguments[2];  
        //是否保留每个单元格的值  
        var keepFlag = arguments[3]==undefined?false:arguments[3];  
 
        var elementObjs = new Array();  
        var tdObj = obj.tagName!='TD'?obj.parentNode:obj;  
        var trObj = tdObj.parentNode;  
        var tableObj = trObj.parentNode;  
        if(tableObj.tagName!='TABLE'){  
            tableObj = tableObj.parentNode;  
        }  
        //当前单元格的原来的格式  
        var colIndex = tdObj.cellIndex;  
        var rowIndex = trObj.rowIndex;  
        //  
        //var colIndexs;  
        //if(rowspan>1){  
        //  colIndexs = doFetchBaseCols(tableObj,doGetColIndex(obj));  
        //}  
        for(var i=colspan-1;i>0;i--){  
            //alert("i+colIndex="+(i+colIndex));  
            //alert("trObj.cells.length="+trObj.cells.length);  
            var tempObj = trObj.cells[i+colIndex].cloneNode(true);  
            elementObjs[elementObjs.length] = tempObj;  
            trObj.removeChild(trObj.cells[i+colIndex]);  
        }  
        tdObj.colSpan = tdObj.colSpan + colspan - 1;  
        //alert("keepFlag="+keepFlag);  
        //alert("elementObjs.length="+elementObjs.length);  
        //添加每个单元格的对象  
        if(keepFlag&&elementObjs.length>0){  
            for(var i=elementObjs.length-1;i>-1;i--){  
                var tempObj = elementObjs[i];  
                for(var j=0;j<tempObj.childNodes.length;j++){  
                    tdObj.appendChild(tempObj.childNodes[j]);  
                }     
            }  
              
        }  
    }  
 
    /** 
     * 对表格新增一行 
     * 
     * tableObj 被新增的表格对象 
     * htmlArr添加内容对象数组, 
     * htmlCols 每个td的元素对应的colSpan参数,为空则获取之前的Tr信息,否则根据htmlCols生成 
     * rowIndex 行号 默认方式在最后一行新增行,从零开始 
     * 
     *返回新增成功、失败 
     */ 
    function insertTableRow(){  
        //表格对象  
        var tableObj = arguments[0];  
        //增加对象集  
        var htmlArr = arguments[1];  
        //元素的TD的colSpan属性  
        var htmlCols = arguments[2]==undefined?new Array():arguments[2];  
        //增加的行位置  
        var rowIndex = arguments[3];  
        //根据当前table表的行数,进行参数的处理  
        if(tableObj==undefined||tableObj.rows==undefined){  
            rowIndex = 0;  
        }else if(rowIndex==undefined||rowIndex>tableObj.rows.length){  
            rowIndex = tableObj.rows.length;  
        }  
        //新增行成功标志,默认失败  
        var isSuccess = doCheckPara(tableObj,htmlArr,htmlCols,rowIndex);  
        if(isSuccess){  
            //新增行  
            //alert("tableObj="+tableObj.rows.length+"\nrowIndex="+rowIndex);  
            //alert("htmlArr.length="+htmlArr.length);  
            var newTrObj = tableObj.insertRow(rowIndex);  
            for(var i=0;i<htmlArr.length;i++){  
                var cellObj = newTrObj.insertCell(i);   
                //判断传入参数不为空,添加对象  
                if(htmlArr[i]!=undefined && htmlArr[i]!=null){  
                    if(htmlArr[i].constructor == Array){  
                        var childHtmlArr = htmlArr[i];  
                        for(var k=0;k<childHtmlArr.length;k++){  
                            if(typeof(childHtmlArr[k])=='object'){  
                                cellObj.appendChild(childHtmlArr[k]);  
                            }  
                        }  
                    }else{  
                        if(typeof(htmlArr[i])=='object'){  
                            cellObj.appendChild(htmlArr[i]);  
                        }else{  
                            cellObj.innerHTML = htmlArr[i];  
                        }  
                    }  
                }  
                if(htmlCols[i]!=undefined && htmlCols[i]!="" && htmlCols[i]!="1"){  
                    cell.colSpan=htmlCols[i];  
                }  
            }  
            isSuccess = true;  
        }  
        return isSuccess;  
    }  
      
    /** 
     * 对表格新增一行 
     * 
     * tableObj 被新增的表格对象 
     * htmlArr 添加内容对象数组, 
     * htmlRows 每个td的元素对应的rowSpan参数,为空则获取之前的Td信息,否则根据htmlRows生成 
     * colIndex 行号 默认方式在最后一列新增列(此处的指定列进行插入,在表格中存在rowSpan!=1的情况下会有有问题),从零开始 
     * 
     *返回新增成功、失败 
     */ 
    function insertTableCol(){  
        //表格对象  
        var tableObj = arguments[0];  
        //增加对象集  
        var htmlArr = arguments[1];  
        //元素的TD的rowSpan属性  
        var htmlRows = arguments[2]==undefined?new Array():arguments[2];  
        //增加的列位置  
        var colIndex = arguments[3];  
        //alert(colIndex);  
        var baseHtmlCols = doFetchBaseCols(tableObj,colIndex);  
        //判断返回为undefined,则表示当前不可进行插入操作  
        if(baseHtmlCols==undefined){  
            return false;  
        }  
        //新增行成功标志,默认失败  
        var isSuccess = doCheckPara(tableObj,htmlArr,htmlRows,colIndex,false,baseHtmlCols);  
          
        if(isSuccess){  
            //新增行  
            var rowSpanCount = 0;  
            var rowIndex = 0;  
            //alert("htmlArr.length="+htmlArr.length);  
            for(var i=0,rowIndex=0;rowIndex<tableObj.rows.length&&rowIndex<htmlArr.length;i++){  
                var trObj = tableObj.rows[rowIndex];  
                var index = baseHtmlCols[rowIndex];  
                var cellObj = trObj.insertCell(index);  
                //判断传入参数不为空,添加对象  
                if(htmlArr[i]!=undefined && htmlArr[i]!=null){  
                    if(htmlArr[i].constructor == Array){  
                        var childHtmlArr = htmlArr[i];  
                        for(var k=0;k<childHtmlArr.length;k++){  
                            if(typeof(childHtmlArr[k])=='object'){  
                                cellObj.appendChild(childHtmlArr[k]);  
                            }  
                        }  
                    }else{  
                        if(typeof(htmlArr[i])=='object'){  
                            cellObj.appendChild(htmlArr[i]);  
                        }else{  
                            cellObj.innerHTML = htmlArr[i];  
                        }  
                    }  
                }  
                if(htmlRows[i]!=undefined && htmlRows[i]!="" && htmlRows[i]!="1"){  
                    cellObj.rowSpan=htmlRows[i];  
                }  
                //alert(htmlRows[0]+"\n"+htmlRows[1]+"\n"+htmlRows[2]+"\n"+htmlRows[3]+"\n");  
                //跳过已经被合并的行  
                rowIndex = rowIndex + (htmlRows[i]!=undefined?parseFloat(htmlRows[i]):1);  
                //alert(rowIndex);  
            }  
            isSuccess = true;  
        }  
        return isSuccess;  
    }  
      
   /** 
    *获取表格中一行的元素,对象数组,返回单元格对象数组、单元格的第一个子对象数组 
    *  
    * tableObj 表格对象 
    * rowIndex 获取的行号 ,从零开始 
    * isCopy  获取copy对象,默认为false,不进行copy 
    * isCellObj  获取单元格对象数组标志,,默认为false,返回单元格的子对象 
    */ 
    function doGetRowObj(){  
        var objArr = new Array();  
        //表格对象  
        var tableObj = arguments[0];  
        //增加对象集  
        var rowIndex = arguments[1];  
        //是否获取COPY对象  
        var isCopy = arguments[2]==undefined?false:arguments[2];  
        //是否为单元格对象  
        var isCellObj = arguments[3]==undefined?false:arguments[3];  
          
        //c判断为当前为拷贝时  
        if(isCopy){  
            //var copyTable = document.body.createTextRange();  
            //copyTable.moveToElementText(tableObj);  
            var memeoryTable = tableObj.cloneNode(true);   
            tableObj = memeoryTable;  
        }  
        //判断对象为空或者不是一个表格对象时  
        if(tableObj==undefined || tableObj.tagName!="TABLE"){  
            alert("传入表格(tableObj)不是一个对象或表格!");  
            return objArr;  
        }  
        //判断表格内容为空时  
        if(tableObj.rows==undefined||tableObj.rows.length==0){  
            alert("当前表格对象为空!");  
            return objArr;  
        }  
        //判断要读取的行参数为空  
        if(rowIndex==undefined){  
            alert("未指名获取的行号!");  
            return objArr;  
        }  
        //判断当前要获取的行超过表格对象的范围  
        if(rowIndex<0 || rowIndex>=tableObj.rows.length){  
            alert("要获取的行号不在当前的表格对象内!");  
            return objArr;  
        }  
        //进行行内容提取,返回对象  
        var rowObj = tableObj.rows[rowIndex];  
        for(var i=0;i<rowObj.cells.length;i++){  
            var cellObj = rowObj.cells[i];  
            var objCopy;  
            //返回当前单元格  
            if(isCellObj){  
                objCopy = cellObj;  
            }  
            else{  
                objCopy = cellObj.childNodes!=undefined?cellObj.childNodes[0]:undefined;  
            }  
            objArr[i] = objCopy;  
        }  
        return objArr;  
    }  
      
 

/Files/lhws/js操作table元素表格的行列新增删除汇集.txt

from:http://www.cnblogs.com/lhws/archive/2012/02/14/2350628.html

  评论这张
 
阅读(1006)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017