php - quitar - strip_tags wordpress

¿Cuál es la mejor manera de agregar dos cadenas juntas?

Question

Leí en algún lugar (pensé en codificar el horror) que es una mala práctica agregar cadenas como si fueran números, ya que los números similares no se pueden cambiar. Por lo tanto, agregarlos juntos crea una nueva cadena. Entonces, me preguntaba, ¿cuál es la mejor manera de sumar dos cadenas cuando se enfoca en el rendimiento?

¿Cuál de estos cuatro es mejor, o hay otra manera que sea mejor?

//Note that normally at least one of these two strings is variable
$str1 = ''Hello '';
$str2 = ''World!''; 
$output1 = $str1.$str2; //This is said to be bad

$str1 = ''Hello '';
$output2 = $str1.''World!''; //Also bad

$str1 = ''Hello'';
$str2 = ''World!'';
$output3 = sprintf(''%s %s'', $str1, $str2); //Good?
//This last one is probaply more common as:
//$output = sprintf(''%s %s'', ''Hello'', ''World!'');

$str1 = ''Hello '';
$str2 = ''{a}World!'';
$output4 = str_replace(''{a}'', $str1, $str2);

¿Incluso importa?

Answer 1

A menos que su gran cantidad de texto no importe realmente.

Answer 2

Aquí está el código de prueba rápido y sucio, para comprender los cuellos de botella de rendimiento.

Solo concat:

$iterations = 1000000;
$table = ''FOO'';
$time = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
        $sql = sprintf(''DELETE FROM `%s` WHERE `ID` = ?'', $table);
}
echo ''single sprintf,'',(microtime(true) - $time)."/n";

$time = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
        $sql = ''DELETE FROM `'' . $table . ''` WHERE `ID` = ?'';
}
echo ''single concat,'',(microtime(true) - $time)."/n";

$time = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
        $sql = "DELETE FROM `$table` WHERE `ID` = ?";
}
echo ''single "$str",'',(microtime(true) - $time)."/n";

Obtengo estos resultados:

single sprintf,0.66322994232178
single concat,0.18625092506409 <-- winner
single "$str",0.19963216781616

Muchos concats (10):

$iterations = 1000000;
$table = ''FOO'';
$time = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
        $sql = sprintf(''DELETE FROM `%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s` WHERE `ID` = ?'', $table, $table, $table, $table, $table, $table, $table, $table, $table, $table);
}
echo ''many sprintf,'',(microtime(true) - $time)."/n";

$time = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
        $sql = ''DELETE FROM `'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''`,`'' . $table . ''` WHERE `ID` = ?'';
}
echo ''many concat,'',(microtime(true) - $time)."/n";

$time = microtime(true);
for ($i = 0; $i < $iterations; $i++) {
        $sql = "DELETE FROM `$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table` WHERE `ID` = ?";
}
echo ''many "$str",'',(microtime(true) - $time)."/n";

Resultados:

many sprintf,2.0778489112854
many concats,1.535336971283
many "$str",1.0247709751129 <-- winner

Como conclusión, se vuelve obvio que solo concat vía punto (.) Char es el más rápido. Y para los casos, cuando tienes muchos concats, el mejor método es utilizar la inyección directa de cadenas mediante la sintaxis de "injection: $inject" .

Answer 3

Como decían los demás, $str1 . $str2 $str1 . $str2 está perfectamente bien en la mayoría de los casos, excepto en los bucles (grandes).
Tenga en cuenta que pasa por alto algunas soluciones:

$output = "$str1$str2";

y para un gran número de cadenas, puede colocarlas en una matriz y usar implode () para obtener una cadena de ellas.

Ah, y "agregar cadenas" suena mal, o al menos ambiguo. En la mayoría de los idiomas, preferimos hablar de concatenación de cuerdas.

Answer 4

Durante casi 2 años después de la última publicación en este hilo, creo que la solución a continuación puede ser la más rápida para una gran cantidad de bucles ajustados:

ob_start();

echo $str1;
echo $str2;
.
.
.
echo $str_n;

$finalstr = ob_get_clean();

Este método garantiza un almacenamiento plano de todas las cadenas y sin sobrecarga de procesamiento o concatenación. Con la línea de código final, también obtienes un búfer completo. Puede ejecutar con seguridad bucles en lugar de ecos independientes.

Answer 5

Encontré esta publicación de Google y pensé que iba a realizar algunos puntos de referencia, ya que tenía curiosidad por cuál sería el resultado. (Evaluó más de 10,000 iteraciones usando un punto de referencia que resta sus propios gastos generales).

Which 2 strings 10 strings 50 strings ---------------------------------------------------------------- $a[] then implode() 2728.20 ps 6.02 μs 22.73 μs $a . $a . $a 496.44 ps 1.48 μs 7.00 μs $b .= $a 421.40 ps ★ 1.26 μs 5.56 μs ob_start() and echo $a 2278.16 ps 3.08 μs 8.07 μs "$a$a$a" 482.87 ps 1.21 μs ★ 4.94 μs ★ sprintf() 1543.26 ps 3.21 μs 12.08 μs

Así que no hay mucho en ello. Probablemente sea bueno evitar el sprintf() y el implode() si necesitas algo para gritar rápido, pero no hay mucha diferencia entre todos los métodos habituales.

Answer 6

Es posible que los consejos que ha leído estén relacionados con la función de echo , por lo que es más rápido usar comas, por ejemplo:

echo $str1, $str2;

Otro enfoque es construir una cadena en una variable (por ejemplo, usar el operador.) Y luego hacer eco de toda la cadena al final.

