Disponible la versión 5.0.0 final de Deame3p, ahora aparte de exportar datos de excel hacia MySQL, también realiza la importación es decir genera a partir de una tabla MySQL un archivo excel. Añadimos también un administrador (ABM) básico para tablas que esta en desarrollo. Los Cambios con respecto a la versión 4.0.1 son:

• ABM básico para tablas de Mysql incluye buscador con paginacion.
• Consola para generar archivos Excel a través de consultas MySQL.
• Configuración de php.ini no solo en la exportación, ahora puede realizarse de forma independiente.
• Menú de borrado de archivos en el directorio planillas, separado de la accion de envio.
• Importar a Excel desde MySQL con selección de los campos a importar.
• Vista previa para archivos que se encuentran en el servidor solo para los excel 2007.
• Actualización de la interfaz grafica de usuario y del logo.

Cualquier error que encuentren por favor si me lo pueden hacer llegar para ir mejorandolo..
Gracias

DEAME3P Versión 5.0.0 final

Los modificadores de acceso nos dan la posibilidad de poder establecer la visibilidad de los atributos y métodos de una clase, o de una manera mas sencilla es un forma de establecer los permisos que tendran otros objetos para acceder a los métodos y atributos de la clase.

Modificador public
Es el modificador de acceso por defecto es decir si no ponemos nada en el atributo o metodo este tomara el modificador public o sea que el método o atributo sera publico.

• public aplicado a un atributo o método: significa que es accesible por cualquier clase que los invoque desde una referencia a un objeto de la clase contenedora. Resumiendo se accede desde cualquier objeto haciendo referencia al objeto propietario.
• public no se puede aplicar a clases como por ejemplo en JAVA.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class modificadores
{	
	public	$mensajeUno;
	private	$mensajeDos;
 
	public function getMensajeUno()
	{
		echo $this->mensajeUno;
	}
 
	public function getMensajeDos()
	{
		echo $this->mensajeDos;
	}
}
$modificador	= new modificadores();
$modificador	->mensajeUno = 'Probando Modificadores';
$modificador	->getMensajeUno();
?>

En este caso como el atributo $mensajeUno es publico se puede acceder desde fuera de la clase, con tener una instancia en este caso $modificador lo podemos cambiar y tambien desplegar aunque en este caso usamos el metodo publico getMensajeUno.

Modificador private
Se puede aplicar tanto a atributos como métodos y es el nivel mas restrictivo de todos. Solo permite acceder desde el propio objeto, nunca desde fuera. Si nosotros intentáramos configurar el atributo mensajeDos como el Uno nos daría un error, para poder cambiar el texto tenemos que crear un método publico que realice la tarea.
Un ejemplo del método necesario seria:

1
2
3
4

public function setMensajeDos($texto)
	{
		$this->mensajeDos	= $texto;
	}

Ejemplo de como accederiamos es el siguiente:

$modificador	= new modificadores();
$modificador	->mensajeDos = 'Probando Modificadores'; 	// Error
$modificador	->setMensajeDos('Asi se debe realizar');	// Correcto
$modificador	->getMensajeDos();

Modificador protected
Es un nivel intermedio de accesibilidad. Si lo aplicamos a un atributo o método este sera accesible desde la propia clase y desde las clases que heredan de esta. Fuera de estas clases se comportan como si fueran atributos o metodos privados.

abstract

PHP 5 introduce las clases y métodos abstractos. Cuando una clase es abstracta no se permite crear una instancia de la misma. Si una clase contiene un metodo abstracto la misma debera ser declarada como abstracta. Los métodos definidos como abstractos no se implementan en dicha clase simplemente se declara la firma del mismo.

Cuando heredamos de una clase abstracta, todos los métodos definidos como abstractos en la clase padre, deben ser definidos en la clase hijo, teniendo en cuenta que la visibilidad de los mismos no puede ser menor a la definida en el metodo declarado como abstracto es decir no se puede restringir la visibilidad. A modo de ejemplo si un metodo es declarado como protected en la clase abstracta, cuando implementamos el mismo en la clase hija el mismo debera ser protected o public pero nunca podra ser private pues estariamos restringiendo la visibilidad.

Resumiendo:

• Aplicado a un metodo significa que no se implementa en la clase actual.
• Aplicado a una clase significa que no se puede instanciar.

final

• Aplicado a un atributo significa que es invariante (constante).
• Aplicado a un metodo significa que no se puede sobreescribir. Es decir la clase que hereda no puede volver a implementar el metodo.
• Aplicado a una clase significa que no se puede heredar.

static
La declaración de atributos de clase o métodos como estático los hace accesibles sin necesitar un instancia de la clase. No se puede tener acceso a una propiedad declarada como estática con una variable que es una instancia del objeto (aunque un método estático pueda) y no puede ser redefinido en una clase que herede de esta.

La declaracion de static tiene que estar despues de la declaracion de visibiliadad, para la compatibilidad con PHP 4, si no se declara la visibilidad del atributo o metodo definido como static, entonces PHP los tratara como si fuesen public (publicos).

Como los métodos estáticos son accesibles sin una instancia del objeto,lapseudovariable $this no está disponible dentro del método declarado como estático, para esto se debera usar self::.

Las propiedades estáticas no pueden ser accesadas a través del objeto usando el operador de flecha ->.

La llamada a métodos no estáticos desde un metodo estatico genera una advertencia de nivel E_STRICT.

Una variable estatica solo se puede inicializar usando un literal o una constante, no se permite que sea con expresiones . Usted puede inicializar una propiedad estatica a un entero(integer) o a un arreglo (array) como cualquier otra variable, pero no se puede inicializar a una variable, un retorno de una funcion o un objeto.

Si una variable se etiqueta como static, solo existira un ejemplar para todos los objetos de la clase.

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
class estatica
{	static 	$variable	= 3;
 
	public function getVariable()
	{	echo "<br />Static: " . self::$variable;	}
 
	public function setVariable($valor)
	{	self::$variable	= $valor;	}
}
// Creamos 2 instancias para ver que el valor es para
// todas las instancias.
$modificador1	= new estatica(); 
$modificador2	= new estatica();
// Formas de acceder al valor
echo "Ver Directamente:" . estatica::$variable;
$modificador1	->getVariable();
// Cambiamos el valor con el modificador1
// y mostramos el valor del 2.
$modificador1 	->setVariable(5);
$modificador2	->getVariable();
/* SALIDA POR PANTALLA
Ver Directamente:3
Static: 3	 # con modificador1
Static: 5	 # con modificador2
 */
?>

Fuente:

• Manual PHP
• Desarrollo Web

Deame3P. Rutina programada en PHP 5 que exporta datos contenidos en archivos Excel 2007 (Probado con versiones mayores a Excel 2003) a MySQL.
Las diferencias con otras soluciones de exportación son básicamente las siguientes:

• nos permite la vinculación o asociación de los campos de la base de datos MySQL con los nombres de las columnas del archivo Excel, no siendo necesario que sus nombres coincidan.
• Intenta la búsqueda de claves foráneas en la base de datos, para así proporcionarnos opciones de exportación, realizado para tablas tipo MISAM, por lo cual la clave foránea debe tener el mismo nombre que en la tabla donde es clave principal o única.
• Con los campos AUTOINCREMENT nos da la posibilidad de mantener los datos de la planilla Excel o que la base siga numerando sola.(Se aconseja esta ultima opción para no provocar errores por duplicación).
• Soporta dos modos INSERCION pura de datos o si una clave se Duplica se puede ACTUALIZAR esa línea.
• Contiene funciones basicas de formateo de campos entre ellos se encuentran varchar, text, Date, DateTime,TimeStamp, Time, Year(4), tinyint, smallint, mediumint, int, bigint, bool, boolean, bit, float,double, set y enum. Además de incluir un método por defecto para los campos no implementados.
• En el caso que administremos el servidor web permite la configuración de variables sensibles a la rutina como el consumo de memoria y el límite de tiempo máximo que puede ejecutarse.
• Nos permite codificar la entrada a UTF8 o dejarla como se encuentra en la planilla Excel.

Deame3p debe ser usado para tablas ya existentes, no crea tablas si no que inserta registros en ellas.
Debes tener activada la librería php_zip

Muchas Gracias.
Saludos el equipo de Programacion de Deame3p.-

Nota: Esta Rutina es de libre distribución, Úselos bajo su responsabilidad. No nos hacemos responsables por los daños que pueda causar, incluyendo perdida de información.
Descarga aquí deame3p versión 4

Constructor

