PHP帮助手册拾遗一：运算符

PHP帮助手册拾遗一：运算符

1、基本的赋值运算符是“=”。一开始可能会以为它是“等于”，其实不是的。
它实际上意味着把右边表达式的值赋给左边的运算数。

赋值运算表达式的值也就是所赋的值。也就是说，“$a = 3”的值是 3。这样就可以做一些小技巧：

1
2
3
4
5

<?php
 
$a = ($b = 4) + 5; // $a 现在成了 9，而 $b 成了 4。     
 
?>

2、取模 $a % $b 在 $a 为负值时的结果也是负值。
3、 尽管 ! 比 = 的优先级高，PHP 仍旧允许类似如下的表达式：if (!$a = foo())，在此例中 foo() 的输出被赋给了 $a。
同样，如下代码：

1
2
3
4
5

<?php
 if ($a = 100 && $b = 200) {                  
var_dump($a, $b); 
} 
?>

先赋值，再进行与运算
此问题鸟哥有一篇文章有谈到过，猛击http://www.laruence.com/2010/07/26/1668.html

4、如果比较一个整数和字符串，则字符串会被转换为整数。
如果比较两个数字字符串，则作为整数比较。此规则也适用于 switch 语句。

5、执行运算符
PHP 支持一个执行运算符：反引号（“）。注意这不是单引号！PHP 将尝试将反引号中的内容作为外壳命令来执行，并将其输出信息返回（例如，可以赋给一个变量而不是简单地丢弃到标准输出）。使用反引号运算符“`”的效果与函数 shell_exec() 相同。

1
2
3
4

<?php
$output = `ls -al`;                                           
echo $output;
?>

注: 反引号运算符在激活了安全模式或者关闭了 shell_exec() 时是无效的。

6、递增／递减运算符不影响布尔值。递减 NULL 值也没有效果，但是递增 NULL 的结果是 1。

1
2
3
4
5
6

$b = TRUE;
echo --$b;                                                                          
echo ++$b;
$c = NULL;
echo --$c;
echo ++$c;

输出在个1和一个空值

7、+ 运算符把右边的数组附加到左边的数组后面，但是重复的键值不会被覆盖。

1
2
3
4

$array1 = array(1, 'key' => 2);
$array2 = array('key' => 3, 'key1' => 4);                                 
$array = $array1 + $array2;
var_dump($array);

输出array(3) { [0]=> int(1) ["key"]=> int(2) ["key1"]=> int(4) }
数组2中的3已经不存在了，数组1中的2没有被覆盖

8、使用括号可以增强代码的可读性。

9、除号（“/”）总是返回浮点数，除非这两个运算数是整数（或由字符串转换成的整数）
这里手册中有一点没有说明，返回的值必须是整数才行，否则如 6/4的结果就是float了
//此处在某个中文手册中有翻译错误，意思完全弄反了，纠结…
代码示例：

1
2
3
4
5
6
7
8
9

$a = 8;
$b = 4;
$c = $a / $b;
var_dump($c);                                                                     
 
$a = 6;
$b = 4;
$c = $a / $b;
var_dump($c);

10、空字符串，false，NULL等值在算术运算符中将会以0对待。
如下所示代码：

1
2
3

echo 5 * "", '<br>';                                                                
echo 5 + false, '<br>';
echo 5 / NULL, '<br>';

11、 加号、减号、点号运行的优先级是一样一样滴
如下所示代码：

1
2

$var = 3;
echo "string " . $var + 3;

输出3

12、instanceof后面不能接字符串，可以直接接类名或包含类名的变量

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

class Demo {                                                                     
 
}
 
$demo = new Demo();
 
/* 以变量的形式存储类名字符串是正确的 */
$class = "Demo";
if ($demo instanceof $class) {
    echo 'yes';
}
 
/* 不能直接接类名的字符串，即类名不能加双引号 */
$demo = new Demo();
 
if ($demo instanceof "Demo") {
    echo 'yes';
}
 
/* 类名上无引号 */
$demo = new Demo();
 
if ($demo instanceof Demo) {
    echo 'yes';
}

PHP设计模式笔记：使用PHP实现合成模式

PHP设计模式笔记：使用PHP实现合成模式

【意图】
将对象组合成树形结构以表示”部分-整体”的层次结构。Composite使用户对单个对象和组合对象的使用具有一致性。
Composite变化的是一个对象的结构和组成

【合成模式中主要角色】
抽象组件(Component)角色：抽象角色，给参加组合的对象规定一个接口。在适当的情况下，实现所有类共有接口的缺省行为。声明一个接口用于访问和管理Component的子组件
树叶组件(Leaf)角色：在组合中表示叶节点对象，叶节点没有子节点。在组合中定义图元对象的行为。
树枝组件(Composite)角色：存储子部件。定义有子部件的那些部件的行为。在Component接口中实现与子部件有关的操作。
客户端(Client)：通过Component接口操纵组合部件的对象

【合成模式的优点和缺点】
Composite模式的优点
1、简化客户代码
2、使得更容易增加新类型的组件

Composite模式的缺点：使你的设计变得更加一般化，容易增加组件也会产生一些问题，那就是很难限制组合中的组件

【合成模式适用场景】
1、你想表示对象的部分-整体层次结构
2、你希望用户忽略组合对象和单个对象的不同，用户将统一地使用组合结构中的所有对象。

【合成模式与其它模式】
装饰器模式：Decorator模式经常与Composite模式一起使用。当装饰与合成一起使用时，它们通常有一个公共的父类。因此装饰必须支持具有add,remove和getChild操作的Component接口
享元模式：Flyweight模式让你共享组件，但不再引用他们的父部件
迭代器模式：Itertor可用来遍历Composite
访问者模式：Visitor将本来应该分布在Composite和Leaf类中的操作和行为局部化。

【安全式的合成模式】
在Composite类里面声明所有的用来管理子类对象的方法。这样的做法是安全的。因为树叶类型的对象根本就没有管理子类的方法，因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。编译通不过，就不会出现运行时期错误
这样的缺点是不够透明，因为树叶类和合成类将具有不同的接口。

【安全式的合成模式结构图】

安全式的合成模式

安全式的合成模式


【安全式的合成模式PHP示例】

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

 
<?php
 
/**
 * 安全的合成模式的PHP实现 2010-08-10 sz
 * @author 胖子 phppan.p#gmail.com  http://www.phppan.com                                        
 * 哥学社成员（http://www.blog-brother.com/）
 * @package design pattern
 */
 
 
/**
 * 抽象组件角色
 */
interface Component {
 
    /**
     * 返回自己的实例
     */
    public function getComposite();
 
    /**
     * 示例方法
     */
    public function operation();
}
 
/**
 * 树枝组件角色
 */
class Composite implements Component {
    private $_composites;
 
    public function __construct() {
        $this->_composites = array();
    }
 
    public function getComposite() {
        return $this;
    }
 
    /**
     * 示例方法，调用各个子对象的operation方法
     */
    public function operation() {
        echo 'Composite operation begin:<br />';
        foreach ($this->_composites as $composite) {
            $composite->operation();
        }
        echo 'Composite operation end:<br /><br />';
    }
 
    /**
     * 聚集管理方法 添加一个子对象
     * @param Component $component  子对象
     */
    public function add(Component $component) {
        $this->_composites[] = $component;
    }
 
    /**
     * 聚集管理方法 删除一个子对象
     * @param Component $component  子对象
     * @return boolean  删除是否成功
     */
    public function remove(Component $component) {
        foreach ($this->_composites as $key => $row) {
            if ($component == $row) {
                unset($this->_composites[$key]);
                return TRUE;
            }
        }
 
        return FALSE;
    }
 
    /**
     * 聚集管理方法 返回所有的子对象
     */
    public function getChild() {
       return $this->_composites;
    }
 
}
 
class Leaf implements Component {
    private $_name;
 
    public function __construct($name) {
        $this->_name = $name;
    }
 
    public function operation() {
        echo 'Leaf operation ', $this->_name, '<br />';
    }
 
    public function getComposite() {
        return null;
    }
}
 
 
/**
 * 客户端
 */
class Client {
 
    /**
     * Main program.
     */
    public static function main() {
        $leaf1 = new Leaf('first');
        $leaf2 = new Leaf('second');
 
        $composite = new Composite();
        $composite->add($leaf1);
        $composite->add($leaf2);
        $composite->operation();
 
        $composite->remove($leaf2);
        $composite->operation();
    }
 
}
 
Client::main();
?>

【透明式的合成模式】
在Composite类里面声明所有的用来管理子类对象的方法。这样做的是好处是所有的组件类都有相同的接口。在客户端看来，树叶类和合成类对象的区别起码在接口层次上消失了，客户端可以同等的对待所有的对象。这就是透明形式的合成模式
缺点就是不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下一个层次的对象，因此调用其添加或删除方法就没有意义了，这在编译期间是不会出错的，而只会在运行时期才会出错。

【透明式的合成模式结构图】

透明式的合成模式

透明式的合成模式

【透明式的合成模式PHP示例】

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

 
<?php
 
/**
 * 透明的合成模式的PHP实现 2010-08-10 sz
 * @author 胖子 phppan.p#gmail.com  http://www.phppan.com                                               
 * 哥学社成员（http://www.blog-brother.com/）
 * @package design pattern
 */
 
 
/**
 * 抽象组件角色
 */
interface Component {
 
    /**
     * 返回自己的实例
     */
    public function getComposite();
 
    /**
     * 示例方法
     */
    public function operation();
 
      /**
     * 聚集管理方法 添加一个子对象
     * @param Component $component  子对象
     */
    public function add(Component $component);
 
    /**
     * 聚集管理方法 删除一个子对象
     * @param Component $component  子对象
     * @return boolean  删除是否成功
     */
    public function remove(Component $component);
 
    /**
     * 聚集管理方法 返回所有的子对象
     */
    public function getChild();
 
}
 
/**
 * 树枝组件角色
 */
class Composite implements Component {
    private $_composites;
 
    public function __construct() {
        $this->_composites = array();
    }
 
    public function getComposite() {
        return $this;
    }
 
    /**
     * 示例方法，调用各个子对象的operation方法
     */
    public function operation() {
        echo 'Composite operation begin:<br />';
        foreach ($this->_composites as $composite) {
            $composite->operation();
        }
        echo 'Composite operation end:<br /><br />';
    }
 
    /**
     * 聚集管理方法 添加一个子对象
     * @param Component $component  子对象
     */
    public function add(Component $component) {
        $this->_composites[] = $component;
    }
 
    /**
     * 聚集管理方法 删除一个子对象
     * @param Component $component  子对象
     * @return boolean  删除是否成功
     */
    public function remove(Component $component) {
        foreach ($this->_composites as $key => $row) {
            if ($component == $row) {
                unset($this->_composites[$key]);
                return TRUE;
            }
        }
 
        return FALSE;
    }
 
    /**
     * 聚集管理方法 返回所有的子对象
     */
    public function getChild() {
       return $this->_composites;
    }
 
}
 
class Leaf implements Component {
    private $_name;
 
    public function __construct($name) {
        $this->_name = $name;
    }
 
    public function operation() {
        echo 'Leaf operation ', $this->_name, '<br />';
    }
 
    public function getComposite() {
        return null;
    }
 
      /**
     * 聚集管理方法 添加一个子对象,此处没有具体实现，仅返回一个FALSE
     * @param Component $component  子对象
     */
    public function add(Component $component) {
        return FALSE;
    }
 
    /**
     * 聚集管理方法 删除一个子对象
     * @param Component $component  子对象
     * @return boolean  此处没有具体实现，仅返回一个FALSE
     */
    public function remove(Component $component) {
        return FALSE;
    }
 
    /**
     * 聚集管理方法 返回所有的子对象 此处没有具体实现，返回null
     */
    public function getChild() {
       return null;
    }
 
}
 
 
/**
 * 客户端
 */
class Client {
 
    /**
     * Main program.
     */
    public static function main() {
        $leaf1 = new Leaf('first');
        $leaf2 = new Leaf('second');
 
        $composite = new Composite();
        $composite->add($leaf1);
        $composite->add($leaf2);
        $composite->operation();
 
        $composite->remove($leaf2);
        $composite->operation();
 
    }
 
}
 
Client::main();
?>

可以看到透明式合成模式的Leaf有各聚集管理方法的平庸实现

Python核心编程读书笔记：第二章，快速入门

第二章学习笔记
【2.1 使用print输出】
print调用str()函数显示对象
print默认在输出的内容后面添加回车，如果不想输出回车，在输出内容后面添加逗号，如果要输出多个内容，使用逗号连接，不过如果带逗号的print语句会在输出的元素之间自动添加一个空格
print与字符串格式操作符（%）结合使用，可实现字符串操作功能（这一点和C语言的printf()函数非常相似）

【2.2 程序输入和raw_input()内建函数】
raw_input读取标准输入，并将读取到的数据赋值给指定的变量，如:

1
2
3

user = raw_input('please input name')
print user
help(raw_input)

Help on built-in function raw_input in module __builtin__:

raw_input(…)
raw_input([prompt]) -> string
raw_input从标准输入读取一个字符串并自动删除串尾的换行字符

【2.3 注释】
单行注释： Python使用#符号标示注释，从#开始，直到一行结束的内容都是注释
多行注释：使用三个单引号或双引号
文档注释：
函数内部的第一行开始的字符串为 DocStrings
DocStrings 一般为多行
DocString 为三引号扩起来的多行字符串
第一行为概述
第二行为空行
第三行开始是详细描述
DocStrings 的存在证明了函数也是对象
函数的 __doc__ 属性为该 DocStrings
例如 print printTest.__doc__ 为打印 printTest 函数的 DocStrings
如下所示代码：

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

#!/usr/bin/python
# -*- coding: utf-8 -*-
u"""文档注释 文档字符串"""
 
import sys
__author__ = "phppan"
__date__ = "$2010-8-1 17:54:58$"
 
def printTest(string):
    u'''
        printTest 函数注释 文档字符串
        注释第二行
    '''
    print string
 
if __name__ == "__main__":
 
    printTest('hello world')
    printTest(__doc__)  #单行注释
    '''
多行注释
    '''
    printTest(printTest.__doc__)
    print __date__
    print __author__

中文注释问题：
Python里有两种字符串，一种是Unicode字符串，一种是一般的字符串。
Python里字符串的encode函数负责将unicode字符串转化为另外一种Unicode编码形式。
decode函数负责将一般的字符串进行解码，结果为unicode编码。还有一点是unicode（）负责将一般的字符串解码为指定格式的unicode字符串。
如果字符串是这样定义：s=’中文’
如果是在utf8的文件中，该字符串就是utf8编码，如果是在gb2312的文件中，则其编码为gb2312。
如果字符串是这样定义：s=u’中文’
则该字符串的编码就被指定为unicode了，即python的内部编码
isinstance(s, unicode) #用来判断是否为unicode

print会对输出的文本做自动的编码转换， print转换的目的编码和环境变量有关，Windows XP是转换为gbk的。可以使用用locale模块的getdefaultlocale方法获得当前环境的编码。而print在输出时会把字符串自动转换为这种编码。

【2.4 操作符】
对于一些数据类型，有些操作符是被重载了的，比如字符串和列表
对于不等于操作符，python支持两种 != 和 <>，建议使用 !=
合理使用括号，增强代码的可读性

【2.5 变量和赋值】
类C语言
以字母开头，可以是数字、字母或下划线
大小写敏感
不需要预先声明变量的类型，变量的类型和值在赋值那一刻被初始化
不支持自增1和自减1操作符

【2.6 数字】
Python支持5种数字类型：有符号整形、长整型、布尔、浮点和复数
其中长整型类似于java中的BigInteger类型，它仅受限于用户计算机的虚拟内存总数
decimal类型需要先导入decimal模块才可以使用

【2.7 字符串】
Python中字符串被定义为引号之间的字符集合。Python支持成对的单引号、双引号和三引号
使用索引操作符（{[]）和切片操作符（[:]）可以得到子串
字符串有其我有的索引规则：第一个字符的索引是0(和C语言类似)，最后一个字符的索引是-1
加号（+）用于字符串连接运算 星号（*）用于字符串重复

【2.8 列表和元组】
从0开始索引，可以存储不同类型的对象
列表元素使用中括号（[]）包裹，元素的个数和元素的值都可以改变
元组元素使用小括号（()）包裹，不可以更改，可以看成是只读的列表

【2.9 字典】
字典是Python中的映射数据类型，工作原理类似于Hash表，可以将其作为PHP的数组使用
字典由键值对构成，几乎所有对象都可以用作键，不过一般使用数字或字符串

【2.10 代码块及缩进对齐】
Python通过缩进对齐表达代码逻辑

【2.11 if语句】
if expression:
if_suite
elif expression2:
elif_suite
else:
else_suite

【2.12 while循环】
while expresion:
while_suite

【2.13 for循环和range()内建函数】
for循环与传统的for循环不同，更像是PHP中的foreach

for eachNum in range(3):
print eachNum

【2.14 列表解析】
[x ** 2 for x in range(4)]
[x ** 2 for x in range(4) if x ** 2 > 1]

【2.15 文件和内建函数file(),open()】
handle = open(filenaem, mode = ‘r’) 返回一个文件句柄

1
2
3
4
5

    filename = raw_input('Enter file name:')
    fobj = open(filename, 'r')
    for eachLine in fobj:
        print eachLine,
    fobj.close()

【2.16 错误和异常】
将代码“封装”在try-except语句当中，就可以增加错误检测及异常处理

【2.17 函数】
一个函数的语法由def关键字及紧随其后的函数名，再加上该函数所需要的参数组成
def function_name([arguments]):
“optional documentation string”
function_suite

函数的参数可以有一个默认值

【2.18 类】
类是面向对象核心，它扮演相关数据及逻辑容器的角色。
定义类：
class ClassName(base_class[es]):
“optional documentation string”
static_memeber_declarations
method_declarations

所有名字开始和结束都有两个下划线的方法都是特殊方法
self是类实例自身的引用
当一个类的实例被创建时，__init__()就会被自动调用

【2.19 模块】
模块是一种组织形式，它将彼此有关系的python代码组织到一个个独立文件当中。模块可以包含可执行代码、函数和类，或者这些东西的组合。
导入模块：import module_name
访问模块函数或模块变量：

1
2
3

    import sys
    sys.stdout.write('hello')
    print sys.platform

【2.20 实用函数】
dir([obj]) 显示对象的属性，如果没有提供参数，则显示全局变量的名字
help([obj]) 以一种整齐美观的形式，，显示对象的文档字符串，如果没有提供任何参数，则会进入交互帮助
int(obj) 将一个对象转化成整形
len(obj) 返回对象的长度
open(fn, mode) 以mode方式打开一个文件名为fn的文件
range([start,]stop[,step]) 返回一个整形列表，起始值为start,结束值为stop -1,start默认值为0，step默认值为1
str(obj) 将一个对象转换为字符串
type(obj) 返回对象的类型（返回值本身是一个type对象）