thinkphp文件上传

该方法已经测试过了，可以正常使用，我用的是用的是ThinkPHP3.2版本写的，如果想自己添加参数的话，请参考ThinkPHP3.2的文档,该方法的原理就是先实现文件的上传，然后获取文件的名字，再用函数获取文件的扩展名（如果想指定扩展名的话，此步骤可以省略，只需要定义新的名字就行）最后调用重命名函数，对文件进行重命名。
首先先写一个前台的表单，用于提交文件

<form action="__URL__/upload" enctype="multipart/form-data" method="post" >
     <input type="text" name="name" />
     <input type="file" name="photo" />
     <input type="submit" value="提交" >
 </form>

下面这个是文件上传函数，实现文件的上传

上传函数

public function upload(){
     $upload = new \Think\Upload();// 实例化上传类
     $oldFN = $_FILES;//获取图片的信息，在后面传给重命名函数
     $upload->maxSize = 3145728 ;// 设置附件上传大小
     $upload->exts = array('jpg', 'gif', 'png', 'jpeg');
                // 设置附件上传类型
     $upload->rootPath = './'; // 设置附件上传根目录
     $upload->savePath = ''; // 设置附件上传（子）目录
     $upload->replace = true;//如果存在同名文件就覆盖
     $upload->autoSub = false;
                //不使用子目录保存上传文件，即上传到指定的文件夹
     $info = $upload->upload();
    $this->renameFile($oldFN['photo']['name'], './');//调用重命名函数
     if(!$info) {// 上传错误提示错误信息
         $this->error($upload->getError());
     }else{// 上传成功
         $this->error('上传成功！');
     }
 }

重命名函数

下面这个是文件重命名函数（重命名为1,2,3）

public function renameFile($oldFN,$path){
    for($i=0;$i<count($oldFN);$i++){
         $extName = substr($oldFN[$i],strrpos($oldFN[$i],'.'));//获取扩展名
         $newName = ($i+1)."$extName";//新的名字
         rename($path.$oldFN[$i],$path.$newName);//重命名
     }
 }

如果有不懂，或者无法正常运行的地方，可以联系我哦。以后我会经常写一些自己的见解，写一些对大家有意义的文章，希望大家多多支持，也希望大家能够多提宝贵的意见。

逻辑运算符

& AND(与），左右全为真时，结果才为真，其余为假
| OR（或），左右全为假时，结果才为假，其余为真
^ XOR（异或），左右相同时为假，左右不相同时为真
！ NOT（非），取反
&& AND（短路），同&
|| OR（短路），同I
“&”和“&&”的区别：

• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
  “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
  异或( ^ )与或( | )的不同之处：当左右都为true时，结果为false。

位运算符

• “<<”,左移, 空位补0，被移除的高位丢弃，空缺位补0。 比如：3 << 2 = 12 ‐‐> 322=12
• “>>”，右移，被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1。比如：3 >> 1 = 1 ‐‐> 3/2=1
• ">>>"，无符号右移，被移位二进制最高位无论是0或者是1，空缺位都用0补。比如：3 >>> 1 = 1 ‐‐> 3/2=1
• "&"，与运算，二进制位进行&运算，只有1&1时结果是1，否则是0。比如：6 & 3 = 2
• "|"，或运算，二进制位进行 | 运算，只有0 | 0时结果是0，否则是1。比如： 6 | 3 = 7
• "^"，异或运算，任何相同二进制位进行 ^ 运算，结果是0； 1^1=0 , 0^0=0；不相同二进制位 ^ 运算结果是1。比如：1^0=1 , 0^1=1。 6 ^ 3 = 5
• "~"，反码，各位取反，结果为原来数的相反数-1.比如： ~6 = ‐7

交换两个变量值的方式

方法一：通过第三方变量（一般使用该方法）。
int temp;
temp = n;
n = m;
m = temp;
方法二：不用第三方变量
n = n + m;//如果n和m的值非常大，容易超出int范围。
m = n - m;
n = n - m;
方法三：异或的方法
n = n ^ m;
m = n ^ m;//(n^m)^m;
n = n ^ m;//n ^ (n ^ m)

选择排序

工作原理
选择排序的的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

算法实现（所用语言为java）

public static void selectSort(int [] arr) {
    for(int i = 0;i<arr.length-1;i++){
        for(int x = i;x<arr.length;x++) {
            if(arr[i]>arr[x]) {
                int temp = arr[i];
                arr[i] = arr[x];
                arr[x] = temp;
            }
        }
    }
}

例子讲解

数组：[12,11,34,65,334,23,55]

第一次排序：[12,11,34,65,334,23,55]
第二次排序：[11,12,34,65,334,23,55]
第三次排序：[11,12,34,65,334,23,55]
第四次排序：[11,12,23,65,334,34,55]
第五次排序：[11,12,23,34,334,65,55]
第六次排序：[11,12,23,34,55,334,65]
第七次排序：[11,12,23,34,55,65,334]
冒泡排序

工作原理
比较相邻的元素，如果第一个比第二个大（或者第一个比第二个小），就交换他们两个，对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大（或最小）的数。针对所有的元素重复以上的步骤，除了最后一个，持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现(java语言）

public static void buttleSort(int [] arr) {
for(int i = 0;i<arr.length-1;i++) {
    for(int x=0;x<arr.length-1-i;x++) {
        if(arr[x]>arr[x+1]) {
            int temp = arr[x];
            arr[x] = arr[x+1];
            arr[x+1] = temp;
            }
        }
     }
}

-例子讲解

数组：[12,11,34,65,334,23,55]

第一次排序：[12,11,34,65,334,23,55]
第一次排序：[11,12,34,65,23,55,334]
第一次排序：[11,12,34,23,55,65,334]
第一次排序：[11,12,23,34,55,65,334]
第一次排序：[11,12,23,34,55,65,334]
第一次排序：[11,12,23,34,55,65,334]
第一次排序：[11,12,23,34,55,65,334]
写的相对来说比较简单了，算法实现的代码不是唯一的，所以小编在这里仅提供了相对简单的实现代码，感兴趣的小伙伴，如果不明白，可以给我留言，我一定会回复的哦。
附：完整代码

public class Sort {

    public static void main(String[] args) {
        int [] arr = {12,11,34,65,334,23,55};
        System.out.print("排序前的结果：");
        printArray(arr);
        selectSort(arr);
        System.out.print("选择排序结果：");
        printArray(arr);
        buttleSort(arr);
        System.out.print("冒泡排序结果：");
        printArray(arr);
    }
    //选择排序
    public static void selectSort(int [] arr) {
        for(int i = 0;i<arr.length-1;i++){
                for(int x = i;x<arr.length;x++) {
                    if(arr[i]>arr[x]) {
                        swap(arr,i,x);
                    }
            }
        }
    }
    //冒泡排序
    public static void buttleSort(int [] arr) {
        for(int i = 0;i<arr.length-1;i++) {
            for(int x=0;x<arr.length-1-i;x++) {
                if(arr[x]>arr[x+1]) {
                    swap(arr,x,x+1);
                }
            }
        }
    }
    //交换函数
    public static void swap(int [] arr,int x,int y) {
        int temp = arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }
    //遍历函数
    public static void printArray(int [] arr) {
        for(int i=0;i<arr.length;i++) {
            if(i!=arr.length-1) {
                System.out.print(arr[i]+",");
            }else {
                System.out.println(arr[i]);
            }
        }
    }
}

请相信这个世界真的有人在过着你想要的生活，忽晴忽雨的江湖。愿你有梦为马，随处可栖。