Uso avanzado de comillas y variables en PHP

Para tratar de explicar de nuevo las variables variables:

La cadena “${$teacher}”, se divide en dos partes: El signo de dólar “$” y el nombre de la variable, en este caso, no pasamos un nombre de variable directo, sino que pasamos corchetes “{}”, eso le indica a PHP que debe resolver lo que esté dentro de los corchetes primero, como si de una ecuación matemática se tratase.

Por tanto, lo que está dentro de los corchetes es una simple vatiable $teacher, y su valor es “italo”, por tanto, al resolver, la cadena queda como: “${italo}”, pero al haber resuelto esto, los corchetes se van, por tanto solo queda como: “$italo” ahora PHP procede a resolver esa variable que tien el valor: “Profesor de PHP”, es por eso que al final imprimer “italo es Profesor de PHP”

😛 accediendo a datos dentro de otro acceso 😮 dinamicamente

Comillas

Comillas simples

Para manejar datos strings con comillas simples. Si queremos utilizar una comilla simple dentro de nuestro string utilizamos \ (backslash) para escaparla y no nos de error.

<?php

echo 'Un texto de una línea';

echo 'Un texto de 
varías líneas solo en código
no solo refleja en output';

echo 'Podemos escapar una comilla
simple así \' con un backslash \\ continuar con más texto <br>';

Comillas dobles

Si queremos acceder a una variable utilizamos comillas dobles. También podemos acceder a una variable con comillas simples, pero tiene que estar fuera de la comillas simples.

$name = 'Luigi';
echo "Mi nombre es $name <br>";
echo 'Mi nombre es ' . $name;

Datos complejos (Comillas dobles)

Para acceder a datos complejos como un objeto o un array con varios niveles necesitamos utilizar {} (llaves) que encierren a la variable con los parámetros que indicamos.

Se puede dar el caso de cuando es un objeto, y este solo tiene un nivel en su parámetro accedemos sin utilizar {} (llaves) y para indicar el key ponemos →, ej: $hora→segundos

$name = 'Luigi';
$courses = [
    'backend' => 'PHP'
];

echo "{$courses['backend'][0]}";

class User
{
    public $name = 'Mario';
}

$user1 = new User;

echo "<br>  $user1->name quiere aprender {$courses['backend'][0]} <br>";

Variables variables

Y si necesitamos utilizar las variables variables, lo hocemos añadiendo $ antes de las {} (llaves) para que búsque la variable variable.

La variable variable debe tener exactamente el mismo nombre que el dato que tiene la variable principal, deben coincidir tanto en lo que dice como si está en mayúscula o no.

También para hacer más legible el código podemos encerrar esta llamada a una variable dentro de otra {} (llaves). Ej: {${getLove()}}

$teacher = 'waluigi';
$waluigi = 'Profesor de moda púrpura';

echo "$teacher es ${$teacher}";

function getTeacher()
{
    return 'teacher';
}

$teacher = 'Wario';

echo "{${getTeacher()}} enseña PHP";

• Simples: usadas para textos. los caracteres. Estas no pueden obtener datos de una variable, la salida ser texto.
• Dobles: Extienden a las variables, pudiendo agregarlas a la cadena y estas serán reconocidas

<?php

/*
echo 'Un texto de una línea 
varias líneas
comilla simple \' backslash \\ continuar con mas texto
$variable';
*/

$name = "Italo Morales";
echo "<h1>Mi nombre es $name</h1>";
//Concatenar
echo '<h1>Mi nombre es ' . $name . '</h1> <br>';

//Array
$courses = [
	'backend' => [
		'PHP',
		'Laravel'
	]
];
echo "<h1>Lenguaje: {$courses['backend'][0]} </h1><br>";

//Clase
class User{
	public $name = 'Danny';
}

//Objeto
$user = new User;

echo "<h1>$user->name quiere aprender {$courses['backend'][0]} </h1><br>";

$course = ['backend' => 'PHP'];

//echo "<h1>Lenguaje: {$courses['backend']} </h1><br>";

//variables variables
$teacher = 'italo';
$italo = 'Profesor de PHP';
echo "<h1>$teacher es ${$teacher}</h1>";

//Función
function getTeacher(){
	return 'teacher';
}

$teacher = 'Italo';

echo "<h1>{${getTeacher()}} Enseña PHP</h1>";

