计算机码

计算机码：原码，反码，补码；数据本身最左边一位为符号位，正数为0，负数为1。
原码：数据本身从10进制转换为2进制
正数：符号位为0
负数：符号位为1
反码：针对负数，符号位不变，其他取反
补码：针对负数，反码后加1

注意：正数不存在反码和补码，10进制转2进制是什么就是什么；或者说反码补码后还是本身
+1
00000001 正1原码

-1
10000001 负1原码

11111110 负1反码

11111111 负1补码

1 + 0 = 1
1 + 1 = 10 //逢2进1

+0
00000000

-0
10000000 //原码

11111111 //反码

00000000 //补码，因为+1等于10，结果应该等于100000000，溢出后等于00000000

+2
00000010

-2
10000010 //原码

11111101 //反码

11111110 //补码

一字节是8个2进制位，四个字节是32个2进制位

位运算符

&：按位与；两个位都为1结果为1，否则为0
|：按位或；两个位有一个位为1，结果为1
~：按位非；一个位运算：位为1结果为0；为0结果为1
^:按位异或；两个位相同位0，不同为1
<<:按位左移；整个位（32位），向左移一位；右边补0
>>:按位右移；整个位(32位)，向右移一位；左边补符号位（正数补0，负数补1）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<?php
$a = 1;
$b = 1;
$c = 0;
$d = 0;

echo "按位与<br>";
echo $a & $b;       //1
echo "<br>";
echo $a & $c;       //0

echo "<br><br>按位或<br>";
echo $a | $b;       //1
echo "<br>";
echo $a | $c;       //1
echo "<br>";
echo $d | $c;       //0

echo "<br><br>按位非<br>";
echo (~$a);       //-2
// 1原码：00000001
// ~：11111110
// 转十进制=-2
echo "<br>";
echo (~$c);       //-1
// 0原码：00000000
// ~   :11111111
// 转十进制：-1

echo "<br><br>按位异或<br>";
echo $a ^ $b;       //0
echo "<br>";
echo $a ^ $c;       //1
echo "<br>";
echo $d ^ $c;       //0

echo "<br><br>按位异或<br>";
echo ($a<<1);       //2
echo "<br>";
echo $a >> 1;       //0

PHP数据类型

四种标准类型

integer (整型)
boolean (布尔型)
float (浮点型)
string (字符型)

两种复合类型

array (数组型)
object (对象型)

两种特殊类型

resource (资源)
NULL (NULL)

伪类型

Mixed (混合型)
number (数值型)

常用系统函数

输出函数

echo() //输出所有参数。不会换行。 echo 不是一个函数（它是一个语言结构)
print() //和 echo 最主要的区别： print 仅支持一个参数，并总是返回 1
var_dump() //显示关于一个或多个表达式的结构信息，包括表达式的类型与值。数组将递归展开值，通过缩进显示其结构。
print_f() //print_r() 以人类易读的格式显示一个变量的信息
var_export() //函数返回关于传递给该函数的变量的结构信息，它和 var_dump() 类似，不同的是其返回的表示是合法的 PHP 代码。

时间函数

date() //格式化时间
time() //返回当前时间戳
microtime() //当前 Unix 时间戳以及微秒数
strtotime() //日期格式的字符串并尝试将其解析为 Unix 时间戳

数学函数

max() //返回最大值
mix() //返回最小值
rand() //返回一个随机数
mt_rand() //生成更好的随机数,效率高
round() //对浮点数进行四舍五入
ceil() //返回不小于 value 的下一个整数，value 如果有小数部分则进一位。
floor() //返回不大于 value 的最接近的整数，将 value 的小数部分舍去取整。
pow() //返回 base 的 exp 次方的幂。如果可能，本函数会返回 integer。
abs() //返回参数 number 的绝对值。
sqrt() //返回 arg 的平方根。

函数函数

