文丰博客

Lazarus DBGrid 控件进阶技巧：列标题换行与行高自定义

Tue, 24 Feb 2026 13:21:08 +0800

Lazarus DBGrid 控件进阶技巧：列标题换行与行高自定义

2026-02-24 12:55·长岭文丰

Lazarus DBGrid 控件进阶技巧：列标题换行与行高自定义

在 Lazarus 开发中，DBGrid 是最常用的数据展示控件之一。然而，在实际开发过程中，我们经常会遇到一些看似简单却不易解决的问题，比如列标题换行和行高自定义。本文将详细介绍这两个常见需求的实现方法。

一、DBGrid 列标题换行实现

问题背景

在默认情况下，DBGrid 的列标题是单行显示的。当列标题文字较长时，要么被截断，要么需要很宽的列宽才能完整显示，影响界面美观。

解决方案

要实现列标题的多行显示，需要完成以下两个步骤：

1. 设置 Title.Multiline 属性为 True

在 DBGrid 的列编辑器中，选中需要换行的列，将其 Title.Multiline 属性设置为 True。

2. 在 Caption 中插入换行符

在列的 Title.Caption 属性中，使用 #13#10 来指定换行位置。

代码示例

// 方法一：在设计器中设置// 双击 DBGrid 打开列编辑器，设置对应列的 Title.Multiline = True// 并在 Title.Caption 中输入：第一行#13#10第二行// 方法二：在代码中动态设置DBGrid1.Columns[0].Title.Multiline := True;
DBGrid1.Columns[0].Title.Caption := '客户' + #13#10 + '信息';
DBGrid1.Columns[1].Title.Multiline := True;
DBGrid1.Columns[1].Title.Caption := '联系' + #13#10 + '方式';

效果说明

设置完成后，列标题将按照 #13#10 的位置进行换行显示，可以有效节省横向空间，使界面更加紧凑美观。

二、DBGrid 行高自定义实现

问题背景

DBGrid 控件提供了 DefaultRowHeight 属性来设置数据行的默认高度，但对于标题行的高度，DBGrid 没有直接公开的属性来修改。

属性与方法说明

属性/方法

说明

访问级别

DefaultRowHeight

设置数据行的默认高度

Public，可直接访问

ResizeRow

RowHeights

调整指定行的高度

Protected，需特殊技巧访问

注意：DBGrid 虽然继承自 TCustomGrid，但 ResizeRow方法和RowHeights 属性在 DBGrid 中不可直接访问，需要通过特殊技巧来修改标题行高度。

解决方案：类继承技巧访问 ResizeRow 方法

由于 ResizeRow 方法和RowHeights 属性是 protected（受保护）的，无法在外部直接调用，我们需要通过类继承技巧来访问。

unit Unit1;
{mode objfpc}{H+}
interface
uses
     Classes, SysUtils, Forms, Controls, Graphics, Dialogs, Grids, DBGrids, DB;
type	
	// 关键技巧：创建继承自 TCustomGrid 的辅助类
	// 不需要添加任何新方法，只是为了访问 protected 成员
TMyGrid = class(TCustomGrid);
TForm1 = class(TForm)
        DBGrid1: TDBGrid;
        DataSource1: TDataSource; 
    private
    		procedure InitDBGrid;
  public
  end;
  var
	Form1: TForm1;
implementation
{R *.lfm}
// 初始化 DBGrid 设置
procedure TForm1.InitDBGrid;
begin    // 设置数据行默认高度
    DBGrid1.DefaultRowHeight := 30;    // 通过类型转换访问 ResizeRow 方法
    // 参数说明：ResizeRow(行索引, 新高度)
    // 行索引 0 表示标题行，1 开始是数据行
    TMyGrid(DBGrid1).ResizeRow(0, 45);    // 启用列标题换行
    DBGrid1.Columns[0].Title.Multiline := True;
    DBGrid1.Columns[0].Title.Caption := '用户' + #13#10 + '姓名';

    DBGrid1.Columns[1].Title.Multiline := True;
    DBGrid1.Columns[1].Title.Caption := '联系' + #13#10 + '电话';
end;
// 窗体显示时初始化
procedure TForm1.FormShow(Sender: TObject);
begin
		InitDBGrid;
end;
end.

三、完整示例：列标题换行 + 行高调整

下面是一个完整的示例，同时实现列标题换行和行高自定义：

unit Unit1;
{mode objfpc}{H+}
interface
uses
    Classes, SysUtils, Forms, Controls, Graphics, Dialogs, Grids, DBGrids,
    DB, SQLite3Conn, SQLDB;
