现象描述：

通过提供给js的接口来读取存在SharedPreferences里的字符串。

在JS里调用接口读出来一个字符:

abc  = ‘abc’;

在js里执行:

abc == ‘abc’

返回true

然后用

switch(abc)

{

case ‘abc’:

//  这里永远进不去

break;

}

如果先执行一下:

abc = “” + abc

前面的switch就能进去。

坑爹！

server {

#用于管理界面的处理
rewrite /wp-admin$ $scheme://$host$uri/ permanent;

location / {

#/wordpress是你的子目录名字,没有子目录就可以不用写
try_files $uri /wordpress$uri/ /wordpress/index.php?q=uri&$args;
}
}

因为主要考虑的是人可以做什么，所以主要的包括的点是这几个。
简单一下，要点是四个： 谁， 地方， 东西， 操作。
所以我们要分析这些要件分别可能是什么，并且他们之间是什么关系。
谁，是一个执行者，那可能是一个用户，一个管理员，一个后台的编辑，也可能是一个特定的人群。因些谁我们至少可以用：用户，角色，组来将他们表示出来。
而用户可以用组与角色来组织起来。假设组是一种树状的垂直组织，那么角色就可以是一种平面的组织。因此他们是有必要共存的一种用户分类方式。

那么这些用户相关的分类应该如何组织起来的呢？

就是涉及到了一些功能性的模块系统，比如用户管理系统，组织架构管理系统，员工管理系统。

通过组织架构管理系统，可以将用户与某些组织有效的组织起来。
但是一旦到了一个系统中，那么就必须要有一个资源的分配权限。

而资源一般都是跟一些结构，频道之类的东西相关的。

比如在组织架构管理系统里，组织本身就是一个资源，他包含创建，删除，更新组织的基本功能，还需要包含添加组成员，组长，副组长都角色的功能。

而这个组织本身又是这个组织结构的节点。

他本身会具有位置的信息，就是上面提到的地方的概念。

而组织的节点可以是一个人组成，也可以是一些角色组织。

如果管理层可能包含CEO，CFO，COO等等，只要给定了这个组织下的角色权限，那么不管指定谁是CEO，他就会具有CEO的权力。

所以我们可以得出来对于权限的管理，至少应该得到下面的几项关键数据：
组织架构/模块， 组织架构/模块的节点， 用户/角色， 用户/角色的标志符， 资源的类型， 资源的标志， 资源的动作标识

那么对应的，组织架构及其节点是我们所说的地方，用户/角色是我们所说的人，资源就是东西，动作标识是干什么。

这样就基本上定义了一个权限。

通过这种形式对权限进行组织，可以实现一个组织下，用户的权限非常细致的控制。

当然实现起来也会相对比较麻烦。

因为权限还会有一定的承继关系，用户，角色，组织权限的优先级关系，都会涉及到。

一般情况下，只要对一个用户设定组权限就可以了。

但是通过角色或者用户的特有权限设置，可以达到很精确的控制。

下面我基于减少instance函数的观点出发，做一个实验。

目标是用以实现一个可以省掉重复定义函数的基类。

下面是我的代码

流程大约是这样
a)创建
key = md5(str).hexdigest() #要限制在64位以内
channel_id = channel.create_channel(key)
b)
然后
channel.send_message(key, message) 发送消息
c)
在客户端的注意点是message发出去后，在javascript端也是一个对象。
内容需要通过得到的对象data.data来得到发送的字符串。

2. 在SDK上并没有使用comet技术，而是使用了polling,不断的从服务器取数据。

3. channel api 现在没有状态，无法知道如何客户端是不是已经断开。

2.转化成整数的规则

a) 字符开头是整数，节取开头的数字：

var num = parseInt(’300day’);  //结果是300

b) 开头不是整数，返回NaN（英文Not a Number的缩写，表示不是数字）

var num = parseInt(‘apple’); //结果是NaN

c) 能识别字面量的八进制与十六进制

var num = parseInt(’0xF’);  //结果是15

var num = parseInt(’034′); //结果是28,而不是34

d)无法识别小数点

var num = parseInt(‘.5′); //结果是NaN

var num = parseInt(’2.5′); //结果是2

f)可以指定字符串的基数（默认是10）

var num = parseInt(‘ab’); //结果是NaN

var num = parseInt(‘ab’, 16); //结果是171

其实只要有点IP基础知识的人就可以想到将IP换成是0.0.0.0就可以让服务与IP无关。

所以我们可以在运行时加上以下的参数：

–address=0.0.0.0

这样就可以让不同的IP都能访问到。

当然也可以添加成：

–address=192.168.1.1

仅限于局域网内访问。

总之只要你对IP绑定的原理有一些了解就可以帮助你更好的完成测试。

当我把 temp的}向外移动两格后，后面添加的两行竟然同样可以执行。
导致了一些莫名其妙的结果。。
而这个if又是写在最后的。
python的缩进，永远的话题!

就是有几个孔的固定的插座。

用电器插入后就能得到电能提供他所能提供的服务了。

对应到网络上，Socket（插座）里包含了你所启动的服务（类似于插座对应的电能），而孔就是所对应的端口。

通过端口，客户端就可以访问你所提供的服务。

当然客户端要找到你的服务，在TCP/IP协议族下通常的办法是通过IP协议来得到。

所以Socket是网络协议连接所使用的一种方式，不是协议。

HTTP，TCP，UDP都是一种协议。

TCP,UDP都是基于Socket的连接方式的协议。

所以讲Socket编程基本就是指用TCP/UDP进行编程。

