您现在的位置：首页 > 实用文 > 其他范文

ActionScript数组使用小结

时间：2022-11-25 09:26:47 其他范文收藏本文下载本文

下面给大家分享ActionScript数组使用小结，本文共13篇，欢迎阅读!

ActionScript数组使用小结

篇1：ActionScript数组使用小结

数组

本文节选自本人最近在制作的AS2语法研究报告，供AS爱好者交流，学习，

ActionScript数组使用小结

。

哪里说得不对或不当，还请指正，谢谢.

数组：

AS2里的数组类型有两个比较牛的地方：

1)数组对象自身可以存放任何数据类型，而不是如C++中的int a[2],char a[3],someClass a[3].

当然，坏处也立刻突现了出来，无法直接创建对象数组。

2)完全的动态数组，使用非常简单，有点像Vector，但同时也更易用出错。这里的动态指的是数组边界的大小(当然，维数还是要声明好的)。

下面是关于数组类型的一些个人认为比较重要点的小结,一些旁枝性的东东都略去了，

哪里少讲了或讲错了什么的话请务必帮我指出一下，大家共同提高：

以下声明错误：

var a[1]:Array=new Array;

function test(arr[]:Array):Void

2声明方式1(注，这里的声明方式全部使用强类型声明方式)

var a:Array=new Array();

a[0]=0;

a[1]=1;

trace(a);

//Output

0,1

3声明方式2

var a:Array=new Array(4);

a[4]=1;

trace(a);

//Output

undefined,undefined,undefined,undefined,1

解释：动态数组，用a[4]后长度自动变成5。

4声明方式3

4.1

var b:Array=new Array(0,1,2,3);

trace(b);

0,1,2,3

4.2并不支持这种形式的二维数组的嵌套定义

var b:Array=new Array((1,2),(3,4),(5,6));

trace(b);

trace(b[0]+“ ”+b[1]+“ ”+b[2]+“ ”+b[3]);

trace(b[0][0]);

2,4,6

2 4 6 undefined

undefined

5用[]取代了C++中的{};

声明方式4

var b:Array=[[1,2],[3,4],[5,6]];

trace(b);

trace(b[0]+“ ”+b[1]+“ ”+b[2]+“ ”+b[3]);

trace(b[0][0]);

1,2,3,4,5,6

1,2 3,4 5,6 undefined//用b[0]输出了一个数组行.

6二维的维数设定同样是动态的：

var b:Array=[[1,2],[3,4],[5,6]];

b[2][3]=12;

trace(b[2][3]);

//Output

7其它的二维数组声明方式：

7.1通过行首参数设定相应的列数.

2*3 Array Declare.

var gRowIndex:Number=2;

var gColIndex:Number=3;

var a:Array=new Array(gRowIndex);

