【转】Delphi 关键字详解

摘自：http://www.delphifans.com/infoview/Article_6445.html

absolute

//它使得你能够创建一个新变量, 并且该变量的起始地址与另一个变量相同.  var    Str: string[32];    StrLen: Byte absolute Str;    //这个声明指定了变量StrLen起始地址与Str相同.  //由于字符串的第0个位置保存了字符串的长度, 所以StrLen的值即字符串长度.  begin    Str := 'abc';    Edit1.Text := IntToStr(StrLen);  end;

abstract

//它允许你创建抽象的方法, 包括有抽象方法的类称为抽象类.  //Abstract关键字必须与Virtual或Dynamic关键字同时使用, 因为抽象方法必须被覆盖式实现.  //抽象类不能实例化, 抽象方法不能包含方法体.  type    TDemo = class      private      protected        procedure X; virtual; abstract;      public        constructor Create;        destructor Destroy; override;      published    end;

and

//一、表示逻辑与  if (a>0) and (b>0) then    //二、表示位运算  var    a,b,c: Integer;  begin    c := (a and b);  end;    //使用And表示逻辑时, And左右的表达式必须用小括号括起, 以避免以生条件的冲突.  //例如:  if a>0 and b>0 then  //编译器可能会理解为:  if a>(0 and b)>0 then  //或:  if (a>0) and (b>0) then  //但是实际编译时, 编译器会产生一个冲突, 报告错误.  //并且第一种可能包含了a>b>c的形式, 这在Delphi中不被支持.  //所以使用And运算符时必须使用括号, 以区分左右的条件.  //表示位运算时也必须加上括号, 将And以及左右参数括起.
  

array

  
//Array用于表示数组, 任何的对象都能被声明成数组.数组分为静态和动态的２种.    //静态数组  var    Arr1: array [1..10] of Integer;    //动态数组, 由于声明时不知其元素个数, 所以必须在后期用SetLength方法设置数组的大小  var    Arr2: array of Integer;    //数组作为参数时, 不能传入数组的大小, 只能传入数组名, 然后用Length方法获取数组的元素个数  function X(A: array of Integer): Integer;  var   i: Integer;  begin    Result := 0;    for i := 0 to Length(A)-1 do    Result := Result + A[i];  end;

as

//As用于将一个对象转换为另一个对象  procedure BtnClick(Sender:TObject);  begin    (Sender as TButton).Caption := 'Clicked';  end;    //对于对象填充接口的转换, 必须用As进行  (HTTPRIO as IExp).GetConnection;    //As不能用于数据类型的转换, 下面的代码是错误的:  var    i: Integer;    s: string;  begin    s := (i as string);  end;  //正确写法是:  s := string(i);
  

asm

  
//Asm关键字用于插入汇编代码, 使用汇编代码时, 必须使用asm...end;的结构, 而非begin...end;  function IntToHex(Value: Integer; Digits: Integer): string;  asm    CMP  EDX, 32    JBE  @A1    xor  EDX, EDX    @A1: PUSH ESI    MOV  ESI, ESP    SUB  ESP, 32    PUSH ECX    MOV  ECX, 16    CALL CvtInt    MOV  EDX, ESI    POP  EAX    CALL System.@LStrFromPCharLen    ADD  ESP, 32    POP  ESI  end;

assembler

//Assembler关键字用于支持早期的汇编, 如80386等.  //它和Asm的区别:Asm允许使用Win32汇编, 而Assembler只允许80x86汇编, 它不允许Invoke语句的出现.  function IntToHex(AValue: Int64): string; assembler;
  

automated

  
//Automated访问区分符用于描述一个自动类型的成员, 它能够使程序的版本向下兼容.  //ComObj单元内的成员及其实例不能使用Automated访问区分符.  type    TDemo = class      automated        Str:WideString;    end;    //在程序的下一个版本中, 将Str做了修改, 变成  type    TDemo = class      automated        Str: AnsiString;    end  //则新版本的Str变量能够接受旧版本的WideString型数据, 并自动转换成AnsiString.  //在实际开发中, 如果没有特殊的需要, 一般不用automated访问区分符.
  

begin

  
//begin关键字用于表示一段程序或一个结构的开始, 必须用end关键字来结束.  procedure X;  begin    ShowMessage('A Demo');  end;    //一般的结构, 如If, For, While等也需要用begin关键字来标出结构起始点  for i:=1 to 100 do  begin    sum := sum + i;    if sum > 1000 then Break;  end;

case

//Case语句用于完成条件选择, Case语句的的被选择对象必须是有序类型, 包括整型, 枚举类型, 字符型等.  //Case语句必须由end结束,如果没有相符合的选择项, 可以加入else来作出通用选择.  function GetDays(AYear,AMonth: Integer): Integer;  begin    case AMonth of      1,3,5,7,8,10,12: Result := 31;      4,6,9,11: Result := 30;      2: begin      if IsLeapYear(AYear) then        Result:=29      else        Result:=28;      end;    else      Result:=0;  end;

cdecl

//Cdecl是函数调用协定的一种, 它规定了从C或C++编写的DLL中调用函数所必须遵守的规则.  //它可以将C或C++中的数据类型转换为Delphi的.  //例如C++中的代码:  int X(int i)  {    return i*2;  }

//这个函数被编译在Demo.dll中, 用Delphi调用时必须使用:  function X(i: Integer): Integer; Cdecl; external 'Demo.dll';
  

class

  
//Class关键字用于声明或继承一个类, 也可以使类和接口同时继承.  //另外, Class关键字也能用于声明类通用方法, 使得父类可以从类内访问子类的方法.  type    ClassDemo = class(TObject)      private      public        constructor Create;    end;    //如果用class声明方法, 则该方法在类与相关类中都可以使用, 譬如:  type    ClassA = class      private      public        procedure Y;    end;    type    ClassB = class(ClassA)      private      public        class procedure X;    end;  //则在使用时ClassA能够直接访问ClassB的X方法  procedure ClassA.Y;  begin    Self.X;  end;  //此时父类将子类的class方法作为自身的方法进行调用.

const

//Const关键字用于声明常量, 使用const声明的数据将不能在程序中被改变.  //也可以用来声明函数参数, 用const指定的参数不允许在函数中改变.  const MyFileName = 'Delphi';  const MyInteger = 100;    //用Const声明常量不需要指出其数据类型, 系统会自动判断类型, 并作自动调整.  //函数中可以用const声明不可更改的参数  function X(const i: Integer): string;  //此时在函数操作过程中, i的值不可改变.

constructor

//constructor关键字用来声明一个类的构造函数, 当类被实例化时, 首先调用此函数  //构造函数一般用Create表示, Create方法能够连带类中存在的CreateWnd方法.  type    ClassDemo = class(TObject)      private        fValue: Integer;      public        constructor Create;    end;    constructor ClassDemo.Create;  begin    fValue := 0;  end;

contains

//Contains关键字指出了某个包(Package)是否包含某个文件.  //用Contains引入的文件必须被添加到包文件中, 它可以避免关键文件的引用丢失.  package DATAX;    requires      rtl, clx;    contains      Db, DBLocal, DBXpress;  end.

default

//Default关键字用于指出一个属性的默认值  //只有有序类型的属性才允许默认值的存在, 否则必须在构造函数中初始化属性值.  type    ClassDemo = class      private        fValue: Integer;      published        property Value: Integer read fValue write fValue default 0;    end;    //它也可以指出一个类的默认属性  property strings[Index: Integer]: string read GetString write PutString; Default;
  

destructor

  
//Destructor用于标识析构函数, 析构函数在类被释放时自动调用.  //析构函数只允许覆盖, 再不允许重载.析构函数通常用Destroy作为函数名.  type    ClassDemo = class(TComponent)      public        destructor Destroy;override;    end;    //由于TComponent类中也有Destroy方法, 所以要将其重写  //但是若要重载析构函数, 则不允许, 下面代码是错误的:  destructor Destroy; overload;
  

dispid

  
//DispId关键字被用在DispInterface接口中, 用于指定特定的适配序号.  //在DispInterface接口中, 适配序号必须是唯一的,   //如果不指定DispId, 则系统会自动分配适配序号给接口内每一个方法.  //可以通过适配序号访问DispInterface接口中的方法.  type    IStringsDisp = dispinterface      ['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}']      property ControlDefault[Index: Integer]: Olevariant dispid 0; default;      function Count: Integer; dispid 1;      property Item[Index: Integer]: Olevariant dispid 2;      procedure Remove(Index: Integer); dispid 3;      procedure Clear; dispid 4;      function Add(Item: Olevariant): Integer; dispid 5;      function _NewEnum: IUnknown; dispid -4;    end;

dispinterface

