Código de PHP - Clase para operaciones básicas de archivos y directorios

Imágen de perfil

Clase para operaciones básicas de archivos y directoriosgráfica de visualizaciones


PHP

estrellaestrellaestrellaestrellaestrella(1)
Publicado el 03 de Mayo del 2017 por abzerox
1.722 visualizaciones desde el 03 de Mayo del 2017. Una media de 28 por semana
Esta clase permite realizar algunas operaciones básicas sobre archivos y directorios.
* Copiar archivos
* Mover
* Borrar directorios
* Borrar archivos
* Encontrar archivos por extensión / expresión regular

Ejemplo de Uso:

1
2
3
4
5
6
7
8
try {
        $dir = 'directorio/de/prueba';
	$file = new \File\File;
	// $file::find($dir, 'php', false); // búsqueda por extensión
	$file::find($dir, '/^[0-9]+\-[A-Za-z0-9_\-\.]+\.php+$/', true); // búsqueda por expresión regular
} catch (Exception $e) {
	die($e->getMessage());
}

Requerimientos

php >= 5.6

1.0.0
estrellaestrellaestrellaestrellaestrella(1)

Actualizado el 06 de Julio del 2017 (Publicado el 03 de Mayo del 2017)gráfica de visualizaciones de la versión: 1.0.0
1.723 visualizaciones desde el 03 de Mayo del 2017. Una media de 28 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
<?php
declare(strict_types=1);
namespace File;
/**
 * Clase útil para realizar algunas operaciones básicas sobre
 * archivos y directorios.
 *
 * - Copiar archivos
 * - Mover
 * - Borrar directorios
 * - Borrar archivos
 * - Encontrar archivos por extensión/expresión regular
 *
 * @author [abZeroX]
 * @version 1.0.0
 */
class File
{
	/**
	 * $results
	 * Guarda los archivos encontrados por el método find.
	 * @var array
	 */
	public static $results = array();
 
	/**
	 * fullCopy
	 * Copia el contenido de un directorios a otro.
	 * En caso de que el archivo no exista, lanza una Excepción.
	 * @param string $source
	 * @param string $target
	 */
	public static function fullCopy($source, $target)
	{
		if (!file_exists($target)) {
			@mkdir($target);
		}
 
		if (is_dir($source)) {
			$directory = opendir($source);
			while (false !== ($entry = readdir($directory))) {
				if ($entry != '.' && $entry != '..') {
					$tmp_entry = $source.'/'.$entry;
					(is_dir($tmp_entry)) ? self::fullCopy($tmp_entry, $target.'/'.$entry) :
					copy($tmp_entry, $target.'/'.$entry);
				}
			}
			closedir($directory);
			clearstatcache();
		} else {
			if (file_exists($source)) {
				copy($source, $target.'/'.basename($source));
			} else {
				throw new \Exception('No existe el archivo de nombre '.$source);
			}
		}
	}
 
	/**
	 * move
	 * @param  string $source
	 * @param  string $target
	 * @return bool
	 */
	public static function move($source, $target)
	{
		self::fullCopy($source, $target);
		return self::remove($source);
	}
 
	/**
	 * removeDir
	 * Elimina un directorio.
	 * En caso de que el directorio no exista, lanza una Excepción.
	 * De lo contrario retorna true si se pudo eliminar.
	 * @param  string $dir
	 * @return bool
	 */
	public static function removeDir($dir)
	{
		if (!is_dir($dir)) {
			throw new \Exception($dir.' no es un directorio');
		}
 
		$files = array_diff(scandir($dir), array('.', '..'));
		foreach ($files as $file) {
			(is_dir($dir.'/'.$file)) ? self::removeDir($dir.'/'.$file) : unlink($dir.'/'.$file);
		}
 
		clearstatcache();
		return rmdir($dir);
	}
 
	/**
	 * removeFiles
	 * Recibe un array con el nombre de ficheros.
	 * En caso de que el fichero a eliminar no exista lanza una Excepción.
	 * @param  array $files
	 * @return bool
	 */
	public static function removeFiles(array $files)
    {
		foreach ($files as $file) {
			if (is_file((string) $file)) {
				if (file_exists((string) $file)) {
					unlink($file);
				} else {
					throw new \Exception('No existe el archivo de nombre '.$file);
				}
			} else {
					throw new \Exception($file.' no es un archivo.');
			}
		}
	}
 
	/**
	 * remove
	 * Elimina un fichero/directorio.
	 * Recibe un string con el nombre de un fichero/directorio.
	 * Lanza una Excepción si no existe dicho archivo/directorio.
	 * @param  string $entry
	 * @return bool
	 */
	public static function remove($entry)
	{
		if (file_exists($entry)) {
			return (is_dir($entry)) ? self::removeDir($entry) : self::removeFiles([$entry]);
		} else {
			throw new \Exception('No existe el fichero/directorio de nombre '.$entry);
		}
	}
 
	/**
	 * find
	 * Busca archivos dentro de un directorio, por extensión o
	 * que su nombre cumpla con una determinada expresión regular
	 * en caso de que el parámetro $regx sea TRUE.
	 *
	 * Los archivos se guardan en el array File::$resultado.
	 *
	 * @param string $directory
	 * @param string $entry
	 * @param bool $regx
	 */
	public static function find($directory, $entry, $regx)
	{
		if (!is_dir($directory)) {
			throw new \Exception('No existe el directorio de nombre '.$directory);
		}
 
		if (file_exists($directory)) {
			$dir = opendir($directory);
			while (false !== ($e = readdir($dir))) {
				if ($e != '.' && $e != '..') {
					if (is_file($directory.'/'.$e)) {
						// Comparo por extensión
						if (!$regx) {
							$ext = explode('.', $e);
							$ext = $ext[count($ext) - 1];
							if ($ext == $entry) {
								array_push(self::$results, $directory.'/'.$e);
							}
						} else {
							if (preg_match($entry, $e)) {
								array_push(self::$results, $directory.'/'.$e);
							}
						}
					} else {
						self::find($directory.'/'.$e, $entry, $regx);
					}
				}
			}
			closedir($dir);
		} else {
			throw new \Exception('No existe el directorio de nombre '.$directory);
		}
	}
}



Comentarios sobre la versión: 1.0.0 (1)

Imágen de perfil
kip
12 de Junio del 2017
estrellaestrellaestrellaestrellaestrella
Si estas usando métodos estáticos por que crear una instancia de la clase ?
Puedes usar algun alias o simplemente llamar a la clase con el espacio de nombre que le diste, algo asi:

\File\File::find($dir, '/^[0-9]+\-[A-Za-z0-9_\-\.]+\.php+$/', true);

O como decia, un alias:

use \File\File as MiclaseFile;
MiclaseFile::find($dir, '/^[0-9]+\-[A-Za-z0-9_\-\.]+\.php+$/', true);

Tambien puedes hacer esto y acceder a la clase directamente:

use \File\File;
File::find($dir, '/^[0-9]+\-[A-Za-z0-9_\-\.]+\.php+$/', true);
Responder

Comentar la versión: 1.0.0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s3973  
Revisar política de publicidad