对于今年的期望就是自己的技术能够继续提升，继续实践TDD开发……当然今年的热门技术也要数HTML5 和 移动终端的应用开发。我只对游戏类开发有点兴趣，可惜android的游戏开发的书实在太少，objective-c倒是有很多关于游戏开发的书，但是开发平台需要mac系统，是个相当大的问题，2010年用了相当痛苦的半个月去尝试双系统安装，结果显卡驱动还是没装上，拖窗口和滚动会花屏。

    javascript的TDD有了qunit的支持，弄起来也舒服很多了，在javascript变的越来越重要的当今，有相当必要的重视。

下面是 quinit的界面

     其他要说的就是……PS3和PSPGO都破解啦！！万岁！！！

     然后，祝博客里的朋友们新的一年大展宏图，身体健康！！

还在考虑要加些什么更cool的东西上去……呃，我不会做图是个很严重的问题……　

结果居然遇上黑屏死机

就是到了这个厂商名过后，就黑屏死机了……

最后，居然给我发现是蓝牙的问题……

GOD OF WAR GHOST OF SPARTA ... close bluetooth...

贴下游戏画面……

  现在连6.20都还没破解……

  安息吧，盗版玩家……

  不过试玩版还需要plus用户才能试玩……

    私以为，年底会出这么多重磅的游戏，而PSP6.20系统又还没完全破解，现在6.31已经更新到PSPGO上了，要是年底的游戏，比如《战神》是6.30系统的话，那大家估计都要哭了……

放上个人觉得算大作的游戏:

patapon3

皇家骑士团

战神

当然……主菜，怪物猎人3!!

    换PSPGO的玩家角度来看，貌似还有点安慰……

                var tipbox = s.tipbox;
                var delay = s.delay || 200;
                var overtime = s.overtime || 200;
                var et_event = s.ev_event || "show";
                var ot_event = s.ot_event || "hide";
                var et_handler = s.et_handler || null;
                var ot_handler = s.ot_handler || null;

                this.live("mouseenter", function () {
                    ktip_isOver = true;
                    $(tipbox).stop(true, true);

                    if (et_handler != null && et_handler.call(this))
                        return;

                    $(tipbox)[et_event]();
                });

                this.live("mouseleave", function () {
                    ktip_isOver = false;
                    setTimeout(function () {
                        if (ktip_isOver == false) {

                            if (ot_handler != null && ot_handler.call(this))
                                return;

                            $(tipbox)[ot_event](delay);
                        }
                    }, overtime);
                });
            }
        })(jQuery);

//用法

/*

        $(function () {
            $("span").ktip({
                tipbox: $("#blockshow")
            });
        });

*/

//PS:最近喜欢封装代码，然后用回调函数……

    var dragObj = window.dragObj = null;
    var ix = window.ix = 0;
    var iy = window.iy = 0;
    var ktempStyle = "";

    /*鼠标容差器*/
    var movecount = window.movecount = 0;

    this.mousedown(function (event) {
        var e = event || window.event;

        this.mousedown_event = null;
        this.moving_event = null;
        this.beforemove_event = null;
        this.mouseup_event = null;
        this.doRest = false;

        /*成员匹配赋值*/
        if (s != null) {
            for (var i in s) {
                this[i] = s[i];
            }
        }

        ix = e.clientX - $(this).offset().left;
        iy = e.clientY - $(this).offset().top;

        dragObj = this;
        dragObj.isDrag = false;

        ktempStyle = dragObj.getAttribute("style");
        /*处理鼠标点下事件*/
        if (this.mousedown_event != null && typeof (this.mousedown_event) == "function")
            this.mousedown_event.call(this, e);

        $(document).bind("mousemove", function (event) {
            if (movecount < 1) {
                movecount++;
                return;
            }
            var e = event || window.event;
            if (dragObj.isDrag == false) {
                dragObj.isDrag = true;
                $(dragObj).css({ width: $(dragObj).width(), height: $(dragObj).height() });
                dragObj.style.position = "absolute";
                dragObj.style.top = (e.clientY - iy) + "px";
                dragObj.style.left = (e.clientX - ix) + "px";

                /*处理鼠标拖动事件*/
                if (dragObj.beforemove_event != null && typeof (dragObj.beforemove_event) == "function")
                    dragObj.beforemove_event.call(dragObj, e);

            }
            dragObj.style.top = (e.clientY - iy) + "px";
            dragObj.style.left = (e.clientX - ix) + "px";

            /*处理正在拖动事件*/
            if (dragObj.moving_event != null && typeof (dragObj.moving_event) == "function")
                dragObj.moving_event.call(dragObj, e);

        });
    });
    $(document).mouseup(function (event) {

        var e = event || window.event;
        if (dragObj == null)
            return;

        movecount = 0;

        if (dragObj.mouseup_event != null && typeof (dragObj.mouseup_event) == "function")
            dragObj.mouseup_event.call(dragObj, e);

        $(document).unbind("mousemove");

        /*处理鼠标松开事件*/
        if (dragObj.doRest) {
            $(dragObj).attr("style", ktempStyle);
        }

        dragObj.isDrag = false;
        dragObj = null;
    });

};

 //使用例子

    $("#addbox").kDrag({
        mousedown_event: function () {
            $("#mask").css({ display: "block" });
        },
        beforemove_event: function () {
            $(this).addClass("drag");
        },
        mouseup_event: function () {
            $(this).removeClass("drag");
            $("#mask").css({ display: "none" });
        }
    });