//DispInterface用于声明一个特定的适配器接口, 这个适配器能够接受标准系统接口中传入传出的数据.  //用DispInterface声明的接口不能被继承, 只能够被引用.  //DispInterface中方法只能调用, 并且必须被动态绑定.  //可以通过DispId为接口内方汉分配适配序号.  //DispInterface仅能用于Windows平台, 如果在Linux下进行开发, 则此关键字会自动被系统屏蔽.  //通常情况下, 不使用DispInterface.    //实例请参见DispId

div

//Div用于求两数之整数商.用于Div运算的两个数值必须均为整型, 其运算结果也为整型.  var    a,b,c:Integer;  begin    a := 20; b := 3;    c := a div b; {6}  end;

do

//Do关键字用于For, While, On, With语句, 构成特定的结构    //For语句:  for i := 1 to 100 do sum:=sum+i;    //While语句:  while i < 100 do  begin  　sum := sum + i;  　Inc(i);  end;    //On语句(异常处理):  try  　i := StrToInt(s);  except  　on exception do ShowMessage('Error!');  end;    //With语句:  with Memo1.Lines do  begin  　Clear;  　Append('abc');  　Append('123');  end;

downto

//DownTo关键字用于For语句, 指明循环变量是递减的.  for i := 100 downto 1 do    ListBox1.Items.Add(IntToStr(i));    //在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.

dynamic

//Dynamic用于声明一个动态的方法,   //动态方法可以被覆盖, 并且可以使代码大小尽可能的减少(区别于Virtual).  procedure X(i: Integer); dynamic;
  

else

  
//else用于引导程序的运行方向, 它可以与If, Case和On语句联用, 当条件不满足时, 转到else下运行    //If语句(在If语句中, else前不允许有分号):  if a > b then    c := a  else    c:=b;    //Case语句:  case Tag Of    1:Result:=1;    2:Result:=2;    3:Result:=3;  else    Result:=0;  end;    //On语句(异常处理):  try    i := StrToInt(s);  Excpet    on EZeroDivide do Result := 1;    on EOverflow do Result := 2;  else    Result := 0;  end;

end

//End用于结束一个语句块或是一个单元.  //它可以与begin, Case, Class, Interface, Asm, Unit, Package等相匹配.  //对于语句块(局部结束), End后必须添加分号.  //而对于单元或包(全局结束), end后必须添加句号.  //在If语句中else关键字前的End后不允许添加符号.  procedure X;  begin  　with Button1 do  　begin  　　if Button1.ShowHint then  　　　Button1.Caption := 'Hinted'  　　else  　　　Button1.Caption := 'Not Hinted';  　end;  end;    //在包内使用End来结束:  package DATAX;    requires      rtl,      clx;    contains Db, DBLocal, DBXpress;  end.

except

//except关键字用于异常处理, 必须用在try语句内, 如果发生异常, 则执行except后的语句  try    i := StrToInt(s);  except    ShowMessage('Error!');  end;

export

//Export标明了函数调用协定, 指出函数可以被输出, 输出的函数能被本地或远程调用.  //其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.  function Add(a,b: Integer): Integer; export;    //如果这个程序被编译为Demo.exe, 并且另一个程序需要调用这个函数, 可以使用以下语句  function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';
  

exports

  
//exports用于输出对象, 它必须被用在接口和实现之间, 可以同时输出多个项, 项与项之间用逗号分开.  library Demo;    function X(i: Integer): string; stdcall;  begin  　Result:=IntToStr(i);  end;    exports  　X;    begin  end.    //如果输出的对象被重载, 则必须给对象起个别名, 并注明参数.  library Demo;    function X(i: Integer): string; overload; stdcall;  begin  　Result := IntToStr(i);  end;    function X(s: string): Integer; overload; stdcall;  begin  　Result := StrToInt(s);  end;    exports    X(i: Integer) name 'x1',    X(s: string) name 'x2';    begin  end.

external

//External关键字用于引用一个外部的或是OBJ内的方法.  {$L Demo.OBJ}  procedure X(i:Integer);external;    //如果是从dll或外部程序中引用, 则可以使用以下代码:  function A(FileName: string): string; external 'Demo.dll';    //如果被引用的函数被重载, 则必须另外指出引用的名称.  function A(Name: string): string; overload; stdcall; external 'Demo.dll' name 'A1';  function A(Code: Integer): string; overload; stdcall; external 'Demo.dll' name 'A2';    //使用External关键字时, 必须注意大小写, 否则将出现错误.

far

//Far标明了函数调用协定, 指出函数可以被远程调用.  //其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.  function Add(a,b: Integer): Integer; Far;    //如果这个程序被编译为Demo.exe, 并且另一个处于其他计算机的程序需要调用这个函数, 可以使用以下语句:  function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';
  

file

  
//File关键字指出了文件操作类型, 文件必须被声明为File,   //如果在File后追加Of和文件类型, 则文件可以被定义为读写指定类型数据.  type    TPerson = record      PName: string[32];      PAge: Integer;    end;  var    PFile: file of TPerson;
  

finalization

  
//finalization关键字标识了单元被释放时所要调用的方法,   //通常是释放掉单元中不能自动释放的对象, 也可以不用.  //finalization最常用的情况是对OLE对象做反初始化.  initialization    ActiveX.OleInitialize(nil);  finalization    ActiveX.OleUninitialize;

finally

  
//finally关键字指出了异常处理中最后必须要调用的方法,   //不论是否发生异常, finally后的语句总是在try语句结束时执行.  try    Node := Node.GetNext;    Edit1.Text := Node.Text;  finally  　Node := nil;  end;

for

//For关键字引出For循环结构, 用于做指定次数的循环.  for i := 1 to 100 do sum := sum + i;    //如果循环变量是递减的, 则可以用DownTo关键字  for i := 100 downto 1 do Inc(sum);
  

forward

  
//Forward关键字用于方法的前置定义.只定义方法声明, 然后在程序的后面对方法进行实现.  //这么做有利于代码的可读性, 可以将所有的声明放在一起, 然后将所有的实现也放在一起.  function X(i: Integer): Integer; forward;  procedure Y(s: string); forward;  ...  function X;  begin    Result := i * 2;  end;    procedure Y;  begin    WriteLn(s);  end;    //用Forward前置声明的方法在实现时不需要再输入方法的参数和返回值, 直接使用方法名即可.

function

//Function用于声明函数  function X(i: Integer): Integer;    //它也可以用于动态函数的声明  type  　TFun = function(i: Integer): Integer of object;    //动态声明时, 不需要指出函数名, 只需要指出参数和返回类型就可以, 具体的函数名可以在后期绑定.

goto

//Goto语句用在跳转行号, 可以跳转到当前结构层内任意位置.  //必须在声明处用label关键字声明行号.  //由于Goto语句会破坏程序的结构, 不推荐使用.  var  　a,b: Integer;  label  　X,Y;  begin  　if a > b then  　　goto X  　else  　　goto Y;  X:  　WriteLn('a > b');  Y:  　WriteLn('b > a');  end;

if

//If关键字引出If条件语句, 用于对条件进行判断.  var  　a,b: Integer;  begin  　a := 2; b := 3;  　if a>b then  　　WriteLn('a=' + IntToStr(a))  　else  　　WriteLn('b=' + IntToStr(b));  end;    //If语句的通常结构是If...Then...else, else语句也可以不要.  //在If语句内如果有多个子语句, 则必须用begin...End结构进行区分.  if a > b then  begin  　WriteLn('a>b');  　WriteLn('a=' + IntToStr(a));  　WriteLn('b=' + IntToStr(b));  End  else  　WriteLn('b>a');

implementation

//Implementation标识了单元中的实现部分, 单元的基本结构为:  //Unit...Interface...implementation...end.  //函数体, 过程体等必须写在implementation关键字后.  //如果在implementation后引用对象, 则对象是非公开的, 仅能供单元自身使用.  implementation    uses frmAbout;  begin    FormAbout.Show;  end;    //一个完整的单元必须拥有implementation部分.

implements

//Implements指出了一个属性从接口继承, 此时属性被转换成接口对象.  //通过接口动态绑定属性, 并动态的设定属性值.  type  　IMyInterface = interface  　　procedure P1;  　　procedure P2;  　end;  　TMyImplclass = class  　　procedure P1;  　　procedure P2;  　end;  　TMyclass = class(TInterfacedObject, IMyInterface)  　　FMyImplClass: TMyImplClass;  　　property MyImplClass: TMyImplclass read FMyImplclass implements IMyInterface;  　　procedure IMyInterface.P1 = MyP1;  　　procedure MyP1;  　end;    //通过implements声明后, 可以在类声明时指出接口中方法的实体, 如上例中的:  procedure IMyInterface.P1 = MyP1;
  

in

  
//In用于判断一个集合中是否包含某个元素.被判断的内容必须是单个集合元素和一个集合的实例.  type  　TCol = (cA,cB,cC);  　TCols = set of TCol;  var  　Cols: TCols;  begin  　Cols := [cA,cB];  　if cA in Cols then  　　ShowMessage('cA in Cols')  　else  　　ShowMessage('cA not in Cols');  end;    //In也用于工程文件中, 用于标识某个文件是否被工程所引用.  Uses  　Unit1 in 'Unit1.pas';    //In可以被用在For语句中, 用于循环取出一个集合中的元素.  var  　s: string;  　sl: TStringList;  begin  　...  　for s In sl do  　begin  　　ShowMessage(s);  　end;  end;

