Etiquetas en PHP
Todo script PHP debe empezar por la siguiente etiqueta:
<?php
Y en caso de que PHP este embebido dentro de un archivo HTML o cualquier otro archivo es necesario utilizar la etiqueta de cierre:
?>
esta puede ser omitida si un documento es completamente código PHP, y así es recomendado hacerlo aunque no habría problema de utilizarla, solo que existe la posibilidad de que agregue por error el editor de texto o usted espacios en blanco o saltos de lineas y estos al momento de usted incluir ese código en un documento los espacios o saltos también serán incluidos y eso sera una sorpresa no muy grata. Pero como se menciono antes no hay mayor inconveniente.
Comentarios en PHP
Los comentarios son útiles al momento de dar una descripción a su código, todo lo que este dentro de un comentario será omitido por PHP pues los comentarios solo están allí para que las personas puedan saber de que va una parte del código ya sea conocer el comportamiento que tendrá o tiene una función, clase entre otras cosas más. Ya que todo lo que este dentro de los comentarios no es interpretado por PHP, usted puede hacer uso de esto para debug del código, comentando parte del mismo y así ver que comportamiento tendría si ese código.Los comentarios de una sola linea "//":
<?php
// Como ves en un script este texto no será mostrado
// pues se esta utilizando dos barras inclinadas las cuales se utilizan para comentar una linea.
Si yo estuviera en tu código te diera un error pues no estoy comentado ni soy un literal de string.
# Al igual que las “//” con el numeral se crea comentarios
?>
Como observa existen dos maneras de hacer comentarios de una sola linea, una usando el numeral(#) y la otra es las dos barras inclinadas(//), para comentar varias lineas puedes utilizar cualquiera de estas dos formas pero siempre y cuando a cada linea le agregues su respectivo signo.
Para comentar unas pocas lineas esto esta bien pero que ocurre se necesita comentar muchas lineas, para ello contamos con los comentarios de múltiples lineas.
Los comentarios de múltiples lineas "/*...*/":
Todo lo que se encierra entre barra inclinada asterisco “/*” y asterisco barra inclinada “*/” será un comentario, a excepción de otro asterisco barra inclinada “*/” la cual cerrará el comentario y el resto dará un hermoso error.<?php
/* Yo soy un comentario de una sola linea */
/*
Yo soy uno de múltiples lineas
lo ves, puedo ser de cuantas lineas quiera.
*/
/* Aquí no soy un error */ pero aquí si me convierto en uno pues el primer asterisco barra inclinada cerro el comentario y yo no soy más que un estorbo, como puedes observar dentro de un comentario de múltiples lineas no pueden existir dos un asterisco barra inclinada */
?>
El constructor “echo”:
echo es un constructor del lenguaje por lo que no se utiliza paréntesis para utilizarlo, permite mostrar o imprimir datos en la salida.<?php
echo "Este es un texto y lo estoy uniendo o concatenando a un entero " . 4 . " y a una variable que podría tener cualquier valor " . $variableLoca;
?>
Todos esos datos serán mostrados en la salida como uno solo pues con ayuda del punto “.” todos estos distintos datos serán unidos o como se llama este proceso concatenación. Los datos que puedes mostrar con echo es unicamente los escalar.
Operadores en PHP
Operadores aritméticos en PHP
<?phpecho 10 + 1; // Suma mostrará 11
echo 10 - 2; // Resta mostrará 8
echo 10 * 2; // Multiplicación mostrará 20
echo 11 / 2; // División mostrará 5.5
echo -2; // Número negativo mostrará -2
echo 7 % 4; // Módulo mostrará 3
?>
Como se aprecia lo operadores funcionan tal cual se nos fue enseñado en primaria aunque con una leve diferencia que aquí tenemos el operador módulo. El modulo es el resultado de una división pero este resultado es muy particular pues es el resto de lo que quedaría de una división entera normal si te has liado no te preocupes veamos unos ejemplos.
- Tenemos el número 10 y lo dividimos entre 5.
El módulo de esta división sería 0 pues la cantidad de 5 que hay dentro del 10 es exacto hay dos 5.
- Ahora 9%5
El módulo ahora sería 4, la cantidad de 5 que hay dentro del 9 es uno y esto da 4 de resto el valor que no tiene compañero.
-. 7%2
Da 1 pues la cantidad de 2 dentro del 7 son 3 y queda el 1 sobrando.
-. 15%10
Es 5 ya que solo hay un 10 dentro del 15.
-. 35%20
15
Sin aun no entienden por favor háganlo saber en los comentarios.
Tipos de datos en PHP
Los tipos de datos con los cuales trabaja PHP son:Tipos escalares:
boolean(Booleanos)
string(Cadena de caracteres )
integer(Números enteros)
float(Números de coma flotante o decimales)
Tipos compuesto:
array
object.
Tipos especiales:
resource
null.
Por ahora solo veremos lo tipos escalares.
integer
4; //Esta es una constante literal del tipo integer (entero)
34345345; //Este es igual que el anterior.
Los números enteros no necesariamente deben ser en base a 10 también están los octal, hexadecimal y los binarios.
0526; //indica que es un entero octal empieza por cero(0).
0x22; //indica que es un entero hexadecimal empieza por "0x"
0b11111111; //indica que se trata de un entero binario empieza por "0b"
-0b11111111; //Precedido por el "-" le indicamos que es un entero negativo.
float
Formas en que se representa los números float(flotantes)
13.234; //Normal
5.2e3; //Utilizando notación científica
7E-10; //Utilizando notación científica
string
Hay 4 formas en que los string son representados y cada forma tiene su cualidad única.
Entrecomillado simple: 'Hola soy un string'
Entrecomillado doble: "Hola que tal, soy otro string literal"
Sintaxis Heredoc: <<<
Ejemplo:
<<<CUALQUIERCOSA //Aquí no puede haber nada ni saltos de lineas comentarios ni espacios nada
Como bien se puede apreciar todo la que este dentro de “CUALQUIERCOSA” es un string y a “CUALQUIERCOSA” le puedes colocar el nombre que más guste. Siempre y cuando inicie con una letra o un guión bajo puede ser mayúscula o minúscula tan sólo puede contener caracteres alfanuméricos y guiones bajos
CUALQUIERCOSA; //Aquí igual que al inicio
Sintaxis Nowdoc: <<<
Ejemplo:
<<<'NOMBRAME'
Como ves “nombreme” ahora esta entre comillas simples '' pero esta no es la única diferencia con Heredoc. Y será explicado mas abajo.
NOMBRAME;
A simple vista se observar que la cuatro formas de representar string en PHP dan un resultado idéntico, pero de acuerdo a la forma que utilices podrás o no hacer cosas distintas.
Estas son las secuencias de escape La mayoría de ellas solo pueden ser utilizadas dentro del "entrecomillado doble o en la sintaxis HEREDOC", para que php reconozca una secuencia de escape debe iniciar con la barra invertida "\" seguido del carácter que se quiera escapar o el carácter que completa una secuencia.
\n avance de línea (LF o 0x0A (10) en ASCII)
\r retorno de carro (CR o 0x0D (13) en ASCII)
\t tabulador horizontal (HT o 0x09 (9) en ASCII)
\v tabulador vertical (VT o 0x0B (11) en ASCII) (desde PHP 5.2.5)
\e escape (ESC o 0x1B (27) en ASCII) (desde PHP 5.4.4)
\f avance de página (FF o 0x0C (12) en ASCII) (desde PHP 5.2.5)
\\ barra invertida
\$ signo de dólar
\" comillas dobles
Si se va a programar para la web lo cual es lo más común puede que no le veas demasiado uso a la mayoría de las secuencias de escape, pero a la hora que necesites escribir un archivo para guardar texto verás lo útiles que son. Por ahora vamos con las comillas simples y ver que se puede hacer con ellas.
Entrecomillado simple '':
Todo cuanto haya dentro de ellas es tomado como texto literal a excepción de \' para representar una comillas simple dentro del entrecomillado simple y la doble barra invertida \\ para representar una barra invertida, el resto es impreso literalmente y no es analizado. Esto es todo lo que puedes hacer con el entrecomillado simple.
Sintaxis Nowdoc:
Es idéntico al entrecomillado simple y no es necesario escapar las comillas simples ya que como esta a diferencia del entrecomillado simple no esta encerrado entre comillas simple.
Entrecomillado doble "":
Puedes hacer uso de todas las secuencias de escape, aparte de tener la posibilidad de introducir dentro de ellas variables, elementos de array y propiedades de objeto.
<?php
"Así seria una variable {$variable} así un elemento de un array indexado {$miArray[0]} si es un array de clave valor es necesario que la clave este dentro de comillas simples {$claveValor['r']}. Puedes agregar propiedades y variables estáticas de clase, aunque antes debe hacer una instancia de la clase pues de otra forma no funcionara, agregando una propiedad {$miClase->propiedad} para una variable estática {$miClase::$estatica}";
?>
Nota: no puede existir espacio en blanco entre la llave y el signo de dólar, Para las variables y los array indexados no es necesario encerrarlos entre llaves pero para el resto si lo es.
Si quieres que PHP lea una variable en vez de analizarla o simplemente expresar cualquier cosa con el signo del dólar, solo debe escapar el signo "\$" de esta forma PHP lo tomara como literal y no lo analizará, de igual manera pasa con las comillas dobles dentro de un string de entrecomillado doble "\"" pues de otro modo daría error la ultima comillas, pues la que se encuentra en medio finaliza el string.
Sintaxis Heredoc:
Funciona igual que el entrecomillado doble con la diferencia que aquí no es necesario escapar las comillas dobles.
Nota: tenga especial cuidado con los espacios en blanco al inicio y final del la sintaxis Heredoc y Nowdoc, si ha creado un string con estas sintaxis y ocurre un error es casi seguro que se debe a un espacio en blanco.
<<<aaa
Cualquier texto.
aaa;
Lo de color azul es donde probablemente tendrá espacios en blanco asegúrese de borrarlos.
Unir string
para unir string se cuenta con el operador de concatenación el cual convierte varias cadenas o cualquiera de los tipos de datos escalar en una única cadena representado por el punto “.”
<?php
"Esta es la cadena primera " . "y esta será añadida a la primera cadena convirtiéndose en una única";
"También me puedo unir a otros datos escalares " . 23 . " " . true . " al concatenar no se te olvide que puedes agregar espacios en blanco al principio y al final de los string para que estas cadenas al unirse no se vea mal";
?>
Lo que esta en verde son espacios en blancos que puse para que las cadenas al unirse no se pegarán. Puede imprimirlas con echo para ver que ocurre.
Operadores de asignación en PHP
Los operadores de asignación le indican a PHP toma el valor de la izquierda y almacenarlo en la variable de la derecha.
El operador de asignación básico "="
<?php
$variableLoca = 9; //La variable $variableLoca ahora vale 9 y cada vez que la escribas de aquí
//en adelante en cualquier parte de tu código estas llamando realmente al
//número 9. Y los comentarios también los puedes usar después del ";" menos en los string.
// Heredoc y Nowdoc.
?>
Asimismo contamos con los operadores combinado. Los operadores aritméticos combinados dicen, toma el valor que ya contiene $variableLoca y sumarle, restarle o dividir el nuevo valor que esta a la derecha y el resultado será el nuevo valor de la variable.
$variableLoca += 8; // es igual que $variableLoca = $variableLoca + 8 Suma
$variableLoca -= 2; // es igual que $variableLoca = $variableLoca - 2 Resta
$variableLoca *= 2; // es igual que $variableLoca = $variableLoca * 2 Multiplicación
$variableLoca /= 2; // es igual que $variableLoca = $variableLoca / 2 División
$variableLoca %= 2; // es igual que $variableLoca = $variableLoca % 2 Módulo
Asignación sobre concatenación.
$variableLoca .= " esto se concatenará a variable loca";
es igual que hacer
$variableLoca = $variableLoca . "Cualquier cosa";
De la misma forma podemos hacer lo mismo con los operadores bit a bit que hablaremos como funcionan un poco más abajo.
$primera &= $otra; //es igual que $primera = $primera & $otra AND bit a bit
$primera |= $otra; //es igual que $primera = $primera | $otra OR bit a bit
$primera ^= $otra; //es igual que $primera = $primera ^ $otra XOR bit a bit
$primera <<= $otra; //es igual que $primera = $primera << $otra Desplazamiento a la izquierda
$primera >>= $otra; //es igual que $primera = $primera >> $otra Desplazamiento a la derecha
Asignación por referencia "&" (usa el mismo signo que AND lógico pero fijarse como se utiliza uno y como el otro):
Hace que una variable apunte al valor de otra, y así trabajar con el mismo valor en dos variables distintas, es parecido a un alias:
<?php
$a = 12;
$b = &$a;
echo $b; // la salida de $b es 12
echo "\n"; // Un salto de linea puede cambiar \n por <br> para mostrar lo en el navegador
$b = 34;
echo $a; // la salida de $a es 34
?>
Tenga en cuenta que si por ejemplo "$a" referencia a otra variable digamos "$c", $b se mantiene con el valor anterior que "$a" poseía o mejor dicho al valor que representaba.
<?php
$a = 12;
$c = 3;
$b = &$a;
$a = &$c;
echo $a . " - - " . $b; // muestra 3 - - 12
?>
Operadores bit a bit.
Tenemos los siguientes operadores:& AND(Y)
| OR(O inclusivo)
^ XOR (O exclusivo)
<< desplazamiento a izquierda
>> desplazamiento a derecha
~ NOT(negación)
Estos operadores nos permiten trabajar a nivel de bit. Digamos que tenemos un byte, con un byte podemos representar 256 números. En la tabla de abajo se muestran como se representa el valor de un entero sumando solo los byte que estén activos, en la table el valor sería 43.
Si el número fuera más grande tuviera más bit que a su vez significa más bites.
Basados en esto podremos decir que teniendo dos números(necesarios para hacer los ejemplos) el primero 12 y un segundo 9.
Respectivamente en binarios.
12: 00001100
9: 00001001
& "Y" operador bit a bit:
De 12 & 9 el resultado es 8 y ¿esto porque ocurre? Esto ocurre debido que "Y (&), el operador" cuando compara dos números se pregunta, oye ¿en la posición donde estoy, están ambos bit activos? Si es así entonces en esta posición al nuevo número que estoy creando que este activa esta posición para él, sino que este desactivada.
Analice usted mismo en cual posición en 12 y 9 tienen los bit activos al mismo tiempo.
00001100
00001001
El 8
00001000
| (O inclusivo) operador bit a bit:
Compara si una posición en especifica tiene ambos o uno de los bit activos si es así entonces en esa posición el nuevo número tendrá el bit activo en contra parte desactivado.
12 | 9 resultará en el número 13 analice los bit usted mismo.
00001100
00001001
El 13
00001101
^ Xor (O exclusivo) operador bit a bit:
Este operador al evaluar dos números busca la posición en la cual son distintos y a partir de esa diferencia será el resultado del nuevo número.
De 12 ^ 9 resultará en 5 analice usted mismo en bit son estos dos números distintos.
00001100
00001001
El 5
00000101
Operador de desplazamiento a la izquierda <<
Mueve todos los bit activos a la izquierda cuantos pasos le digas, ahora digamos que tenemos el número 1 (uno) representado en bit de la siguiente forma:
00000001
Para decirle que se mueva a la izquierda 4 paso: 1 << 4 lo cual resultaría en 0010000 teniendo el número 16
¿pero sino fuera el 1 sino el número 5?
00000101
y le pedimos que se mueva a la izquierda 3 paso: 5 << 3
El resultado es 00101000 que representa al número 40.
Nota: al usar el desplazamiento de bit a la izquierda debes tener en cuenta si tu sistema es de 32 o 64 bits, pues para 32 bit el limite es usar 31 y para 64 bit el limite es 63 hacer que un bit se mueva más allá del limite los resultados empezarán a ser inesperados.
Operador de desplazamiento a la derecha >>
Funciona igual que el desplazamiento a la izquierda solo que este es a la derecha teniendo un número digamos el 1.
00000001
1 >> 1 el resultado es 0 pues al único bit que teníamos lo mandamos al olvido.
Ahora con el 5:
00000101
5 >> 1 el resultado es 2 al moverlo una posición el que esta en el borde lo mandamos al olvido y el otro aun le queda espacio para desplazarse, así queda internamente.
00000010
Vamos con una ultima tenemos el número 128:
10000000
128 >> 4 y tenemos como resultado el número 8.
00001000
Operador ~ NOT (negación)
Los bits que están activos son desactivados y viceversa, tenga en cuenta que el 0 (cero) también es contado como un número entero positivo esto a la hora de hacer la negación.
~2 resulta en -3
~3 resulta en -4
~1 resulta en -2
~4 resulta en -5
~0 resulta en -1
como se observar al realizase la negación el valor absoluto es un número mayor en los números negativos esto es porque el cero es también contado como un número positivo, esto lo puedes contrarrestar sumándole 1 (uno)
(~2 + 1) resulta en -2
(~3 + 1) resulta en -3
(~1 + 1) resulta en -1
(~4 + 1) resulta en -4
(~0 + 1) resulta en -0
Aunque su sistema puede manejar 32 bit o 64 bit dependiendo que versión instalada que este tiene. PHP solo puede usar 31 o en contra parte 63 pues el ultimo bit es reservado para el signo, como se ha mencionado previamente el 0 (cero) es visto como un número entero positivo y este se ve representado por toda la secuencia de bit desactivados.
El cero al ser negado 0 el resultado es el -1 representado por la siguiente secuencia de bit:
1111111111111111111111111111111111111111111111111111111111111111
"~" Invierte los valores de los bits convirtiendo CEROS en UNOS y los UNOS en CEROS. Como en el cero todos los valores se mantienen desactivados al invertirlos estos son activados todos.
y a la inversa ~-1
0
Operadores de comparación PHP
Al comparar dos valores el resultado es un booleano "true" o "false".Imaginemos que tenemos 4 datos:
12 // un número entero
"12" // un string con el mismo valor que el número primero
12.0 // un número float con el mismo valor que el primero
13 // y un numero mayor que el numero primero
Operador igual que "==" (no es igual que al de asignación "=")
<?php
echo 12 == 12; /* el resultado es true (1) ya que son idénticos */
echo 12 == 12.0; /* el resultado es true (1) ya que son iguales */
echo 12 == "12"; /* el resultado es true (1) ya que son iguales */
echo 12 == 13; /* No muestra nada como resultado de false ya que son distintos*/
?>
igual que "==" compara el valor, mas no el tipo de dato. Para comparar el tipo de dato al mismo tiempo que se compara valor se utiliza el operador idéntico que "===" (con 3 signos que igualdad).
Operador idéntico que "==="
Funciona igual que el operador anterior con la diferencia que compara también el tipo de dato.
<?php
echo 12 === 12.0; /* el resultado es false ya que los tipos son distintos con echo el resultado no será mostrado, pues echo no muestra el booleano false para ello puedes usar una función var_dump que da información sobre estructurada de un dato*/
var_dump(12 === 12.0);
?>
Operador diferente que
Este operador se puede representar de dos formas ambas validas por igual la primera "!=" y la segunda forma "<>", Este operador es parecido al operador "==" simplemente que en vez de comparar la igualdad compara la diferencia, no toma en cuenta el tipo, solo el valor.
<?php
echo 12 <> 12; /* false pues no son distintos */
echo 12 != 12.0; /* false pues no son distintos */
echo 12 != "12"; /* false pues no son distintos */
echo 12 <> 13; /* true porque definitivamente si son distintos */
?>
Operador distinto que "!=="
compara si los datos son distintos en cuanto a valor y si los valores son iguales compara el tipo de dato en busca de diferencia, al encontrar una diferencia el resultado es true y si no la encuentra será false.
<?php
echo 12 !== 12; /* false pues no son distintos */
echo 12 !== 12.0; /* true uno es integer y el otro float */
echo 12 !== "12"; /* true uno es integer y el otro es string */
echo 12 !== 13; /* true los datos son distintos */
?>
Operador menor que "<"
compara si un valor es menor que otro, si es menor retorna true de lo contrario false:
12 < 13; // true 12 si es menor que 13;
12 < 12.1; // true 12 si es menor que el float 12.1;
13 < 13; // false 13 no es menor que 13;
13 < 12; // false 13 no es menor que 12;
Operador mayor que ">"
compara si un valor es mayor que otro, si es mayor retorna true de lo contrario false:
12 > 13; // false 12 no es mayor que 13;
12 > 12.1; // false 12 no es mayor que el float 12.1;
13 > 13; // false 13 no es mayor que 13;
13 > 12; // true 13 si es mayor que 12;
Operador menor o igual que "<="
compara si un valor es menor o igual que otro, si es menor o igual retorna true de lo contrario false:
12 <= 13; // true 12 es menor que 13;
12 <= 12.1; // true 12 es menor que el float 12.1;
13 <= 13; // true 13 si es igual que 13;
13 <= 12; // false 13 no es menor ni igual que 12;
Operador mayor o igual que ">="
compara si un valor es mayor o igual que otro, si es mayor o igual retorna true de lo contrario false:
12 >= 13; // false 12 no es mayor ni igual que 13;
12 >= 12.1; // false 12 no es mayor ni igual que el float 12.1;
13 >= 13; // true 13 es igual que 13;
13 >= 12; // true 13 si es mayor que 12;
Operadores lógicos
Los operadores solo trabajan con booleanos, tenga en cuenta los siguientes valores pues todos son tratados por PHP como "false":
false // boolean false
0 // integer Cero
"0" // un string con el valor de cero
0.0 // un float 0.0
"" // un string vació
[] // array vació
null // el tipo especial null
si usted quiere saber si tanto como el tipo y valor se trata de un false booleano debe comparar con el operador de comparación "===", false === $cualquierDato, tomando en cuenta todos los datos de arriba son interpretados como false cualquier otro valor distinto a ellos es tratado como true.
Se preparan los datos a operar:
$dato1 = 5 < 4; // false pues 5 no es menor que 4
$dato2 = false == false; // true pues false si es igual a false
Empezamos con las operaciones:
$dato1 and $dato2; // "and" y "&&" significan lo mismo, ambos datos a comparar deben ser true
$dato1 && $dato2; // para poder devolver true de lo contrario es false
$dato1 or $dato2; // “or” y “||” significan lo mismo, solo uno o ambos de los dos valores
$dato1 || $dato2; // en la comparación debe ser true, para que la expresión se a true
// sino, será false
$dato1 xor $dato2; /* xor analiza si ambos datos son distintos osea uno true y otro false, si es así el resultado es true, en caso que sean iguales un true y el otro true o false y false el resultado es false, deben ser distintos para poder ser true salu2*/
!$dato1 // "!" niega el valor lógico si es true lo cambia a false y si es false lo pasa a true.
"and" "&&" y "or" "||" su diferencia radica en la precedencia, la precedencia es cual operador analiza PHP primero y cual después, en una expresión donde están combinados digamos que el operador "and" y el "&&" primero se analizara "&&" y después es que vendrá el análisis de "and", en caso que hayan dos operadores que tengan la misma precedencia PHP los analizará de izquierda a derecha aquí una tabla de precedencia también la puedes encontrar en php.net
La precedencia va, los que están arriba en la tabla son analizados primero, las filas muestran cuales operadores tienen la misma precedencia en ese caso que en una expresión estén combinados operadores con la misma precedencia el análisis empieza de izquierda a derecha, los que encuentre primero eso serán analizados.
var_dump( false && true and false or true); // devuelve true pues or es analizado de ultimo.
var_dump( false && true and false || true); //devuelve false ya que and es analizado de ultimo.
Operadores sobre array:
aunque en este articulo no veremos los array, como estamos viendo los operadores es bueno ver con los que cuentan los array.
$a + $b (Unión) - Unión de $a y $b.
$a == $b (Igualdad) - true si $a y $b tienen los mismos pares de clave / valor.
$a === $b (Idéntico) – true si $a y $b tienen los mismos pares de clave / valor en el mismo orden y de los mismos tipos.
$a != $b (Desigualdad) – true si $a no es igual a $b.
$a <> $b (Desigualdad) – true si $a no es igual a $b.
$a ! == $b (No idéntico) – true si $a no es idéntico a $b.
El operador + devuelve el array de la derecha anexa al array de la izquierda, para las claves que existen en ambos array, se usarán los elementos del array de la izquierda y se ignorarán los elementos coincidentes del array de la derecha.
Operador ternario: "?:"
Es un alternativa reducida del condicional "if-else", hace uso de 3 partes primero una condición segundo lo que quieres que ocurra si la condición es true tercero en caso que dicha condición sea false.Condición ? En caso de que sea true pasa esto : si no es así pasa esto;
echo 5 == "5" ? "La condición es cierta." : "la condición es falsa";
También puedes guardar el resultado en una variable, para luego hacer lo que mas quiera con el resultado yo lo imprimí con echo, Tenga en cuenta que echo no puede ser utilizado dentro de ninguna de las partes de del operador.
$miVariable = 5 == "hola" ? "5 es igual a hola" : "no es igual";
echo $miVariable;
¿Recuerdas que antes hablamos sobre la precedencia de los operadores? Usted puede aumentar la precedencia de una expresión encerrando esta entre paréntesis () como vimos en los operadores lógicos unos tienen más precedencia que otros al igual que pasa con ellos usted puede observar en la tabla, que los signos "* / %" son analizados primero que los de suma(+) y resta(-), en caso que usted quiera que se evalúen estos dos antes que los otros puede hacer uso de los paréntesis.
Observe usted mismo que el el uso o no de los paréntesis afecta la operación:
echo (2 + 4 ) * 3; // Resultado 18
echo 2 + 4 * 3; // Resultado 14
Los paréntesis no solo agrega lógica a su código también le da vistosidad, puede hacer uso de los paréntesis para solo vistosidad cuando la lógica no es necesaria.
echo (2 + 2) == 4; // true, aunque los paréntesis no son necesarios es mas fácil leerlo así.
echo 2 + 2 == 4; // true
Lo mismo ocurre con el operador ternario aunque los paréntesis no serian necesarios algunas veces, no esta de mas utilizarlos.
$miVariable = (5 == "hola" ) ? "5 es igual a hola" : "no es igual";
echo $miVariable;
Operador de control de error "@"
Cuando se antepone "@" a una expresión en PHP, cualquier mensaje de error que pueda ser generado por esa expresión será ignorado.Nota: "@" funciona solo en expresiones. Una regla general simple es: si puede tomar el valor de algo, puede anteponer el operador "@" a él. Por ejemplo, puede anteponerlo a variables, función e incluir llamadas, constantes, etc. No se puede anteponer a definiciones de funciones o clases, o estructuras condicionales como if y foreach, etc.
Advertencia: actualmente, el operador @ error-control incluso deshabilitará el informe de errores críticos que terminarán la ejecución del script. Entre otras cosas, esto significa que si usa @ para suprimir los errores de una determinada función y, o bien no está disponible o ha sido mal escrita, la secuencia de comandos morirá allí mismo sin indicación de por qué.
Al intentar abrir un archivo con la función "fopen" para lectura, el cual no existe en el computado genera un Warning un aviso y lo podemos suprimir de esta forma:
$archivo = fopen("algoQueNoExisteEnMiPc.txt", "r"); //No esta suprimido el Warning
$archivo = @fopen("algoQueNoExisteEnMiPc.txt", "r"); //El Warning esta suprimido por lo que no se mostrar
Al tratar de acceder a una clave que no existe en un array PHP lanza un Notice, se puede suprimir con el operador "@"
$ella = ["saludo" => "Hola", "despedida" => "adios"];
@$ella['meAma']; //Se suprimió el dolor.
Operadores de incremento y decremento "++", "--"
Aumenta o disminuye en 1 el valor de una variable, la disminución o aumento puede ser inmediatamente o ser reflejado la próxima vez que se invoque la variable, para que el incremento o decremento sea inmediato el operador que desee utilizar debe estar por delante de la variable "++$miVariable" si quiere que el incremento o decremento se vea reflejado la próxima vez que invoque la variables entonces debe colocar el operador detrás de la variable "$miVariable--".Antes que nada debe tener en cuenta que estos operadores son equivalentes a hacer esto:
$miVariable = 3; // inicializamos $miVariable con el valor de 3 integer
$miVariable = $miVariable + 1;
o
$miVariable += 1;
<?php
// Empezamos
$variLoca = 5.2; // Se inicializa $variLoca con el valor de 5.2 float
echo ++$variLoca . "\n"; // Muestra 6.2 ya que el incremento es inmediato
echo $variLoca++ . "\n"; // Sigue mostrado 6.2, el incremento se ve es en el próximo uso.
echo $variLoca . "\n"; // Muestra 7.2
// El mismo principio aplica para el operador de decremento.
/* \n es un salto de linea si usted va a mostrar los ejemplos en el navegador cámbielo por <br> */
?>
Operadores de tipo
instanceof es utilizado para saber si una variable es un objeto instanciado de una clase.var_dump($variableDemente instanceof UnaClaseLoca); // true
Variables
La declaración de una variable inicia con el signo de dólar($) seguido del nombre de la variable, el nombre debe iniciar con una letra o un guión bajo luego de esto la variable puede tener números mas no puede iniciar con números, se permiten mayúscula y minúscula para el nombre pero al invocar la variable debe tener en cuenta que es sensible a mayúscula y minúscula osea debe escribirla tan cual la nombró, generalmente las variables son nombrada solo con letras en minúscula, haga que sus variables sean descriptivas en cuanto al valor que estas representan. Otra cosa nombre sus variables como a usted mas le parezca es usted el programador.Tenemos que:
Solo pueden contener letras, números y guión bajo.
Inician con $.
la primera letra del nombre debe ser o bien una letra o un guión bajo.
Nombres validos para variables:
$soy_una_variable; // como observas todas la variables básicamente se llaman igual
$soyUnaVariable; // pero para PHP son distintas, a eso me refiero con
$soyunavariable; // sensibilidad a mayúscula y minúscula ¡Cuidado con eso!
$_soyunavariable;
Nombres inválidos:
$%soyunavariable;
$3soyunavariable;
Tipos de datos con los cuales puede trabajar una variable.
Tipos escalar: boolean, string, integer, float.
Tipos compuesto: array, object.
Tipos especiales: resource, null.
Constante
Las constante una vez que le das un valor este nunca cambia(ni podrás redefinirla) a través de la ejecución de un programa en otros lenguaje usted encontrará que en lo que PHP se llama constante en realidad es una constante simbólica y lo que en PHP se llama literal es en realidad una constante."Hola"; // un string es un literal. Este nunca cambiará su valor porque él es lo que es.
2; // el integer igualmente.
¿Pero que tienen en común eso dos literales?
Que si son datos que debes utilizar varias veces en el código tienes que estar escribiéndolos una y otras vez donde los necesites eso no es grave pero imagina que un día tienes que cámbialos, tendrá que buscarlos uno por uno. Son parecidas a las variables pues referencia un valor pero se declaran de distinta manera y una vez que le das un valor no se lo puedes cambiar más adelante.
Maneras de declarar una constante.
Contamos con dos formas. (una ultima cosa la gran mayoría declara sus constantes en mayúscula eso se hace así para que un persona al leer el código sepa solo con mirarla que se trata de una constante tu nombrarlas como mejor te parezca)
define("AQUIELNOMBRE", "valor");
const NOMBRE = "valor";
no utilizan símbolo de dólar como las variables si intentas ponérselo de dará un erro inténtalo, los tipos de datos que puedes almacenar en una constante son los escalares y los arrays.
integer, float, string, boolean y array.
const VELOCIDADLUZ = 300000;
define("GRAVEDADTIERRA", 9.807);
Nota: si he cometido algún error por favor hacerlo saber para así repararlo.
Comentarios
Publicar un comentario