有些专家认为，AI应该视为机器所展示的智能行为，或是智能行为背后的人工大脑。即使是这样的解释，也不够全面。有些专家对AI的研究，目的在于研究人类智慧的本质，而不是为了建造智能机器。

这样就会引发出一个问题：“何谓智能？”对某些人而言，判定标准是AI技术产生的效果有多么接近人类智慧的表现;其他人则认为还必须满足额外的条件，机器才能被视为具有智能，其中有些人主张，意识是智能的必要条件，而且情绪和意识也不可分割;另一派学者则说智能必须要能够解决问题，而且要看起来好像是由人类解决似的;但即使提出这么多的条件，也还不够全面，AI还必须有学习和适应的能力，才有资格被视为有智能。

满足上述所有条件的AI，就称为“强势AI”（Strong AI）。弱势AI不同于强势AI的地方，在于涉及到比较宽的用途和科技，让机器拥有专业化的智力。游戏AI属于弱势AI的范畴。

序列化与反序列化的代码实现：

// OBJECT -> XML
    public static void SaveXml(string filePath, object obj) { SaveXml(filePath, obj, obj.GetType()); }
    public static void SaveXml(string filePath, object obj, System.Type type)
    {
        using (System.IO.StreamWriter writer = new System.IO.StreamWriter(filePath))
        {
            System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(type);
            xs.Serialize(writer, obj);
            writer.Close();
        }
    }
    // XML -> OBJECT
    public static object LoadXml(string filePath, System.Type type)
    {
        if (!System.IO.File.Exists(filePath))
            return null;
        using (System.IO.StreamReader reader = new System.IO.StreamReader(filePath))
        {
            System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(type);
            object obj = xs.Deserialize(reader);
            reader.Close();
            return obj;
        }
    }

相关的常用Attribute（命名空间System.Xml.Serialization ）解释：
    [XmlRootAttribute("PurchaseOrder", Namespace="http://www.cpandl.com", IsNullable=false)]  // 指定根
    [XmlIgnoreAttribute]                                                                      // 跳过不序列化
    [XmlArrayAttribute("Items")] public orderedItem[] orderedItems;                           // 层次序列化: <Items><OrderedItem.../><OrderedItem.../>..</Items>
    [XmlElementAttribute(ElementName="Link", IsNullable=false)] public Link[] Links;          // 平面序列化: <Link ..../><Link .../>...
    [XmlAttribute("Cat")] public string Cat;                                                  // 表现为属性<... Cat=.. />
    [XmlElementAttribute(IsNullable=false)]                                                   // 表现为节点<Cat>..</cat>

    XmlAttributes                     表示一个特性对象的集合，这些对象控制 XmlSerializer 如何序列化和反序列化对象。
    XmlArrayAttribute                 指定 XmlSerializer 应将特定的类成员序列化为 XML 元素数组。
    XmlArrayItemAttribute             指定 XmlSerializer 可以放置在序列化数组中的派生类型。
    XmlArrayItemAttributes            表示 XmlArrayItemAttribute 对象的集合。
    XmlAttributeAttribute             指定 XmlSerializer 应将类成员作为 XML 特性序列化。
    XmlChoiceIdentifierAttribute      指定可以通过使用枚举来进一步消除成员的歧义。
    XmlElementAttribute               在 XmlSerializer 序列化或反序列化包含对象时，指示公共字段或属性表示 XML 元素。
    XmlElementAttributes              表示 XmlElementAttribute 的集合，XmlSerializer 将其用于它重写序列化类的默认方式。
    XmlEnumAttribute                  控制 XmlSerializer 如何序列化枚举成员。
    XmlIgnoreAttribute                指示 XmlSerializer 的 Serialize 方法不序列化公共字段或公共读/写属性值。
    XmlIncludeAttribute               允许 XmlSerializer 在它序列化或反序列化对象时识别类型。
    XmlRootAttribute                  控制视为 XML 根元素的属性目标的 XML 序列化。
    XmlTextAttribute                  当序列化或反序列化包含类时，向 XmlSerializer 指示应将此成员作为 XML 文本处理。
    XmlTypeAttribute                  控制当属性目标由 XmlSerializer 序列化时生成的 XML 架构。
    XmlAnyAttributeAttribute          指定成员（返回 XmlAttribute 对象的数组的字段）可以包含任何 XML 属性。
    XmlAnyElementAttribute            指定成员（返回 XmlElement 或 XmlNode 对象的数组的字段）可以包含对象，该对象表示在序列化或反序列化的对象中没有相应成员的所有 XML 元素。
    XmlAnyElementAttributes           表示 XmlAnyElementAttribute 对象的集合。
    XmlAttributeEventArgs             为 UnknownAttribute 事件提供数据。
    XmlAttributeOverrides             允许您在使用 XmlSerializer 序列化或反序列化对象时重写属性、字段和类特性。
    XmlElementEventArgs               为 UnknownElement 事件提供数据。
    XmlNamespaceDeclarationsAttribute 指定目标属性、参数、返回值或类成员包含与 XML 文档中所用命名空间关联的前缀。
    XmlNodeEventArgs                  为 UnknownNode 事件提供数据。
    XmlSerializer                     将对象序列化到 XML 文档中和从 XML 文档中反序列化对象。XmlSerializer 使您得以控制如何将对象编码到 XML 中。
    XmlSerializerNamespaces           包含 XmlSerializer 用于在 XML 文档实例中生成限定名的 XML 命名空间和前缀。
    XmlTypeMapping                    包含从一种类型到另一种类型的映射。

