精华内容
下载资源
问答
  • using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks...using Excel = Microsoft.Office.Interop.Excel; using System.Text.RegularExpressions;...
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Excel = Microsoft.Office.Interop.Excel;
    using System.Text.RegularExpressions;
    using System.IO;
    using System.Runtime.Serialization;
    using System.Runtime.Serialization.Formatters.Binary;
    
    
    namespace CpmBigDataImportService
    {
        /// <summary>
        /// 通用拆分工作表类
        /// </summary>
        public class DetachSheetCommon
        {
            /// <summary>
            /// 构造方法
            /// </summary>
            /// <param name="sht"></param>
            /// <param name="titleStartLine">标题开始行</param>
            /// <param name="titleEndLine">标题结束行</param>
            /// <param name="flagCols">拆分列,int数组</param>
            /// <param name="type">拆分方式 0工作表 1工作簿 2全部</param>
            public DetachSheetCommon(Excel.Application app, Excel.Worksheet sht, int titleStartLine, int titleEndLine, int[] flagCols, int type = 0)
            {
                this.app = app;
                this.sht = sht;
                this.DetachType = type;
    
                string dimension = sht.UsedRange.Address[false, false];
                string[] addresses = dimension.Split(':');
                string lastCellAddress = addresses[addresses.Length - 1];
                this.endColNum = MyCommon.LetterToInt(GetColumnLetter(lastCellAddress));
    
                this.TitleStartLine = titleStartLine;
                this.TitleEndLine = titleEndLine;
                this.startLine = titleEndLine + 1;
    
    
                this.flagCols = flagCols;
    
                this.endLine = GetRowNumber(lastCellAddress);
    
                if (this.endLine <= 1)
                    throw new Exception("行数错误!");
            }
    
            private Excel.Application app;
    
            /// <summary>
            /// 获取单元格地址字母
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            private string GetColumnLetter(string str)
            {
                return Regex.Replace(str, "[0-9]", "", RegexOptions.IgnoreCase);
            }
    
            private int GetRowNumber(string str)
            {
                return int.Parse(Regex.Replace(str, "[A-Z]", "", RegexOptions.IgnoreCase));
            }
    
            /// <summary>
            /// 被拆分工作表
            /// </summary>
            private Excel.Worksheet sht;
    
            /// <summary>
            /// 被拆分工作表
            /// </summary>
            public Excel.Worksheet Sht
            {
                get { return sht; }
                set { sht = value; }
            }
    
            /// <summary>
            /// 开始列,默认1
            /// </summary>
            private int startColNum = 1;
    
            /// <summary>
            /// 结束列 usedrange最后一列
            /// </summary>
            private int endColNum;
    
            /// <summary>
            /// 开始行
            /// </summary>
            private int startLine;
    
            /// <summary>
            /// 结束行
            /// </summary>
            private int endLine;
    
            /// <summary>
            /// 标题 开始行 默认1
            /// </summary>
            public int TitleStartLine { set; get; }
    
            /// <summary>
            /// 标题 结束行 默认1
            /// </summary>
            public int TitleEndLine { set; get; }
    
            /// <summary>
            /// 拆分列
            /// </summary>
            private int[] flagCols;
    
            /// <summary>
            /// 拆分方式 0工作表 1工作簿 2全部
            /// </summary>
            public int DetachType { set; get; }
    
    
    
            public void Check()
            {
                TitleStartLine = (TitleStartLine == 0) ? 1 : TitleStartLine;
                TitleEndLine = (TitleEndLine == 0) ? 1 : TitleEndLine;
                endColNum = (endColNum == 0) ? 1 : endColNum;
            }
    
            /// <summary>
            /// 提示信息
            /// </summary>
            /// <returns></returns>
            public string GetMsg()
            {
                List<string> ls = new List<string>();
                ls.Add(string.Format("文件路径:{0}", ((Excel.Workbook)this.sht.Parent).FullName));
                ls.Add(string.Format("标题开始行:{0},标题结束行:{1}", TitleStartLine, TitleEndLine));
                ls.Add(string.Format("开始行:{0} 开始列:{1}  结束行:{2} 结束列:{3}"
                    , startLine, startColNum.ToString() + "/" + MyCommon.IntToLetter(startColNum)
                    , endLine, endColNum.ToString() + "/" + MyCommon.IntToLetter(endColNum)
                    ));
                ls.Add(string.Format("拆分列:{0}", GetCols(flagCols)));
                ls.Add(string.Format("拆分类型:{0}", GetDetachType(DetachType)));
                //ls.Add(string.Format(""));
    
                return string.Join(Environment.NewLine, ls.ToArray());
            }
    
            private string GetCols(int[] cols)
            {
                List<string> ls = new List<string>();
                for (int i = 0; i < cols.Length; i++)
                {
                    ls.Add(string.Format("【{0}/{1}】", cols[i], MyCommon.IntToLetter(cols[i])));
                }
    
                return string.Join("", ls.ToArray());
            }
    
            private string GetDetachType(int type)
            {
                if (0 == type)
                    return "工作表";
                else if (1 == type)
                    return "工作簿";
                else
                    return "工作表及工作簿";
            }
    
    
            /// <summary>
            /// Clones the specified list.
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="List">The list.</param>
            /// <returns>List{``0}.</returns>
            public static List<T> Clone<T>(object List)
            {
                using (Stream objectStream = new MemoryStream())
                {
                    IFormatter formatter = new BinaryFormatter();
                    formatter.Serialize(objectStream, List);
                    objectStream.Seek(0, SeekOrigin.Begin);
                    return formatter.Deserialize(objectStream) as List<T>;
                }
            }
    
            public void Detach()
            {
                //标题
                Excel.Range rngTitle = sht.Range[sht.Cells[TitleStartLine, startColNum], sht.Cells[TitleEndLine, endColNum]];
    
                //拆分列
                Excel.Range flagRng = null; object[,] objTemp = null;
    
                //先排序
                if (flagCols.Length > 3)
                    throw new Exception("目前最多支持3个排序字段");
    
                Excel.Range rngSort = sht.Range[sht.Cells[startLine, startColNum], sht.Cells[endLine, endColNum]];
                switch (flagCols.Length)
                {
                    case 1:
                        rngSort.Sort(Key1: rngSort[1, flagCols[0]], Header: Excel.XlYesNoGuess.xlNo);
                        break;
                    case 2:
                        rngSort.Sort(Key1: rngSort[1, flagCols[0]]
                            , Key2: rngSort[1, flagCols[1]]
                            , Header: Excel.XlYesNoGuess.xlNo);
                        break;
                    case 3:
                        rngSort.Sort(Key1: rngSort[1, flagCols[0]]
                            , Key2: rngSort[1, flagCols[1]]
                            , Key3: rngSort[1, flagCols[2]]
                            , Header: Excel.XlYesNoGuess.xlNo);
                        break;
    
                }
    
    
    
                List<object[,]> flagList = new List<object[,]>();
                for (int i = 0; i < flagCols.Length; i++)
                {
                    flagRng = sht.Range[sht.Cells[startLine, flagCols[i]], sht.Cells[endLine, flagCols[i]]];
                    objTemp = flagRng.Value2;
                    flagList.Add(objTemp);
                }
    
                //分组
                Dictionary<string, List<int>> dict = new Dictionary<string, List<int>>();
                for (int i = flagList[0].GetLowerBound(0); i <= flagList[0].GetUpperBound(0); i++)
                {
                    string k = string.Empty;
                    for (int j = 0; j < flagList.Count; j++)
                    {
                        k += ((null == flagList[j][i, 1]) ? "" : flagList[j][i, 1].ToString().Trim()) + "_";
                    }
                    k = k.Substring(0, k.Length - 1);
    
                    if (!dict.ContainsKey(k))
                    {
                        List<int> rows = new List<int>();
                        rows.Add(startLine - 1 + i);
                        dict.Add(k, rows);
                    }
                    else
                    {
                        dict[k].Add(startLine - 1 + i);
                    }
                }
    
                List<string> ls = new List<string>();
    
                //新分组
                Dictionary<string, List<QuJian>> dictNew = new Dictionary<string, List<QuJian>>();
                foreach (var item in dict)
                {
                    List<string> ls1 = new List<string>();
    
                    List<int> rows = item.Value;// Clone<int>(item.Value);
                    rows.Sort();
                    int current = rows[0]; int count = 0; bool different = false;
    
                    for (int i = 1; i < rows.Count; i++)
                    {
                        int act = rows[i];
                        int shouldbe = current + count + 1;
                        if (act.Equals(shouldbe))
                        {
                            count++;
                        }
                        else
                        {
                            if (dictNew.ContainsKey(item.Key))
                            {
                                dictNew[item.Key].Add(new QuJian(current, rows[i - 1]));
                            }
                            else
                                dictNew.Add(item.Key, new List<QuJian> { new QuJian(current, rows[i - 1]) });
    
                            current = act;
                            count = 0;
                            if (!different)
                                different = true;
                        }
                    }
                    if (!different)
                    {
                        if (dictNew.ContainsKey(item.Key))
                        {
                            dictNew[item.Key].Add(new QuJian(current, rows[rows.Count - 1]));
                        }
                        else
                            dictNew.Add(item.Key, new List<QuJian> { new QuJian(current, rows[rows.Count - 1]) });
    
                    }
    
    
                }
    
                if (dictNew.Count > 0)
                {
                    //Excel.Application app1 = this.sht.Application; 
                    app.Visible = true;
                    Excel.Workbook wb1 = app.Workbooks.Add();
                    Excel.Worksheet shtNew = null;
                    Excel.Range rngContent = null;
    
    
                    foreach (var item in dictNew)
                    {
                        int count = 0;
    
                        if (MyCommon.HasSheet(wb1, "Sheet1"))
                            shtNew = wb1.Worksheets["Sheet1"];
                        else
                            shtNew = wb1.Worksheets.Add();
                        shtNew.Name = string.IsNullOrEmpty(item.Key) ? "空白" : item.Key;
    
                        count = rngTitle.Rows.Count;
                        rngTitle.Copy(shtNew.Range["A" + count.ToString()]);
    
                        count++;
                        for (int i = 0; i < item.Value.Count; i++)
                        {
                            int a = item.Value[i].StartLine;
                            int b = item.Value[i].EndLine;
    
                            rngContent = this.sht.Range[this.sht.Cells[a, startColNum], this.sht.Cells[b, endColNum]];
                            rngContent.Copy(shtNew.Range["A" + count.ToString()]);
                            count += rngContent.Rows.Count;
    
                            //if (count > 1000)
                            //    break;
                        }
    
                    }
    
                    //拆成独立工作簿
                    if (DetachType.Equals(1) || DetachType.Equals(2))
                    {
                        DetachSheetsToWorkbooks(wb1);
                    }
    
                    wb1 = sht.Parent;
                    wb1.Close(SaveChanges: false);
                    //app.Quit();
                }
    
            }
    
            /// <summary>
            /// 将将一个工作簿内工作表拆成多个独立工作簿
            /// </summary>
            /// <param name="sourceWb"></param>
            public void DetachSheetsToWorkbooks(Excel.Workbook sourceWb)
            {
                string path = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
                path = (path.EndsWith("\\")) ? path : path + "\\";
                path += DateTime.Now.ToString("MMdd_HHmmss");
                if (!Directory.Exists(path))
                    Directory.CreateDirectory(path);
    
    
                Excel.Worksheet sht = null;
    
                Excel.Application app = null;
                Excel.Workbook wbNew = null;
                Excel.Worksheet newSht = null;
    
                app = sourceWb.Application;
    
                for (int i = 1; i <= sourceWb.Worksheets.Count; i++)
                {
                    sht = sourceWb.Worksheets[i];
    
                    string filename = path + "\\" + sht.Name;
                    wbNew = app.Workbooks.Add();
                    sht.Copy(After: wbNew.Worksheets[1]);
                    newSht = wbNew.Worksheets[1]; newSht.Delete();
                    wbNew.SaveAs(Filename: filename);
                    wbNew.Close(SaveChanges: false);
                }
    
                MyCommon.ExecuteProcess("explorer.exe", path);
    
            }
    
    
            /// <summary>
            /// 区间
            /// </summary>
            private class QuJian
            {
                public int StartLine { set; get; }
                public int EndLine { set; get; }
    
                public QuJian(int startLine, int endLine)
                {
                    this.StartLine = startLine;
                    this.EndLine = endLine;
                }
    
                public override string ToString()
                {
                    return string.Format("{0}-{1}", this.StartLine, this.EndLine);
                }
            }
        }
    }
    
       private void btnDetach_Click(object sender, EventArgs e)
            {
                ((Button)sender).Enabled = false;
    
    
                string filename = txtFilename.Text;
                string sheetName = string.Empty;
                if (cmbSheetName.SelectedIndex != -1)
                {
                    sheetName = cmbSheetName.Items[cmbSheetName.SelectedIndex].ToString();
                }
                if (string.IsNullOrEmpty(filename) || string.IsNullOrEmpty(sheetName))
                {
                    MessageBox.Show("请选择工作簿及工作表!");
                    return;
                }
    
                Excel.Application app = new Excel.Application();
                app.Visible =true;
                Excel.Workbook wb = app.Workbooks.Open(Filename: filename, ReadOnly: true);
                
                Excel.Worksheet sht = wb.Worksheets[sheetName];
                int titleStartLine = int.Parse(txtTitleStartLine.Text);
                int titleEndLine = int.Parse(txtTitleEndLine.Text);
    
                List<int> flagList = new List<int>();
                string[] colsArray = txtFlag.Text.Split(',');
                foreach (var item in colsArray)
                {
                    flagList.Add(MyCommon.LetterToInt(item.Trim()));
                }
    
                int[] flags = flagList.ToArray();
                
                int type = 0;
                if (chkSheet.Checked && chkWb.Checked)
                    type = 2;
                else if (chkSheet.Checked && !chkWb.Checked)
                    type = 0;
                else if (!chkSheet.Checked && chkWb.Checked)
                    type = 1;
                else
                {
                    MessageBox.Show("请选择拆分方式(工作表/工作簿)!");
                    return;
                }
                DetachSheetCommon detach = new DetachSheetCommon(app, sht,titleStartLine,titleEndLine,flags,type);
                detach.Detach();
    
                //detach.DetachSheetsToWorkbooks(wb);
                ((Button)sender).Enabled = true;
    
            }

     

     

    展开全文
  • 1、如果你有现成的一个工作簿含有多个工作表的文件,想分成多个工作簿的话, 可以通过office2007或office2013等打开execl,然后通过execl里面的开发工具, 输入以下运行代码,执行就行(拆分的工作簿在你设置的路径...

    前提:电脑上装有office2007或office2013等,WPS不行。

    1、如果你有现成的一个工作簿含有多个工作表的文件,想分成多个工作簿的话,
    可以通过office2007或office2013等打开execl,然后通过execl里面的开发工具,
    输入以下运行代码,执行就行(拆分的工作簿在你设置的路径下):

    Sub cfb()
    Dim m As Integer
    Dim sht, sht1 As Worksheet
    '按照需要将分出来的表分成多个工作簿
    n = InputBox(“请输入excel的路径”)
    For Each sht1 In Sheets
    sht1.Copy
    ActiveWorkbook.SaveAs Filename:=n & “” & sht1.Name & “.xlsx”
    ActiveWorkbook.Close
    Next
    End Sub

    2、如果你的工作簿里只有一个工作表,但是需要根据工作表中的某个字段拆分成多个工作簿,并且以该字段值命名工作簿的话,输入以下运行代码,执行就行(拆分的工作簿在你设置的路径下):

    Sub cfb()
    Dim i, j, k, l, m As Integer
    Dim sht, sht1 As Worksheet
    m = InputBox(“想按照第几列分表!”)
    '分表前先删除多余表(将需要的工作表放最前方就行)
    Application.DisplayAlerts = False
    If Sheets.Count > 1 Then
    For i = Sheets.Count To 2 Step -1
    Sheets(i).Delete
    Next
    End If
    '通过字段名进行建表,注意需要建表的字段不能违反表名规则
    j = Sheet1.Range(“a65536”).End(xlUp).Row
    For i = 2 To j
    k = 0
    For Each sht In Sheets
    If sht.Name = Sheet1.Cells(i, m) Then
    k = 1
    End If
    Next
    If k = 0 Then
    Sheets.Add after:=Sheets(Sheets.Count)
    Sheets(Sheets.Count).Name = Sheet1.Cells(i, m)
    End If
    Next
    '通过已知到的表名进行数据筛选赋值拷贝数据
    For l = 2 To Sheets.Count
    Sheet1.Range(“a1:iv65536”).AutoFilter Field:=m, Criteria1:=Sheets(l).Name
    Sheet1.Range(“a1:iv65536”).Copy Sheets(l).Range(“a1”)
    Next
    Sheet1.Range(“a1:iv65536”).AutoFilter
    '按照需要将分出来的表分成多个工作簿
    m = InputBox(“是否需要分成多个工作簿:1.是,2.否”)
    If m = 1 Then
    n = InputBox(“请输入excel的路径”)
    For Each sht1 In Sheets
    sht1.Copy
    ActiveWorkbook.SaveAs Filename:=n & “” & sht1.Name & “.xlsx”
    ActiveWorkbook.Close
    Next
    End If
    End Sub

    3、如果你有现成的一个工作簿含有多个工作表的文件,想分成多个工作簿,并且有隐藏工作表时,弹出输入框,选择是否执行或显示当前隐藏的工作表。输入以下运行代码,执行就行(拆分的工作簿在当前目录的"拆分"文件夹中):

    Sub cfb()
    Application.ScreenUpdating = False
    Dim xpath, isNext As String
    Dim sht As Worksheet
    xpath = Application.ActiveWorkbook.Path & “\拆分”
    '如果文件夹不存在,则新建文件夹
    If Len(Dir(xpath, vbDirectory)) = 0 Then MkDir xpath
    For Each sht In Worksheets
    If sht.Visible = False Then
    'MsgBox “有隐藏工作表” & sht.Name
    '隐藏工作表是否拆分
    isNext = InputBox(“1:跳过不处理” & Chr(10) & “2:处理” & Chr(10) & “空:默认不处理”, “【” & sht.Name & “】为隐藏工作表,请选择执行方式”)
    If isNext = “2” Then
    sht.Visible = True '取消工作表的隐藏
    sht.Copy
    ActiveWorkbook.SaveAs Filename:=xpath & “” & sht.Name & “.xlsx”
    ActiveWorkbook.Close
    sht.Visible = False '恢复工作表的隐藏
    End If
    ElseIf sht.Visible = True Then
    sht.Copy
    ActiveWorkbook.SaveAs Filename:=xpath & “” & sht.Name & “.xlsx”
    ActiveWorkbook.Close
    End If
    Next
    'MsgBox “工作簿拆分完成”
    Application.ScreenUpdating = True '恢复屏幕更新
    End Sub

    以上就是大致的拆分情况。

    展开全文
  • 本篇经验贴子中,我将向大家分享如何利用函数将一个Excel工作簿中的多个工作表拆分成为单独的工作簿文件。步骤亦不负责,具体请参看内容。希望对你有所帮助! 工具/原料 microsoft office excel 2007 ...

    本篇经验贴子中,我将向大家分享如何利用函数将一个Excel工作簿中的多个工作表拆分成为单独的工作簿文件。步骤亦不负责,具体请参看内容。希望对你有所帮助!

    工具/原料

    • microsoft office excel 2007

    方法/步骤

    1. 1

      打开需要编辑的Excel文档。如图所示,工作簿下方有很多工作表。现在需要将这些工作表单独拆分开成一个个工作簿。

      怎么拆分一个Excel工作簿中的多个工作表?
    2. 2

      右键任意一个工作表标签,在弹出的下拉列表中选择查看代码。即弹出代码窗口。如下图所示。

      怎么拆分一个Excel工作簿中的多个工作表?
      怎么拆分一个Excel工作簿中的多个工作表?
    3. 3

      点击菜单插入-模块 在弹出的模块对话框中 输入以下代码:


         Private Sub 分拆工作表()
             Dim sht As Worksheet
             Dim MyBook As Workbook
             Set MyBook = ActiveWorkbook
             For Each sht In MyBook.Sheets
                 sht.Copy
                 ActiveWorkbook.SaveAs Filename:=MyBook.Path & "\" & sht.Name, FileFormat:=xlNormal     '将工作簿另存为EXCEL默认格式
                 ActiveWorkbook.Close
             Next
             MsgBox "文件已经被分拆完毕!"
         End Sub

      怎么拆分一个Excel工作簿中的多个工作表?
      怎么拆分一个Excel工作簿中的多个工作表?
    4. 4

      单击运行-运行子过程|窗体 几秒过后 弹出提示窗口“文件已被拆分完毕” 如下图所示

      怎么拆分一个Excel工作簿中的多个工作表?
      怎么拆分一个Excel工作簿中的多个工作表?
    5. 5

      返回Excel工作簿文件所在路径 查看 如下图所示 原先工作簿中的工作表已经成为单独的工作簿了!不信 可以对照查看图中的修改日期 

      怎么拆分一个Excel工作簿中的多个工作表?
    展开全文
  • Excel用代码将工作表保存为工作簿

    千次阅读 2017-12-21 13:47:48
    今天,做会计的朋友问我一个问题,怎么讲Excel的工作表拆分成单独的文件,并给我发了一个链接。  https://jingyan.baidu.com/article/75ab0bcb0ecc67d6874db27e.html  说这个在他那执行不了,他还以为是...

    今天,做会计的朋友问我一个问题,怎么讲Excel的工作表拆分成单独的文件,并给我发了一个链接。

     https://jingyan.baidu.com/article/75ab0bcb0ecc67d6874db27e.html 

    说这个在他那执行不了,他还以为是office是非正版,专门买了个正版的。

    随便试了下,发现能执行,让他截图,发现是他的工作表都是 用日期命名的,比如2016.1,然后拆分的文件就直接把 .1当成后缀名了。

    修改下,强制将保存的文件以xls结尾,让他拿去执行了。我还真是第一次知道excel 还能用 代码来执行批量操作,又学到了。

    Private Sub 分拆工作表()
           Dim sht As Worksheet
           Dim MyBook As Workbook
           Set MyBook = ActiveWorkbook
           For Each sht In MyBook.Sheets
               sht.Copy
               ActiveWorkbook.SaveAs Filename:=MyBook.Path & "\" & sht.Name & ".xls", FileFormat:=xlNormal     '将工作簿另存为EXCEL默认格式
               ActiveWorkbook.Close
           Next
           MsgBox "文件已经被分拆完毕!"
       End Sub


    展开全文
  • (本文版本office2016) 1.需要打开“开发工具”选项 2.定义宏 3.代码(文档最后) 4.执行 5.拆分完成 Sub CF() Dim myRange As Variant Dim myArray Dim titleRange As Range Dim title ...
  • OFFICE软件应用技术

    2012-11-15 10:53:22
    OFFICE基本知识。...(1)工作表拆分:把工作表窗口拆分为几个窗格。每个窗格中都包含了工作表的内容,便于对工作表中感兴趣部分对比观看。 可以进行水平拆分、垂直拆分、水平和垂直拆分 (2)工作表窗口的冻结
  • Microsoft Office Excel 2003通过拆分或冻结窗格查看工作表的两个部分:  拆分窗格  在垂直滚动条的顶端或水平滚动条的右端,指向拆分框。    当鼠标变为拆分指针 后,将拆分框向下或向左拖至所需的位置。 ...
  • office access vs mysql

    2012-06-05 12:12:00
    您可能会出于各种原因决定将数据库拆分为前端应用程序或后端应用程序。后端数据库包含并且存储在文件服务器上。链接到后端的前端数据库包含所有窗体、查询、报表、宏和模块。前端数据库将分布在用户的工作站中。...
  • 3、导出表格到Excel多表:导出表格时将每一个WORD表格保存在单独的工作表中,即WORD中有多少个表格,则在Excel中生成多少个工作表,逐一存放,同时还生成工作表目录。 4、导出表格到Excel单表:将当前文档中的所有...
  • WPS免费下载(WPS Office 2013个人版)官方下载_WPS是什么(9.1.0.4636) 更新日期:2014-05-23 小提示 支持在线字体 200多款在线字体,让设计师不再为“找字体” 烦恼;不会因缺失某种字体,导致接收到的文档 ...
  • 由于Excel 2003在单元格和行数上有限制,在报表导出到Excel中,如遇单元格数据过多或行数过多会出现异常。对用户的使用造成很大的困挠。...打开的工作簿个数 受可用内存和系统资源的限制 工作表大小 65,536 行...
  • 易通Excel助手 V1.4

    2011-02-24 10:26:53
    单元格数据类型查看器:一旦启动该功能,工作表中单元格的背景色会依据其数据类型而改变:文本数据变黄色,数字数据变蓝色,日期数据变淡红等等,颜色可以自由设置。停止该功能时,所有单元格的背景色立即恢复到变化...
  • Excel新增工具集

    2011-12-20 09:30:27
    7、按类别拆分一个工作表中的行记录(组)到新表:是指将一个工作表中的多条记录按按照某一列或某两列的类别关键(第一关键字和第二关键字)字拆分成若干个结构相同的工作表,它适合于档案数据记录的分类。...
  • 慧办公 H6.61

    2014-10-23 14:21:11
    12、1秒钟,根据类别将工作表拆分成N个工作表,每张工作表放一类内容 13、1秒钟,将多个工作表的内容合并到一张工作表里 14、1秒钟,将多个工作簿文件合并到一张工作簿里面 15、1秒钟,合并名称相同的工作表的...
  • EXCEL 2007 宝典 10/10

    2012-03-31 22:37:02
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 9/10

    2012-03-31 22:35:46
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 8/10

    2012-03-31 22:26:48
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 7/10

    2012-03-31 22:17:34
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 6/10

    2012-03-31 22:08:39
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 5/10

    2012-03-31 21:59:23
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 4/10

    2012-03-31 21:50:16
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 3/10

    2012-03-31 21:39:31
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 2/10

    2012-03-31 21:30:10
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • EXCEL 2007 宝典 1/10

    2012-03-31 21:16:22
     1.3.1 理解工作簿和工作表  1.3.2 新建空白工作簿  1.3.3 保存工作簿  1.3.4 关闭工作簿  1.3.5 打开工作簿 1.4 认识Excel 2007的工作环境  1.4.1 认识全新的用户界面  1.4.2 使用功能区  1.4.3 使用快速...
  • 2.支持将记录集导入为txt、xml以及wps excel或者office excel文件中,对超过65536行的查询结果集自动拆分工作表。 3.支持查询结果在水晶报表工具简单展示。 4.支持将查询出的结果集,批量复制到多个sql server服务器...
  • Excel百宝箱9.0无限制破解版

    热门讨论 2012-02-03 19:05:29
    工作表折分】:将当前工作表的数据按条件拆分成多个工作表,可以用任意列的数据做为拆分条件 【合并工作簿】:将指文件夹中所有工作簿中所有工作表数据合并起来。有两种合并方式:将每个工作簿中的工作表合到当前...
  • Excel百宝箱

    2012-10-27 17:09:21
    工作表折分】:将当前工作表的数据按条件拆分成多个工作表,可以用任意列的数据做为拆分条件 【合并工作簿】:将指文件夹中所有工作簿中所有工作表数据合并起来。有两种合并方式:将每个工作簿中的工作表合到当前...
  • 允许开发人员使用 C#、VB.NET 或 ASP.NET 来创建、添加、删除、重命名、编辑和移动工作表,开发人员还可以在多个充满数据的工作表之间进行复制、调换和合并操作。这个专业的 .NET Excel 类库嵌入了很多灵活显示工作...
  • 工作表折分】将当前工作表的数据按条件拆分成多个工作表,可以用任意列的数据做为拆分条件 【合并工作簿】将指文件夹中所有工作簿中所有工作表数据合并起来。有两种合并方式 【文本与数值互换】将选区的数字瞬间...

空空如也

空空如也

1 2 3 4 5 6
收藏数 110
精华内容 44
热门标签
关键字:

office拆分工作表