for (var i=0;i

{ a[i]=new Array(gColIndex);

for (var j=0;j

{

a[i][j]=String(i)+String(j);

}

trace(a);

//Output

00,01,02,10,11,12

8数组作函数为参数的传递.

8.1

var b:Array=new Array(0,1,2,3);

function test(arr:Array):Void

{

trace(arr[0]+“ ”+arr[1]+“ ”+arr[2]+“ ”+arr[3]+“ ”);

}

test(b);

0 1 2 3

8.2

二维数组：

var b:Array=[[1,2],[3,4],[5,6]];

function test(arr:Array):Void

{

trace(arr);

trace(arr[0]+“ ”+arr[1]+“ ”+arr[2]+“ ”+arr[3]+“ ”);

}

test(b);

1,2,3,4,5,6

1,2 3,4 5,6 undefined

8.3

行首参数的传递：

var b:Array=[[1,2],[3,4],[5,6]];

function test(arr:Array):Void

{

trace(arr);

trace(arr[0]+“ ”+arr[1]+“ ”);

}

test(b[0]);

test(b[1]);

test(b[2]);

1,2

1 2

3,4

3 4

5,6

5 6

9更多：

9.1

var gRowIndex:Number=2;

var gColIndex:Number=3;

var a:Array=[[0,1],[3,4,5]];//某个位置空缺某个元素，这里为[0][2]

trace(a);

for (var i=0;i

{

for (var j=0;j

{

trace(a[i][j]);

}

0,1,3,4,5

undefined

9.2动态维数并不支持

var b:Array=[5,6];

b[0][0]=3;

trace(b[0][0]);

//Output

undefined，

9.3一个间接对象数组实现的例子.

var enArray=new Array(3);

// ------ 连接到ENEMY数组 --------- //

for(var j=0;j<3;j++){

attachMovie(“baddie”, “baddie”+j, 200+j);

enArray[j] = _root[“baddie”+j];

enArray[j]._x = 50*j;

enArray[j]._y = 100;

}

9.4

还有很多实际中用得到的例子，比方说，用array 来保存颜色数据，加载图片的变量名等等。

10删除数组元素：

10.1一维：

var p=new Array(1,2,3,4,5);

p.splice(1);

trace(p);

var t=new Array(1,2,3,4,5);

t.splice(2,1);

trace(t);

//Output

1,2,4,5

10.2二维情况:

var b:Array=[[1,2],[3,4],[5,6]];

b[0].splice(0);//delete c[0][0] c[0][1]

trace(b);

var c:Array=[[1,2],[3,4],[5,6]];

c[1].splice(1);//c[1][1]

trace(c);

,3,4,5,6

1,2,3,5,6

11长度测试:

var b:Array=[[1,2,2],[3,4],[5,6,4,5]];

trace(b.length);

trace(b[0].length);

trace(b[2].length);

//Output

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

一个月后的补充：

11动态维数:跟JAVA中一样的.

var arr:Array=new Array(1);

arr[0]=new Array(3);

arr[0][0]=1;

arr[0][1]=2;

arr[0][2]=3;

trace(arr);

trace(arr[0][0]);

trace(arr[0][1]);

trace(arr[0][2]);

1,2,3

12加载数据的新方式(多重属性):

mData=new Array();

mData.addItem({ label: “二球动量守恒(一维)” ,data:0});

mData.addItem({ label: “三球动量守恒(一维)” ,data:1});

mData.addItem({ label: “多球平面碰撞(二维)”,data:2});

mData.addItem({ label: “子母球”,data:3});

用于配合V2Component中的ComboBox的使用:

_root.menuCombo.dataProvider=mData;

篇2：Actionscript中的数组

数组

难度:中级

软件环境:Flash 5

如果你对数组感性趣的话，那么你也一定了解变量吧，变量是装着数据的容器，数据可以是数字、字符串或者是个布尔值。

数组与变量相似同样是做为数据的容器，但它还能包含更多的数据，每一个元素（数据中的一部分）都被附于一个索引。

数组可以用来保存你的脚本和组织结构，它们通常用来去组织一些在某些方面有些关联的数值，这些数值采用一个索引值

与数组中其它的元素区分开来。你可以用下面这个方法去定义 3个变量：:

quote1=“Flash is cool!”

quote2=“Flash is my favourite program”

quote3=“Flash rules”

显然有一个更好的方法去实现上面的例子那就是使用数组。有很多的方法可以创建一个数组，但我首先展示的是最简单的方法：

name_of_array=new Array()

所以我们想去引用一个数组的话，就用这个：

quotes=new Array()

很好，现在我们有了一个数组了，但问题是那里面没有任何的数据，它是没有用处的，所以我们现在把数据放到我们的数组里面，我们

用一个索引号码去定义它在数组中的位置。

我们可以用下面的方法把第一个元素放到数组中：

quotes[0]=“Flash is cool!”

我要说的是在Flash 5中数组索引下标是基于0的，意思是在数组中的第一个元素它的索引值为0。

因此我们可以在我们的数组中的第二个元素中放入一个数据：

quotes[1]=“Flash is my favourite program”

使用如下语法可以添满数组内所有元素：

name_of_array[index]=value

说明：上面的name_of_array是你数组的名子，index是你想要增加到你的数组中数据的位置。

因此我们更早的创建了使用变量的代码：

quote1=“Flash is cool!”

quote2=“Flash is my favourite program”

quote3=“Flash rules”

也可以被写成这样:

quotes=new Array()

quotes[0]=“Flash is cool!”

quotes[1]=“Flash is my favourite program”

quotes[2]=“Flash rules”

我们还可以采有如下的语法去创建：

name_of_array=new Array(“value1”,“value2”,“value3”)

这是一个在一行代码中实现的，value1 是数组中第一个元素 value2是数组中第二个元素，以此类推。

我们使用如下语法创建我们引用的数组：

quotes=new Array(“Flash is cool!”,“Flash is my favourite program”,“Flash rules”)

现在我们知道该如何创建数组，并且如何去使用，在下面的这个语法中同样可以去创建一个数姐:

name_of_array=[“value1”,“value2”,“value3”]

这个与前面不同的是没有使用数组对像（new Array()）

所以我们可以这样创建引用的数组代码如下：

quotes=[“Flash is cool!”,“Flash is my favourite program”,“Flash rules”]

我不管你用什么方法做做，但我还是喜欢用这最后一个方法去创建数组，它是如此的简单，

现在我们知道怎么创造数组，但是有时你想在脚本中访问你的数组，嗯幸运的是还有一种方法可以实现它：

mynewvariable=name_of_array[index]

那么我们想去为一个新的变量附值为数组中第一个元素的值话请这样做：

firstquote=quotes[0]

这个名为firstquote的新变量值就是“Flash is cool!”

在脚本中数组的实现

设想一下如果我们想得出数组中所有的元素，但是我们并不知道数组中有多少个元素啊，还好的是Flash中为

数组对像设置了若干属性与方法，其中有一个属性为Length可以得出该数组中元素的个数。

语法如下：

myarraylength=name_of_array.length

上面的这段代码创建了一个新变量，里面的值就是你所指定的数组对像（name_of_array）元素的个数。

在我们引用数组的情况中，使用下面的代码得到数组中元素的个数：

假如quotes是一个数组的话那么

len=quotes.length 这个len变量的值就是该数组的长度

数组的长度等于它的最高索引值加1。最高索引值如果是2的话那么这个数组的长度就是3，也就是说它里面有

3个元素，原因就在于Flash 5中数组下标是基于0的。

现在我们知道了如何去用数组的Length属性了，采用下面的脚本可以得出数级中所有元素的值。

for(z=0;z

write（name_of_array[z]）

}

让我们逐步来分析一下上面的代码。

首先创建了一个临时的变量 z

z=0

下列的代码是一个循环的条件，当变量z小于数组的元素长度就循环

然后再作变量z的增量使它本身加1 ；

++z

你可以在这里面放入你需要的代码它们会被执行（name_of_array.length的值）次

for(z=0;z

...

}

Associative arrays:

关联数组可以提供另一种存储信息的方法，用它你可以实现采用字符串做为数组的下标而不是一个数字，这样会更容易记忆。

这样的不便是在循环中不能被采用，因为它不是一个数值。

关联数组的定义与变通数组是相同的，而唯一不同的是它采用字符串作为索引下标

请看下面的例子，我们定义一个汽车的数组：

mycars=new Array()

mycars[0]=“peugoet 306”

mycars[1]=“citreon saxo”

mycars[2]=“ford fiesta”

这是关联数组的格式：

mycars=new Array()

mycars[“fast”]=“peugoet 306”

mycars[“sporty”]=“citreon saxo”

mycars[“old”]=“ford fiesta”

用字符做索引值有时会很有用，但当在循环中检索数组是非常的不便。

现在当要得到这种类型数组中的值，你就得用字符串做为索引了，参照上面的例子写出：

mysportycar=mycars[“sporty”]

结果就是变量mysportyca的值就是“citreon saxo”

如果有任何疑问，请直接于作者联系！mailto:flashguru@flashkit.com

篇3：Swift之数组使用

Swift提供两种类型的集合，一种是数组Array,另外一种是字典Dictionary,他们之间的共同点是都是用来存储相同类型的数据，不同点是数组中存放的数据是有序的，二字典中存放的数据时无序的，字典还具有两外一个特性，就是字典中所存储的数据是键值对（key - value）形式存在。

这里主要写一下Swift中数组类型使用

一、数组类型定义

想定义其他变量或者常量一样，如果我们在Swift中定义一个数据，也可以通过类型标注指定他的类型。在Swift中，数组类型有两种写法：

// 一是完整版：var colorArray : Array= [red,blue,green]//另外一种是简化版var colorArray1 : [String] = [red, blue, green]// 可以使用推导来声明数组var colorArray2 = [red, blue,green]var integerArray = [1,2,3]/*注：1、我们在定义数组时，指定数组中的数据类型，我们必须统一存放该类型数组 2、我们在定义数组时，不指定数组中的数据类型，则数组默认为anyObject类型。*/二、我们在定义数组时可以不指定数组类型：

var inferList = [eggs,123,true]for item in inferList{ println(inferList contain item : (item))}需要指出的是这种情况下产生的数组时NSArray的数组。

判断数组是否为空，Swift中数组为空判断可以直接调用isEmpty方法

if inferList.isEmpty { println(inferList为空)}else{ println(inferList不空)}也可以采用数组元素个数进行判断：

if inferList.count == 0 { println(inferList为空)}else{ println(inferList不空)}

三、swift提供两种方法为数组添加元素

第一种：通过调用数组的内嵌方法（append）为数组添加新元素

inferList.append(hello)

第二种：通过加法赋值运算符来为当前数组添加新元素

inferList += [你好]

第二种方法更为强大的是可以进行批量添加，批量添加的数组只能存放一种数据类型

inferList += [红茶,绿,黑茶]

四、修改数组元素

swift中修改数组中元素可以先通过数组名+方括号+下标的方式来获取数组中某个元素的值

如获取inferList第一个元素

var firseItem = inferList[0]

修改具体元素的值

inferList[0] = egg

Swift提供了批量修改数组元素的功能

inferList[4...6] = [呵呵,嘿嘿]/*这种情况下，4、5元素被修改，6及以后元素被移除，若不移除则inferList[4...6] = [呵呵,哈哈,嘻嘻]*/

五、为数组插入、移除元素

Swift中通过调用insert(atIndex:)方法在数组的任意指定位置插入一个新的元素

inferList.insert(insertElements, atIndex: 0)

Swift中通过调用removeAtIndex方法移除指定位置元素，其他元素自动前移

inferList.removeAtIndex(0)

第一个位置insertElements被移除

也可以使用removeLast，移除最后一个元素

inferList.removeLast

最后一个元素黑茶被移除

六、数组遍历

在Swift中数组遍历一共有两种方法：

1、通过for in 循环快速遍历数组

for item in inferList { println(item)}

2、通过enumerate全局函数来便利数组，这个函数将会将数组中的元素作为一个类型为（index,value）元祖返回

for (var (index,value)) in enumerate(inferList) { println(item : (index), value : (value))}

篇4：ActionScript 3.0系列教程：爽快使用XML

xml|教程

ActionScript. 3.0系列教程(3)：Document Class特色为我们带来了什么？

ActionScript. 3.0系列教程(4)：爽快使用XML

为什么放弃AS2.0选择AS3.0?如果只允许我说三个理由，那么AS3.0对XML的近乎完美的支持绝对是其中一个。

简单说说AS3.0中对于XML支持的不同吧：

.AS2.0对XML的支持勉勉强强，将就着可以用。而AS3.0中对XML的支持是全方位的，极其强大和灵活的。

AS2.0对XML的支持不是内建的(build-in)，也并非基于ECMAScript. for XML(E4X)标准。而AS3.0中对XML的支持符合E4X标准，它的设计有三个优点：

1. 简易。包括操作和可读性。你会发现AS3.0中对于XML的操作犹如对一个普通Object对象一样浅显易懂。语句非常浅白流畅。

2. 连续性。其各个功能的设计和AS3.0其余的部分思想一致，易于理解。

3. 熟悉。操作符和操作逻辑对我们来说都相当熟悉易用。

在AS2.0时代，为了解决这部分的问题

效率。

效率包括两方面，开发效率，和代码执行效率。开发效率的论述见上。AS3.0对于XML的执行效率远远高过没有内建XML支持的AS2.0。

XML的输入

在AS2.0时代，在代码行中输入XML代码是一种痛苦。如果不是从文件中读取，那么我们就要忍受一长串挤在一块儿的字符串。

而在AS3.0中，太简单了。直接按照XML的内容输即可，想换行就换行，想Tab就Tab，就一个字，爽。

新建一个fla,选中第一帧，F9打开动作面板，输入如下代码：

//www.kingda.org

//例1

var kingdaXML:XML =

First touch of Flash 9

Binding Classes

Document Class

trace (kingdaXML.item[1].level); //output:3

//例2

var kS:String = “this is a test”;

var kXML:XML = new XML(kS);

trace (kXML.txt); //output:this is a test;

例1中注意到没，直接写XML内容在后面，想换行就换行，想tab就tab，多爽。不想AS2.0中写string时，换个行就不行了。

写完这一句后，我们所写出的类似于string的形式立刻就被Flash理解成了XML对象了，所以我们马上就可以用“.”操作符来访问相应的属性。本例中访问了第2个item节点的level值。

这么简便直观的访问方式是不是比 AS2.0中那千遍一律的childNodes要好得多？

不过要注意，最后可以加“;”结束。但我为了XML的视觉美观没有加。这个没有关系，编译时不会考虑这一点。

事实上只要你喜欢，AS1.0, 2.0, 3.0中语句结束都可以不加“;”号。但是这并不是一个好的编程习惯，更不符合严谨的自我语法要求。因此我建议，除了XML可以不加外，其余的都应该加，呵呵。

例2展示了如何将一个包含了XML内容的字符串转换成XML对象。用的是XML的构造函数转换的。

AS3更有趣的是，可以使用已有的变量来直接构造XML，带来方便的编程特性。如下例。

var rootNodeName :String = “site”;

var subNodeName :String = “orgin”;

var subNodeContent :String = “Kingda's Blog”;

var attributeName :String = “url”

var attributeValue :String = “www.kingda.org”;

var extXML:XML =

<{rootNodeName} {attributeName}={attributeValue}>

<{subNodeName}>{subNodeContent}

;

trace (extXML.toString());

/*output:

Kingda's Blog

要点就是要把变量用“{}”括起来，并且设置属性时不要再加引号了。

XML的外部读取

包括读取外部xml文件，和通过URL读取xml。AS3.0中不像2.0那样集成了一个load()。

AS3.0在架构上就设计了所有与外部打交道的都由URLrequest对象来进行，数据都由URLloader对象来接受。这个我们会在下一部分教程详细讲解。这一次只要知道这样的架构设计是深思熟虑，且简洁优美的即可。

var myXML:XML = new XML();

//初始化XML地址，可以是本地的“xxx.xml”，也可以是如下的URL地址。

var XML_URL:String = “www.kingda.org/blog/index.xml”; //我的Blog RSS Feed

var myXMLURL:URLRequest = new URLRequest(XML_URL);

var myLoader:URLLoader = new URLLoader(myXMLURL);

//添加装载完成侦听器,

//Event.COMPLETE的值是“complete”,直接用此字符串也可以，

myLoader.addEventListener(Event.COMPLETE, xmlLoaded);

function xmlLoaded(evtObj:Event) {

myXML = XML(myLoader.data);

trace(“数据装载完成.”);

trace (myXML);

}

XML的操作

1.查询

//显示level为4的节点的title值

trace (kingdaXML.item.(level == 4).title);

//output：Document Class

//显示level>2的节点的title值，本处结果大于1，所以是一个XML Array。

trace (kingdaXML.item.(level >2).title);

/*output:

Binding Classes

Document Class

//使用属性用@开头即可。真方便。

trace (kingdaXML.item.(level >2).@id);

//output:23

//这儿要注意，实际上是2,3。一个Array.

//也可以用属性来做判断

trace (kingdaXML.item.(@id >1).title);

2.添加或者修改属性

方便的不能再方便，直接写即可。爽翻天啊。

//把id == 1的节点level值改为2

kingdaXML.item.(@id==1).level = 2;

//把id==1的节点添加一个属性 page

kingdaXML.item.(@id==1).page = 100;

trace (kingdaXML.item.(@id==1));

3.按某条件插入节点

var newNode1:XML = 0None

var newNode2:XML = 0None

//把newNode1插入到id==2的节点后面

kingdaXML = kingdaXML.insertChildAfter(kingdaXML.item.(@id==2), newNode1);

//把newNode1插入到id==2的节点前面

kingdaXML = kingdaXML.insertChildBefore(kingdaXML.item.(@id==2), newNode2);

trace (kingdaXML);

XML的高级操作

常用的操作上面已经介绍的很清楚了。高级操作则是留给对XML应用更深的兄弟们。

几点注意：

1.在AS3.0中， XML类的ignoreWhitespace默认为true。

2.AS3.0支持对comments的直接操作。但默认:

XML.ignoreComments = false;

var kingdaXML:XML =

;

trace(kingdaXML.toXMLString()); //默认为true时，不会显示comment的

访问comment用

trace(kingdaXML.comments()[1].toXMLString());

3.XML支持克隆。

使用copy()可以得到一份现有XML的值拷贝。

var kingdaCopy:XML = kingdaXML.copy();

对kingdaCopy操作就不会影响kingdaXML对象了。

4.极有用的descendants函数返回一个XMLList对象，包括所有的子节点。

设ignoreComments = false;和ignoreProcessingInstructions ＝ false后，连comments和process instructions也会包含在这个XMLList对象中。

运用示例如下：

XML.ignoreComments = false;

var xml:XML =

text1

text2

;

trace(xml.descendants(“*”).length()); // 5

trace(xml.descendants(“*”)[0]); // //

trace(xml.descendants(“*”)[1].toXMLString()); // text1

trace(xml.descendants(“a”).toXMLString()); //text2

trace(xml.descendants(“b”).toXMLString()); //text2

还有太多的XML有用操作功能了(如对namespace的操作)。用到时再去翻参考书吧。

以上的介绍可以满足绝大部分运用了。

对了AS2.0已有的XML类，在3.0中变成了XMLDocument类，使用方法不变。便于AS2.0程序移植。其余不推荐。

下一次讲3.0的Web交互模型和运用吧。

篇5：Python程序设计入门数组的使用

热点排行

Python入门教程超详细1小时学会

python 中文乱码问题深入分析

比较详细Python正则表达式操作指

Python字符串的encode与decode研

Python open读写文件实现脚本

Python enumerate遍历数组示例应

Python 深入理解yield

Python+Django在windows下的开发

python 文件和路径操作函数小结

python 字符串split的用法分享

篇6：DataGrid分页使用小结

默认分页模式：

选中“允许分页”；页大小；页导航设置，可以是上下方式，也可以用页码方式

格式里可以设置“页导航”按钮的对起方式；

private void datashow()//绑定数据

{

string sql=“server=127.0.0.1;database=ltp;user id=sa;password=”;

SqlConnection mycon=new SqlConnection(sql);

string selsql=“select * from data”;

SqlDataAdapter da=new SqlDataAdapter(selsql,mycon);

DataSet ds=new DataSet();

da.Fill(ds,“data”);

this.DataGrid1.DataSource=ds.Tables[“data”];

this.DataGrid1.DataBind();

}

响应事件 PageIndexChanged()

this.DataGrid1.CurrentPageIndex=e.NewPageIndex;

datashow();

自定义导航控件的默认分页模式

当前页：this.Label1.Text=(this.DataGrid1.CurrentPageIndex+1).ToString();

因为CurrentPageIndex从0开始的，所以要+1

总页数：this.Label2.Text=this.DataGrid1.PageCount.ToString();

//第一页

this.DataGrid1.CurrentPageIndex=0;

//上一页

if(this.DataGrid1.CurrentPageIndex>0)

{

this.DataGrid1.CurrentPageIndex-=1;

this.datashow();

}

//下一页

if(this.DataGrid1.CurrentPageIndex<(this.DataGrid1.PageCount-1))

{

this.DataGrid1.CurrentPageIndex+=1;

this.datashow();

}

//最后一页

this.DataGrid1.CurrentPageIndex=this.DataGrid1.PageCount-1

最后再 datashow();

自定义数据分页--非常重要！（提高性能效率）

每次this.datashow();是提取全部数据，反而降低了效率，

正确的方法：

1，选中“允许分页”；“允许自定义分页”；页大小。

2，添加导航按钮，设置CommandName属性，previous，next

3，代码：

//记录每一页的开始索引

int startindex;

private void Page_Load(object sender, System.EventArgs e)

{

//自定义按钮事件

this.btnprevious.Click+=new System.EventHandler(this.NavigateToPage);

this.btnnext.Click+=new System.EventHandler(this.NavigateToPage);

//or nCommand=“NavigateToPage”

if(!IsPostBack)

{

startindex=0;

//得到数据源的记录数，并指派给DataGrid1

string constr=“server=127.0.0.1;database=ltp;user id=sa;password=”;

SqlConnection mycon=new SqlConnection(constr);

mycon.Open();

string sql=“select 总数=count(*) from data”;

SqlCommand com=new SqlCommand(sql,mycon);

SqlDataReader dr=com.ExecuteReader(CommandBehavior.SingleRow);

if(dr.Read())

this.DataGrid1.VirtualItemCount=(int)dr[“总数”];

dr.Close();

mycon.Close();

this.bindGrid(startindex,“previous”);

}

//自定义按钮事件

private void NavigateToPage(object sender,System.EventArgs e)

{

string pageinfo=((Button)sender).CommandName;

switch(pageinfo)

{

case “previous”:

if(this.DataGrid1.CurrentPageIndex>0)

{

this.DataGrid1.CurrentPageIndex-=1;

}

break;

case “next”:

if(this.DataGrid1.CurrentPageIndex<(this.DataGrid1.PageCount-1))

{

this.DataGrid1.CurrentPageIndex+=1;

}

break;

}

//得到开始的索引

startindex=this.DataGrid1.CurrentPageIndex*this.DataGrid1.PageSize;

//重新绑定

this.bindGrid(startindex,pageinfo);

}

//从数据源提取所需的数据记录--方法2（有int序号的表）

private void bindGrid2(int startindex,string pageinfo)

{

string constr=“server=127.0.0.1;database=ltp;user id=sa;password=”;

SqlConnection mycon=new SqlConnection(constr);

mycon.Open();

string sql=“select top 5 * from data where 序号>=”+startindex+“ order by 序号”;

SqlDataAdapter da=new SqlDataAdapter(sql,mycon);

DataSet ds=new DataSet();

da.Fill(ds,“data”);

this.DataGrid1.DataSource=ds.Tables[“data”];

this.DataGrid1.DataBind();

mycon.Close();

}

//从数据源提取所需的数据记录--方法1（按某字符串列排序的）

private void bindGrid(int startindex,string pageinfo)

{

string constr=“server=127.0.0.1;database=ltp;user id=sa;password=”;

SqlConnection mycon=new SqlConnection(constr);

mycon.Open();

SqlCommand com=new SqlCommand();

switch(pageinfo)

{

case “previous”:

string sql=“select top 5 * from data where 持股名称>=@id order by 持股名称”;

com=new SqlCommand(sql,mycon);

// com=new SqlCommand(“select top 5 * from data where 持股名称>=@id order by 持股名称”,mycon);

if(startindex==0)

{

com.Parameters.Add(“@id”,SqlDbType.NVarChar,10).Value=“”;

}

else

{

//把开始

com.Parameters.Add(“@id”,SqlDbType.NVarChar,10).Value=ViewState[(this.DataGrid1.CurrentPageIndex+1).ToString()];

// com.Parameters.Add(“@id”,SqlDbType.NVarChar,10).Value=this.DataGrid1.Items[0].Cells开始

com.Parameters.Add(“@id”,SqlDbType.NVarChar,10).Value=this.DataGrid1.Items[4].Cells[1].Text;

break;

}

SqlDataReader dr=com.ExecuteReader();

this.DataGrid1.DataSource=dr;

this.DataGrid1.DataBind();

dr.Close();

mycon.Close();

//重新得到当前开始第一行的列值

ViewState[(this.DataGrid1.CurrentPageIndex+1).ToString()]=this.DataGrid1.Items[0].Cells[1].Text;

}

篇7：Linux Shell 数组的创建及使用技巧

这篇文章主要介绍了Linux Shell 数组的创建及使用技巧,本文讲解了数组定义、数组读取与赋值以及特殊使用,需要的朋友可以参考下

linux shell在编程方面比windows 批处理强大太多，无论是在循环、运算，已经数据类型方面都是不能比较的。下面是个人在使用时候，对它在数组方面一些操作进行的总结。

1.数组定义

[chengmo@centos5 ~]$ a=(1 2 3 4 5)[chengmo@centos5 ~]$ echo $a

一对括号表示是数组，数组元素用“空格”符号分割开。

2.数组读取与赋值

得到长度：

[chengmo@centos5 ~]$ echo ${#a[@]}5

用${#数组名[@或*]} 可以得到数组长度

读取：

[chengmo@centos5 ~]$ echo ${a[2]} 3[chengmo@centos5 ~]$ echo ${a[*]} 1 2 3 4 5

用${数组名[下标]} 下标是从0开始下标是：*或者@ 得到整个数组内容

赋值:

[chengmo@centos5 ~]$ a[1]=100[chengmo@centos5 ~]$ echo ${a[*]} 1 100 3 4 5[chengmo@centos5 ~]$ a[5]=100 [chengmo@centos5 ~]$ echo ${a[*]}1 100 3 4 5 100

直接通过数组名[下标] 就可以对其进行引用赋值，如果下标不存在，自动添加新一个数组元素

删除:

[chengmo@centos5 ~]$ a=(1 2 3 4 5)[chengmo@centos5 ~]$ unset a[chengmo@centos5 ~]$ echo ${a[*]}[chengmo@centos5 ~]$ a=(1 2 3 4 5)[chengmo@centos5 ~]$ unset a[1] [chengmo@centos5 ~]$ echo ${a[*]} 1 3 4 5[chengmo@centos5 ~]$ echo ${#a[*]}4

直接通过：unset 数组[下标] 可以清除相应的元素，不带下标，清除整个数据，

3.特殊使用

分片:

[chengmo@centos5 ~]$ a=(1 2 3 4 5)[chengmo@centos5 ~]$ echo ${a[@]:0:3}1 2 3[chengmo@centos5 ~]$ echo ${a[@]:1:4}2 3 4 5[chengmo@centos5 ~]$ c=(${a[@]:1:4})[chengmo@centos5 ~]$ echo ${#c[@]}4[chengmo@centos5 ~]$ echo ${c[*]} 2 3 4 5

直接通过 ${数组名[@或*]:起始位置:长度} 切片原先数组，返回是字符串，中间用“空格”分开，因此如果加上””，将得到切片数组，上面例子：c 就是一个新数据。

替换:

[chengmo@centos5 ~]$ a=(1 2 3 4 5) [chengmo@centos5 ~]$ echo ${a[@]/3/100}1 2 100 4 5[chengmo@centos5 ~]$ echo ${a[@]}1 2 3 4 5[chengmo@centos5 ~]$ a=(${a[@]/3/100}) [chengmo@centos5 ~]$ echo ${a[@]} 1 2 100 4 5

调用方法是：${数组名[@或*]/查找字符/替换字符} 该操作不会改变原先数组内容，如果需要修改，可以看上面例子，重新定义数据。

从上面讲到的，大家可以发现linux shell 的数组已经很强大了，常见的操作已经绰绰有余了。

篇8：LUA string库使用小结

这篇文章主要介绍了LUA string库使用小结,本文总结了简单的模式串、格式化的模式串、模式串中的特殊字符、用‘[]‘创建字符集、在‘[]‘中使用连字符‘-‘等内容,需要的朋友可以参考下

1. string库中所有的字符索引从前往后是1,2,...;从后往前是-1,-2,...

2. string库中所有的function都不会直接操作字符串，而是返回一个结果

代码如下:

s = “[abc]”

string.len(s) <==返回5

string.rep(“abc”, 2) <==返回“abcabc”

string.lower(“ABC”) <==返回“abc”

string.upper(“abc”) <==返回“ABC”

string.sub(s, 2) <==返回“abc]”

string.sub(s, -2) <==返回“c]”

string.sub(s, 2, -2) <==返回“abc”

string.format(fmt, ...)返回一个类似printf的格式化字符串

string.find(s, pattern, pos)

第1个参数：源字符串

第2个参数：待搜索之模式串

第3个参数：A hint, 从pos位置开始搜索

找到匹配返回：匹配串开始和结束的位置，否则返回nil

简单的模式串:

代码如下:

s = “hello world”

i, j = string.find(s, “hello”)

print(i, j) -->1 5

print(string.sub(s, i, j)) -->hello

print(string.find(s, “world”)) -->7 11

i, j = string.find(s, “l”)

print(i, j) -->3 3

print(string.find(s, “lll”)) -->nil

格式化的模式串:

代码如下:

s = “Deadline is 30/05/, firm”

date = “%d%d/%d%d/%d%d%d%d”

print(string.sub(s, string.find(s, date))) -->30/05/1999

下面的表列出了Lua支持的所有字符类：

代码如下:

. 任意字符

%s 空白符

%p 标点字符

%c 控制字符

%d 数字

%x 十六进制数字

%z 代表0的字符

%a 字母

%l 小写字母

%u 大写字母

%w 字母和数字

上面字符类的大写形式表示小写所代表的集合的补集，例如，‘%A‘非字母的字符：

模式串中的特殊字符:

代码如下:

( ) . % + - * ? [ ^ $

‘%‘ 用作特殊字符的转义字符

‘%.‘ 匹配点；

‘%%‘ 匹配字符 ‘%‘。

转义字符 ‘%‘不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。当对一个字符有疑问的时候，为安全起见请使用转义字符转义他。

用‘[]‘创建字符集：

代码如下:

‘[%w_]‘ 匹配字母数字和下划线

‘[01]‘ 匹配二进制数字

‘[%[%]]‘匹配一对方括号

在‘[]‘中使用连字符‘-‘：

代码如下:

‘%d‘ 表示 ‘[0-9]‘；

‘%x‘ 表示 ‘[0-9a-fA-F]‘

‘[0-7]‘ 表示 ‘[01234567]‘

在‘[]‘开始处使用 ‘^‘ 表示其补集：

代码如下:

‘[^0-7]‘ 匹配任何不是八进制数字的字符；

‘[^\n]‘ 匹配任何非换行符户的字符，

‘[^%s]‘ == ‘%S‘

模式修饰符：

代码如下:

+ 匹配前一字符1次或多次

* 匹配前一字符0次或多次;最长匹配

- 匹配前一字符0次或多次;最短匹配

? 匹配前一字符0次或1次

^ 匹配字符串开头

$ 匹配字符串结尾

捕获：用()将要捕获的部分包围起来：

代码如下:

pair = “name = Anna”

firstidx, lastidx, key, value = string.find(pair, “(%a+)%s*=%s*(%a+)”)

print(key, value) <== name Anna

拷贝捕获(%1-%9)：

代码如下:

s = “abc \”it\‘s a cat\“”

_,_,_,q = string.find(s, “([\”‘])(.-)%1“))

print(q) <== it‘s a cat 如果%d代表第几个捕获的拷贝。

string.gsub(s, pattern, reps)

第1个参数：源字符串

第2个参数：待替换之模式串

第3个参数：替换为reps

将s中所有符合pattern的字串替换为reps，返回结果串+匹配数：

代码如下:

print(string.gsub(”hello, world“, ”o“, ”a“)) <== hella, warld 2

gsub也可以用拷贝捕获技巧

代码如下:

print(string.gsub(”hello, world“, ”(o)“, ”%1-%1“)) <== hello-o, wo-orld 2

print(string.gsub(”hello Lua“, ”(.)(.)“, ”%2%1“)) <== ehll ouLa 4

function trim (s) return (string.gsub(s, ”^%s*(.-)%s*$“, ”%1“)) end <== 注意匹配数用括号丢弃

string.gsub(s, pattern, func)

第3个参数：自定义函数，对找到的匹配操作，并传出替换值：

代码如下:

s, n = string.gsub(”hello world“, ”l+“, function(s) return ”xxx“ end)

print(s, n) <== hexxxo worxxxd 2

string.gfind(s, pattern)

返回一个迭代器，迭代器每执行一次，返回下一个匹配串：

代码如下:

iter = string.gfind(”a=b c=d“, ”[^%s+]=[^%s+]“)

print(iter()) <== a=b

print(iter()) <== c=d

通常用于泛性for循环,下面的例子结果同上：

代码如下:

for s in string.gfind(”a=b c=d“, ”[^%s+]=[^%s+]“) do

print(s)

end

篇9：Linux如何使用awk处理工具进行数组排序

代码如下：

［chengmo@localhost ~］$ awk ‘BEGIN{info = “this is a test”;split（info，tA，“ ”）;for（k in tA）{print k，tA［k］;}}’

4 test

1 this

2 is

3 a

如果需要按照顺序输出，通过键值定位方式输出。

代码如下：

［chengmo@localhost ~］$ awk ‘BEGIN{info = “this is a test”;slen=split（info，tA，“ ”）;for（i=1;i《=slen;i++）{print i，tA［i］;}}’

1 this

2 is

3 a

4 test

一、通过内置函数（asort，asorti使用） awk 3.1以上版本才支持

1、asort使用说明

srcarrlen=asort［srcarr，dscarr］默认返回值是：原数组长度，传入参数dscarr则将排序后数组赋值给dscarr.

代码如下：

［chengmo@localhost ~］$ awk ‘BEGIN{

a［100］=100;

a［2］=224;

a［3］=34;

slen=asort（a，tA）;

for（i=1;i《=slen;i++）

{print i，tA［i］;}

}’

1 34

2 100

3 224

asort只对值进行了排序，因此丢掉原先键值。

2、asorti 使用说明

代码如下：

［chengmo@localhost ~］$ awk ‘BEGIN{

a［“d”］=100;

a［“a”］=224;

a［“c”］=34;

slen=asorti（a，tA）;

for（i=1;i《=slen;i++）

{print i，tA［i］，a［tA［i］］;}

}’

1 a 224

2 c 34

3 d 100

asorti对键值进行排序（字符串类型），将生成新的数组放入：tA中。

二、通过管道发送到sort排序

代码如下：

［chengmo@localhost ~］$awk ‘BEGIN{

a［100］=100;

a［2］=224;

a［3］=34;

for（i in a）

{print i，a［i］ | “sort -r -n -k2”;}

}’

2 224

100 100

3 34

通过管道，发送到外部程序“sort”排序，-r 从大到小，-n 按照数字排序，-k2 以第2列排序。通过将数据丢给第3方的sort命令，所有问题变得非常简单。如果以key值排序 –k2 变成 -k1即可。

代码如下：

［chengmo@localhost ~］$ awk ‘BEGIN{

a［100］=100;

a［2］=224;

a［3］=34;

for（i in a）

{print i，a［i］ | “sort -r -n -k1”;}

}’

100 100

3 34

2 224

三、自定义排序函数

awk自定义函数结构：

代码如下：

function funname（p1，p2，p3）

{

staction;

return value;

}《/p》《p》以上是：awk自定义函数表示方式，默认传入参数都是以引用方式传入，return值，只能是字符型或者数值型。不能返回数组类型。如果返回数组类型。需要通过形参方式传入。再获得。《/p》《p》awk返回数组类型《/p》《p》awk ‘function test（ary）{ for（i=0;i《10;i++）{ ary［i］=i; } return i;}BEGIN{ n=test（array）; for（i=0;i《n;i++）{ print array［i］; }}’

排序函数

代码如下：

#arr 传入一维数组《/p》《p》#key 排序类型 1是按照值排序 2按照键值《/p》《p》#datatype 比较类型 1按照数字排序 2按照字符串排序《/p》《p》#tarr 排序返回的数组《/p》《p》#splitseq 分割字符串数组中键与值之间分割字符串《/p》《p》#return 数组长度《/p》《p》#实现思路，将原始数组a［‘a’］=100 排序后变成 a［1］=a分隔符100 ，然后按照下标递归显示内容，

本排序使用冒泡方式进行。《/p》《p》《/p》《p》function sortArr（arr，key，datatype，tarr，splitseq）

{ 《/p》《p》 if（key ~ /［^1-2］/）

{return tarr;}

for（k in arr）

{

tarr［++alen］=（k“”splitseq“”arr［k］）;

} 《/p》《p》 for（m=1;m《=alen;m++）

{

for（n=1;n《=alen-m-1;n++）

{

split（tarr［m］，tm，splitseq）;

split（tarr［n+1］，tn，splitseq）; 《/p》《p》 tnum=tarr［m］;

if（datatype==1）

{

if（tm［key］+0《tn［key］+0）

{

tarr［m］=tarr［n+1］;

tarr［n+1］=tnum;

}

else

{

if（（tm［key］“”）《（tn［key］“”））

{

tarr［m］=tarr［n+1］;

tarr［n+1］=tnum;

}

return alen;

}

完整代码如下：

代码如下：

［chengmo@centos5 ~］$ awk ‘BEGIN{

a［“a”］=100;

a［“b”］=110;

a［“c”］=10;

splitseq=“%%”;

alen=sortArr（a，2，1，tarr，splitseq）;

for（m=1;m《=alen;m++）

{

split（tarr［m］，ta，splitseq）;

print m，ta［1］，ta［2］;

}

function sortArr（arr，key，datatype，tarr，splitseq）

{ 《/p》《p》 if（key ~ /［^1-2］/）

{return tarr;}

for（k in arr）

{

tarr［++alen］=（k“”splitseq“”arr［k］）;

} 《/p》《p》 for（m=1;m《=alen;m++）

{

for（n=1;n《=alen-m-1;n++）

{

split（tarr［m］，tm，splitseq）;

split（tarr［n+1］，tn，splitseq）; 《/p》《p》 tnum=tarr［m］;

if（datatype==1）

{

if（tm［key］+0《tn［key］+0）

{

tarr［m］=tarr［n+1］;

tarr［n+1］=tnum;

}

else

{

if（（tm［key］“”）《（tn［key］“”））

{

tarr［m］=tarr［n+1］;

tarr［n+1］=tnum;

}

return alen;

}

’ 《/p》《p》1 b 110

2 a 100

3 c 10

上面就是Linux使用awk进行数组排序的方法介绍了，本文一共介绍了3种方法，每种方法都能够实现awk的数组排序，可选择任一方法实现。

篇10：Shell中的变量使用小结

这篇文章主要介绍了Shell中的变量使用小结,本文总结了变量的语法、常见使用形式等内容,并分别给出代码示例,需要的朋友可以参考下

变量的定义,只能以字母和下划线开始,区分大小写,可以包含数字字母下划线.详见官方手册

代码如下:

[root@svn shell_example]# yourname=‘Linux‘

[root@svn shell_example]# echo $yourname

Linux

[root@svn shell_example]# YourName=”linux“

[root@svn shell_example]# echo ”The variable is $YourName“

The variable is linux

获取当前日期的脚本,常用在日志切割中,为了区分每天的日志文件

如下生成4月27日

代码如下:

[root@svn shell_example]# echo `date +%Y%m%d`

0427

[root@svn shell_example]# cat today.sh

#!/bin/bash

TODAY=`date +%A`

YEAR=`date +%Y年%m月%d日`

echo ”今天是 $YEAR, $TODAY“

[root@svn shell_example]# sh today.sh

今天是月27日, 星期一

从键盘获取用户的输入,如下脚本执行后脚本直接等待用过户输入,直到用户输入完成并回车,脚本获取到用户的输入并将结果打印出来.

代码如下:

[root@svn shell_example]# cat var.sh

#!/bin/bash

read myvar

echo ”myvar is $myvar

执行结果如下

[root@svn shell_example]# sh var.sh

Linux

myvar is Linux

[/code]

带提示信息的从键盘获取用户输入

代码如下:

#!/bin/bash

#从键盘获取用户信息,并打印出来.

echo -n ‘Enter Your Name:‘ #-n 选项表示不换行.

read name

echo “Hi $name”

sh name.sh

Enter Your Name:linux

Hi linux

升级版脚本,此脚本成功的接受了用户的2个参数姓和名字,并将输入打印在屏幕上

代码内容如下

代码如下:

[root@svn shell_example]# cat firstname.sh

#!/bin/bash

pw=“123”

echo

echo “+========用户登录=========+”

echo

echo -n “请输入您的用户名: ”

read fname lname

echo -n “请输入您的密码: ”

read passwd

echo “尊敬的会员$fname $lname,您好!您已登录成功”

[root@svn shell_example]# sh firstname.sh

+========用户登录=========+

请输入您的用户名: 纳斯李

请输入您的密码: 123

尊敬的会员纳斯李,您好!您已登录成功

篇11：在PostgreSQL中使用数组时值得注意的一些地方

这篇文章主要介绍了在PostgreSQL中使用数组时值得注意的一些地方,包括如何提高输入性能,需要的朋友可以参考下

在Heap中，我们依靠PostgreSQL支撑大多数后端繁重的任务，我们存储每个事件为一个hstore blob，我们为每个跟踪的用户维护一个已完成事件的PostgreSQL数组，并将这些事件按时间排序， Hstore能够让我们以灵活的方式附加属性到事件中，而且事件数组赋予了我们强大的性能，特别是对于漏斗查询，在这些查询中我们计算不同转化渠道步骤间的输出。

在这篇文章中，我们看看那些意外接受大量输入的PostgreSQL函数，然后以高效，惯用的方式重写它。

你的第一反应可能是将PostgreSQL中的数组看做像C语言中对等的类似物。你之前可能用过变换阵列位置或切片来操纵数据。不过要小心，在PostgreSQL中不要有这样的想法，特别是数组类型是变长的时，比如JSON、文本或是hstore。如果你通过位置来访问PostgreSQL数组，你会进入一个意想不到的性能暴跌的境地。

这种情况几星期前在Heap出现了。我们在Heap为每个跟踪用户维护一个事件数组，在这个数组中我们用一个hstore datum代表每个事件。我们有一个导入管道来追加新事件到对应的数组。为了使这一导入管道是幂等的，我们给每个事件设定一个event_id，我们通过一个功能函数重复运行我们的事件数组。如果我们要更新附加到事件的属性的话，我们只需使用相同的event_id转储一个新的事件到管道中。

所以，我们需要一个功能函数来处理hstores数组，并且，如果两个事件具有相同的event_id时应该使用数组中最近出现的那个。刚开始尝试这个函数是这样写的：

-- This is slow, and you don‘t want to use it!---- Filter an array of events such that there is only one event with each event_id.-- When more than one event with the same event_id is present, take the latest one.CREATE OR REPLACE FUNCTION dedupe_events_1(events HSTORE[]) RETURNS HSTORE[] AS $$ SELECT array_agg(event) FROM ( -- Filter for rank = 1, i.e. select the latest event for any collisions on event_id. SELECT event FROM ( -- Rank elements with the same event_id by position in the array, descending.

这个查询在拥有2.4GHz的i7CPU及16GB Ram的macbook pro上测得，运行脚本为：gist.github.com/drob/9180760。

在这边究竟发生了什么呢? 关键在于PostgreSQL存贮了一个系列的hstores作为数组的值, 而不是指向值的指针. 一个包含了三个hstores的数组看起来像

{“event_id=>1,data=>foo”, “event_id=>2,data=>bar”, “event_id=>3,data=>baz”}

相反的是

{[pointer], [pointer], [pointer]}

对于那些长度不一的变量, 举个例子. hstores, json blobs, varchars,或者是 text fields, PostgreSQL 必须去找到每一个变量的长度. 对于evaluateevents[2], PostgreSQL 解析从左侧读取的事件直到读取到第二次读取的数据. 然后就是 forevents[3], 她再一次的从第一个索引处开始扫描,直到读到第三次的数据! 所以, evaluatingevents[sub]是 O(sub), 并且 evaluatingevents[sub]对于在数组中的每一个索引都是 O(N2), N是数组的长度.

PostgreSQL能得到更加恰当的解析结果, 它可以在这样的情况下分析该数组一次. 真正的答案是可变长度的元素与指针来实现，以数组的值, 以至于,我们总能够处理 evaluateevents[i]在不变的时间内.

即便如此，我们也不应该让PostgreSQL来处理，因为这不是一个地道的查询。除了generate_subscripts我们可以用unnest，它解析数组并返回一组条目。这样一来，我们就不需要在数组中显式加入索引了。

-- Filter an array of events such that there is only one event with each event_id.-- When more than one event with the same event_id, is present, take the latest one.CREATE OR REPLACE FUNCTION dedupe_events_2(events HSTORE[]) RETURNS HSTORE[] AS $$ SELECT array_agg(event) FROM ( -- Filter for rank = 1, i.e. select the latest event for any collisions on event_id. SELECT event FROM ( -- Rank elements with the same event_id by position in the array, descending. SELECT event, row_number AS index, rank OVER (PARTITION BY (event ->‘event_id‘)::BIGINT ORDER BY row_number DESC) FROM ( -- Use unnest instead of generate_subscripts to turn an array into a set. SELECT event, row_number() OVER (ORDER BY event ->‘time‘) FROM unnest(events) AS event ) unnested_data ) deduped_events WHERE rank = 1 ORDER BY index ASC ) to_agg;$$ LANGUAGE SQL IMMUTABLE;

结果是有效的，它花费的时间跟输入数组的大小呈线性关系，

对于100K个元素的输入它需要大约半秒，而之前的实现需要40秒。

这实现了我们的需求：

一次解析数组，不需要unnest。

按event_id划分。

对每个event_id采用最新出现的。

按输入索引排序。

教训：如果你需要访问PostgreSQL数组的特定位置，考虑使用unnest代替。

SELECT events[sub] AS event, sub, rank() OVER (PARTITION BY (events[sub] ->‘event_id‘)::BIGINT ORDER BY sub DESC) FROM generate_subscripts(events, 1) AS sub ) deduped_events WHERE rank = 1 ORDER BY sub ASC ) to_agg;$$ LANGUAGE SQL IMMUTABLE;

这样奏效，但大输入是性能下降了。这是二次的，在输入数组有100K各元素时它需要大约40秒！

这个查询在拥有2.4GHz的i7CPU及16GB Ram的macbook pro上测得，运行脚本为：gist.github.com/drob/9180760。

在这边究竟发生了什么呢? 关键在于PostgreSQL存贮了一个系列的hstores作为数组的值, 而不是指向值的指针. 一个包含了三个hstores的数组看起来像

{“event_id=>1,data=>foo”, “event_id=>2,data=>bar”, “event_id=>3,data=>baz”}

相反的是

{[pointer], [pointer], [pointer]}

-- Filter an array of events such that there is only one event with each event_id.-- When more than one event with the same event_id, is present, take the latest one.CREATE OR REPLACE FUNCTION dedupe_events_2(events HSTORE[]) RETURNS HSTORE[] AS $$ SELECT array_agg(event) FROM ( -- Filter for rank = 1, i.e. select the latest event for any collisions on event_id. SELECT event FROM ( -- Rank elements with the same event_id by position in the array, descending. SELECT event, row_number AS index, rank() OVER (PARTITION BY (event ->‘event_id‘)::BIGINT ORDER BY row_number DESC) FROM ( -- Use unnest instead of generate_subscripts to turn an array into a set. SELECT event, row_number() OVER (ORDER BY event ->‘time‘) FROM unnest(events) AS event ) unnested_data ) deduped_events WHERE rank = 1 ORDER BY index ASC ) to_agg;$$ LANGUAGE SQL IMMUTABLE;

结果是有效的，它花费的时间跟输入数组的大小呈线性关系。对于100K个元素的输入它需要大约半秒，而之前的实现需要40秒。

这实现了我们的需求：

一次解析数组，不需要unnest。

按event_id划分。

对每个event_id采用最新出现的。

按输入索引排序。

教训：如果你需要访问PostgreSQL数组的特定位置，考虑使用unnest代替。

篇12：关于IBM DB2数据库的使用小技巧小结

1. 查看本地节点目录

命令窗口中输入：db2 list node directory

2. 编目一个TCP/IP节点

命令窗口：db2 catalog tcpip node remote server ostype

3. 取消节点编目

db2 uncatalog node

4. 查看系统数据库目录

db2 list database directory

5. 查看本地数据库目录

db2 list database directory on <盘符>

在本地数据库目录中有而系统数据库目录中没有的数据库不能访问，可以在控制中心中选中<数据库>右键单击选择添加，然后输入需要添加的数据库名称或者点击刷新按钮选择数据库，加入数据库后即可以访问，

关于IBM DB2数据库的使用小技巧小结

。

6. 编目数据库

db2 catalog database as at node

7. 取消数据库编目

db2 uncatalog database

8. 测试远程数据库的连接

db2 connect to user using

9. 设置默认模式

任何用户均可通过设置Current Schema专用寄存器为特定的数据库连接设置默认模式，初始默认值为当前会话用户的权限ID。

set schema =

可以由用户交互式的使用，也可在应用程序中使用，如果用Dynamicrules Bind选项绑定包，这个语句就没有作用。此语句不在事务控制之下。

10. 代码页的设置

在创建数据库时设置字符集

create database using codeset territory

例：

create database dbtest using codeset IBM-437 territory US

也可以设置整个数据库的代码页，在win/NT/xp中，在我的电脑-->属性-->高级-->环境变量中添加变量DB2CODEPAGE = ，例：DB2CODEPAGE = 437 或 DB2CODEPAGE = 1386。或者在IBM DB2命令窗口输入 db2set DB2CODEPAGE=1386，设置后需要重新启动DB2生效。

11. DB2低版本数据到高版本的迁移

先将低版本数据备份使用恢复功能导入高版本数据库，然后在命令窗口输入 db2 migrate database 。

12. 表名或模式中含有引号时访问表

命令窗口：db2 select * from “tabschema”.“tabname”

命令行处理器：db2=>select * from “tabschema”.“tabname”

13. 导出数据库的表结构生成DDL文件

命令窗口：db2look -d -e -c -o

14. 执行脚本文件

命令窗口：db2 -tvf

15. 代码页的转换

16. 获取当前DB2的版本

select * from sysibm.sysversions

17. DB2表的字段的修改限制?

只能修改VARCHAR2类型的并且只能增加不能减少

alter table alter column set data type varchar(SIZE)

18. 如何查看表的结构?

describe table

describe select * from .

19. 如何快速清除一个大表?

ALTER TABLE TABLE_NAME ACTIVE NOT LOGGED INITALLY WITH EMPTY TABLE

20. 如何查看数据库的存储过程?

SELECT * FROM SYSCAT.POCEDURES

21. 如何查看表的约束?

SELECT * FROM SYSCAT.CHECKS WHERE TABNAME =

22. 如何查看表的引用完整约束?

SELECT * FROM SYSCAT.REFERENCES WHERE TABNAME =

23. 如何知道BUFFERPOOLS状况?

select * from SYSCAT.BUFFERPOOLS

24. 如何在命令行下查看修改实例和数据库配置参数?

查看实例配置参数: db2 get dbm cfg

修改实例配置参数: db2 update dbm cfg using 参数名新值

查看数据库配置参数: db2 get db cfg for

修改数据库配置参数: db2 update db cfg for using 参数名新值

25. 如何修改缓冲区?

增加缓冲区: create bufferpool size [pagesize 4096] {[not] EXTENDED STORAGE}

修改缓冲区: alter bufferpool size {[not] EXTENDED STORAGE}

删除缓冲区: drop bufferpool

如果缓冲区大小设置为 -1 表示缓冲池的页面数目由数据库配置参数buffpage决定，

注意: 数据库配置参数buffpage仅对缓冲区大小设置为 -1 的缓冲池起作用。

26. 多个字段时如何不通过使用select子句使用in/not in

select * from tabschema.tabname where (colA, colB, colC) [not] in (values (valueA1, valueB1, valueC1), (valueA2, valueB2, valueC2), ...(valueAn, valueBn, valueCn))

27. 查看当前连接到数据库的应用

db2 list application [show detail]

28. 如何确认DB2数据库的一致性

db2dart /DB

/DB表示检查整个数据库的一致性

29. 测试SQL语句的性能

db2batch -d -f [-a userid/passwd] [-r ]

-r 选项表示将查询结果输出到一个文件中。

30. 导出某个表的数据

export to

如：导出用户表

export to c:user.ixf of ixf select * from user

31. 导入数据

import from

：导入用户表。导入时可以直接建立新表。如果有该表存在也可以用INSERT 插入，或者用UPDATE更新

import from c:user.ixf of ixf [Create/Insert into / update] tablename

篇13：C语言：使用malloc开辟一个3*4的二维数组，并将内容

方法一：

#include#includeint main(){ int(*p)[4] = (int (*)[4])malloc(12 * sizeof(int));//数组指针 for (int i = 0; i < 3; i++) { for (int j = 0; j < 4; j++) {*(*(p + i) +j) = i * 4 + j + 1 ; } } for ( i = 0; i < 3; i++) { for (j = 0; j < 4; j++) {printf(“%d\t”, *(*(p + i) + j)); } } printf(“\n”); system(“pause”); return 0;}

方法二：

#include#includeint main(){ int i = 0; int j = 0; int **p = (int **)malloc(3 * sizeof(int)); for (i = 0; i < 3; i++) { *(p + i) = (int *)malloc(4 * sizeof(int)); } for (i = 0; i < 3; i++) { for (j = 0; j < 4; j++) {p[i][j] = 4 * i + j + 1; } } for (i = 0; i < 3; i++) { for (j = 0; j < 4; j++) {printf(“%d ”, *(*(p + i) + j)); } } system(“pause”); return 0;}

★后缀数组

★《编写ActionScript》教学反思

★小结