Es un método especial de una clase , que es llamado siempre que se inicializa un objeto. Es decir cuando instanciamos una clase se ejecuta ese método automáticamente, se utiliza para cualquier inicialización que el objeto pueda necesitar antes de ser usado.
La sintaxis básica es: void __construct ( [mixed args [, ...]] ), dado que esta forma solo esta soportada a partir de PHP5, también se puede declarar un constructor usando el mismo nombre que la clase a la cual pertenece (Para otorgar compatibilidad con PHP4), es decir si al instanciar no encuentra el método __construct(), PHP buscara un método que se llame igual que la clase.

Si una clase que hereda (sub-clase o clase hija), tiene definido su propio constructor, entonces al crear el objeto de esta, solo se ejecutara el constructor propio de la clase hija y no el de la clase superior o padre. Si necesitamos que la clase padre ejecute su constructor entonces debemos realizar una llamada explicita al método padre de la siguiente manera parent::__construct().

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?php
class BaseClase
{
    function __construct()
    {
        print "Constructor de Clase Base<br />\n";
    }
}
 
class SubClase extends BaseClase
{
    function __construct()
    {
        parent::__construct();   // llamamos al constructor de la clase padre.
        print "Constructor en clase Hija<br />\n";
    }
}
 
$obj = new BaseClase();
// salida : Constructor de Clase Base
$obj = new SubClase();
// salida: Constructor de Clase Base
//          Constructor en clase Hija
?>

Destructor

PHP 5 introduce un concepto de destructor similar a aquellos de otros lenguajes de programación orientada a objetos, tal como C++. El método destructor será llamado tan pronto como todas las referencias a un objeto en particular sean removidas o cuando el objeto sea explícitamente destruido. En definitiva es otro método especial de una clase que se ejecuta antes de que un objeto de esa clase sea eliminado físicamente de la memoria. El destructor se utiliza para realizar las acciones finales, como borrar viejos archivos o liberar recursos.

Como sucede en los constructores, los destructores de la clase padre no serán llamados explícitamente por el compilador. Para ejecutar un destructor padre, se debe tener una llamada explícita a parent::__destruct() en el cuerpo del destructor.
El destructor es llamado durante la finalización del script, de tal manera que los headers ya han sido enviados.
Si se intenta arrojar una excepción desde un destructor produce un error fatal.

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php
class MyDestructableClass
{
    function __construct()
    {
        print "In constructor\n";
        $this->name = "MyDestructableClass";
   }
 
    function __destruct()
    {
        print "Destroying " . $this->name . "\n";
    }
}
 
$obj = new MyDestructableClass();
?>

Auto-Carga de Clases

Muchos desarrolladores que escriben aplicaciones con programación orientada a objetos crean un archivo fuente PHP por cada definición de clase. Una de las molestias más grandes es tener que escribir una larga lista de includes necesarios al principio de cada script (uno para cada clase).

En PHP 5, esto ya no es necesario. Puede definir una función __autoload la cual es llamada automáticamente en caso de que intente usar una clase que no ha sido definida aún. Al llamar esta función la ejecución del script da una última oportunidad de cargar la clase antes de que PHP falle con un error.

Las excepciones arrojadas en la función __autoload no pueden ser capturadas en el bloque catch y resultan en el despliegue de un error fatal.

52
53
54
55
56
57
58
59
60

<?php
function __autoload($nombreDeClase)
{
	require_once $nombreDeClase . '.php';
}
 
$obj  = new MyClass1();
$obj2 = new MyClass2();
?>

La pequeña rutina intenta levantar la clase MyClass1, al fallar y tener el método mágico __autoload, pasa el nombre de la clase a dicha función quien realiza el include para poder lograr la instancia.

La clase imagen soporta la edición de tres tipos de archivos de imagen, JPG, GIF y PNG, así como mantiene las transparencias en los últimos dos tipos.
Soporta 4 modos de recorte numerados del 0 al 3 que son los siguiente:

• Modo 0: Respeta la Proporcionalidad (Escala) de la imagen y toma como base de calculo el ancho.
• Modo 1: Respeta la Proporcionalidad de la imagen y toma como base de calculo el alto.
• Modo 2: Respeta el ancho y alto indicado, así como la proporcionalidad pero recortando la imagen (Se pueden perder porciones de imagen si las escalas de origen y destino difieren).
• Modo 3: Re-escala la imagen a el alto y ancho indicado, no manteniendo la proporcionalidad de la escala origen, pero si mantiene todo el contenido de la imagen (la imagen se puede deformar).

(Escala = ancho /alto)

Como se utiliza el Modo 2

En el modo 2 o recorte debemos configurar 3 variables, filas y columnas , lo que genera una cuadricula virtual y una tercer variable que se llama centrado que indica en el cuadrante que se deberá centrar la imagen para su recorte.

Ejemplo si elegimos filas = 3, columnas = 4 y centrado 11
Fila 1.[00][01][02][03]
Fila 2.[04][05][06][07]
Fila 3.[08][09][10][11]
La cuadricula seria la anterior y la clase intentara centrar la imagen recortada en el cuadrante 11 es decir recortaría manteniendo intacto el lado inferior derecho de la imagen.

La clase soporta dos tipos de pasajes de parámetros, uno a través de sentencias set y otra en el momento de la creación pasarle una estructura JSON.

Ejemplos de Uso:

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

	#################################################################################
	# EJEMPLO 1> PASAJE DE PARAMETROS POR METODOS SET								#
	#################################################################################
	$obj_img	= new Imagen();
	$obj_img	->set("imagenOrigen","cumpleanios 001.jpg");
	$obj_img	->set("imagenDestino",'cumpleanios 001_edit.jpg');
	$obj_img	->set("anchoDestino",'1000');
	$obj_img	->set("altoDestino",768);
	$obj_img	->set("recorte",array('filas'	=> 3, 'columnas'	=> 4, 'centrado'	=>	12));
	$obj_img	->set("calidadImagen",100);
	$obj_img	->set("generarArchivo",true);
	$obj_img	->set("modo",2);
	$obj_img	->procesarImagen();
	//Veo si todo salio bien o no
	if(!$obj_img->get("resultado"))
	{	echo "Archivo 1:".$obj_img->get("mensaje"); }			
	#################################################################################
	# EJEMPLO 2> PASAJE DE PARAMETROS POR JSON										#
	#################################################################################
	// Sin Variables
	$datos		= '{"imgOrigen"	: "cuboFrente.png",
 	 		 		"imgDestino": "cuboFrente_edit.png",
 	 		 		"ancho"		: "100",
 	 				"alto"		: "80",
 	 		 		"modo"		: 0,
 	 		 		"filas"		: 3,
 	 		 		"calidad"	: 95,
					"columnas"	: 4,
 	 		 		"centrado"	: 11,
 	 		 		"archivo"	: true,
  	 		 		"borrar"	: true
 	 			 }';
	$obj_img2	= new Imagen($datos);
	$obj_img2	->procesarImagen();
	//Veo si todo salio bien o no
	if(!$obj_img2->get("resultado"))
	{	echo "Archivo 2:".$obj_img2->get("mensaje"); }
 
	// Con  variables
	$fotoOri	= "logomsn.gif";
	$fotoDest	= "logomsn_edit.gif";
	$datos2		= '{"imgOrigen"	: "'.$fotoOri.'",
 	 		 		"imgDestino": "'.$fotoDest.'",
 	 		 		"ancho"		: 105,
 	 				"alto"		: 100,
 	 		 		"modo"		: 0,
 	 		 		"filas"		: 3,
 	 		 		"columnas"	: 4,
 	 		 		"centrado"	: 11,
 	 		 		"calidad"	: 95,
 	 		 		"archivo"	: true,
 	 		 		"borrar"	: false
 	 			 }';
	$obj_img3	= new Imagen($datos2);
	$obj_img3	->procesarImagen();
	//Veo si todo salio bien o no
	if(!$obj_img3->get("resultado"))
	{	echo "Archivo 3:".$obj_img3->get("mensaje"); }

Observaciones:
* Si se envía a crear una imagen de mayor tamaño a la original.
* El modo 0 simplemente regresa la imagen con el mismo tamaño.
* Modo 1 lo mismo del modo 0.
* Modo 2 trata de recortar el lado mas grande si ambos son menores. regresa la Misma imagen.
* Modo 3 re-escala la imagen a los atributos pasados

Imagen.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
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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653

<?php
/**
 * Responsable de Modificar imagenes en el servidor.
 * @author	Marcelo Castro 
 * @author 	objetivophp
 * @version 4.0.0 15/03/2009.-
 * @since 	Incopora ver propiedades 							
 * 			Chequeo de seguriadad en imagen.								
 * 			Soporte para png, gif y jpg.
 * 			Soporte de Trasparencias para formatos gif y png.					
 * 			Soporte para PHP 5 exclusivamente.-
 * @version 4.0.1 05/05/2009.- Correccion de error en servidores que no ponen .tmp a los archivos temporales.
 */