type
    // 用于访问 protected 方法的辅助类
    TMyGrid = class(TCustomGrid);
    TForm1 = class(TForm)
    DBGrid1: TDBGrid;
    DataSource1: TDataSource;
    SQLQuery1: TSQLQuery;
    SQLite3Connection1: TSQLite3Connection;
    btnApply: TButton;
    private
    procedure InitDBGrid;
    procedure ApplyRowHeight;
    procedure btnApplyClick(Sender: TObject);
    public
    end;
var
    Form1: TForm1;
implementation
{R *.lfm}
// 初始化 DBGrid 列设置
    procedure TForm1.InitDBGrid;
    begin// 启用标题换行DBGrid1.Columns[0].Title.Multiline := True;
        DBGrid1.Columns[0].Title.Caption := '用户' + #13#10 + '姓名';
        
        DBGrid1.Columns[1].Title.Multiline := True;
        DBGrid1.Columns[1].Title.Caption := '联系' + #13#10 + '电话';
        
        DBGrid1.Columns[2].Title.Multiline := True;
        DBGrid1.Columns[2].Title.Caption := '注册' + #13#10 + '日期';// 自动调整列宽以适应内容DBGrid1.AutoAdjustColumns := True;
    end;
    // 设置行高
    procedure TForm1.ApplyRowHeight;
    begin
        // 设置数据行默认高度
        DBGrid1.DefaultRowHeight := 30;
        // 设置标题行高度（配合多行标题显示）
        // 通过类型转换访问 protected 的 ResizeRow 方法
        TMyGrid(DBGrid1).ResizeRow(0, 50);
    end;
    // 按钮点击事件
    procedure TForm1.btnApplyClick(Sender: TObject);
    begin
        ApplyRowHeight;
    end;
    // 窗体显示时初始化
    procedure TForm1.FormShow(Sender: TObject);
    begin
        // 加载数据
        SQLQuery1.Open;
        // 初始化列设置
        InitDBGrid;
        // 设置行高
        ApplyRowHeight;
    end;
end.

四、注意事项

1. 关于换行符

- #13#10 是 Windows 标准的换行符（CR+LF）

- 在 Linux/macOS 上可能需要使用 #10（LF）

- Lazarus 的 LCL 通常会自动处理跨平台换行符

2. 关于行高设置时机

- 必须在 DBGrid 完成初始化后调用

- 建议在数据加载完成后执行

- 如果动态切换标题换行状态，需要重新调整标题行高度

3. ResizeRow 方法说明：

参数1：行索引（0 = 标题行，1 开始 = 数据行）

参数2：新的行高度（像素）

4. 辅助类定义位置

TMyGrid 辅助类可以定义在：

- 单元的 type 部分（推荐）

- 单独的单元文件中

- 项目的公共单元中（便于多处复用）

五、总结

功能	实现方法	关键代码
列标题换行	设置 Title.Multiline := True + Caption 中添加 #13#10	DBGrid1.Columns[0].Title.Multiline := True
数据行高度	使用 DefaultRowHeight 属性	DBGrid1.DefaultRowHeight := 30
标题行高度	继承 TCustomGrid 访问 ResizeRow 方法或RowHeights属性	TMyGrid(DBGrid1).ResizeRow(0, 45); TMyGrid(DBGrid1).RowHeights[0]:= 45;

核心要点：

1. 列标题换行：Title.Multiline := True + Caption 中加入 #13#10

2. 数据行高度：直接使用 DefaultRowHeight 属性

3. 标题行高度：通过 TMyGrid = class(TCustomGrid) 技巧访问 ResizeRow 方法或RowHeights属性

这两个技巧虽然简单，但在实际开发中非常实用。通过掌握这些方法，可以让你的 Lazarus DBGrid 界面更加美观和专业。

参考资源：

- Lazarus 官方文档：
https://www.lazarus-ide.org/

- Free Pascal 编译器文档：
https://www.freepascal.org/

- Lazarus 组件参考：
https://wiki.freepascal.org/DBGrid

粮食收购系统 Ver：3.9.1

Thu, 11 Dec 2025 13:45:18 +0800

粮食收购系统

一款适用于中小粮食收购企业的自动检斤系统，操作简单，功能强大

立即下载了解功能

软件简介

本软件是一款面向中小粮食收购企业的软件，操作简单，容易上手，一般企业员工无需电脑操作知识就可以操作，提升工作效率。

软件采用简洁直观的操作界面，无需复杂学习即可上手，可实现自动读取电子秤数据，自动计算统计收购数据。无论是收购入库和销售出库，都能轻松应对。

软件有两种授权方式，一是永久授权，二是按年授权。

核心功能

自动检斤收购