function_exists() //判断函数是否被定义
func_get_arg() //获取自定义函数的实参值
func_get_args() //获取自定义函数的所有实参值
func_num_args() //获取自定义函数的实参数量

错误函数

trigger_error() //产生一个用户级错误
ini_set() //设置指定配置选项的值。这个选项会在脚本运行时保持新的值，并在脚本结束时恢复。

PHP字符串

定义字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
//单引号定义
$str1 = 'string';

//双引号定义
$str2 = "string";

//nowdoc结构，单引号字符串
$str3 = <<<'EON'
string
EON;

//heredoc结构，双引号字符串
$str4 = <<<EON
    hello,world;
        2020/08/29
EON;
echo '<pre>';
var_dump($str1,$str2,$str3,$str4);

//string(6) "string"
//string(6) "string"
//string(6) "string"
//string(36) "    hello,world;
//        2020/08/29"

字符串的转义

在计算机中，有的字母何符号具有特殊的含义，如果需要使用本身而不是使用它的功能，则需要对字符串进行转义；PHP和大多数语言相似，使用+字符串来实现转义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
$str = 'This is \'yes\',this is \'no\'.';
echo $str,'<br>';

$str = "This is \"yes\",this is \"no\".";
echo $str,'<br>';

$str = "This is 'yes',this is 'no'.";
echo $str,'<br>';

$str = 'This is "yes",this is "no".';
echo $str,'<br>';

$str = <<<EON
This is "yes",this is "no".
EON;
echo $str,'<br>';

$str = <<<'EON'
This is 'yes',this is 'no'.
EON;
echo $str,'<br>';

//This is 'yes',this is 'no'.
//This is "yes",this is "no".
//This is 'yes',this is 'no'.
//This is "yes",this is "no".
//This is "yes",this is "no".
//This is 'yes',this is 'no'.

PHP常用转义符号：
1.\‘在单引号字符串中显示单引号
2.\“在双引号字符串中显示双引号
3.\r回到当前行的行首
4.\n新的一行
5.\t输出四个空格
6.\$转义$符号，让其失去定义变量的作用

单双引号的区别

1、单引号只识别\‘转义，其他原样输出；双引号不识别\‘转义，其他识别
2、单引号不解析变量，$a就输出$a；双引号解析变量，$a输出$a的值
3、单引号不解析变量和其他转义，处理纯文本效力高
4、双引号解析变量和其他转义，处理纯文本效率低

1
2
3
4
5
6
7
8
9
10
11
12
<?php
$a = '2020-08-09 09:35:26';
//单引号不会解析$a
$str = 'Now time:{$a}';
echo $str,'<br>';

//双引号会解析$a,使用{}区分变量和文本
$str = "Now time:{$a}";
echo $str,'<br>';

//Now time:{$a}
//Now time:2020-08-09 09:35:26

字符串长度

在utf-8字符集编码中，一个汉字占三个字节

1
2
3
4
5
6
7
8
<?php
$str = 'China';
echo '"',$str,'" long: ',strlen($str),'<br>';
$str = '中国';
echo '"',$str,'" long: ',strlen($str),'<br>';

//"China" long: 5
//"中国" long: 6

字符串函数

  1. 转换函数

    implode — 将一个一维数组的值转化为字符串
    explode — 使用一个字符串分割另一个字符串
    str_split — 将字符串转换为数组

  2. 处理函数

    trim — 去除字符串首尾处(两边)的空白字符（或者其他字符）
    ltrim — 删除字符串开头(左边)的空白字符（或其他字符）
    rtrim — 删除字符串末端(右边)的空白字符（或者其他字符）

  3. 截取函数

    substr — 从某位置截取指定长度的字符串
    strstr — 查找字符串的首次出现并截取之后的全部字符串

  4. 大小写函数

    strtolower — 将字符串转化为小写
    strtoupper — 将字符串转化为大写
    ucfirst — 将字符串的首字母转换为大写

  5. 查找函数

    strpos — 查找字符串首次出现的位置 //可能返回0，判断false使用===
    strrpos — 查找字符串最后一次出现的位置 //可能返回0，判断false使用===

  6. 字符串替换

    str_replace — 子字符串替换

  7. 格式化函数

    printf — 输出格式化字符串
    sprintf — 返回格式化字符串

  8. 其他函数

    str_repeat — 重复一个字符串
    str_shuffle — 随机打乱一个字符串
    strlen — 获取字符串长度

