A practical PHP file upload class code_PHP tutorial-PHP Tutorial-php.cn

Here is an implemented file upload class code from an online friend. We have introduced the use of each variable in detail. Take a look below and refer to it if necessary.

/**
* File upload class
*/
class uploadFile {
public $max_size = '1000000';//Set upload file Size
public $file_name = 'date';//The renaming method represents naming based on time, and others use the given name
public $allow_types;//The file extensions allowed to be uploaded, different file types use "| "Separated
public $errmsg = '';//Error message
public $uploaded = '';//Uploaded file name (including file path)
public $save_path;//Uploaded file Save path
private $files;//Submitted files waiting to be uploaded
private $file_type = array();//File type
private $ext = '';//Upload file extension

/**
* Constructor, initialization class
* @access public
* @param string $file_name Uploaded file name
* @param string $save_path Uploaded target folder
*/
public function __construct($save_path = './upload/',$file_name = 'date',$allow_types = '') {
$this-> file_name = $file_name;//The renaming method represents naming based on time, and others use the given name
$this->save_path = (preg_match('//$/',$save_path)) ? $save_path : $ save_path . '/';
$this->allow_types = $allow_types == '' ? 'jpg|gif|png|zip|rar' : $allow_types;
}

/* *
* Upload files
* @access public
* @param $files Files waiting to be uploaded ($_FILES[] from the form)
* @return boolean Return Boolean value
*/
public function upload_file($files) {
$name = $files['name'];
$type = $files['type'];
$size = $files['size'];
$tmp_name = $files['tmp_name'];
$error = $files['error'];

switch ($error) {
case 0 : $this->errmsg = '';
break;
case 1 : $this->errmsg = 'Exceeded the file size in php.ini';
break;
case 2 : $this->errmsg = 'Exceeded the file size specified by the MAX_FILE_SIZE option';
break;
case 3 : $this->errmsg = 'Only part of the file was uploaded';
break;
case 4: $this->errmsg = 'No file was uploaded';
break;
case 5: $this->errmsg = 'The uploaded file size is 0';
break;
default: $this->errmsg = 'File upload failed! ';
break;
}
if($error == 0 && is_uploaded_file($tmp_name)) {
//Detect file type
if($this->check_file_type($ name) == FALSE){
return FALSE;
}
//Detect file size
if($size > $this->max_size){
$this-> errmsg = 'The uploaded file '.$name.' is too large. The maximum supported file is '.ceil($this->max_size/1024).' kb file';
return FALSE;
}
$this->set_save_path();//Set the file storage path
$new_name = $this->file_name != 'date' ? $this->file_name.'.'.$this->ext : date('YmdHis').'.'.$this->ext;//Set a new file name
$this->uploaded = $this->save_path.$new_name;//Uploaded file name
//Move file
if(move_uploaded_file($tmp_name,$this->uploaded)) {
$this->errmsg = 'File'.$this->uploaded.'Uploaded successfully! ';
return TRUE;
}else{
$this->errmsg = 'File'.$this->uploaded.'Upload failed ! ';
return FALSE;
}

}
}

/**
* Check the uploaded file type
* @access public
* @param string $filename The name of the file waiting to be checked
* @return Returns TRUE if the check passes, FALSE and an error message if it fails
*/
public function check_file_type($filename){
$ext = $this->get_file_type($filename);
$this->ext = $ ext;
$allow_types = explode('|',$this->allow_types);//Split the file extensions allowed to be uploaded into an array
//echo $ext;
//Check the uploaded file Whether the extension is among the file extensions allowed to be uploaded
if(in_array($ext,$allow_types)){
return TRUE;
}else{
$this->errmsg = ' The uploaded file '.$filename.' is of wrong type, only supports uploading '.str_replace('|',',',$this-> allow_types).' and other file types!';
return FALSE;
}
}

/**
* Get the file type
* @access public
* @param string $filename The target file name to get the file type
* @return string file type
*/
public function get_file_type( $filename){
$info = pathinfo($filename);
$ext = $info['extension'];
return $ext;
}

/**
* Set the saving path after uploading the file
*/
public function set_save_path(){
$this->save_path = (preg_match('//$/',$this->save_path)) ? $this->save_path : $this->save_path . '/';
if(!is_dir($this->save_path)){
//If the directory does not exist, create the directory
$this->set_dir( );
}
}

/**
* Create directory
* @access public
* @param string $dir The path to create the directory
* @return boolean Returns an error message and FALSE on failure
*/
public function set_dir($dir = null){
//Check whether the path exists
if(!$dir){
$dir = $this->save_path;
}
if(is_dir($dir)){
$this->errmsg = 'Required The created folder already exists! ';
}
$dir = explode('/', $dir);
foreach($dir as $v){
if($v){
$d .= $v . '/';
if(!is_dir($d)){
$state = mkdir($d, 0777);
if(!$state)
$this-> ;errmsg = 'Error creating directory ' . $d . '! ';
}
}
}
return true;
}
}

