<![CDATA[南斗工作组]]>

<![CDATA[南斗工作组]]> http://www.nd21.com/index.php zh-cn http://www.nd21.com/read.php/78.htm <![CDATA[PHP中贪心和非贪心匹配示范]]> Model.King <P.Qingliang@hotmail.com> Tue, 12 Aug 2008 09:00:53 +0000 http://www.nd21.com/read.php/78.htm
[codes=php]
$a = "abc?test&a=a&b=b&c=c&d=d&e=e&f=f&g=g&h=h";
$b = "aadg&adgas";
preg_match("/^(.+?)&(.+?)/",$a,$rs);
var_dump($rs);
preg_match("^(.+)&(.+)",$b,$rs);
var_dump($rs);
[/codes]

默认情况下，Perl 的正则表达式是“贪婪地”，也就是说它们将尽可能多地匹配字符。要改变匹配特点，只须简单地在量词（加号[+]或星号[*]）后面加一个问号（?）即可。
Tags - 贪心 , 非贪心 , 匹配 ]]> http://www.nd21.com/read.php/77.htm <![CDATA[一段时间(半个月左右)可能都将不更新]]> Model.King <P.Qingliang@hotmail.com> Tue, 12 Aug 2008 08:57:48 +0000 http://www.nd21.com/read.php/77.htm http://www.nd21.com/read.php/76.htm <![CDATA[[算法每日一学]-数据结构之串--2008.08.12]]> Model.King <P.Qingliang@hotmail.com> Tue, 12 Aug 2008 07:51:21 +0000 http://www.nd21.com/read.php/76.htm /*************************************************************
** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-12
** 声明：笔记不是教程，这是我系统学习算法的记录而已，如有错
** 误，欢迎指正。
**
*************************************************************/

串（string）也是一种特殊的线性表，它的每个节点都由一个字符组成。它由零个或多个有序的字符组成，组成形式为 S=”a1a2……an”，其中S为字符串名，a1a2……an为串值，””只是字符串的标示符而已。
不包含任何字符的串称为空串（Empty string）
只包含空格符的串称为空白串（Blank string）
在程序中，串分为串常量和串变量

1.串的基本操作string strcat(string to, string from)连接串
int strchr(string haystack, string needle)查找串
int strlen(string str)求串长
string strcpy(string from, string to, int begin, int length)串复制
int strcmp(string s1, string s2)串比较

绝大部分高级语言都内置或者通过其他方式扩展实现了串的操作。例如c语言string.h头文件中就定义了一套关于字符串操作的函数。

2.串的存储方式
同样的分为顺序存储和链式存储

2.1顺序存储

顺序存储方式又可分为静态分配和动态分配

2.1.1静态分配
[codes=c] #define STRING_SIZE 256
typedef char[STRING_SIZE] string;
string str;
[/codes]
由于字符串的最后一个位置要用来存放字符串结束标记’\0’，所以实际上述string只能存放STRING_SIZE-1个字符。

[codes=c]
#define STRING_SIZE 256
typedef struct _string
{
  char[STRING_SIZE]  str;
  int          length;//用来标示字符串长度
}string;
[/codes]
这种定义在求串长的相关操作时比较优势。
2.1.2动态分配
[codes=c]
typedef struct _string
{
  char *ch;
  int   length;
}string;

typedef char* string;
[/codes]
2.2链式存储
[codes=c]
typedef struct _string
{
  char ch;
  struct _string * next;
}string;
[/codes]
为了提高空间利用率，可以在每个节点存储多个字符
[codes=c]
#define NUM 4
typedef struct _string
{
  char[NUM] ch;
  struct _string *next;
}string;
[/codes]

通常，将结点数据域存放的字符个数定义为结点的大小。结点的大小的值越大，存储密度越高。但是这种方式在查看、删除、插入操作时会比较费时。

3．对串的操作重点在子串匹配（子串定位）。
串匹配就是对于合法的位置（又称合法的位移）0≤i≤n-m，依次将目标串中的子串"titi+1…ti+m-1"和模式串"p0p1p2…pm-1"进行比较：
　　①若"titi+1…ti+m-1"＝"p0p1p2…pm-1"，则称从位置i开始的匹配成功，或称i为有效位移。
　　②若"titi+1…ti+m-1"≠"p0p1p2…pm-1"，则称从位置i开始的匹配失败，或称i为无效位移。朴素的串匹配：即以一次循环来测试i是否为有效位移
  朴素的串匹配：即用一个循环来依次检查n-m+1个合法的位移i（0≤i≤n-m）是否为有效位移。

3.1顺序串上的串匹配算法
[codes=c]
#define MaxStrSize 256  //该值依赖于应用，由用户定义
       typedef struct{
            char ch[MaxStrSize]; //可容纳256个字符，并依次存储在ch[0..n]中
            int length;
        }SeqString;
         int Naive StrMatch(SeqString T,SeqString P)
         {//找模式P在目标T中首次出现的位置，成功返回第1个有效位移，否则返回-1
              int i,j,k;
              int m=P.length;  //模式串长度
              int n=T.length;  //目标串长度
              for(i=0;i<=n-m;i++){  //0<=i<=n-m是合法的位移
                  j=0;k=i;  //下面用while循环判定i是否为有效位移
                  while(j                           k++;j++;
                   }
                    if(j==m)  //既T[i..i+m-1]=P[0..m-1]
                          return i;  //i为有效位移，否则查找下一个位移
               }//endfor
               return -1;  //找不到有效位移，匹配失败
           }//NaiveStrMatch
[/codes]

3.2链串上的子串定位运算
[codes=c]
LinkStrNode *LinkStrMatch(LinkString T,LinkString P)
      {//在链串上求模式P在目标T首次出现的位置
         LinkStrNode * shift,*t,*p;
         shift=T;  //shift表示位移
         t=shift;p=P;
         while(t&&p)  {
                if(t->data==p->data){  //继续比较后续结点中字符
                     t=t->next;
                     p=p->next;
                }
                else{  //已确定shift为无效位移
                    shift=shift->next;  //模式右移，继续判定shift是否为有效位移
                    t=shift;
                    p=P;
                 }
          }//endwhile
          if(p==NULL)
             return shift;  //匹配成功
          else
             return NULL;  //匹配失败
      }
[/codes]

Tags - 数据结构 , 串 ]]> http://www.nd21.com/read.php/75.htm <![CDATA[[算法每日一学]-数据结构之栈和队列--2008.08.11]]> Model.King <P.Qingliang@hotmail.com> Mon, 11 Aug 2008 08:02:40 +0000 http://www.nd21.com/read.php/75.htm 栈只能在一端进行添加、删除操作，通常这一端称为栈顶（top），另一端称为栈底(bottom)，栈的一个标志性特点：first in last out或者last in first out；队列则只能在一端添加，另一端删除的，允许删除的一端称为队头（Front），允许添加的一端称为队尾（Rear），也就是说从队头出队（删除），从队尾入队（添加），特点是first in first out。

同线性表一样，栈和队列的存储方式也分为顺序存储和链式存储。

栈的顺序存储方式下的操作实现：
stack.h文件
[codes=c]
#ifndef _HEAD_STACK_ND
#define _HEAD_STACK_ND

//C99 bool宏定义
#include

#define QUEUE_SIZE 100
//栈溢出（元素已满）
#define STACK_OVERFLOW -1
#define STACK_UNDERFLOW -2

typedef int DataType;

typedef struct _stack
{
    DataType    a[QUEUE_SIZE];
    int         length;
}STACK;

//初始化栈
void initStack(STACK *s);
//栈是否为空？
bool isEmpty(STACK *s);
//栈是否已满？
bool isFull(STACK *s);
//压入一个值，返回当前栈的长度
int push(STACK *s, DataType v);
//返回一个top值
DataType pop(STACK *s);
//取出顶部值，但不改变内部状态
DataType top(STACK *s);

#endif
[/codes]

stack.c文件
[codes=c]
#include
#include "stack.h"

void initStack(STACK *s)
{
    memset(s->a, 0, QUEUE_SIZE*sizeof(DataType));
    s->length = 0;
}

bool isEmpty(STACK *s)
{
    if (s->length == 0)
    {
        return true;
    }
    return false;
}

bool isFull(STACK *s)
{
    if (s->length == QUEUE_SIZE)
    {
        return true;
    }
    return false;
}

int push(STACK *s, DataType v)
{
    if (isFull(s))
    {
        return STACK_OVERFLOW;
    }
    s->a[s->length] = v;
    s->length++;
    return s->length;
}

DataType pop(STACK *s)
{
    if (isEmpty(s))
    {
        return STACK_UNDERFLOW;//这里如何返回比较合适？char？如果值也是char呢？
    }
    s->length--;
    return s->a[s->length];
}

DataType top(STACK *s)
{
    if (isEmpty(s))
    {
        return STACK_UNDERFLOW;//这里如何返回比较合适？char？如果值也是char呢？
    }
    return s->a[s->length-1];
}

[/codes]
上述代码测试
[codes=c]
#include
#include
#include "stack.h"

int main(void)
{
    STACK *s = (STACK*)malloc(sizeof(STACK));
    int i;

    initStack(s);
    if (isEmpty(s))
    {
        printf("Current stack is empty!\n");
    }
    else
    {
        printf("Current stack is not empty!\n");
    }
    push(s, 3);
    if (isEmpty(s))
    {
        printf("Current stack is empty!\n");
    }
    else
    {
        printf("Current stack is not empty!\n");
    }

    if (isFull(s))
    {
        printf("Current stack is full!\n");
    }
    else
    {
        printf("Current stack is not full!\n");
    }

    for(i=0; i<100; i++)
    {
        push(s, i);
    }

    if (isFull(s))
    {
        printf("Current stack is full!\n");
    }
    else
    {
        printf("Current stack is not full!\n");
    }

    for(i=0; i<100; i++)
    {
        pop(s);
    }

    if (isFull(s))
    {
        printf("Current stack is full!\n");
    }
    else
    {
        printf("Current stack is not full!\n");
    }

    if (isEmpty(s))
    {
        printf("Current stack is empty!\n");
    }
    else
    {
        printf("Current stack is not empty!\n");
    }

    return 0;
}

