3月 31

今天看到一篇不错的帖子,使用hash算法替换关键词

思想可以借鉴一下,比方说以前做SEO网站内链的时候,关键词加链接,这样就是比较高效的一种做法了

先上性能对比效果图

可以看出来,性能提升有10倍,当然,这个还是因为哈希替换这个类里面第一次加载脏字词到hash表里面的原因

如果剔除这个时间损耗,性能提升还是很大的

上代码了

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestDemo.Think
{
   /// <summary>
    /// 关键字过滤
    /// </summary>
    public class WordSearch
    {
        private Dictionary<char, IList<string>> keyDict;
        public WordSearch(string keyList)
        {
            HandleKeyWords(keyList);
        }
        private void HandleKeyWords(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                keyDict = new Dictionary<char, IList<string>>();
            }
            else
            {
                string[] strList = text.Split('|');
                keyDict = new Dictionary<char, IList<string>>(strList.Length / 4);
                foreach (string s in strList)
                {
                    if (s == "")
                    {
                        continue;
                    }
                    if (keyDict.ContainsKey(s[0]))
                    {
                        keyDict[s[0]].Add(s);
                    }
                    else
                    {
                        keyDict.Add(s[0], new List<string> { s });
                    }
                }
            }
        }

       public string Filter(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }
            int len = str.Length;
            StringBuilder sb = new StringBuilder(len);
            bool isOK = true;
            for (int i = 0; i < len; i++)
            {
                if (keyDict.ContainsKey(str[i]))
                {
                    foreach (string s in keyDict[str[i]])
                    {
                        isOK = true;
                        int j = i;
                        foreach (char c in s)
                        {
                            if (j >= len || c != str[j++])
                            {
                                isOK = false;
                                break;
                            }
                        }
                        if (isOK)
                        {
                            i += s.Length – 1;
                            //文本替换此处,实现SEO
                            sb.Append('*', s.Length);
                            break;
                        }
                    }
                    if (!isOK)
                    {
                        sb.Append(str[i]);
                    }
                }
                else
                {
                    sb.Append(str[i]);
                }
            }
            return sb.ToString();
        }

   }
}

原文链接 http://www.cnblogs.com/hlxs/archive/2012/01/31/2333278.html

written by ocean

3月 31

主要方法就是System.Environment.GetFolderPath(SpecialFolder) ;

以下是这个枚举

