X

由于无法提供服务器的高昂费用,博客即将迁移到github pages...

点击右上的X可以临时关闭此框并阻止跳转^_^

现在带您过去 秒后跳转...

我是如何将mac OS X(10.11.6)的PHP版本升级到5.6.29的


    由于项目和学习的需要,本机曾经升级到了5.5.38已经不够折腾了,所以时候升级一波5.6了(没必要到7的时候,我是不会去升级的)。
    首先直接去搜索引擎找便捷的方法呗,直接就选中了一款来自“简书”的文章,因为它就简单的一条命令:

    curl -s http://php-osx.liip.ch/install.sh | bash -s 5.6
    

    看到这个地址,我心里就放心了!因为上一个版本也是liip的。
    我首先看了一下这个install.sh的内容,确定没有什么危险,里面其实就是检测一下设备的系统版本和cpu类型是否可以升级。
    环境检测没问题就去下载了一个叫做“packager.tgz”的压缩包,然后解压,运行里面的pythony脚本。

    #TYPE = 5.6-10.10
    sudo packager.py install $TYPE-frontenddev
    

    (…继续阅读这篇文章…)

JetBrains家的IDEA真不便宜

    先贴出来正版购买链接

    JetBrains公司的那些IDE真的是非常的好用,No.1的水准!一直都非常喜欢这家的产品,也难怪价格会稍微贵那么不止一点点了!
    IntelliJ IDEA专为Java打造,当然还有为PHP打造的PHPStorm,为javascript打造的WebStorm,为Python打造的PyCharm等等。
    不过今天不是来吹嘘JetBrains家的产品的,我是来吐槽自己买不起的事实。[/摊手]
    (…继续阅读这篇文章…)

[合集]面试中遇到的那些提问

    参加了好几家公司的面试了,一直也没来得及将这些问题整理一下,今天正好不想到处跑了,所以先在这里写下这一篇文章,以后会不定期更新。

    非技术篇:

    1. 先来一个自我介绍吧(废话! =_=!)
    2. 用3个词组评价你自己
    3. 说一说你一生中感到最有成就感的一件事
    4. 说一说你曾经遇到过的最沮丧的一件事
    5. 说说你的优缺点
    6. 说说你的父母都是做什么的?
    7. 你有多少个兄弟姐妹?
    8. 你为什么选择来参加我们公司的招聘
    9. 你对加班的看法和出差的看法,以及你对加班和出差的最大忍耐极限
    10. 你觉得你在哪一方面比较优秀?
    11. 别人都是怎么评价你的?
    12. 在同一个Team中,当别人的意见和自己的意见冲突的时候,你会怎么办?
    13. 拿一个你最熟悉的项目来讲讲,它的架构、设计、遇到的问题以及是如何解决的
    14. 你对我们的开发团队有什么期望吗?
    15. 最后,你有什么想要问我的?


    (…继续阅读这篇文章…)

[修复]wordpress WP_Image_Editor_Imagick 指令注入漏洞

    漏洞描述:该修复方案为临时修复方案,可能存在兼容性风险,为了防止WP_Image_Editor_Imagick扩展的指令注入风险,将wordpress的默认图片处理库优先顺序改为GD优先,用户可在/wp-includes/media.php的_wp_image_editor_choose()函数中看到被修改的部分
    云盾不提供自动修复,咱们自己来修复吧。根据提示,我们打开media.php 找到相关函数的内容:

    $implementations = apply_filters( 'wp_image_editors', array( 'WP_Image_Editor_Imagick', 'WP_Image_Editor_GD' ) );
    

    做如下顺序调整:

    $implementations = apply_filters( 'wp_image_editors', array( 'WP_Image_Editor_GD', 'WP_Image_Editor_Imagick' ) );
    

    正如上面的描述所说,临时方案嘛。Wordpress官方不做处理的话,你每次升级了程序,都会出现这样的报错,每次都得自己去修改。不过如果不在乎这个提示的话,不理也行!
    (…继续阅读这篇文章…)