[/codes]
栈的链式存储下的常用操作实现，由于链式存储的节点是动态分配的，所以不存在上溢问题，也就不需要实现isFull了。
[codes=c]
LinkStack.h
#ifndef LINKSTACK_H_INCLUDED
#define LINKSTACK_H_INCLUDED

#include

#define STACK_DOWNFLOW -1

typedef int DataType;

typedef struct __linkStack
{
    DataType    v;
    struct __linkStack *pNext;
}LinkStack;

typedef struct __linkStack * StackHeader;

void initStack(StackHeader s);
bool isEmpty(StackHeader s);
DataType pop(StackHeader s);
void push(StackHeader s, DataType x);

#endif // LINKSTACK_H_INCLUDED

LinkStack.c
#include
#include "LinkStack.h"

void initStack(StackHeader s)
{
    s->pNext = NULL;
}

bool isEmpty(StackHeader s)
{
    if (s->pNext == NULL)
    {
        return true;
    }
    return false;
}

DataType pop(StackHeader s)
{
    if (isEmpty(s))
    {
        return STACK_DOWNFLOW;
    }
    LinkStack *tmp = (LinkStack *)malloc(sizeof(LinkStack));
    tmp = s->pNext;
    DataType rtn = s->pNext->v;
    free(s->pNext);
    s->pNext = tmp->pNext;
    free(tmp);
    return rtn;
}

void push(StackHeader s, DataType x)
{
    LinkStack *tmp = (LinkStack*)malloc(sizeof(LinkStack));
    tmp->v = x;
    tmp->pNext = s->pNext;
    s->pNext = tmp;
}

[/codes]
测试代码：
[codes=c]
#include
#include
#include "LinkStack.h"

int main(void)
{
    StackHeader sh;
    initStack(sh);

    if (isEmpty(sh))
    {
        printf("The stack is empty!\n");
    }
    else
    {
        printf("The stack is not empty!\n");
    }

    LinkStack *s = (LinkStack *)malloc(sizeof(LinkStack));
    s->v = 1;
    s->pNext = NULL;
    sh->pNext = s;

    if (isEmpty(sh))
    {
        printf("The stack is empty!\n");
    }
    else
    {
        printf("The stack is not empty!\n");
    }

    int i;
    for(i=0; i<100; i++)
    {
        push(sh, i);
    }

    for(i=0; i<100; i++)
    {
        printf("%d\n", pop(sh));
    }

    return 0;
}

[/codes]
队列实现类似于栈。

Tags - 栈 , 队列 ]]> http://www.nd21.com/read.php/74.htm <![CDATA[[算法每日一学]-数据结构之线性表--2008-08-10]]> Model.King <P.Qingliang@hotmail.com> Sun, 10 Aug 2008 10:58:03 +0000 http://www.nd21.com/read.php/74.htm /*************************************************************
** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-10
** 声明：笔记不是教程，这是我系统学习算法的记录而已，如有错
** 误，欢迎指正。
**
*************************************************************/

线性表是最为常见的线性数据结构。

逻辑定义
线性表由n(n>=0)个元素a0, a1, a2 …… an组成的有序序列：
1.  n为线性表的长度
2.  线性表记为(a1, a2, ……, an)
3.  ai(1<=i<=n)在不同情况下，具体含义可以不同，是个抽象的符号

逻辑结构特征
1.  每个线性表只有一个开始节点，该节点没有直接前驱节点，只有一个直接后继节点
2.  每个线性表只有一个结束节点，该节点只有一个直接前驱节点，没有直接后继节点
3.  除开始节点和结束节点之外，任意一个节点都有唯一的前驱节点和后继节点

常见的线性表基本运算
1.  初始化线性表：initList(L)
2.  获得线性表长度: getLength(L)
3.  获得线性表中第i个元素的值: getNode(L, i)
4.  查找线性表中是否有值x: locateValue(L, x)
5.  插入元素: insertValue(L, i, x)
6.  删除元素: deleteValue(L, i)
7.  清空线性表: emptyList(L)

具体如何去实现运算则需要在确定存储结构的基础上才能完成。其他的复杂运算则由基本运算组合来实现。

线性表的两种存储方式
顺序存储和链式存储

顺序存储
把线性表的节点元素存储在一组地址连续的存储单元中，以这种方式存储的线性表称为顺序表。

这种方式下我们很容易获得第i个元素的地址，进而获得它的值：
location(ai) = locaction(a0) + sizeof(a0) * (i-1);
由于可以在相同时间内获得顺序表的任意元素，所以这种顺序表也称随即存取结构。

到了这里我们就可以定义顺序表了(c语言描述)：
[codes=c]
#define SIZE 1000
typedef int DataType;
typedef struct node
{
  DataType   arr[SIZE]; //存储元素
  int      length; //已用存储单元长度
}NodeList;
[/codes]

基本运算
[codes=c]
void initList(L)
{
  L->length = 0;
}

int getLength(L)
{
  return L->length;
}

DataType getNode(L, i)
{
  return L->arr[i-1];
}

int locateValue(L, x)
{
  int i = 0;
  for(i=0; ilength; i++)
{
  if (L->arr[i] == x)
  {
    return i+1;
  }
}

return -1;//表示未找到该值
}

void insertValue(L, i, x)
{
  if (i> L->length+1 || L->length>=SIZE || i<1)
  //最多只能已用存储的末尾插入，已用存储不能已经达到
  //储存空间限制
  {
    return;
  }
  int a;
  for(a=L->length; a>=i; a--)
  {
    L->arr[a+1] = L->arr[a];
  }
  L->arr[i] = x;
}

void deleteValue(L, i)
{
  if (i>L->length || i<1)
  {
    return;
  }
  int a;
  for(a=i; alength; a++)
{
  L->arr[a-1] = L->arr[a];
}
L->length--;
}
[/codes]

很明显的我们可以看到，对于顺序表的插入和删除操作是比较耗时的，插入和删除的最坏运行时间都为O(n)，最佳运行时间为O(1)。假设在任何位置进行删除和插入的概率相同，则平均运行时间为O(n/2)。

链式存储
以链式方式存储的线性表称为链表，实际上就是单链表。链表用任意一段存储空间存储，不一定要连续的空间；链表中元素的逻辑结构同物理结构可能完全不同，为了实现逻辑结构中元素的关系，链表中存储了“指向后继元素的指针”。
链表的c语言定义
[codes=c]
typedef int DataType;
typedef stuct __node
{
  DataType  a;
  struct __node *pNext;
}Node;
typedef Node *NodeList;
Node * p;
NodelList head;
[/codes]

链表的实现和操作方法由多种，例如：有的有头节点，有的没有。
这里重点关注一下链表的插入操作（删除类似）。由于链表本身不能进行随即存取操作，所以插入和删除操作往往都是在头部或者尾部进行的，因为插入到指定位置对于链表来说基本没有任何实际意义。
由于单链表只能单向定位，所以在链表结尾进行操作，都需要一个遍历的过程：
[codes=c]
while(p->pNext != NULL)
{
  p = p->pNext;
}
[/codes]

链表有几个变形形态：循环链表和双向链表。

对比而言，规模较大时，顺序表的查找快过链表，删除和插入慢于链表。

]]> http://www.nd21.com/read.php/73.htm <![CDATA[[算法每日一学]-数据结构概论--2008-08-09]]> Model.King <P.Qingliang@hotmail.com> Sun, 10 Aug 2008 10:56:30 +0000 http://www.nd21.com/read.php/73.htm /*************************************************************
** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-9
** 声明：笔记不是教程，这是我系统学习算法的记录而已，如有错
** 误，欢迎指正。
**
*************************************************************/

意义
数据结构是计算机的一门基础课程，众多实际应用问题的解决都需要配合适合的数据结构才能解决。

概念
  数据：广义的讲指存在于世界中的各类信息，对于计算机来说，则指能够被计算机识别、存储的各类信息，如字符、图片、声音等等。
  数据元素：组成数据的基本单位。
  数据项：组成数据元素的最小标示单位。
  数据结构：包含三个方面的内容，数据的组成关系，数据以及它们之间关系的存储方式，定义在数据上的各种操作。
  数据结构从逻辑结构上分为：线性和非线性
  数据结构从存储方式上分为：顺序、链接、索引、散列
  数据类型：可以认为是已经定义好的数据结构，例如整数(int)。
  抽象数据类型（ADT）：数据的逻辑结构以及在逻辑结构上定义的各种操作。

常用数据结构
  线性表、栈和队列、串、多维数组、广义表、树、图.

]]> http://www.nd21.com/read.php/72.htm <![CDATA[[算法每日一学]-逆序数算法--2008-08-08]]> Model.King <P.Qingliang@hotmail.com> Sat, 09 Aug 2008 11:06:59 +0000 http://www.nd21.com/read.php/72.htm ** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-8
** 声明：笔记不是教程，这只是我系统学习算法的记录而已，如有错
** 误，欢迎指正。
**
*************************************************************/

逆序数定义：对于一个数字序列，a1, a2, ..., an ,如果（am, an）满足man，那么（am, an）称为逆序对，我们暂时称呼am为左值，an为右值。
[codes=c]

#include