class Imagen
{	/**
 	* Ubicacion de la imagen de origen. (Se puede utilizar con $_FILES[])
 	* @var		String
 	* @access 	private
 	*/
	private $imagenOrigen;
 
	/**
	 * Ubicacion para la imagen una vez editada, es decir donde quedara la nueva imagen.
	 * @var 	String
	 * @access 	Private
	 */
	private $imagenDestino;
 
	/**
	 * Ancho en pixeles para la imagen destino.
	 * @var		Integer
	 * @access 	Private
	 */
	private $anchoDestino;
 
	/**
	 * Alto en pixeles para la imagen destino.
	 * @var 	Integer
	 * @access	Private
	 */
	private $altoDestino;
 
	/**
	 * Calcula el ancho en pixeles de la imagen de Origen.
	 * @var 	Integer
	 * @access 	Private
	 */
	private $anchoOrigen;
 
	/**
	 * Calcula el alto en pixeles de la imagen de Origen.
	 * @var		Integer
	 * @access 	Private
	 */
	private $altoOrigen;
 
	/**
	 * Especifica como respetara o no la proporcionalidad de la imagen. (Forma de Edicion).-
	 * @var 	Integer
	 * @access 	Private
	 * @since	Modos disponibles
	 * 	#0 para que respete la proporcionalidad de la imagen y tome como base el ancho
	 * 	#1 para que respete la proporcionalidad de la imagen y tome como base el alto
	 *  #2 para que respete el ancho y el alto recortando el resto de la imagen
	 *  #3 para respetar el ancho y alto indicando pero deformando la imagen
	 *  #El valor por defecto sera 0.
	 */
	private $modo				= 0;
 
	/**
	 * Se activa con el modo 2.
	 * La opcion cuadricula establece de cuanto sera la cuadricula para realizar el recorte y la propiedad
	 * centrado en que cuadrante se centrara para realizar el recorte.	
	 * @var		array
 	 * @since  Ejemplo en una cuadricula de 3x4
 	 * 	Fila 1.[00][01][02][03]
	 *  Fila 2.[04][05][06][07]
	 *  Fila 3.[08][09][10][11]
	 */
	private $recorte			= array('filas'	=> 3, 'columnas'	=> 3, 'centrado'	=>	4);
 
	/**
	 * Guarda si la imagen se realizo satisfactoriamento o no en el servidor.
	 * @var 	Boolean
	 * @access 	private
	 */
	private $resultado			= false;
 
	/**
	 * Guarda los mensajes de errores que se pudieron ocasionar.
	 * @var 	String
	 * @access 	private
	 */
	private $mensaje;
 
	/**
	 * Configura si se tiene que borrar o no la imagen de origen.
	 * @var		boolean
	 * @access 	private
	 */
	private $borrarOrigen		= false;
 
	/**
	 * Conserva los datos iniciales.
	 * @var 	object
	 * @access 	private
	 */
	private	$jsonArgumentos;
 
	/**
	 * Guarda las propiedades de la imagen extraidas mediante getimagesize.
	 * @access 	private
	 * @var		array
	 */
	private $propiedadesImagen;
 
	/**
	 * Calidad de la imagen destino.
	 * @access 	private
	 * @var		integer
	 */
	private	$calidadImagen		= 95;								
 
	/**
	 * Si la imagen es segura crea un puntero de imagen para utilizarlo para realizar las modificaciones.
	 * Es una imagen en Blanco.
	 * @access 	private
	 * @var 	object
	 */
	private $punteroImagen;
 
	/**
	 * Mantiene la extencion de la imagen.
	 * @access 	private
	 * @var 	string
	 */
	private $extencion;
 
	/**
	 * Configura si se generara un archivo (true) o se volcara por pantalla el resulatado.
	 * Nota:  si se vuelca por pantalla se tiene que tener la precaucion de no haber enviado 
	 * ningun cabezal antes.
	 * @access 	private
	 * @var 	boolean
	 */
	private $generarArchivo		= true;
 
	/**
	 * Marca si la imagen se editara desde el archivo temporal creado
	 * al realizar la subida de la imagen
	 * @access 	private
	 * @var 	boolean
	 */
	private $archivoTmp			= false;
	#########################################################################	
	# VARIABLES DE CONTROL													#
	#########################################################################
	/**
	 * Contiene las variables que no se podran setear por medio del metodo magico __set().
	 * @access 	private
	 * @var		array
	 */
	private $noPermitirSetVar	= array('anchoOrigen','altoOrigen','punteroImagen','extencion','resultado','mensaje','jsonArgumentos','propiedadesImagen','noPermitirSetVar','noPermitirGetVar','imageCreateFrom','msjError','tiposImagenes');
 
	/**
	 * Contiene las variables que no se podran ver por medio de el metodo magico __get().
	 * @access 	private
	 * @var 	array
	 */
	private $noPermitirGetVar	= array('punteroImagen','jsonArgumentos','propiedadesImagen','noPermitirSetVar','noPermitirGetVar','imageCreateFrom','tiposImagenes');
 
	/**
	 * Tiene los tipos de archivos de imagen permitidos y la funcion que crea la imagen editada.
	 * @access 	private
	 * @var 	array
	 */
	private $imageCreateFrom	= array(
									"JPG"	=> "jpeg", 
									"GIF"	=> "gif",
									"PNG"	=> "png"
									);
 
	/**
	 * Contiene los tipos de errores que se pueden ocasionar.
	 * @access 	private
	 * @var		array
	 */
	private static $msjError	= array(
									"ERR_File"		=> "No existe el archivo a modificar",
									"ERR_Param"		=> "No se pudieron resolver todos los parametros.",
									"ERR_Params"	=> "Ningun parametro pudo ser resuelto.<br />Verifique que sea una imagen.",
									"ERR_Exten"		=> "El tipo de archivo y su contenido no coinciden",
									"ERR_Taman"		=> "El archivo no contiene informacion que procesar",
									"ERR_ImgNP"		=> "Tipo de imagen no permitida.",
									"ERR_ImgNC"		=> "No se puede crear una imagen tomando como origen su imagen",
									"ERR_ImgNS"		=> "La imagen no a sido verificada como segura, por favor primero utilize el metodo esImagenSegura()",
									"ERR_FIOri"		=> "No se ha configurado cual sera la imagen de origen",
									"ERR_FIDes"		=> "No se ha configurado cual sera el destino de la imagen",
									"ERR_Modo2"		=> "No se encontraron los parametros para el modo 2."
									);
 
 
	private $tiposImagenes		= array(
        							1 	=> 'GIF',
        							2	=> 'JPG',
        							3 	=> 'PNG',
        							4 	=> 'SWF',
        							5 	=> 'PSD',
        							6 	=> 'BMP',
        							7 	=> 'TIFF_II',
        							8	=> 'TIFF_MM',
        							9 	=> 'JPC',
        							10 	=> 'JP2',
        							11 	=> 'JPX',
        							12 	=> 'JB2',
        							13 	=> 'SWC',
        							14 	=> 'IFF',
        							15 	=> 'WBMP',
        							16 	=> 'XBM',
    								17	=> 'ICO');
	#########################################################################	
	# METODOS PUBLICOS														#
	#########################################################################
    /**
	 * Metodo constructor.
	 * Se le pueden pasar los argumentos que deberian venir en formato JSON o
	 * tambien se pueden definir despues con los metodos SET correspondientes.
	 * FORMATO DE DATOS:
	 * '{ 	"imgOrigen"	: "direccion de origen",
 	 * 		"imgDestino": "direccion de destino",
 	 * 		"ancho"		: "ancho destino en piixeles",
 	 *		"alto"		: "alto destino",
 	 * 		"modo"		: 0,
 	 * 		"filas"		: 0,
 	 * 		"columnas"	: 0,
 	 * 		"centrado"	: 0,
 	 * 		"borrar"	: false,
 	 * 		"calidad"	: 95
 	 * }'
	 * Se pueden poner los parametros que se dese y complementarlos despues. 
	 *
	 * @param	String	$argumentos	cadena tipo JSON
	 */
	public function __construct($argumentos='')
	{	// No quiero que me largue errores si suceden.							
		//error_reporting(0);
		set_time_limit(0);
		$this->jsonArgumentos	= json_decode(stripslashes($argumentos));
		if(is_object($this->jsonArgumentos))
		{	// Transfiero los datos JSON a las variables Correspondientes
			// Propiedades no configuradas por defecto
			$this->imagenOrigen			= $this->jsonArgumentos->imgOrigen;
			$this->imagenDestino		= $this->jsonArgumentos->imgDestino;
			$this->anchoDestino			= (int)($this->jsonArgumentos->ancho);
			$this->altoDestino			= (int)($this->jsonArgumentos->alto);
			$this->modo					= (int)($this->jsonArgumentos->modo);
			$this->generarArchivo		= $this->jsonArgumentos->archivo;
			// Propiedades configuradas por defecto
			empty($this->jsonArgumentos->calidad)	?false:$this->calidadImagen			= (int)($this->jsonArgumentos->calidad);
			empty($this->jsonArgumentos->filas)		?false:$this->recorte["filas"]		= (int)($this->jsonArgumentos->filas);	
			empty($this->jsonArgumentos->columnas)	?false:$this->recorte["columnas"]	= (int)($this->jsonArgumentos->columnas);
			empty($this->jsonArgumentos->centrado)	?false:$this->recorte["centrado"]	= (int)($this->jsonArgumentos->centrado);
			empty($this->jsonArgumentos->borrar)	?false:$this->borrarOrigen			= $this->jsonArgumentos->borrar;
			empty($this->jsonArgumentos->archivoTmp)?false:$this->archivoTmp			= $this->jsonArgumentos->archivoTmp;
 
		}
	}
 