有5个参数可以设置

mousedown_event/*鼠标按下事件*/

moving_event /*移动中事件*/

beforemove_event /*准备移动之前的事件*/

mouseup_event /*鼠标松开事件*/

doRest  /*结束拖动后样式是否恢复*/

namespace Url2Img
{
    public class WebSiteImage
    {
        public delegate void GetHandler(Bitmap bm,WebBrowser wb);
        public delegate void FinishHandler(WebBrowser wb);

        public GetHandler websiteImageHandler;
        public GetHandler websiteICOHandler;
        public FinishHandler finishHandler;

        private string m_Url = null;
        private int m_TW;
        private int m_TH;
        private int m_BW;
        private int m_BH;
        private string m_title;

        private double m_overtime;
        private bool is_complete = false;

        public double overtime
        {
            set
            {
                this.m_overtime = value;
            }
        }
        public string title
        {
            get
            {
                return this.m_title;
            }
            set
            {
                this.m_title = value;
            }
        }

        /// <summary>
        /// 网站截图
        /// </summary>
        /// <param name="url">网页地址</param>
        /// <param name="bw">浏览器宽度</param>
        /// <param name="bh">浏览器高度</param>
        /// <param name="tw">缩略图宽度</param>
        /// <param name="th">缩略图高度</param>
        /// <param name="overtime">超时设置</param>
        public WebSiteImage(string url, int bw, int bh, int tw, int th, int overtime)
        {
            this.m_Url = url;
            this.m_BW = bw;
            this.m_BH = bh;
            this.m_TW = tw;
            this.m_TH = th;
            this.m_overtime = overtime;
        }

        /// <summary>
        /// 网站截图
        /// </summary>
        /// <param name="url">网页地址</param>
        /// <param name="tw">缩略图宽度</param>
        /// <param name="th">缩略图高度</param>
        public WebSiteImage(string url, int tw, int th)
        {
            this.m_Url = url;
            this.m_BW = 800;
            this.m_BH = 600;
            this.m_TW = tw;
            this.m_TH = th;
            this.m_overtime = 160;
        }

        /// <summary>
        /// 通过线程来开始图片抓取
        /// </summary>
        public void ThreadGetImg()
        {
            Thread thread = new Thread(new ThreadStart(GenerateImage));
            try
            {
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();
            }
            finally
            {
                //thread.Abort();
                thread.Join();
            }
        }

        /// <summary>
        /// 生成图片
        /// </summary>
        private void GenerateImage()
        {
            WebBrowser wb = new WebBrowser();
            try
            {
                if (ConfigurationManager.AppSettings["ProxyAddress"] != null &&
                 ConfigurationManager.AppSettings["ProxyPort"] != null)
                    Proxy.RefreshIESettings(ConfigurationManager.AppSettings["ProxyAddress"] + ":" +
                       ConfigurationManager.AppSettings["ProxyPort"]);

                wb.Navigate(this.m_Url);
                DateTime dt = DateTime.Now;
                TimeSpan ts = new TimeSpan();
                is_complete = false;

                //载入完成回调函数
                wb.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(wb_DocumentCompleted);

                while (wb.ReadyState != WebBrowserReadyState.Complete)
                {
                    ts = DateTime.Now - dt;

                    //判断超时
                    if (ts.TotalSeconds > this.m_overtime || is_complete)
                    {
                        return;
                    }
                    System.Windows.Forms.Application.DoEvents();
                }
            }
            finally
            {
                wb.Dispose();
            }
        }