PHP数组

数组概念

数组[array]：数据的组合，指将一组数据存储到一个指定的容器中，用变量指向该容器，然后通过变量一次性得到该容器中的所有数据。

数组类型

  • 索引数组：下标全为整数的数组
  • 关联数组：下标标全为字符串的数组
  • 混合数组：下标存在整数和字符串的数组

PHP数组定义

  1. 使用array关键词

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <?php
    //array([ mixed $...] ) : array
    echo '<pre>';
    $array = array('China',71,'good');
    var_dump($array);
    /*
    array(3) {
      [0]=>
      string(5) "China"
      [1]=>
      int(71)
      [2]=>
      string(4) "good"
    }
     */

  2. 使用中括号定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
echo '<pre>';
$array = ['China',71,'good'];
var_dump($array);

/*
array(3) {
    [0]=>
  string(5) "China"
    [1]=>
  int(71)
  [2]=>
  string(4) "good"
}
*/
  1. 隐写定义
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
echo '<pre>';
$array[] = 1;
$array[] = 2;
$array[4] = 3;
var_dump($array);

//该方式可以指定下标，可以是字符串和数字；如果不指定下标，则使用递增下标

/*
array(3) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [4]=>
  int(3)
}
*/

  1. 定义多维数组
    多维数组就是数组里的数组，理论上有N维数组
    多维数组调用方式：$array[一维下标][二维下标]
1
2
3
4
<?php
$arr = array('Say ',['goodbye ','to',['the' ,['depravation ','of ',['yesterday','I love you!']]]],'bey!');

echo $arr[1][2][1][2][1];       //I love you!

PHP数组特点

  1. 可以整数下标和字符串下标
  2. 不同下标可以混合存在
  3. 数组元素的顺序以放入顺序wei’zhun
  4. 数字下标的自增长特性
  5. 特殊值下标的转换

数组遍历

PHP遍历数组有专门的函数，也可以使用for之类的循环函数变量；如果是多维数组，可以进行嵌套遍历。

  1. 使用foreac遍历
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$arr = array(
    array('name'=>'Jim','age'=>30),
    array('name'=>'Tom','age'=>25)
);

foreach ($arr as $key => $value){
    echo 'His name is '.$value['name'].', age is ' . $value['age'] . '<br>';
}

//His name is Jim, age is 30
//His name is Tom, age is 25
  1. for循环遍历数组

    for函数只能遍历索引数组

1
2
3
4
5
6
7
8
9
10
11
12
<?php
$arr = array(
    0 => array('name'=>'Jim','age'=>30),
    1 => array('name'=>'Tom','age'=>25)
);

for ($i=0,$len=count($arr);$i<$len;$i++){
    echo 'His name is '.$arr[$i]['name'].' and age is ' . $arr[$i]['age'] . '<br>';
}

//His name is Jim and age is 30
//His name is Tom and age is 25
  1. 使用while、each、list函数遍历
1
2
3
4
5
6
7
8
9
<?php
$arr = array(11,3,5,);
$bool = 1;
while (list($key,$value) = @each($arr)) {
    echo 'key is ' . $key . ' and value is ' . $value . '<br>';
};
//key is 0 and value is 11
//key is 1 and value is 3
//key is 2 and value is 5

数组函数

  1. 排序函数，通过ASCII码比较

