计算机码

计算机码:原码,反码,补码;数据本身最左边一位为符号位,正数为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>';
}
}

完结!!!

撒花!!!!