/**
* 遍历求逆序数,其最坏运行时间为θ(n2)
*/
int nixu(int arr[], int size)
{
    if (size <= 1)
    {
        return 0;
    }

    int i = 0, j = 0, sum = 0, key;
    for(i=0; i    {
        key = arr[i];
        for(j=i+1; j        {
            if (key > arr[j])
            {
                sum++;
            }
        }
    }

    return sum;
}

/**
* 递归求求逆序数,其最坏运行时间为θ(n2)
*/
int nixu2(int arr[], int begin, int end)
{
    if (begin == end)
    {
        return 0;
    }

    int i = begin;
    int key = arr[begin];
    int sum = 0;

    for(i=begin; i<=end; i++)
    {
        if (key > arr[i])
        {
            sum++;
        }
    }

    sum += nixu2(arr, begin+1, end);

    return sum;
}

int main(int argc, char** argv)
{
    int arr[5] = {3, 6, 2, 5, 4};

    printf("The result is %d\n", nixu(arr, 5));

    printf("The result is %d\n", nixu2(arr, 0, 4));

    return 0;
}
[/codes]
nixu()和nixu2()的运行时间是一样的（只从语句的执行次数来说），都是θ(n2)，如何实现运行时间为nlog2(n)的算法版本？这时我们需要从合并排序借鉴思路了,因为合并排序的运行时间就是nlog2(n)。

对于输入数组（假定以数组方式提供数字序列）每一个数，我们都希望从它之后的子序列中找出小于该数值的数的个数，这样循环一遍即可获得结果，这个思路同线性排序是相似的。因而我们可以像从“线性排序”到“合并排序”一样来思考上述问题。
假设数组如下： arr[0...size-1]，划分为arr[0...mid] 和 arr[mid+1...size-1]，其中mid=(int)size>>1.那么逆序对数的个数为 f(0, size-1) = f(0, mid) + f(mid+1, size-1) + s(0, mid, size-1)，这里s(0, mid, size-1)代表左值在[0---mid]中，右值在[mid+1, size-1]中的逆序对数。由于两个子序列本身都已经排序，所以查找起来非常方便。到了这里，算法的思路就已经ok了，稍微修改合并排序算法即可。
[codes=c]
#include
#include

#define ARRAY_MAX_SIZE 10000
int num = 0;

/**
* 打印数组内容
*/
void print_array(int arr[], int size)
{
    int i;
    printf("********* Array print begin *********\r\n");
    for(i=0; i    {
        printf("array[%d] = %d\r\n", i, arr[i]);
    }
    printf("********* Array print end *********\r\n");
}

void merge_array(int arr[], int begin ,int mid, int end)
{
    int i, j, key;

    if (arr[mid+1] > arr[mid])
    {
        //return;
    }

    for(i=mid; i>=begin; i--)
    {
        key = arr[i];
        j = i+1;
        while(j<=end && key > arr[j])
        {
            arr[j-1] = arr[j];
      j++;
        }
        num += j - i - 1;
        arr[j-1] = key;
    }
}

void merge_sort(int arr[], int begin, int end)
{
    int mid = (int)((begin+end)>>1);

    if (begin < end)
    {
        merge_sort(arr, begin, mid);
        merge_sort(arr, mid+1, end);
        merge_array(arr, begin, mid, end);
    }
}
int main(void)
{
    int arr[6] = {3, 2, 5, 7, 1, 6};
    merge_sort(arr, 0, 5);
    printf("The result is %d\n", num);
    print_array(arr, 6);
    return 0;
}
[/codes]
该算法的运行时间为nlog2(n)
Tags - 逆序对逆序对数 , 合并排序 ]]> http://www.nd21.com/read.php/71.htm <![CDATA[[c语言每日一学]Linux下c语言开发简介]]> Model.King <P.Qingliang@hotmail.com> Fri, 08 Aug 2008 08:14:51 +0000 http://www.nd21.com/read.php/71.htm /*************************************************************
** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-7
** 声明：笔记不是教程，这只是我系统c的记录而已，如有错
** 误，欢迎指正。
**
*************************************************************/

Linux下c语言开发教程

概述
机器语言  汇编语言  高级语言  第四代(4GL)，如sql，告诉计算机做什么而需要指挥计算机如何去做。

源代码  编译  连接  运行

C语言同时具有汇编语言和高级语言的优势，方便、灵活、效率高、功能强大

C语言适合于底层开发，如linux内核，嵌入式

Linux下c语言开发环境的构成
GNU的gcc编译器，glibc等等

编辑器：VI
编译器：选择GNU C/C++编译器gcc
调试器：应用广泛的gdb
函数库：glibc
系统头文件：glibc_header

Gcc是GNU CCompiler的缩写，能够编译c/c++源码

.c 为后缀的文件，c语言源文件文件
.h 头文件
.i 已经预处理过的c源代码文件
.o 编译后的目标文件
.s 汇编语言源代码文件

文件名不具有绝对约束文件类型的能力

gcc使用指令

gcc –o hello hello.c 把hello.c编译成文件名为hello的可执行文件
-c
-g

glibc包含一些附加包，如linuxThreads,locale,crypt ，是提供系统调用和基本函数的c库，如open，malloc，printf等，所有动态连接的程序都需要用到它

gcc依赖binutils和cpp包，另外make包在编译中也是经常用到的，
cpp,binutils,glibc,glibc kernheaders,glibc-common,glibc-devel,gcc,make

ls  /lib/libc-*
gcc –version

c程序包含可执行文件、包含文件、库文件，所以往往单独的拷贝一个可执行程序是无法正常运行的。

]]> http://www.nd21.com/read.php/70.htm <![CDATA[[算法每日一学]-算法基础之函数增长--2008.08.06]]> Model.King <P.Qingliang@hotmail.com> Thu, 07 Aug 2008 10:10:09 +0000 http://www.nd21.com/read.php/70.htm ** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-6
** 声明：笔记不是教程，这只是我系统学习算法的记录而已，如有错
** 误，欢迎指正。
**
*************************************************************/

检测算法的时间效率往往是在大规模的输入（n）的情况下进行，当n足够大时，研究算法的运行时间就趋向于研究算法的渐进效率了，因为我们没有必要进行过于精确的计算。在计算机中，有几种标准的方法用于简化算法的渐进分析。

渐进符号
  用以表示算法的渐进时间记号是域为自然数的函数。有时域的范围可以适当的扩充以获得更广的益处。

三种渐进符号：ΘΩΟ
f(n) = Θ(g(n)) 表示的是这样的一个集合：存在c1,c2，当n>n0时，有0 < c1g(n)

（图来自《算法导论》）
它实际上是确定了一个算法的运行时间渐进上界和渐进下界。

对应的Ω用于确定算法的渐进下界（最佳运行时间），Ο用于确定算法的渐进上界（最坏运行时间）

需要注意的是，实际上运行时间并非是n的函数，对于某个特定的n来说，运行时间与具体的输入有关，当我们用渐渐符号来表示算法运行时间时，实际上是在某个特定条件约束下说明的。

方程中的渐进符号
  方程中的渐进符号实际上相当于一个匿名函数f(n)，用于表示我们不关注的部分，因为我们没有必要写出我们不关心而又繁琐的某些细节部分（如低阶项）。

对于非精确上界渐进用符号o(g(n))表示，例如2n=o( ),而精确上界渐进则用符号Ο(g(n))表示，例如 .
w与Ω的关系同O与Ο。

Tags - 算法函数 ]]> http://www.nd21.com/read.php/69.htm <![CDATA[[算法每日一学]-算法基础入门--2008.08.06]]> Model.King <P.Qingliang@hotmail.com> Wed, 06 Aug 2008 02:18:07 +0000 http://www.nd21.com/read.php/69.htm ** 作者：P.Qingliang (P.Qingliang at msn.com)
** 创建时间： 2008-8-5
** 声明：笔记不是教程，这是我系统学习算法的记录而已
**
*************************************************************/

算法的定义
算法（Algorithm）是指在有限步骤内解决问题的一组明确定义的规则，通俗的说，就是计算机解决问题的过程。

算法的特点
  有穷性、确切性、输入、输出、可行性

  即使是错误的算法，当其错误率在可接受范围内时也就是认为是“正确”的算法。算法的描述一般是伪代码（类c，类c++，类pascal等等）来进行。

分析算法
  算法分析的重要内容：算法的复杂性，包括空间复杂性和时间复杂性，一般只讨论时间复杂性。所谓时间复杂性，简单的说就是指在一定的输入规模下算法执行的时间效率。通常我们分析算法时假定指令是一条接着一条的执行的，而没有并发操作，也就是所谓的RAM模型。

  相关术语：输入规模，运行时间，最坏情况

算法从排序开始
  插入排序c语言实现：
[codes=c]
#include