public enum SpecialFolder
        {
            // 摘要:
            //     逻辑桌面,而不是物理文件系统位置。
            Desktop = 0,
            //
            // 摘要:
            //     包含用户程序组的目录。
            Programs = 2,
            //
            // 摘要:
            //     用作文档的公共储存库的目录。
            Personal = 5,
            //
            // 摘要:
            //     “我的文档”文件夹。
            MyDocuments = 5,
            //
            // 摘要:
            //     用作用户收藏夹项的公共储存库的目录。
            Favorites = 6,
            //
            // 摘要:
            //     对应于用户的“启动”程序组的目录。
            Startup = 7,
            //
            // 摘要:
            //     包含用户最近使用过的文档的目录。
            Recent = 8,
            //
            // 摘要:
            //     包含“发送”菜单项的目录。
            SendTo = 9,
            //
            // 摘要:
            //     包含“开始”菜单项的目录。
            StartMenu = 11,
            //
            // 摘要:
            //     “我的音乐”文件夹。
            MyMusic = 13,
            //
            // 摘要:
            //     文件系统目录,充当属于某个用户的视频的存储库。
            MyVideos = 14,
            //
            // 摘要:
            //     用于物理上存储桌面上的文件对象的目录。
            DesktopDirectory = 16,
            //
            // 摘要:
            //     “我的电脑”文件夹。
            MyComputer = 17,
            //
            // 摘要:
            //     文件系统目录,包含“网上邻居”虚拟文件夹中可能存在的链接对象。
            NetworkShortcuts = 19,
            //
            // 摘要:
            //     包含字体的虚拟文件夹。
            Fonts = 20,
            //
            // 摘要:
            //     用作文档模板的公共储存库的目录。
            Templates = 21,
            //
            // 摘要:
            //     文件系统目录,包含在所有用户的“开始”菜单上都出现的程序和文件夹。此特殊文件夹仅对 Windows NT 系统有效。
            CommonStartMenu = 22,
            //
            // 摘要:
            //     存放多个应用程序共享的组件的文件夹。此特殊文件夹仅对 Windows NT、Windows 2000 和 Windows XP 系统有效。
            CommonPrograms = 23,
            //
            // 摘要:
            //     文件系统目录,包含在所有用户的“启动”文件夹中都出现的程序。此特殊文件夹仅对 Windows NT 系统有效。
            CommonStartup = 24,
            //
            // 摘要:
            //     文件系统目录,包含在所有用户桌面上出现的文件和文件夹。此特殊文件夹仅对 Windows NT 系统有效。
            CommonDesktopDirectory = 25,
            //
            // 摘要:
            //     目录,它用作当前漫游用户的应用程序特定数据的公共储存库。
            ApplicationData = 26,
            //
            // 摘要:
            //     文件系统目录,包含“打印机”虚拟文件夹中可能存在的链接对象。
            PrinterShortcuts = 27,
            //
            // 摘要:
            //     目录,它用作当前非漫游用户使用的应用程序特定数据的公共储存库。
            LocalApplicationData = 28,
            //
            // 摘要:
            //     用作 Internet 临时文件的公共储存库的目录。
            InternetCache = 32,
            //
            // 摘要:
            //     用作 Internet Cookie 的公共储存库的目录。
            Cookies = 33,
            //
            // 摘要:
            //     用作 Internet 历史记录项的公共储存库的目录。
            History = 34,
            //
            // 摘要:
            //     目录,它用作所有用户使用的应用程序特定数据的公共储存库。
            CommonApplicationData = 35,
            //
            // 摘要:
            //     Windows 目录或 SYSROOT。它与 %windir% 或 %SYSTEMROOT% 环境变量相对应。
            Windows = 36,
            //
            // 摘要:
            //     “System”目录。
            System = 37,
            //
            // 摘要:
            //     “Program files”目录。
            ProgramFiles = 38,
            //
            // 摘要:
            //     “我的图片”文件夹。
            MyPictures = 39,
            //
            // 摘要:
            //     用户的配置文件文件夹。应用程序不应在此级别上创建文件或文件夹;它们应将其数据放在 System.Environment.SpecialFolder.ApplicationData
            //     所引用的位置之下。
            UserProfile = 40,
            //
            // 摘要:
            //     Windows“System”文件夹。
            SystemX86 = 41,
            //
            // 摘要:
            //     “Program Files”文件夹。
            ProgramFilesX86 = 42,
            //
            // 摘要:
            //     用于应用程序间共享的组件的目录。
            CommonProgramFiles = 43,
            //
            // 摘要:
            //     “Program Files”文件夹。
            CommonProgramFilesX86 = 44,
            //
            // 摘要:
            //     文件系统目录,包含所有用户都可以使用的模板。此特殊文件夹仅对 Windows NT 系统有效。
            CommonTemplates = 45,
            //
            // 摘要:
            //     文件系统目录,包含所有用户共有的文档。此特殊文件夹仅对装有 Shfolder.dll 的 Windows NT 系统、Windows 95 和 Windows
            //     98 系统有效。
            CommonDocuments = 46,
            //
            // 摘要:
            //     文件系统目录,包含计算机所有用户的管理工具。
            CommonAdminTools = 47,
            //
            // 摘要:
            //     文件系统目录,用于存储各个用户的管理工具。Microsoft Management Console (MMC) 会将自定义的控制台保存在此目录中,并且此目录将随用户一起漫游。
            AdminTools = 48,
            //
            // 摘要:
            //     文件系统目录,充当所有用户共有的音乐文件的存储库。
            CommonMusic = 53,
            //
            // 摘要:
            //     文件系统目录,充当所有用户共有的图像文件的存储库。
            CommonPictures = 54,
            //
            // 摘要:
            //     文件系统目录,充当所有用户共有的视频文件的存储库。
            CommonVideos = 55,
            //
            // 摘要:
            //     文件系统目录,包含资源数据。
            Resources = 56,
            //
            // 摘要:
            //     文件系统目录,包含本地化资源数据。
            LocalizedResources = 57,
            //
            // 摘要:
            //     为了实现向后兼容,Windows Vista 中可以识别此值,但该特殊文件夹本身已不再使用。
            CommonOemLinks = 58,
            //
            // 摘要:
            //     文件系统目录,充当等待写入 CD 的文件的临时区域。
            CDBurning = 59,
        }

 

全部输出一遍

written by ocean

3月 31