	/**
	 * Se encarga de validar los parametros y generar una imagen para ser utilizada posteriormente.
	 * @access 	public
	 * @var 	string	$imagen	Contiene la ruta y nombre de archivo de la imagen de origen.
	 * @return 	boolean	true si se pudo generar imagen, false si no.
	 */
	public function cargarImagen($imagen)
	{	try
		{	$propiedadImagen	= getimagesize($imagen);
			if(!$propiedadImagen)	
			{	throw new Exception(Imagen::$msjError["ERR_File"]);	}
 
			// Si Existe el Archivo Largo el codigo de Verificacion
			$extencion			= $this->extraerExtencion($imagen);
			$tamanio			= filesize($imagen);
 
			// Veerifico que todos los parametros tengan algo.
			if(is_array($propiedadImagen))
			{	$this->propiedadesImagen	= $propiedadImagen;
				foreach ($propiedadImagen as $valor)
				{	if(!$valor)
					{	throw new Exception(Imagen::$msjError["ERR_Param"]);	}
				}
			}
			else
			{	throw new Exception(Imagen::$msjError["ERR_Params"]);	}
			// Verifico que si el modo es 2 existan datos para ello
			if($this->modo==2)
			{	if($this->recorte['filas']<1 || $this->recorte['columnas']<1)
				{	throw new Exception(Imagen::$msjError["ERR_Modo2"]);	}
			} 
 
			if($this->archivoTmp)
			{	$extencion	= $this->tiposImagenes[$propiedadImagen[2]];	}
			// Verifico que coincidan las extenciones fisicas y del tipo mime
			if($extencion!=$this->tiposImagenes[$propiedadImagen[2]])
			{	throw new Exception(Imagen::$msjError["ERR_Exten"]);	}
 
			$this->extencion	= $extencion;
 
			if(!$tamanio)
			{	throw new Exception(Imagen::$msjError["ERR_Taman"]);	}
 
			// Veo que sea un tipo permitido y que sea efectivamente de ese tipo.
			if(!array_key_exists($extencion,$this->imageCreateFrom))
			{	throw new Exception(Imagen::$msjError["ERR_ImgNP"]);	}
 
			switch ($extencion)
			{	case 	"JPG":
						$img = imagecreatefromjpeg($imagen);
						break;
				case 	"PNG": // Mantener Transparencias en PNG
						$img = imagecreatefrompng($imagen); 
						imagealphablending($img, true); // setting alpha blending on
						imagesavealpha($img, true); // save alphablending setting (important)
						break;
				case 	"GIF": // Mantener Transparencias en GIF		
						$img = imagecreatefromgif($imagen); 
						break;
			}
			if(!img)
			{	throw new Exception(Imagen::$msjError["ERR_ImgNC"]);	}
			$this->punteroImagen	= $img;
		}
		catch (Exception $e)
		{	$this->mensaje	= $e->getMessage();
			return false;
		}
		return true;
	}
 
	/**
	 * Muestra las propiedades de una imagen.
	 * @access 	public
	 * @return	void
	 */
	public function verPropiedades()
	{	if(!$this->punteroImagen)
		{	$this->mensaje	= Imagen::$msjError["ERR_ImgNS"];
			return false;
		}
 
		$propiedadesEtq		= array(	0			=> 'ancho:',
										1 			=> 'alto:',
										2			=> 'tipo:',
										3 			=> 'etiquetas img:',
										'bits'		=> 'Profundidad del color (bits):',
										'channels'	=> 'Canales:',
										'mime'		=> 'Tipo Mime:'
										);
		foreach ($this->propiedadesImagen as $clave => $valor)
		{	echo $propiedadesEtq[$clave]."  ".$valor."<br />"; 	}
		return true;
	}
 
	public function procesarImagen()
	{	if(!$this->punteroImagen)
		{	$estado	= $this->cargarImagen($this->imagenOrigen);
			if(!$estado)
			{	$this->__destruct();
				return ;
			}
		}
		// Controlo que los datos sean suficientes
		if($this->datosSuficientes())
		{	$this->__destruct();
			return ;
		}
 
		/**
		 * Nota:
		 * propiedadesImagen[0]	equivale a $anchoOrigen
		 * propiedadesImagen[1]	equivale a $altoOrigen 
		 */
		switch ($this->modo)
		{	case	0:	// Respeta Proporcionalidad y toma como base el ancho.
 
					if($this->propiedadesImagen[0]<$this->anchoDestino) { $this->anchoDestino = $this->propiedadesImagen[0]; }
					$coeficiente	= $this->propiedadesImagen[0] / $this->anchoDestino;
					$anchoFinal 	= ceil($this->propiedadesImagen[0] / $coeficiente);
					$altoFinal 		= ceil($this->propiedadesImagen[1] / $coeficiente);
					$this->crearImagenSinRecorte($anchoFinal,$altoFinal);	
					break;
 
			case	1:	// Respeta Proporcionalidad y toma como base el alto.
					if($this->propiedadesImagen[1]<$this->altoDestino) { $this->altoDestino = $this->propiedadesImagen[1]; }
					$coeficiente	= $this->propiedadesImagen[1] / $this->altoDestino;
					$anchoFinal 	= ceil($this->propiedadesImagen[0] / $coeficiente);
					$altoFinal 		= ceil($this->propiedadesImagen[1] / $coeficiente);
					$this->crearImagenSinRecorte($anchoFinal,$altoFinal);				
					break;
 
			case	2:	// Respeta ancho y alto recortando el resto.
					if($this->anchoDestino>$this->propiedadesImagen[0])
					{	$this->anchoDestino	= $this->propiedadesImagen[0];	}
					if($this->altoDestino>$this->propiedadesImagen[1])
					{	$this->altoDestino	= $this->propiedadesImagen[1];	}
					$this->recortarImagen();
					break;
			case 	3:	// Respeta ancho y alto pero deforma la imagen.
					$this->crearImagenSinRecorte($this->anchoDestino,$this->altoDestino);
					break;
		}
	}
 
	/**
	 * Destructor.
	 * @access 	public
	 * @since 	intenta borrar el archivo de origen si se le ha pedido.
	 */
	public function __destruct()
	{	if($this->borrarOrigen)
		{	if(is_file($this->imagenOrigen))
			{	if(is_writable($this->imagenOrigen))
				{	unlink($this->imagenOrigen);	}
			}
		}
	}
 
	#########################################################################	
	# METODOS GET Y SET 													#
	#########################################################################
	
	/**
	 * Metodo Magico get.
	 * Retorna el valor que tiene un atributo de la clase.
	 * @access 	public
	 * @param 	string		$propiedad	Nombre de la propiedad o Atributo que se quiere saber su valor.
	 * @return	mixed		false si no existe o el valor del atributo.
	 */
	public function get($propiedad)
	{	if(in_array($propiedad,$this->noPermitirGetVar))
		{	return 	false;	}
 
		if(!property_exists(__CLASS__,$propiedad))
		{	return false;	}
		else 
		{	return $this->$propiedad;	 }
	}
 
	/**
	 * Metodo Magico set.
	 * Modifica los valores a los atributos de clase.
	 * @access 	public
	 * @var 	String		$propiedad	Nombre de la Porpiedad o Atributo que se le cambiara su valor.
	 * @var 	mixed		$valor		Valor que se le dara a la propiedad.
	 * @var 	boolean		
	 */
	public function set($propiedad,$valor)
	{	if(in_array($propiedad,$this->noPermitirSetVar))
		{	return 	false;	}
		if(property_exists(__CLASS__,$propiedad))
		{	$this->$propiedad	= $valor;
			return true;
		}
		else 
		{	echo "El Atributo ".$propiedad." no existe.";
			return false;
		}
	}
 