支持批量处理各类数据格式，自动识别并清洗数据，大幅减少人工操作时间，数据处理效率提升80%以上。

销售出库管理管理

自动分类整理文件，支持快速检索和预览，自定义标签和筛选条件，让文件管理更加有序。

数据查询导出电子表格

兼容主流文件格式，支持一键导出为Excel、PDF、Word等格式，满足不同场景的输出需求。

库存管理

内置多重加密机制，保护敏感数据安全，支持密码保护和权限管理，防止数据泄露。

自定义报表模板

提供丰富的预设模板，支持自定义模板创建和保存，满足个性化使用需求。

自动备份数据

支持定时自动备份数据，多设备同步功能，确保数据永不丢失，随时随地访问。

更新日志

版本：3.9.1 （2025-12-10）

1、新建“入库计算类”，把入库相关公式计算功能归集，便于统一处理和修改。

2、添加“价格表”功能，用于生成价格表。

3、修改入库报表，在报表尾部添加汇总数据，取消汇总报表。

版本：3.9.0 （2025-12-2）

1 、数据库品种表中增加场地扣量比设置（掺杂扣量），按“净重*场地扣量比”填写掺杂扣量编辑框。

2、收购数据表增加“粮食价款"字段，粮食价款=结算单价*结算数量，公式从结算公式中提前半部分。

3、修改结算单和收购报表，增加粮食价款项目。

版本：3.8.3 （2025-11-29）

1、姓名编辑框回车时不弹出售粮人列表框问题

2、获取新编号不正确的问题。

3、修改出库报表模块去掉了动态分组，直接按收货单位和品种分组统计数据，修改了报表模板。

功能截图

软件主界面 - 简洁直观的操作布局

系统设置

入库检斤

出口检斤

下载中心

当前版本：v3.9.1 | 更新时间：2025-12-11 | 软件大小：85MB

Windows 版本（稍后提供下载，敬请关注)

支持Win7/Win8/Win10/Win11 64位系统

下载安装包

常见问题

Q1：软件是否免费使用？

A：软件提供免费试用版。

Q2：安装软件需要什么配置？

A：Windows系统需要2GB以上内存，500MB以上硬盘空间。

Q3：数据是否会上传到服务器？

A：软件所有数据均保存在本地设备，不会上传到任何服务器，确保数据隐私安全。

Q4：如何获取软件更新？

A：定期访问本页面下载最新版本，更新不会丢失本地数据。

Q5：遇到使用问题如何解决？

A：可查看软件内置的帮助文档，或发送邮件至clxstlk@126.com获取技术支持，我们会在24小时内回复。

Delphi常用关键字用法详解

Thu, 24 Jul 2025 08:33:03 +0800

H-KING 于 2017-04-14 15:26:13 发布

absolute：

//它使得你能够创建一个新变量, 并且该变量的起始地址与另一个变量相同.  
var  
 Str: string[32];  
 StrLen: Byte absoluteStr;  