index

//Index用于在属性中标识序号, 以便用相同的属性方法(Get,Set)对不同的属性进行操作.  type  　TForm1 = class(TForm)  　private  　　function GetInfo(const Index: Integer): Longint;  　　procedure SetInfo(const Index: Integer; const Value: Longint);  　public  　　property iLeft:Longint index 0 read GetInfo write SetInfo;  　　property iTop:Longint index 1 read GetInfo write SetInfo;  　　property iWidth:Longint index 2 read GetInfo write SetInfo;  　　property iHeight:Longint index 3 read GetInfo write SetInfo;  　end;    function TForm1.GetInfo(const Index: Integer): Longint;  begin  　case Index of  　　0: result := self.Left;  　　1: Result := self.Top;  　　2: result := self.Width;  　　3: result := self.Height;  　end;  end;    //Index关键字也用于在属性中指出多个元素, 例如:  property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;
  

inherited

  
//Inherited用于调用父类的方法.  type  　TDemo = class(TComponent)  　public  　　constructor Create(AOwner: TComponent); override;  　end;    constructor TDemo.Create(AOwner: TComponent);  begin  　inherited Create(AOwner);  end;    //如果调用的是与自身同名的方法, 则也可以省去方法名和参数.如上例中的  inherited Create(AOwner);  //可以改成:  Inherited;

initialization

//initialization关键字标识了单元被载入时所要调用的方法,   //通常是初始化一些不能自动初始化的对象, 也可以不用.  //initialization最常用的情况是对OLE对象做初始化.  initialization    ActiveX.OleInitialize(nil);  finalization    ActiveX.OleUninitialize;

inline

  
//InLine关键字用于Asm或assembler结构中,   //用于指出该汇编语句是向下兼容的.它对于程序的编译没有任何影响.  function IntToStr(Value: Integer): string;  asm  　InLine;    PUSH  ESI    MOV   ESI, ESP    SUB   ESP, 16    xor   ECX, ECX    PUSH  EDX    xor   EDX, EDX    CALL  CvtInt    MOV   EDX, ESI    POP   EAX    CALL  System.@LStrFromPCharLen    ADD   ESP, 16    POP   ESI  end;

interface

//Interface标识了单元中的接口部分, 单元的基本结构为:  //Unit...Interface...implementation...end.  //函数, 过程等的声明必须写在Interface关键字后.  //如果在Interface后引用对象, 则对象是没有实例的, 使用时必须被实例化.  Interface  　uses frmAbout;  var  　FAbout: TFormAbout;  begin  　FAbout :＝ TFormAbout.Create(Self);  　FAbout.Show;  end;    //一个完整的单元必须拥有Interface部分.    //Interface也可以用作接口的声明.  type  　IMalloc = interface(IInterface)  　['{00000002-0000-0000-C000-000000000046}']  　　function Alloc(Size: Integer): Pointer; stdcall;  　　function Realloc(P: Pointer; Size: Integer): Pointer; stdcall;  　　procedure Free(P: Pointer); stdcall;  　　function GetSize(P: Pointer): Integer; stdcall;  　　function DidAlloc(P: Pointer): Integer; stdcall;  　　procedure HeapMinimize; stdcall;  　end;

is

//Is关键字用于对象的判断, 有某些情况下, 也可以作"As"使用.  var  　Comp: TComponent;  begin    ...  　if Comp Is TEdit then  　　(Comp as TEdit).Text := 'Edit';  end;

label

//label关键字用于声明行号标签, 以便用Goto进行转向, 不推荐使用.  var  　a,b: Integer;  label  　X,Y;  begin  　if a > b then  　　goto X  　else  　　goto Y;  X:  　WriteLn('a>b');  Y:  　WriteLn('b>a');  end;

library

//Library关键字用于指出一个工程为类库.类库编译后生成DLL文件, 可被其他程序调用.  library Editors;  uses EdInit, EdInOut, EdFormat, EdPrint;  exports    InitEditors,    doneEditors name done,    InsertText name Insert,    DeleteSelection name Delete,    FormatSelection,    PrintSelection name Print,    SetErrorHandler;  begin    InitLibrary;  end.

message

//Message关键字用于声明消息方法,   //带有Message的方法必须指出接收的消息类型, 并通过引用将消息传入方法中, 以便进行处理.  procedure Refresh(var Msg: TMessageRecordtype); message ID_REFRESH;    procedure Refresh(var Msg: TMessageRecordtype);  begin    if Chr(Msg.Code) = #13 then      ...    else      inherited;  end;    //用户可以自定义消息, 自定义消息也能够被Message接收, 并引发事件.

mod

//Mod用于求两数之整数模, 即余数.用于Mod运算的两个数值必须均为整型, 其运算结果也为整型.  var  　a,b,c: Integer;  begin  　a := 20; b := 3;  　c := a mod b; {2}  end;

name

//Name关键字用于指出方法的别名,   //对于一个要被外部引用的方法, 建议用Name申请方法别名, 以避免外部程序改动方法的实体内容.  //从外部引用一个方法时, 如果该方法有别名, 则必须用Name进行标识.  function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer;     stdcall; external 'user32.dll' name 'MessageBoxA';
  

near

  
//Near标明了函数调用协定, 指出函数可以被本地调用.  //其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.  function Add(a,b: Integer): Integer; near;    //如果这个程序被编译为Demo.exe, 并且另一个处于本地的程序需要调用这个函数, 可以使用以下语句:  function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';
  

nil

  
//Nil用于表示一个空指针, 或是没有实例的对象.  while Node <> nil do  begin  　ListBox1.Items.Add(Node.Text);  　Node := Node.GetNext;  end;

nodefault

//NoDefault关键字指出了一个属性不允许有默认值, 这通常用在继承中.  type  　TClassA = class  　private  　　fValue: Integer;  　published  　　property Value: Integer read fValue write fValue default 0;  　end;    　TClassB = class(TClassA)  　published  　　property Value:Integer read fValue write fValue nodefault;  　end;    //由上例可知, TClassA中的Value有默认值0,   //TClassB继承了TClassA, 所以也继承了其默认值, 在此用NoDefault去掉默认值
  

not

  
//Not用于取反, 它否定了原先的结果.例如:  if a > b then  //可以写成:  if not(a < b) then    //Not关键字通常用于切换Boolean型的属性  procedure Button1Click(Sender: TObject);  begin  　StatusBar1.Visible := not StatusBar1.Visible;  end;

object

//Object用于声明一个对象, 这个对象可以是任意的, 并且向下兼容.Object只能被Object所继承.  //声明对象的方法与声明类的方法是相同的.  type  　ODemoA = object  　end;    　ODemoB = object(ODemoA)  　end;    //Object关键字还用于声明动态函数或过程, 例如:  type  　TMyFun = function(i: Integer): Integer of Object;  　TMyProc = procedure(s: string) of object;    //经过object声明的函数或过程可以被动态的绑定到指定的函数体, 或是绑定到控件是事件中.

of

//Of关键用于和其他关键字构成指定的结构.Of可以与Case, Class, Array, File, Set, Object连用.    //Case语句:  case Tag Of  　0: Result := 'a';  　1: Result := 'b';  end;    //Class语句:  type  　TDemo = class of TComponent;    //Array结构:  var  　MyInt: array of Integer;    //File结构:  var  　MyFile: file of Byte;    //Set语句:  type  　TCol = (cA,cB,cC);  　TCols = set of TCol;    //Object结构:  type  　MyFun = function(I: Integer): Integer of Object;
  

on

  
//On关键字用于异常处理, 指出发生的异常, 并获取异常信息.  try  　i := StrToInt(s);  except  　on E: exception do  　　ShowMessage(E.Message);  end;

or

//一、表示逻辑或  if (a>0) or (b>0) then    //二、表示位运算  var    a,b,c: Integer;  begin    c := (a or b);  end;    //使用Or表示逻辑时, Or左右的表达式必须用小括号括起, 以避免以生条件的冲突  //如果在条件语句中使用 Or, 则编辑器不知道用户使用Or做什么  例如:  if a>0 or b>0 then  //编译器可能会理解为:  if a>(0 or b)>0 then  //或者  if (a>0) or (b>0) then  //但是实际编译时, 编译器会产生一个冲突, 报告错误  //并且第一种可能包含了a>b>c的形式, 这在Delphi中不被支持  //所以使用Or运算符时必须使用括号, 以区分左右的条件.  //表示位运算时也必须加上括号, 将Or以及左右参数括起.
  

