recorrer - ¿Las cadenas de php son inmutables?

string to array php

Question

O bien, ¿debería optimizar mis operaciones de cadena en PHP? Traté de preguntar el manual de PHP al respecto, pero no obtuve ninguna pista sobre nada.

Answer 1

Un Google rápido parece sugerir que son mutables, pero la práctica preferida es tratarlos como inmutables.

Answer 2

PHP ya lo optimiza: las variables se asignan utilizando copy-on-write , y los objetos se pasan por referencia. En PHP 4 no es así, pero nadie debería usar PHP 4 para el nuevo código de todos modos.

Answer 3

Las cadenas de PHP son inmutables.

Prueba esto:

 $a="string";
echo "<br>$a<br>";
echo str_replace(''str'',''b'',$a);
echo "<br>$a";

Echo:

string
bing
string

Si una cuerda era mutable, habría seguido mostrando "bing".

Answer 4

Las matrices y cadenas tienen un comportamiento de copiado en escritura. Son mutables, pero cuando los asigna a una variable, inicialmente esa variable contendrá la misma instancia exacta de la cadena o matriz. Solo cuando modifica la matriz o cadena se realiza una copia.

Ejemplo:

$a = array_fill(0, 10000, 42); //Consumes 545744 bytes
$b = $a; // " 48 "
$b[0] = 42; // " 545656 "
$s = str_repeat('' '', 10000); // " 10096 "
$t = $s; // " 48 "
$t[0] = ''!''; // " 10048 "

Answer 5

Una de las técnicas de optimización de velocidad más importantes en muchos idiomas es la reutilización de instancias. En ese caso, el aumento de velocidad proviene de al menos 2 factores:

1. Menos instancias significa menos tiempo dedicado a la construcción.

2. Cuanto menor sea la cantidad de memoria que utiliza la aplicación, menos errores de caché de la CPU probablemente haya.

Para las aplicaciones, donde la velocidad es la prioridad número 1, existe un cuello de botella realmente apretado entre la CPU y la RAM. Una de las razones del cuello de botella es la latencia de la memoria RAM.

El PHP, Ruby, Python, etc., están relacionados con los fallos de caché por el hecho de que incluso almacenan al menos algunos (probablemente todos) los datos de tiempo de ejecución de los programas interpretados en la RAM.

La creación de instancias de cadenas es una de las operaciones que se realiza con bastante frecuencia, en relativamente "grandes cantidades", y puede tener un impacto notable en la velocidad.

Aquí hay un run_test.bash de un experimento de medición:

#!/bin/bash
for i in `seq 1 200`;
do
/usr/bin/time -p -a -o ./measuring_data.rb php5 ./string_instantiation_speedtest.php
done

Aquí están los ./string_instantiation_speedtest.php y los resultados de la medición:

<?php
// The comments on the
// next 2 lines show arithmetic mean of (user time + sys time) for 200 runs.
$b_instantiate=False; // 0.1624 seconds
$b_instantiate=True; // 0.1676 seconds
// The time consumed by the reference version is about 97% of the
// time consumed by the instantiation version, but a thing to notice is
// that the loop contains at least 1, probably 2, possibly 4,
// string instantiations at the array_push line.
$ar=array();
$s=''This is a string.'';
$n=10000;
$s_1=NULL;
for($i=0;$i<$n;$i++) {
if($b_instantiate) {
$s_1=''''.$s;
} else {
$s_1=&$s;
}
// The rand is for avoiding optimization at storage.
array_push($ar,''''.rand(0,9).$s_1);
} // for
echo($ar[rand(0,$n)]."/n");
?>

Mi conclusión de este experimento y de otro experimento que hice con Ruby 1.8 es que tiene sentido pasar los valores de cadena por referencia.

Una forma posible de permitir que "pass-strings-by-reference" tenga lugar en todo el ámbito de la aplicación es crear consistentemente una nueva instancia de cadena, siempre que se necesite usar una versión modificada de una cadena.

Para aumentar la localidad, por lo tanto, la velocidad, se puede querer disminuir la cantidad de memoria que cada uno de los operandos consume. El siguiente experimento demuestra el caso de concatenaciones de cadenas:

<?php
// The comments on the
// next 2 lines show arithmetic mean of (user time + sys time) for 200 runs.
$b_suboptimal=False; // 0.0611 seconds
$b_suboptimal=True; // 0.0785 seconds
// The time consumed by the optimal version is about 78% of the
// time consumed by the suboptimal version.
//
// The number of concatenations is the same and the resultant
// string is the same, but what differs is the "average" and maximum
// lengths of the tokens that are used for assembling the $s_whole.
$n=1000;
$s_token="This is a string with a Linux line break./n";
$s_whole='''';
if($b_suboptimal) {
for($i=0;$i<$n;$i++) {
$s_whole=$s_whole.$s_token.$i;
} // for
} else {
$i_watershed=(int)round((($n*1.0)/2),0);
$s_part_1='''';
$s_part_2='''';
for($i=0;$i<$i_watershed;$i++) {
$s_part_1=$s_part_1.$i.$s_token;
} // for
for($i=$i_watershed;$i<$n;$i++) {
$s_part_2=$s_part_2.$i.$s_token;
} // for
$s_whole=$s_part_1.$s_part_2;
} // else
// To circumvent possible optimization one actually "uses" the
// value of the $s_whole.
$file_handle=fopen(''./it_might_have_been_a_served_HTML_page.txt'',''w'');
fwrite($file_handle, $s_whole);
fclose($file_handle);
?>

Por ejemplo, si uno ensambla páginas HTML que contienen una cantidad considerable de texto, entonces puede que desee pensar sobre el orden, cómo se unen las diferentes partes del HTML generado.

Está disponible una implementación de PHP con licencia de BSD y la implementación de Ruby del algoritmo de concatenación de cadenas de líneas divisorias de aguas. El mismo algoritmo puede (he sido yo) generalizar para acelerar la multiplicación de enteros de precisión arbitrarios.