	#########################################################################	
	# METODOS PRIVADOS														#
	#########################################################################
	
	/**
	 * Corrobora que tenga los datos minimos para ejecutar la rutina.
	 * En caso de no ser escenciales, los regresa al modo por defecto si no existen.
	 * @access 	private
	 * @return 	boolean		false (No se creara la imagen), true (Se puede crear la imagen)
	 */
	private function datosSuficientes()
	{	// Comprobamos el Origen y Destino de la imagen que existan
		// Con estos dos parametros solo ya funcionaria.
		if(!$this->imagenOrigen)
		{	$this->mensaje	= Imagen::$msjError["ERR_Ori"];
			return false;
		}
		if($this->imagenDestino)
		{	$this->mensaje	= Imagen::$msjError["ERR_Des"];
			return false;
		}
		// Veo los parametros por defecto
		if(!$this->anchoDestino)
		{	$this->anchoDestino	= $this->propiedadesImagen[0];	}
		if(!$this->altoDestino)
		{	$this->altoDestino	= $this->propiedadesImagen[1];	}
		// Controles de Modo
		if($this->modo==2)
		{	if( (int)($this->recorte["filas"])<1 || (int)($this->recorte["columnas"])<1   )
			{	$this->recorte			= array('filas'	=> 3, 'columnas'	=> 3, 'centrado'	=>	4);	}
			else
			{	$opcionesRecorte		= $this->recorte["filas"]*$this->recorte["columnas"]-1;
				if($this->recorte["centrado"]>$opcionesRecorte)
				{	$this->recorte["centrado"]	= $opcionesRecorte;	}
			}	
		}
		return true;
	}
 
	/**
	 * Extrae la extencion que trae el archivo basandose en su nombre solamente.
	 * @access 	private
	 * @param	string		$archivo	Ruta hacia el archivo de imagen.
	 * @return	string		Contiene la extencion del archivo en Mayusculas.
	 */
	private function extraerExtencion($archivo)
	{	$puntero	= strripos($archivo,".");
		$extencion	= strtoupper(substr($archivo,$puntero+1));
 
		return $extencion;
	}
 
	/**
	 * Metodo CrearImagenSinRecorte.
	 * Es un sub-metodo que termina creando la imagen de Destino.
	 * @access 	private
	 * @param 	int 		$anchoFinal es el ancho final de la imagen destino. Si modo es 0 coincide con el propuesto , si no podria variar.
	 * @param 	int 		$altoFinal es el alto final de la imagen destino. Si modo es 1 coincide con el propuesto , si no podria variar.
	 * @return	Archivo		Es una imagen que se almacena en la direccion establecida.
	 */
	private function crearImagenSinRecorte($anchoFinal,$altoFinal)
	{	switch ($this->extencion)
		{	case 	"JPG":
					$ImgMediana 	= imagecreatetruecolor($anchoFinal,$altoFinal);
					break;
			case	"GIF":
					$ImgMediana 		= imagecreatetruecolor($anchoFinal,$altoFinal);
					$colorTransparente 	= array('red' => 0, 'green' => 0, 'blue' => 0);
		           	$indiceTransparencia= imagecolorallocate($ImgMediana, $colorTransparente['red'], $colorTransparente['green'], $colorTransparente['blue']);
            		imagefill($ImgMediana, 0, 0, $indiceTransparencia);
             		imagecolortransparent($ImgMediana, $indiceTransparencia);
					break;
			case	"PNG":
					// Definimos propiedades de Fondo
					$fondo 				= array('red'	=> 0, 'green' => 0, 'blue'=> 0,'alfa'=>127);
					$ImgMediana 		= imagecreatetruecolor($anchoFinal,$altoFinal);
					//modo sobreescritura de pixeles anteriores activado
					imagealphablending($ImgMediana ,false);
					//color con canal alfa
					$fondo = imagecolorallocatealpha($ImgMediana , $fondo['red'], $fondo['green'], $fondo['blue'], $fondo['alfa']);
					//rellenamos (sustituimos) toda la imagen con este color
					//imagefilledrectangle ( $ImgMediana  , 0 , 0 , $anchoFinal , $altoFinal , $fondo );
					imagefill($ImgMediana,0,0,$fondo);
					//modo sobreescritura de pixeles anteriores desactivado
					imagealphablending($ImgMediana ,true);
					//salida conservando el canal alfa
					imagesavealpha($ImgMediana ,true);
					break;
		}
		// Creamos el Recorte para cualquier tipo de Imagen
		imagecopyresampled($ImgMediana,$this->punteroImagen,0,0,0,0,$anchoFinal,$altoFinal,$this->propiedadesImagen[0],$this->propiedadesImagen[1]);
		$this->crearArchivoDeImagen($ImgMediana);
		imagedestroy($ImgMediana);
	}
 
	/**
	 * Genera la Salida de la Imagen a un archivo, en el directorio especificado.
	 * @access 	private
	 * @var 	resource	$imgTrueColor	Es una referencia a una imagen creada con la funcion imagecreatetruecolor().
	 * @var 	String		$imgDestino		Nombre del archivo a generar. Si no se pasa se asume que es el de Imagen Destino.
	 * @return 	imagen		Archivo de Imagen
	 */
	private function crearArchivoDeImagen($imgTrueColor,$imgDestino='')
	{	if(empty($imgDestino))
		{	$imgDestino	= $this->imagenDestino;	}
		if($this->generarArchivo==false)
		{	$imgDestino	= "";
			header("Content-type: image.jpg");
		}
 
		if($this->calidadImagen<10) {	$this->calidadImagen = 10;	}
		switch ($this->extencion)
		{	case "JPG":	// Crea una imgen jpg
						$imgOk	= imagejpeg($imgTrueColor,$imgDestino,$this->calidadImagen);
						break;
			case "PNG":	// Crea una imagen png
						($this->calidadImagen>99)? $comprension = 9:$comprension	= floor($this->calidadImagen/10);
						$imgOk	= imagepng($imgTrueColor,$imgDestino,$comprension);
						break;
			case "GIF": // Crea una imagen gif
						$imgOk	= imagegif($imgTrueColor,$imgDestino);		
						break;
		}
 
		if($imgOk)
		{	$this->resultado	= true;
			return true;
		}
		return false;
	}
 
	/**
	 * Metodo RecortarImagen.
	 * Se encarga de Recortar la imagen de origen y llevarla exactamente a los valores de destino.
	 * Trata de perder la porcion minima de imagen posible.
	 */	
	private function recortarImagen()
	{
		$ImgTemporal="temporal_clase_Imagen.".strtolower($this->extencion);
 
		$CoefAncho		= $this->propiedadesImagen[0]/$this->anchoDestino;
		$CoefAlto		= $this->propiedadesImagen[1]/$this->altoDestino;
		$Coeficiente=0;
		if ($CoefAncho>1 && $CoefAlto>1)
		{	if($CoefAncho>$CoefAlto)	
			{ $Coeficiente=$CoefAlto; }
			else
			{$Coeficiente=$CoefAncho;}
		}
		else
		{	$Coeficiente = $CoefAncho; 	}
 
		if ($Coeficiente!=0)
		{	$anchoTmp	= ceil($this->propiedadesImagen[0]/$Coeficiente);
			$altoTmp	= ceil($this->propiedadesImagen[1]/$Coeficiente);
 
			$ImgMediana = imagecreatetruecolor($anchoTmp,$altoTmp);
			imagecopyresampled($ImgMediana,$this->punteroImagen,0,0,0,0,$anchoTmp,$altoTmp,$this->propiedadesImagen[0],$this->propiedadesImagen[1]);
			$this->crearArchivoDeImagen($ImgMediana,$ImgTemporal);
		}
 
		$fila			= floor($this->recorte['centrado']/$this->recorte['columnas']);
		$columna		= $this->recorte['centrado'] - ($fila*$this->recorte["columnas"]);
 
		$centroX 	= floor(($anchoTmp / $this->recorte["columnas"])/2)+$columna*floor($anchoTmp / $this->recorte["columnas"]);
		$centroY 	= floor(($altoTmp / $this->recorte["filas"])/2)+$fila*floor($altoTmp / $this->recorte["filas"]);
 
		$centroX	-= floor($this->anchoDestino/2);
		$centroY 	-= floor($this->altoDestino/2);
 
		if ($centroX<0) {$centroX = 0;}
		if ($centroY<0) {$centroY = 0;}
 
		if (($centroX+$this->anchoDestino)>$anchoTmp) {$centroX = $anchoTmp-$this->anchoDestino;}
		if (($centroY+$this->altoDestino)>$altoTmp) {$centroY = $altoTmp-$this->altoDestino;}
 
		$ImgRecortada = imagecreatetruecolor($this->anchoDestino,$this->altoDestino);
		imagecopymerge ( $ImgRecortada,$ImgMediana,0,0,$centroX, $centroY, $this->anchoDestino, $this->altoDestino,$this->calidadImagen);
 
		$this->crearArchivoDeImagen($ImgRecortada,$this->imagenDestino);
		imagedestroy($ImgRecortada);
		unlink($ImgTemporal);
	}
}