        void wb_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
        {
            WebBrowser wb = (WebBrowser)sender;

            //未完全载入完成则返回
            if (wb.ReadyState != WebBrowserReadyState.Complete || is_complete)
                return;

           this.m_title = wb.DocumentTitle;

            wb.ClientSize = new Size(this.m_BW, this.m_BH);
            Bitmap bm = new Bitmap(this.m_BW, this.m_BH);
            wb.ScrollBarsEnabled = false;
            wb.BringToFront();

            wb.DrawToBitmap(bm, wb.Bounds);
            bm = (Bitmap)bm.GetThumbnailImage(this.m_TW, this.m_TH, null, IntPtr.Zero);
            try
            {
                this.websiteImageHandler.Invoke(bm,wb);
            }
            catch (Exception ex)
            {
                string message = ex.Message;
            }
            finally
            {
                is_complete = true;
                bm.Dispose();
            }

            this.GetIco(wb);
            this.finishHandler.Invoke(wb);
           
        }

        /// <summary>
        /// 获取网页ico
        /// </summary>
        public void GetIco(WebBrowser wb)
        {
            string icourl = string.Empty;

            icourl = Regex.Replace(this.m_Url, "^(?:http://)?(.*?)(?:/.*|$)", "http://$1/favicon.ico");
          
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(icourl);

                if (ConfigurationManager.AppSettings["ProxyAddress"] != null &&
                    ConfigurationManager.AppSettings["ProxyPort"] != null)
                {
                    string proxy_address = ConfigurationManager.AppSettings["ProxyAddress"];
                    int proxy_port = Convert.ToInt32(ConfigurationManager.AppSettings["ProxyPort"]);

                    request.Proxy = new WebProxy(proxy_address, proxy_port);
                }

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                Bitmap b = new Bitmap(response.GetResponseStream());
                this.websiteICOHandler.Invoke(b,wb);

            }
            catch (Exception ex)
            {
                string message = ex.Message;
            }
        }

    }
}