//这个声明指定了变量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用于输出对象, 它必须被用在接口和实现之间, 可以同时输出多个项, 项与项之间用逗号分开.  
libraryDemo;  
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的形式调用程序内的函数.它是向下兼容的.  
functionAdd(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 dosum := 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用于声明函数  
functionX(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); messageID_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用于声明过程  
procedureX(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 readfValue;  
//上例中即表明Value属性的值从fValue成员上读取.

readonly：

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

record：

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

register：

//Register标明了函数调用协定, 指出函数在被调用时可以在注册表内留下记录.它是向下兼容的.  
functionAdd(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 ofTCol;  
//操作时允许使用加减符号来添加或删除某个集合元素  
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 writefValue;  
//上例中即表明Value属性的值写入到fValue成员上.

writeonly：

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

xor：

pascal view plain copy //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}

lazarus 2.2.4/fpc 3.2.2修正说明

Mon, 12 Dec 2022 08:31:35 +0800

转自：https://www.cnblogs.com/qiufeng2014/p/16954691.html

lazarus 2.2.4/fpc 3.2.2修正说明

lazarus在实际使用中还存在一些问题,特别是在linux下lazarus代码编辑时不能输入中文/combobox/lazarus Object Inspector下拉时不显示文字/日期分隔符乱码(还会引起pas文件中的中文乱码等严重的问题),如果不对fpc/lazarus进行修复,会影响开发效率和使用,经以下修改后的lazarus已能比较顺利开发应用.

这个链接已包含以下修复内容，用解压后的文件替换原文件，重新编译fpc、lazarus就可以：https://pan.baidu.com/s/1oeozSMa3-WLZ_pM5haxc1w?pwd=rcfu
提取码：rcfu
一.修复lazarus中文输入

修改方法很简单，这4个文件开始位置添加：
lazarus/components/synedit/lazsyngtk2imm.pas
lazarus/lcl/interfaces/gtk2/gtk2globals.pp
lazarus/lcl/interfaces/gtk2/gtk2widgetset.inc
lazarus/lcl/interfaces/gtk2/gtk2proc.inc

{$ifdef linux}{$define WITH_GTK2_IM}{$endif}

lazarus/components/synedit/synedit.inc添加

{$ifdef linux}{$define Gtk2IME}{$endif}

二.FPC/lazrus支持中文变量/过程和函数

fpcsrc/compiler/scanner.pas
修改scanner.pas以下4个位置:
1、第4054行：

将'A'..'Z'：
修改为：'A'..'Z',#$80..#255 :

2、第4729行：

将

if c in ['A'..'Z','a'..'z','_'] then

改为：

if (c in ['A'..'Z','a'..'z','_',#$80..#255]) then

3、第4822行：
将

if not (c in ['_','A'..'Z','a'..'z']) thenmessage2(scan_f_syn_expected,tokeninfo^[_ID].str,c);

改为：

if not ((c in ['_','A'..'Z','a'..'z',#$80..#255])) thenmessage2(scan_f_syn_expected,tokeninfo^[_ID].str,c);

4、第5456行：

将

'a'..'z' :

改为：

'a'..'z' , #$80..#255:

修改后重新编译fpcsrc

修改lazarus\components\codetools\keywordfunclists.pas
将第852行：

IsIdentChar[c]:=c in ['a'..'z','A'..'Z','_','0'..'9'];

改为：

IsIdentChar[c]:=c in ['a'..'z','A'..'Z','_','0'..'9',#$80..#255];

重新编译lazarus

三.lazarus/lcl/interfaces/gtk2:
1.lazarus/lcl/interfaces/gtk2/gtk2widgetset.inc:
文件开始添加以下代码:

{$ifdef linux}{$define WITH_GTK2_IM}{$endif}

将第1386~-1393行注释

{ //2022.07.11 LBZ 防止打开frx报表设计器出错
else
if ALogLevel and G_LOG_LEVEL_CRITICAL <> 0
then begin
   Level := 'CRITICAL';
   Ex := EInterfaceCritical;
end}

2.lazarus/lcl/interfaces/gtk2/gtk2winapi.inc:

在第9601行添加:

gtk_widget_realize(PGtkWidget(GtkWindow));

在第9610行添加:

if Aflags and GDK_WINDOW_STATE_MAXIMIZED = 0 then//2022.10.18 LBZ

3.lazarus/lcl/interfaces/gtk2/gtk2wsforms.pp

在第409添加以下代码

case ACustomForm.WindowState of
  wsMaximized: gtk_window_maximize(PGtkWindow(P));
  wsMinimized: gtk_window_iconify(PGtkWindow(P));
  wsFullscreen: gtk_window_fullscreen(PGtkWindow(P));elseend;

4.lazarus/lcl/interfaces/gtk2/gtk2devicecontext.inc

在第736行添加:

Self.BkMode:=ASource.BkMode;//2022.12.05 LBZ

四.lazarus/lcl/include/

1.修复combobox类item列表背景颜色和文字颜色相同的问题
lazarus/lcl/include/customcombobox.inc
第113行加上以下5行:
//2022.05.28 LBZ 修复combobox类item列表背景颜色和文字颜色相同的问题

{$ifdef linux}// LCLgtk2}FCanvas.FillRect(ARect);{$endif}//2022.05.28 LBZ

五.修复linux lazarus Object Inspector下拉列表文字颜色和背景颜色相同导致不显示的问题(2022.12.06 已验证lazarus 2.2.4已修复此Bug,无需按以下方法修复)
修复lazarus在linux(ubuntu、银河麒麟等) Object Inspector下拉文字不显示的问题。
打开lazarus\components\ideintf\objectinspector.pp(3489行开始)，按红字的修改后重新编译lazarus就可以。
第3517行添加以下代码:

    {$ifdef windows}
      ValueComboBox.Canvas.Font.Color := clWindowText;    {$else}
      ValueComboBox.Canvas.Font.Color := clHighlightText;//2022.5.24 LBZ 字体颜色与背景颜色相同的Bug
    {$endif}

六.lazarus/components

1.汉化打印对话框
lazarus/components/printers/printer4lazstrconst.pas

{*****************************************************************************
This file is part of the Printer4Lazarus package

See the file COPYING.modifiedLGPL.txt, included in this distribution,
for details about the license.
*****************************************************************************

Abstract: Resourcestrings.}unit Printer4LazStrConst;{$mode objfpc}{$H+}interfaceresourcestringp4lrsCancel = '取消';
p4lrsPrinterProperties = '打印机属性';
p4lrsOk = '确定';
p4lrsGeneral = '常规';
p4lrsPaperSize = '纸张尺寸';
p4lrsPaperType = '纸张类型';
p4lrsPaperSource = '纸张来源';
p4lrsResolution = '分辨率';
p4lrsOrientation = '方向';
p4lrsPortrait = '纵向';
p4lrsLandscape = '横向';
p4lrsReverseLandscape = '横向反转';
p4lrsReversePortrait = '纵向反转';
p4lrsBanners = '横幅(Banners)';
p4lrsStart = '开始';
p4lrsEnd = '结束';
p4lrsPagesPerSheet = '每页页数';
p4lrsMargins = '边距';
p4lrsAdvanced = '高级';
p4lrsNoDefaultPrinter = '未找到默认打印机.';
p4lrsShortUnitsMm = '(mm)';
p4lrsShortUnitsInches = '(英寸)';
p4lrsButtonMoreArrow = '更多 >>';
p4lrsButtonLessArrow = '<< 较少';
p4lrsJobStateReady = '已准备好';
p4lrsJobStatePrinting = '打印';
p4lrsJobStateStopped = '停止';
p4lrsJobStateAccepting = '(接受作业)';
p4lrsJobStateRejecting = '(拒绝作业)';
p4lrsAllPages = '全部';
p4lrsPageOdd = '奇数';
p4lrsPageEven = '偶数';
p4lrsNotAvailable = '不可用';
p4lrsAbbrevUnitsMm = 'mm';
p4lrsAbbrevUnitsInches = '"';implementationend.

七.lazarus调整界面

1.lazarus/components/ide/projectwizarddlg.pas
2.lazarus/components/ide/projectinspector.pas

delphi单元文件

Thu, 10 Nov 2022 08:33:37 +0800

单元文件

转载“跟着老侯玩编程”

写完开篇之后考虑很久先写什么，Delphi是以单元（unit）作为它的程序组成，单元文件的后缀名为 .pas 想来想去还是从单元文件开始说起

我们在官方文档可以看到如下的描述

将大型程序划分为可以单独编辑的模块。
创建可以在程序之间共享的库。
在不提供源代码的情况下将库分发给其他开发人员。

一个完整的，可执行的Delphi应用程序由多个单元模块组成，所有这些模块都由一个称为项目文件的源代码模块捆绑在一起。项目文件的后缀名为 .dpr

官方文档：http://docwiki.embarcadero.com/RADStudio/Sydney/en/Programs_and_Units_(Delphi)

#结构和语法-.dpr

手动新建一个 VCL Application 通过下图的方式可以看到程序最开始的源码

其代码如下：

program Project1;uses
  Vcl.Forms,
  Unit1 in 'Unit1.pas' {Form1};{$R *.res}begin
  Application.Initialize;
  Application.MainFormOnTaskbar := True;
  Application.CreateForm(TForm1, Form1);
  Application.Run;end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

可执行的Delphi应用程序的源代码文件包含：

（1）program 声明：默认情况下采用的就是当前的项目名称

（2）uses 语句声明：use子句由关键字use组成，后跟一个逗号分隔的项目文件直接依赖的单位列表

（3）可执行语句块

begin
  .
  .
  .end.

1
2
3
4
5

其组成语句只是对项目的Application对象的方法调用。大多数项目都有一个全局Application变量，该变量包含Vcl.Forms.TApplication，Web.WebBroker.TWebApplication或Vcl.SvcMgr.TServiceApplication的实例（对象）。

该块还可以包含常量，类型，变量，过程和函数的声明；这些声明必须在块的语句部分之前。

注意，代表程序源结尾的结尾必须后面带有英文状态句号

通过上文可以看出，Delphi程序确实是通过 .dpr 文件进行组织，其中 .pas 即为创建程序时通过项目创建向导并自动引入。将来自己手动创建的普通单元文件如果想成功的使用依然需要在此处进行引入

#结构和语法-.pas

以这种后缀名结尾的文件即为普通的单元文件，这个也是使用频率最高的一种文件类型。

创建方式也很简单，可以通过IDE顶部菜单的**File-->New-->Unit **的方式创建，也可以通过下图的方式创建

一个单元由类型（包括类），常量，变量和例程（函数和过程）组成。

单元文件以 unit 开头，后跟interface关键字。在interface关键字之后，uses子句指定了单元依赖性列表。接下来是实现部分implementation，然后是可选的初始化initialization 和完成部分finalization 。单元源文件如下所示：

unit Unit1;interfaceuses // 依赖清单，或者称为引入的其他单元清单，一般引入系统单元
  // 声明部分implementationuses // 依赖清单，或者称为引入的其他单元清单。一般引入自定义单元，可避免互相引用// 类、方法、过程和函数的实现在这里...initialization//初始化部分// 程序启动时先执行,并顺序执行。一个单元的初始化代码运行之前,就运行了它使用的每一个单元的初始化部分finalization// 结束化部分,程序结束时执行end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#Interface

（1）接口部分声明常量、类型、变量、过程和函数,这些声明对引用单元就像自己的声明一样

（2）在接口部分声明的过程和函数,就像使用了forward关键字(一般称为前置声明)

（3）接口部分可以包含其自己的uses子句，该语句必须立即出现在关键字interface之后。

#Implementation

（1）如果包含uses字句,必须紧跟关键字implementation

（2）在这里实现interface中定义的过程和函数,可以任意顺序的定义和调用.

（3）可以定义单元私有的常量、类型(包括类)、变量、过程和函数,但这些对引用单元的客户是不可见的

#Initialization

Initialization是可选的。它从保留字初始化开始，一直持续到finalization 的开始，如果没有 finalization 部分，则一直持续到单元结束。 Initialization 部分包含在程序启动时按照它们出现的顺序执行的语句。

在其他单元中引用的话单元的初始化部分将按照其在uses语句中出现的顺序执行。

#Finalization

finalization部分是可选的，并且只能在具有Initialization部分的单元中使用。 finalization部分从保留字终结开始，一直持续到单元结束。它包含在主程序终止时执行的语句（除非使用Halt程序终止程序）。使用finalization部分释放在Initialization部分中分配的资源。

finalization部分的执行顺序与Initialization部分相反。例如，如果在应用程序以该顺序初始化单元A、B和C，它将以C、B和A的顺序完成它们的释放。

待办事项管理小工具

Tue, 25 Oct 2022 11:58:11 +0800

下载地址： todoList_1.0.zip

简单的待办事项管理，没有多余的功能，没有广告，绿色小巧。模仿了360桌面助手界面。

下载地址： todoList_1.0.zip

诊所处方系统

Tue, 25 Oct 2022 11:55:24 +0800

个体诊所适用的药品销售和处方系统。

粮食收购系统操作说明

Mon, 24 Oct 2022 15:56:35 +0800

下载地址（v3.0.6）：

本地下载

一、概述

本系统主要针对中小型粮食收购企业
1.自动读取电子秤，秤重数据自动进入计算机，防止人为更改称重数量。
2.计算，可根据设置的单价，扣量，扣价等自动计算金额。
3.统计，可生成日报表，汇总报表，方便掌握收购进度。

二、入库收购

一般的收购流程

检质：化验员对入库粮进行检质并开出检质证（检质证的编号不可重复）。
检毛重：对入库粮车进行毛重检斤，电脑录入相关数据。
3.粮车进入场地卸粮，监卸员的检质证上填写掺杂扣量。
4.检皮重：根据检质证号在电脑上调出毛检数据，对卸完粮的车进行皮重检斤。
5.结算：电脑打印出结算单，售粮人结算卖粮款。
当日收购结束后，可打印报表。
**一个收购期结束后，可导出收购数据到历史数据文件中。

基础数据设置

点击“参数设置”，在弹出的窗口中对参数进行设置。
一、常规
1：单位名称
填写本单位名称。
2：单位编号
暂时不用，为网络版预留。
3：设置电子秤参数
根据实际情况设置。

二、地址信息

此处设置常用的地址名称，以方便毛重检斤时录入乡村屯数据。

三、车种

此处设置售粮人常用车种，以方便毛重检斤时录入。

四、参数名

此处设置粮食品种在检斤计算时可能用到的相关参数。常见参数系统已经设置完成，一般不用设置，如有需要请联系程序开发者。

五、品种

设置将要收购的粮食品种，可多个品种同时收购。

在“使用”栏标记对号的品种，将出现在检斤时的品种选择列表中。

第一步：添加品种

点击“添加”按钮** **增加收购品种。

1、编号：系统自动产生，一般不用修改。
2、品名：品种名称。
3、定价方式：手工定价和公式定价
手工定价是的粮食价格的检斤时，手工输入。一般是的化验员验质后确定一个结算价格，这是最灵活最简单的收购方式。
公式定价是根据一些固定规则，通过计算最终确定结算价格的方式。比如国家每年出台的粮食收购计价标准。具体公式设置的“编辑计算公式”中说明。
4、票据：粮食收购结算单的格式。详见票据格式
5、等级单价设置：如果定价方式是“公式定价”，此处的标准单价将公式计算结算单价的基础单价，既粮食的标准水分的各个等级单价，比如玉米在2等，水分14%时，标准单价2.04元/公斤。如果定价方式是“手工定价”，此处无意义。
6、打印机：暂未使用，不用设置。
7、扦样加量：暂未使用，不用设置。
8、启用此品种：勾选此项，则在检斤时，可以收购此品种，否则在检斤时此品种不可见。
点击保存后生效。

第二步：选择参数

选中一个品种，点击“选择参数”，设置此品种的收购时要用到的参数。

参数分两种：输入型参数和计算型参数，输入型参数是指参数值在检斤时直接输参数值；计算型参数是指参数值需要通过公式计算而来，具体公式的“编辑计算公式”中指定。

添加输入型参数:在左侧的”可选参数”中选定一个参数,点击”添加”按钮,如果是输入型参数,就会弹出如下窗口:

1、是否验证输入有效性：勾选此项，则根据下面的最大值和最小值对输入的参数值进行检验，如果输入的值小于最小值或大于最大值，检斤数据不能保存并给出提示。
2、长度：指参数值的最大位数。比如等级一般是1位，水分一般是4位，位数的计算包含小数点。
3、默认值：检斤时没有输入参数值时，默认给出的参数值。
添加计算型参数：在左侧的”可选参数”中选定一个参数,点击”添加”按钮,如果是计算型参数，不会弹出任何窗口，参数名会直接出现在右侧的已选参数中。

第三步：编辑计算公式
选中一个品种，点击“编辑计算公式”，设置此品种的结算金额的计算公式。

1、可引用的数据
公式的计算会用到一些数据,比如一车粮的等级,水分,杂质等,在公式中我们用”[ ]”扩起来的参数名标示,例如公式:水分扣量=([水分]-14)/0.5*0.65/100*[净重] ,计算时会用这车粮的实际水分净重替换公式中的 [水分] [净重],如果粮食的水分时25%,净重5300公斤,替换后就变成:水分扣量=(25-14)/0.5*0.65/100*5300 ,计算后水分扣量是757.9公斤,由于公式的保留小数位数设置的是0，所以最后结果数758公斤。

可引用的数据必须是前面参数选择中已经选择的参数。另外，系统还有几个内部参数可引用
[净重]——-毛重－皮重
[扣后净重]————净重－所有扣量相加的和
[标准单价]————品种设置中的给出的标准单价
[结算单价]————标准单价－所有扣价相加的和
[扣款]—————-所有扣款相加的和
2、公式设置的例子：
A：水分增量
要求: 标准水分14%，每低0.5个百分点增量0.75%，但低于标准规定指标2.5个百分点及以上时，不再增量。
公式: 水分扣量=([水分]-14)/0.5*0.75/100*[净重]
约束: 当水分大于等于11.5 小于等于 14 时公式有效
保留小数位数: 0
B：水分扣量、扣价
要求：标准水分14%，每高0.5个百分点扣量0.65%，并扣价0.15%作为烘干费。
扣量公式：水分扣量=([水分]-14)/0.5*0.65/100*[净重]
约束: 当水分大于等于14 小于等于 35 时公式有效
保留小数位数: 0
扣价公式：水分扣价=([水分]-14)/0.5*0.15/100*[标准单价]
约束: 当水分大于等于14 小于等于 35时公式有效
保留小数位数: 3
其他扣量：如杂质扣量，不完善粒扣量的公式设置参照水分扣量公式设置。

扣款设置：
例如：卸车费= [净重]/1000*2 （每吨2元）
默认不会在结算金额的计算时减去扣款，如果想在计算金额时减去扣款，请设置金额的公式，如：结算金额=[结算单价]*[扣后净重]－[扣款]
金额设置：

此处设置结算金额的计算公式，必须设置。

有3个可选项,第一第二是比较常用的公式,第三个选项是有特殊要求,需要自定义公式时用（如：结算金额=[结算单价]*[扣后净重]－[扣款] ）
选择一个选项,点”确定”即可.
收购前注意事项
一、设置基础数据
如前所述。
二、清除无用数据
收购前，应该清除以前的无用数据。
点击“数据维护”

1、数据转历史
将现在的收购数据转存到历史数据文件中，并自动清除数据库中的收购数据。每个收购期结束后，新的收购期开始前使用此功能。

历史数据将会以品种名称开头+当前日期作为文件名保存，如：玉米2014_11_3.mdb，要查看历史数据，使用“历史数据查看器”查看。

2、收购数据清空
此功能将清除数据，不保存。一般是测试系统后，使用此功能，以便清除测试数据。
3、数据库备份
此操作将数据库文件备份到指定目录下，以防意外。名称为”sg”加备份日期.
4、数据库恢复

备份恢复，覆盖当前数据。
开始收购检斤

点击“入库检斤”,打开入库检斤窗口：

每项输入完成后，回车即可自动跳到下一项。

1、检质证号

此项为必须输入，并且检质证号不能重复。我们以检质证号唯一确定售粮车。

系统根据检质证号自动判断毛重检斤和皮重检斤，在光标进入毛重或皮重项时，系统将读取电子称的数据，并等待检斤员确认。如有特殊情况需要人工输入重量时，请点击“手工方式”，

此时在光标进入毛重或皮重项时，会出现重量输入框。在打印结算单时，结算单上会打印手工票据的字样。

2、输入检质证号并按回车键

A：如果是毛重检斤，则弹出品种选择框

用上下光标键，选择品种，回车

下面有哪些项可输入数据，就是在参数选择时已选了哪些参数。

B：如果是皮重检斤，则弹出电子称的数据，并等待检斤员确认。

确认后光标进入“掺杂扣量”项，此处输入监卸员签的扣量数，净重=毛重-皮重-掺杂扣量

单价项，如果品种定价方法是公式定价，此处不能修改，如果是手工定价，此处输入单价。

票据的修改和删除

输入要修改或要删除的检质证号，回车或点击“搜索”,将调出此车的数据。

要删除票据，直接点“删除“按钮。

要修改票据，直接修改错误项目后，点击“重新计算”，再点“保存”。

毛重、皮重不能修改。该品种如果是手工定价，则单价可修改，否则单价不能修改。

如一定要修改这些项目，请删除此票据，重新用手工方式入库检斤（和正常入库检斤一样，也要毛检一次、皮检一次）

<div id="winchm_template_content">收购报表

报表分为当日报表和汇总报表两种：

1-单日报表：统计当天（可以用日期框指定统计哪一天）收购数量、金额、票据张数等信息。

2-汇总报表：统计从收购开始截止到当天（可以用日期框指定统计截止到哪一天）的收购信息。

点击打印可以打印报表（默认A4纸，注意更换打印机的纸张）。

</div>
二、销售出库

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

1、出库设置

只有一项：出库单的样式选择，具体样式详见票据格式。

2、往来客户

界面：

对有业务往来的客户进行管理。（这不是必须的，可以不设置）

3、出库计划

界面：

1、建议发货前，编制此出库计划，出库检斤时会方便很多。

2、拖到底部的滚动条，会显示每个计划的完成数量。

3、运费计算公式可用参数：[净重]、[运价率]、[运输里程]。

4、运输单位

界面：

设置运输单位和车辆信息，方便出库检斤的操作。

5、出库检斤

界面：

1、车号

如果在运输单位中设置了车辆信息，输入车号时会弹出车号选择框快速输入车号。比如在车号中输入一个5，会列出所有包含5的车号

按向下光标键选择车号，回车键输入完成。

程序根据输入的车号，自动取得承运单位、车型、司机姓名、司机电话信息（如果你在运输单位里设置了这些信息）。

程序会自动判断此车号是毛重检斤还是皮重检斤。

2、计划号

像输入车号一样，只要输入计划号中的一部分数字就会弹出计划列表，方便快速输入。

计划号输入完成后，程序自动取相关信息（如果你在出库计划中设置了这些信息）。

3、出货仓位是装车的货位号，便于统计某个货位发出了多少。可以不填。

6、出库单的修改和删除

界面：

修改车号和计划号时，需要输入完整的车号或计划号，然后点击后面的取得信息按钮，才能取出相关信息。

出库的修改和手工检斤，不会在出库单上打印标记。可以在程序中查询那些票据修改了，那些票据是手工检斤。

7、出库查询

###

界面：

1、筛选“手工检斤”的出库单

打开筛选列表，选择手工检斤，点击过滤查询。

2、筛选修改过的出库单

同上，选择已修改，点击过滤查询。

选择一条记录，双击或点击详细信息按钮。会现行出此记录的详细信息和修改记录。

对比当前的详细信息和修改记录，可以知道每次都修改了哪些数据。

3、显示设置

点击显示设置按钮，可以选择查询中显示或隐藏那些列。

8、出库报表

三、单据样例

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

1、结算单-窄票据

纸张：3等分（241mm*94mm）

2、结算单-2等分

纸张：2等分（241mm*140mm）

3、出库单-3等分

4、出库单-2等分

四、下载地址（v3.0.6）：

本地下载

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

注意：软件是个人开发，杀毒软件会报毒，请自行添加到杀软的信任列表中。

欢迎到来

Mon, 24 Oct 2022 15:51:24 +0800

祝您使用愉快！