这,是一个笑话:
突然让我想起两年前的那个图,产品经理拿到一个要做秋千的需求,经过层层转达,最后做出一个十不象来,事实上就是人们所说的,每一次信息传递,都会丢失大约20%左右的信息,当信息传达次数过多的时候,需求和结果就已经很偏离方向了。
上海以前有一个节目《智力大冲浪》,其中有一个游戏就是COPY不走样,但事实上这真的不太可能。
在实际工作中,往往都是老板说要做一个什么东西,然后产品经理进行规划,事实上这时候已经可能偏了大约10%左右。然后产品经理规划好了,找开发主管讨论,这时候又偏了10%左右。开发主管找小弟把需求复述一遍,需求还剩70%,这时候根据开发人员的水平来划分:
1、特别好的开发人员能够保证60%的准确度+15%的自己理解(可能会有实际偏差也可能就正好把需求损失的补回来)
2、一般的开发人员,能够保证60%的完成度
3、稍差一点的开发人员,能够保证50%
4、差一点的,30%
5、如果连程序都写不完的,就不谈百分比了。。。。
细想想,难道不正是这样?
易栈网-膘叔
儿童咳嗽,不要总当感冒治
也是一个转贴啊,主要是我们家的小朋友也有点这种症状,如果有相同类似的小朋友们可以看看。当然我也不知道这是对还是错。。。
原文来自:http://geek.techweb.com.cn/viewthread.php?tid=231886
引起儿童慢性咳嗽的原因很多,过敏是重要原因之一。
过敏性咳嗽患儿的表现:
?长期咳嗽,久治不见好转;
?一般在夜间或清晨发作,白天通常不咳嗽或很少咳嗽;
?过敏性咳嗽一般不发烧,吐白色泡沫痰,多以咳嗽为主,不喘。
?咳三阵是它的最大特点,晚上睡觉前咳一阵,半夜醒来咳一阵,早上醒来咳一阵,有的儿童一连咳上3个月;
?过敏性咳嗽的孩子喜欢揉眼睛和鼻子,爱抓头皮,睡觉时爱出汗、不安分,喜欢蜷曲着睡。
治疗误区:
孩子出现过敏性咳嗽时,父母的第一反应往往还是“孩子又感冒了”,并把它当成感冒而一味使用抗生素和止咳药治疗,但实际上不对证的治疗是不可能获得良好效果的。咳嗽时间长了,患儿可以发展成典型的支气管哮喘。
正确治疗:
?在季节交替、气温骤变时,父母应尽量为孩子防寒保暖,避免着凉、感冒;
小快克的一分为二设计其实就是将一整袋药品分为两个相等的半份,这样便可以使年轻父母可以更好的掌握用药剂量。小快克的设计受到了广大年轻父母的欢迎,这无疑也是给那些不负责任的厂家好好的上了一课。
其实宝宝作为一家人中最受爱护的对象,从出生开始便会集万千宠爱于一身,很多的父母长辈都希望宝宝可以健康快乐的成长。如果宝宝受到病痛的伤害与侵扰,那将是全家人的烦心事,尤其是在选择用药剂量上,一直以来都困扰着很多的父母。
?避开过敏源,家里不要养宠物和养花,不要铺地毯,避免接触花粉、尘螨、油烟、油漆等,避免食用会引起过敏症状的食物,如海产品、冷饮等;
phpstorm 函数提示
其实我一直以为phpstorm的函数提示只能提示参数的,但最近我在把菜单一一看完的时候才发现,原来,它真的可以提示函数的详细信息。
说白了, 就是将phpdoc这一块的内容全部提示出来。具体怎么操作呢?
在macosx上,快捷键是F1或者ctrl+j
其他平台上未知,但没有关系,可以通过keymap来看一下定义的是什么快捷键,也可以看这个:
看那个QuickDocumentation,就知道了。
因为菜单里的提示只是默认的,所以如果有多种快捷键,还是看keymap的定义吧。比如我现在的定义是:
转:apache一个优化小技巧
determine the MaxClient
決定 web server 效能一個最重要的因素就是記憶體的量,而藉由調整 MaxClient,可以避免 Apache 產生過多無用的 child process。這個數字到底要調到多少,老實說也沒有一個標準答案,網路上大家比較建議的算法都是用機器有的記憶體和每個 child process 的 size 去做粗估。但事實上,要估計 apache child process 的 size 也不是一件容易的事,如果你用 ps aux 這個指令去看,出來的 VSZ or RSS value,其實都會把 shared memory 重覆記算(詳細內容請參考: Understanding memory usage on Linux , Memory usage determination with the ps command ),所以後來我採用的作法是:先將 MaxClent 設成一個比較小的值 (e.g. 30),然後再定期去看 error log 是否有 run out of clients 的情形,如果有的話,就再幫 MaxClients 加個 5。
原文来自:http://brooky.cc/2011/06/30/practical-guide-on-setup-wordpress-on-amazon-ec2-free-tier/
disable “AllowOverride”
理論上,AllowOverride 會造成 Apache 在路徑的每一層去找找看是否有 .htaccess 這個 file。
例如說:如果 virtual host 的設定是:
DocumentRoot /www/htdocs AllowOverride all
那任何一個 /index.html 的 request, Apache 都會試著去找 /.htaccess, /www/.htaccess, and /www/htdocs/.htaccess.
所以除非必要,是可以將 AllowOverride 設成 None.
但如果你用了 wordpress Pretty Permalinks”這個功能,那就會需要 rewrite rule 的功能。在這種情況下,可以考慮將 AllowOverride 的設定直接寫在 config 檔裡。
----------
上文中的链接:Memory usage determination with the ps command
The ps command can also be used to monitor memory usage of individual processes.
The ps v PID command provides the most comprehensive report on memory-related statistics for an individual process, such as:
- Page faults
- Size of working segment that has been touched
- Size of working segment and code segment in memory
- Size of text segment
- Size of resident set
- Percentage of real memory used by this process
# ps v
PID TTY STAT TIME PGIN SIZE RSS LIM TSIZ TRS %CPU %MEM COMMAND
36626 pts/3 A 0:00 0 316 408 32768 51 60 0.0 0.0 ps v
The most important columns on the resulting ps report are described as follows:
- PGIN
- Number of page-ins caused by page faults. Since all I/O is classified as page faults, this is basically a measure of I/O volume.
- SIZE
- Virtual size (in paging space) in kilobytes of the data section of the process (displayed as SZ by other flags). This number is equal to the number of working segment pages of the process that have been touched times 4. If some working segment pages are currently paged out, this number is larger than the amount of real memory being used. SIZE includes pages in the private segment and the shared-library data segment of the process.
- RSS
- Real-memory (resident set) size in kilobytes of the process. This number is equal to the sum of the number of working segment and code segment pages in memory times 4. Remember that code segment pages are shared among all of the currently running instances of the program. If 26 ksh processes are running, only one copy of any given page of the ksh executable program would be in memory, but the ps command would report that code segment size as part of the RSS of each instance of the ksh program.
- TSIZ
- Size of text (shared-program) image. This is the size of the text section of the executable file. Pages of the text section of the executable program are only brought into memory when they are touched, that is, branched to or loaded from. This number represents only an upper bound on the amount of text that could be loaded. The TSIZ value does not reflect actual memory usage. This TSIZ value can also be seen by executing the dump -ov command against an executable program (for example, dump -ov /usr/bin/ls).
- TRS
- Size of the resident set (real memory) of text. This is the number of code segment pages times 4. This number exaggerates memory use for programs of which multiple instances are running. The TRS value can be higher than the TSIZ value because other pages may be included in the code segment such as the XCOFF header and the loader section.
- %MEM
- Calculated as the sum of the number of working segment and code segment pages in memory times 4 (that is, the RSS value), divided by the size of the real memory in use, in the machine in KB, times 100, rounded to the nearest full percentage point. This value attempts to convey the percentage of real memory being used by the process. Unfortunately, like RSS, it tends the exaggerate the cost of a process that is sharing program text with other processes. Further, the rounding to the nearest percentage point causes all of the processes in the system that have RSS values under 0.005 times real memory size to have a %MEM of 0.0.
-----------
第二篇:http://virtualthreads.blogspot.com/2006/02/understanding-memory-usage-on-linux.html
这篇文章来自blogspot,一般情况下打不开,所幸我用Read it later,直接用广本模式,让他帮我打开了。HOHO,有点长,慢慢看:
This entry is for those people who have ever wondered, "Why the hell is a simple KDE text editor taking up 25 megabytes of memory?" Many people are led to believe that many Linux applications, especially KDE or Gnome programs, are "bloated" based solely upon what tools like ps report. While this may or may not be true, depending on the program, it is not generally true -- many programs are much more memory efficient than they seem.
What ps reports
The ps tool can output various pieces of information about a process, such as its process id, current running state, and resource utilization. Two of the possible outputs are VSZ and RSS, which stand for "virtual set size" and "resident set size", which are commonly used by geeks around the world to see how much memory processes are taking up.
For example, here is the output of ps aux for KEdit on my computer:
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
dbunker 3468 0.0 2.7 25400 14452 ? S 20:19 0:00 kdeinit: kedit
According to ps, KEdit has a virtual size of about 25 megabytes and a resident size of about 14 megabytes (both numbers above are reported in kilobytes). It seems that most people like to randomly choose to accept one number or the other as representing the real memory usage of a process. I'm not going to explain the difference between VSZ and RSS right now but, needless to say, this is the wrong approach; neither number is an accurate picture of what the memory cost of running KEdit is.
Why ps is "wrong"
Depending on how you look at it, ps is not reporting the real memory usage of processes. What it is really doing is showing how much real memory each process would take up if it were the only process running. Of course, a typical Linux machine has several dozen processes running at any given time, which means that the VSZ and RSS numbers reported by ps are almost definitely "wrong". In order to understand why, it is necessary to learn how Linux handles shared libraries in programs.
Most major programs on Linux use shared libraries to facilitate certain functionality. For example, a KDE text editing program will use several KDE shared libraries (to allow for interaction with other KDE components), several X libraries (to allow it to display images and copy and pasting), and several general system libraries (to allow it to perform basic operations). Many of these shared libraries, especially commonly used ones like libc, are used by many of the programs running on a Linux system. Due to this sharing, Linux is able to use a great trick: it will load a single copy of the shared libraries into memory and use that one copy for every program that references it.
For better or worse, many tools don't care very much about this very common trick; they simply report how much memory a process uses, regardless of whether that memory is shared with other processes as well. Two programs could therefore use a large shared library and yet have its size count towards both of their memory usage totals; the library is being double-counted, which can be very misleading if you don't know what is going on.
Unfortunately, a perfect representation of process memory usage isn't easy to obtain. Not only do you need to understand how the system really works, but you need to decide how you want to deal with some hard questions. Should a shared library that is only needed for one process be counted in that process's memory usage? If a shared library is used my multiple processes, should its memory usage be evenly distributed among the different processes, or just ignored? There isn't a hard and fast rule here; you might have different answers depending on the situation you're facing. It's easy to see why ps doesn't try harder to report "correct" memory usage totals, given the ambiguity.
Seeing a process's memory map
Enough talk; let's see what the situation is with that "huge" KEdit process. To see what KEdit's memory looks like, we'll use the pmap program (with the -d flag):
Address Kbytes Mode Offset Device Mapping
08048000 40 r-x-- 0000000000000000 0fe:00000 kdeinit
08052000 4 rw--- 0000000000009000 0fe:00000 kdeinit
08053000 1164 rw--- 0000000008053000 000:00000 [ anon ]
40000000 84 r-x-- 0000000000000000 0fe:00000 ld-2.3.5.so
40015000 8 rw--- 0000000000014000 0fe:00000 ld-2.3.5.so
40017000 4 rw--- 0000000040017000 000:00000 [ anon ]
40018000 4 r-x-- 0000000000000000 0fe:00000 kedit.so
40019000 4 rw--- 0000000000000000 0fe:00000 kedit.so
40027000 252 r-x-- 0000000000000000 0fe:00000 libkparts.so.2.1.0
40066000 20 rw--- 000000000003e000 0fe:00000 libkparts.so.2.1.0
4006b000 3108 r-x-- 0000000000000000 0fe:00000 libkio.so.4.2.0
40374000 116 rw--- 0000000000309000 0fe:00000 libkio.so.4.2.0
40391000 8 rw--- 0000000040391000 000:00000 [ anon ]
40393000 2644 r-x-- 0000000000000000 0fe:00000 libkdeui.so.4.2.0
40628000 164 rw--- 0000000000295000 0fe:00000 libkdeui.so.4.2.0
40651000 4 rw--- 0000000040651000 000:00000 [ anon ]
40652000 100 r-x-- 0000000000000000 0fe:00000 libkdesu.so.4.2.0
4066b000 4 rw--- 0000000000019000 0fe:00000 libkdesu.so.4.2.0
4066c000 68 r-x-- 0000000000000000 0fe:00000 libkwalletclient.so.1.0.0
4067d000 4 rw--- 0000000000011000 0fe:00000 libkwalletclient.so.1.0.0
4067e000 4 rw--- 000000004067e000 000:00000 [ anon ]
4067f000 2148 r-x-- 0000000000000000 0fe:00000 libkdecore.so.4.2.0
40898000 64 rw--- 0000000000219000 0fe:00000 libkdecore.so.4.2.0
408a8000 8 rw--- 00000000408a8000 000:00000 [ anon ]
... (trimmed) ...
mapped: 25404K writeable/private: 2432K shared: 0K
I cut out a lot of the output; the rest is similar to what is shown. Even without the complete output, we can see some very interesting things. One important thing to note about the output is that each shared library is listed twice; once for its code segment and once for its data segment. The code segments have a mode of "r-x--", while the data is set to "rw---". The Kbytes, Mode, and Mapping columns are the only ones we will care about, as the rest are unimportant to the discussion.
If you go through the output, you will find that the lines with the largest Kbytes number are usually the code segments of the included shared libraries (the ones that start with "lib" are the shared libraries). What is great about that is that they are the ones that can be shared between processes. If you factor out all of the parts that are shared between processes, you end up with the "writeable/private" total, which is shown at the bottom of the output. This is what can be considered the incremental cost of this process, factoring out the shared libraries. Therefore, the cost to run this instance of KEdit (assuming that all of the shared libraries were already loaded) is around 2 megabytes. That is quite a different story from the 14 or 25 megabytes that ps reported.
What does it all mean?
The moral of this story is that process memory usage on Linux is a complex matter; you can't just run ps and know what is going on. This is especially true when you deal with programs that create a lot of identical children processes, like Apache. ps might report that each Apache process uses 10 megabytes of memory, when the reality might be that the marginal cost of each Apache process is 1 megabyte of memory. This information becomes critial when tuning Apache's MaxClients setting, which determines how many simultaneous requests your server can handle (although see one of my past postings for another way of increasing Apache's performance).
It also shows that it pays to stick with one desktop's software as much as possible. If you run KDE for your desktop, but mostly use Gnome applications, then you are paying a large price for a lot of redundant (but different) shared libraries. By sticking to just KDE or just Gnome apps as much as possible, you reduce your overall memory usage due to the reduced marginal memory cost of running new KDE or Gnome applications, which allows Linux to use more memory for other interesting things (like the file cache, which speeds up file accesses immensely).
转perfgeeks的:记一次tps提升,做的配置变更
这次的转贴内容其实更象一个找到问题的过程,可以用来参考也可以用来思考,当你遇到问题的时候应该怎么做。
原文地址在:http://www.perfgeeks.com/?p=668
内容如下:
记一次tps提升,做的配置变更
tps低,响应时间高,并发能力差。
1.应用本身,通过xhprof找出问题代码。产生系统内核调用函数尽量避免调用。比如is_file(), time(),require/include代替require_once/include_once等。
2.尽量使用memcached缓存系统配置、模块数据、还有用户数据。减少mysqli_query()执行次数,它比较耗资源。开启mysqld的slow_query日志功能,优化那些较慢的sql查询语句。
2.通过xhprof,我们发现load和run源文件需要不少的挂钟时间,可以开启apc缓存opcode,同时设置apc.stat=off。还可以使用apc的apc_define_constants()代替php的define()
3.通过apc和memcached,收效可见,但是tps并没有提升到理想状态,同时tps不稳定,还会触底。php代码本身的优化效果甚微,对tps贡献不大。
4.重新编译php,将不必要的模块和功能禁用掉,只编译需要的。
5.配置php.ini,将不必要的模块去掉,比如gd(我们的应用不需要处理图片),soap,xhprof,mssql等。通过pmap或者lsof 可以查看一个php-cgi加载了哪些模块。减少模块加载,可以节约内存。尽量通过php.ini进行php设置,避免在代码中调用init_set操 作。比如设置时区,设置session等等。尤其data.timezone需要配置。
6.通过禁用xhprof,大概可以省下5000个cs。xhprof用完了,就应该关闭。
7.正确地设置php-fpm.max_children数量。过多的max_children浪资内存资源,还会增加cs。当然,过少的max_children会响应502。可以通过top命令观察,调整该值。
8.php-fpm使用sock方式配置。php-fpm.listen_address=/var/run/php-cgi.sock,同时nginx也需要配置fastcgi_pass指向该sock文件。
9.设置nginx.worker_processes,分别尝试了2、4、8几个值。网上大量资料说设置为cpu数*核数,其实更需要根据你的需求来设 定这个值。worker值越大,表示同时处理量大但速度更慢,相反表示处理速度能力强但数量更小。如果做为反向代理服务器,worker值可以大一点,如 果做为web逻辑服务器,值可以小一点。
10.网络IO,选择支持多路复用模型epoll,FreeBSD采用kqueue。如果网站流量小,选择select也还是不错的。
11.开启持久连接机制keep-alive,keep-alive可以复用tcp/ip连接,大量地减少了accept()系统内核调用。这里将nginx.keepalive_timeout设置为60.注意http/1.1默认开启keep-alive
12.gzip,压缩http响应输出。当响应输出量足够小,使用gzip压缩并没有意义。可以通过gzip_min_length指定跳过gzip压缩。
13.关闭nginx.access_log。通过access_log off可以不记录日志。减少不必要的磁盘I/O操作。如果开启日志功能,最好写个脚本将日志按量分割成更小的文件。
14.对于静态资源服务器,可以开启sendfile功能和设置expires缓存新鲜期。
15.将selinux设置为disabled,命令setenforce 0,只是将selinux设置为permissive,该模式会执行安全策略检查并打印警告。
16.通过chkconfig管理系统随机开启的守护进程。将不必要启动的守护进程关闭,比如sendmail, portmap, atd, netfs, nfslock等。这些守护进程浪费内存空间。
17.关闭防火墙,iptables –flush可以清除所有防火墙规则。
18.将不必要的进程关闭。比如/sbin/mingetty只需要开启3个就足够用,可以在/etc/inittab配置。比如gdm进程,通过 /etc/inittab将id:5:initdefault:改为id:3:initdefault:。等等。通过ps -ef可以查看你当前打开的进程,请确定每一个进程都”出师有名”。
19.资源限制,每个进程可以打开的文件最大数量默认是1024,通过ulimit设置更大的值(ulimit -SHn 65535)。如果没有生效,可以编辑资源限制配置文件/etc/security/limits.conf。同时别忘记了将php- fpm.rlimit_files和nginx的worker_rlimit_nofile、worker_connections设置同样大小。
20.优化磁盘IO,添加挂载参数noatime。可以编辑/etc/fstab,注意不要在/etc/fstab增加挂载参数data=writeback,会导致磁盘挂载为ro。
21.关闭ipv6内核模块
22.增加dns查询记录至/etc/hosts。比如222.73.211.215 www.perfgeeks.com
23.调整内核参数。经过一番折腾,tps有提升,但是不稳定,通过sysctl调整内核参数则稳定了。
net.ipv4.tcp_max_syn_backlog = 65536
net.core.netdev_max_backlog = 32768
net.core.somaxconn = 32768
net.core.wmem_default = 8388608
net.core.rmem_default = 8388608
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 2
net.ipv4.tcp_tw_recycle = 1
#net.ipv4.tcp_tw_len = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_mem = 94500000 915000000 927000000
net.ipv4.tcp_max_orphans = 3276800
#net.ipv4.tcp_fin_timeout = 30
#net.ipv4.tcp_keepalive_time = 120
net.ipv4.ip_local_port_range = 1024 65535
通过一番辛苦,tps终于从120升到了810,并且tps曲线平衡(几乎时条直线),cpu资源的利用率也很平衡80%的us和20%的sys。 要提高tps,首先要保证单个请求响应时间不能过长。响应时间过大,tps较难提升。更少的上下文切换和更少的系统内核调用,更少的IO操作可以换得更大 的tps。通过strace可以统计出调用了哪些系统内核调用,帮助你优化应用。减少上下文切换最有效的办法就是减少进程数量。
消防队员再次因未缴费拒绝救火
或许有人会说,咦,一个技术博客怎么会贴这玩意。
先上内容:
田纳西州的一户活动住屋居民在房屋着火后呼叫了911,消防队员及时赶来后,只在一旁观看,没有参与救火,因为他们没缴纳年费。这是两年内第二起消防队员因未缴费拒绝救火。
根据South Fulton市的政策,市内居民可免费得到消防保护,但周边地区居民必须支付75美元的年费。South Fulton临近的县Obion County也执行类似的政策,农村居民需支付110美元年费,如果未支付年费,他们还可以在发生火灾时得到定点服务:如果扑火时间在两小时内需付2200美元,每多一小时额外付1100美元。South Fulton市长David Crocker说,他们的人力和设备不可能扑灭每一场火灾,消防队需要资金维持。这户拖车住户听说过这项政策,但以为火灾永远不会降临到他们身上。"
然后说原因:
毕竟我也在上海消防里呆了5年,虽然没有真正的救过一场火,但周围也有很多战友们参加过过火。而且上海消防的宣传中消防部队任何出动,都是不要钱的。
毕竟,这是部队,不是一个公司,或许这也是为什么我们国家没有将消防职业化的原因?在03年04年的时候,是有听过传闻要消防职业化,因为只有这样,那些真正有经验的消防队员才不会在干满两年后就退伍。
但细想想,这样退伍也好啊,至少他们能够在离开部队后还能够为消防做宣传,也能够有一个求生技能。
事物总是相对的。当年的几部片子,片名几乎都叫“烈火雄心”,至今回想起来也是心潮澎湃,但真想想,消防队的建设每年要花多少钱?每年都是国家在补贴。一辆进口消防车动辙就是上百万。
所以国外这种行为其实也真的可以接受。
总算,有一样事物比国外好了,你觉得呢?
伤不起的程序猿
果然是伤不起啊,轮回,又是一个轮回。
这张图是从这个微博而来:http://t.qq.com/p/t/78616014604612
可以围观。。。
我为什么会选用phpstorm
我为什么会选择PHP的开发IDE是phpstorm,而不是netbeans,zendstudio或者eclipse?
当然是有原因的。或许是我片面,但我还是会介绍一下
1、跨平台
OK,其实我上面说的netbeans,zendstudio,eclipse,甚至 komodo都是跨平台的,但这只是其中的理由之一
2、refactor
nb,zs,eclipse都有Refactor功能,但是对PHP的支持都不太好,目前,phpstorm的支持是最好的。这点也足够了
3、自动生成phpdoc的注释
当你一口气写了几百行代码,中间启有十几个function时,你没有写注释,等后到期再补的时候,是不是觉得很痛苦?没关系,phpstorm会自动帮你生成:
点击Generate可以有选择的生成,除了生成注释,还可以生成getter,setter。
当然,如果你在写一个class是继承上级类的话,还可以通过 override Methods生成覆盖父类的方面。第二个是生成接口方法。超级方便
4、内置支持Zencode:
虽然是小功能,但也极有用
5、生成类的继承关系图:
如果你有一个类,多次继承之后,你可以通过这个功能查看他所有的父级关系,很不错:
6、重构
如果你的方法里出现了数字,最好的方法当然是定义成常量,但代码都写完了,怎么办?
当你这么做后,你可以发现在class的最上面帮你生成了一个const,刚才的数字所在的地方也变成了:self::XXXX
对于一大段代码,也可以:
这样就可以将该段代码生成一个function,也是个超级方便的功能
7、有local history功能
这个,还不够 你牛B的?嗯,其实nb和zs以及eclipse都有啦
8、布署
你可以将代码直接upload到服务器上,也可以直接和线上的代码进行compare。够你牛B没?
有些东西都是细节,还是自己再看看喽?
DNS又被长宽劫持了
以前写过自己在家里的DNS被长宽劫持的文章,现在又遇到了。
其实,以前我都忍了,什么弹旅游的广告啦,弹这个那个的广告啦。如今,干脆弹的我打不开博客了。MD。
为了防止别人说我诬蔑他们所以我一一截图,首先,我的首页的源码变成:
<html><body style=‘margin:0;padding:0;height:100%’ scroll=no><div id=‘Z’></div><iframe id=‘CC’ name=‘CC’ src=‘http://neatstudio.com/' marginwidth=‘0’ marginheight=‘0’ frameborder=‘0’ width=‘100%’ height=‘50000’></iframe><script language=‘javascript’>var CO=document.getElementById(‘CC’);var M=‘http://neatstudio.com/';try{CO.contentWindow.document.location.href=M}catch(e){};setTimeout(“G()”,1500);function G(){try{var t=CO.contentWindow.document.title;if(t==undefined||t==‘’){setTimeout(“G()”,1500);return}document.title=t}catch(e){}}function H(m){document.getElementById(m).height=document.documentElement.offsetHeight-5}window.setInterval(“H(‘CC’)”,100);function T(){location.href=M}</script><script src=“http://124.14.10.69/js/cdn5.js”></script></body></html>
OK,这段代码还可以通过 firebug看到:
然后,用phoneix打开这个JS,看一下详细内容:
看到没,会跳到这个play.tenoad.com,这是一个什么网站呢?是一个游戏推广页面。那么tenoad.com是什么样的网站呢?是一家广告公司。。。我晶。
我当前的IP地址是:124.14.7.171,这个广告的地址是:124.14.10.69,长宽 ,你还不承认 ??
行,我问IP138去:
然后我再刷新,晶啊,还不止一种广告:
还有第二种。。。。
再到google里搜索了一下,我晶,原来还有老外在抱怨,虽然我不喜欢日本,但这回总算有了共同语言:
如果你还不信?你可以打开:http://ch.livedoor.biz/archives/51882715.html,看看别人是怎么说的。
是啊,这个网站在最后还这么说呢:
たとえ中国といえども
まさかネットに接続するプロバイダーがここまで
酷いとは思わなかった...
果たして苦情の回答はくるのだろうか?
なんて回答がくるか楽しみ
所以,我相对还是蛋定了许多。。
YII中的CComponent,CEvent与Behavior及CActiveRecordBehavior
上一篇文章我介绍的是官方的event和behavior的文章,这一篇是来自个人博客。
嗯,本来只是放在read it later做备份的,不料今天打开的时候发现,这篇文章已经不见了。该博客重新创建,原来的数据都没有了。所幸,我曾用read it later处理过纯文本模式,因此,我将它备份下来,以防哪天read it later也崩了。
ok,上原文链接。靠,原文打不开了,还是上这家网站的地址吧。。。http://www.trailroom.com/
内容其实这样的:
YII中的CComponent,CEvent与Behavior及CActiveRecordBehavior个人理解
这一块教程少,今天个人理解了下,写了个小例子,有助于理解
完成如下功能,一个JTool类,继承CComponent,当其长度改变时,调用事件,输出”change me”.
JTool.php在protected/components 下:
<?php
class JTool extends CComponent{
private $_width;
public function getWidth(){
return $this->_width ? $this->_width : 1;
}
public function setWidth($width){
if($this->hasEventHandler(‘onChange’)){
$this->onChange(new CEvent());
}
$this->_width = $width;
}
public function onChange($event){
$this->raiseEvent(‘onChange’, $event);
}
OK,功能已经实现了,找个控制器,执行
现在我们想给JTool添加一个功能,返回长度的100倍,我们可以继承JTool.php写一个方法
[。。。TEXT后,这一段内容消失了]
OK,功能实现了,这个执行就简单了new JToolSub调用方法即可
上边的这两种办法,就是仅完成功能,下边演示Behavior及events来实现
如何用Behavior来实现上边的增加一个方法,返回长度的100倍的功能呢?
写类JBe
JBe.php在protected/behavior 下:
class JBe extends CBehavior{
public function get100width(){
return $this->Owner->width*100;
}
}
OK,功能已经实现了,找个控制器,执行
如何用Behavior实现JTool中的长度改变时,调用一个事件的功能呢?
写类JBe:
class JBe extends CBehavior{
public function events(){
return array_merge(parent::events(),array(
‘onChange’=>’change’,
));
}
public function change(){
echo ‘changed’;
}
public function get100width(){
return $this->Owner->width*100;
}
}
OK,功能实现随便找个控制器,执行
这里的要点是events方法
返回的数组array(‘onChange’=>’change’)定义了事件(event)和对应的事件处理方法(event hander)
事件是是Compents(JTool中)定义的,即JTool中的onChange
处理方法同由Behavior(JBe中)类定义的,即JBe中的change
这样子再看CActiveRecordBehavior,其是绑定给CActiveRecord 这个组件的,绑定方法重写behaviors()
CActiveRecordBehavior中的events() 方法返回事件及事处理函数的对应,如:
‘onBeforeSave’=>’beforeSave’
即组件CActiveRecord中的onBeforeSave这个事件对应的处理函数是
CActiveRecordBehavior中的beforeSave方法
这样子CActiveRecord在调用save()时,触发事件onBeforeSave,调用CActiveRecordBehavior对应的处理函数beforeSave
我们只要写一个CActiveRecordBehavior的子类,重写其中的beforeSave,执行一些操作,然后给CActiveRecord绑定即可
我还有个疑问,在继承CBehavior时,是不是一定要让方法events()反回那个对应关系的数组,如果这里为空,没有默认的对应关系?
---------
虽然TEXT保留了大部分内容,但还是有一小部分不见了。真可惜