/**
* 插入排序算法 --- 从小到大
*/
void insertSort(int arr[], int size)
{
    int key, i, j, k;
    for(i=1; i    {
        j = i - 1;
        key = arr[i];
        while(key=0)
        {
            arr[j+1] = arr[j];//在遍历比较时就移动元素
j--;
        }

        arr[j+1] = key;
    }
}

/**
* 打印数组内容
*/
void printArray(int arr[], int size)
{
    int i;
    printf("********* Array print begin *********\r\n");
    for(i=0; i    {
        printf("array[%d] = %d\r\n", i, arr[i]);
    }
    printf("********* Array print end *********\r\n");
}

int main(void)
{
    int arr[10] = {22, 73, 54, 92, 14, 32, 65, 98, 55, 43};

    printArray(arr, 10);

    insertSort(arr, 10);

    printArray(arr, 10);

    return 0;
}
[/codes]

运行结果

********* Array print begin *********
array[0] = 22
array[1] = 73
array[2] = 54
array[3] = 92
array[4] = 14
array[5] = 32
array[6] = 65
array[7] = 98
array[8] = 55
array[9] = 43
********* Array print end *********
********* Array print begin *********
array[0] = 14
array[1] = 22
array[2] = 32
array[3] = 43
array[4] = 54
array[5] = 55
array[6] = 65
array[7] = 73
array[8] = 92
array[9] = 98
********* Array print end *********

Process returned 0 (0x0)   execution time : 0.031 s
Press any key to continue.

分析算法：
[codes=c]
void insertSort(int arr[], int n)
{
    int key, i, j, k;  // 执行1次，每次消耗时间t1
    for(i=1; i    {
        j = i - 1; //n – 1, c3
        key = arr[i]; // n – 1, c4
        while(key=0) // f(j, n), c5
        {
            arr[j+1] = arr[j];//在遍历比较时就移动元素  f(j, n) - 1, c6
j--; // f(j, n) - 1, c7
        }

        arr[j+1] = key; //n – 1, c8
    }
}
[/codes]
这里我们假设计算机执行每一步基本运算代码的时间都是个常量，在这里也就是c1, c2, c3……c8都是常量。
上面函数运行的时间总和是T = c1+ nc2+(n-1)c3+(n-1)c4+f(j, n)c5 + (f(j, n)-1)c6 + (f(j, n)-1)c7+(n-1)c8。
其中f(j, n) 是关于j，n的函数，其值同数组的排序程度有关，通常我们都假设为最坏情况，这里的最坏情况为初始数组按从大到小排序，这样f(j, n) =

最终我们得出 T = an*n + bn + c， a,b,c为常数。
利用高中的求极限的知识，我们得出T = f(n*n)，这样我们就得出了插入排序算法的时间复杂性公式。

算法设计
增量法，分治法等等

排序算法分治版
[codes=c]
#include
#include

#define ARRAY_SIZE 10000
#define RAND_SIZE 10000

/**
* 打印数组内容
*/
void printArray(int arr[], int size)
{
    int i;
    printf("********* Array print begin *********\r\n");
    for(i=0; i    {
        printf("array[%d] = %d\r\n", i, arr[i]);
    }
    printf("********* Array print end *********\r\n");
}

int mergeArray(int arr[], int begin, int mid, int end)
{
    if (arr[mid+1] > arr[mid])
    {
        return 0;
    }

    int i, j=mid+1;
    int key;

    for(j=j; j<=end; j++)
    {
        key = arr[j];
        i = j-1;
        while( arr[i] > key && i >= begin )
        {
            arr[i+1] = arr[i];
            i--;
        }
        arr[i+1] = key;
    }

    return 0;
}

/**
* 分治法排序，从小到大
*/
void divideSort(int arr[], int begin, int end)
{
    int iMid;
    if (begin < end)
    {
        iMid = (int)((end + begin)/2);
        divideSort(arr, begin, iMid);
        divideSort(arr, iMid+1, end);
        mergeArray(arr, begin, iMid, end);
    }
}

int main(void)
{
    int *pArr = malloc(sizeof(int)*ARRAY_SIZE);
    int i = 0;

    srand(RAND_SIZE);

    for(i=0; i    {
        pArr[i] = rand();
    }

    //printArray(arr, 10);

    divideSort(pArr, 0, 9);

    //printArray(arr, 10);

    return 0;
}

[/codes]
]]> http://www.nd21.com/read.php/68.htm <![CDATA[PHP变量安全小设置]]> Model.King <P.Qingliang@hotmail.com> Thu, 17 Jul 2008 21:36:58 +0000 http://www.nd21.com/read.php/68.htm [codes=php]
//服务器register_global打开情况下运行示范代码
var_dump($a);
if (@ini_get('register_globals'))
{
  foreach ($_REQUEST as $varName => $void)
  {
    unset(${$varName});
  }
}
var_dump($a);
var_dump($_GET['a']);
[/codes]

$_REQUEST 包含了$_GET，$_POST 和 $_COOKIE 中的全部内容，但是他们之间是相对独立的，所以即使unset了$_REQUEST 依然可以GET等。

本机测试效果：

string 'hello' (length=5)

null

string 'hello' (length=5)

较为完整的代码如下：
[codes=php]
  set_magic_quotes_runtime(0);
    //注销所有自动注册变量
    if (@ini_get('register_globals'))
    {
      foreach ($_REQUEST as $varName => $void)
      {
        unset(${$varName});
      }
    }
    //转义
    if (!get_magic_quotes_gpc())
    {
      adds($_GET);
      adds($_POST);
      adds($_COOKIES);
    }
    adds($_FILES);
[/codes]

adds code:
[codes=php]
/**
* 递归转义数组
*
* @param array $arr
*/
function adds(array &$arr)
{
  foreach ($arr as $key=>$value)
  {
    if (is_array($value))
    {
      adds($arr);
    }
    else
    {
      $arr[$key] = addslashes($value);
    }
  }
}
[/codes]
没有多少新意。对于转义可以用另一种方式：反转义自动转义字符串，在程序中所有需要的地方手工转义，至于这种方式有什么不同本人就不知道了。
Tags - php , addslashes , 转义 , 安全 ]]> http://www.nd21.com/read.php/67.htm <![CDATA[“人无信则不立“想到的]]> Model.King <P.Qingliang@hotmail.com> Wed, 16 Jul 2008 16:39:15 +0000 http://www.nd21.com/read.php/67.htm
      这是一个非常简单但又非常深刻的问题，说它简单是因为人人都明白这个道理，它看起来是如此的简单；说它深刻，是因为信的理解各不相同、做法各不相同、做到也十分的困难。一个人一旦有了“信”，别人对你的信任度就会增高，你在别人心目中的形象也会增高。例如在一个团队中，一个集体或者一个宿舍中，往往最有说服力的人都是有“信”的人。
信可分为两种：一是对别人，二是对自己。对别人，不食言、不欺骗等等。对自己，这个是我想重点讨论的。

平时的时候我们总有个这样那样的事情，我们自己回忆一下，发现完成了很多事情，失败了很多事情，也有很多事情依然拖拉着没有做或没有做完。我们习惯去制定计划，但是往往在热血沸腾之后再也没有去执行过自己的计划。统计数据表明一个某个领域内的专家所花的学习时间实际上是不超过2-5年的，这还不是绝对的时间，如果考虑到他每天真正的学习时间，假设每天有8个小时的时间在学习某个领域的课程，那么他花的时间也只有半年到1年多点的时间。但是实际当中很少有人能够在专业的领域花长时间专注的去学习，例如大学生，往往四年都是在各种各样的活动、娱乐中度过的（并不是说不娱乐，只不过娱乐也是有限度的，娱乐也是要有物质基础的），而能做到长时间坚持的人都成了“牛人”。经常性的有菜鸟问大牛：你是怎么学的？有什么好方法介绍么？，呵呵，这个时候除非是天才一类的人物（毕竟很少）一般都是懒得回答的，因为在他们看来，专注与勤奋实在是很简单的道理。
从我的身边我收集不少做事不能坚持、不能按时完成的原因：1.总觉得世界在变，自己的计划跟不上变化 2.觉得有些事情并不如想象的那么重要 3.做了一段时间，觉得难度大，觉得厌烦，无法坚持 4.自身性格导致。我希望能够就这些原因给出我自己的看法、体会等。
1.  总觉得世界在变，自己的计划跟不上变化
世界在变这是毋庸置疑的，我是学计算机的，计算机的技术日新月异，各种新的专业名词母鸡下蛋似的出现。
假如，如果你觉得你的计划跟不上变化，那么你应该根据你执行计划中的所得去修改你的计划或者直接放弃原有计划重新开始另外一份计划，但是一定要有记录和原因说明，作为以后的参考。如果接二连三的你觉得你的计划还是跟不上变化，那么我想你在认知上本身是有些问题的：认识新潮流。很多时候我们没有一直跟着最新的潮流走，只要我们觉得我们所学有用即可；更何况，潮流往往是某一部分人的潮流。例如：众多同学在选择编程语言时都会问诸如：我是选C++好呢还是Java好呢？比较潮流的做法是选择Java，因为Java最近这些年的发展势头很好，市场占有率第一，而C++是比较古老的语言了。没错这些都是对的，但这不是你选择语言时考虑的理由，或者说你不应该考虑这部分太多。每种语言都有其专长的领域，存在必然有其道理，往往抨击另外一种语言的人对他所抨击的语言都不是很了解，起码不是该语言的专家，他们的评论往往带有过多的感情色彩。在我看来，真正想要体会一门语言，自己学才是最好的方式，
学习并不是只是一味的看、读、模仿等等，更多的是思考与实践。
2.  觉得有些事情并不如想象的那么重要
这是很多人经常性遇到的问题，也是一类很正常的问题。对于这种问题，采用一种简单的方法可能比较好解决。在决定之前使用如下方法给予事情评断：标示重要程度：1.很重要而且立刻要做 2.很重要但不是马上要做 3.不重要但必须马上要做 4.不重要也不是必须要做    判断先后顺序：1 >  3 > 2 > 4 或者1 > 2 > 3 > 4，你可以在对事情的性质进行进一步的标示。通常情况下，如果我们遇到4就直接放弃掉，除非时间非常充足或者其他特殊的原因。以此来去除一些不必要的决定。
3.  做了一段时间，觉得难度大，觉得厌烦，无法坚持
这个也是常见的问题。很多事情都是如此，看起来简单，做起来相当的困难，这个时候除了自律之外，似乎没有什么好方法可以将计划执行下去。这里的自律法是指：相信自己能完成，觉得自己必须要完成，这个是自己对自己的挑战。同时可能还需要其他的一些辅助手段，例如：每次学习都必须达到2个小时，每次学习历程都必须完成8-16个循环等等。在我个人看来，很难的东西就算草草的学一遍对于以后也是有好处的，这是人类学习的特点导致的（人在看到某些熟悉的东西，尽管之前不能理解，也可能会很快的学会）。
4.  自身性格导致
某些人的性格就是无法长时间的坚持某件事或者喜欢“勾三搭四”的或者就是喜欢拖拖拉拉的，这个在我看来是最难克服的一点，我在我自己的身上看到了它的影子。有时我决定了第二天要把某件事情办好，因为我觉得我应该将那件事情办好，这是我自己的锻炼，可是到了第二天，我可能会想：没关系，反正不做也关系不大，以后可以再做，又或者一件另外的事情将它耽搁了，之后就忘记了，过了很多天才想起来。这样的例子非常的常见的，总的来说是由于没有养成“果断”的性格、平时缺少计划与思考导致的。做事不果断，很多事情就不能及时高效的完成，缺少思考和计划就可能会因为没有充分考虑某些事情，没有一个比较好的方案而延误时间，从而打断了原有的计划。

  看了我说了这么多，很多人我想都会说：你就说说。的确这些都是说起来容易，做起来难的事情，但并不是没有办法去解决的。最起码在我身上我已经看到了一些效果。如果你想克服上面的缺点，最少你应该有个方式来提醒你做的决定，然后是给自己适当的压力来完成自己的决定。例如：将决定写成一张表格，挂在显眼处，然后告诉自己周围的人如女友，舍友等你的计划，让他们监督你。方法有很多，看你有没有那份决心。记住：没有人会笑话你上进，如果真的有人这样，那么不是玩笑就是嫉妒了。

]]> http://www.nd21.com/read.php/65.htm <![CDATA[[原创]设计分发器（Dispatcher）--- PHP框架编写123]]> P.Qingliang <p.qingliang@hotmail.com> Thu, 03 Jul 2008 14:28:00 +0000 http://www.nd21.com/read.php/65.htm 有了对MVC模式的简单认识，我们就可以正式开始框架的设计了（参见http://www.nd21.com/read.php/61.htm）。
从上面链接的示范代码中我们可以大致的了解分发器的职责：解析web端请求（GET方式）为某个控制的动作，也就是简单的路由功能。其次，分发器还需要将更多的请求参数传递给控制器，能够提供出错处理（当控制器或者控制器的方法不存在时），能够进行重定向等等功能。我们可以根据这些定义出分发器的基本框架：