out

  
//Out关键字说明了方法参数的输出方式, 一般的函数只能有一个返回值,   //使用Out可以在一个函数中返回多个结果.  //Out和var不同, Out是以返回值的形式进行参数返回, 而var是直接输入一个参数的地址.  procedure X(out i: Integer; out s: string);  begin  　i := i * 2;  　s := s + 'abc';  end;    procedure TForm1.Button1Click(Sender: TObject);  var  　i: Integer;  　s: string;  begin  　i := 20;  　s := 'xxx';  　X(i,s);  end;

overload

//Overload关键字指出了用于重载的方法, 重载即方法名相同,   //但是参数数量, 类型或顺序不同, 满足此条件的构成重载.  function X(i: Integer): string; overload;  function X(s: string): string; overload;    //从父类继承时, 如果子类拥有和父类相同的方法, 则也必须用overload构成重载,   //但是此类重载也必须满足重载的要求.  type  　TDemo = class(TComponent)  　public  　　procedure CreateWnd(AOwner: TWinControl); overload;  　end;    //如上例, 子类拥有的方法为:  procedure CreateWnd; {继承自父类}  procedure CreateWnd(AOwner: TWinControl); {子类声明}  //共两个CreateWnd方法.    //如果不使用重载, 则在子类中可以覆盖父类的方法.

override

//Override用于覆盖一个Virtual或是Dynamic形式的方法.  //覆盖时必须沿用被覆盖方法的声明, 并且不允许修改原方法的参数和返回类型.  procedure Create(AOwner: TComponent); override;    //Override多用于继承, 用子类覆盖掉父类的方法.  type  　TClassA = class  　　procedure X; virtual;  　end;    　TClassB = class(TClassA)  　　procedure X; override;  　end;    //如上例, 子类拥有的方法为:  procedure X; {从父类覆盖}  //父类拥有的方法为:  procedure X; {父类自身方法, 未被覆盖}    //如果父类的方法未用Virtual或Dynamic声明,   //或是有修改参数的需要, 则必须用Reintroduce关键字进行覆盖.
  

package

  
//Package关键字用于指出一个工程为控件库.  //控件库编译后生成BPL文件, 可被安装到Delphi的控件库中, 从而在以后的开发中使用控件.  package DATAX;    requires      rtl,      clx;    contains      MyUnit in 'C:\MyProject\MyUnit.pas';  end.

packed

//Packed关键字用于对结构体记录或数组进行打包, 打包后被打包对象的体积能显著减小.  type  　TPerson = packed Record  　　PName: string[32];  　　PAge: Integer;  　end;  　MyArray: packed array of PChar;
  

pascal

  
//Pascal标明了函数调用协定,   //指出函数在调用时遵循Pascal原因, 即先对所有的变量进行初始化,   //避免因异步线程调用而产生的错误.它是向下兼容的.  function X(i: Integer): Integer; Pascal;  begin  　Result := i * 2;  end;

private

//Private标明了类内元素的访问区分权限, 被Private区分的元素只能被本类内部访问.
  

procedure

  
//Procedure用于声明过程  procedure X(i: Integer);    //它也可以用于动态函数的声明  type  　TProc = procedure(i: Integer) of object;    //动态声明时, 不需要指出过程名, 只需要指出参数就可以, 具体的过程名可以在后期绑定.

program

//Program关键字用于指出一个工程为应用程序.控件库编译后生成exe文件, 可以直接执行  program Project1;  uses    Forms,    Unit1 in 'Unit1.pas' ;  {$R *.res}  begin    Application.Initialize;    Application.CreateForm(TForm1, Form1);    Application.Run;  end.

property

//Property关键字用于声明属性, 属性分为显式属性和隐式属性两种,   //只有声明在published访问区分符下的属性才是显式属性, 可以直接在对象查看器中查看.  type  　TDemo = class  　Private  　　fValue: Integr;  　Published  　　property Value: Integer read fValue write fValue;  　end;    //事件也是属性的一种, 可以在published区分符下用Property进行声明  type  　TOnTextChange=procedure (Sender: TObject) of object;  　TDemo = class  　private  　　fEvent: TOnTexChange;  　published  　　property OntextChange: TOnTextChange read fEvent write fEvent;  　end;

protected

//Protected标明了类内元素的访问区分权限, 被Protected区分的元素只能被本类内部和其子类访问.
  

public

  
//Public标明了类内元素的访问区分权限, 被Public区分的元素能够被类内和类外任何对象访问.

published

//Published标明了类内元素的访问区分权限.  //被Published区分的元素能够被类内和类外任何RTTI对象访问  //只在声明在Published区分符下的属性才能够成为显式属性并在对象查看器中显示.
  

raise

  
//Raise语句用于抛出异常,   //如果希望通过外部程序处理异常, 或是在异常发生时重新将异常抛出, 可以使用Raise语句.  function GetString(i: Integer): string;  begin  　if i < 0 then  　　raise exception.Create('Integer Cannot smaller than 0');  　Result := IntToStr(i);  end;    //在异常处理中, 可以重新抛出异常  try  　i := StrToInt(s);  except  　on E: exception do  　　raise exception.Create(E.Message);  end;

read

//Read用于标识属性中读取所使用的成员或方法.  private  　fValue: Integer;  published  　property Value: Integer read fValue;    //上例中即表明Value属性的值从fValue成员上读取.

readonly

//ReadOnly关键字用于标识一个对象是否只读.  property ReadOnly;    //当ReadOnly设为True时, 不允许用户手动修改属性, 只能通过其他对象来操作.

record

//Record关键字用于声明一个结构体记录,   //一个结构体可以视为一个不需要实例化的对象, 拥有自己的成员.  type  　TPerson = record  　　PName: string[32];  　　PAge: Integer;  　end;

register

//Register标明了函数调用协定, 指出函数在被调用时可以在注册表内留下记录.它是向下兼容的.  function Add(a,b: Integer): Integer; Register; Register    //关键字还用于向控件库或是IDE注册控件或是专家工具.  procedure Register;  begin  　RegisterComponents('Sample', [TDemo]);  end;

reintroduce

//Reintroduce用于重新发布方法, 通常用于继承时,   //如果要覆盖的方法是静态方法, 或是需要修改方法的参数等, 必须用Reintroduce进行重发布.  //对于Virtual或Dynamic方法, 可以直接用Override进行覆盖.  type  　TClassA = class  　　procedure X;  　end;  　TClassB = class(TClassA)  　　procedure X; reintroduce;  　end;  　TClassC = class(TClassB)  　　procedure X(i: Integer); reintroduce;  　end;

repeat

//repeat关键字用于引出repeat循环结构,   //该循环必须先执行一次循环体, 然后再对循环条件进行判断.repeat必须与Until关键字联合使用.  i := 0;  repeat  　sum := sum + i;  　Inc(i);  until(i >= 100);
  

requires

  
//Requires关键字指出了编译Package时的必备条件.若Requires的条件未满足, 则不允许编译包.  package DATAX;    requires      rtl,      clx;  end.

resourcestring

//ResourceString用于声明资源字符串, 资源字符串可以在被声明的结构内使用.  ResourceString  　CreateError = 'Cannot create file %s';  　OpenError = 'Cannot open file %s';  　LineTooLong = 'Line too long';  　ProductName = 'Borland Rocks';  　SomeResourceString = SomeTrueConstant;

safecall

  
//Safecall是函数调用协定的一种, 它规定了被COM调用的函数所必须遵守和规则.  //在编译时, Safecall声明的函数被编译成COM接口兼容的.  procedure X(s: WideString); safecall;    //在编译后成为:  procedure X(s: PAnsiString);
  

set

  
//Set关键字用于声明集合类, 集合类允许用集合运算符, 如in等进行操作.  type  　TCol = (cA,cB,cC);  　TCols = set of TCol;    //操作时允许使用加减符号来添加或删除某个集合元素  var  　Cols: Tcols;  begin  　Cols := Cols + [cA,cB];  end;

shl

//SHL表示向左移位, 左移的位数即乘以2的幂数  var  　x: Integer;  begin  　X := 2 shl 3; {16}  end;

shr

//SHR表示向右移位, 右移的位数即除以2的幂数  var  　x: Integer;  begin  　X := 16 shr 2; {4}  end;

stdcall

//Stdcall是函数调用协定的一种, 它规定了能让程序调用的函数所应遵守的规则.  //Stdcall关键字必须在主调方和被调方之间形成配对.    //例如, 被调方函数:  Library Demo;  function X(i: Integer): Integer; stdcall;  begin  　Result := i * 2;  end;  exports  　X;  begin  end.    //主调方函数:  function X(i: Integer): Integer; stdcall; external 'Demo.dll';    //同时需要注意, 使用Stdcall关键字时, 被调函数是大小写敏感的, 此处极容易出错.

stored

//Stored用于指出一个属性的值是否能被保留, 若指定了True, 则允许对属性值进行赋值撤销的操作.  property Value: string read fValue write fValue stored True;
  

string

  
//String是一个数据类型, 它代表了字符串.  var  　Str: string;

then