[作业]JavaBean+Jsp简易购物车实现

    本次作业要求使用到JavaBean+纯Jsp,带有登陆功能的购物车系统。
    登陆功能这里就不多讲了,前面的聊天室已经做过,这边直接拷贝就能使用了。
    另外,本次作业中我加入了BootStrap来做一个小小风格美化。
    不多说,直接上代码!
    index.jsp 首页,也是登陆界面

    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    <%
        Cookie[] cookies = request.getCookies();
        String uname = "";
        String upwd = "";
        if(cookies!=null){
            for(int i=0;i
    
    
        
            
            
            
            请登录ShopCartDemo
            
        
        
            

    dologin.jsp 登陆信息处理页面

    <%-- 
        Document   : dologin
        Created on : 2015-10-9, 11:28:29
        Author     : Anthony
    --%>
    
    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    <%@page import="java.util.*"%>
    
    
        
            
            正在登录...
        
        
            <%
            String username = request.getParameter("username");
            String password = request.getParameter("password");
            String remember = (String) request.getParameter("remember");
            if(username == null)
                username="";
            if(password == null)
                password="";
            if(remember == null)
                remember = "false";
            if(username.equals("201321092028")&&password.equals("123456") || username.equals("201321092027")&&password.equals("123456"))
            {
                if(remember != null && remember.equals("true"))
                {
                    Cookie cookie1 = new Cookie("remname",username);
                    Cookie cookie2 = new Cookie("rempwd",password);
                    cookie1.setMaxAge(60*60*24*5);
                    cookie2.setMaxAge(60*60*24*5);
                    response.addCookie(cookie1);
                    response.addCookie(cookie2);
                }
                session.setAttribute("UserName",username);
                session.setAttribute("IsLogin","true");
                response.sendRedirect("goods.jsp");
            }else{
                response.sendRedirect("index.jsp");
            }
            %>
        
    
    

    goods.jsp 商品列表页面

    <%-- 
        Document   : goods
        Created on : 2015-10-15, 17:11:28
        Author     : anthony
    --%>
    
    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    
    
        
            
            
            
            商品列表
            
        
        
            
    编号商品名单价(元/斤)购买数量
    1苹果13
    2橘子8
    3西瓜2
    4火龙果15

    order.jsp 订单信息页面

    <%-- 
        Document   : order
        Created on : 2015-10-15, 18:28:05
        Author     : anthony
    --%>
    
    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    
    
        
            
            
            
            订单信息
            
        
        
            
                
                
                
                
            
    编号商品名单价(元/斤)数量价格
    1苹果13
    2橘子8
    3西瓜2
    4火龙果15

    另外,还需要一个JavaBean CountPrice.java

    package Cart;
    
    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    
    /**
     *
     * @author anthony
     */
    public class CountPrice {
        private double n_apple;
        private double n_orange;
        private double n_watermalon;
        private double n_fires;
        private double p_apple;
        private double p_orange;
        private double p_watermalon;
        private double p_fires;
        private double totalprice;
    
        /**
         * @return the n_apple
         */
        public double getN_apple() {
            return n_apple;
        }
    
        /**
         * @param n_apple the n_apple to set
         */
        public void setN_apple(double n_apple) {
            this.n_apple = n_apple;
            this.setP_apple(n_apple*13);
        }
    
        /**
         * @return the n_orange
         */
        public double getN_orange() {
            return n_orange;
        }
    
        /**
         * @param n_orange the n_orange to set
         */
        public void setN_orange(double n_orange) {
            this.n_orange = n_orange;
            this.setP_orange(n_orange*8);
        }
    
        /**
         * @return the n_watermalon
         */
        public double getN_watermalon() {
            return n_watermalon;
        }
    
        /**
         * @param n_watermalon the n_watermalon to set
         */
        public void setN_watermalon(double n_watermalon) {
            this.n_watermalon = n_watermalon;
            this.setP_watermalon(n_watermalon*2);
        }
    
        /**
         * @return the n_fires
         */
        public double getN_fires() {
            return n_fires;
        }
    
        /**
         * @param n_fires the n_fires to set
         */
        public void setN_fires(double n_fires) {
            this.n_fires = n_fires;
            this.setP_fires(n_fires*15);
        }
    
        /**
         * @return the totalprice
         */
        public double getTotalprice() {
            this.totalprice = this.getP_apple()+this.getP_fires()+this.getP_orange()+this.getP_watermalon();
            return totalprice;
        }
    
        /**
         * @return the p_apple
         */
        public double getP_apple() {
            return p_apple;
        }
    
        /**
         * @return the p_orange
         */
        public double getP_orange() {
            return p_orange;
        }
    
        /**
         * @return the p_watermalon
         */
        public double getP_watermalon() {
            return p_watermalon;
        }
    
        /**
         * @return the p_fires
         */
        public double getP_fires() {
            return p_fires;
        }
    
        /**
         * @param p_apple the p_apple to set
         */
        public void setP_apple(double p_apple) {
            this.p_apple = p_apple;
        }
    
        /**
         * @param p_orange the p_orange to set
         */
        public void setP_orange(double p_orange) {
            this.p_orange = p_orange;
        }
    
        /**
         * @param p_watermalon the p_watermalon to set
         */
        public void setP_watermalon(double p_watermalon) {
            this.p_watermalon = p_watermalon;
        }
    
        /**
         * @param p_fires the p_fires to set
         */
        public void setP_fires(double p_fires) {
            this.p_fires = p_fires;
        }
        
    }

    附上NetBean项目工程:
    链接: http://pan.baidu.com/s/1o66DrjO 密码: yksy

linux下mysql的root密码忘记解决方法

    1.首先确认服务器出于安全的状态,也就是没有人能够任意地连接MySQL数据库。
    因为在重新设置MySQL的root密码的期间,MySQL数据库完全出于没有密码保护的
    状态下,其他的用户也可以任意地登录和修改MySQL的信息。可以采用将MySQL对
    外的端口封闭,并且停止Apache以及所有的用户进程的方法实现服务器的准安全
    状态。最安全的状态是到服务器的Console上面操作,并且拔掉网线。
    2.修改MySQL的登录设置:
    # vi /etc/my.cnf
    在[mysqld]的段中加上一句:skip-grant-tables
    例如:
    [mysqld]
    datadir=/var/lib/mysql
    socket=/var/lib/mysql/mysql.sock
    skip-grant-tables
    保存并且退出vi。
    3.重新启动mysqld
    # /etc/init.d/mysqld restart
    Stopping MySQL: [ OK ]
    Starting MySQL: [ OK ]
    4.登录并修改MySQL的root密码
    # /usr/bin/mysql
    Welcome to the MySQL monitor. Commands end with ; or \g.
    Your MySQL connection id is 3 to server version: 3.23.56
    Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.
    mysql> USE mysql ;
    Reading table information for completion of table and column names
    You can turn off this feature to get a quicker startup with -A
    Database changed
    mysql> UPDATE user SET Password = password ( ‘new-password’ ) WHERE User = ‘root’ ;
    Query OK, 0 rows affected (0.00 sec)
    Rows matched: 2 Changed: 0 Warnings: 0
    mysql> flush privileges ;
    Query OK, 0 rows affected (0.01 sec)
    mysql> quit
    Bye
    5.将MySQL的登录设置修改回来
    # vi /etc/my.cnf
    将刚才在[mysqld]的段中加上的skip-grant-tables删除
    保存并且退出vi。
    6.重新启动mysqld
    # /etc/init.d/mysqld restart
    Stopping MySQL: [ OK ]
    Starting MySQL: [ OK ]
    文章转自:http://www.cnblogs.com/allenblogs/archive/2010/08/12/1798247.html

各种排序算法介绍

    1.直接插入排序算法(Straight Insertion Sort):
    基本思想:
    将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表。即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止。
    算法的实现:

    //
    //  main.cpp
    //  Straight Insertion Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    
    void print(int a[], int n ,int i){
        cout<
    

    运行结果:
    1:5 6 1 3 2 8 9 7
    2:1 5 6 3 2 8 9 7
    3:1 3 5 6 2 8 9 7
    4:1 2 3 5 6 8 9 7
    5:1 2 3 5 6 8 9 7
    6:1 2 3 5 6 8 9 7
    7:1 2 3 5 6 7 8 9
    8:1 2 3 5 6 7 8 9
    Program ended with exit code: 0
    时间复杂度:O(n^2).
    2.选择排序—简单选择排序(Simple Selection Sort):
    基本思想:
    在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换;然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止。

    操作方法:
    第一趟,从n 个记录中找出关键码最小的记录与第一个记录交换;
    第二趟,从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换;
    以此类推.....
    第i 趟,则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换,
    直到整个序列按关键码有序。

    算法的实现:

    //
    //  main.cpp
    //  Simple Selection Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    
    void print(int a[], int n ,int i){
        cout<<"第"< a[j]) k = j;
        }
        return k;
    }
    
    /**
     * 选择排序
     *
     */
    void selectSort(int a[], int n){
        int key, tmp;
        for(int i = 0; i< n; ++i) {
            key = SelectMinKey(a, n,i);           //选择最小的元素
            if(key != i){
                tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换
            }
            print(a,  n , i);
        }
    }
    
    int main(int argc, const char * argv[]) {
        int a[8] = {5,6,1,3,2,8,9,7};
        cout<<"初始值:";
        for(int j= 0; j<8; j++){
            cout<
    

    运行结果:
    初始值:5 6 1 3 2 8 9 7

    第1趟 : 1 6 5 3 2 8 9 7
    第2趟 : 1 2 5 3 6 8 9 7
    第3趟 : 1 2 3 5 6 8 9 7
    第4趟 : 1 2 3 5 6 8 9 7
    第5趟 : 1 2 3 5 6 8 9 7
    第6趟 : 1 2 3 5 6 7 9 8
    第7趟 : 1 2 3 5 6 7 8 9
    第8趟 : 1 2 3 5 6 7 8 9
    第9趟 : 1 2 3 5 6 7 8 9
    Program ended with exit code: 0

     简单选择排序的改进——二元选择排序

    简单选择排序,每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序,最多只需进行[n/2]趟循环即可。具体实现如下:

    void SelectSort(int r[],int n) {
        int i ,j , min ,max, tmp;
        for (i=1 ;i <= n/2;i++) {
            // 做不超过n/2趟选择排序
            min = i; max = i ; //分别记录最大和最小关键字记录位置
            for (j= i+1; j<= n-i; j++) {
                if (r[j] > r[max]) {
                    max = j ; continue ;
                }
                if (r[j]< r[min]) {
                    min = j ;
                }
            }
            //该交换操作还可分情况讨论以提高效率
            tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;
            tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;
            
        }
    }
    

    3.交换排序—冒泡排序(Bubble Sort):
    基本思想:
    在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。
    算法的实现:

    void bubbleSort(int a[], int n){
        for(int i =0 ; i< n-1; ++i) {
            for(int j = 0; j < n-i-1; ++j) {
                if(a[j] > a[j+1])
                {
                    int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
                }
            }
        }
    }
    

    冒泡排序算法的改进
    对冒泡排序常见的改进方法是加入一标志性变量exchange,用于标志某一趟排序过程中是否有数据交换,如果进行某一趟排序时并没有进行数据交换,则说明数据已经按要求排列好,可立即结束排序,避免不必要的比较过程。本文再提供以下两种改进算法:

    1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

    改进后算法如下:

    void Bubble_1 ( int r[], int n) {
        int i= n -1;  //初始时,最后位置保持不变
        while ( i> 0) {
            int pos= 0; //每趟开始时,无记录交换
            for (int j= 0; j< i; j++)
                if (r[j]> r[j+1]) {
                    pos= j; //记录交换的位置
                    int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
                }
            i= pos; //为下一趟排序作准备
        }
    }
    

    2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

    改进后的算法实现为:

    void Bubble_2 ( int r[], int n){
        int low = 0;
        int high= n -1; //设置变量的初始值
        int tmp,j;
        while (low < high) {
            for (j= low; j< high; ++j) //正向冒泡,找到最大者
                if (r[j]> r[j+1]) {
                    tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
                }
            --high;                 //修改high值, 前移一位
            for ( j=high; j>low; --j) //反向冒泡,找到最小者
                if (r[j]
    

    4.交换排序—快速排序(Quick Sort)
    基本思想:
    1)选择一个基准元素,通常选择第一个元素或者最后一个元素,
    2)通过一趟排序讲待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
    3)此时基准元素在其排好序后的正确位置
    4)然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。
    算法的实现:

    //
    //  main.cpp
    //  Quick Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    void print(int a[], int n){
        for(int j= 0; j= privotKey) --high;  //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的交换到低端
            swap(&a[low], &a[high]);
            while(low < high  && a[low] <= privotKey ) ++low;
            swap(&a[low], &a[high]);
        }
        print(a,10);
        return low;
    }
    
    
    void quickSort(int a[], int low, int high){
        if(low < high){
            int privotLoc = partition(a,  low,  high);  //将表一分为二
            quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序
            quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序
        }
    }
    
    int main(){
        int a[10] = {3,1,5,7,2,4,9,6,10,8};
        cout<<"初始值:";
        print(a,10);
        quickSort(a,0,9);
        cout<<"结果:";
        print(a,10);
        return 0;
    }
    

    分析:
    快速排序是通常被认为在同数量级(O(nlog2n))的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时,快排序反而蜕化为冒泡排序。为改进之,通常以“三者取中法”来选取基准记录,即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

    快速排序的改进
    在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序,然后再对整个基本有序序列用插入排序算法排序。实践证明,改进后的算法时间复杂度有所降低,且当k取值为 8 左右时,改进算法的性能最佳。算法思想如下:

    //
    //  main.cpp
    //  Straight Insertion Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    void print(int a[], int n){
        for(int j= 0; j= privotKey) --high; //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的交换到低端
            swap(&a[low], &a[high]);
            while(low < high  && a[low] <= privotKey ) ++low;
            swap(&a[low], &a[high]);
        }
        print(a,10);
        return low;
    }
    
    
    void qsort_improve(int r[ ],int low,int high, int k){
        if( high -low > k ) { //长度大于k时递归, k为指定的数
            int pivot = partition(r, low, high); // 调用的Partition算法保持不变
            qsort_improve(r, low, pivot - 1,k);
            qsort_improve(r, pivot + 1, high,k);
        }
    }
    void quickSort(int r[], int n, int k){
        qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序
        
        //再用插入排序对基本有序序列排序
        for(int i=1; i<=n;i ++){
            int tmp = r[i];
            int j=i-1;
            while(tmp < r[j]){
                r[j+1]=r[j]; j=j-1;
            }
            r[j+1] = tmp;
        }
        
    }
    
    
    
    int main(){
        int a[10] = {3,1,5,7,2,4,9,6,10,8};
        cout<<"初始值:";
        print(a,10);
        quickSort(a,9,4);
        cout<<"结果:";
        print(a,10);
        return 0;
    }
    

    还有更多的算法,这里就不写那么多了,熟记基本的算法应付简单的程序还是可以的,重要的是学会运用其中的思想。

1/4 1 2 3 »