Puede probar esto usted mismo usando la función de microtiempo (necesitará hacer un bucle que se repita, por ejemplo, 1,000 o 100,000 veces para que los números sean significativos) Pero de los cuatro que publicaste, es probable que el primero sea el más rápido. También es el más legible: los demás no tienen sentido programáticamente.

Answer 7

Esta no es una solución para 2 cadenas, pero cuando estás pensando en unir más cuerdas de esta manera:

$tmp=srray();
for(;;) $tmp[]=''some string'';
$str=implode('''',$tmp);

Es más rápido crear un elemento de matriz y unirlos todos a la vez, que unirlos cientos de veces.

Answer 8

Hay 3 tipos de operaciones de unión de cadenas.

Concatene, tome 2 cadenas, asigne el tamaño de memoria longitud1 + longitud2 y copie cada una en la nueva memoria. Más rápido para 2 cuerdas. Sin embargo, concatenar 10 cadenas requiere 9 operaciones concat. La memoria utilizada es la primera cadena 10 veces, la segunda cadena 10 veces, la tercera cadena 9 veces, la cuarta cadena 8 veces, etc. Ejecuta X + 1 + (X-1) * 2 operaciones usando más memoria en cada ciclo.

sprintf (array_merge, join, etc.), tome todas las cadenas juntas, sume su longitud, asigne una nueva cadena de suma de tamaño, luego copie cada cadena en su lugar respectivo. la memoria utilizada es 2 * longitud de todas las cadenas iniciales, y las operaciones son 2 * X (cada longitud, cada copia)

ob (buffer de salida) asigna un fragmento genérico de 4k y le copia cada cadena. memoria 4k + cada cadena inicial, operaciones = 2 + X. (inicio, final, cada copia)

Elige tu veneno. OB es como usar una bomba atómica de memoria para unir 2 cadenas pequeñas, pero es muy efectivo cuando hay muchas combinaciones, bucles, condiciones o las adiciones son demasiado dinámicas para un sprintf limpio. concat es el más eficaz para unir algunas cadenas fijas, sprintf, que funciona mejor para construir una cadena a partir de valores fijos al mismo tiempo.

No sé qué rutinas usa php en esta situación: "$ x $ y $ z", podría reducirse a un $ x en línea. "". $ y. "". $ z

Answer 9

La concatenación de cadenas con un punto es definitivamente el más rápido de los tres métodos. Siempre crearás una nueva cadena, te guste o no. Lo más probable es que la forma más rápida sería:

$str1 = "Hello";
$str1 .= " World";

No los ponga en comillas dobles como $result = "$str1$str2"; ya que esto generará una sobrecarga adicional para analizar los símbolos dentro de la cadena.

Si va a usar esto solo para la salida con eco, entonces use la función de eco para poder pasarle varios parámetros, ya que esto no generará una nueva cadena:

$str1 = "Hello";
$str2 = " World";
echo $str1, $str2;

Para obtener más información sobre cómo PHP trata las cadenas interpoladas y la concatenación de cadenas, consulte el blog de Sarah Goleman .

Answer 10

No importa a menos que se use en un bucle looong. En los casos habituales, céntrese en la legibilidad del código, incluso si pierde varios ciclos de procesador.

Los ejemplos 1 y 2 son similares, no creo que deba haber mucha diferencia, esto sería el ayuno de todos. El número 1 podría ser un poco más rápido.

El ejemplo 3 será más lento, ya que es necesario analizar el formato sprintf (''% s% s'').

El Ejemplo 4 hace el reemplazo, lo que implica buscar dentro de una cadena; algo adicional que hacer, toma más tiempo.

Pero, en primer lugar, ¿concatenar cadenas es un problema de rendimiento? Es muy poco probable que debas usar un código de perfil para medir cuánto tiempo se tarda en ejecutarlo. Luego, reemplaza el método de concatenación con uno diferente y vuelve a hacerlo.

Si lo identifica como un problema, intente buscar en Google para la clase php string builder (hay algunos que se pueden encontrar) o escriba uno propio.

Answer 11

No soy un gurú de PHP, sin embargo, en muchos otros idiomas (por ejemplo, Python), la forma más rápida de construir una cadena larga a partir de muchas cadenas más pequeñas es agregar las cadenas que desea concatenar a una lista y luego unirlas. utilizando un método de unión incorporado. Por ejemplo:

$result = array();
array_push("Hello,");
array_push("my");
array_push("name");
array_push("is");
array_push("John");
array_push("Doe.");
$my_string = join(" ", $result);

Si está construyendo una cadena enorme en un bucle estrecho, la forma más rápida de hacerlo es agregar la matriz y luego unirla al final.

Nota: toda esta discusión depende del rendimiento de un array_push. Debe agregar sus cadenas a una lista para que esto sea efectivo en cadenas muy grandes. Debido a mi exposición limitada a php, no estoy seguro de si tal estructura está disponible o si la matriz de php es rápida para agregar nuevos elementos.

Answer 12

Siempre va a crear una nueva cadena cuando concatene dos o más cadenas juntas. Esto no es necesariamente "malo", pero puede tener implicaciones de rendimiento en ciertos escenarios (como miles / millones de concatenaciones en un circuito cerrado). No soy un tipo de PHP, por lo que no puedo darte ningún consejo sobre la semántica de las diferentes formas de concatenar cadenas, pero para una sola cadena de concatenación (o solo unas pocas), solo hazlo legible. No va a ver un impacto de rendimiento de un número bajo de ellos.