//Then关键字用于If语句中, 当If条件成立时, 执行Then后的语句.  var  　a,b: Integer;  begin  　if a > b then  　　WriteLn('a')  　else  　　WriteLn('b');  end;

threadvar

//Threadvar标识了一个随线程启动而创建的变量,   //如果用Threadvar声明变量, 则在程序结束前必须手动释放其占用的空间.  threadvar S: AnsiString;  S := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';  S := '';    //S := ''; 即释放变量S所占用的内存.

to

//To关键字用于For语句, 指明循环变量是递增的.  for i := 10 to 100 do  　ListBox1.Items.Add(IntToStr(i));    //在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.

try

//try语句用于异常处理, 对于有可能发生异常的语句, 可以放在try结构下, 以便对其进行异常保护.  try  　i := StrToInt(s);  except  　ShowMessage('Error');  end;

type

//Type关键字用于声明各种对象, 用Type关键字声明的对象, 在传递时按引用传递.  type  　TDemo = class  　end;    //type也用来声明枚举类型或是按引用传递的变量.  type  　TCol = (cA,cB,cC);  　TInt = Integer;

unit

  
//Unit标识了单元的开头, 单元的基本结构为 Unit...Interface...implementation...end.  Unit Unit1;  Interface  　uses Classes;  implementation  end.    //一个完整的单元必须拥有Unit作为开头.

until

//Until关键字用于判断repeat循环结构的循环条件,   //如果循环条件为真, 则退出循环.Until必须与repeat关键字联合使用.  i := 0;  repeat  　sum := sum + i;  　Inc(i);  until(i >= 100);
  

uses

  
//Uses用于引用一个外部的单元, 并且能够使用该单元中的公共部分.  //Uses语句通常放在一个单元的接口或是实现部分.  Interface  　uses Classes;  Implemention  　uses frmAbout;

var

//var关键字用于声明一个变量或是对象, 用var声明的变量接值传递.  var  　i: Integer;  　s: string;    //var也可以用于标识按引用传递的方法参数  function X(var i: Integer): Integer;    //上述函数中的参数i即按引用传递, 它的值可以在函数执行时被改变, 并返回主调函数.

varargs

//varArgs标识了引用参数, 它必须和Cdecl关键字联用, 表明允许调用的函数使用引用传递.  function printf(Format: PChar): Integer; cdecl; varargs;    //上述代码从C++的类库中引用了Printf函数, 并允许按引用的方式传入参数.

virtual

//Virtual用于声明一个虚方法,   //虚方法可以被覆盖, 并且可以使程序运行速度尽可能的快(区别于Dynamic).  procedure X(i: Integer); virtual;
  

while

  
//While关键字用于引出While循环语句, 循环前先进行循环条件的判断, 如果条件为真则执行循环.  i := 0;  while i < 100 do  begin  　sum := sum + i;  　Inc(i);  end;

with

//With关键字用于将相同的对象集合起来处理, 它可以省去输入大量重复的代码, 使代码看上去比较精简.  with Form1.Memo1.Lines do  begin  　Clear;  　Append('abc');  　Append('def');  　SaveToFile('C:\demo.txt');  end;    //上面这段代码如果不使用With语句, 则显得非常冗余复制内容到剪贴板代码:  Form1.Memo1.Lines.Clear;  Form1.Memo1.Lines.Append('abc');  Form1.Memo1.Lines.Append('def');  Form1.Memo1.Lines.SaveToFile('C:\demo.txt');

write

//Write用于标识属性中写入所使用的成员或方法.  private  　fValue: Integer;  published  　property Value: Integer write fValue;    //上例中即表明Value属性的值写入到fValue成员上.

writeonly

//writeonly关键字用于标识一个对象是否只写.  property writeonly;    //当writeonly设为True时, 不允许用户读取属性, 只能通过其他对象来操作.

xor

//Xor用于取异或, 当两个操作数相等时, 返回False, 不等时返回True.  var  　a,b: Integer;  begin  　a := 2; b := 3;  　if a xor b then  　　WriteLn('a xor b')  　else  　　WriteLn('a not xor b');  end;    //Xor也用于计算异或值  WriteLn(IntToStr(3 xor 5)); {6}
  

原稿来源: http://mydelphi.5d6d.com/viewthread.php?tid=252&extra=&page=1 

【转】Com+组件如何安装？

1、安装COM+组件有两种方式，第一种：如果是在IDE环境里，点击"Run->Install COM+  Objects"即可把打开的Active Library项目安装到COM+环境中，注意：如果打开的项目是 一个普通的Application项目，是不能被安装到COM+环境中的。第二种办法：打开控制面板-> 管理工具->组件服务->计算机->我的电脑->COM+应用程序，在COM+应用程序的树项上点击 鼠标右键，选择"新建->应用程序"->创建一个空的应用程序，并为此应用程序命名，接下 来点击"下一步"直到结束即可。建立了空的COM+应用程序后，接下来就是把COM DLL安装 到COM+应用程序中了。在刚建立的空应用程序的树项中新建一个组件，选择"安装新组件"， 在打开文件对话框中选择要安装到COM+环境中的DLL文件，之后跟着向导做都可以了，要把 多个COM DLL安装到同一个COM+应用程序包中，只需重复以上步骤即可。  2、"导出客户端组件包"指的是把已经注册的组件导出为.msi格式的文件，这些文件在客 户端安装后，只会在客户端注册组件，而不会安装多余的文件。如果不在客户端注册组件， 是不不能调用位于服务器上的组件的（此指服务器和客户端分布在不同的机器上时）。

摘自： http://www.winu.cn/space-14160-do-blog-id-9024.html

【转】Delphi下可以实现dispinterface么？该如何解决

Delphi下可以实现dispinterface么？
据说dispinterface就是纯分发接口，未实现IUnknown的
在用连接点的时候，需要给它一个dispinterface的接口，通常就是给它IDispatch接口，但是因为不能实现dispinterface接口，弄得每次QueryInterface的时候要比较GUID，如果是某个dispinterface，就返回对应的IDispatch，而不能使用QueryInterface的默认实现。

大家在自己手动使用事件连接点的时候一般怎么干的啊？还有，有没有好一点的办法能够直接将Invoke调用映射到一系列方法上去？Delphi编译器有没有对它的默认实现？

------解决方案--------------------------------------------------------
Delphi帮助就有：
type
IStringsDisp = dispinterface
['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}']
property ControlDefault[Index: Integer]: OleVariant dispid 0; default;
function Count: Integer; dispid 1;
property Item[Index: Integer]: OleVariant dispid 2;
procedure Remove(Index: Integer); dispid 3;
procedure Clear; dispid 4;
function Add(Item: OleVariant): Integer; dispid 5;
function _NewEnum: IUnknown; dispid -4;
end; 
------解决方案--------------------------------------------------------
楼主理解有点不对

IUnkonwn 是最底的带 GUID 接口 等价于 IInterface, 派生于 interface 用于 COM 实现时转义为 IUnknown, delphi 接口有一个广意性, 它不一定非要是 COM 对像

IDispatch 叫调度接口, 定义为
IDispatch = interface(IUnknown)
['{00020400-0000-0000-C000-000000000046}']
function GetTypeInfoCount(out Count: Integer): HResult; stdcall;
function GetTypeInfo(Index, LocaleID: Integer; out TypeInfo): HResult; stdcall;
function GetIDsOfNames(const IID: TGUID; Names: Pointer;
NameCount, LocaleID: Integer; DispIDs: Pointer): HResult; stdcall;
function Invoke(DispID: Integer; const IID: TGUID; LocaleID: Integer;
Flags: Word; var Params; VarResult, ExcepInfo, ArgErr: Pointer): HResult; stdcall;
end;
其中 2 个方法最为重要, GetIDsOfNames和 Invoke

注意 GetIdsOfNames 中参数  
Names 是一个 c 数组
DispIDs 实际是一个整形数组
这里面的内容就是 函数名 <--> Disp id 之间的关系

现在是 Invoke 参数, 跟上面很有关系
DispId 是用 name 查出来的 Id, 并不支持 Name 调用
... 下面是参数之类

换句话说你如果直接知道 DispID 就可以直接调用 Invoke 而不必用 GetIDsOfNames(用函数名称取得 id)

摘自： http://www.myexception.cn/delphi/347595.html 

基于PHP的cURL快速入门

cURL 是一个利用URL语法规定来传输文件和数据的工具，支持很多协议，如HTTP、FTP、TELNET等。最爽的是，PHP也支持 cURL 库。本文将介绍 cURL 的一些高级特性，以及在PHP中如何运用它。

为什么要用 cURL?

是的，我们可以通过其他办法获取网页内容。大多数时候，我因为想偷懒，都直接用简单的PHP函数：

以下为引用的内容： $content = file_get_contents("http://www.nettuts.com"); // or $lines = file("http://www.nettuts.com"); // or readfile(http://www.nettuts.com);