Descarga el ejemplo y la clase desde aqui

Sobrecarga de Metodos

La interpretacion de PHP para la sobrecarga de métodos, es diferente a la mayoria de los lenguajes orientados a objetos. La sobrecarga tradicional proporciona la capacidad de tener multiples métodos con el mismo nombre, pero con diferente número y/o tipo de parámetros (a esto se le llama firma del metodo), dependiendo de ellos se ejecutará una función u otra.

En JAVA la sobrecarga seria así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Pruebas
{
    public void Pruebas()
   {
        System.out.println("Hola Pruebas");
    }
 
    public void Pruebas(String name)
    {
        System.out.println("Hola " + name);
    }
 
    public void Pruebas(String firstName, String lastName)
    {
        System.out.println("Hola " + firstName + " " + lastName);
    }
}

En este caso declaramos 3 constructores (Metodos que inicializan el objeto pruebas), que reciben diferente cantidad de parametros. De esta forma segun el numero de parametros que pasemos se ejecuta uno u otro metodo.
Como logramos esto en PHP, si no soporta la sobrecarga de metodos en esa forma. Para ello se recurre a un metodo magico que es el método __call().

Metodo __call()

Se trata de un método “mágico” que permite capturar la invocación de métodos no existentes. Esté método puede ser redefinido para cubrir las necesidades del proyecto o como en este caso, proporcionar sobrecarga a nuestros scripts. Aprovechando está funcionalidad podemos controlar la función a la que estamos llamando y redirigir a la función concreta a la que hacemos referencia.

1
2
3
4
5

mixed __call ( string $nombre, array $argumentos );
/** La función _call() recibe dos parámetros:
 * $nombre -> El nombre del método
 * $argumentos -> Los argumentos pasados a la función.
*/

Una forma de implementarlo con este metodo es la siguiente…

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
class SobreCarga
{	
	public function __call($metodo, $parametros)
	{	if (method_exists($this, $metodo.sizeof($parametros))) return call_user_func_array(array($this, $metodo.sizeof($parametros)), $parametros);
                // Si la Funcion no Existe
                throw new Exception('Metodo Desconocido: '.get_class($this).'::'.$metodo);
        }
 
        function Param2($a, $b) {
                echo "<br />Param2($a,$b)\n";
        }
 
        function Param3($a, $b, $c) {
                echo "<br />Param3($a,$b,$c)\n";
        }
}
 
$o = new SobreCarga();
$o->Param(4,5);
$o->Param(4,5,6);
$o->ParamX(4,5,6,7);
?>
// La salida de este script seria:
Param2(4,5)
Param3(4,5,6)
Fatal error: Uncaught exception 'Exception' with message 'Metodo Desconocido: SobreCarga::ParamX' in C:\AppServ\www\clasesPHP\sobrecarga.php:7 Stack trace: #0 [internal function]: SobreCarga->__call('ParamX', Array) #1 C:\AppServ\www\clasesPHP\sobrecarga.php(22): SobreCarga->ParamX(4, 5, 6, 7) #2 {main} thrown in C:\AppServ\www\clasesPHP\sobrecarga.php on line 7

la funcion method_exists() comprueba que el metodo de clase existe y requiere 2 parametros un objeto donde se buscara el método y el nombre del método a buscar. La misma retorna un booleano, true si existe el metodo en la clase o false en caso contrario.
bool method_exists ( object object, nombreDeMetodo )
Es lo que hace la consulta de la linea 7. En caso de ser verdadera es decir existe el método utiliza la funcion call_user_func_array () que lo que realiza es Llamar una función definida por el usuario dada por funcion, con los parámetros establecidos.
mixed call_user_func_array ( callback funcion, array matriz_parametros );
callback funcion contiene una estructura de array donde debera constar el objeto y el metodo a llamar por ejemplo array(’MiClase’, ‘miMetodoDeRetorno’). Por lo cual la llamada de tipo array($this, $metodo.sizeof($parametros)) le indica que retorne de esta misma clase($this) el metodo que se llama $metodo.sizeof($parametros) donde sizeof es el numero de parametros pasados.

Como se puede ver no existe en PHP la sobrecarga tradicional, pero se puede llegar a simular con un poco de trabajo.
Fuente: Anieto, php.net

Sobre-Escritura de Métodos

Es un mecanismo por el cual una clase que hereda puede redefinir los métodos que está heredando. Es decir que podemos crear un método con el mismo nombre que el método de la clase padre. Ahora cuando creamos un objeto de la subclase, el método que se llamará es el de dicha subclase.
Lo más conveniente es sobreescribir métodos para completar el algoritmo del método de la clase padre. No es bueno sobreescribir un método y cambiar completamente su comportamiento.
Un ejemplo sencillo.

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 
class Saludo
{	public function saludar()
	{	
		echo '<br />Hola';
	}
 
	public function despedida()
	{	
		echo '<br />Chau';
	}
}
 
class BuenosDias extends Saludo
{
	public function saludar()
	{
		echo '<br />Buenos Dias';
	}
}
$instancia	= new BuenosDias();
$instancia->saludar();
$instancia->despedida();
// El resultado seria:
Buenos Dias 
Chau
?>

En el resultado se ve claro que ejecuta el metodo de la clase hija.
la palabra extends indica que hereda los metodos y propiedades de la clase padre Saludo.

Los Entornos de Desarrollo Integrado o IDE (Integrated Development Environment ), es un programa compuesto por un conjunto de herramientas para un programador. Puede dedicarse a un solo lenguaje de programacion o a varios de ellos. Los componentes mas comunes de los IDE’s son editor de texto (o codigo), compilador, interprete, herramientas de Automatizacion, depurador, controlador de versiones y ofrecen facilidades para el desarrollo de la interfaz grafica de Usuario.

IDE’s para PHP

• Zend Studio (de pago): Es quizas uno de los mejores IDE para PHP, es un programa de la casa Zend, orientado al desarrollo de aplicaciones web basado en Eclipse.
  - Ofrece soporte para PHP 5.3
  - Integracion con Zend FrameWorks
  - Integracion con Zend Server
  - Caracteristicas Abanzadas de Edicion de codigo: Resaltado de sintaxis, autocompletado de código, ayuda de código y lista de parámetros de funciones y métodos de clase, inserción automática de paréntesis y corchetes de cierre, sangrado automático, emparejamiento de paréntesis y corchetes (si se sitúa el cursor sobre un paréntesis (corchete) de apertura (cierre), Zend Studio localiza el correspondiente paréntesis (corchete) de cierre (apertura))..
  - Generador de documentacion integrado (phpDoc)
  - Detección de errores de sintaxis en tiempo real.
  - Generador de Getters y Setters.
  - Caracteristicas de Refactorizacion.
  - Funciones de Depuracion (Debuger): Botón de ejecución y traza, marcadores, puntos de parada (breakpoints), seguimiento de variables y mensajes de error del intérprete de PHP. Permite también la depuración en servidores remotos (requiere Zend Platform).
  - Barra de herramientas para Internet Explorer y FireFox.
  - Manual de PHP integrado
  - Soporte para control de versiones usando CVS o Subversion.
  - Cliente FTP integrado.
  - Soporte para navegación en bases de datos y ejecución de consultas SQL.
  - Soporte basico para otros lenguajes web como HTML, Javascript y XML.
  - Dispone de vista WYSIWYG, What You See Is What You Get (en inglés, “lo que ves es lo que obtienes”)

• PDT 2.1: (gratis) PHP Develoment tools Project. Tambien basado en eclipse y se dice que el dia que sea tan bueno como Zend Studio, se discontinuara este ultimo y quedara PDT.
  El programa no necesita instalación: hay que descomprimir el archivo zip en una carpeta y ejecutar el programa eclipse.exe. Es un programa Java, por lo que se necesita tener instalado Java Runtime Environment 1.5 (o posterior).
  - Existe una version disponible en el sitio comunitario de Zend con el Zend Debuger.
  - Totalmente compatible con las noramas de Eclipse.
  - Nuevo mecanismo de indexacion y almacenamiento en cache para mejorar el rendimiento y experiencia en la edicion de codigo y ayudar la navegacion.
  - Caracteristicas mejoradas con respecto a la programacion orientada a objetos con respecto a la herencia y polimorfismo, permitiendo una mejor navegacion sobre los objetos.
  - Marcas de referencia, permite ver cuantas veces se referencia un elemento simplemete cliqueando sobre el.
  - Indicador de sobreescritura de metodos. son marcadores iconos que se muestran cuando se esta sobreescribiendo o implementando un metodo de una clase padre.
  - Navegacion por jerarquias
  - Ayudas de codigo mejoradas.