[codes=php]
class N_Dispatcher_Abstract
{
  /**
   * 客户端的请求信息
   *
   * @var array
   */
  protected $_request;

  /**
   * 请求信息备份
   *
   * @var array
   */
  protected $_requestBackup;

  /**
   * 控制器名称
   *
   * @var string
   */
  protected $_controllerName;

  /**
   * 动作名
   *
   * @var string
   */
  protected $_actionName;

  /**
   * 获得请求的控制器名称
   *
   */
  protected function _getController($ifAdmin = false)
  {
    $controllerKeyName = N::getAppIni('controllerTrigger');
    $this->_request = array_change_key_case($this->_request, CASE_LOWER);
    //如果没有指定controller，则使用默认的controller
    $this->_controllerName = !empty($this->_request[$controllerKeyName])
            ? $this->_request[$controllerKeyName]
            : N::getAppIni('defaultController');
    //添加前缀
    $controllerNamePrefix = N::getAppIni('controllerNamePrefix');
    $this->_controllerName = $controllerNamePrefix.ucfirst(strtolower($this->_controllerName));

    /**
     * 这里我们假设前台文件（控制器，模型，视图）都置于根目录的APP文件夹下
     * 后台文件全部置于根目录的ADMIN文件下
     * 如果希望前后台文件都位于同一个文件夹下，请修改N/Congfig/IniMapping.php下的ADMIN_MVC_ROOT_NAME选项，
     * 如果ADMIN_MVC_ROOT_NAME和APP_MVC_ROOT_NAME都设置为APP，则表示站点的前后台文件都位于根目录的APP文件
     * 夹下
     */
    $this->_controllerName = $ifAdmin
            ?  N::getAppIni('ADMIN_MVC_ROOT_NAME').'_'.$this->_controllerName
            : N::getAppIni('APP_MVC_ROOT_NAME').'_'.$this->_controllerName;
  }

  /**
   * 从请求中获得action名
   *
   */
  protected function _getAction()
  {
    $actionKeyName = N::getAppIni('actionTriggerName');
    $actionPrefix = N::getAppIni('actionNamePrefix');
    //如果没有指定action，则使用默认的action
    if (N::getAppIni('urlLowerCase'))
    {
      $this->_actionName = $this->_request[$actionKeyName] ? $actionPrefix.ucfirst($this->_request[$actionKeyName]) : N::getAppIni('defaultAction');
    }
    else
    {
      $this->_actionName = $this->_request[$actionKeyName] ? $actionPrefix.$this->_request[$actionKeyName] : N::getAppIni('defaultAction');
    }
  }

  /**
   * 路由请求
   *
   */
  public function dispatching()
  {
    //保存请求信息
    $this->_request = $_GET;
    $this->_requestBackup = $_GET;
    $ifAdmin = (isset($this->_request[N::getAppIni('adminTrigger')]) && !empty($this->_request[N::getAppIni('adminTrigger')]));
    $this->_getController($ifAdmin);
    $this->_getAction();
    try
    {
      $this->_forward();
    }
    catch (Exception $e)
    {
      if (DEBUG_MODE)
      {
        print $e->getMessage();
      }
      $this->_onControllerNotExists();
    }
  }

  /**
   * 执行指定控制器的指定方法
   *
   */
  protected function _forward()
  {
    $controller = $this->_controllerName;
    N::LoadClass($controller);
    $action = $this->_actionName;
    $controllerObj = new $controller($this->_requestBackup, $action);
    if (!method_exists($controllerObj, $action))
    {
      throw new Exception('控制器'.$controller.'不存在方法'.$action);
    }
    $controllerObj->$action($action);
  }


  /**
   * 控制器或其方法不存在时的异常处理函数
   *
   */
  protected function _onControllerNotExists()
  {
    /**
    $this->_controllerName = N::getAppIni('APP_MVC_ROOT_NAME').'_'.N::getAppIni('controllerNamePrefix').N::getAppIni('defaultController');
    $this->_actionName = N::getAppIni('defaultAction');
    $this->_requestBackup = array();
    $this->_forward();
    */
    N::loadClass('N_Controller_Abstract');
    N_Controller_Abstract::redirectTo(N_Controller_Abstract::url('index'));
  }
?>

[/codes]
代码的执行过程很简单：
分发器开始工作 --> 获得控制器 -->获得方法 -->执行指定的控制器的指定方法
另外我们提供了一个_onControllerNotExists 方法，相当于一个回调函数（我们可以将它设计成一个回调函数），当控制器指定方法出错时会被调用。这样我们的分发器就可以工作了。

注意到我在类中很多方法和属性都设计成protected类型，用意是希望用户根据自己的要求派生分发器类，例如需要权限控制的分发器。
Tags - php , framework , 框架 , 分发器 , dispatch , dispatcher ]]> http://www.nd21.com/read.php/64.htm <![CDATA[[原创]一些基本设定和框架总体设计---PHP框架编写123]]> P.Qingliang <p.qingliang@hotmail.com> Fri, 27 Jun 2008 16:50:09 +0000 http://www.nd21.com/read.php/64.htm 一些基本的要求和设定
为了使用某些比较特殊的功能以及交流上的方便，我们进行了一些约定。
在这里，首先我们要求PHP的版本至少是5.0，我们推荐版本在5.1或以上， 5.1在性能上比5.0要快得多。其次，我们要进行一些基本的约定：
1.  类命名：

类的命名我们采用如下的方法：
N_Controller_Abstract
这个类的名字包含了它的路径，它应该位于导入的某个类路径（Class Path）下的N/Controller/Abstract.php文件中。

2.  类路径（Class Path）：

你可以将类路径看成类似与include_path的一样东西，当我们寻找某个类时，我们会先根据类的名称产生一个类名称路径（类似上面的N/Controller/Abstract.php），然后依次在类路径下寻找。

3.  命名方式：

我们采用的是类似这样的方法、函数命名方式：
getFileExt
而不是
GetFileExt
也不是
get_file_ext

框架总体
  我们先简单的将MVC的执行过程封装起来，为次我们需要另外一个类，我们暂时命名为N，类实现放在N.php文件中，所有的文件都置于N文件夹下，它的所有方法我们都设计为静态方法，这样不需要实例化就可以直接调用它的方法：

[codes=php]
class N
{
  /**
   * 是否首次运行程序
   *
   * @var boolean
   */
  static private $firstRun = true;

/**
   * MVC启动入口
   *
   */
  static public function runMVC()
  {
    $dispatcher = new $dispatcherClass();
    $dispatcher->dispatching();
  }

  /**
   * 在程序的开始必须首先调用该函数，用以初始化各种参数
   *
   */
  static public function init()
  {
    if (!self::$firstRun) return;
    self::$firstRun = false;
    //初始化环境代码，之后添加
  }
}
?>
[/codes]

是的，一个框架的启动类就是这么简单，当然要实际的运行还需要添加诸多功能，下面我们开发为其添加一些必要的东西。

首先是类的寻找问题，根据我们前面的约定，我们已经可以很轻松的知道类的路径了，但是计算机不知道。在PHP5及其之后的版本，提供了autoload功能，即使你不主动加载类文件，php引擎也会帮助你寻找指定的类文件的，它很方便，只是牺牲了一定的效率，我们建议在任何需要的时候主动加载类，因为某些时候自动寻找类可能是相当费时的，当然你不是必须这样做。为了能够主动加载类，我们需要提供一个方法来主动加载，因为N是整个框架运行的基点，所以我们可以将加载类作为它的一个静态方法来实现，最初版本：
[codes=php]

static public function LoadClass($className)
  {
    if (class_exists($className, false) || interface_exists($className, false))
    {//已经加载则直接返回
      return true;
    }
    $classPath = './'.str_replace('_', '/', $className).'.php';
    if (is_readable($classPath))
    {
      require_once($classPath);
      return true;
    }
    throw new Exception('Class file not exists!Class Name:'.$className);
  }
[/codes]
这样PHP会在./N/Controller/Abstract.php文件中寻找N_Controller_Abstract类，但是问题来了，如果我们N文件夹不是放在根目录下，例如是放在Libs文件夹下，那么PHP就会抛出异常表示该类找不到。

上面是两种常见的目录安排方式（有些为了安全考虑，甚至将库文件放在站点根目录之外）。第一种N文件夹在根目录下（learning为根目录），第二种在根目录的Libs/文件夹下(schoolPlant为根目录)。我们的N.php是被首页文件（假设为index.php）直接包含了，所以文件包含也是相对index.php的。为了解决这个问题，我们需要导入一些目录作为类目录，下面展示了部分修改后的N类：
[codes=php]

class N
{
  /**
   * 是否首次运行程序
   *
   * @var boolean
   */
  static private $firstRun = true;

  static private $_import = array('.');

  /**
   * 包含指定类到程序中，类名称相对根文件夹命名，如：
   * $rootDir参数为APP，则该目录下的类Model_Index，应位于Model子文件夹中，
   * 且文件名为Index.php
   *
   * @param string $className
   * @param string $rootDir
   */
  static public function LoadClass($className)
  {
    if (class_exists($className, false) || interface_exists($className, false))
    {
      return true;
    }

    foreach (self::$_import as $dir)
    {
      $classPath = $dir.'/'.str_replace('_', '/', $className).'.php';
      if (is_readable($classPath))
      {
        require_once($classPath);
        return true;
      }
    }

    throw new Exception('Class file not exists!Class Name:'.$className);
  }

  public function import($dir)
  {
    array_push(self::$_import, $dir);
  }
[/codes]
这样我们只要在index.php文件中加入如下代码即可寻找到我们的类文件了：
[codes=php]

require('Libs/N/N.php');
define('APP_ROOT', dirname(__FILE__) . DS);
N::import('./Libs');
N::init();
N::runMVC();

[/codes]
另外我们还需要给类添加配置控制功能，对于任何框架都是需要可伸缩的配置功能的。直接看代码吧：（省略重复代码）

[codes=php]

class N
{
  /**
   * 是否首次运行程序
   *
   * @var boolean
   */
  static private $firstRun = true;