不过，这种做法缺乏灵活性和有效的错误处理。而且，你也不能用它完成一些高难度任务——比如处理coockies、验证、表单提交、文件上传等等。

引用：
cURL 是一种功能强大的库，支持很多不同的协议、选项，能提供 URL 请求相关的各种细节信息。

基本结构

在学习更为复杂的功能之前，先来看一下在PHP中建立cURL请求的基本步骤：

1. 初始化
2. 设置变量
3. 执行并获取结果
4. 释放cURL句柄

以下为引用的内容： // 1. 初始化 $ch = curl_init(); // 2. 设置选项，包括URL curl_setopt($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. 执行并获取HTML文档内容 $output = curl_exec($ch); // 4. 释放curl句柄 curl_close($ch);

第二步（也就是 curl_setopt() ）最为重要，一切玄妙均在此。有一长串cURL参数可供设置，它们能指定URL请求的各个细节。要一次性全部看完并理解可能比较困难，所以今天我们只试一下那些更常用也更有用的选项。

检查错误

你可以加一段检查错误的语句（虽然这并不是必需的）：

以下为引用的内容： // ... $output = curl_exec($ch); if ($output === FALSE) {     echo "cURL Error: " . curl_error($ch); } // ...

请注意，比较的时候我们用的是“=== FALSE”，而非“== FALSE”。因为我们得区分 空输出 和 布尔值FALSE，后者才是真正的错误。

获取信息

这是另一个可选的设置项，能够在cURL执行后获取这一请求的有关信息：

以下为引用的内容： // ... curl_exec($ch); $info = curl_getinfo($ch); echo '获取'. $info['url'] . '耗时'. $info['total_time'] . '秒'; // ...

返回的数组中包括了以下信息：

• “url” //资源网络地址
• “content_type” //内容编码
• “http_code” //HTTP状态码
• “header_size” //header的大小
• “request_size” //请求的大小
• “filetime” //文件创建时间
• “ssl_verify_result” //SSL验证结果
• “redirect_count” //跳转技术  
• “total_time” //总耗时
• “namelookup_time” //DNS查询耗时
• “connect_time” //等待连接耗时
• “pretransfer_time” //传输前准备耗时
• “size_upload” //上传数据的大小
• “size_download” //下载数据的大小
• “speed_download” //下载速度
• “speed_upload” //上传速度
• “download_content_length”//下载内容的长度
• “upload_content_length” //上传内容的长度  
• “starttransfer_time” //开始传输的时间
• “redirect_time”//重定向耗时

基于浏览器的重定向

在第一个例子中，我们将提供一段用于侦测服务器是否有基于浏览器的重定向的代码。例如，有些网站会根据是否是手机浏览器甚至用户来自哪个国家来重定向网页。

我们利用 CURLOPT_HTTPHEADER 选项来设定我们发送出的HTTP请求头信息（http headers），包括user agent信息和默认语言。然后我们来看看这些特定网站是否会把我们重定向到不同的URL。

以下为引用的内容： // 测试用的URL $urls = array(     "http://www.cnn.com",     "http://www.mozilla.com",     "http://www.facebook.com" ); // 测试用的浏览器信息 $browsers = array(     "standard" => array (         "user_agent" => "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6 (.NET CLR 3.5.30729)",         "language" => "en-us,en;q=0.5"         ),     "iphone" => array (         "user_agent" => "Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1A537a Safari/419.3",         "language" => "en"         ),     "french" => array (         "user_agent" => "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)",         "language" => "fr,fr-FR;q=0.5"         ) ); foreach ($urls as $url) {     echo "URL: $url\n";     foreach ($browsers as $test_name => $browser) {         $ch = curl_init();         // 设置 url         curl_setopt($ch, CURLOPT_URL, $url);         // 设置浏览器的特定header         curl_setopt($ch, CURLOPT_HTTPHEADER, array(                 "User-Agent: {$browser['user_agent']}",                 "Accept-Language: {$browser['language']}"             ));         // 页面内容我们并不需要         curl_setopt($ch, CURLOPT_NOBODY, 1);         // 只需返回HTTP header         curl_setopt($ch, CURLOPT_HEADER, 1);         // 返回结果，而不是输出它         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);         $output = curl_exec($ch);         curl_close($ch);         // 有重定向的HTTP头信息吗?         if (preg_match("!Location: (.*)!", $output, $matches)) {             echo "$test_name: redirects to $matches[1]\n";         } else {             echo "$test_name: no redirection\n";         }     }     echo "\n\n"; }

首先，我们建立一组需要测试的URL，接着指定一组需要测试的浏览器信息。最后通过循环测试各种URL和浏览器匹配可能产生的情况。

因为我们指定了cURL选项，所以返回的输出内容则只包括HTTP头信息（被存放于 $output 中）。利用一个简单的正则，我们检查这个头信息中是否包含了“Location:”字样。

运行这段代码应该会返回如下结果：

用POST方法发送数据

当发起GET请求时，数据可以通过“查询字串”（query string）传递给一个URL。例如，在google中搜索时，搜索关键即为URL的查询字串的一部分：

http://www.google.com/search?q=nettuts

这种情况下你可能并不需要cURL来模拟。把这个URL丢给“file_get_contents()”就能得到相同结果。

不过有一些HTML表单是用POST方法提交的。这种表单提交时，数据是通过 HTTP请求体（request body） 发送，而不是查询字串。例如，当使用CodeIgniter论坛的表单，无论你输入什么关键字，总是被POST到如下页面：

http://codeigniter.com/forums/do_search/

你可以用PHP脚本来模拟这种URL请求。首先，新建一个可以接受并显示POST数据的文件，我们给它命名为post_output.php：

print_r($_POST);

接下来，写一段PHP脚本来执行cURL请求：

以下为引用的内容： $url = "http://localhost/post_output.php"; $post_data = array (     "foo" => "bar",     "query" => "Nettuts",     "action" => "Submit" ); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // 我们在POST数据哦！ curl_setopt($ch, CURLOPT_POST, 1); // 把post的变量加上 curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close($ch); echo $output;

执行代码后应该会得到以下结果：

这段脚本发送一个POST请求给 post_output.php ，这个页面 $_POST 变量并返回，我们利用cURL捕捉了这个输出。

文件上传

上传文件和前面的POST十分相似。因为所有的文件上传表单都是通过POST方法提交的。

首先新建一个接收文件的页面，命名为 upload_output.php：

print_r($_FILES);

以下是真正执行文件上传任务的脚本：