function getTeacher()
{
    return 'teacher';
}

$teacher = 'Cristhian';

$Cristhian = 'PHP';

$PHP = 'Symfony';

echo "${getTeacher()} quiere aprender ${$teacher} para poder usar el framework de: {${${${getTeacher()}}}}. <br/>";

Output
Cristhian quiere aprender PHP para poder usar el framework de: Symfony.

Siempre me había parecido php difícil pero no lo es 💪🏼
#nuncaparesdeaprender 🔥🔥🔥

Conocer a profundidad un lenguaje nos ayuda a no “reinventar la rueda”, aprovechando todas las funciones que nos ofrece PHP.

Entre comillas simples podemos poner textos de una sola línea. Podemos escapar dos caracteres, comilla simple y diagonal invertida. Para incluir una variable se usa un punto para concaternarla a la cadena.

Con comillas dobles podemos incluir variables directamente dentro de las comillas. También podemos incluir etiquetas HTML que serán funcionales a la hora de verlo en el navegador.

Cuando se utilizan estructuras complejas o funciones dentro de las dobles comillas se tiene que poner entre llaves la expresión o variable.

✨ El símbolo \ nos permite hacer un escape para utilizar otros símbolos dentro de las comillas simples o dobles.

echo 'Este simbolo \' es una comilla simple';
echo "Este simbolo \" es una comilla doble";

Que interesante saber lo de las maneras de imprimir el resultado con comillas siples o dobles con los arrays, objetos o estructuras de datos complejos y eso de las variables variables más interesante todavía:

#cuando una estructura de datos es compleja y tiene más de un nivel usamos las llaves para escapar, para que se analicé lo que estamos mostrando y se imprima el dato.
        #ejeplo usando variables variables.
        $teacher = 'italo';
        $italo = 'Profesor de PHP';
        echo "$teacher es ${$teacher}";
        //italo es Profesor de PHP



    #Usando variables variables con una función
    function getTeacher()
    {
        return 'teacher';
    }
    $teacher = 'Italo';

    echo "{${getTeacher()}} enseña PHP.";

Mi practica de Variables variables, ¿Qué usos tendrá en proyectos reales?

$estudiante = 'Christian';
$Christian = 'Aprender';
$Aprender = 'PHP';

$PHP = 'Laravel';

echo "{$estudiante} esta dandolo todo para ${$estudiante} ${${$estudiante}} y poder llegar a ${${${$estudiante}}}";

Que buen tip el de la llaves

Excelente clase

<?php

$nombre = 'Christian';
$Christian = "Programando";

echo "$nombre hace arte  ${$nombre}</br>";
echo "${$nombre} tu puedes hacer arte";

Muy buena esta clase! No entendía lo de las variables variables hasta ahora jajaja

No me quedó tan claro lo de variable variable

Alternativa a comillas dobles:

Heredoc
sintaxis: <<<. Después de este operador, se deberá proporcionar un identificador y justo después una nueva línea. A continuación va el propio string, y para cerrar la notación se pone el mismo identificador.

$str = <<<EOD
Ejemplo de una cadena
expandida en varias líneas
empleando la sintaxis heredoc.
EOD;

Alternativa a comillas simples:

Nowdoc
Nowdoc es a los string con comillas simples lo mismo que Heredoc lo es a los string con comillas dobles.

$str = <<<'EOD’
Ejemplo de un string
expandido en varias líneas
empleando la sintaxis nowdoc.
EOD;

Nota: Los corchetes para imprimir una estructura compleja debe estar pegador a todo momento en la expresión, no es lo mismo escribir: { $courses[‘backend’][0] } que {$courses[‘backend’][0]}.

El correcto sería: {$courses[‘backend’][0]}

Se puede insertar expresiones dentro de otras expresiones

Muy bien explicado

En caso de emplear de emplear una estructura compleja emplear “{}”

Excelente!

Evaluar las comillas, cuando usar simples y cuando dobles.

Comillas:

• Simples: usadas para textos. los caracteres. Estas no pueden obtener datos de una variable, la salida ser texto.

• Dobles: Extienden a las variables, pudiendo agregarlas a la cadena y estas serán reconocidas

Si se desea imprimir datos mas complejos, se encapsulan en corchetes {$courses[‘backend’][0]}

Caracteres a escapar con comillas simples

