ExtJS

ExtJS中Store与TreeStore

ExtJS中将后台数据交由前端显示的一般过程为：将数据库中数据通过交互文件和AJAX技术传到前端，根据前端定义的相应的model，将数据加载到相应的store中，将创建的store赋给相应的前端组件即可显示。采取这样的方式，就避免了原生JavaScript等要先将json数据解析，再分析数据，然后根据结果进行显示的耦合性比较高的问题。

Model与TreeModel

Model类型指定了解析json等数据的格式。store可以根据model直接将json等数据解析为model定义的格式。

1
2
3
4
5
6
7
8
9
Ext.define('treeModel', { //定义Model类
    extend: 'Ext.data.Model', //从Ext.data.Model扩展，此外还有treeModel
    fields: [ //其域的名称以及类型要和传递的json数据的格式对应
        { name: 'id', type: 'string' }, 
        { name: 'text', type: 'string' }, //还可以定义默认值等属性
        { name:'name',type:'string'}

    ]
});

TreeStore

本文以TreeStore为例分析，此外还有JsonPStore、JsonStore、XmlStore等store类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//1.创建store
var treeStore = Ext.create('Ext.data.TreeStore', { 
    model: 'treeModel', //按照treeModel格式解析
    proxy: {
        type: 'ajax',
        url: '..', //指向请求的相应的处理文件的位置。可以通过更改url，使store加载不同的值
        reader: { //定义reader，即对数据进行解码的方式。可采用默认值
            type: 'json'
        }
    }
});

//2.给相应的组件赋值
Ext.create("Ext.tree.Panel",{
		//其他属性
		store:treeStore //将store赋给某个组件的store
	}); 

//3.加载数据及重加载数据
treeStore.load(); //加载，将数据加载到treeStore中。执行这个方法后，控件就会显示数据

treeStore.reload(); //再次加载。当数据更新后，调用此方法重新加载以显示新数据。
ExtJS

ExtJS定义类

在ExtJS中，用户可以使用Ext.define自定义类或进行重载。此处将对其使用方法以及实现原理进行剖析。

定义一个类

定义一个新的基本类

1
2
3
4
5
6
7
8
9
10
11
12
13
Ext.define('My.awesome.Class', {
    someProperty: 'something',

    someMethod: function(s) {
        alert(s + this.someProperty);
    }

    ...
});

var obj = new My.awesome.Class();

obj.someMethod('Say '); // alerts 'Say something'

创建一个匿名类

1
2
3
4
5
Ext.define(null, {
  constructor: function () {
    // ...
  }
});

创建一个包含私有类型的嵌套域

1
2
3
4
5
6
7
8
9
10
11
12
13
Ext.define('MyApp.foo.Bar', function () {
    var id = 0;

    return {
        nextId: function () {
            return ++id;
        }
    };
});

var bar=Ext.create('MyApp.foo.Bar');
alert(bar.nextId()); //1
alert(bar.nextId()); //2

Ext实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
define: function (className, data, createdFn) {
            //如果是重载，则应用Manager.createOverride方法，否则应用Manager.create
            if (data.override) {
                return Manager.createOverride.apply(Manager, arguments);
            }

            return Manager.create.apply(Manager, arguments);
        },