以下为引用的内容： $url = "http://localhost/upload_output.php"; $post_data = array (     "foo" => "bar",     // 要上传的本地文件地址     "upload" => "@C:/wamp/www/test.zip" ); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close($ch); echo $output;

如果你需要上传一个文件，只需要把文件路径像一个post变量一样传过去，不过记得在前面加上@符号。执行这段脚本应该会得到如下输出：

cURL批处理（multi cURL）

cURL还有一个高级特性——批处理句柄（handle）。这一特性允许你同时或异步地打开多个URL连接。

下面是来自来自php.net的示例代码：

以下为引用的内容： // 创建两个cURL资源 $ch1 = curl_init(); $ch2 = curl_init(); // 指定URL和适当的参数 curl_setopt($ch1, CURLOPT_URL, "http://lxr.php.net/"); curl_setopt($ch1, CURLOPT_HEADER, 0); curl_setopt($ch2, CURLOPT_URL, "http://www.php.net/"); curl_setopt($ch2, CURLOPT_HEADER, 0); // 创建cURL批处理句柄 $mh = curl_multi_init(); // 加上前面两个资源句柄 curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); // 预定义一个状态变量 $active = null; // 执行批处理 do {     $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc == CURLM_OK) {     if (curl_multi_select($mh) != -1) {         do {             $mrc = curl_multi_exec($mh, $active);         } while ($mrc == CURLM_CALL_MULTI_PERFORM);     } } // 关闭各个句柄 curl_multi_remove_handle($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close($mh);

这里要做的就是打开多个cURL句柄并指派给一个批处理句柄。然后你就只需在一个while循环里等它执行完毕。

这个示例中有两个主要循环。第一个 do-while 循环重复调用 curl_multi_exec() 。这个函数是无隔断（non-blocking）的，但会尽可能少地执行。它返回一个状态值，只要这个值等于常量 CURLM_CALL_MULTI_PERFORM ，就代表还有一些刻不容缓的工作要做（例如，把对应URL的http头信息发送出去）。也就是说，我们需要不断调用该函数，直到返回值发生改变。

而接下来的 while 循环，只在 $active 变量为 true 时继续。这一变量之前作为第二个参数传给了 curl_multi_exec() ，代表只要批处理句柄中是否还有活动连接。接着，我们调用 curl_multi_select() ，在活动连接（例如接受服务器响应）出现之前，它都是被“屏蔽”的。这个函数成功执行后，我们又会进入另一个 do-while 循环，继续下一条URL。

还是来看一看怎么把这一功能用到实处吧：

WordPress 连接检查器

想象一下你有一个文章数目庞大的博客，这些文章中包含了大量外部网站链接。一段时间之后，因为这样那样的原因，这些链接中相当数量都失效了。要么是被和谐了，要么是整个站点都被功夫网了...

我们下面建立一个脚本，分析所有这些链接，找出打不开或者404的网站/网页，并生成一个报告。

请注意，以下并不是一个真正可用的WordPress插件，仅仅是一段独立功能的脚本而已，仅供演示，谢谢。

好，开始吧。首先，从数据库中读取所有这些链接：

以下为引用的内容： // CONFIG $db_host = 'localhost'; $db_user = 'root'; $db_pass = ''; $db_name = 'wordpress'; $excluded_domains = array(     'localhost', 'www.mydomain.com'); $max_connections = 10; // 初始化一些变量 $url_list = array(); $working_urls = array(); $dead_urls = array(); $not_found_urls = array(); $active = null; // 连到 MySQL if (!mysql_connect($db_host, $db_user, $db_pass)) {     die('Could not connect: ' . mysql_error()); } if (!mysql_select_db($db_name)) {     die('Could not select db: ' . mysql_error()); } // 找出所有含有链接的文章 $q = "SELECT post_content FROM wp_posts     WHERE post_content LIKE '%href=%'     AND post_status = 'publish'     AND post_type = 'post'"; $r = mysql_query($q) or die(mysql_error()); while ($d = mysql_fetch_assoc($r)) {     // 用正则匹配链接     if (preg_match_all("!href=\"(.*?)\"!", $d['post_content'], $matches)) {         foreach ($matches[1] as $url) {             // exclude some domains             $tmp = parse_url($url);             if (in_array($tmp['host'], $excluded_domains)) {                 continue;             }             // store the url             $url_list []= $url;         }     } } // 移除重复链接 $url_list = array_values(array_unique($url_list)); if (!$url_list) {     die('No URL to check'); }

我们首先配置好数据库，一系列要排除的域名（$excluded_domains），以及最大并发连接数（$max_connections）。然后，连接数据库，获取文章和包含的链接，把它们收集到一个数组中（$url_list）。

下面的代码有点复杂了，因此我将一小步一小步地详细解释：

以下为引用的内容： // 1. 批处理器 $mh = curl_multi_init(); // 2. 加入需批量处理的URL for ($i = 0; $i < $max_connections; $i++) {     add_url_to_multi_handle($mh, $url_list); } // 3. 初始处理 do {     $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 4. 主循环 while ($active && $mrc == CURLM_OK) {     // 5. 有活动连接     if (curl_multi_select($mh) != -1) {         // 6. 干活         do {             $mrc = curl_multi_exec($mh, $active);         } while ($mrc == CURLM_CALL_MULTI_PERFORM);         // 7. 有信息否？         if ($mhinfo = curl_multi_info_read($mh)) {             // 意味着该连接正常结束             // 8. 从curl句柄获取信息             $chinfo = curl_getinfo($mhinfo['handle']);             // 9. 死链么？             if (!$chinfo['http_code']) {                 $dead_urls []= $chinfo['url'];             // 10. 404了?             } else if ($chinfo['http_code'] == 404) {                 $not_found_urls []= $chinfo['url'];             // 11. 还能用             } else {                 $working_urls []= $chinfo['url'];             }             // 12. 移除句柄             curl_multi_remove_handle($mh, $mhinfo['handle']);             curl_close($mhinfo['handle']);             // 13. 加入新URL，干活             if (add_url_to_multi_handle($mh, $url_list)) {                 do {                     $mrc = curl_multi_exec($mh, $active);                 } while ($mrc == CURLM_CALL_MULTI_PERFORM);             }         }     } } // 14. 完了 curl_multi_close($mh); echo "==Dead URLs==\n"; echo implode("\n",$dead_urls) . "\n\n"; echo "==404 URLs==\n"; echo implode("\n",$not_found_urls) . "\n\n"; echo "==Working URLs==\n"; echo implode("\n",$working_urls); // 15. 向批处理器添加url function add_url_to_multi_handle($mh, $url_list) {     static $index = 0;     // 如果还剩url没用     if ($url_list[$index]) {         // 新建curl句柄         $ch = curl_init();         // 配置url         curl_setopt($ch, CURLOPT_URL, $url_list[$index]);         // 不想输出返回的内容         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);         // 重定向到哪儿我们就去哪儿         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);         // 不需要内容体，能够节约带宽和时间         curl_setopt($ch, CURLOPT_NOBODY, 1);         // 加入到批处理器中         curl_multi_add_handle($mh, $ch);         // 拨一下计数器，下次调用该函数就能添加下一个url了         $index++;         return true;     } else {         // 没有新的URL需要处理了         return false;     } }

下面解释一下以上代码。列表的序号对应着代码注释中的顺序数字。

1. 新建一个批处理器。Created a multi handle.
2. 稍后我们将创建一个把URL加入批处理器的函数 add_url_to_multi_handle() 。每当这个函数被调用，就有一个新url被加入批处理器。一开始，我们给批处理器添加了10个URL（这一数字由 $max_connections 所决定）。
3.   运行 curl_multi_exec()  进行初始化工作是必须的，只要它返回 CURLM_CALL_MULTI_PERFORM 就还有事情要做。这么做主要是为了创建连接，它不会等待完整的URL响应。
4. 只要批处理中还有活动连接主循环就会一直持续。
5. curl_multi_select() 会一直等待，直到某个URL查询产生活动连接。
6. cURL的活儿又来了，主要是获取响应数据。
7. 检查各种信息。当一个URL请求完成时，会返回一个数组。
8. 在返回的数组中有一个 cURL 句柄。我们利用其获取单个cURL请求的相应信息。
9. 如果这是一个死链或者请求超时，不会返回http状态码。
10. 如果这个页面找不到了，会返回404状态码。
11. 其他情况我们都认为这个链接是可用的（当然，你也可以再检查一下500错误之类...）。
12. 从该批次移除这个cURL句柄，因为它已经没有利用价值了，关了它！
13. 很好，现在可以另外加一个URL进来了。再一次地，初始化工作又开始进行...
14. 嗯，该干的都干了。关闭批处理器，生成报告。
15. 回过头来看给批处理器添加新URL的函数。这个函数每调用一次，静态变量 $index 就递增一次，这样我们才能知道还剩多少URL没处理。

我把这个脚本在我的博客上跑了一遍（测试需要，有一些错误链接是故意加上的），结果如下：

以下为引用的内容： <img border="0" src="http://nettuts.s3.cdn.plus.org/534_curl/ss_4.png" />

共检查约40个URL，只耗费两秒不到。当需要检查更加大量的URL时，其省心省力的效果可想而知！如果你同时打开10个连接，还能再快上10倍！另外，你还可以利用cURL批处理的无隔断特性来处理大量URL请求，而不会阻塞你的Web脚本。

另一些有用的cURL 选项

HTTP 认证

如果某个URL请求需要基于 HTTP 的身份验证，你可以使用下面的代码：
复制内容到剪贴板代码:

以下为引用的内容： $url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // 发送用户名和密码 curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword"); // 你可以允许其重定向 curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // 下面的选项让 cURL 在重定向后 // 也能发送用户名和密码 curl_setopt($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $output = curl_exec($ch); curl_close($ch);

FTP 上传

PHP 自带有 FTP 类库， 但你也能用 cURL：

以下为引用的内容： // 开一个文件指针 $file = fopen("/path/to/file", "r"); // url里包含了大部分所需信息 $url = "ftp://username:password@mydomain.com:21/path/to/new/file"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // 上传相关的选项 curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt($ch, CURLOPT_INFILE, $fp); curl_setopt($ch, CURLOPT_INFILESIZE, filesize("/path/to/file")); // 是否开启ASCII模式 (上传文本文件时有用) curl_setopt($ch, CURLOPT_FTPASCII, 1); $output = curl_exec($ch); curl_close($ch);

翻墙术

你可以用代理发起cURL请求：

以下为引用的内容： $ch = curl_init(); curl_setopt($ch, CURLOPT_URL,'http://www.example.com'); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // 指定代理地址 curl_setopt($ch, CURLOPT_PROXY, '11.11.11.11:8080'); // 如果需要的话，提供用户名和密码 curl_setopt($ch, CURLOPT_PROXYUSERPWD,'user:pass'); $output = curl_exec($ch); curl_close ($ch);

回调函数

可以在一个URL请求过程中，让cURL调用某指定的回调函数。例如，在内容或者响应下载的过程中立刻开始利用数据，而不用等到完全下载完。

以下为引用的内容： $ch = curl_init(); curl_setopt($ch, CURLOPT_URL,'http://net.tutsplus.com'); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"progress_function"); curl_exec($ch); curl_close ($ch); function progress_function($ch,$str) {     echo $str;     return strlen($str); }

这个回调函数必须返回字串的长度，不然此功能将无法正常使用。