Komodo
Aptana
NetBeans
Eclipse
NotePad++
UltraEdit

En desarrollo ….

Primero aclarar que la Programación Orientada a Objetos (POO), no es un lenguaje de programación sino que es un paradigma. Un paradigma según la WIKI, representa un enfoque particular o filosofía para la construcción del software. La POO se puede aplicar a casi todos los lenguajes modernos.
Podemos distinguir entre lenguajes Puros e híbridos. Puros cuando se ajusta 100% a los principios que la técnica propone y contempla la posibilidad de trabajar exclusivamente con clases. Híbrido, cuando el lenguaje que generalmente existía antes de la aparición de la POO, incorpora características para trabajar con clases.

Conceptos Básicos

Los principales conceptos que se vinculan con la POO son Clase, Objeto, Método, Instancia,  Evento, Mensaje, Propiedad o Atributo, Estado Interno.

Clases: son declaraciones o abstracciones de objetos, lo que significa, que una clase es la definición de un objeto. Cuando se programa un objeto y se definen sus características y funcionalidades, realmente se programa una clase.
Las clases contienen datos (variables, propiedades miembro o atributos) junto con las operaciones de manipulación de esos datos (funciones o Métodos).
Ejemplo de clase en PHP:

class Nombre {
    // Variables miembro (habitualmente privadas)
    private miembro_1; //lista de miembros
    public miembro_2;
    protected miembro_3; 
 
    // Funciones o métodos (habitualmente públicas)
    public function miembro_1( );
    public function miembro_2 ( );
}

Objetos: se define como la unidad que en tiempo de ejecución realiza las tareas de un programa. También a un nivel más básico se define como la instancia  de una clase. Estos objetos interactúan unos con otros, en contraposición a la visión tradicional en la cual un programa es una colección de subrutinas (funciones o procedimientos), o simplemente una lista de instrucciones para el computador. Cada objeto es capaz de recibir mensajes, procesar datos y enviar mensajes a otros objetos de manera similar a un servicio. En el mundo de la programación orientada a objetos (POO), un objeto es el resultado de la instanciación de una clase. Una clase es el anteproyecto que ofrece la funcionalidad en ella definida, pero ésta queda implementada sólo al crear una instancia de la clase, en la forma de un objeto.

Método: es una subrutina asociada exclusivamente a una clase. Un método consiste generalmente de una serie de sentencias para llevar a cabo una acción, un juego de parámetros de entrada que regularán dicha acción y, posiblemente, un valor de salida (o valor de retorno) de algún tipo. Existen 2 tipos de métodos los de instancia, que están relacionados con un objeto en particular y los estáticos   o de clase (o compartidos) están asociados a una clase en particular.
En ciertos lenguajes de programación  se requiere de un metodo especial que son los constructores siendo estos métodos de instancia especiales llamados automáticamente cuando se crea una instancia de alguna clase.

Instancia: se produce con la creación de un objeto perteneciente a una clase (instanciar una clase), que hereda entonces sus atributos, propiedades y métodos para ser usados dentro de un programa, ya sea como contenedores de datos o como partes funcionales del programa al contener en su interior funcionalidades de tratamiento de datos y procesamiento de la información que ha sido programada con anterioridad en la clase a la que pertenece. Ejemplo de instancia en php:

$instancia = new Nombre(); // instanciamos la clase del ejemplo anterior.
$instancia->miembro_1(); // accedemos a un método.