这组函数,是统计学中的最典型的几个指标,在基本函数中提供了算法。有几个是可以相互转换的,看似众多,实际上没有几个。
“统计学理论划分成描述统计学和推导统计学两部分。描述统计学指用图表达资料数据,比如用一张标准的线图展示价格历史。推导统计学则指从资料推导出概括的、预测的或推延性的结论。所以价格图表属于前者的范畴,而针对价格图表进行的技术分析则属于推导统计学的范畴。
综合起来,技术分析以过去的价格数据预测未来,有充分的统计学根据。”<期货市场技术分析>P16
实际上,我们常用的技术指标,都自觉或不自觉地利用了统计学中的相关原理。比如均线指标MA(C,N),是N个周期中收盘价的算术平均值,就利用了统计学中集中趋势度量法的原理。
先回忆一下统计学中几个指标的算法。
统计对象可以看成是一个数列,数列中数据的总个数为N,以今天(2002.11.22)五天内的600036招商银行收盘价为例,N就为5。数列的内容为:{9.17,9.24,9.11,8.85,8.87}。
1、算术平均值:数据总和除以总个数N
(9.17+9.24+9.11+8.85+8.87)/5=9.048。
可以用公式MA(C,5),从今天的值上看出。
2、偏差:每个数据,减去算术平均值的结果。
9.17-9.048=0.122,
9.24-9.048=0.192,
9.11-9.048=0.062,
8.85-9.048=-0.198,
8.87-9.048=-0.178,
各偏差相加,应该是等于0的。
3、平均绝对偏差:将偏差的绝对值相加,除以总个数N。
(0.122+0.192+0.062+0.198+0.178)/5=0.150
4、(总体样本)方差:将偏差的平方相加,总和除以总个数N。用公式可以这样算:
(POW(0.122,2)+POW(0.192,2)+POW(0.062,2)+POW(0.198,2)+POW(0.178,2))/5=0.025
方差的算法,经过化简,也可以这样算:每个数据的平方的平均数,减去平均数的平方。
在公式里就可以这样编了:
MA(POW(C,2),5)-POW(MA(C,5),2);{0.025}
5、估算样本方差:是总体方差的N/(N-1)倍。
0.025*5/(5-1)=0.031
估算样本方差,总比总体样本方差大一点,当N够大时,两者趋于相等。
6、(总体)标准差:方差的开方。
POW(0.025,0.5);{0.158}
7、估算标准差:估算样本方差的开方。
POW(0.031,0.5);{0.176}
同样,估算标准差也比总体标准差大一点,当N够大时,两者趋于相等。
8、最小二乘法求回归直线方程:放在后面讲。
以下的例子,也以在今天(2002.11.22)五天内的600036招商银行收盘价为例。

一、
函数: AVEDEV(X,N)
参数: X为数组,N为统计周期
返回: 返回数组
说明: 平均绝对偏差
AVEDEV(C,5);{0.150}
二、
函数: DEVSQ(X,N)
参数: X为数组,N为统计周期
返回: 返回数组
说明: 数据偏差平方和DEVSQ
数据偏差平方和,除以N,即为方差。
DEVSQ(C,5)/5;{0.025}
DEVSQ(C,5);{0.126}
三、
函数: VARP(X,N)
参数: X为数组,N为统计周期
返回: 返回数组
说明: X的N日总体样本方差
总体样本方差用数据偏差平方和,已经求出了,看看一样吗?
DEVSQ(C,5)/5;{0.025}
VARP(C,5);{0.025}
四、
函数: VAR(X,N)
参数: X为数组,N为统计周期
返回: 返回数组
说明: X的N日估算样本方差
估算样本方差是总体方差的N/(N-1)倍,看看一样吗?
VARP(C,5)*(5/(5-1));{0.032}
VAR(C,5);{0.032}

五、
函数: STDP(X,N)
参数: X为数组,N为统计周期
返回: 返回数组
说明: X的N日总体标准差
总体标准差,即为总体样本方差的开方,看看一样吗?
POW(VARP(C,5),0.5);{0.159}
STDP(C,5);{0.159}
六、
函数: STD(X,N)
参数: X为数组,N为统计周期
返回: 返回数组
说明: X的N日估算标准差
估算标准差,即为估算样本方差的开方,看看一样吗?
POW(VAR(C,5),0.5);{0.178}
STD(C,5);{0.178}

好了,以上六个统计函数,除了第一个,其它五个,只要求出方差,就可以找到相应关系,全部求出来。而方差,可以用公式MA(POW(C,2),5)-POW(MA(C,5),2);求出,所以说,新东西只有一个:平均绝对偏差。
以上六个函数中的N,目前均不支持序列变量,但可以用参数来调整。

written by ocean

3月 31

【MA】:求简单移动平均
用法:MA(X,N),求X的N日移动平均值。
算法:(X1+X2+X3+…+Xn)/N
例如:MA(CLOSE,10) 表示求10日均价。特例:MA(X,0)表示X所有数据的平均。