在URL响应接收的过程中，只要收到一个数据包，这个函数就会被调用。

小结

今天我们一起学习了cURL库的强大功能和灵活的扩展性。希望你喜欢。下一次要发起URL请求时，考虑下cURL吧！

原文：基于PHP的cURL快速入门

英文原文：http://net.tutsplus.com/tutorial%20...%20for-mastering-curl/

原文作者：Burak Guzel

本文链接：http://www.blueidea.com/tech/program/2010/7348.asp　

转：CSS模拟不同的拐角效果

 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" >
<head>
<meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
<title>FLYSO Blog--CSS模拟不同的拐角效果 </title>
<meta name="Author" content="Stu Nicholls" />
<style type="text/css">

body {background:#e0e0e0;}
/* Inset 3D Raised */
.raised {background: transparent; width:40%;}
.raised h1, .raised p {margin:0 10px;}
.raised h1 {font-size:2em; color:#fff;}
.raised p {padding-bottom:0.5em;}

.raised .b1, .raised .b2, .raised .b3, .raised .b4, .raised .b1b, .raised .b2b, .raised .b3b, .raised .b4b {display:block; overflow:hidden; font-size:1px;}
.raised .b1, .raised .b2, .raised .b3, .raised .b1b, .raised .b2b, .raised .b3b {height:1px;}
.raised .b2 {background:#ccc; border-left:1px solid #fff; border-right:1px solid #eee;}
.raised .b3 {background:#ccc; border-left:1px solid #fff; border-right:1px solid #ddd;}
.raised .b4 {background:#ccc; border-left:1px solid #fff; border-right:1px solid #aaa;}
.raised .b4b {background:#ccc; border-left:1px solid #eee; border-right:1px solid #999;}
.raised .b3b {background:#ccc; border-left:1px solid #ddd; border-right:1px solid #999;}
.raised .b2b {background:#ccc; border-left:1px solid #aaa; border-right:1px solid #999;}

.raised .b1 {margin:0 5px; background:#fff;}
.raised .b2, .raised .b2b {margin:0 3px; border-width:0 2px;}
.raised .b3, .raised .b3b {margin:0 2px;}
.raised .b4, .raised .b4b {height:2px; margin:0 1px;}
.raised .b1b {margin:0 5px; background:#999;}
.raised .boxcontent {display:block; background:#ccc; border-left:1px solid #fff; border-right:1px solid #999;}

/* Inset 3D Curved */
.inset {background: transparent; width:40%;}
.inset h1, .inset p {margin:0 10px;}
.inset h1 {font-size:2em; color:#fff;}
.inset p {padding-bottom:0.5em;}

.inset .b1, .inset .b2, .inset .b3, .inset .b4, .inset .b1b, .inset .b2b, .inset .b3b, .inset .b4b {display:block; overflow:hidden; font-size:1px;}
.inset .b1, .inset .b2, .inset .b3, .inset .b1b, .inset .b2b, .inset .b3b {height:1px;}
.inset .b2 {background:#ccc; border-left:1px solid #999; border-right:1px solid #aaa;}
.inset .b3 {background:#ccc; border-left:1px solid #999; border-right:1px solid #ddd;}
.inset .b4 {background:#ccc; border-left:1px solid #999; border-right:1px solid #eee;}
.inset .b4b {background:#ccc; border-left:1px solid #aaa; border-right:1px solid #fff;}
.inset .b3b {background:#ccc; border-left:1px solid #ddd; border-right:1px solid #fff;}
.inset .b2b {background:#ccc; border-left:1px solid #eee; border-right:1px solid #fff;}

.inset .b1 {margin:0 5px; background:#999;}
.inset .b2, .inset .b2b {margin:0 3px; border-width:0 2px;}
.inset .b3, .inset .b3b {margin:0 2px;}
.inset .b4, .inset .b4b {height:2px; margin:0 1px;}
.inset .b1b {margin:0 5px; background:#fff;}

.inset .boxcontent {display:block; background:#ccc; border-left:1px solid #999; border-right:1px solid #fff;}

/* Curved cutout Borders*/
.curved {background: transparent; width:40%;}
.curved h1, .curved p {margin:0 10px;}
.curved h1 {font-size:2em; color:#fff;}
.curved p {padding-bottom:0.5em;}

.curved .b1, .curved .b2, .curved .b3, .curved .b4 {display:block; overflow:hidden; height:1px; font-size:1px;}
.curved .b2, .curved .b3, .curved .b4 {background:#e0cea3; border-left:1px solid #fff; border-right:1px solid #fff;}
.curved .b1 {margin:0 4px; background:#fff;}
.curved .b2 {margin:0 4px; height:2px;}
.curved .b3 {margin:0 3px;}
.curved .b4 {margin:0; height:1px; border-width:0 3px 0 3px;}

.curved .boxcontent {display:block; background:#e0cea3; border:0 solid #fff; border-width:0 1px;}

/* flared serif */
.serif {background: transparent; width:40%;}
.serif h1, .serif p {margin:0 10px;}
.serif h1 {font-size:2em; color:#fff;}
.serif p {padding-bottom:0.5em;}

.serif .b1, .serif .b2, .serif .b3, .serif .b4 {display:block; overflow:hidden; font-size:1px;}
.serif .b1, .serif .b2, .serif .b3 {height:1px;}
.serif .b2, .serif .b3 {background:#fc0; border-left:1px solid #fff; border-right:1px solid #fff;}
.serif .b4 {background:#fc0; border-left:1px solid #fff; border-right:1px solid #fff;}

.serif .b1 {margin:0; background:#fff;}
.serif .b2 {margin:0 1px; border-width:0 2px;}
.serif .b3 {margin:0 3px;}
.serif .b4 {height:2px; margin:0 4px;}

.serif .boxcontent {display:block; background:#fc0; border-left:1px solid #fff; border-right:1px solid #fff; margin:0 5px;}

/* Pillar type */
.pillar {background: transparent; width:40%;}
.pillar h1, .pillar p {margin:0 10px;}
.pillar h1 {font-size:2em; color:#fff;}
.pillar p {padding-bottom:0.5em;}

.pillar .b1, .pillar .b2, .pillar .b3, .pillar .b4 {display:block; overflow:hidden; font-size:1px;}
.pillar .b1, .pillar .b2, .pillar .b4 {height:1px;}
.pillar .b2, .pillar .b3 {background:#d66; border-left:1px solid #fff; border-right:1px solid #fff;}
.pillar .b4 {background:#d66; border-left:4px solid #fff; border-right:4px solid #fff;}

.pillar .b1 {margin:0 2px; background:#fff;}
.pillar .b2 {margin:0 1px; border-width:0 1px;}
.pillar .b3 {height:2px; margin:0;}
.pillar .b4 {margin:0 2px;}

.pillar .boxcontent {display:block; background:#d66; border-left:1px solid #fff; border-right:1px solid #fff; margin:0 5px;}

</style>
</head>

<body>

<h2 class="bxs">Krazy Korners</h2>
<h3>by Stu Nicholls</h3>

<div class="curved">
<b class="b1"></b><b class="b2"></b><b class="b3"></b><b class="b4"></b>
<div class="boxcontent">
<h1>Example 1</h1>
<p>A box with cutout corners</p>
</div>
<b class="b4"></b><b class="b3"></b><b class="b2"></b><b class="b1"></b>
</div>
<p></p>

<div class="serif">
<b class="b1"></b><b class="b2"></b><b class="b3"></b><b class="b4"></b>

<div class="boxcontent">
<h1>Example 2</h1>
<p>Corners to give a serif effect.</p>
</div>
<b class="b4"></b><b class="b3"></b><b class="b2"></b><b class="b1"></b>
</div>
<p></p>

<div class="pillar">
<b class="b1"></b><b class="b2"></b><b class="b3"></b><b class="b2"></b><b class="b4"></b>

<div class="boxcontent">
<h1>Example 3</h1>
<p>Corners to give a rounded pillar effect.</p>
</div>
<b class="b4"></b><b class="b2"></b><b class="b3"></b><b class="b2"></b><b class="b1"></b>
</div>
<p></p>

<div class="raised">
<b class="b1"></b><b class="b2"></b><b class="b3"></b><b class="b4"></b>
<div class="boxcontent">
<h1>Example 4</h1>
<p>Rounded corners with raised borders</p>
</div>
<b class="b4b"></b><b class="b3b"></b><b class="b2b"></b><b class="b1b"></b>
</div>
<p></p>

<div class="inset">
<b class="b1"></b><b class="b2"></b><b class="b3"></b><b class="b4"></b>
<div class="boxcontent">
<h1>Example 5</h1>
<p>Rounded corners with inset borders</p>
</div>
<b class="b4b"></b><b class="b3b"></b><b class="b2b"></b><b class="b1b"></b>
</div>

</body>
</html>

摘自：http://blog.chinaunix.net/uid-20509084-id-1939379.html