PHP

1) Que es Php
2) Que se necesita para trabajar con Php
3) Como se hace la apertura y cerrado en el codigo Php
4)  Como se definen y se inician y definen las variables en Php
5)  operadores aritmeticos, relacionales, booleanos

1) Que es Php

PHP es un potente lenguaje, y su intérprete, bien como módulo del servidor web o bien como binario CGI, puede acceder a ficheros, ejecutar comandos o abrir conexiones de red desde el servidor. Estas propiedades hacen que, por omisión, sea inseguro todo lo que se ejecute en un servidor web. PHP está diseñado específicamente para ser un lenguaje más seguro para escribir aplicaciones CGI que Perl or C

 

2) Que se necesita para trabajar con Php

Instalar un servidor web, como » Apache, y por supuesto » PHP.  también instalar una base de datos como » MySQL.
 
 
 

3) Como se hace la apertura y cerrado en el codigo Php

 
<html>
<head>
  <title>Prueba de PHP</title>
</head>
<body>
<p>Hola mundo</p>
</body>
</html>
 
 

4)  Como se definen y se inician las variables en Php

 

En PHP las variables se representan con un signo de dólar seguido por el nombre de la variable. El nombre de la variable es sensible a minúsculas y mayúsculas.

Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido tiene que empezar con una letra o un carácter de subrayado (underscore), seguido de cualquier número de letras, números y caracteres de subrayado. Como expresión regular se podría expresar como: '[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*'

<?php
$var = 'Roberto';
$Var = 'Juan';
echo "$var, $Var";      // imprime "Roberto, Juan"

$4site = 'aun no';      // inválido; comienza con un número
$_4site = 'aun no';     // válido; comienza con un carácter de subrayado
$täyte = 'mansikka';    // válido; 'ä' es ASCII (Extendido) 228
?>

De forma predeterminada, las variables siempre se asignan por valor. Esto significa que cuando se asigna una expresión a una variable, el valor completo de la expresión original se copia en la variable de destino. Esto quiere decir que, por ejemplo, después de asignar el valor de una variable a otra, los cambios que se efectúen a una de esas variables no afectará a la otra. Para más información sobre este tipo de asignación, vea Expresiones.

PHP también ofrece otra forma de asignar valores a las variables: asignar por referencia. Esto significa que la nueva variable simplemente referencia (en otras palabras, "se convierte en un alias de" ó "apunta a") la variable original. Los cambios a la nueva variable afectan a la original, y viceversa.

Para asignar por referencia, simplemente se antepone un signo ampersand (&) al comienzo de la variable cuyo valor se está asignando (la variable fuente). Por ejemplo, el siguiente segmento de código produce la salida 'Mi nombre es Bob' dos veces:

<?php
$foo = 'Bob';                // Asigna el valor 'Bob' a $foo
$bar = &$foo;                // Referenciar $foo vía $bar.
$bar = "Mi nombre es $bar";  // Modifica $bar...
echo $bar;
echo $foo;                   // $foo también se modifica.
?>

Algo importante a tener en cuenta es que sólo las variables con nombre pueden ser asignadas por referencia.

<?php
$foo = 25;
$bar = &$foo;      // Esta es una asignación válida.
$bar = &(24 * 7);  // Inválida; referencia una expresión sin nombre.

function test()
{
   return 25;
}

$bar = &test();    // Inválido.
?>

No es necesario inicializar variables en PHP, sin embargo, es una muy buena práctica. Las variables no inicializadas tienen un valor predeterminado de acuerdo a su tipo dependiendo del contexto en el que son usadas - las booleanas se asumen como FALSE, los enteros y flotantes como cero, las cadenas (p.ej. usadas en echo) se establecen como una cadena vacía y las matrices se convierten en un array vacío.

Ejemplo #1 Valores predeterminados en variables sin inicializar

<?php
// Una variable no definida Y no referenciada (sin contexto de uso); imprime NULL
var_dump($variable_indefinida);

// Uso booleano; imprime 'false' (Vea operadores ternarios para más información sobre esta sintaxis)
echo($booleano_indefinido ? "true\n" : "false\n");

// Uso de una cadena; imprime 'string(3) "abc"'
$cadena_indefinida .= 'abc';
var_dump($cadena_indefinida);

// Uso de un entero; imprime 'int(25)'
$int_indefinido += 25; // 0 + 25 => 25
var_dump($int_indefinido);

// Uso de flotante/doble; imprime 'float(1.25)'
$flotante_indefinido += 1.25;
var_dump($flotante_indefinido);

// Uso de array; imprime array(1) {  [3]=>  string(3) "def" }
$array_indefinida[3] = "def"; // array() + array(3 => "def") => array(3 => "def")
var_dump($array_indefinida);

// Uso de objetos; crea un nuevo objeto stdClass (vea https://www.php.net/manual/en/reserved.classes.php)
// Imprime: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }
$objeto_indefinido->foo = 'bar';
var_dump($objeto_indefinido);
?>