XML序列化答疑，很重要：
    （1）需序列化的字段必须是公共的(public)
    （2）需要序列化的类都必须有一个无参的构造函数
    （3）枚举变量可序列化为字符串，无需用[XmlInclude]
    （4）导出非基本类型对象，都必须用[XmlInclude]事先声明。该规则递归作用到子元素
        如导出ArrayList对象，若其成员是自定义的，需预包含处理：
        using System.Xml.Serialization;
        [XmlInclude(typeof(自定义类))]
    （5）Attribute中的IsNullable参数若等于false，表示若元素为null则不显示该元素。
        也就是说：针对值类型（如结构体）该功能是实效的
        若数组包含了100个空间，填充了10个类对象，则序列化后只显示10个节点
        若数组包含了100个空间，填充了10个结构体对象，则序列化后会显示100个节点
    （6）真正无法XML序列化的情况
        某些类就是无法XML序列化的（即使使用了[XmlInclude]）
            IDictionary（如HashTable）
            System.Drawing.Color
            System.Drawing.Font
            SecurityAttribute声明
        父类对象赋予子类对象值的情况
        对象间循环引用
    （7）对于无法XML序列化的对象，可考虑
        使用自定义xml序列化（实现IXmlSerializable接口）
        实现IDictionary的类，可考虑（1）用其它集合类替代；（2）用类封装之，并提供Add和this函数
        某些类型需要先经过转换，然后才能序列化为 XML。如XML序列化System.Drawing.Color，可先用ToArgb()将其转换为整数
        过于复杂的对象用xml序列化不便的话，可考虑用二进制序列化

序列化中异常的扑捉：
    使用Exception.Message只会得到简单的信息“行***错误"
    可以使用Exception.InnerException.Message得到更详尽的信息

可使用事件代理来处理解析不了的XML节点：
    XmlSerializer serializer = new XmlSerializer(typeof(PurchaseOrder));
    serializer.UnknownNode+= new XmlNodeEventHandler(serializer_UnknownNode);
    serializer.UnknownAttribute+= new  XmlAttributeEventHandler(serializer_UnknownAttribute);
    protected void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
    {
      Console.WriteLine("Unknown Node:" +   e.Name + "\t" + e.Text);
    }
    protected void serializer_UnknownAttribute(object sender, XmlAttributeEventArgs e)
    {
      System.Xml.XmlAttribute attr = e.Attr;
      Console.WriteLine("Unknown attribute " +  attr.Name + "='" + attr.Value + "'");
    }