  static private $_import = array('.');

  static private $_ini = array();

  /**
   * 使用文件导入程序全局配置，可以批量导入配置，避免每次调用setAppIni函数的麻烦
   *
   */
  static public function loadAppIni()
  {
    $args = func_get_args();
    $numOfArgs = sizeof($args);
    if ($numOfArgs === 2)
    //导入的配置是采用名称/值对的形式
    {
      $index = $args[0];
      $value = $args[1];
      if (is_array($index) && is_array($value))
      {
        $tmpArr = array_combine($index, $value);
        $this->_ini = array_merge($this->_ini, $tmpArr);
      }
      else if (is_string($index) && is_string($value))
      {
        $this->_ini = array_merge($this->_ini, array($index=>$value));
      }
    }
    else if ($numOfArgs === 1)
    {
      $value = $args[0];
      if (is_array($value))
      {
        $this->_ini = array_merge($this->_ini, $value);
      }
      else
      //如果是文件路径
      {
        if (file_exists($value) && is_readable($value))
        {
          $tmpArr = require_once($value);
          $this->_ini = array_merge($this->_ini, $tmpArr);
        }
      }
    }
}

  /**
   * 获取某项全局配置值
   *
   * @param string $iniStr
   * @param bool $autoInitClass
   * @param string $default
   * @return string
   */
  static public function getAppIni($iniStr, $autoInitClass = false, $default = NULL)
  {
    $rtn = !empty(self::$_ini[$iniStr]) ? self::$_ini[$iniStr] : $default;

    //如果自动初始化类
    if ($autoInitClass)
    {
      self::LoadClass($rtn);
    }
    return $rtn;
  }
[/codes]
loadAppIni方法有两种传参方式，由于php本身不支持重载，所以我们采用了一些技巧来实现，关键的代码就是func_get_args()。一种是直接传递文件名，文件的内容应该类似下面的格式：
[codes=php]

return array(
    //url中controller的键名，如:index.php?con=xxxx，则controllerTrigger为con
    'controllerTrigger' => 'con',
    //同上
    'actionTriggerName' => 'action',
    'adminTrigger' => 'cp',
    //默认的控制，没有前缀，使用时需要在前连接controllerNamePrefix，首字母大写
    'defaultController' => 'Index',
    //同上
    'defaultAction' => 'actionShow',
[/codes]

这样我们require之后，就直接得到了一个数组，将它合并到N类的$_ini属性中之后就可以方便的通过数组索引来访问配置了。
另一种方式是传递键值对，例如 N::loadAppIni(‘defaultControllerName’, ‘index’);

现在我们就可以在类N的init方法中添加一些其他的初始化代码了：
[codes=php]

/**
   * 在程序的开始必须首先调用该函数，用以初始化各种参数
   *
   */
  static public function init()
  {
    if (!self::$firstRun) return;
    self::$firstRun = false;
    //初始化环境：必要文件的包含，基本设置
    N::loadAppIni(N_RUNTIME_ROOT.'Config/IniMapping.php');
    N::loadAppIni(N_RUNTIME_ROOT.'Config/DataMapping.php');
    N::loadAppIni(N_RUNTIME_ROOT.'Config/ClassMapping.php');
    N::loadAppIni(N_RUNTIME_ROOT.'Config/TableMapping.php');
    //5.1以后版本，设置时区
    if (floatval(PHP_VERSION) >= 5.1)
    {
      date_default_timezone_set(N::getAppIni('default_timezone'));
    }
}
[/codes]

在这里，我尽量少的使用全局变量，而更多的是用类N的成员变量来保存某些全局配置，原因有二：1.我们尽量的希望以面向对象的方法来实现，在这里完全没有必要使用全局变量来保存 2.为了防止直接修改某些重要的全局配置，使用约定方式修改比直接修改往往要安全的多。另外一个算不上原因的原因是PHP6将取消对全局变量的支持。

里面的几个文件我打包一下，在文章的最后面可以下载。

到这里N类的功能已经可以正常的运行一个框架了，在之后的过程中，我们还会添加一些需要的功能。

下一篇我们开始丰富各个MVC组件的功能。

点击这里下载文件

Tags - php , framework , 总体设计 ]]> http://www.nd21.com/read.php/63.htm <![CDATA[PHP页面静态化的两种方式]]> P.Qingliang <p.qingliang@hotmail.com> Thu, 26 Jun 2008 03:05:10 +0000 http://www.nd21.com/read.php/63.htm
在我的总结有两种主要的方式，其他的还没有发现，如果你有第三种可行的方案，请给我发一份示意代码，谢谢。（代码使用PHPLIB template示范）

第一种方式：由控制器来调用单独的缓存类。在这个时候缓存类是一个单独的类，与模板引擎相对独立，在一个请求开始的时候，缓存类即被调用，并进行一些相关的缓存操作。这一工作甚至可以直接在调度器中完成（如果存在调度器dispatcher的话）。下面给出一个简单的代码示范（只有框架）：

[codes=php]
class WebController
{
  public function actionIndex()
  {
    //实例化静态缓存类，缓存类初始化时要决定是否启用缓存，这里略过
    $cache = new HtmlCache();
    if (!$cache->enableCache)
    //没有启用缓存
    {
      //调用模型层、视图层来完成请求
    }
    else
    //启动了缓存
    {
      if ($cache->isCached)
      //如果文件已经被缓存
      {
        //重定向到缓存文件,getCacheFile方法根据url生成一个唯一的静态文件名
        header('Location:'.$cache->getCacheFile($_SERVER['REQUEST_URI']));
        return;
      }
      else
      //如果文件还没有被缓存，则我们需要创建该文件并写入内容
      {
        //下面三行代码使用的PHPLIB template的代码
        $tpl->set_file('index', 'index.html');//载入模板文件
        $tpl->set_var('title', 'Hello world');//赋值
        $html = $this->parse('indexHtml', 'index');//解析模板文件并返回解析结构字符串
        //$html变量包含了文件的内容，writeCache方法将其写入到文件
        $cache->writeCache($html);
        //重定向
        header('Location:'.$cache->getCacheFile($_SERVER['REQUEST_URI']));
      }
    }
  }
}
[/codes]

第二种方法：由模板类来控制缓存。对于任何请求，控制器都直接调用模板类来完成工作，由模板类自己完成与缓存相关的工作。下面的代码我只列出框架：

[codes=php]

class N_View_CacheTemplate extends Template_PHPLIB
{
  /**
   * html静态化目录，相对于系统根目录
   *
   * @var string
   */
  protected $cacheDir = './cache/';

  /**
   * 是否打开静态缓存
   *
   * @var bool
   */
  protected $enableCache = false;

  /**
   * 页面缓存时间
   *
   * @var int
   */
  protected $cacheTime = 900;

  protected $htmlFullPathName;

  protected $htmlFileName;

/**
   * 如果该选项打开，则在解析模板之后，自动生成对应缓存静态文件
   *
   * @var unknown_type
   */
  private $_autoCache = false;


  public function __construct($enableCache = false, $root = ".", $unknowns = "remove")
  {
    parent::__construct($root, $unknowns);
    $this->enableCache = $enableCache;
    $this->_cache();
  }

  /**
   * 返回当前对象实例
   *
   * @return N_View_CacheTemplate
   */
  public function getInstance()
  {
    return getInstanceOf(__CLASS__);
  }

  /**
  * 开始缓存调用
  */
  private function _cache()
  {
    if ($this->enableCache)
    {
      if (!$this->isCached)
      {
        $this->_writeCache();
      }
      header(‘Location:’.$this->cacheDir().$this->htmlFileName);
    }
}

  //检测是否已经缓存了
  public function isCached()
  {
  }

  //生成缓存
  private function _writeCache()
  {
  }

//更新缓存
  private function _updateCache()
  {
  }

[/codes]

两种方式各有特点，从功能上来说：
第一种方式（独立缓存类）可较大程度的控制缓存，无论是否使用模板引擎、无论使用哪种模板引擎，对其都几乎没有影响。如果模板引擎本身也提供静态缓存功能，则直接关闭模板缓存功能即可；
第二种方式由于缓存功能是嵌入在模板引擎之内的，对于每一步的页面生成都能很好的把握，所以可以更好的定制输出信息。
两种方式在核心处理上是一样的，区别只是他们的在模式中定位的不同，这在框架的编写中是必须要考虑的。

Tags - php , 缓存 , 静态化 , 静态 ]]> http://www.nd21.com/read.php/62.htm <![CDATA[[小备忘]接口与实现类]]> P.Qingliang <p.qingliang@hotmail.com> Tue, 24 Jun 2008 06:53:07 +0000 http://www.nd21.com/read.php/62.htm
PHP中，接口定义如下：
[codes=php]
interface ITest
{
  function test1();
}
[/codes]

如果是一个抽象类实现了某个接口，由于抽象类本身不能实例化，所以不需要抽象类实现所有的接口方法，如下代码可以正常运行：
[codes=php]
interface ITest
{
  function test1();
}

abstract class A implements ITest
{

}

[/codes]

但是如果是一个具体类实现某个接口，则必须实现所有接口的方法。如下代码不能正常运行：
[codes=php]
interface ITest
{
  function test1();
}

class C implements ITest
{

}
[/codes]

一点点基础知识，用来备忘。

Tags - 接口 , 抽象类 , php ]]> http://www.nd21.com/read.php/61.htm <![CDATA[[原创] web中的 MVC模式 --- PHP框架编写123]]> P.Qingliang <p.qingliang@hotmail.com> Sat, 14 Jun 2008 12:22:43 +0000 http://www.nd21.com/read.php/61.htm     简单的来说，设计模式是指针对我们周围经常出现的一些问题的通用解决方案。

    在这里我们采用的是被动MVC架构模式（微软的称呼为MVP模式），它是MVC模式的一个变种。如果你还不了解它，那么这里有两篇文章可以供参考：
    1. http://www.phpwact.org/pattern/model_view_controller
      2. http://www.microsoft.com/china/msdn/library/architecture/architecture/architecturetopic/MVP.mspx?mfr=true

      MVC是一种概念比较模糊的设计模式，所以往往带有着比较浓厚的个人理解色彩，所以我们经常会看到实现不一的MVC框架，这并不是很重要，只要是符合它的初衷，适合当前的环境即可。在理解MVC时，最好结合代码来理解。顺便提一下：你只需要明白它的运行过程即可，对于为什么用它、有哪些优势可能不是短期内能够体会得到的。