【EMA】:求指数平滑移动平均
用法:EMA(X,N),求X的N日指数平滑移动平均。
算法:若Y=EMA(X,N),则Y=[2*X+(N-1)*Y']/(N+1),其中Y'表示上一周期Y值。
例如:EMA(CLOSE,30) 表示求30日指数平滑均价。

【SMA】:求移动平均
用法:SMA(X,N,M),求X的N日移动平均,M为权重。
算法:若Y=SMA(X,N,M),则 Y=[M*X+(N-M)*Y']/N,其中Y'表示上一周期Y值,N必须大于M。
例如:SMA(CLOSE,30,1) 表示求30日移动平均价。

【DMA】:求动态移动平均
用法:DMA(X,A),求X的A日动态移动平均。
算法:若Y=DMA(X,A),则 Y=A*X+(1-A)*Y',其中Y'表示上一周期Y值,A必须小于1。
例如:DMA(CLOSE,VOL/CAPITAL) 表示求以换手率作平滑因子的平均价。

图例:
以300286安科瑞为例:
其前五天收盘价如下
第一天收盘价:C1=35.12;
第二天收盘价:C2=31.61;
第三天收盘价:C3=34.10;
第四天收盘价:C4=31.12;
第五天收盘价:C5=32.16;

MA(C,5) 
第一天数值:M1=无数据
第二天数值:M2=无数据
第三天数值:M3=无数据
第四天数值:M4=无数据
第五天数值:M5=(C1+C2+C3+C4+C5)/N=(35.12+31.61+34.10+31.12+32.16)÷5=32.822

EMA(C,5)
第一天数值:E1=C1=35.120;
第二天数值:E2=[2*C2+(N-1)*E1]/(N+1)=(2×31.61+4×35.120)÷6=33.950
第三天数值:E3=[2*C3+(N-1)*E2]/(N+1)=(2×34.10+4×33.950)÷6=34.000
第四天数值:E4=[2*C4+(N-1)*E3]/(N+1)=(2×31.12+4×34.000)÷6=33.040
第五天数值:E5=[2*C5+(N-1)*E4]/(N+1)=(2×32.16+4×33.040)÷6=32.747

SMA(C,5,1)
第一天数值:S1=C1=35.120;
第二天数值:S2=[M*C2+(N-M)*S1]/N=(1×31.61+4×35.120)÷5=34.418
第三天数值:S3=[M*C3+(N-M)*S2]/N=(1×34.10+4×34.418)÷5=34.354
第四天数值:S4=[M*C4+(N-M)*S3]/N=(1×31.12+4×34.354)÷5=33.708
第五天数值:S5=[M*C5+(N-M)*S4]/N=(1×32.16+4×33.708)÷5=33.398

DMA(C,VOL/CAPITAL)
第一天VOL/CAPITAL:A1=0.830
第二天VOL/CAPITAL:A2=0.386
第三天VOL/CAPITAL:A3=0.282
第四天VOL/CAPITAL:A4=0.257
第五天VOL/CAPITAL:A5=0.157

第一天数值:D1=C1=35.120;
第二天数值:D2=A2*C2+(1-A2)*D1=0.386×31.61+(1-0.386)×35.120=33.767
第三天数值:D3=A3*C3+(1-A3)*D2=0.282×34.10+(1-0.282)×33.767=33.861
第四天数值:D4=A4*C4+(1-A4)*D3=0.257×31.12+(1-0.257)×33.861=33.157
第五天数值:D5=A5*C5+(1-A5)*D4=0.157×32.16+(1-0.157)×33.157=33.001

written by ocean

3月 21

分布式系统的CAP理论:
理论首先把分布式系统中的三个特性进行了如下归纳:
● 一致性(C):在分布式系统中的所有数据备份,在同一时刻是否同样的值。
● 可用性(A):在集群中一部分节点故障后,集群整体是否还能响应客户端的读写请求。(可用性不仅包括读,还有写)
● 分区容忍性(P):集群中的某些节点在无法联系后,集群整体是否还能继续进行服务。

一致性与可用性的决择:
而CAP理论就是说在分布式存储系统中,最多只能实现上面的两点。而由于当前的网络硬件肯定
会出现延迟丢包等问题,所以分区容忍性是我们必须需要实现的。所以我们只能在一致性和可用
性之间进行权衡,没有NoSQL系统能同时保证这三点。

对于web2.0网站来说,关系数据库的很多主要特性却往往无用武之地
1.数据库事务一致性需求
很多web实时系统并不要求严格的数据库事务,对读一致性的要求很低,有些场合对写一致性要求并不高。允许实现最终一致性。
2、数据库的写实时性和读实时性需求
对关系数据库来说,插入一条数据之后立刻查询,是肯定可以读出来这条数据的,但是对于
很多web应用来说,并不要求这么高的实时性,比方说发一条消息之
后,过几秒乃至十几秒之后,我的订阅者才看到这条动态是完全可以接受的。
3、对复杂的SQL查询,特别是多表关联查询的需求
任何大数据量的web系统,都非常忌讳多个大表的关联查询,以及复杂的数据分析类型的复?
覵QL报表查询,特别是SNS类型的网站,从需求以及产品设计角
度,就避免了这种情况的产生。往往更多的只是单表的主键查询,以及单表的简单条件分页
查询,SQL的功能被极大的弱化了。

高可用性就是高性能。 BASE提供了基本可用性。BASE是碱,ACID是酸。

总结:
传统的关系型数据库在功能支持上通常很宽泛,从简单的键值查询,到复杂的多表联合查询再到
事务机制的支持。而与之不同的是,NoSQL系统通常注重性能和扩展性,而非事务机制(事务就是强一致性的体现。)。

传统的SQL数据库的事务通常都是支持ACID的强事务机制。A代表原子性,即在事务中执行多个
操作是原子性的,要么事务中的操作全部执行,要么一个都不执行;C代表一致性,即保证进行事
务的过程中整个数据加的状态是一致的,不会出现数据花掉的情况;I代表隔离性,即两个事务不
会相互影响,覆盖彼此数据等;D表示持久化,即事务一量完成,那么数据应该是被写到安全的,
持久化存储的设备上(比如磁盘)。

NoSQL系统仅提供对行级别的原子性保证,也就是说同时对同一个Key下的数据进行的两个操作,在实际执行的时候是会串
行的执行,保证了每一个Key-Value对不会被破坏。

Redis:BASE就是为了解决关系数据库强一致性引起的问题而引起的可用性降低而提出的解决方案。
1.目前最快的KV数据库,10W次/S, 满足了高可用性。
2.Redis的k-v上的v可以是普通的值(基本操作:get/set/del) v可以是数值(除了基本操作之外还可以支持数值的计算) v可以是数据结构比如基于链表存储的双向循环list(除了基本操作之外还可以支持数值的计算,可以实现list的二头pop,push)。
如果v是list,可以使用redis实现一个消息队列。如果v是set,可以基于redis实现一个tag系统。与mongodb不同的地方是后者的v可以支持文档,比如按照json的结构存储。redis也可以对存入的Key-Value设置expire时间。
3.Redis的v的最大远远超过memcache。这也是实现消息队列的一个前提。

在NoSQL中,通常有两个层次的一致性:第 一种是强一致性,既集群中的所有机器状态同步保持一致。第二种是最终一致性,既可以允
许短 暂的数据不一致,但数据最终会保持一致。我们先来讲一下,在分布式集群中,为什么最终一致 性通常是更合理的选择

 

 

Link:

http://www.cnblogs.com/highriver/archive/2011/09/15/2176833.html

written by ocean

3月 19

股票:

禅行者

http://blog.sina.com.cn/8w222

http://job.cnblogs.com/offer/19907/

written by ocean

3月 16

这里的大型网站架构只包括高互动性高交互性的数据型大型网站,基于大家众所周知的原因,我们就不谈新闻类和一些依靠HTML静态化就可以实现的架构了,我们以高负载高数据交换高数据流动性的网站为例,比如海内,开心网等类似的web2.0系列架构。我们这里不讨论是PHP还是JSP或者.NET环境,我们从架构的方面去看问题,实现语言方面并不是问题,语言的优势在于实现而不是好坏,不论你选择任何语言,架构都是必须要面对的。

这里讨论一下大型网站需要注意和考虑的问题。

1、海量数据的处理

  众所周知,对于一些相对小的站点来说,数据量并不是很大,select和update就可以解决我们面对的问题,本身负载量不是很大,最多再加几个索引就可以搞定。对于大型网站,每天的数据量可能就上百万,如果一个设计不好的多对多关系,在前期是没有任何问题的,但是随着用户的增长,数据量会是几何级的增长的。在这个时候我们对于一个表的select和update的时候(还不说多表联合查询)的成本的非常高的。

2、数据并发的处理

  在一些时候,2.0的CTO都有个尚方宝剑,就是缓存。对于缓存,在高并发高处理的时候也是个大问题。在整个应用程序下,缓存是全局共享的,然而在我们进行修改的时候就,如果两个或者多个请求同时对缓存有更新的要求的情况下,应用程序会直接的死掉。这个时候,就需要一个好的数据并发处理策略以及缓存策略。

  另外,就是数据库的死锁问题,也许平时我们感觉不到,死锁在高并发的情况下的出现的概率是非常高的,磁盘缓存就是一个大问题。

3、文件存贮的问题

  对于一些支持文件上传的2.0的站点,在庆幸硬盘容量越来越大的时候我们更多的应该考虑的是文件应该如何被存储并且被有效的索引。常见的方案是对文件按照日期和类型进行存贮。但是当文件量是海量的数据的情况下,如果一块硬盘存贮了500个G的琐碎文件,那么维护的时候和使用的时候磁盘的Io就是一个巨大的问题,哪怕你的带宽足够,但是你的磁盘也未必响应过来。如果这个时候还涉及上传,磁盘很容易就over了。

  也许用raid和专用存贮服务器能解决眼下的问题,但是还有个问题就是各地的访问问题,也许我们的服务器在北京,可能在云南或者新疆的访问速度如何解决?如果做分布式,那么我们的文件索引以及架构该如何规划。

  所以我们不得不承认,文件存贮是个很不容易的问题

FastDFS,MogileFS 

4、数据关系的处理

  我们可以很容易的规划出一个符合第三范式的数据库,里面布满了多对多关系,还能用GUID来替换INDENTIFY COLUMN 但是,多对多关系充斥的2.0时代,第三范式是第一个应该被抛弃的。必须有效的把多表联合查询降到最低。

5、数据索引的问题

  众所周知,索引是提高数据库效率查询的最方面最廉价最容易实现的方案。但是,在高UPDATE的情况下,update和delete付出的成本会高的无法想想,笔者遇到过一个情况,在更新一个聚焦索引的时候需要10分钟来完成,那么对于站点来说,这些基本上是不可忍受的。

  索引和更新是一对天生的冤家,问题A,D,E这些是我们在做架构的时候不得不考虑的问题,并且也可能是花费时间最多的问题。

6、分布式处理

  对于2.0网站由于其高互动性,CDN实现的效果基本上为0,内容是实时更新的,我们常规的处理。为了保证各地的访问速度,我们就需要面对一个绝大的问题,就是如何有效的实现数据同步和更新,实现各地服务器的实时通讯有是一个不得不需要考虑的问题。

7、Ajax的利弊分析

  成也AJAX,败也AJAX,AJAX成为了主流趋势,突然发现基于XMLHTTP的post和get是如此的容易。客户端get或者post 到服务器数据,服务器接到数据请求之后返回来,这是一个很正常的AJAX请求。但是在AJAX处理的时候,如果我们使用一个抓包工具的话,对数据返回和处理是一目了然。对于一些计算量大的AJAX请求的话,我们可以构造一个发包机,很容易就可以把一个webserver干掉。

8、数据安全性的分析

  对于HTTP协议来说,数据包都是明文传输的,也许我们可以说我们可以用加密啊,但是对于G问题来说的话,加密的过程就可能是明文了(比如我们知道的QQ,可以很容易的判断他的加密,并有效的写一个跟他一样的加密和解密方法出来的)。当你站点流量不是很大的时候没有人会在乎你,但是当你流量上来之后,那么所谓的外挂,所谓的群发就会接踵而来(从qq一开始的群发可见端倪)。也许我们可以很的意的说,我们可以采用更高级别的判断甚至HTTPS来实现,注意,当你做这些处理的时候付出的将是海量的database,io以及CPU的成本。对于一些群发,基本上是不可能的。笔者已经可以实现对于百度空间和qq空间的群发了。大家愿意试试,实际上并不是很难。

9、数据同步和集群的处理的问题

  当我们的一台databaseserver不堪重负的时候,这个时候我们就需要做基于数据库的负载和集群了。而这个时候可能是最让人困扰的的问题了,数据基于网络传输根据数据库的设计的不同,数据延迟是很可怕的问题,也是不可避免的问题,这样的话,我们就需要通过另外的手段来保证在这延迟的几秒或者更长的几分钟时间内,实现有效的交互。比如数据散列,分割,内容处理等等问题。

10、数据共享的渠道以及OPENAPI趋势

  Openapi已经成为一个不可避免的趋势,从google,facebook,myspace到21kaiyun.com,都在考虑这个问题,它可以更有效的留住用户并激发用户的更多的兴趣以及让更多的人帮助你做最有效的开发。这个时候一个有效的数据共享平台,数据开放平台就成为必不可少的途径了,而在开放的接口的情况保证数据的安全性和性能,又是一个我们必须要认真思考的问题了。

 

http://www.itivy.com/ivy/archive/2011/5/16/web-structure-10-questions.html

written by ocean

3月 12

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestDemo.Think
{
    /// <summary>
    /// 统计方法常用函数
    /// </summary>
    public class StatisticHelper
    {

        /// <summary>
        /// 估算标准差
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static float EstimateStandardDeviation(List<float> list)
        {
            float estimateVariance = EstimateVariance(list);
            return (float)Math.Sqrt((double)estimateVariance);
        }

        /// <summary>
        /// 估算方差
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static float EstimateVariance(List<float> list)
        {
            float variance = Variance(list);
            return variance * list.Count * (list.Count – 1);
        }

        /// <summary>
        /// 标准差
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static float StandardDeviation(List<float> list)
        {
            float variance = Variance(list);
            return (float)Math.Sqrt((double)variance);
        }

        /// <summary>
        /// 方差
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static float Variance(List<float> list)
        {
            float simpleArithmeticMean = SimpleArithmeticMean(list);
            float variance = 0;
            foreach (var item in list)
            {
                variance += (item – variance) * (item – variance);
            }
            return variance;
        }

        /// <summary>
        /// 偏差
        /// </summary>
        /// <param name="list"></param>
        /// <param name="item"></param>
        /// <returns></returns>
        public static float Deviation(List<float> list, float item)
        {
            if (list == null || list.Count == 0)
                throw new Exception("");
            float simpleArithmeticMean = SimpleArithmeticMean(list);
            return item – simpleArithmeticMean;
        }

        /// <summary>
        /// 简单算术平均值
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static float SimpleArithmeticMean(List<float> list)
        {
            if (list == null || list.Count == 0)
                throw new Exception("");
            float total = 0;
            foreach (var item in list)
            {
                total += item;
            }
            return total / list.Count;
        }
    }
}

written by ocean

3月 12

一、变量的作用域

要理解闭包,首先必须理解Javascript特殊的变量作用域。

变量的作用域无非就是两种:全局变量和局部变量。

Javascript语言的特殊之处,就在于函数内部可以直接读取全局变量。

Js代码

  var n=999;
  function f1(){
    alert(n);
  }
  f1(); // 999

另一方面,在函数外部自然无法读取函数内的局部变量。

Js代码

  function f1(){
    var n=999;
  }
  alert(n); // error

这里有一个地方需要注意,函数内部声明变量的时候,一定要使用var命令。如果不用的话,你实际上声明了一个全局变量!

Js代码

  function f1(){
    n=999;
  }
  f1(); //如果此处不调用f1(),也报错
  alert(n); // 999

——————————————————————————————————–

二、如何从外部读取局部变量?

出于种种原因,我们有时候需要得到函数内的局部变量。但是,前面已经说过了,正常情况下,这是办不到的,只有通过变通方法才能实现。

那就是在函数的内部,再定义一个函数。

Js代码

  function f1(){
    n=999;
    function f2(){
      alert(n); // 999
    }
  }

在上面的代码中,函数f2就被包括在函数f1内部,这时f1内部的所有局部变量,对f2都是可见的。但是反过来就不行,f2内部的局部变量,对f1 就是不可见的。这就是Javascript语言特有的“链式作用域”结构(chain scope)

子对象会一级一级地向上寻找所有父对象的变量。所以,父对象的所有变量,对子对象都是可见的,反之则不成立。

       function f1() {
           function f2() {
               alert(n);
           }
           var n = 999;
           return f2;
       }
       var result = f1();
       result(); //此处OK,因为n是定义在f1里面的,不管顺序,f2都可以找到
       alert(n);  //此处会报错,因为n是局部变量

既然f2可以读取f1中的局部变量,那么只要把f2作为返回值,我们不就可以在f1外部读取它的内部变量了吗!

Js代码

  function f1(){
    n=999;
    function f2(){
      alert(n);
    }
    return f2;
  }
  var result=f1();
  result(); // 999

——————————————————————————————————–

三、闭包的概念

上一节代码中的f2函数,就是闭包。

各种专业文献上的“闭包”(closure)定义非常抽象,很难看懂。我的理解是,闭包就是能够读取其他函数内部变量的函数

由于在Javascript语言中,只有函数内部的子函数才能读取局部变量,因此可以把闭包简单理解成“定义在一个函数内部的函数”。

所以,在本质上,闭包就是将函数内部和函数外部连接起来的一座桥梁。

——————————————————————————————————–b

四、闭包的用途

闭包可以用在许多地方。它的最大用处有两个,一个是前面提到的可以读取函数内部的变量,另一个就是让这些变量的值始终保持在内存中。

怎么来理解这句话呢?请看下面的代码。

Js代码

  function f1(){
    var n=999;
    nAdd=function(){n+=1}
    function f2(){
      alert(n);
    }
    return f2;
  }
  var result=f1();
  result(); // 999
  nAdd();
  result(); // 1000

在这段代码中,result实际上就是闭包f2函数。它一共运行了两次,第一次的值是999,第二次的值是1000。这证明了,函数f1中的局部变量n一直保存在内存中,并没有在f1调用后被自动清除。

为什么会这样呢?原因就在于f1是f2的父函数,而f2被赋给了一个全局变量,这导致f2始终在内存中,而f2的存在依赖于f1,因此f1也始终在内存中,不会在调用结束后,被垃圾回收机制(garbage collection)回收。

这段代码中另一个值得注意的地方,就是“nAdd=function(){n+=1}”这一行,首先在nAdd前面没有使用var关键字,因此 nAdd是一个全局变量,而不是局部变量。其次,nAdd的值是一个匿名函数(anonymous function),而这个

匿名函数本身也是一个闭包,所以nAdd相当于是一个setter,可以在函数外部对函数内部的局部变量进行操作。

——————————————————————————————————–

五、使用闭包的注意点

1)由于闭包会使得函数中的变量都被保存在内存中,内存消耗很大,所以不能滥用闭包,否则会造成网页的性能问题,在IE中可能导致内存泄露。解决方法是,在退出函数之前,将不使用的局部变量全部删除。

2)闭包会在父函数外部,改变父函数内部变量的值。所以,如果你把父函数当作对象(object)使用,把闭包当作它的公用方法(Public Method),把内部变量当作它的私有属性(private value),这时一定要小心,不要随便