Un ejemplo del manejo de variables variables

	$niño = 'Pedrito';
	$Pedrito = 'viaja';
	$viaja = 'escuela';
	$escuela = 'Simón Bolivar';
	echo "$niño ${$niño} a la ${${$niño}} ${${${$niño}}}";

Generando el siguiente resultado
Pedrito viaja a la escuela Simón Bolivar

Vamos a ver si entiendo, las comillas simples se utilizan para asignar valores a las variables y las doble para mostrar o imprimir contenido.

En PHP, las comillas simples (') y las comillas normales (") tienen comportamientos diferentes al momento de interpretar variables y expresiones.

• Las comillas simples (') tratan su contenido como una cadena literal y no realizan ningún tipo de interpretación. Por ejemplo:

$name = 'John';
echo 'Hola $name'; // Imprime: Hola $name

• Las comillas normales (") evalúan el contenido y reemplazan cualquier variable o expresión dentro de ellas con su valor. Por ejemplo:

$name = 'John';
echo "Hola $name"; // Imprime: Hola John

Además, las comillas normales permiten realizar operaciones aritméticas dentro de su contenido, mientras que las comillas simples no. Por ejemplo:

$num = 5;
echo "El doble de 5 es: " . 2 * $num; // Imprime: El doble de 5 es: 10
echo 'El doble de 5 es: ' . 2 * $num; // Imprime: El doble de 5 es: . 10

En resumen, se recomienda utilizar comillas simples para cadenas de texto simples y comillas normales para cadenas con contenido dinámico o operaciones aritméticas.

Pésima ruta con este profesor tan malo.😫

No me impirme en la pagina si no le pongo el string entre parentesis.

Como usar arrays en una cadena de texto.

Aqui esta mi ejercicio de la clase

• Si usamos comillas simples básicamente puedo colocar un texto de una línea, y, también puedo colocar más de una línea (varias líneas).

• Comillas dobles, Incorpora variables dentro. Las comillas dobles tienen el mismo funcionamiento que las comillas simples solo que estas no necesitan concatenar las variables porque las reconoce de por sí.

• Cuando una estructura es compleja necesitamos utilizar llaves al momento de iniciar, y al momento de finalizar.

• Cuando una estructura de datos es compleja, tiene más de un nivel utilizamos las llaves para escapar.

Comparto mi practica realizada de acuerdo a los aprendizajes de esta unidad, sin embargo, me quedo con la apreciación de que dependiendo de la lógica se usan comillas simples o dobles.

Interesante clase, dejo mi ejercicio

Hola,
Mi aportacion con los ejercicios del tema comillas.

$nom = ‘Luis’;
echo “Mi nombre es $nom <br>”;
echo 'Mi nombre es ’ . $nom;

$nom2 = ‘Pedro’;
$coursos = [ ‘backend’ => ‘PHP’ ];
echo “{$coursos[‘backend’][0]}”;

class User
{
public $name = ‘Jose’;
}
$user1 = new User;

echo “<br> $user1->nom2 quiere aprender {$courses[‘backend’][0]} <br>”;

Variables Variable-

$teacher = ‘waluigi’;
$waluigi = ‘Profesor de moda púrpura’;
echo “$teacher es ${$teacher}”;
function getTeacher()
{
return ‘teacher’;
}
$teacher = ‘Wario’;

echo " {${getTeacher()}} enseña PHP ";

Ejercicio Comillas–>

echo ’ texto a pintar ';

$pinta=‘azul’;
echo " El color es $pinta";

$musico=‘Paco’;
$instrumento=‘Percussion’;
$orquesta=‘Marabu’;
echo “$musico toca la ${$musico} en la orquesta ${${musico}}”;

Para evitar hacer lo que esta hecho, se intenta conocer el lenguaje en profundidad (Conocer soluciones ya proporcionados por el leguaje)

Comillas Doble

• Se pueden escapar dos símbolos la comilla doble (") y el backslash (\), esto anteponiendo un backslash (\)
• Con las comillas dobles SI se reconocen las variables que estén adentro de ellas

Ej:

echo "Un texto de una linea
varias líneas
comilla simple \" backslash \\ continuar con mas texto";

$name = 'Daniel';
echo "Mi nombre es $name";

Comillas Simples

• Se pueden escapar dos símbolos la comilla simple (’) y el backslash (\), esto anteponiendo un backslash (\)
• Con las comillas simples NO se reconocen las variables que estén adentro de ellas
• Para incluir variable hay que recurrir a la concatenación con punto (.)

Ej:

echo 'Un texto de una linea
varias líneas
comilla simple \' backslash \\ continuar con mas texto';

$name = 'Daniel';
echo 'Mi nombre es' . $name;

Arreglos

• Cuando una estructura es compleja se deben de utilizar llaves {} al iniciar y al finalizar
• Cuando se tiene una estructura simple o acceso rápido como $user->name no es necesario las llaves

Ej:

$courses = [
    'backend' => [
        'PHP',
        'Laravel'
    ]
];

class User {
    public $name = 'Daniel';
}

$user = new User;

echo "$user->name es el mejor programador del universo en {$courses['backend'][0]}";

Variable variables

Ej:

$teacher = 'italo';
$italo = 'PHP';
echo "$teacher es profesor de ${$teacher}";

function getTeacher() {
    return 'teacher';
}

$teacher = 'italo';
echo "${getTeacher()} enseña ${${getTeacher()}}";

** 😄 Un ejemplo con respecto al Uso de variables variables.**

<?php

/**
 * Uso de variables variables
 */

$name = 'Ramsey';
$ramsey = 'tiene un programa de tv llamado hell\'s kitchen.';
$caracter = 'mal_caracter';

echo "$name {${strtolower($name)}}";
echo "<br>";


class PersonalidadChef
{
    protected $name;
    protected $caracter;
    protected $mal_caracter = 'tiene un mal caracter xD';
    protected $buen_caracter = 'tiene un buen caracter :D';

    public function __construct($name, $caracter) {

        $this->name = $name;
        $this->caracter = $caracter;
    }

    public function getName() {
        return $this->name;
    }

    public function setName($name) {
        $this->name = $name;
    }

    public function getCaracter() {
        return $this->caracter;
    }
    
    public function getDescripcionCaracter() {
        return $this->{$this->caracter};
    }

    public function setCaracter($caracter) {
        $this->caracter = $caracter;
    }
}

$personalidadChef = new PersonalidadChef($name, $caracter);

echo "Además {$personalidadChef->getName()}, {$personalidadChef->getDescripcionCaracter()}";
echo "<br>";
 

Nunca había visto este tipo de manejo de variables y simplemente me voló la cabeza, es hermoso.

function getTeacher(){
    return 'teacher';
}

$teacher = 'Benjamin';
$Benjamin = 'PHP';
$PHP = 'Consuelo';
$Consuelo = 'Viña del Mar';

echo "${getTeacher()} enseña ${${getTeacher()}} en el Colegio ${${${getTeacher()}}} de ${${${${getTeacher()}}}} ";


Respuesta:
Benjamin enseña PHP en el Colegio Consuelo de Viña del Mar

<?php

     $b_numeros = [
         'dos' => [2,3,2,4],
         'tres' => 3
     ];

     class numbers{
        public $num1 = 2;
        public $num2 = 5;
     }
     $numbers = new numbers;
     echo $numbers->num2 + $b_numeros['dos'][3] - $numbers->num1;

Una comparacion extrana, pero se me ocurrio comparar esta sintaxis ${} con la funcion INDIRECT o INDIRECTO de Ms Excel xD

Tenemos mas de 1 forma de escribir arrays

#Primer forma
$frutas = array("pera", "manzana", "uva", 2)
#Desde este tipo podemos acceder segun el indice 

#Segunda forma
$frutas = ["Uva","Pera","Sandia"];
#Desde este tipo podemos acceder segun el indice 

#Arreglo Asociativo
$joe = array('name'=>'Jose','age'=>25,'country'=>'mexico');
#Para acceder a este tipo debemos hacerlo de lasiguente forma $nameArray['namePropiedad']

Otras formas son las Heredoc que se comporta igual a las comillas dobles y la Nowdoc que se comporta de la misma forma que las comillas simples.

Sintaxis Heredoc

$mensaje = <<<DOC
nuestro string
pueden ser varias
líneas
DOC;

echo <<<OTR
Nuestro mensaje
OTR;

Probando cositas

Resultados 😃

conocer un lenguaje en profundidad nos lleva a el área de conocer el lenguaje de manera avanzada jejejeje, cómico como empieza este vídeo. hombres con hombres mujeres con mujeres y de manera invertida

Para utilizar las variables variables en medio de una cadena de texto, entonces necesitamos usar las llaves, pero con el símbolo de dolar antes: "${$variables}" en el caso de que queramos acceder por más variables a una, entonces tendríamos que aumentar el número de los símbolos que lleva la variable, NO los corchetes

Un buen resumen para variables variables por si estan un poco perdidos como iio
https://es.stackoverflow.com/a/258450

Comillas simples

• Se muestra en una línea
• \ para escapar caracteres: \ y ‘
• Debes concatenar variables
• Lee código HTML

echo 'Texto en una linea
Comilla simple \' backslash \\';
// Texto en una linea Segunda linea Comilla simple ' backslash \

Comillas dobles

• Incorpora variables dentro

$variable = 'Julian';
echo "Mi nombre es $variable <br>";
//Mi nombre es Julian

Array

• Como es una estructura compleja (tiene más de un nivel) requiere llaves {}

$courses = [
    'backend'=> [
        'PHP',
        'Laravel'
    ]
];

echo "{$courses['backend'][0]}";
//PHP

Clases

• Es una estructura simple pero puede ser compleja dependiendo del nivel de sus atributos

class User
{
    public $name = 'italo';
}

$user = new User;

echo "$user->name quiere aprender";
//italo quiere aprender

Variables variables

• Como es una estructura compleja (tiene más de un nivel) requiere llaves {}

$teacher = 'italo';
$italo = 'Profesor de PHP';
echo "$teacher es ${$teacher}";
//italo es Profesor de PHP

• Otro ejemplo pero desde el retorno de una función:

function getTeacher()
{
    return 'teacher';
}
$teacher = 'italo';
echo "${getTeacher()} enseña PHP";
//italo enseña PHP

En estructuras un poco más complejas el código va entre llaves para que no de error:
echo “{$courses [‘backend’] [0]}”;

No me aparecen los aportes de los otros estudiantes.

    // Multiline  text and line breaks

    echo "<h3>Multiline  text and line breaks</h3>";

    $longText = "
    Hi!, my name is Luis Arturo.
    I am 27 years old and 
    i love pizza and play videogames ^_^";

    echo "<li>$longText</li>";
    echo "<li>" . nl2br($longText) . "</li>";

    /** 
     * nl2br — Inserta saltos de línea HTML antes de todas las nuevas líneas de un string
     */

    $longText = "
    Hi!, my name is <b>Luis Arturo</b>.
    I am <b>27</b> years old and 
    i love pizza and play videogames ^_^";

    echo "<li>1- $longText</li>" . PHP_EOL;
    echo "<li>2- " . nl2br($longText) . "</li>" . PHP_EOL;
    echo "<li>3- " . htmlentities($longText) . "</li>" . PHP_EOL;

    /**
     * htmlentities — Convierte todos los caracteres aplicables a entidades HTML
     * 
     * resource:
     * // https://www.php.net/manual/en/ref.strings.php
     */

    echo "<li> 4- " . nl2br(htmlentities($longText)) . "</li>" . PHP_EOL;

2. Comillas

Les comparto lo que leí de StackOverflow:

1. Single quoted strings will display things almost completely “as is.” Variables and most escape sequences will not be interpreted. The exception is that to display a literal single quote, you can escape it with a back slash \', and to display a back slash, you can escape it with another backslash \\ (So yes, even single quoted strings are parsed).
2. Double quote strings will display a host of escaped characters (including some regexes), and variables in the strings will be evaluated. An important point here is that you can use curly braces to isolate the name of the variable you want evaluated. For example let’s say you have the variable $type and you want to echo "The $types are". That will look for the variable $types. To get around this use echo "The {$type}s are" You can put the left brace before or after the dollar sign. Take a look at string parsing to see how to use array variables and such.

$s = "dollars";
echo 'This costs a lot of $s.'; // This costs a lot of $s.
echo "This costs a lot of $s."; // This costs a lot of dollars.

Además comparto el código de la clase:

<?php
/**
 * Podemos usar comillas simples o dobles
 * <br> es el salto de línea
 * podemos escapar caracteres como ' o / anteponiendo un /
 */

/*
echo 'Un texto de una línea
varias líneas
comilla simple \'
backslash \\ continuar más texto
$variable';
*/

// $name = 'Aldo';
// echo "Mi nombre es $name <br>";

// $courses = ['backend' => 'PHP'];

// class User
// {
//     public $name = "Aldo";
// }

// $user = new User;

// echo "$user->name quiere aprender {$courses['backend'][0]}";
//echo "{$courses['backend'][0]}";

$teacher = "Aldo";
$Aldo = "Profesor de PHP";
//variables variables
echo "$teacher es ${$teacher}<br>";

function getTeacher()
{
    return "teacher";
}

$teacher = "Aldo";

echo "${getTeacher()} enseña PHP";

Cabe resaltar que las variables variables no funcionan si no las mandas a llamar como se llaman exactamente, por ejemplo:

$teacher = 'Geracros';
$geracros = 'Programador de platzi';

echo "$teacher es ${$teacher}";

Esto no funciona, porque el valor de la variable ‘teacher’, esta con inicial mayuscula, y cuando mandas a llamar la variable ‘geracros’, no la encuentra porque el valor de teacher esta con inicial mayuscula.

Hay que tener cuidado con eso.

Me estuve estresando esta semana por no poder imprimir el resultado de una función adentro de una cadena y ahorita que veo la parte de variables variables me quedo de WOOOOW.

Una forma de concatenar resultados, sería:"{${yourFunction()}}"

Con las llaves incluso podemos concatenar el resultado de las funciones. Es importante notar que el resutaldo también puede utlizarse como una variable variable.

Si ya utilicé un método con -> entonces para seguir profundizando, solo necesito utilizar las llaves.

Para utilizar de un objeto algún método o utilizar alguna variable de clase o instancia, entonces podemos utilizar el símbolo de ->

Cuando queremos concatenar estructuras con complejidad, las tenemos que encerrar entre llaves.

Si quiero poner el texto un back slash,, tengo que hacerlo con doble back slash.

Para poner comillas simples dentro de comillas simples, podemos simplemente utilizar el back slash invertido justo al lado de la comilla simple.

Con el echo, se pueden conseguir imprimir varias líneas incluso con sangría.

Un dato importante sobre las comillas simples ' :

Los saltos de línea de las comillas simples también son enviados al navegador, pero el navegador no los interpreta por defecto.

Retomando el ejemplo de la clase:

<?php
echo 'Un texto de una línea
varias lineas
comilla simple \' backslash \\ continuar con mas texto
$variable <br>';

El texto es interpretado en el navegador de tal manera que aparenta no tener saltos de línea:

Pero con estilos CSS podemos hacer que nuestro navegador muestre los saltos de línea:

El navegador ignora los espacios en blanco debido a que son utilizados mayormente para dar formato al código. Hay situaciones en las que es bastante útil tener esto en mente.

| Cadenas de caracteres
Para poner caracteres especiales siempre hay que poner un backslash antes.
Siempre hace las string con comillas dobles.
Puedes poner dentro de una cadena de caracteres un signo dólar y una variable y va a ser bien interpretado por la cadena de caracteres.
Dentro de estas cadenas de caracteres hay html que puede ser interpretado por el browser.
También puedes poner variables dentro de cadenas de caracteres Cómo puede ser un array, sirve incluso Llamando a ciertos elementos de la array poniendo todo dentro de unas llaves.
Para mostrar atributos de una clase dentro de una cadena de caracteres hay que poner
instancia -> atributo
| Variables variables
Permite acceder a variables de una manera dinámica, esto es a partir de usar como nombre referencia a la primera variable definida y seleccionará una variable más abajo poniendo mayor cantidad de signos peso.
Para usarlas en cadenas de caracteres hay que poner:
${$primera_variable}

• las comillas simples son para imprimir solo texto, para agregar variables se necesita concatenar la variable al texto con un punto (.).

• las comillas dobles tienen el mismo funcionamiento que las comillas simples solo que estas no necesitan concatenar las variables porque las reconoce de por si.

• cuando te desea imprimir o mostrar variables complejas de debe colocar entre { }

Volviendo a repasar este gran curso

<code> 
<?php 

/* echo 'Hola me llamo IWA
siguiente linea
otra linea\' gaaa\\<br>'; 

$name = "IWA";

echo 'Me llamo'. $name .'<br>';
echo "Me llamo $name"; */

$courses =[
    'backend'=>[
        'php',
        'laravel',
        'js',
    ]
];

echo "{$courses['backend'][1]}\n";

$curso = ['fronted'=>'REACT.JS'];


class Usuario{
    public $name = "IWA";
}

$usuario = new Usuario;

echo "$usuario->name quiere aprender {$courses['backend'][0]}\n";

echo "$usuario->name quiere volver aprender {$curso['fronted']}\n";

$teacher = "profesor";
$profesor = "Bertila";

echo "el $teacher se apellida ${$teacher}\n";

function getTeacher(){
    return 'teacher';
}

echo "${${getTeacher()}} enseña Base de datos";

OUTPUT:
laravel
IWA quiere aprender php
IWA quiere volver aprender REACT.JS
el profesor se apellida Bertila
Bertila enseña Base de datos

En esta parte: echo "{$courses['backend'][0]}";
La pueden cambiar por: echo ($courses['backend'][0]);
En dado caso que no se las muestre en el navegador

Interesante el concepto de variable variables

+2

cambios en el reproductor. Excelente

#variables variables
function getTeacher(){
return ‘teacher’;
}
$teacher = ‘Edwar’;
echo “${getTeacher()} enseña PHP”;

Por más que lo intento no llego a comprender las varaibles variables.

Por más vuelta que le doy, lo siguiente no tiene sentido:

$teacher = 'italo';
$italo = 'Aprendiendo PHP';
echo "$teacher esta ${$teacher}";

Que tan buena practica será usar estas variables variables?

Las variables variables son nombres de variables que se pueden definir y usar dinámicamente.
Una variable variable toma el valor de una variable y lo trata como el nombre de una variable

Ejemplo:

<code>

>?php
$a = 'hola';
$$a = 'mundo';
?>
 

En el ejemplo anterior, “hola” se puede usar como el nombre de una variable utilizando dos signos de dólar. De tal manera que se han definido y almacenado dos variables en el árbol de símbolos de PHP:
$a que contiene “hola”
$hola que contiene “mundo”

Por lo cual las siguientes dos sentencias serán equivalentes:

<code> 
>?php
echo "$a ${$a}";
>?

<code> 
>?php
echo "$a $hola";
>?

Variables Variables 😱🤯

Aqui más información
https://www.php.net/manual/es/language.variables.variable.php

Muy bueno este tema
aprendí unas cuantas cosas que no sabía de las comillas, dejo apuntes.

<?php
//Variable
$value1 = 'Hernan';

//Array
$courses = [
   'backend' => [
      'PHP',
      'Laravel',
   ]
];

//Objeto
class User
{
   public $fullName = 'Hernan Arica';
}

//Array
$courses2 = ['frontend' => 'JavaScript'];

//Acceso dinámico
$dev    = 'hernan';
$hernan = 'Desarrollador javascript';

// Imprimiendo con comillas simples.
echo 'Un texto de una linea
Un texto de varias lineas.\' backslash \\ $value1 <br>';

// Imprimiendo con comillas dobles.
echo "Mi nombre es $value1 <br>";

// Imprimiendo valores de un array.
// nota: Cuando la estructura de nuestra variable es compleja debemos usar llaves { $variable } ya que sino nos da error.
echo "{$courses['backend'][0]} <br>";
echo "{$courses['backend'][1]} <br>";

// Imprimiendo valores de un objeto.
$user = new User;
echo "$user->fullName quiere aprender {$courses['backend'][0]} <br>";

// Imprimiendo valores de un Array.
echo "$user->fullName quiere aprender {$courses2['frontend']} <br>";

// Imprimiendo variables con acceso dinámico con ${ $variable }
echo "$dev es ${$dev} <br>";

// Imprimiendo funciones que retornan un valor con {${ functionName() }}
function printDev()
{
   return 'dev';
}

echo "{${printDev()}} es un desarrollador javascript"; // De esta manera mostramos valores que retorna una función.

Me sale error que la variable no esta definida alguien me da una idea?

'
"

Ya tengo tiempo usando PHP y no conocía Variables variables 😮

hola, pero si yo escribo solo el backslash igual me lo imprime, no necesito escribir 2,

Alguien tiene un ejemplo práctico de ponerle a una variable el nombre con el valor de otra para de esa forma accederla? Realmente lo veo confuso y me parece muchísimo más práctico la manera como trabajamos en Javascript.

Las llaves {} es ocupan para analizar y escapar estructuras de datos un poco más complejas

interesante el uso de variables variables con funciones, eso si no lo había visto… aumenta mas posibilidades de uso…