/*顺便附上网上的代理设置*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace Url2Img
{

    class Proxy
    {

        public struct Struct_INTERNET_PROXY_INFO
        {
            public int dwAccessType;
            public IntPtr proxy;
            public IntPtr proxyBypass;
        };

        [DllImport("wininet.dll", SetLastError = true)]
        private static extern bool InternetSetOption(IntPtr hInternet, int dwOption, IntPtr lpBuffer, int lpdwBufferLength);

        public static void RefreshIESettings(string strProxy)
        {
            const int INTERNET_OPTION_PROXY = 38;
            const int INTERNET_OPEN_TYPE_PROXY = 3;

            Struct_INTERNET_PROXY_INFO struct_IPI;

            // Filling in structure
            struct_IPI.dwAccessType = INTERNET_OPEN_TYPE_PROXY;
            struct_IPI.proxy = Marshal.StringToHGlobalAnsi(strProxy);
            struct_IPI.proxyBypass = Marshal.StringToHGlobalAnsi("local");

            // Allocating memory
            IntPtr intptrStruct = Marshal.AllocCoTaskMem(Marshal.SizeOf(struct_IPI));

            // Converting structure to IntPtr
            Marshal.StructureToPtr(struct_IPI, intptrStruct, true);

            bool iReturn = InternetSetOption(IntPtr.Zero, INTERNET_OPTION_PROXY, intptrStruct, Marshal.SizeOf(struct_IPI));
        }
    }
}

PS:使用方法

 web.config 假如需要用到代理的话，加上

<add key="ProxyAddress" value="xxx.xxx.net"></add>
<add key="ProxyPort" value="80"></add>

//可以自己设置下图片的处理方式，存文件或数据库，通过委托

            Url2Img.WebSiteImage wsi = new Url2Img.WebSiteImage(url, width, height);
            wsi.websiteImageHandler = new Url2Img.WebSiteImage.GetHandler(HandleImg);
            wsi.websiteICOHandler = new Url2Img.WebSiteImage.GetHandler(HandleIco);
            wsi.finishHandler = new Url2Img.WebSiteImage.FinishHandler(SaveHandle);
            wsi.ThreadGetImg();

    kinogam.ajax = function (s) {
        var x = new kinogam.ajaxHandler();
        x.setMember(s);

        x.xmlHttp.onreadystatechange = function () {
            if (x.xmlHttp.readyState == 4 && ((x.xmlHttp.status >= 200 && x.xmlHttp.status < 300) || x.xmlHttp.status == 304 || x.xmlHttp.status == 1223)) {
                if (x.success)
                    x.success.call(x, x.xmlHttp.responseText);
            }
            else if (x.xmlHttp.readyState == 4) {
                if (x.error)
                    x.error.call(x, x.xmlHttp.responseText);
            }
        }
        x.xmlHttp.open(x.type, x.url, x.async);
        try {
            x.xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
            x.xmlHttp.send(kinogam.ajax.json2url(x.data));
        }
        catch (e) {
        }
    }

    kinogam.ajaxHandler = function () {
        this.url = "";
        this.type = "POST";
        this.data = null;
        this.async = true;
        this.success = null;
        this.error = null;
        this.xmlHttp = kinogam.ajax.getXmlHttpRequest();
    }
    kinogam.ajaxHandler.prototype.setMember = function (s) {
        if (s != null) {
            for (var i in s) {
                this[i] = s[i];
            }
        }
    }
    kinogam.ajax.getXmlHttpRequest = function () {
        return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();

    }
    kinogam.ajax.json2url = function (json) {
        var url = "";
        for (var i in json) {
            url += "&" + encodeURIComponent(i) + "=" + encodeURIComponent(json[i]);
        }
        return url.replace(/^&/, "");
    }
})();

            kinogam.ajax({
                url: "handler.ashx",
                data: { b: "kkkyyy", k: "uuu" },
                success: function (html) {
                   
                    alert(html+"kinogam test over");
                }

            });

PS：这个又是帮百度知道的人回答的一个正则问题……

不过他貌似要匹配所有的括号内容，我这里只捕获了最大的括号……

估计要想个办法匹配完最大的括号内容，然后回溯到第二大的括号，然后一直到最小……

原文:

text = "ccc |cFF000000 a|cFF000000 |bc |r|r|r ddd";

目标找出成对出现的|c |r    (|c之后一定是跟着8位字母和数字的组合)
如上字符串应该找出
|cFF000000 a|cFF000000 |bc |r|r
和
|cFF000000 |bc |r

(?:(?:\d*[48]00|(?:\d*[0-35-79](?:[2468][048]|[13579][26]))|[48])-0?2-29 #验证闰年的2月29号
|
\d+-(?:[13578]|10|12)-31  #所有有31号的日期
|
\d+-(?:(?:1[1-2]|0?[13-9])-(?:30|[0-2]?\d)|0?2-(?:1?\d|2[1-8])) #30天的
)
\s+

(?:24:0?0:0?0|(?:[0-1]?[0-9]|2[1-3]):(?:[0-5]?\d):(?:[0-5]?\d)) #精确到秒

)$

PS:下一步就是写个能够验证各种日期格式的函数……

    kinogam.MapFlashHandler = function (id, layer, delay) {
        /// <summary>
        /// Mapinfo图层闪烁
        /// </summary>
        /// <param name="id" type="string">MapControl的ID</param>
        /// <param name="layer" type="string">图层的别名(Alias)</param>
        /// <param name="delay" type="number">闪烁间隔</param>

        this.timer = null;
        this.map = document.getElementById(id + "_Image");
        this.layer = layer;
        this.delay = delay;
    }

    kinogam.MapFlashHandler.prototype.layerFlash = function () {
        /// <summary>
        /// 设置图层闪烁
        /// </summary>
        var f = false;
        var _map = this.map;
        var _layer = this.layer;
        var _delay = this.delay;

        this.timer = setInterval(function () {
            if (_map.readyState) {
                if (_map.readyState != "complete" && _map.readyState != "loading")
                    return;
             }
             else if(!_map.complete)
                return;
                   
                kinogam.ChangeLayer(_map, _layer, f);
                if (f)
                    f = false;
                else
                    f = true;
        }, _delay);
       
    }

    kinogam.MapFlashHandler.prototype.resetLay = function (layer) {
        /// <summary>
        /// 重置闪烁图层
        /// </summary>
        /// <param name="layer" type="string">图层名称</param>
        this.clear();
        this.layer = layer;
        this.layerFlash();
    }

    kinogam.ChangeLayer = function (map, layer, isShow) {
        /// <summary>
        /// Mapinfo图层显示、隐藏操作
        /// </summary>
        /// <param name="map" type="dom">MapControl的Image Dom</param>
        /// <param name="layer" type="string">图层的别名(Alias)</param>
        /// <param name="isShow" type="bool">
        /// 1.true 显示
        /// 2.false 隐藏
        ///</param>
        var imgsrc = map.src;
        imgsrc = imgsrc.replace(/command=[^&]+/i, "Command=LayerVisibility");

        /*如果不存在请求变量则加在字符串末端*/
        var lr = new RegExp("LayerAlias=[^&]+", "i")
        if (lr.test(imgsrc))
            imgsrc = imgsrc.replace(lr, "LayerAlias=" + layer);
        else
            imgsrc += "&LayerAlias=" + layer;

        var visble = "true";
        if (!isShow)
            visble = "false";

        /*如果不存在请求变量则加在字符串末端*/
        var vr = new RegExp("Visible=[^&]+", "i")
        if (vr.test(imgsrc))
            imgsrc = imgsrc.replace(vr, "Visible=" + visble);
        else
            imgsrc += "&Visible=" + visble;

        /*如果不存在请求变量则加在字符串末端*/
        var vr = new RegExp("LayerType=[^&]+", "i")
        if (vr.test(imgsrc))
            imgsrc = imgsrc.replace(vr, "LayerType=Normal");
        else
            imgsrc += "&LayerType=Normal";

        map.src = imgsrc;
    }

    kinogam.MapFlashHandler.prototype.clear = function () {
        /// <summary>
        /// 清除闪烁事件
        /// </summary>
        clearInterval(this.timer);
    }
})();