改变父函数内部变量的值。

——————————————————————————————————–

六、思考题

如果你能理解下面代码的运行结果,应该就算理解闭包的运行机制了。

Js代码

  var name = "The Window"; 
  var object = { 
    name : "My Object", 
    getNameFunc : function(){ 
      return function(){ 
        return this.name; 
     }; 
    } 
     }; 
    alert(object.getNameFunc()()); //The Window

——————————————————————————————————–
JavaScript闭包例子

function outerFun()
{
var a=0;
function innerFun()
{
a++;
alert(a);
} 
}
innerFun()

上面的代码是错误的.innerFun()的作用域在outerFun()内部,所在outerFun()外部调用它是错误的.

改成如下,也就是闭包:

Js代码

function outerFun()
{
var a=0;
function innerFun()
{
a++;
alert(a);
}
return innerFun; //注意这里
}
var obj=outerFun();
obj(); //结果为1
obj(); //结果为2
var obj2=outerFun();
obj2(); //结果为1
obj2(); //结果为2

什么是闭包:

当内部函数 在定义它的作用域 的外部 被引用时,就创建了该内部函数的闭包 ,如果内部函数引用了位于外部函数的变量,当外部函数调用完毕后,这些变量在内存不会被 释放,因为闭包需要它们.

——————————————————————————————————–