这是被动MVC模式下，一个php请求的执行过程.

简单的代码示范：

[codes=php]
class Dispatcher
{
  public function dispatchering()
  {
    $o = new Controller();
    $o->actionExample();
    //这里应该通过请求来实例化指定的控制器，这里我们简单的以Controller来示范
    //你可以自己从Controller派生子类来实现指定请求，形如：
    //$controller = $this->getController();
    //$action = $this->getAction;
    //$o = new $controller();
    //$controller->$action();
  }
}

class Controller
{
  private $_tpl;

  private $_model;

  public function __construct()
  {
    $this->_tpl = new View();
    $this->_model = new Model();
  }

  public function actionExample()
  {
    $str = $this->_model->get();
    $this->_tpl->display($str);
  }

  public function actionOthers()
  {

  }
}

class View
{
  public function display($str)
  {
    echo $str;
  }
}

class Model
{
  public function create()
  {

  }

  public function insert()
  {

  }

  public function update()
  {

  }

  public function get()
  {
    return "Hello world";//实际当中可能是从数据库、文本等取出数据
  }

  public function otherFunctions()
  {

  }
}

$run = new Dispatcher();
$run->dispatchering();
[/codes]


]]> http://www.nd21.com/read.php/60.htm <![CDATA[[原创]  PHP项目开发方式 ---  PHP框架编写123 ]]> P.Qingliang <p.qingliang@hotmail.com> Sat, 14 Jun 2008 10:08:16 +0000 http://www.nd21.com/read.php/60.htm 感谢李学成师兄.

PS: 只是说说我的历程.

随着视野的扩大, 我开发php项目的方式也在不断的改变. 也许还有更多, 只是我没发现. 下面是我的一些改变历程:

1.最初: 采用的是php+html混写的方式编码, 那个时候不知道什么是面向对象, 也不知道函数式编程其实就是面向过程. 所有项目都是采用累积式的函数编写, 稍稍的有一些模块分解的思想. 每一个函数的完成都能让我觉得什么的兴奋. 代码类似:
[codes=php]
if (some codes)
{
    echo '....';
}
[/codes]

2.起步: 后来偶然间看到了强大的pw, 试着去阅读他的代码, 突然发现自己之前所学的都是破烂. 在pw身上我知道了什么是模板, 什么是库, 怎么样去安排代码复用.
[codes=php]
include "table.php";
......
[/codes]

3.实践: 终于我开始了我一个不算正式的项目, 一个小公司的网站, 我尝试着采用pw的模板和库方式去做, 呵呵, 很幸运的, 虽然有些困难, 但最终我还是成功了.  但是重复了几个类似的项目之后, 我累了, 不是我不够耐心, 而是重复写的代码太多, 即使是采用库的方式, 而且对于界面与功能的整合经常让我焦头烂额.

4.成长: 终于意识到问题了, gg了很多, 看到了采用 class + template 的方式, 这个时候才知道什么是面向对象. 因为当初我看的是php4, 几乎没有介绍到面向对象的任何内容.
      面向对象是个非常庞大的理论体系, 学的越深越发觉他的好, 当然这不是对面向过程的否认, 他们本身并不冲突.  在这个阶段我停留的最久.

5. 现在: 人往高处走, 不可否认的, 架构师站得角度的确要比编码人员高, 为了更高的编码效率, 更好的复用, 更好的团队合作, 我开始学习设计模式,架构模式. 这也是我一直到现在还在深入的领域. 设计模式的学习才能更加深刻的理解面向对象, 面向对象不仅仅是类与对象那么的简单, 那些只是它的一小部分. 在这一部分的学习里, 最多的得益来自于fleaphp (http://www.fleaphp.org). 这是一个非常优秀的国产轻量级开发框架, 可以极大地提高项目的开发速度, 更多的是可以学习多众多优秀的架构思想与编程模式.

今天忽然打算将之前学习的全部整理出来, 所以就有了这篇以及之后的文章.
]]> http://www.nd21.com/read.php/59.htm <![CDATA[[原创] PHP框架编写123 总目录]]> P.Qingliang <p.qingliang@hotmail.com> Sat, 14 Jun 2008 09:40:26 +0000 http://www.nd21.com/read.php/59.htm 这是一项大的工程, 水平所限难免会有错误, 欢迎各位朋友指正.

声明: 这个系列的文章包含我学习php的一些经验和总结, 更多的是探讨与深入.

内容：
学习到今天的php，很多东西觉得需要整理一下。这个系列的文章是我自我检验关于设计模式和框架的一些基本想法，很多地方都是分析fleaphp和zf得到的结果，当然也借鉴了其他的一些框架的优秀思想。

这里是汇总目录, 便于查阅:

目录:
1. php项目开发方式
2.web中的 MVC模式 --- PHP框架编写123 [2008-06-27更新]
3. 一些基本设定和框架总体设计---PHP框架编写123 [2008-06-28更新]
4.设计分发器（Dispatcher）--- PHP框架编写123 [2008-07-03更新]

Tags - php , framework , mvc , 框架 , 框架编写 , 自己编写 , php框架 ]]> http://www.nd21.com/read.php/58.htm <![CDATA[服务器前两天被D,现已恢复]]> P.Qingliang <p.qingliang@hotmail.com> Tue, 10 Jun 2008 05:09:17 +0000 http://www.nd21.com/read.php/58.htm http://www.nd21.com/read.php/57.htm <![CDATA[[强推][转帖]CSDN应当减少娱乐化，端正态度，提高水准]]> P.Qingliang <p.qingliang@hotmail.com> Sun, 08 Jun 2008 04:47:13 +0000 http://www.nd21.com/read.php/57.htm

帖子内容：

引用

今天CSDN头条上有篇文章

《国际：身处两难境地，PHP该走向何方？》
http://news.csdn.net/n/20080606/116556.html

文章来源于一个博客，作者因为招不到合格的PHP程序员，发了一通牢骚。

原文标题是：Where did all the PHP programmers go? (PHP程序员都到哪去了)，而CSDN居然翻译成“国际：身处两难境地，PHP 该走向何方？”这加上了“国际”，把“PHP程序员”换成了“PHP”，整个味道全变了，搞得好像什么很正式的国际评论，即没有真实反映原文作者的意图，又误导了国内的读者。

这篇文章反映了CSDN的不少问题：

1。不熟悉国际开源社区，有一定技术偏向；

我不知道CSDN的新闻来源是什么，但感觉CSDN在Linux，PHP这两方面应该说和国际社区太脱节了。大部分信息是Java、.NET相关，Linux/Unix/PHP方面的精品文章很少。这和我在欧洲的感觉完全不同。欧洲各种开源技术的User Group都很活跃，Linux和PHP的信息到处可见。CSDN本身基于Windows/.NET开发，也许这也是一个原因。但我想一个号称“中国最大的IT技术社区”，眼光不应该太狭隘。

CSDN选的这篇文章，来自一个对于PHP根本不怎么了解的公司招聘者，对于我们真正的PHP程序员来说，he is just a nobody，根本是一个无足轻重的小人物，这篇博客更不能代表“PHP 该走向何方”。技术社区的新闻来源要有一定的权威性。　如果真要关注PHP最新的发展，请上php.net或者几个大牛的博客，或者加入内部团队的邮件列表。

2。娱乐化倾向

我相信网络时代，吸引眼球、提高流量对于每个网站都是重要的，但是技术社区娱乐化，绝对不是个好主意。技术社区应该具备一定的严谨性，不可像娱乐八卦那样信口开河。因为娱乐新闻只是大家在茶余饭后的谈资，就算说错了，对于彼此来说不会有太大影响。人家明星如何和我们老百姓有啥关系。　但是技术社区的文章，如果也信口胡说，会严重误导读者，特别是那些新入门的开发者。对他们来说，“哪种语言是最优秀的，哪种语言是不好的”，这些有很重要的意义。也正因为如此，非常容易受到误导。（比如最最常见的说法是“PHP做小网站好用、但开发复杂的网站和大网站得用Java”，一般别人问我这种看法是否正确，我都让他们自己估计一下未来的网站会不会比facebook拥有更多用户，更大流量和更复杂的应用逻辑，因为facebook是用PHP开发的。）

现在PHP一直很流行，甚至上面提到的，号称Google之后最伟大WEB应用的“Facebook”，也是用PHP开发的。而CSDN的这篇文章却说“PHP已经过时”（英文原文是PHP is getting mature，PHP日渐成熟，这里是一个明显的翻译错误），这岂不是让人感到莫名其妙？这到底是编辑的英文水平太低，还是因为对PHP有偏见？　如果是编辑水平太低，请努力，如果是态度问题，真的需要反省一下。

短期的娱乐化运作，可能会带来更多人气，但长此以往，就会使CSDN在技术圈内失去公信力。已经有很多朋友和我说“CSDN编辑水平太低，经常胡扯，这个社区里菜鸟居多”。　这是非常糟糕的问题，CSDN应该像IBM DeveloperWorks那样，成为精品的代名词才行。

PS. 我从04年开始在CSDN写blog，感觉到CSDN越来越好（最直观的是博客系统，然后社区人数，线下活动等）。CSDN对国内技术社区的贡献还是很大的。

我也是CSDN WEB频道和Java频道的“专家”（虽然自认为水平一般），所以觉得应该把自己的想法说出来，供参考，希望CSDN在已有基础上精益求精。

]]> http://www.nd21.com/read.php/56.htm <![CDATA[来自Adobe的DIV水平、垂直居中代码]]> P.Qingliang <p.qingliang@hotmail.com> Mon, 02 Jun 2008 23:40:52 +0000 http://www.nd21.com/read.php/56.htm [codes=html]
div#main {
  position: absolute;
  left: 50%;
  top: 50%;
  margin-left: -478px;
  margin-top: -325px;
  text-align: center;
  width: 955px;
  height: 650px;
  border: 1px #CCCCCC solid;
}
[/codes]

