• jquery对象是否相同

    通过不同形式得到同一个htnl元素,如何比较它是否相同?
    假设得到后,两者变量名是A和B. (A和B是js元素,还是jquery对象,此时不清楚)

    第一个想到的是方法是$(A) == $(B),结果返回false
    再试试$(A)[0] == $(B)[0],结果返回true

    它比较的是什么?

    看看下面例子,下面的两个input比较,会相同吗.

    <div id="content">
        <input name="user_name"/>
        <input name="user_name"/>
    </div>
    

    它们不同

    $(function(){
        var inputs = $("#content input")
        console.info(inputs[0] == inputs[1]);  //false
        console.info($(inputs[0]) == $(inputs[0])); //false
    });
    

    其实比较只有两种类型: 值类型和引用类型.
    上面就是引用比较. jquery的$会产生新对象,每次的引用都不同,自然就不相等.
    所以只能用最初的引用进行比较,而不是jquery转化后的.

  • 理解select模块--等待IO完成

    用一句话描述select是做什么的: 等待IO完成.
    怎么理解
    在没有select模块时,通常的socket通信如下
    服务器server.py

    #encoding=utf-8
    import socket
    
    
    def main():
        '''阻塞'''
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.bind(('0.0.0.0', 8080))
        sock.listen(5)
        while True:
            client_sock, address = sock.accept()
            client_sock.settimeout(5)
            msg = client_sock.recv(1024)
            if msg == '1':
                client_sock.send('welcome to server!')
            else:
                client_sock.send('please go out!')
            client_sock.close()
    
    
    if __name__ == '__main__':
        main()
    

    客户端client.py

    #encoding=utf-8
    import socket
    import time
    
    
    def main():
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect(('0.0.0.0', 8080))
        time.sleep(2)
        sock.send('1')
        print sock.recv(1024)
        sock.close()
    
    
    if __name__ == '__main__':
        main()
    

    启动server.py之后,它会停在socket.accept()上,除了等待,程序再也不能做其它事情了。这样的IO等待,极大影响程序效率。

    很自然的会想: 有什么办法把这个等待过程独立出来,不让它影响到整个程序?
    select模块就是为了解决这个问题的.

    替换上面的server.py

    #encoding=utf-8
    import socket
    
    
    def main():
        '''非阻塞'''
        import select
    
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.bind(("0.0.0.0", 8080))
        sock.listen(5)
        while True:
            # 传入需要等待的socket,返回准备好的socket
            infds, outfds, errfds = select.select([sock, ], [], [], 5)
            print infds, outfds, errfds
            # 返回准备好的fd
            if sock in infds:
                client_sock, clientaddr = sock.accept()
                msg = client_sock.recv(8196)
                if len(msg) != 0:
                    print (msg)
                client_sock.close()
            print "no data coming"
    
    
    if __name__ == '__main__':
        main()
    

    上面用法就是将需要等待IO的socket作为参数传入,返回准备好的socket.
    即select负责IO等待,当IO准备好了,就将它回返.
    这就是select做的事情.

    select()说明
    select.select(rlist, wlist, xlist[, timeout])
    rlist 等待直到准备好读--为输入而观察的文件对象列表
    wlist 等待直到准备好写--为输出而观察的文件对象列表
    xlist 等待一种意外的情况--观察错误异常的文件列表
    timeout 单位是seconds,
    默认是timeout=None表示select永远阻塞,直到一个fd准备好
    timeout=0 表示不会阻塞
    timeout=10 表示最多阻塞10秒,在阻塞期间发现有准备好的文件对象,会立刻退出阻塞状态.
    return:返回参数rlist, wlist, xlist中准备好的文件对象,没有则返回([], [], [])

  • socket.error: [Errno 32] Broken pipe错误的原因

    linux下的socket程序,尝试发送消息到已关闭的socket上,会出现此错误.

    示例代码 服务端server.py ```python

    encoding=utf-8

    import socket import time

    def main(): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('0.0.0.0', 8050)) sock.listen(5)

    client_sock, address = sock.accept()
    while True:
        msg = client_sock.recv(1024)
        print msg
        client_sock.send('from server: %s' % msg)
        time.sleep(1)
    client_sock.close()
    sock.close()
    

    if name == 'main': main() ```

    客户端client.py

    #encoding=utf-8
    import socket
    import time
    
    
    def main():
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect(('0.0.0.0', 8050))
        while True:
            sock.send('hi')
            print sock.recv(1024)
            time.sleep(1)
        sock.close()
    
    
    if __name__ == '__main__':
        main()
    

    运行server.py和client.py,然后中断client.py会出现上面错误。

  • ssh在远程执行多个命令

    执行单个命令

    ssh wyq@135.32.9.98 'ps -ef |grep process.py'
    

    在远程主机上执行命令"ps -ef |grep process.py",在本机就可以看到输出. 使用分号分隔,允许一次执行多个命令

    ssh wyq@135.32.9.98 'cd ~/src; sh start.sh'
    

    进入到~/src目录,然后执行脚本sh start.sh

  • 什么是异常,其实我也不是很清楚

    起因

    平时能较好的处理异常。但在自定义异常时才发现,并不了解异常。对于用的api也不真明白为什么要抛出异常,而不用其它方式。

    针对自己的疑惑,觉得有必要好好思考下

    异常机制的产生

    语言发展是从汇编到C再到C++. 在汇编和C语言中都没有异常机制。
    它们用的是错误编码机制. 直到C++才出现异常机制。

    什么导致C++中出现异常机制?要回答它,需先了解错误编码机制的存在的缺点。
    * 错误信息不全
    调用信息不全; 错误种类很多,返回会过于简单.
    * 默认可以被忽略
    默认可以不用检查返回的错误编码,很容易使程序处在不正常状态.
    * 不能跨作用域传送
    只能一层层的向上传送,每层都有一堆检查错误的代码,会掩盖正常处理。

    编码机制是为解决程序错误这个需求而生。在错误发生时最重要的是:
    错误内容是什么?
    在哪儿出错了?
    为什么出错?
    编码机制存在着缺点,不能很好解决这几个需求。

    异常机制能完善的解决了这些问题. 所以后来语言中都加入了异常机制。

    异常机制也就了两个重要特点:
    * 沿着调用堆栈向上传递错误
    * 不可忽略
    前者可获得完整的调用信息,方便定位错误地点. 也可将错误处理代码分离出来。
    后者明确拒绝不健康运行状态,是程序正确性的关键。

    对异常的疑惑

    一个简单的python异常

    >>> a = {"a": 1, "b": 2}
    >>> a.pop(c)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'c' is not defined

    对于它我有很多疑问: 1. 为什么抛异常?返回特殊标记不行吗. 2. 什么是异常?为什么它会被定义为异常.

    回答第一个问题 异常的特点是就是"不可忽略",上面的pop没有任何值适合作为标记,它只能抛异常. 如果忽略了,可能会让程序处在不健康状态。

    回答第二个问题
    异常是判断词,与它对的应是正常。
    那么什么是正常?回答它也就可回答第二个问题了.
    异常与正常其实隐藏着一个判断, 隐藏着一个判断标准。

    那么谁在判断,谁在制定标准。答案是你。
    你在决定什么是异常,什么时候该抛异常,抛什么类型的异常。
    例子中就是python作者在背后做了思考/定义,决定它应该作为异常。

    如何使用异常

    当定义好什么是正常,知道哪些是不正常而且不可忽略时,就是使用异常的时候。为防止不健康运行状态. 而且不可忽略.

    值得注意的是:通常是没法考虑全面的,会有漏掉的情况,应以保守的方法处理,对未考虑到的情况全部作为异常处理,再分辨,逐步完善。

    异常的重要性
    它是软件好坏的重要标志,任何在这上面处理不好的软件,无不是充满了坑。

  • 在用proxychains时, ping用不了怎么办

    一般用ping来测试网络是否连通. 在用proxychains代理时,发现ping用不了

    [wyq@localhost ~]$ proxychains ping 135.32.9.98
    ProxyChains-3.1 (http://proxychains.sf.net)
    ERROR: ld.so: object 'libproxychains.so.3' from LD_PRELOAD cannot be preloaded: ignored.
    PING 135.32.9.98 (135.32.9.98) 56(84) bytes of data.
    

    proxychains支持的是socks,http, https协议.它们以tcp或者udp协议为基础. 所以proxychains只支持使用tcp或udp协议的程序. ping用的是ICMP协议,不以tcp或udp为基础,所以用不了。

    有其它办法吗? 以tcp或udp为基础,测试网络是否可用的工具,比较好用的有wget

    [wyq@localhost ~]$ proxychains wget 135.32.9.98
    ProxyChains-3.1 (http://proxychains.sf.net)
    --2014-01-16 09:44:57--  http://135.32.9.98/
    正在连接 135.32.9.98:80... |S-chain|-<>-192.168.1.115:1080-<><>-135.32.9.98:80-<--denied
    失败:拒绝连接。
    

    虽然提示拒绝连接,但是输出信息,已能说明网络连通了.

    wget本身简单易用,在这种情况下,用来测试网络是否可用,还是比较适合的。

  • 内网到外网的隧道

    今天需要在内网机器上安装一个包,而且没有与系统版本匹配的rpm. 所以只能自己编译安装。编译时出现错误,原因是系统没有安装gcc. 只好再安装gcc,然而再次出现问题,发现缺少gcc的依赖了,而且是一堆的依赖包. 没有办法,只能再一个个安装依赖包. 相信手动安装过linux软件的人,能够深深体会到相互依赖问题会让人有多痛苦。 好不容找到这些特定版本的包,最后出现悲剧了,貌似其中几个依赖包,由版本比较老,网上已经没有了。而且由于内核版本的原因,gcc也只能安装这个版本的。

    结果出现了安装某个包,需要gcc,安装gcc,需要依赖包,部分依赖包找不到。并且内核限制了只能安装这个版本的gcc。并且系统的安装盘是精简版的,没有常用软件的安装包.

    找依赖包已经让人很痛苦了,结果是这样,让人很恼火. 下定决心要在内网机器上使用yum,用它来解决这个问题。 为达到这个目的,需要在内网和外网间搭一条隧道,让内网能访问外网。

    工作的网络环境 工作是在外网,系统在独立的内部网络。在外网访问内网需要通过专门的vpn软件。 这个vpn软件,只能运行在windows下,使外网机器拥有临时的内网地址,运行时外网机器不能访问外网。

    其中网内到外网的端口转发

    proxychains ssh  -N -D 1090 wyq@192.168.1.102
    

    这里面最要的不是怎么建数据通道,而是怎么绕过这个特定的vpn软件. 工作原因实现方法只能略说.

  • objgraph无法生成分析图的原因查找多个词

    objgraph 是用于诊断内存问题的有用的工具
    安装objgraph

    sudo pip install objgraph
    

    用小段测试代码,生成png格式的分析图片

    #encoding=utf-8
    import objgraph
    
    
    def main(hi):
        print hi
    
    if __name__ == '__main__':
        hi = 'hi'
        main(hi)
        objgraph.show_backrefs([hi], filename='/tmp/hi.png')
    

    会出现错误

    Graph written to /tmp/objgraph-Nieb4E.dot (6 nodes)
    Graph viewer (xdot) and image renderer (dot) not found, not doing anyt
    hing else  
    

    原因: 缺少依赖包

    sudo yum install python-xdot  perl-Image-Dot
    
  • yum查找多个词

    yum search不支持多个关键词,可以用grep

    sudo yum search xdot |grep viewer
    
  • webpy+DBUtils是如何将数据库连接数占满的

    通过代理远程登陆其它网段的机器,要以命令行方式启动远程桌面.
    在fedora20以前,启动远程桌面的命令是rdesktop。目前的fedora20中未提供rdesktop,需要自己安装

    [wyq@localhost workspace]$ sudo yum install rdesktop
    

    或者使用vinagre命令启动

    [wyq@localhost workspace]$ vinagre