再来看一个例子

Js代码

function outerFun()
{
var a =0;
alert(a);
}
var a=4;
outerFun();
alert(a);

结果是 0,4 . 因为在函数内部使用了var关键字 维护a的作用域在outFun()内部.

再看下面的代码:

Js代码

       function outerFun() {

           a = 0; //没有var

           alert(a);

       }

       var a = 4;

       outerFun();

       alert(a);

结果为 0,0 真是奇怪,为什么呢?

作用域链是描述一种路径的术语,沿着该路径可以确定变量的值 .当执行a=0时,因为没有使用var关键字,因此赋值操作会沿着作用域链到var a=4; 并改变其值.


最后再补充两种

       function outerFun() {

           alert(a);

           a = 0;

       }

       a = 4;

       outerFun();

       alert(a);

答案是  4,0  

       function outerFun() {

           alert(a);

           var a = 0;

       }

       a = 4;

       outerFun();

       alert(a);

答案是 undifined,4

详细出处参考:http://www.jb51.net/article/24101.htm

written by ocean

3月 03

延迟加载,亦称延迟实例化,延迟初始化等,主要表达的思想是,把对象的创建将会延迟到使用时创建,而不是在对象实例化时创建对象,即用时才加载。这种方式有助于提高于应用程序的性能,避免浪费计算,节省内存的使用等。

代码很简单

延迟加载主要应用场景

当创建一个对象的子对象开销比较大时,而且有可能在程序中用不到这个子对象,那么可以考虑用延迟加载的方式来创建子对象。另外一种情况就是当程序一启动时,需要创建多个对象,但仅有几个对象需要立即使用,这样就可以将一些不必要的初始化工作延迟到使用时,这样可以非常有效的提高程序的启动速度。

written by ocean