sort — 对数组排序
rsort — 对数组逆向排序
asort — 对数组进行排序并保持索引关系
arsort — 对数组进行逆向排序并保持索引关系
ksort — 对数组按照键名排序，本函数主要用于关联数组。
krsort — 对数组按照键名逆向排序，主要用于结合数组。
shuffle — 随机打乱数组

  1. 指针函数

reset — 将数组的内部指针指向第一个单元
end — 将数组的内部指针指向最后一个单元
next — 将数组中的内部指针向前移动一位
prev — 将数组的内部指针倒回一位
current — 返回数组中的当前指针键值
key — 从关联数组中取得当前指针键名

  1. 其他函数

count — 计算数组中的单元数目，或对象中的属性个数
array_push — 将一个或多个单元压入数组的末尾（入栈）
array_pop — 弹出数组最后一个单元（出栈）
array_shift — 将数组开头的单元移出数组
array_unshift — 在数组开头插入一个或多个单元
array_reverse — 返回单元顺序相反的数组
in_array — 检查数组中是否存在某个值
is_array — 检测变量是否是数组
array_keys — 返回数组中部分的或所有的键名
array_values — 返回数组中所有的值

数组出入栈

压栈：先进栈的后出栈，都是从一端出来
从前面压栈=array_unshift/array_shift
从后面压栈=array_push/array_pop

队列：先进栈的先出栈，一端进，一端出
前进后出=array_unshift/array_pop
后进前出=array_push/array_shift

编程思想

编程思想：如何利用数学模式来解决对应的需求问题；然后利用代码实现对应的数据模型(逻辑)
算法：利用代码实现对应的数学模型，从而解决对应的业务问题。

递推算法

递推算法是一种简单的算法，即通过已知条件，利用特定关系得出中间推论，直至得到结果的算法。通过最简单已知条件逐步推演结果称为顺推，反之通过结果找到规律推出已知条件成为逆推。

悲波那契数列：1 1 2 3 5 8 13 …
需求：找到第50个数是多少

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?php
/*
$n = 1;
$j = 1;
$n = $j + $n; //2
$j = $n - $j;
echo $n , '<br>';
$n = $j + $n; //3
$j = $n - $j;
echo $n , '<br>';
$n = $j + $n; //5
$j = $n - $j;
echo $n , '<br>';
$n = $j + $n; //8
$j = $n - $j;
echo $n , '<br>';
$n = $j + $n; //13
$j = $n - $j;
echo $n , '<br>';
*/

for ($i=0,$j=0,$n=1;$i<50;$i++){
    echo $n,'<br>';
    $n = $j + $n;
    $j = $n - $j;
}

递归算法

递归算法是把问题转化为规模缩小了的同类子问题，然后递归调用函数或过程来表示问题的解。递归的本质就是函数调用自己：一个函数需要开辟一块内存空间，递归会出现同时调用N个函数(自己)，所以该算法是使用空间换时间。

递归点：发现当前问题可以有解决当前问题的函数，去解决规模比当前小的我问题来解决
递归出口：当问题解决的时候，已经到达最优子问题，不能再次调用函数

悲波那契数列：1 1 2 3 5 8 13 …
需求：找到第50个数是多少

1
2
3
4
5
6
<?php
function get_n($n){
    if ($n == 1 || $n == 2) return 1;
    return get_n($n - 1) + get_n($n - 2);
}
echo get_n(5);

数组排序算法

冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?php
$arr = array("lemon", "orange", "banana", "apple");
shuffle($arr);
echo '<pre>';
print_r($arr);
function my_sort($arr,$bool)
{
    for ($i = 0, $len = count($arr); $i < $len - 1; $i++) {
        for ($j = 0; $j < $len - $i - 1; $j++) {
            if ($bool){
                if ($arr[$j] > $arr[$j + 1]) {
                    $tmp = $arr[$j + 1];
                    $arr[$j + 1] = $arr[$j];
                    $arr[$j] = $tmp;
                }
            }else{
                if ($arr[$j] < $arr[$j + 1]) {
                    $tmp = $arr[$j + 1];
                    $arr[$j + 1] = $arr[$j];
                    $arr[$j] = $tmp;
                }
            }
        }
    }
    return $arr;
}
print_r( my_sort($arr,true));

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
$arr = array(1,2,3,4,5,6,7,8,9);
shuffle($arr);
echo '<pre>';
print_r($arr);
//选择排序
for ($i=0,$len=count($arr);$i<$len;$i++){
    $min = $i;
    for ($j=$i+1;$j<$len;$j++) {
        if ($arr[$j] > $arr[$min]) {
            $min = $j;
        }
    }
    if ($min != $i){
        $tmp = $arr[$i];
        $arr[$i] = $arr[$min];
        $arr[$min] = $tmp;
    }
}
print_r($arr);

插入排序

插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<?php
echo '<pre>';
$arr = array(2,4,1,3,5,8,6,9,7);
// 1、   确定要插入多少次(假设一个数组一次性插入到正确的位置、第一个位置是对的)
for ($i = 1,$len = count($arr);$i < $len; $i++){
    // 2、   取出当前要插入的元素的值
    $tmp = $arr[$i];
    // 3、   让该数据和前面已经排好序的全部值比较
    $flag = false;
    for ($j = $i - 1;$j >= 0;$j--){
        //  4、  如果要插入的值比前面一个大，就交换位置
        if ($arr[$j] < $tmp){
            $arr[$j+1] = $arr[$j];
            $flag = true;
        }else{
            break;
        }
    }
    if ($flag){
        $arr[$j+1] = $tmp;
    }
    print_r($arr);
}

/*
//插入排序，从大到小
2,4,1,3,5,8,6,9,7
4 < 2? false           //4比2大，交换位置
4,2,1,3,5,8,6,9,7       //使用1再次比较之前的所有数据
1 < 2? true             //因为1已经小于前面的第一个数据，不用交换，跳过
4,2,1,3,5,8,6,9,7       //使用3比较之前的所有数据
3 < 1? false            //3比1大，交换位置
4,2,3,1,5,8,6,9,7       //使用3再次比较之前的所有数据
3 < 2? false            //3比2大，交换位置
4,3,2,1,5,8,6,9,7       //以此循环
*/

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
$arr = array(5,6,4,3,7,1,9,8);
function quick_sort($arr){
    $len = count($arr);
    if ($len <= 1) return $arr;
    $l = $r = array();
    for ($i=1;$i<$len;$i++){
        if ($arr[$i] < $arr[0]){
            $l[] = $arr[$i];
        }else{
            $r[] = $arr[$i];
        }
    }
    $l = quick_sort($l);
    $r = quick_sort($r);
    return array_merge($l,(array)$arr[0],$r);
}
echo '<pre>';
print_r(quick_sort($arr));

归并排序

归并排序（Merge Sort）是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
$arr =  array(2,7,4,9,8,5,1,6);
function merge_sort($arr){
    //递归出口
    $len = count($arr);
    if ($len <= 1) return $arr;
    //拆分数组
    $middle = floor($len / 2);
    $left = array_slice($arr,0,$middle);
    $right = array_slice($arr,$middle);
    //递归点
    $left = merge_sort($left);
    $right = merge_sort($right);
    //二路归并
    $marr = array();
    while (count($left) && count($right)){
        $marr[] = $left[0] > $right[0] ? array_shift($left) : array_shift($right);
    }
    return array_merge($marr,$left,$right);
}
echo '<pre>';
print_r(merge_sort($arr));

查找算法

查找算法的含义

查找算法是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是最常用的基本算法。查找算法是指实现查找过程对应的代码集。就是中大型数组中快速定位想要的元素。

顺序查找算法

顺序查找也称为线性查找，从数据结构线形表的一端开始，顺序扫描，以此将扫描的结点关键字与给定的值比较，若相等则表示查找成功；若扫描结束乃没有找到关键字等于给定值的结点，表示查找失败。