Depender del valor predeterminado de una variable sin inicializar es problemático al incluir un archivo en otro que use el mismo nombre de variable. También es un importante riesgo de seguridad cuando la opción register_globals se encuentra habilitada. Un error de nivel E_NOTICE es emitido cuendo se trabaja con variables sin inicializar, con la excepción del caso en el que se anexan elementos a un array no inicializado. La construcción del lenguaje isset() puede ser usada para detectar si una variable ya ha sido inicializada.

 

5)  operadores aritmeticos, relacionales, booleanos

 

Operadores lógicos 

Operadores lógicos
Ejemplo Nombre Resultado
$a and $b And (y) TRUE si tanto $a como $b son TRUE.
$a or $b Or (o inclusivo) TRUE si cualquiera de $a o $b es TRUE.
$a xor $b Xor (o exclusivo) TRUE si $a o $b es TRUE, pero no ambos.
! $a Not (no) TRUE si $a no es TRUE.
$a && $b And (y) TRUE si tanto $a como $b son TRUE.
$a || $b Or (o inclusivo) TRUE si cualquiera de $a o $b es TRUE.

La razón para tener las dos variaciones diferentes de los operadores "and" y "or" es que ellos operan con precedencias diferentes. (Ver Precedencia de operadores.)

Ejemplo #1 Los operadores lógicos ilustrados

<?php

// --------------------
// foo() nunca será llamado ya que los operadores están en cortocircuito

$a = (false && foo());
$b = (true  || foo());
$c = (false and foo());
$d = (true  or  foo());

// --------------------
// "||" tiene una precedencia mayor que "or"

// El resultado de la expresión (false || true) es asignado a $e
// Actúa como: ($e = (false || true))
$e = false || true;

// La constante false es asignada a $f y entonces true es ignorado
// Actúa como: (($f = false) or true)
$f = false or true;

var_dump($e, $f);

// --------------------
// "&&" tiene una precedencia mayor que "and"

// El resultado de la expresión (true && false) es asignado a $g
// Actúa como: ($g = (true && false))
$g = true && false;

// La constante true es asignada a $h y entonces false es ignorado
// Actúa como: (($h = true) and false)
$h = true and false;

var_dump($g, $h);
?>

El resultado del ejemplo sería algo similar a:

bool(true)
bool(false)
bool(false)
bool(true)
Operadores aritméticos
Ejemplo Nombre Resultado
-$a Negación Opuesto de $a.
$a + $b Adición Suma de $a y $b.
$a - $b Sustracción Diferencia de $a y $b.
$a * $b Multiplicación Producto de $a y $b.
$a / $b División Cociente de $a y $b.
$a % $b Módulo Resto de $a dividido por $b.

 

El operador de división ("/") devuelve un valor flotante a menos que los dos operandos sean integers (o strings que se conviertan a integers) y los números sean divisibles, en cuyo caso será devuelto un valor integer.

Los operandos del módulo se convierten en integers (por extracción de la parte decimal) antes del procesamiento.

El resultado del operador módulo % tiene el mismo signo que el dividendo — es decir, el resultado de $a % $b tendrá el mismo signo que $a. Por ejemplo:

<?php

echo (5 % 3)."\n";           // muestra 2
echo (5 % -3)."\n";          // muestra 2
echo (-5 % 3)."\n";          // muestra -2
echo (-5 % -3)."\n";         // muestra -2

?>

 

 

 

Booleanos 

Este es el tipo más simple. Un boolean expresa un valor de verdad. Puede ser TRUE o FALSE.

Sintaxis 

Para especificar un literal boolean, use alguna de las palabras clave TRUE o FALSE. Ambas son insensibles a mayúsculas y minúsculas.

<?php
$foo = True; // asigna el valor TRUE a $foo
?>

Usualmente, el resultado de un operador que devuelve un valor boolean es pasado a una estructura de control.

<?php
// == es un operador que prueba por
// igualdad y devuelve un booleano
if ($accion == "mostrar_version") {
    echo "La versión es 1.23";
}

// esto no es necesario...
if ($mostrar_separadores == TRUE) {
    echo "<hr>\n";
}

// ...porque se puede escribir simplemente:
if ($mostrar_separadores) {
    echo "<hr>\n";
}
?>

Conversión a booleano 

Para convertir explícitamente un valor a boolean, use el moldeamiento (bool) o (boolean). Sin embargo, en la mayoría de casos no es necesario usar el moldeamiento, ya que un valor será convertido automáticamente si un operador, función o estructura de control requiere un argumento tipo boolean.

Vea también Manipulación de Tipos.

Cuando se realizan conversiones a boolean, los siguientes valores son considerados FALSE:

  • el boolean FALSE mismo
  • el integer 0 (cero)
  • el float 0.0 (cero)
  • el valor string vacío, y el string "0"
  • un array con cero elementos
  • un object con cero variables miembro (sólo en PHP 4)
  • el tipo especial NULL (incluyendo variables no definidas)
  • objetos SimpleXML creados desde etiquetas vacías

Cualquier otro valor es considerado TRUE (incluyendo cualquier resource).

Advertencia

-1 es considerado TRUE, como cualquier otro número diferente a cero (¡ya sea negativo o positivo!)

<?php
var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)
var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)
?>