避免了为了兼容FF,IE要设置父子DIV属性的问题。当然这段代码也有小小的限制：如果你的容器的高度超过了浏览器的屏幕高度，则需要在外面再套一层容器。
Tags - div , 居中 , 水平 , 垂直 ]]> http://www.nd21.com/read.php/55.htm <![CDATA[[强推]飞升之后]]> P.Qingliang <p.qingliang@hotmail.com> Sun, 01 Jun 2008 02:57:28 +0000 http://www.nd21.com/read.php/55.htm http://www.qidian.com/Book/144549.aspx ]]> http://www.nd21.com/read.php/54.htm <![CDATA[[强推历史穿越小说]极品家丁]]> P.Qingliang <p.qingliang@hotmail.com> Sun, 01 Jun 2008 02:55:53 +0000 http://www.nd21.com/read.php/54.htm
嘿嘿，YY+智谋

http://www.qidian.com/Book/105199.aspx ]]> http://www.nd21.com/read.php/52.htm <![CDATA[[CSS笔记]块级元素与内联元素]]> P.Qingliang <p.qingliang@hotmail.com> Thu, 29 May 2008 08:40:12 +0000 http://www.nd21.com/read.php/52.htm 块级元素是指以块的方式显示的元素，特点是单独占据一行，可以设置高宽度，当然设置了一些特殊属性除外，如浮动。块级元素有多个，如div，p，ul等等。
2.什么是内联元素 Inline element
内联元素的特点是以类似文本的方式显示，它不能设置高宽度，它的高宽度是它本身的高宽度（如文字、图片等），如a，span等。

块级元素可以通过display:inline属性来改变为内联显示，内联元素则可以通过display:block属性改变为块级显示。

备忘而已。

Tags - block , element , inline , 块级元素 , 内联元素 , css ]]> http://www.nd21.com/read.php/51.htm <![CDATA[请为四川地震中遇难的人们默哀！]]> P.Qingliang <p.qingliang@hotmail.com> Tue, 13 May 2008 08:26:59 +0000 http://www.nd21.com/read.php/51.htm 平安即是福 ]]> http://www.nd21.com/read.php/50.htm <![CDATA[wincachegrind-1.0.0.12下载]]> P.Qingliang <p.qingliang@hotmail.com> Wed, 16 Apr 2008 14:39:42 +0000 http://www.nd21.com/read.php/50.htm
可以方便的查看PHP运行的过程，每个过程中发生的调用以及调用消耗的时间，是检查PHP程序运行效率瓶颈的利器。

示意图：

打开日志输出对应XDebug配置选项：
xdebug.profiler_enable=on
xdebug.profiler_output_dir="c:/web/var/debuginfo"

点击这里下载文件

Tags - wincachegrind , xdebug , wincachegrind下载 ]]> http://www.nd21.com/read.php/48.htm <![CDATA[PHP开发群]]> P.Qingliang <p.qingliang@hotmail.com> Tue, 08 Apr 2008 17:10:26 +0000 http://www.nd21.com/read.php/48.htm 暗号：我要php ]]> http://www.nd21.com/read.php/66.htm <![CDATA[新博客启用]]> Model.King <P.Qingliang@hotmail.com> Tue, 08 Apr 2008 16:52:32 +0000 http://www.nd21.com/read.php/66.htm    南斗工作组其实只是我给这个窝起的一个名字而已，希望能在这里记录一些我学习生活中的事情，当然主要还是希望能和大家一起交流交流。当然任何爱好技术的同志我都非常欢迎你加入进来。
   我本人不喜欢QQ群的形式讨论，不过还是建立了一个群：17588007，加入请写上：南斗。由于我个人的爱好，讨论的范围不是很广，主要是php和vc方面的技术，欢迎大家的加入。有什么事情也可以一起商讨一下。

2008-07-08更新：上述信息已经无效。 ]]> http://www.nd21.com/read.php/47.htm <![CDATA[基于PHP5的上传类]]> P.Qingliang <p.qingliang@hotmail.com> Sat, 05 Apr 2008 13:33:48 +0000 http://www.nd21.com/read.php/47.htm define('ERROR_FILE_EXISTS', 8);

define('ERROR_EXIST_FILE_CANNOT_REMOVE', 9);

define('ERROR_NOT_UPLOAD_FILE', 10);

define('ERROR_NOT_ALLOW_TYPE', 11);

define('ERROR_CANNOT_MOVE', 12);

class N_Com_Upload
{
  /**
   * 文章保存目录
   *
   * @var string
   */
  protected $_uploadDir = '/Upload/';

  /**
   * 最大文件体积
   *
   * @var integer
   */
  protected $_maxFilesize = 4194304;
......
[/codes]
............

Tags - 文件上传,upload,php5,文件上传类,php ]]> http://www.nd21.com/read.php/46.htm <![CDATA[上传了FreeBSD的手册]]> P.Qingliang <p.qingliang@hotmail.com> Thu, 03 Apr 2008 17:58:03 +0000 http://www.nd21.com/read.php/46.htm 英文版的版本老了点,不过不影响使用. 大部分内容都没有改.
中文版:http://www.nd21.com/download/online_learning/FreeBSD_Handbook/Chinese_Edition/
英文版:http://www.nd21.com/download/online_learning/FreeBSD_Handbook/English_Edition/
Tags - freebsd, , freebsd手册,handbook ]]> http://www.nd21.com/read.php/45.htm <![CDATA[php中无限参数函数或方法的一种实现]]> P.Qingliang <p.qingliang@hotmail.com> Wed, 26 Mar 2008 02:36:24 +0000 http://www.nd21.com/read.php/45.htm [codes=php]
class NANDOU_Db_TableSel
{
  protected $_sql;

  public function where($condition, $param1)
  {
    $param = func_get_args();
    $condition = array_shift($param);
    foreach ($param as $value)
    {
      $condition = str_replace('?', $value, $condition);
    }
    $this->_sql .= $condition;
    return $this;
  }
}

$o = new NANDOU_Db_TableSel();
$o->where('date > ? and name = ?', 2006, 'model');
var_dump($o);
?>
[/codes]
结果显示

引用

object(NANDOU_Db_TableSel)#1 (1) { ["_sql:protected"]=> string(27) "date > 2006 and name = 2006" }

呵呵，想法来源于http://code.google.com/p/qeephp/wiki/QDB_Table_Select ，当时想不出它是怎么实现的。

顺便广告一下：http://www.fleaphp.org/ 很不错的国产PHP框架，除了文档不如意之外，其他都是非常优秀的，尤其在数据库处理方面，很多有创意的代码。
Tags - 无限参数,函数,方法 ]]> http://www.nd21.com/read.php/44.htm <![CDATA[foreach遍历数组的一点注意]]> P.Qingliang <p.qingliang@hotmail.com> Sun, 23 Mar 2008 05:38:48 +0000 http://www.nd21.com/read.php/44.htm [codes=php]
foreach ($rs as $key=>$value)
{
$value['title'] = str_repeat('|--', $value['depth']).$value['title'];
}
[/codes]

代码本身希望能够在title列前加上一定数量(depth)的 |-- 标记，实际输出的时候，却什么都没有改变。本来以为是PDOStatement对象本身不能修改的问题，经过测试给排除了。最后郁闷的发现PHP手册上这样的一句话：

引用

除非数组是被引用，foreach 所操作的是指定数组的一个拷贝，而不是该数组本身

汗啊，只好改了下代码使用for循环来操作:
[codes=php]
$size = sizeof($rs);
for ($i=0; $i<$size; $i++)
{
  $rs[$i]['title'] = str_repeat('|--', $rs[$i]['depth']).$rs[$i]['title'];
}
[/codes]

如果你的php版本是5.0以上也可以这样写：
[codes=php]
foreach ($rs as $key=>&$value)
{
               $value['title'] = str_repeat('|--', $value['depth']).$value['title'];
}
[/codes]

小小问题，狠狠郁闷
Tags - foreach,拷贝,php5,for,引用,不能修改 ]]> http://www.nd21.com/read.php/43.htm <![CDATA[PHPPDOMysql事务处理的一些总结]]> P.Qingliang <p.qingliang@hotmail.com> Sun, 16 Mar 2008 02:21:43 +0000 http://www.nd21.com/read.php/43.htm 1.Mysql默认的是自动提交变更的，即默认autocommit模式；可以使用SET AUTOCOMMIT=0;语句来禁用autocommit模式，不过这仅对当前连接有效。

2.当开始一个事务处理过程时，autocommit模式自动被禁用，直至事务结束。

3.如果表支持事务，而在PHP中禁用了autocommit模式，则可能会导致PHP返回成功值，而实际未成功写入数据到Mysql的问题。所以一般情况下，在PHP中请不要禁用连接的autocommit模式。

4.某些操作会导致隐含的结束一个事务过程，见Mysql手册13.4.3. 会造成隐式提交的语句

5.如果使用try catch对来捕捉PDO执行过程中的错误，打开连接后进行如下设置：
[codes=php]$this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);[/codes]
表示如何错误都以异常抛出，提高程序健壮性的同时也帮助了改善程序的逻辑。这样在事务处理过程的不能成功执行的语句都以异常抛出，并可以获得这些异常的来源，方便解决。
Tags - mysql,php,pdo,事务处理,autocommit ]]> http://www.nd21.com/read.php/42.htm <![CDATA[Form表单action属性设置问题]]> P.Qingliang <p.qingliang@hotmail.com> Tue, 11 Mar 2008 07:34:05 +0000 http://www.nd21.com/read.php/42.htm
[codes=js]
function categoryAction()
{
  var url;

  if ($('#delete').attr('checked'))
  {
    url = $('#formAction').attr('action') + 'delete';
    alert(url);
    document.getElementById("formAction").action.value = url; // ......1
    $('#formAction').attr('action', url);  //......2
    alert($('#formAction').attr('action'));
  }
  else if ($('#edit').attr('checked'))
  {
    //$('#formAction').attr('action', actionUrl + 'edit');
  }
  else
  {
    alert('请选择动作!');
  }