//创建一个新的类
create: function(className, data, createdFn) {
			
            var ctor = makeCtor();//建立构造器
            if (typeof data == 'function') {
                data = data(ctor);
            }

            data.$className = className; //更改类名

            //返回创建好的类，创建类的过程中，不仅要将自定义的类的属性和方法添加到类中，
            //还需要将ext基本类的属性和方法添加到新建的类中。
            return new Class(ctor, data, function() {//……});

Ext.Class = ExtClass = function(Class, data, onCreated) {
        if (typeof Class != 'function') {
            onCreated = data;
            data = Class;
            Class = null;
        }

        if (!data) {
            data = {};
        }

        Class = ExtClass.create(Class, data); //先创建基于ExtClass的类的实例，添加应有的属性和方法

        ExtClass.process(Class, data, onCreated); //将添加的属性和方法放至正确的位置

        return Class; //返回创建好的类
    };

重载类

定义基于EXT组件的重载

1
2
3
4
5
6
7
8
9
10
Ext.define('MyApp.override.BaseOverride', function () {
    var counter = 0;

    return {
        override: 'Ext.Component',
        logId: function () {
            console.log(++counter, this.id);
        }
    };
}());

分解类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// File: /src/app/Panel.js

 Ext.define('My.app.Panel', {
     extend: 'Ext.panel.Panel',
     requires: [
         'My.app.PanelPart2',
         'My.app.PanelPart3'
     ]

     constructor: function (config) {
         this.callParent(arguments); // calls Ext.panel.Panel's constructor
         //...
     },

     statics: {
         method: function () {
             return 'abc';
         }
     }
 });

 // File: /src/app/PanelPart2.js
 Ext.define('My.app.PanelPart2', {
     override: 'My.app.Panel',

     constructor: function (config) {
         this.callParent(arguments); // calls My.app.Panel's constructor
         //...
     }
 });

Ext重载类的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
createOverride: function (className, data, createdFn) {
            var me = this,
                overriddenClassName = data.override,
                requires = data.requires,
                uses = data.uses,
                compat = data.compatibility,
                classReady = function () {
                    var cls, temp;

               		//requires加载需要的类时机是：当前类初始化之前被加载。
                    if (requires) {
                        temp = requires;
                        requires = null; 

                        Ext.Loader.require(temp, classReady);
                    } else {
                        cls = me.get(overriddenClassName);

                        delete data.override;
                        delete data.compatibility;
                        delete data.requires;
                        delete data.uses;

                        Ext.override(cls, data);

                        me.triggerCreated(className);

						//uses记载需要的类的时机是，当前类初始化之后被加载。
                        if (uses) {
                            Ext.Loader.addUsedClasses(uses); 
                        }

                        if (createdFn) {
                            createdFn.call(cls); 
                        }
                    }
                };

            me.existCache[className] = true;

            if (!compat || Ext.checkVersion(compat)) {
                
                me.onCreated(classReady, me, overriddenClassName);
            }

            return me;
        },
计算机基础

数据库概论

数据模型

数据模型是对现实世界数据特征的抽象，也就是说数据模型是用来描述数据、组织数据和对数据进行操作的。现有的数据库系统均是基于某种数据模型的。

根据模型应用的不同目的，数据模型分为两类：概念模型、逻辑模型和物理模型。概念模型是按用户的观点来对数据和信息建模，主要用于数据库设计。第二类逻辑模型主要包括关系模型、层次模型、网状模型、层次模型、面向对象数据模型和对象关系模型、半结构化模型等。其中关系模型是最重要的一种数据模型。

从数据库应用开发人员角度看，数据库系统通常采用三级模式结构（外模式、模式、内模式）。从最终用户角度看，数据库系统的结构分为单用户结构、主从式结构、分布式结构、客户-服务器、浏览器-应用服务器/数据库服务器多层结构等。这是数据库外部的体系结构。

常用数据库以及模型

  • MySQL 小型关系型数据库管理系统，适用于中小型网站
  • Oracle 一种大型关系数据库系统，一般用于商业、政府机关等。能处理大批量的数据。
  • SQL Server 关系数据库管理系统。有微软和Sybase两家
  • DB2 IBM的一系列关系型数据库管理系统，主要应用于大型应用系统。对大型分布式应用系统尤为适用。
  • Informix IBM出品的关系数据库管理系统家族。
  • Sybase 关系型数据库，是一种典型的UNIX或WindowsNT平台上客户机/服务器环境下的代行数据库系统。
  • PostgreSQL 一种特性非常齐全的自由软件的对象-关系型数据库。
  • MongoDB 跨平台、高性能、开源、无模式的文档型数据库。
  • NoSQL 泛指非关系型数据库，如Redis、HBase、MongoDB、CouchDB等。

关系数据库

关系模型的数据结构非常简单，只包含单一的数据结构——关系。关系的每一个分类必须是一个不可分的数据项，即不允许表中有表，一列只能有一个head。行和列的顺序无所谓，可以任意交换。

一些概念

R(D1，D2，……Dn)

  • R表示关系的名字，n是关系的目或度（degree），即列长度
  • 表的每行对应一个元组，表的每列对应一个域。
  • 候选码：若关系中的某一属性组可以唯一表示一个元祖而其子集不能，则称该属性组为候选码。
  • 主码/主键（Primary Key）：选定一个候选码作为唯一标识。

关系数据库标准语言SQL

结构化查询语言是关系数据库的标准语言，也是一个通用的、功能极强的关系数据库语言，可以实现数据库模式创建、数据库数据的增删改查、数据库安全性完整性定义与控制等一系列功能。

数据定义

操作对象 创建 删除 修改
模式 CREATE SCHEMA DROP SCHEMA
表 CREATE TABLE DROP TABLE ALTER TABLE
视图 CREATE VIEW DROP VIEW
索引 CREATE INDEX DROP INDEX ALTER INDEX

一个关系数据库管理系统的实例中可以创建多个数据库，一个数据库中可以建立多个模式，一个模式下通常包含多个表、视图和索引等数据库对象。当表的数据量比较大时，查询操作会比较耗时，建立索引是加快查询速度的有效手段。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
CREATE SCHEMA <模式名> AUTHORIZATION <用户名> //也可以在后面继续创建表、视图等
CREATE SCHEMA TEST AUTHORIZATION ZHANG //为用户ZHANG创建一个模式TEST

DROP SCHEMA <模式名> <CASCADE|RESTRICT> //删除模式，cascade表示删除模式下所有数据库对象，restrict表示如果存在下属数据库，则不执行

CREATE TABLE <表名> (<列名><数据类型>[列级完整性约束条件下]) //如设置主码等
CREATE TABLE StudentCourse (
	Sno CHAR(9),  //也可以在其后面直接加PRIMARY KEY，表示其为主键。这样称为列级完整性
	Cpo CHAR(4),
	Grade SMALLINT,
	PRIMARY KEY(Sno,Cno), //主码由两个属性构成，必须作为表级完整性进行定义
	FOREING KEY (Sno) REFERENCES Student(Sno), //表级完整性定义，Sno是外码，被参照表示Student
	FOREING KEY (Cno) REFERENCES Course(Cno),  //表级完整性定义，Cno是外码，被参照表示Course
	)

ALTER TABLE <>
[ADD <新列名> <数据类型> [完整性约束]] //ALTER TABLE Student ADD S_entrance DATE;
[DROP <列名> [CASCADE|RESTRICT]]
[ALTER COLUMN <列名> <数据类型>]

DROP TABLE <表名> [CASCADE|RESTRICT]; //删除基本表

数据查询与操作SQL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//表的查询
SELECT [ALL|DISTINCT] <目标列表达式> [,<目标列表达式>]…… //指明选择要获取的列
FROM <表名或视图名> [,<表名或视图名>……]   //指明从什么表格里面取，可以多个表格
[WHERE <条件表达式>]   //Sage<20，指明条件
[GROUP BY <列名1> [HAVING <条件表达式>]] 
[ORDER By <列名2> [ASC|DESC]];  //按某列排序，ASC表示升序，DESC表示降序

SELECT Student.Sno,Sname //*表示全部取出来
FROM Student,SC,Course
WHERE Student.Sno=SC.Sno AND
	  SC.Cno=Course.Cno AND
	  Course.Cname='信息系统'
ORDER BY Sno ASC;

//插入新项
INSERT INTO <表名> [(<属性列1>[,<属性列2>]……)]
VALUES (<常量1>[,<常量2>]……);

INSERT INTO Student(Sno,Sname) //如果新元组与属性列一一对应，则可以省略属性
VALUES('20121515','黎明'); 

//更新表格内容
UPDATE <表名>
SET <列名>=<表达式> [,<列名>=<表达式>]
[WHERE <条件>];

UPDATE Student
SET Sage=22
WHERE Sno='20121515';

//删除数据
DELETE FROM <表名>
[WHERE <条件>]

DELETE FROM Student
WHERE Sno='20121515'
计算机基础

编译原理

编译程序

从功能上看，一个编译程序就是一个语言翻译程序。语言翻译程序把一种语言（源语言）书写的程序翻译成另一种语言（目标语言）的等价程序。典型的高级语言程序的处理过程为：将预处理的源程序进行预处理得到源程序；将源程序进行编译，获得目标汇编语言程序；将目标汇编语言程序进行汇编，得到可再装配的机器代码；将可再装配的机器代码进行装配/连接编译程序，加上可再装配目标文件，得到绝对机器代码。

编译程序完成从源程序到目标程序的翻译工作，按过程可以分为：词法分析、语法分析、语义分析、中间代码生成、代码优化和目标代码生成6个阶段。这只是典型的编译过程，有的编译程序没有代码优化等过程。

运行时存储组织

通常，在有操作系统的情况下，目标程序将在自己的逻辑地址空间内存储和运行。编译程序所产生的目标程序的大小通常是确定的，一般存放在指定的专用存储区域，即代码区。相应的，目标程序运行过程中需要创建或访问的数据对象将存放在数据区。

程序运行时存储空间的布局

一般来说，程序运行时的存储空间从逻辑上可分为“代码区”和“数据区”，但为了方便存储组织和管理，往往需要将存储空间划分为更多的逻辑区域。具体的划分方法会依赖于目标机体系结构，但一般情况下至少含有保留地址区、代码区、静态数据区及动态数据区等逻辑区域。

  • 保留地址去。专门为目标机体系结构和操作系统保留的内存地址区。通常，该区域不允许普通的用户程序存取，只允许操作系统的某些特权操作进行读写。
  • 代码区。静态存放编译程序产生的目标代码。
  • 静态数据区。存放全局数据，是普通程序可读可写的区域。存放程序中用到的所有常量和数据对象，以及各类全局变量和静态变量所对应的数据对象。
  • 动态数据区。运行时动态变化的堆区和栈区。
  • 共享库和分别编译模块区。静态存放共享库模块和分别编译模块的代码和全局数据。

存储分配策略

数据区分为静态数据区和动态数据区（堆区、栈区），分别对应了3种规则：静态存储分配、栈式存储分配和堆式存储分配。

  • 静态存储分配，即在编译期间为数据对象分配存储空间。要求在编译期间就可以确定数据对象的大小，同时还可以确定数据对象的数目。如可全程访问的全局变量、静态变量、程序中的常量以及class的虚函数表等。
  • 栈式存储分配，将数据对象的运行时存储按照栈的方式来管理。栈式存储分配是动态的，也就说必须是运行的时候才能确定数据对象的分配结果。运行时每当进入一个过程/函数，就在栈顶为该过程/函数分配存放活动记录的数据空间，当一个过程/函数工作完毕返回时，它在栈顶的活动记录数据空间也随即释放。在编译过程中，过程、函数以及嵌套程序块的活动记录大小（最小值）应该是可以确定的，这是进行栈式存储分配的必要条件，如果不满足应该使用堆式存储管理。
  • 堆式存储分配，当数据对象的生产期与创建它的过程/函数的执行期无关时，例如某些数据对象可能在该过程/函数结束之后仍然长期存在，就不适合使用栈式存储分配。堆式存储分配和释放数据对象的操作是应用程序通过向操作系统提出申请实现的，因此要占用相当的时间。堆式存储空间的释放分为：不释放、显示释放（如malloc和free、new和delete）、隐式释放（垃圾回收）。

面向对象语言存储分配策略

面向对象语言中，与存储组织关系密切的概念是类和对象。类扮演的角色是程序的静态定义，对象扮演的角色是程序运行时的动态结构。

  • 类是一组运行时对象的共同性质的静态描述，包含变量和方法。存储在静态存储区。
  • 对象时类的一个实例，在堆区为对象申请空间并创建对象，同时在栈区保存引用对象的存储单元。在堆区的对象包含局部变量，但并不包含方法，而是有一个指向该方法的引用。
C/C++

C++

C++程序范例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<iostream> //格式化输入输出。 也可以使用C的库#include<cstdio>
#include<string>
//using std::cout //命名空间，可以使下面的std::cout简写为cout
//using std::string //可以使std::string简写为string 

int main()
{
	std:cout << "enter two numbers:" << std::end1; //cout处理输出，读see-out。end1具有输出换行的效果，并刷新与设备相关联的缓冲区。
	int v1,v2;
	std::cin >> v1 >> v2; //cin处理输入，读see-in
	std::cout << "the sum of" << v1 << "and" << v2
			  << "is" << v1+v2 << std:end1;

	return 0; //返回0表示成功执行
}

指针及取址等

1
2
3
4
const int ival = 1024; //const 表示定义常量。类似c中的define
const int &refVal = ival; //构造一个引用指向ival，两者指向同一内容

int *pi=0； //指针初始化

内存管理和分配

1
2
3
4
string *sp = new String("string");
delete sp; //new delete配合使用

//malloc和free配合使用
C/C++

c语言编程

头文件

1
2
3
4
5
#include<stdio.h>  //普遍需要的，支持scanf、printf等
#include<string.h>  //说明一些字符串串和内存操作函数
#include<graphics.h>  //画图
#include<alloc.h>  //说明内存管理函数
#include<io.h>  //包含低级I/O子程序的结构和说明

函数定义以及调用等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void main() //主函数，入口函数
{
	int x,y;
	scanf("%d%d",&x,&y);
	printf("%d\n",comp(x,y));
}

int comp(int x,int y) //必须指明形参类型，并且要匹配
{
	if(x > y)
		return 1;
	else if(x < y)
		return -1
	else
		return 0;
}

变量的定义及初始化

1
2
3
4
5
6
7
8
9
10
11
//也可以在子函数中定义，但是要注意在前面定义
double dx,sy;
int a=5; 
char c='a';

char string[20]={'s','t','r','i','n','g','\0'};
char str[20] = "string"; //c有没有string类型。str第七位为'\0'
char str[3][10]={"string","is","it"}; //多个字符串

int a[3][3]={{1,2,3},{1,2,3},{1,2,3}};  //二维数组方式1
int a[3][3]={1,2,3,4,5,6,7,8,9};   //二维数组，方式2

输入输出函数

1
2
3
4
5
6
7
8
scanf("%c%3d",&x,&y); //%f浮点小数，%c字符，%s字符串。%3d表示3位整数
printf("%c asicii is %d",x,x);  //输出，可以类型转换

c=getchar(); //输入字符
putchar(c); //

gets(str); //输入字符串，并给str
puts(str); //显示字符串

常用函数以及方法

1
2
3
4
5
6
if(str[0]>='a'){} //字符比较，也可以用来检测数字还是其他

strcpy(str1,str2); //不可以用=直接赋值。将字符串2赋值给字符串1，不只是给指针
strcat(str1,str2); //将str2加到str1后面
strcmp(str1,str2); //比较，str1大于str2则返回正整数
strlen(str1); //获得字符串str1的长度，不算'\0'
计算机基础

计算机组成原理及操作系统

数据表示方式

数据在计算机中以0 1表示，计算机领域中使用二进制、八进制、十进制和十六进制表示，常用的二进制编码有

8421BCD编码

0000表示数字0，1001分别表示数字9,0001 0101表示十进制15

ASCII码

0~9:0011 0000(48) ~ 0011 1001 (57)
A~Z:0100 0001(65) ~ 0101 1010 (90)
a~z:0110 0001(97) ~ 0111 1010 (122)

格雷码

0~15:
0000 0001 0011 0010
0110 0111 0101 0100
1100 1101 1111 1110
1111 1110 1010 1000

某二进制数为Bn-1 Bn-2 ……B0，其对应的格雷码为Gn-1 Gn-2 …… G0
则：Gn-1=Bn-1 其他 Gi=Bi+1异或Bi

机器码

  • 原码：第一位0，表示正，第一位1表示负，其他位不变
  • 补码：正数不变，负数为2的n+1加上x
  • 反码：正数不变，负数则符号位不变，其他相反。
  • 正数的原码、反码、补码都一样
  • 负数符号位固定为1.原码其他位求反得反码，反码最低位加1得补码。

汉字表示方式

  • 汉字输入编码：数字编码（用数字串代表一个汉字输入） 拼音码（用拼音代码汉字，但重码率高，还要进行同音字选择） 字形编码（比如五笔）
  • 汉字内码：是用于汉字信息的存储、交换、检索扥各操作的机内代码，一般采用两个字节表示，类似七位ASCII码，但最高位为1
  • 汉字字模码：用点阵表示的汉字字形代码。

内部存储器

主存储器和中央处理器一样是计算机系统的重要资源，它为操作系统、各种系统程序和用户程序所共享。现代操作系统区分两类主存：物理主存和逻辑主存。主存中分片的方式分为两种：

  • 划分为大小不等的区域，这些区域根据用户程序实际需要而被分割。
  • 划分为大小相等的块，以快为单位进行分配，操作系统和用户程序根据需要占用若干主存块。

主存管理的功能

  • 为了支持多道程序运行，每个应用程序必须为每个用户提供0~n-1的一组逻辑地址。程序执行时，必须将逻辑地址正确地转换为物理地址，此即为地址映射。
计算机基础

operating-system

操作系统的类型和结构

操作系统是计算机系统中的核心系统软件，负责管理和控制计算机中硬件和软件资源 ，合理地组织计算机工作流程和有效地利用资源，在计算机和用户之间起接口的作用。操作系统具有5个基本功能：处理机管理、存储管理、设备管理、文件管理和作业管理。

操作系统的类型

现代操作系统大多拥有两种工作状态：核心态和用户态，我们使用的一般程序工作在用户态，而内核模块和最基本的操作系统核心工作在核心态。根据使用环境和对作业的处理方式，操作系统分为：

  • 批处理操作系统：把用户提交的作业分类，把一批中的作业编成一个作业执行序列。用户脱机使用计算机、成批处理、多道程序运行。
  • 分时操作系统：采用分时技术，使多个用户同时以会话方式控制自己程序的运行。交互性、多用户性、独立性。
  • 实时操作系统：系统与应用很难分离，常常紧密结合在一起。提供即时响应、高可靠性。
  • 网络操作系统：按照网络架构的各个协议标准进行开发，需要支持异种计算机系统之间进程通信的网络环境，以实现协同工作和应用集成。互操作性、协作处理。
  • 分布式操作系统：要求有一个统一的操作系统，实现系统操作的统一性，负责全系统的资源分配和调度，为用户提供统一的界面。它是一个逻辑上紧密耦合的系统。

操作系统的结构

  • 无序结构：又称整体结构或模块组合结构。它以大型表格和队列为中心，操作系统的各部分程序围绕着表格运行，整个系统是一个程序。
  • 层次结构：把一个大型复杂的操作系统分解成若干个单向依赖的层次，由多层的正确性保证操作系统的可靠性。
  • 面型对象结构：在计算机系统中对象时操作系统管理的信息和资源的抽象，是一种抽象的数据类型。如windows server中有执行对象（进程、线程、文件等）和内核对象（时钟、事件、信号等）。适用于网络操作系统和分布式操作系统中。
  • 对称多处理结构
  • 微内核结构：把系统的公共部分抽象出来，形成一个底层核心，提供最基本的服务，其他服务以服务器形式建立在微内核上。微内核结构十分适合嵌入式的专用系统。