集合类(IEnumerable, ICollection)必须满足下列规则才可XML序列化：
    - 不得实现 IDictionary。
    - 必须有一个 Add 方法，该方法不是由该接口定义的，因为它通常是为该集合将要容纳的专用类型而创建的
    - 必须有一个索引器, 且参数为 System.Int32 (C# int)
    - 在 Add、Count 和索引器中不能有任何安全特性（SecurityAttribute）
    可序列化集合类例程：
        public class PublisherCollection : CollectionBase
        {
          public int Add(Publisher value)
          {
            return base.InnerList.Add(value);
          }
          public Publisher this[int idx]
          {
            get { return (Publisher) base.InnerList[idx]; }
            set { base.InnerList[idx] = value; }
          }
        }

某些类是以程序集的形式提供的，无法修改其源码。可用XmlAttributeOverrides设置其序列化特性
     XML目标
        <?xml version="1.0" encoding="utf-8"?>
        <Inventory xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
           <Product>
              <ProductID>100</ProductID>
              <ProductName>Product Thing</ProductName>
              <SupplierID>10</SupplierID>
           </Product>
           <Book>
              <ProductID>101</ProductID>
              <ProductName>How to Use Your New Product Thing</ProductName>
              <SupplierID>10</SupplierID>
              <ISBN>123456789</ISBN>
           </Book>
        </Inventory>
    源类（无法修改）
        public class Inventory
        {
           private Product[] stuff;
           public Inventory() {}
           public Product[] InventoryItems {get {return stuff;} set {stuff=value;}}
        }
    附加XmlAttributeOverrides后即可序列化
       XmlAttributes attrs = new XmlAttributes();
       attrs.XmlElements.Add(new XmlElementAttribute("Book", typeof(BookProduct)));
       attrs.XmlElements.Add(new XmlElementAttribute("Product", typeof(Product)));
       //add to the Attributes collection
       XmlAttributeOverrides attrOver = new XmlAttributeOverrides();
       attrOver.Add(typeof(Inventory), "InventoryItems", attrs);
       //deserialize and load data into the listbox from deserialized object
       FileStream f=new FileStream("..\\..\\..\\inventory.xml",FileMode.Open);
       XmlSerializer newSr=new XmlSerializer(typeof(Inventory), attrOver);
       Inventory newInv = (Inventory)newSr.Deserialize(f);

------------------------------------------------------------------------------------
最简单的示例
-------------------------------------------------------------------------------------
类设计
    public class MyClass  {public MyObject MyObjectProperty;}
    public class MyObject {public string ObjectName;}

序列化的 XML：
    <MyClass>
        <MyObjectProperty>
            <Objectname>My String</ObjectName>
        </MyObjectProperty>
    </MyClass>

 
------------------------------------------------------------------------------------
示例: 序列化数组，并限制数组元素类型
-------------------------------------------------------------------------------------
类设计
    public class Things
    {
       [XmlElement(DataType = typeof(string)), XmlElement(DataType = typeof(int))]
       public object[] StringsAndInts;
    }

生成的 XML 可能为：
    <Things>
       <string>Hello</string>
       <int>999</int>
       <string>World</string>
    </Things>

-------------------------------------------------------------------------------------
示例: 序列化数组
-------------------------------------------------------------------------------------
类设计
    using System.Xml.Serialization;
    [XmlRootAttribute("LinkLibrary", IsNullable = false, Namespace="http://www.wztelecom.cn")]
    public class LinkLib
    {
        [XmlElementAttribute(ElementName="Link", IsNullable=false)]
        public Link[] Links;
        public LinkLib()
        {
            Links = new Link[50];
            Links[0] = new Link("aa", "aa", "aa");
            Links[1] = new Link("bb", "aa", "aa");
            Links[2] = new Link("cc", "aa", "aa");
            Links[3] = new Link("aa", "aa", "aa");
            Links[4] = new Link("aa", "aa", "aa");
            Links[5] = new Link("aa", "aa", "aa");
            Links[6] = new Link("aa", "aa", "aa");
            Links[7] = new Link("aa", "aa", "aa");
            Links[8] = new Link("aa", "aa", "aa");
            Links[9] = new Link("aa", "aa", "aa");
        }
    }
    public class Link
    {
        [XmlAttribute("Cat")] public string Cat;
        [XmlAttribute("Url")] public string Url;
        [XmlAttribute("Desc")]public string Desc;
        public Link(){}
        public Link(string cat, string url, string desc)
        {
            Cat = cat;
            Url = url;
            Desc = desc;
        }
    }

目标XML文件
    <?xml version="1.0" encoding="utf-8"?>
    <LinkLibrary xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="bb" Url="aa" Desc="aa" />
      <Link Cat="cc" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
      <Link Cat="aa" Url="aa" Desc="aa" />
    </LinkLibrary>

若使用[XmlArrayAttribute("Links")] public Link[] Links;则序列化后的xml文件会多出一层：
    <?xml version="1.0" encoding="utf-8"?>
    <LinkLibrary xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
         <Links>
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="bb" Url="aa" Desc="aa" />
              <Link Cat="cc" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
              <Link Cat="aa" Url="aa" Desc="aa" />
         </Links>
    </LinkLibrary>

-------------------------------------------------------------------------------------
示例：使用自定义序列化序列化Dictionary对象
-------------------------------------------------------------------------------------
XML目标
    <?xml version="1.0" encoding="utf-8"?>
    <FactTableDef>
      <Name>FactTableDef1</Name>
      <Owner>owner1</Owner>
      <SourceTable>sourceTable1</SourceTable>
      <ColumnMeasureMaps>
        <Map Column="column1" Measure="Measure1" />
        <Map Column="column2" Measure="Measure2" />
        <Map Column="column3" Measure="Measure3" />
      </ColumnMeasureMaps>
      <ColumnDimensionMaps>
        <Map Column="column4" Dimension="Dimension4" />
        <Map Column="column5" Dimension="Dimension5" />
        <Map Column="column6" Dimension="Dimension6" />
      </ColumnDimensionMaps>
    </FactTableDef>

类源码
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Runtime.Serialization;
    using System.Xml;
    using System.Xml.Serialization;

    namespace WZDM.OLAP
    {
        [System.Serializable()]
        [XmlInclude(typeof(FactTableDef))]
        public class FactTableDef : System.Xml.Serialization.IXmlSerializable
        {
            public string Name;               // 名称
            public string Owner;              // 事实表属主
            public string SourceTable;        // 源表
            public Dictionary<string, string> ColumnMeasureMaps;   // 字段和量度对应关系
            public Dictionary<string, string> ColumnDimensionMaps; // 字段和维度对应关系
   
   
            public FactTableDef() { }
            ...
   
            public void WriteXml(System.Xml.XmlWriter writer)
            {
                writer.WriteElementString("Name", this.Name);
                writer.WriteElementString("Owner", this.Owner);
                writer.WriteElementString("SourceTable", this.SourceTable);
   
                // ColumnMeasureMaps
                writer.WriteStartElement("ColumnMeasureMaps");
                foreach (string key in this.ColumnMeasureMaps.Keys)
                {
                    writer.WriteStartElement("Map");
                    writer.WriteAttributeString("Column", key);
                    writer.WriteAttributeString("Measure", ColumnMeasureMaps[key]);
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
   
   
                // ColumnDimensionMaps
                writer.WriteStartElement("ColumnDimensionMaps");
                foreach (string key in this.ColumnDimensionMaps.Keys)
                {
                    writer.WriteStartElement("Map");
                    writer.WriteAttributeString("Column", key);
                    writer.WriteAttributeString("Dimension", ColumnDimensionMaps[key]);
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
            }
   
   
            public void  ReadXml(System.Xml.XmlReader reader)
            {
                reader.Read();
                this.Name = reader.ReadElementString("Name");
                this.Owner = reader.ReadElementString("Owner");
                this.SourceTable = reader.ReadElementString("SourceTable");
   
                // ColumnMeasureMaps
                ColumnMeasureMaps = new Dictionary<string, string>();
                reader.ReadStartElement("ColumnMeasureMaps");
                reader.ReadToDescendant("Map");
                do
                {
                    string key = reader.GetAttribute("Column");
                    string item = reader.GetAttribute("Measure");
                    ColumnMeasureMaps.Add(key, item);
                }while (reader.ReadToNextSibling("Map"));
                reader.ReadEndElement();
   
                // ColumnDimensionMaps
                ColumnDimensionMaps = new Dictionary<string, string>();
                reader.ReadStartElement("ColumnDimensionMaps");
                reader.ReadToDescendant("Map");
                do
                {
                    string key = reader.GetAttribute("Column");
                    string item = reader.GetAttribute("Dimension");
                    ColumnDimensionMaps.Add(key, item);
                } while (reader.ReadToNextSibling("Map"));
                reader.ReadEndElement();
            }
        }
    }

大多数金融教科书都会告诉你衍生产品只有两种：期权和远期合同（期货）．

　　期权赋予持有人在未来时间买或卖的权利，分别叫做“买入期权”和“卖出期权”。如果你得知一个月后经销商那里会有一批新的柯维特跑车到货，你可以立即付给他1 000美元，给你自己预订一辆，并约定到货后以固定价格购买——比如说4万美元。这样，当车运到后你就有了一个买入期权。你有权利——而不是义务——以4万美元购入一辆车。因为有了这样一个买入期权，你自然希望新到跑车的价格上升：如果车价上涨到5万美元，以4万美元买车的权利就值差不多1万美元。而且，有了这样的期权，你的损失也是有限度的。如果车价只有3万美元，你可以不要那1 000美元（专业上称为“期权费”），直接花3万美元买车。

　　另一种衍生工具——远期合同是在未来时间买或卖的义务。这些合同在交易所交易时被称为“期货”，名称不同，但原理相同。假定你想买一辆新柯维特跑车，又不想付1 000美元的期权费，你可以选择签订一个远期合同，同意在一个月后以4万美元购买一辆跑车。车运到后，即使实际定价低于4万美元，你也必须以合同价格购买。和持有买入期权一样，你希望车价上涨。但因为你签订的是远期合同，你的损失不再是有限度的了，所以，你尤其不希望车价下跌。就算车价跌到3万，你还是要按4万的价格来买。尽管存在风险，远期合同和期权相比，至少有一个优点——你可以省下1 000美元的期权费。

平时有空就拿它来研究一下，终于知道它能安装第三方的输入，于是找了点讯梅花输入，这是个很不错的手机输入法，有普通拼音，联想拼音，五笔等输入，小凯撒能很好地兼容它．

今天我有空在网逛的时候，看到HTC主页上的软件更新区发现有windows mobile 6.1的更新，许多论坛早就有这消息了，说这是简体中文的系统，于是我高兴地下载来安装到小凯撒上了．

令人失望的是，它根本就没有简体中文语言呀，就只是系统的升级程序呀．不过，这次的系统升级还是有所收获的，手机系统里的图标更加好看了，有性能上的提高，现在的小凯撒用起来，轻快了许多！

        感觉PSP的普通难度要比PC的要简单得多.为了打最终Boss,我练到了平均每个人物142级,但最后发现用这样的等级打Boss真的好轻松,只要防得好的话,不需要复活.但是话说回来,打主线Boss的队员的等级练得再高,没有法宝"刻耀珠"(就是时属性的驱动3啊,放魔法飞快!)和完全防御类的魔法也是非常难过的啊!.

本人用角色"莉丝"配戴上"谍报","银耀珠","琥耀珠","金耀珠","木耀珠","刻耀珠","苍耀珠",终于调制出了超级完全防御系的魔法!!!:

1. [大地之障] - 单体完全防御

2. [大地之墙] - 小圆完全防御

3. [盖亚之盾] - 全体完全防御 牛!不用怕物理达人Boss了

4. [根源屏障] - 全体除回复魔法以外无效化 更牛,不管多么狠的Boss的魔法都不顶用哈

当然还得需要最大限度地加快魔法的驱动速度,那就是"刻耀珠",无论再复杂强大的魔法都无需等待就能释放出来!

这里要感叹一下,最终Boss那招魔法"毁灭星球", 竟然能将平均防御力是2200再加成25%防御力,生命平均是2800的四个队员打得真是"灰飞烟灭"!全挂了.有了上述的两个条件, 无视Boss.

最后,列出我用来挑战最终Boss的四个队员,他们是:

1. 凯文 2.莉丝 3.玲 4. 约修亚

public void SetSelectValue4DropDownList(string valueSelected, DropDownList dd)
  {

      ListItem li = dd.Items.FindByValue(valueSelected);
      if (li != null)
      {
          dd.ClearSelection();
          int index = dd.SelectedIndex = dd.Items.IndexOf(li);
                dd.SelectedIndex = index;
      }
  }

一般我们在为DropDownlist绑定数据源的时候，DropDownlist都默认选择第一个Item，使它被选中，如果想另外从数据库取得某一数值，使其选中相应的Item，那么就会出现多重选中的情况multiple items selected in a DropDownList，这么想是很有道理，但是不知道为什么在某些情况下，这种异常却不会出现。即使你用了上述的方法，还是会有不work的情况，这是因为：

在某个静态类中，有定义一个这样的对象，ListItem common = new ListItem("--","") ，然后被某个页面的多个DropDownlist使用（例如insert到第一个位置），这样，有时，ASP.NET，就会认为某中的一个DropDownlist已经选中了第一个选项，而后又选中另外一个Item，这时同时会出现这个神奇的异常！（神奇就在于，各别DropDownlist不会出错）解决的办法就尽量不要共用ListItem，插入Item最后New一个。

PDA(Personal digital assistant),是一部掌上电脑，基本结构类似电脑，是一个手持式消费类产品。是微软定义的一种PDA架构。有特定的软件和硬件架构。现在的PDA大部分是PPC了。

PPC就是Pocket PC（简称PPC）是基于微软的windows CE,Windows Mobile操作系统的一种掌上电脑。

PDA的操作系统大概分为两种，就是PALM和windows CE，拿台式电脑来打比方，就相当于LINIX和WINDOWS的差别。 


PALM是奔迈公司的操作系统： 
http://www.palm.com/cn/ 

现在一般的PDA都具有手写功能！一部分有PDA功能的手机被称为SMARTPHONE（聪明的手机）就是因为它们已经具备了简单的电脑使用功能！ 

XCOPY source [destination] [/A | /M] [/D[:date]] [/P] [/S [/E]] [/V] [/W]

　　　　　　　　　　　　　 [/C] [/I] [/Q] [/F] [/L] [/G] [/H] [/R] [/T] [/U]
　　　　　　　　　　　　　 [/K] [/N] [/O] [/X] [/Y] [/-Y] [/Z]
　　　　　　　　　　　　　 [/EXCLUDE:file1[+file2][+file3]...]

　source　　　 指定要复制的文件。
　destination　指定新文件的位置和/或名称。
　/A　　　　　 只复制有存档属性集的文件，但不改变属性。
　/M　　　　　 只复制有存档属性集的文件，并关闭存档属性。
　/D:m-d-y　　 复制在指定日期或指定日期以后改变的文件。
　　　　　　　 如果没有提供日期，只复制那些源时间比目标时间新的文件。
　/EXCLUDE:file1[+file2][+file3]...
　　　　　　　 指定含有字符串的文件列表。如果有任何字符串与要被复制的文件
　　　　　　　 的绝对路径相符，那个文件将不会得到复制。
　　　　　　　 例如，指定如 \obj\ 或 .obj 的字符串会排除目录 obj 下面的
　　　　　　　 所有文件或带有 .obj 扩展名的文件。
　/P　　　　　 创建每个目标文件前提示。
　/S　　　　　 复制目录和子目录，除了空的。
　/E　　　　　 复制目录和子目录，包括空的。与 /S /E 相同。可以用来修改 /T。
　/V　　　　　 验证每个新文件的大小。
　/W　　　　　 提示您在复制前按键。
　/C　　　　　 即使有错误，也继续复制。
　/I　　　　　 如果目标不存在，又在复制一个以上的文件，则假定目标一定是一
　　　　　　　 个目录。
　/Q　　　　　 复制时不显示文件名。
　/F　　　　　 复制时显示完整的源和目标文件名。
　/L　　　　　 显示要复制的文件。
　/G　　　　　 允许将没有经过加密的文件复制到不支持加密的目标。
　/H　　　　　 也复制隐藏和系统文件。
　/R　　　　　 覆盖只读文件。
　/T　　　　　 创建目录结构，但不复制文件。不包括空目录或子目录。/T /E 包
　　　　　　　 括空目录和子目录。
　/U　　　　　 只复制已经存在于目标中的文件。
　/K　　　　　 复制属性。一般的 Xcopy 会重设只读属性。
　/N　　　　　 用生成的短名复制。
　/O　　　　　 复制文件所有权和 ACL 信息。
　/X　　　　　 复制文件审核设置(隐含 /O)。
　/Y　　　　　 禁止提示以确认覆盖一个现存目标文件。
　/-Y　　　　　导致提示以确认覆盖一个现存目标文件。
　/Z　　　　　 用重新启动模式复制网络文件。

命令行开关 /Y 可以预先在 COPYCMD 环境变量中设置。这可能被命令行上的 /-Y
覆盖。

=========================================

Xcopy
复制文件和目录，包括子目录。

语法
xcopySource [Destination] [/w] [/p] [/c] [/v] [/q] [/f] [/l] [/g] [/d[:MM-DD-YYYY]] [/u] [/i] [/s [/e]] [/t] [/k] [/r] [/h] [{/a | /m}] [/n] [/o] [/x] [/exclude:FileName1[+[FileName2]][+[FileName3]] [{/y | /-y}] [/z]

参数
Source

必需。指定要复制的文件的位置和名称。该参数必须包含驱动器或路径。

Destination

指定要复制的文件的目标。该参数可以包含驱动器号和冒号、目录名、文件名或者它们的组合。

/w

在开始复制文件之前将显示以下消息并等待您的响应：

Press any key to begin copying file(s)

/p

提示您确认是否要创建每个目标文件。

/c

忽略错误。

/v

在写入目标文件时验证每个文件，以确保目标文件与源文件完全相同。

/q

禁止显示“xcopy”的消息。

/f

复制时显示源文件名和目标文件名。

/l

显示要复制的文件列表。

/g

创建已解密的目标文件。

/d [:MM-DD-YYYY]

只复制那些在指定日期或指定日期之后更改过的源文件。如果不包括“MM-DD-YYYY”值，“xcopy”会复制比现有“Destination”文件新的所有“Source”文件。该命令行选项使您可以更新更改过的文件。

/u

只从“Source”复制“Destination”中已有的文件。

/i

如果“Source”是一个目录或包含通配符，而“Destination”不存在，“xcopy”会假定“destination”指定目录名并创建一个新目录。然后，“xcopy”会将所有指定文件复制到新目录中。默认情况下，“xcopy”将提示您指定“Destination”是文件还是目录。

/s

复制非空的目录和子目录。如果省略“/s”，则“xcopy”将在单个目录中工作。

/e

复制所有子目录，包括空目录。将“/e”与“/s”和“/t”命令行选项一起使用。

/t

只复制子目录结构（即目录树），不复制文件。要复制空目录，必须包含“/e”命令行选项。

/k

复制文件，如果源文件具有只读属性，则在目标文件中保留该属性。默认情况下，“xcopy”将删除只读属性。

/r

复制只读文件。

/h

复制具有隐藏和系统文件属性的文件。默认情况下，“xcopy”不复制隐藏或系统文件。

/a

只复制那些具有存档文件属性设置的源文件。“/a”不修改源文件的存档文件属性。有关如何通过使用“attrib”来设置存档文件属性的信息，请参阅“相关主题”。

/m

复制具有存档文件属性设置的源文件。与“/a”不同，“/m”关闭在源中指定的文件的存档文件属性。有关如何通过使用“attrib”来设置存档文件属性的信息，请参阅“相关主题”。

/n

使用 NTFS 短文件或目录名创建副本。将文件或目录从 NTFS 卷复制到 FAT 卷或者当目标文件系统需要 FAT 文件系统命名约定（即 8.3 字符）时，需要“/n”。目标文件系统可以是 FAT 或 NTFS。

/o

复制文件所有权与随机访问控制列表 (DACL) 信息。

/x

复制文件审核设置和系统访问控制列表 (SACL) 信息（包含“/o”）。

/exclude:FileName1[+[ FileName2]][+[FileName3]]

指定包含字符串的文件列表。

/y

禁止提示确认要覆盖已存在的目标文件。

/-y

提示您确认要覆盖已存在的目标文件。

/z

在可重启模式中通过网络复制。

/?

在命令提示符显示帮助。

注释
• 使用“/v”

Windows XP 和 Windows Server 2003 家族产品不使用该命令。只为了与现有的 MS-DOS 文件保持兼容性才包含此命令，但是因为其功能是自动实现的，所以在命令行使用时不起作用。

• 使用“/exclude”

在每个文件的单独一行中的列出每个字符串。如果列出的任何字符串与要复制的文件的绝对路径的任何部分匹配，就从复制进程排除该文件。例如，如果指定字符串 "\Obj\"，则会排除 Obj 目录下的所有文件。如果指定字符串 ".obj"，则排除具有 .obj 扩展名的所有文件。

• 使用“/z”

如果在复制过程中丢失连接（例如，如果用于连接的服务器脱机），复制过程将在重新建立连接后恢复。“/z”也显示每个文件完成的复制操作的百分比。

• 在 COPYCMD 环境变量中使用“/y”

可在 COPYCMD 环境变量中使用“/y”。在命令行上使用“/-y”可以覆盖该命令。默认情况下，会提示您覆盖，除非您从批处理脚本内运行“copy”。

• 复制加密的文件

将加密文件复制到不支持 EFS 的卷会导致错误。应首先解密文件或将文件复制到支持 EFS 的卷中。

• 追加文件

要追加文件，请指定单个目标文件，多个源文件（使用通配符或 file1+file2+file3 格式）。

• “Destination”的默认值

如果省略“Destination”，则“xcopy”命令将文件复制到当前目录。

• 指定“Destination”是文件还是目录

如果“Destination”不包含现有目录且不以反斜杠 (\) 结尾，会出现下列消息：

Does destination specify a file name or directory name on the target (F = file, D = directory)?
如果要将一个或多个文件复制到一个文件，请按 F。如果要将一个或多个文件复制到一个目录，请按 D。

使用“/i”命令行选项可禁止显示该消息，从而导致“xcopy”认定在源是多个文件或一个目录的情况下，目标是一个目录。

• 使用“xcopy”命令设置“Destination”文件的存档属性

“xcopy”命令创建具有存档属性设置的文件，无论源文件中是否设定了此属性。有关文件属性和“attrib”的详细信息，请参阅“相关主题”。

• 比较“xcopy”和“diskcopy”

如果磁盘的子目录中包含文件，要将其复制到具有不同格式的磁盘中，请使用“xcopy”命令，而不要使用“diskcopy”。因为“diskcopy”命令是一个磁道接一个磁道地复制磁盘，所以需要源磁盘和目标磁盘的格式必须相同。“xcopy”命令没有这个要求。通常情况下请使用“xcopy”，除非您需要完整的磁盘映像副本。

• “xcopy”的退出代码

要处理“xcopy”返回的退出代码，请在批处理程序的“if”命令行上使用“ErrorLevel”参数。有关使用“if”处理退出码的批处理程序的示例，请参阅“相关主题”。下表列出每一个退出代码和描述。


退出代码 描述
0
文件复制没有错误。

1
没有找到要复制的文件。

2
用户按 Ctrl+C 终止了“xcopy”。

4
出现了初始化错误。没有足够的内存或磁盘空间，或命令行上输入了无效的驱动器名称或语法。

5
出现了磁盘写入错误。



示例
要从驱动器 A 将所有文件和子目录（包括所有空的子目录）复制到驱动器 B，请键入：

xcopy a: b: /s /e

要包含上一示例中的任何系统或隐藏文件，请按如下所示添加“/h”命令行选项：

xcopy a: b: /s /e /h

要使用 \Rawdata 目录中 1993 年 12 月 29 日后更改的文件更新 \Reports 目录中的文件，请键入：

xcopy \rawdata \reports /d:12-29-1993

要更新上例中 \Reports 中存在的所有文件而不考虑日期，请键入：

xcopy \rawdata \reports /u

要获得前一个命令要复制的文件列表而不实际复制文件，请键入：

xcopy \rawdata \reports /d:12-29-1993 /l > xcopy.out

文件 Xcopy.out 列出了要复制的所有文件。

要将 \Customer 目录及其所有子目录复制到网络驱动器 H: 上的目录 \\Public\Address，保留只读属性，并在 H: 上创建新文件时对您做出提示，请键入：

xcopy \customer h:\public\address /s /e /k /p

要发出上一个命令，确保在 \Address 目录不存在时“xcopy”会创建该目录，并禁止显示创建新目录时出现的消息，请按如下所示添加“/i”命令行选项：

xcopy \customer h:\public\address /s /e /k /p /i

可以创建批处理程序执行“xcopy”操作，并且使用“if”批处理命令在发生错误时处理退出代码。例如，以下的批处理程序使用了可替换的“xcopy”源和目标参数：

@echo off rem COPYIT.BAT transfers all files in all subdirectories of rem the source drive or directory (%1) to the destinationrem drive or directory (%2)xcopy %1 %2 /s /eif errorlevel 4 goto lowmemory if errorlevel 2 goto abort if errorlevel 0 goto exit :lowmemory echo Insufficient memory to copy files or echo invalid drive or command-line syntax. goto exit:abort echo You pressed CTRL+C to end the copy operation. goto exit :exit
要使用该批处理程序将 C:\Prgmcode 目录及其子目录中的所有文件复制到驱动器 B 中，请键入：

copyit c:\prgmcode b:

该命令解释程序将用“C:\Prgmcode”替换“%1”，用“B:”替换“%2”，然后执行带“/e”和“/s”命令行选项的“xcopy”。如果“xcopy”遇到错误，批处理程序将读取退出码并转到相应“IF ERRORLEVEL”语句中指示的标签，然后显示相应的消息并退出批处理程序。