window.onload = function () {
    var x = new kinogam.MapFlashHandler("MapControl1", "TempLayerAlias3", 1000);
    x.layerFlash();
   
    document.getElementById("stop").onclick = function () {
        x.clear();
    }

    document.getElementById("changemap").onclick = function () {
        x.resetLay("行政区域");
    }
}

PS:相信很多人都遇到客户要求图片闪烁的功能……
       

我的正则表达式:

^[a-z](?:[-—.](?![-—.])|[a-z]){3,18}[a-z]$

public class KZip
{
    ZipOutputStream zos = new ZipOutputStream(System.Web.HttpContext.Current.Response.OutputStream);
    string strBaseDir = "";
    byte[] m_buf = new byte[4096];

    /// <summary>
    /// 打包压缩下载
    /// </summary>
    /// <param name="patchStr">文件或文件夹路径</param>
    /// <param name="zipname">压缩后的文件名</param>
    public void dlZipDir(string patchStr, string zipname)
    {
        HttpResponse response = System.Web.HttpContext.Current.Response;

        //输出头信息
        response.Clear();
        response.ClearHeaders();
        response.AddHeader("Content-Disposition", "attachment; filename=" + zipname);
        response.ContentType = "application/octet-stream";
        try
        {
            zos.SetLevel(9);
            FileInfo fi = new FileInfo(patchStr);
            DirectoryInfo di = new DirectoryInfo(patchStr);
            if (fi.Exists == false && di.Exists == false)
                return;

            strBaseDir = Path.GetDirectoryName(patchStr) + "\\";
            addZipEntry(patchStr);
        }
        finally
        {
            zos.Finish();
            zos.Close();
            System.Web.HttpContext.Current.Response.OutputStream.Close();
            System.Web.HttpContext.Current.Response.End();
        }

    }