但是这是一种不明确的说法。

要明确讲就要用TCP/UDP/HTTP。

Socket是大部分语言对TCP/UDP封装时所使用的名字。

如果不明确他的意义，将很容易造成困扰。

比如很多程序员以为Socket编程就是TCP编程。

如果不是很明确，可以到国外的论坛上看看。

理解Socket的明确含义。

var reg = /<[^>]*?>([^>^<]+)<[^>]*?\/+[^>]*?>/g;
var res = '&nbsp123456'.replace(reg, "$1,");
console.log(res);

结果:
“&nbsp,1,2,3,4,5,6,”

然后调用下面的代码:

UPDATE users SET pass = md5(‘newpassword’) WHERE uid = 1;

</pre>

2.print, echo前者只能打印一个字符,而echo 可以打印多个

print  $a, $b是错误的,而 echo $a, $b是正确的

3.print会有返回值,但是echo没有返回值,性能略好一些

To stream data, a client initiates a request, the server’s response begins immediately, and continues indefinitely until the client closes the connection. This would seem to be the ideal method of interaction – events can be pushed out as they happen on a pre-established connection, the resources spent opening and closing sockets are minimised, and since the connection has already been negoitiated, no additional headers or wrapper content are required so the use of bandwidth is also very efficient.

The problems with streaming are evident when the connection is routed to, or via, hosts that are not willing to play ball with this style of interaction. First, web browsers often wait for the entire response to complete before processing it. Second, proxy servers often wait for a response to complete before passing it on to the client, so streaming connections may never get received.

On the server side there are issues as well. By having no timeout on connections, it’s possible for lots of zombie connections to slowly build up, particularly if the client has failed to disconnect but is no longer listening to the response. This is particularly the case with proxy caches that try to finish downloading files even when their client has disconencted, so that it’s cached for the next request. And even assuming no zombie connections, there is still the issue of conccurrency – thousands of open sockets with not very much happening on most of them at any given moment.

Overall, streaming connections are still a very compelling choice where the browser can cope with reading a partially downloaded response, and there are no buffers in the way.

Short polling cannot pretend to even emulate pushing data to the client, but it is one step up from refreshing an entire page. Using AJAX, the client connects to the server and requests new events. The server sends an immediate response containing the events that have occured since the client last requested an update, and closes the connection. The client waits a predetermined interval and initiates another request.

Using this method, client and server spent the majority of their time not connected to each other, with the regular periodic polling connections being answered and closed by the server within a few milliseconds. This reduces the number of concurrent connections required of the server, but if there are lots of subscribers and the updates being requested by each one require an expensive but repetitive backend operation (like a database query), the server can rapidly become overloaded doing unnecessary tasks over and over again. Meteor addresses this by storing the events in memory and answering polling requests directly from the memory cache, avoiding repetitive database or disk access. This means that even though Meteor is designed to deal with long-lived connections, it is still worth using for polling as well.

Short polling is the most reliable way of updating data that will generally survive most browser and connection setups, but it’s hardly ideal as it’s not particularly scalable and the client is by no means receiving updates as they happen.

Sounds like it’s time for a happy middle ground between streaming and short polling, doesn’t it? Well, long polling may well fit the bill. The client initiates a request, and if the server has events pending, it sends them and closes the connection, much like short polling. But if the server does not have any events waiting, it holds the connection open until an event occurs, at which point it send the event and closes the connection. The client can then initiate a new connection immediately, since all the waiting is done at the server end.

The obvious benefit to this is that the client can treat the interaction as a simple ‘request-response’ and wait for it to complete before processing it rather than having to sniff the response as it loads. It works through proxies and is more resilient to connections dropping. And since the server is actively closing connections all the time, the chance of long-lived zombie connections is much reduced. On the negative side, there is a need to create and close many more connections than for a stream, one for each event that is sent (but far fewer than for short polling, because the server no longer has the thankless task of responding to millions of repeated requests with “no updated events available”). Also events may be slightly delayed if they occur in rapid succession while the client is reinitiating a new connection after the last update.

from jinja2 import Environment, FileSystemLoader
_TEMPLATE_DIR_ = 'res/html'
file = 'index.html'

env = Environment(loader = FileSystemLoader(_TEMPLATE_DIR_))
template = env.get_template(file)
content = template.render(params)

然后将content输出既可。
但这个时候还不行。
如果你使用了GBK的页面模板。

注:本人特别喜欢用GBK编码。
即使在UTF-8统一了很多程序员的思维的时期，
因为我坚信大部分的程序用UTF-8并没有意义，
除非他要支持多种语言，
但对于大部分WEB网站来讲，
支持多语言基本上是神话。
即使当你需要国际化时，转化也是相当容易的事情。
所以为什么不从GBK开始？
一个更加轻量的编码。

言归正传，要支持GBK，你需要做一定的修改,代码如下：

from jinja2 import Environment, FileSystemLoader
_TEMPLATE_DIR_ = 'res/html'
file = 'index.html'
encoding = 'gbk'
params = {}

env = Environment(loader = FileSystemLoader(_TEMPLATE_DIR_, encoding=encoding))
template = env.get_template(file) #这个时候的编辑又变成了内码（unicode）
content = template.render(params).encode(encoding)

这样就可以实现编码的统一了。
当然其它保证HTTP各处的编码统一的事情我就不细说了。

这样可以得到包含 abc的路径。
去掉abc就可以得到当前执行文件的路径。
Linux下面可以这样实现：

path = path[0:path.rfind('/')]