Evento: un suceso en el sistema (tal como una interacción del usuario con la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje adecuado al objeto pertinente. También se puede definir como evento, a la reacción que puede desencadenar un objeto, es decir la acción que genera.

Mensaje: una comunicación dirigida a un objeto, que le ordena que ejecute uno de sus métodos con ciertos parámetros asociados al evento que lo generó.

Propiedad o atributo: contenedor de un tipo de datos asociados a un objeto (o a una clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define como sus características predeterminadas, y cuyo valor puede ser alterado por la ejecución de algún método.

Estado interno: es una variable que se declara privada, que puede ser únicamente accedida y alterada por un método del objeto, y que se utiliza para indicar distintas situaciones posibles para el objeto (o clase de objetos). No es visible al programador que maneja una instancia de la clase.

Características

Las principales características son  Abstracción, Encapsulamiento, Principio de Ocultación, Polimorfismo, Herencia.

Abstracción: es poner el enfasis en el ¿Que se Hace? mas que en el  ¿como lo hace?. Es decir  consiste en captar las características esenciales de un objeto, así como su comportamiento.
Es el mecanismo de diseño en la POO. Nos permite extraer de un conjunto de entidades datos y comportamientos comunes para almacenarlos en clases.
La abstracción ofrecida por los lenguajes de programación se puede dividir en dos categorías: abstracción de datos (pertenecientes a los datos) y abstracción de control (perteneciente a las estructuras de control).

Encapsulamiento: consiste en unir en la Clase las características y comportamientos, esto es, las variables y métodos. Es tener todo esto es una sola entidad. En los lenguajes estructurados esto era imposible. Es evidente que el encapsulamiento se logra gracias a la abstracción y el ocultamiento que veremos a continuación. La utilidad del encapsulamiento va por la facilidad para manejar la complejidad, ya que tendremos a las Clases como cajas negras donde sólo se conoce el comportamiento pero no los detalles internos, y esto es conveniente porque lo que nos interesará será conocer qué hace la Clase pero no será necesario saber cómo lo hace.

Ocultamiento: Es la capacidad de ocultar los detalles internos del comportamiento de una Clase y exponer sólo los detalles que sean necesarios para el resto del sistema.
El ocultamiento permite 2 cosas: restringir y controlar el uso de la Clase. Restringir porque habrá cierto comportamiento privado de la Clase que no podrá ser accedido por otras Clases. Y controlar porque daremos ciertos mecanismos para modificar el estado de nuestra Clase y es en estos mecanismos dónde se validarán que algunas condiciones se cumplan. En PHP el ocultamiento se logra usando las palabras reservadas: public, private y protected delante de las variables y métodos.

Segun la WIKI el principio de ocultamiento significa que cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de maneras inesperadas, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o rompecabezas de objetos.

Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado. Cuando esto ocurre en “tiempo de ejecución”, esta última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes proporcionan medios más estáticos (en “tiempo de compilación”) de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.

Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un objeto hereda de más de una clase se dice que hay herencia múltiple.

Para mayor comprension se puede decir que Es una relación entre clases en la cual una clase comparte la estructura y comportamiento definido en otra clase (Grady Booch)
Cada clase que hereda de otra posee:

1. Los atributos de la clase base además de los propios
2. Soporta todos o algunos de los métodos de la clase base

Fuente: WIKI 1 + WIKI 2 y extractos de otras webs.

Deame3p es una rutina que exporta datos contenidos en un archivo Excel hasta su versión 2003 a la base de datos MySql, utilizando el lenguaje PHP para realizar dicha tarea.

Descargue Deame3p desde este enlace
Las diferencias con otras soluciones de exportación son básicamente las siguientes:

• nos permite la vinculación o asociación de los campos de la base de datos MySQL con los nombres de las columnas del archivo Excel, no siendo necesario que sus nombres coincidan.
• Intenta la búsqueda de claves foráneas en la base de datos, para así proporcionarnos opciones de exportación, realizado para tablas tipo MISAM, por lo cual la clave foránea debe tener el mismo nombre que en la tabla donde es clave principal o única.
• Con los campos AUTOINCREMENT nos da la posibilidad de mantener los datos de la planilla Excel o que la base siga numerando sola.(Se aconseja esta ultima opción para no provocar errores por duplicación).
• Soporta dos modos INSERCION pura de datos o si una clave se Duplica se puede ACTUALIZAR esa línea.
• Contiene funciones basicas de formateo de campos entre ellos se encuentran varchar, Date, DateTime,TimeStamp, Time, Year(4), tinyint, smallint, mediumint, int, bigint, bool, boolean, bit, float,double, set y enum. Además de incluir un método por defecto para los campos no implementados.
• En el caso que administremos el servidor web permite la configuración de variables sensibles a la rutina como el consumo de memoria y el límite de tiempo máximo que puede ejecutarse.
• Nos permite codificar la entrada a UTF8 o dejarla como se encuentra en la planilla MySQL.

Deame3p debe ser usado para tablas ya existentes, no crea tablas si no que inserta registros en ellas.

Requerimientos
PHP >= 5.2.0
MySQL >= 5
Navegador Compatible con JavaScript

Instalación
Lo único que tienes que hacer es descomprimir el archivo rar en tu servidor web y darle al directorio planillas los permisos de lectura y escritura.

Uso
Ingresas a la rutina a través de tu navegador Web (Recomendamos FireFox) elijes la opción EXPORTAR y vas siguiendo los pasos de los formularios.

Cualquier Duda o sugerencia por favor déjanos un comentario…
Gracias

El estandar que utilizaremos en PHP es el recomendado por la empresa Zend.

Formato del Archivo
Para aquellos archivos que contienen sólo código PHP los tags de demarcación (”<? “) no estarán permitidos, además no es requerido por PHP y omitirlos nos previene de algún accidente ocasionado por un espacio en blanco.

Identación
La identación consistirá en cuatro espacios en blanco y la tabulación no estará permitida.

Largo máximo de la línea
El largo máximo ideal de una linea de código es de 80 caractéres, esto nos permite una cómoda lectura del mismo. El  máximo permitido por PHP es de 120 caractéres.

Fin de línea
El fin de línea seguirá la convención de texto de Unix. La línea debe de terminar con el caracter linefeed (LF)  representado con el ordinal 10 ó hexadecimal 0×0A.
No utilice el retorno de carro (Enter) (CF) que es un convecionalismo de los Sistemas operativos de Apple ó el  retorno de carro / linefeed (CRLF) que es de Windows.

Convención en los nombres

Clases
El nombre de las clases debe estar compuesto de caractéres alfanuméricos. El catacter Underscore (”_”) solo es  permitido para remplazar al separador en el path del archivo, por ejemplo: “Zend/Db/Table.php” quedaría como  “Zend_Db_Table”.
Si el nombre de la clase está comprimida en más de una palabra la primera letra debe de ser mayúscula. Letras mayúsculas seguidas no son permitidas.
Ejemplo: “Zend_PDF” no es permitido mientras que “Zend_Pdf” si lo es.

Archivos
En el nombre de los archivos se permite caractéres alfanuméricos, Underscore, dash (”-”),   pero no está permitido el  espacio en blanco.

Funciones y Métodos
El nombre de las funciones debe estar compuesto de caractéres alfanuméricos, el catactér Underscore no está  permitido, siempre tiene que comenzar con letra minúscula, si el nombre consiste en más de una palabra la primera letra de cada una de ella deberá ser mayúscula, por ejemplo: getElementById(), widgetFactory().
Un correcto empleo de verbos describe mejor el propósito y comportamiento de las funciones.
En caso de la programación orientada a objetos suele colocarse prefijos como “get” ó “set”, asi como también el nombre de los  patrones. En el caso que el método sea “private” ó “protected” el primer caractér debe ser Underscore ( único caso permitido ), aquelllos declarados “public” no llevan Underscore.

Variables
El nombre de las variables debe estar compuesto de caractéres alfanuméricos, el catactér Underscore no está   permitido. En el caso que sean declaradas “private” ó “protected” el primer caractér debe ser Underscore ( único caso permitido ), aquelllas declaradas “public” no llevan Underscore.
Siempre tiene que comenzar con letra minúscula, si el nombre consiste en más de una palabra la primera letra de  cada una de ella deberá ser mayúscula. Un correcto empleo de verbos describe mejor la variable. Por ejemplo
aquellas llamadas “$i” y “$n” serían permitidas en caso de que el algortimo sobrepasara las 20 líneas.
Constantes
Está permitido caractéres alfanuméricos y Underscore, asi también Números.
Las letras usadas en las constantes deben ser mayúsculas y las palabras separadas por Underscore, por ejemplo:
EMBED_SUPPRESS_EMBED_EXCEPTION estaría permitido y EMBED_SUPPRESSEMBEDEXCEPTION no lo estaría.

Estilo en el código

PHP Código de Delimitación
Todo código PHP debe estar delimitado por los tags estándares ( los cortos no están permitidos ).
<?php
?>
Estas delimitaciones se omiten en quellos archivos que sólo contengan código PHP.

String Literales
Cuando se le asigna un texto literal ( sin contenido de variables ) se utilizarán comillas simples.
$a = ‘Texto de ejemplo’;

String Literales con apóstrofes
Cuando se le asigna un texto literal con apóstrofes se utilizarán comillas dobles, este caso es principalmente en las sentencias SQL.

$sql = “SELECT `id`, `name` from `some_people` WHERE `name`=’Fred’ OR `name`=’Susan’”;

Sustitución por Variables
Cuando un texto contiene porciones que serán sustituidas por el valor de alguna variable, se toma como correcto únicamente esta dos formas:

$greeting = "Hola $nombre, bienvenido!";
$greeting = "Hola {$nombre}, bienvenido!";

Concatenación
Para concatenar Strings se utilizará el operador “.” (punto), con un espacio entre medio para mejorar la lectura.

$company = 'Zend' . ' ' . 'Technologies';

Arrays
En aquellos arrays de índices numéricos estos deberán ser números positivos, en la declaración de los valores del array se dejará un espacio en blanco luego de la coma para mejorar la lectura.
En caso que se necesiten varias líneas en la construcción del array, se identará cada una donde empezó la primera.
En el caso de los arrays asociativos, se hace un quiebre de línea por cada clave y valor.

$sampleArray = array('firstKey' => 'firstValue',
                     'secondKey' => 'secondValue');

Clases
En la declaración de la clase el nombre deberá seguir la convención ya expresada anteriormente, debe estar
precedida por una documentación conforme a PHPDocumentor, luego la declaración y desarrollo.

/**
* Documentación del bloque aquí.
* Documentación del bloque aquí.
*/
class SampleClass
{
    // Todo el contenido de la clase aquí
    // identada por cuatro espacios vacíos
}

Las funciones deberán seguir la convención de nombres, los métodos de las clases deberán ser declarados utilizando
uno de los modificadores private, protected, ó public. El pasaje por referencia es el único método permitido para
usar una variable externa, el llamado de una variable externa está totalmente prohibido.
A continuación un ejemplo de declaración de una variable, note que el valor de retorno no está entre paréntesis.

/**
* Documentación del bloque aquí.
*/
class Foo
{
    /**
    * Documentación del bloque aquí.
    */
    public function bar(&$var)
    {
        // Todo el contenido de la función aquí
        // identada por cuatro espacios vacíos
        return $this->bar;
    }
}

Control de flujo
En las declaraciones if/then/else deberá tener un espacio antes y después del parentesis condicional, en la misma
línea se habre llave y se cierra en una línea diferente, lo mismo se aplica al elseif, a continuación un ejemplo que lo
ilustra:

if ($a != 2) {
    $a = 2;
} elseif ($a == 3) {
    $a = 4;
} else {
    $a = 7;
}

En el caso de un Switch la convención es la misma, adicionando que el break tiene una identación mayor que el resto
a continuación un ejemplo:

switch ($numPeople) {
    case 1:
        break;
    default:
        break;
}

La opción default jamás deberá ser omitida en un Switch.
Nota: en aquel caso que dos case correspondan a un bloque de implementación, se comentará el break para diferenciarlo de un bug.

Documentación

Formato
El formato de los bloques de documentación deberán ser acorde al de PHPDocumentor, para más información  visitar: phpdoc.org

Archivos
Todo archivo con Código PHP deberá incluir un Bloque de Documentación en la parte superior con estos tags de PHPDocumentor como mínimo:

/**
* Descripción corta del archivo
*
* Descripción extendida del archivo (si alguien)...
*
* LICENCIA: Algún dato sobre la licencia
*
* @copyright 2008 Zend Technologies
* @license http://framework.zend.com/license BSD License
* @version $Id:$
* @link http://framework.zend.com/package/PackageName
* @since File available since Release 1.5.0
*/

Clases
Las clases deberán incluir un Bloque de Documentación en la parte superior con estos tags de PHPDocumentor como mínimo:

/**
* Descripción corta de la clase
*
* Descripción extendida de la clase (si alguien)...
*
* @copyright 2008 Zend Technologies
* @license http://framework.zend.com/license BSD License
* @version Release: @package_version@
* @link http://framework.zend.com/package/PackageName
* @since Class available since Release 1.5.0
* @deprecated Class deprecated in Release 2.0.0
*/

Funciones
Todas las funciones y los métodos deberán tener un Bloque de Documentación conteniendo como mínimo:
- Descripción de la función
- Argumentos
- Retorno
No es necesario utilizar el tag “@access” ya que el nivel de acceso está dado por los modificadores “public”, “private”, ó “protected” usados al declarar la función.
Si algún método/función tiene expeciones utilice el tag @throws.

Fuente
Esto es un resumen para más información visitar:
Zend Framework Coding Standard for PHP