1
2
3
4
5
6
7
8
9
10
<?php
function get_check($arr,$res){
    for ($i = 1,$len=count($arr); $i<$len;$i++){
        if ($arr[$i] == $res) return $arr[$i];
    }
    return false;
}
$arr = array(1,6,5,8,3,9,4,7);
$res = 50;
var_dump(get_check($arr,$res));

二分查找算法

二分查找要求线性表中的结点按关键字值升序或降序排序，用给定值k先与中间结点的关键字比较，中间结点把线性表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表。这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
//二分查找算法
function get_check($arr,$res){
    sort($arr);
    $right = count($arr);
    $lift = 0;
    while ($lift <= $right){
        $middle = floor(($right + $lift) / 2);
        if ($arr[$middle] == $res) return true;
        if ($arr[$middle] < $res){
            $lift = $middle + 1;
        }else{
            $right = $middle - 1;
        }
    }
    return false;
}
$arr = array(1,5,7,9,13,2,8,3,10,4);
$res = 2;
var_dump(get_check($arr,$res));

文件上传

前台表单

文件上传表单中type属性值为file，enctype属性必须为multipart/form-data。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!doctype html>
<html lang="ch">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>文件上传</title>
</head>
<body>
    <form method="post" action="upload.php" enctype="multipart/form-data">
        <input type="file" name="filename" />
        <input type="submit" value="上传" />
    </form>
</body>
</html>

后端代码

在PHP中有个超全局变量$_FLES，该变量专门用来接收用户上传的文件。
结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
array(5) {
  ["name"]=>
  string(25) "这有啥好抑郁的.jpg"
  ["type"]=>
  string(10) "image/jpeg"
  ["tmp_name"]=>
  string(22) "C:\Windows\phpA1D3.tmp"
  ["error"]=>
  int(0)
  ["size"]=>
  int(233237)
}

使用php脚本把上传来的文件移动到指定目录：

1
2
3
4
5
6
<?php
echo '<pre>';
var_dump($_FILES['image']);
if (is_uploaded_file($_FILES['image']['tmp_name'])) {
    move_uploaded_file($_FILES['image']['tmp_name'], 'upload/' . $_FILES['image']['name']);
}

多文件上传

不同名文件

通过数组遍历的方式上传文件，都不需要知道name属性值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<!doctype html>
<html lang="ch">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>文件上传</title>
</head>
<body>
    <form method="post" action="index.php" enctype="multipart/form-data">
        <input type="file" name="head" />
        <input type="file" name="body" />
        <input type="file" name="foot" />
        <input type="submit" value="上传" />
    </form>
</body>
</html>
<?php
foreach($_FILES as $value){
    if (is_uploaded_file($value['tmp_name']) && $value['error'] === 0){
        if (move_uploaded_file($value['tmp_name'],'upload/' . $value['name'])){
            echo '文件上传成功<br>';
        }else{
            echo '文件保存失败<br>';
        }
    }else{
        echo '文件上传失败<br>';
    }
}

同名文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<!doctype html>
<html lang="ch">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>文件上传</title>
</head>
<body>
<form method="post" action="index.php" enctype="multipart/form-data">
    <input type="file" name="image[]" />
    <input type="file" name="image[]" />
    <input type="file" name="image[]" />
    <input type="submit" value="上传" />
</form>
</body>
</html>
<?php
echo '<pre>';
print_r($_FILES);
    for ($i = 0,$len=count($_FILES['image']['name']); $i < $len; $i++){
        $file = $_FILES['image'];
        if (is_uploaded_file($file['tmp_name'][$i])){
            if (move_uploaded_file($file['tmp_name'][$i],'upload/' . $file['name'][$i])){
                echo '文件上传成功<br/>';
            }else{
                echo '文件移动失败<br/>';
            }
        }else{
            echo '文件上传失败<br>';
        }
    }

完结！！！

撒花！！！！