/***************************************************
* Image processing class
*
* You can generate thumbnails, watermark and other operations on pictures
* The default encoding of this class is UTF8. If you want to use it under GBK, please add a Chinese string watermark in the img_mark method. Remove the iconv annotation
*
* Since the sizes (pixels) of UTF8 Chinese characters and English letters are not easy to determine, when there are too many mixed Chinese and English characters, the string may be biased to the left
* or to the right, please depend on the project The environment adjusts $strc_w = strlen($this->mark_str)*7+5 in the get_mark_xy method
* * Requires GD library support. For better use of this class, it is recommended to use GD library 2.0+
*
* @author kickflip@php100 QQ263340607
********************************* ****************/
class uploadImg extends uploadFile {
public $mark_str = 'kickflip@php100'; //Watermark string
public $str_r = 0; //String color R
public $str_g = 0; // String color G
public $str_b = 0; //String color B
public $mark_ttf = './upload/SIMSUN.TTC'; //Watermark text font file (including path)
public $mark_logo = './upload/logo.png'; //Watermark image
public $resize_h;//Generate thumbnail height
public $resize_w;//Generate thumbnail width
public $source_img; //Source image file
public $dst_path = './upload/'; //Thumbnail file storage directory, if left blank, it will be the source image storage directory

/**
* Generate thumbnail image
* @access public
* @param integer $w The width of the reduced image (px)
* @param integer $h The height of the reduced image (px) px)
* @param string $source_img source image (path + file name)
*/
public function img_resized($w,$h,$source_img = NULL){
$source_img = $source_img == NULL ? $this->uploaded : $ source_img; //Get the address of the source file. If it is empty, it defaults to the last uploaded image
if(!is_file($source_img)) { //Check whether the source image exists
$this->errmsg = 'File'.$source_img.'does not exist';
return FALSE;
}
$this->source_img = $source_img;
$img_info = getimagesize($source_img);
$source = $this->img_create($source_img); //Create source image
$this->resize_w = $w;
$this->resize_h = $h;
$ thumb = imagecreatetruecolor($w,$h);
imagecopyresized($thumb,$source,0,0,0,0,$w,$h,$img_info[0],$img_info[1]);/ /Generate thumbnail image
$dst_path = $this->dst_path == '' ? $this->save_path : $this->dst_path; //Get the target folder path
$dst_path = ( preg_match('//$/',$dst_path)) ? $dst_path : $dst_path . '/';//Add /
after the target folder if(!is_dir($dst_path)) $this-> ;set_dir($dst_path); //If the target folder does not exist, create it
$dst_name = $this->set_newname($source_img);
$this->img_output($thumb,$dst_name) ;//Output image
imagedestroy($source);
imagedestroy($thumb);
}

/**
*Watermark
*@access public
*@param string $source_img Source image path + file name
*@param integer $mark_type Watermark type (1 is English string, 2 is Chinese character String, 3 is the picture logo, the default is English string)
*@param integer $mark_postion watermark position (1 is the lower left corner, 2 is the lower right corner, 3 is the upper left corner, 4 is the upper right corner, the default is the lower right corner) ;
*@return watermarked picture
*/
public function img_mark($source_img = NULL,$mark_type = 1,$mark_postion = 2) {
$source_img = $source_img == NULL ? $this->uploaded : $source_img;//Get the address of the source file, if it is empty, the default is The last uploaded image
if(!is_file($source_img)) { //Check whether the source image exists
$this->errmsg = 'File'.$source_img.'does not exist';
return FALSE;
}
$this->source_img = $source_img;
$img_info = getimagesize($source_img);
$source = $this->img_create($source_img); / /Create source image
$mark_xy = $this->get_mark_xy($mark_postion);//Get watermark position
$mark_color = imagecolorallocate($source,$this->str_r,$this->str_g ,$this->str_b);

switch($mark_type) {

case 1: //Add English string watermark
$str = $this->mark_str;
imagestring($source,5,$mark_xy[0],$mark_xy[1],$str,$mark_color);
$this->img_output($source,$source_img);
break ;

case 2: //Add Chinese string watermark
if(!is_file($this->mark_ttf)) { //Check whether the font file exists
$this->errmsg = 'Watermarking failed: font file '.$this->mark_ttf.' does not exist!';
return FALSE;
}
$str = $this->mark_str;
/ /$str = iconv('gbk','utf-8',$str);//Convert character encoding. If you use GBK encoding, please remove this line comment
imagettftext($source,12,0,$mark_xy[2 ],$mark_xy[3],$mark_color,$this->mark_ttf,$str);
$this->img_output($source,$source_img);
break;

case 3: //Add image watermark
if(is_file($this->mark_logo)){ //If there is a watermark logo image, get the basic information of the logo image, if it does not exist, exit
$logo_info = getimagesize($this->mark_logo);
}else{
$this->errmsg = 'Watermarking failed: logo file '.$this->mark_logo.' does not exist! ';
return FALSE;
}

$logo_info = getimagesize($this->mark_logo);
if($logo_info[0]>$img_info[0] || $logo_info[1]>$img_info[1]) { / /If the source image is smaller than the logo size, exit
$this->errmsg = 'Watermarking failed: The source image'.$this->source_img.' is smaller than '.$this->mark_logo.'! ';
return FALSE;
}

$logo = $this->img_create($this->mark_logo);
imagecopy ( $source, $logo, $mark_xy[ 4], $mark_xy[5], 0, 0, $logo_info[0], $logo_info[1]);
$this->img_output($source,$source_img);
break;

default: //Others are text images
$str = $this->mark_str;
imagestring($source,5,$mark_xy[0],$mark_xy[1],$str ,$mark_color);
$this->img_output($source,$source_img);
break;
}
imagedestroy($source);
}

/**
* Get the watermark position
* @access private
* @param integer $mark_postion The position of the watermark (1 is the lower left corner, 2 is the lower right corner, 3 is the upper left corner, 4 is the upper right corner, others are right Lower corner)
* @return array $mark_xy The coordinates of the watermark position (index 0 is the English string watermark coordinate X, index 1 is the English string watermark coordinate Y,
* Index 2 is the Chinese string watermark coordinate X, Index 3 is the Chinese string watermark coordinate Y, index 4 is the watermark image coordinate X, index 5 is the watermark image coordinate Y)
*/
private function get_mark_xy($mark_postion){
$img_info = getimagesize($this->source_img);

$stre_w = strlen($this-> ;mark_str)*9+5; //The length of the watermark English string (px) (the size of English characters for size 5 is about 9px, plus 5px for beauty)
//(The size of Chinese characters for size 12 is about 9px 12px, in utf8, the length of a Chinese character is 3 bytes and 4px per byte, while the length of an English character is approximately 9px
// In order to display a mixture of Chinese and English, set its length to characters Number of sections*7px)
$strc_w = strlen($this->mark_str)*7+5; //The length of the watermark Chinese string (px)

if(is_file($this-> ;mark_logo)){ //If there is a watermark logo image, get the basic information of the logo image
$logo_info = getimagesize($this->mark_logo);
}

//Due to imagestring The starting position of the string is different between the function and the imagettftext function, so the Y position of the English and Chinese strings is also different
//The imagestring function is referenced from the upper left corner of the text. The imagettftext function is referenced from the lower left corner of the text
switch($mark_postion){

case 1: //Position lower left corner
$mark_xy[0] = 5; //Watermark English string coordinates X
$mark_xy[1] = $img_info [1]-20; //Watermark English string coordinates Y
$mark_xy[2] = 5; //Watermark Chinese string coordinates X
$mark_xy[3] = $img_info[1]-5; //Watermark Chinese string coordinates Y
$mark_xy[4] = 5; //Watermark image coordinates X
$mark_xy[5] = $img_info[1]-$logo_info[1]-5;// Watermark image coordinate Y
break;

case 2: //Position lower right corner
$mark_xy[0] = $img_info[0]-$stre_w; //Watermark English string coordinate X
$mark_xy[1] = $img_info[1]-20; //Watermark English string coordinate Y
$mark_xy[2] = $img_info[0]-$strc_w; //Watermark Chinese string coordinate X
$mark_xy[3] = $img_info[1]-5;//Watermark Chinese string coordinate Y
$mark_xy[4] = $img_info[0]-$logo_info[0]-5;// Watermark image coordinates Upper left corner
$mark_xy[0] = 5; //Watermark English string coordinates X
$mark_xy[1] = 5; //Watermark English string coordinates Y
$mark_xy[2] = 5 ; //Watermark Chinese string coordinates [5] = 5;//Watermark image coordinate Y
break;

case 4: //Position upper right corner
$mark_xy[0] = $img_info[0]-$stre_w; //Watermark English string coordinates X
$mark_xy[1] = 5;// Watermark English string coordinates Y
$mark_xy[2] = $img_info[0]-$strc_w; //Watermark Chinese string coordinates X
$mark_xy[3] = 15;//Watermark Chinese string coordinates Y
$mark_xy[4] = $img_info[0]-$logo_info[0]-5;//Watermark image coordinates X
$mark_xy[5] = 5;//Watermark image coordinates Y
break;

default : //Other defaults are the lower right corner
$mark_xy[0] = $img_info[0]-$stre_w; //Watermark English string coordinates X
$mark_xy[1 ] = $img_info[1]-5; //Watermark English string coordinates Y
$mark_xy[2] = $img_info[0]-$strc_w; //Watermark Chinese string coordinates X
$mark_xy[ 3] = $img_info[1]-15;//Watermark Chinese string coordinates Y
$mark_xy[4] = $img_info[0]-$logo_info[0]-5;//Watermark image coordinates X
$mark_xy[5] = $img_info[1]-$logo_info[1]-5;//Watermark image coordinate Y
break;
}
return $mark_xy;
}

/**
* Create source image
* @access private
* @param string $source_img Source image (path + file name)
* @return img Create an image from the target file
*/
private function img_create($source_img) {
$info = getimagesize($source_img);
switch ($info[2]){
case 1:
                                                                                                                                                                     efromgif($source_img);
                                                                                                                                   case 3:
$source = @imagecreatefrompng($source_img);
break;
case 6:
$source = @imagecreatefromwbmp($source_img);
break;
default:
$source = FALSE;
break;
}
return $source;
}

/**
* Rename the image
* @access private
* @param string $source_img Source image path + file name
* @return string $dst_name Renamed image name (path + file name)
*/
private function set_newname($sourse_img) {
$info = pathinfo($sourse_img);
$new_name = $this->resize_w.'_'.$this->resize_h.'_'.$info['basename'];//Change the file name to: width_height_filename
if($this->dst_path == ''){ //If the thumbnail storage path is empty, it will default to the same folder as the source file
$dst_name = str_replace($info['basename'],$ new_name,$sourse_img);
}else{
$dst_name = $this->dst_path.$new_name;
}
return $dst_name;
}

/**
* Output image
* @access private
* @param $im processed image
* @param $dst_name output image name (path + file name)
* @ return output image
*/
public function img_output($im,$dst_name) {
$info = getimagesize($this->source_img);
switch ($info[2 ]){
case 1:
if(!function_exists('imagegif')){
imagejpeg($im,$dst_name);
}else{
Imagegif($im, $ dst_name);
}
break;
case 2:
imagejpeg($im,$dst_name);
break;
           case 3:
              imagepng($im,$ dst_name);
break;
case 6:
imagewbmp($im,$dst_name);
break;
}
}

}
? >

It is much more convenient to write this as an upload file class. Save the above code into a file and it can be publicly called, modified and deleted.