    /// <summary>
    /// 打包压缩下载
    /// </summary>
    /// <param name="patchStr">文件或文件夹路径</param>
    /// <param name="zipname">压缩后的文件名</param>
    public void dlZipDir(string[] patchStr, string zipname)
    {
        HttpResponse response = System.Web.HttpContext.Current.Response;

        //输出头信息
        response.Clear();
        response.ClearHeaders();
        response.AddHeader("Content-Disposition", "attachment; filename=" + zipname);
        response.ContentType = "application/octet-stream";

        try
        {
            zos.SetLevel(9);
            for (int i = 0; i < patchStr.Length; i++)
            {
                FileInfo fi = new FileInfo(patchStr[i]);
                DirectoryInfo di = new DirectoryInfo(patchStr[i]);
                if (fi.Exists == false && di.Exists == false)
                    continue;

                strBaseDir = Path.GetDirectoryName(patchStr[i]) + "\\";
                addZipEntry(patchStr[i]);
            }
        }
        finally
        {
            zos.Finish();
            zos.Close();
            System.Web.HttpContext.Current.Response.OutputStream.Close();
            System.Web.HttpContext.Current.Response.End();
        }
    }

    private void addZipEntry(string PathStr)
    {
        DirectoryInfo di = new DirectoryInfo(PathStr);
        if (di.Exists)
        {
            foreach (DirectoryInfo item in di.GetDirectories())
            {
                addZipEntry(item.FullName);
            }

            if (di.GetFiles().Length == 0)
            {
                FileInfo d = new FileInfo(PathStr);
                this.addZipDir(d);
            }
            else
                foreach (FileInfo item in di.GetFiles())
                {
                    this.addZipFile(item);
                }
        }
        else
        {
            FileInfo f = new FileInfo(PathStr);
            this.addZipFile(f);
        }

    }

    private void addZipFile(FileInfo item)
    {
        using (FileStream zfs = File.OpenRead(item.FullName))
        {
            int sourcebytes;
            string strEntryName = item.FullName.Replace(strBaseDir, "");
            ZipEntry entry = new ZipEntry(strEntryName);
            entry.Size = zfs.Length;
            zos.PutNextEntry(entry);

            do
            {
                sourcebytes = zfs.Read(m_buf, 0, m_buf.Length);

                zos.Write(m_buf, 0, sourcebytes);
                System.Web.HttpContext.Current.Response.Flush();

            }
            while (sourcebytes > 0);
            zfs.Close();
        }
    }

    private void addZipDir(FileInfo item)
    {

        string strEntryName =  item.FullName.Replace(strBaseDir, "") + "/";
        ZipEntry entry = new ZipEntry(strEntryName);
        zos.PutNextEntry(entry);
        System.Web.HttpContext.Current.Response.Flush();
    }
}

PS：用了 ICSharpCode.SharpZipLib.Zip,把一些现有的代码修改了下写了个自己用的类……

ps:百度知道上有个人问了n次，一直都没给分偶……没脾气了，写在blog上，有机会让他们搜吧……

(function () {
    var KInput;
    if (window.KInput == null)
        KInput = window.KInput = function (_obj, _fn) {
            /// <summary>
            /// 输入框的改变事件。
            /// </summary>
            /// <param name="_obj" type="dom">
            ///  1: _obj - 绑定change监听的对象。
            /// </param>
            /// <param name="_fn" type="function">
            ///  1: _fn - dom对象的值改变所触发的回调函数。
            /// </param>
            this.txt = null;
            this.obj = _obj;
            this.fn = _fn;
            this.timer = null;
            this.AddLinstener();
        }

    KInput.prototype.AddLinstener = function () {
        this.obj.kinogamInputInstance = this;
        this.obj.of = this.obj.onfocus;
        this.obj.ob = this.obj.onblur;
        this.obj.onfocus = function () {
            if (this.of != null)
                this.of();
            var itemp = this.kinogamInputInstance;
            this.kinogamInputInstance.timer = setInterval(function () { KInput.changeChecker(itemp); }, 500);
        }
        this.obj.onblur = function () {
            if (this.ob != null)
                this.ob();
            clearInterval(this.kinogamInputInstance.timer);
        }
    }

    KInput.changeChecker = function (ki) {
        if (ki.txt == null) {
            ki.txt = ki.obj.value;
            if(ki.txt.length == 0)
                return;
        }
        else if (ki.obj.value == ki.txt)
            return;
        else
            ki.txt = ki.obj.value;
        ki.fn.call(ki.obj);
    }
})();

使用例子:

window.onload = function () {

var x = new KInput(document.getElementById("test"), function () {
                alert(this.value);
});
}