(PHP 4, PHP 5, PHP 7)

str_replace - Substitui todas as ocorrências da string de pesquisa por uma string de substituição

Descrição

Esta função retorna uma string ou array com todas as ocorrências de pesquisa no assunto substituídas por substituir.

Se você não precisa de regras complexas de pesquisa / substituição (por exemplo, expressões regulares), esta função é preferida. preg_replace ().

Lista de Parâmetros

Se pesquisar e substituir forem matrizes, então str_replace () usa cada valor da matriz correspondente para pesquisar e substituir no assunto. Se a matriz de substituição tiver menos elementos do que a pesquisa, uma string vazia será usada como string de substituição para os valores restantes. Se a pesquisa for uma matriz e a substituição for uma string, essa string de substituição será usada para cada elemento na matriz de pesquisa. O caso oposto não faz sentido.

Se pesquisar ou substituir forem matrizes, seus elementos serão processados ​​do primeiro ao último.

O valor a procurar, também conhecido como agulha(agulha). Para um conjunto de valores desejados, você pode usar uma matriz.

Substituir

O valor de substituição será usado para substituir a pesquisa de valores de pesquisa. Para vários valores, você pode usar uma matriz.

Sujeito

A string ou matriz a ser pesquisada e substituída, também conhecida como palheiro(uma pilha de feno).

Se o assunto for uma matriz, a pesquisa de substituição será realizada em cada elemento do assunto, e a função também retornará uma matriz.

Se aprovado, será definido com o número de substituições feitas.

Valores de retorno

Esta função retorna uma string ou array com valores substituídos.

Exemplos de

Exemplo # 1 Exemplos de uso str_replace ()

// atribui
$ bodytag = str_replace ("% body%", "preto", " " );

// atribui: Hll Wrld f PHP
$ vogais = array ("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
$ onlyconsonants = str_replace ($ vowels, "", "Hello World of PHP");

// atribui: você deve comer pizza, cerveja e sorvete todos os dias
$ frase = "Você deve comer frutas, vegetais e fibras todos os dias.";
$ healthy = array ("frutas", "vegetais", "fibras");
$ yummy = array ("pizza", "cerveja", "sorvete");

$ newphrase = str_replace ($ healthy, $ yummy, $ frase);

// atribui: 2
$ str = str_replace ("ll", "", "bom Deus, senhorita molly!", $ count);
echo $ count;
?>

Exemplo # 2 Exemplos de truques potenciais com str_replace ()

// Ordem de substituição
$ str = "Linha 1 \ nLinha 2 \ rLinha 3 \ r \ nLinha 4 \ n";
$ order = array ("\ r \ n", "\ n", "\ r");
$ replace = "
" ;

// Processa \ r \ n primeiro para evitar substituí-los novamente.
echo $ newstr = str_replace ($ pedido, $ substituir, $ str);

// Imprime F, porque A é substituído por B, então B por C e assim por diante ...
// Como resultado, E será substituído por F, já que a substituição é da esquerda para a direita.
$ search = array ("A", "B", "C", "D", "E");
$ substituir = array ("B", "C", "D", "E", "F");
$ subject = "A";
echo str_replace ($ search, $ replace, $ subject);

// Resultados: noz de maçã e noz (pelo motivo acima)
$ letras = array ("i", "o");
$ fruta = array ("maçã", "noz");
$ text = "Estou prestes a";
$ output = str_replace ($ letters, $ fruit, $ text);
echo $ output;
?>

Notas (editar)

Comente: Esta função é segura para o processamento de dados em formato binário.

Aviso

Nota de Substituição

Porque str_replace () realiza a substituição da esquerda para a direita, então ao usar várias substituições, pode substituir o valor inserido anteriormente por outro. Veja também exemplos nesta página.

Comente:

Esta função diferencia maiúsculas de minúsculas. Usar str_ireplace () para uma substituição insensível a maiúsculas e minúsculas.

Comente: PHP 7.0.0 em plataformas de 64 bits não tem nenhum limite de comprimento de string alcançável, em sistemas de 32 bits e anteriores Versões PHP, as linhas não podem ter mais de 2 GB (2147483647 bytes).

Sintaxe

Uma string pode ser especificada por quatro jeitos diferentes:

• aspas simples
• aspas duplas
• sintaxe nowdoc (desde PHP 5.3.0)

Aspas simples

A maneira mais simples definir uma string é colocá-la entre aspas simples (o " ).

Para usar aspas simples em uma string, faça o escape com uma barra invertida ( \ ) Se você precisar escrever a própria barra invertida, duplique-a ( \\ ) Todos os outros usos da barra invertida serão interpretados como caracteres normais, o que significa que se você tentar usar outras sequências de escape, como \ r ou \ n, eles serão exibidos como estão, em vez de qualquer comportamento especial.

eco "esta é uma string simples";

eco "Você também pode inserir em linhas
caractere de nova linha como este,
isto é normal";

// Saídas: Arnold disse uma vez "Eu" voltarei "
eco "Arnold disse uma vez:" Eu voltarei ";

Eco "Você removeu C: \\ *. *?";

// Saídas: Você removeu C: \ *. *?
echo "Você removeu C: \ *. *?" ;

// Saídas: não serão expandidas: \ n nova linha
eco "Isso não será expandido: \ n nova linha";

// Saídas: Variáveis ​​$ expandem também $ ou não expandidas
eco "Variáveis ​​$ expandem também não $ expandem";
?>

Aspas duplas

Se uma string estiver entre aspas duplas ("), o PHP reconhece as seguintes sequências de escape para caracteres especiais:

Sequências de escape

Subsequência	Significado
\ n	nova linha (LF ou 0x0A (10) em ASCII)
\ r	retorno de carro (CR ou 0x0D (13) em ASCII)
\ t	guia horizontal (HT ou 0x09 (9) em ASCII)
\ v	aba vertical (VT ou 0x0B (11) em ASCII) (desde PHP 5.2.5)
\ e	caractere de escape (ESC ou 0x1B (27) em ASCII) (desde o PHP 5.4.4)
\ f	feed de página (FF ou 0x0C (12) em ASCII) (desde PHP 5.2.5)
\\	barra invertida
\$	cifrão
\"	citação dupla
\{1,3}	uma sequência de caracteres que correspondem a um caractere de expressão regular em octal que transborda silenciosamente para caber em um byte (ou seja, "\ 400" === "\ 000")
\ x (1,2)	uma sequência de caracteres correspondendo a um caractere de expressão regular em notação hexadecimal
\ u (+)	uma sequência de caracteres correspondendo a um regex de caractere Unicode que mapeia para uma string em notação UTF-8 (adicionado no PHP 7.0.0)

Como acontece com uma string entre aspas simples, o escape de qualquer caractere também produzirá o próprio caractere de escape. Antes do PHP 5.1.1, barra invertida em \ ($ var) não foi impresso.

Heredoc

A terceira maneira de definir strings é usando a sintaxe heredoc: <<< ... Após este operador, você deve especificar um identificador e, em seguida, uma alimentação de linha. Depois vem a própria linha, e depois o mesmo identificador que fecha o insert.

Linha deve comece com um identificador de fechamento, ou seja, deve estar na primeira coluna da linha. Além disso, o identificador deve seguir as mesmas regras de nomenclatura que todas as outras tags em PHP: conter apenas caracteres alfanuméricos e um sublinhado, e não deve começar com um número (sublinhados são permitidos).

Atenção

É muito importante observar que a linha com o identificador de fechamento não deve conter nenhum outro caractere, com exceção do ponto-e-vírgula ( ; ) Isso significa que o identificador não deve ser indentado e que não pode haver espaços ou tabulações antes ou depois do ponto-e-vírgula. Também é importante entender que o primeiro caractere antes do identificador de fechamento deve ser um caractere de nova linha, conforme definido pelo sistema operacional. Por exemplo, em sistemas UNIX, incluindo macOS, isso é \ n... Uma nova linha também deve começar imediatamente após o identificador de fechamento.

Se esta regra for violada e o identificador de fechamento não estiver "limpo", o identificador de fechamento será considerado ausente e o PHP continuará a procurá-lo. Se, neste caso, o identificador de fechamento correto ainda não for encontrado, isso causará um erro de análise com um número de linha no final do script.

Exemplo # 1 Exemplo de sintaxe incorreta

classe foo (
public $ bar =<<Barra
EOT;
// recuo antes do identificador de fechamento não é permitido
}
?>

Exemplo # 2 Exemplo de sintaxe correta

classe foo (
public $ bar =<<Barra
EOT;
}
?>

Heredoc não pode ser usado para inicializar campos de classe. Desde o PHP 5.3, esta limitação só se aplica a heredocs contendo variáveis.

O texto heredoc se comporta da mesma forma que uma string entre aspas duplas, sem tê-los. Isso significa que você não precisa de aspas de escape no heredoc, mas ainda pode usar as sequências de escape acima. Variáveis ​​são processadas, mas ao usar variáveis ​​complexas dentro do heredoc, você precisa ser tão cuidadoso quanto ao trabalhar com strings.

Exemplo # 3 Exemplo de definição de uma string heredoc

$ str =<<Linha de exemplo,
abrangendo várias linhas,
usando a sintaxe heredoc.
EOD;

Classe foo
{
var $ foo;
var $ bar;

Função __construct ()
{
$ this -> foo = "Foo";
$ this ->
}
}

$ foo = novo foo ();
$ name = "Nome";

eco<<Meu nome é "$ name". Estou digitando $ foo -> foo .
Agora eu trago($ foo -> bar [1]) .
Isso deve resultar em um "A" maiúsculo: \ x41
EOT;
?>

Meu nome é "Imarek". Estou digitando Foo. Agora, estou exibindo Bar2. Isso deve resultar em um "A" maiúsculo: A

Também é possível usar a sintaxe heredoc para passar dados por meio de argumentos de função:

A partir da versão 5.3.0, tornou-se possível inicializar variáveis ​​estáticas e propriedades / constantes de classe usando a sintaxe heredoc:

Exemplo # 5 Usando heredoc para inicializar variáveis ​​estáticas

// Variáveis ​​estáticas
função foo ()
{
static $ bar =<<Não há nada aqui...
RÓTULO;
}

// Constantes / propriedades da classe
classe foo
{
const BAR =<<Um exemplo de uso de uma constante
FOOBAR;

Público $ baz =<<Exemplo de uso de um campo
FOOBAR;
}
?>

A partir do PHP 5.3.0, você também pode colocar o identificador Heredoc entre aspas duplas:

Nowdoc

Nowdoc é igual para strings entre aspas simples e heredoc é para strings entre aspas duplas. Nowdoc é como heredoc, mas dentro dele nenhuma substituição é realizada... Essa construção é ideal para incorporar código PHP ou outros grandes blocos de texto sem a necessidade de escape. Nesse aspecto, é um pouco como a construção SGML. declarando um bloco de texto a não ser processado.

Nowdoc é indicado pela mesma sequência <<< , que é usado no heredoc, mas o identificador que o segue é colocado entre aspas simples, por exemplo, <<<"EOT" ... Todas as condições que se aplicam a identificadores heredoc também se aplicam a nowdoc, especialmente aquelas relacionadas ao identificador de fechamento.

Exemplo # 7 Exemplo usando nowdoc

eco<<<"EOD"
Texto de amostra,
abrangendo várias linhas,
usando a sintaxe nowdoc. Barras invertidas são sempre tratadas literalmente,
por exemplo, \\ e \ ".
EOD;

O resultado deste exemplo:

Texto de amostra abrangendo várias linhas usando a sintaxe nowdoc. As barras invertidas são sempre tratadas literalmente, por exemplo, \\ e \ ".

Exemplo # 8 Exemplo de citação de string Nowdoc com variáveis

/ * Exemplo mais complexo com variáveis. * /
classe foo
{
public $ foo;
public $ bar;

Função __construct ()
{
$ this -> foo = "Foo";
$ this -> bar = array ("Bar1", "Bar2", "Bar3");
}
}

$ foo = novo foo ();
$ name = "Nome";

eco<<<"EOT"
Meu nome é "$ name". Estou digitando $ foo-> foo.
Agora estou digitando ($ foo-> bar).
Isso não deve imprimir um "A" maiúsculo: \ x41
EOT;
?>

O resultado deste exemplo:

Meu nome é "$ name". Estou digitando $ foo-> foo. Agora estou digitando ($ foo-> bar). Isso não deve imprimir um "A" maiúsculo: \ x41

Exemplo # 9 Exemplo de uso de dados estáticos

classe foo (
public $ bar =<<<"EOT"
Barra
EOT;
}
?>

Comente:

Suporte para Nowdoc foi adicionado no PHP 5.3.0.

Manipulação de variável

Se a string for especificada entre aspas duplas ou usando heredoc, as variáveis ​​dentro dela são processadas.

Existem dois tipos de sintaxe: simples e complexa. A sintaxe simples é mais fácil e conveniente. Torna possível processar uma variável, o valor de um array ( variedade) ou propriedades do objeto ( objeto) com um mínimo de esforço.

A sintaxe complexa pode ser identificada pelas chaves ao redor da expressão.

Sintaxe simples

Se o intérprete encontrar um cifrão ( $ ), ele pega o máximo de caracteres possível para formar o nome de variável correto. Se você quiser definir precisamente o final de um nome, coloque o nome da variável entre chaves.

$ suco = "maçã";

echo "Ele bebeu um pouco de suco de $." ... PHP_EOL;

// Incorreta. "s" é um caractere válido para o nome de uma variável, mas a variável é chamada $ juice.
echo "Ele bebeu um pouco de suco feito de $ sucos." ;

// Correto. O final do nome da variável é estritamente especificado usando parênteses:
echo "Ele bebeu um pouco de suco feito de $ (suco) s." ;
?>

O resultado deste exemplo:

Ele bebeu um pouco de suco de maçã. Ele bebeu um pouco de suco feito de. Ele bebeu um pouco de suco feito de maçãs.

O elemento da matriz ( variedade) ou propriedade do objeto ( objeto) Em índices de matriz, o colchete de fechamento ( ] ) denota o fim da definição do índice. As mesmas regras se aplicam às propriedades do objeto e às variáveis ​​simples.

Exemplo # 10 Exemplo de sintaxe simples

define ("KOOLAID", "koolaid1");
$ juices = array ("maçã", "laranja", "koolaid1" => "roxo");

echo "Ele bebeu suco de $ juices [0]." ... PHP_EOL;
echo "Ele bebeu alguns sucos de $ [1] suco." ... PHP_EOL;
echo "Ele bebeu suco de $ sucos [koolaid1]." ... PHP_EOL;

pessoas da classe (
public $ john = "John Smith";
public $ jane = "Jane Smith";
public $ robert = "Robert Paulsen";

Público $ smith = "Smith";
}

$ pessoas = novas pessoas ();

echo "$ people -> john bebeu suco de $ juices [0]." ... PHP_EOL;
echo "$ people -> john então disse olá para $ people -> jane." ... PHP_EOL;
echo "$ people -> a esposa de john" cumprimentou $ people -> robert. ". PHP_EOL;
echo "$ people -> robert cumprimentou os dois $ people -> smiths." ; // Não funciona
?>

O resultado deste exemplo:

Ele bebeu um pouco de suco de maçã. Ele bebeu um pouco de suco de laranja. Ele bebeu um pouco de suco roxo. John Smith bebeu um pouco de suco de maçã. John Smith então disse olá para Jane Smith. A esposa de John Smith cumprimentou Robert Paulsen. Robert Paulsen cumprimentou os dois.

PHP 7.1.0 adiciona suporte para negativoíndices numéricos.

Exemplo # 11 Índices numéricos negativos

$ string = "string";
eco "O personagem com índice -2 é$ string [- 2]. ", PHP_EOL;
$ string [- 3] = "o";
eco "Alterar o caractere na posição -3 para" o "fornece a seguinte linha:$ string. ", PHP_EOL;
?>

O resultado deste exemplo:

O personagem com índice -2 é n. Mudar o caractere na posição -3 para "o" dá a seguinte linha: forte

Para algo mais complexo, use sintaxe complexa.

Sintaxe complexa (ondulada)

É denominado difícil não porque seja difícil de entender, mas porque permite o uso de expressões complexas.

Qualquer variável escalar, elemento de matriz ou propriedade de objeto mapeada para uma string pode ser representada em uma string com esta sintaxe. Basta escrever a expressão da mesma forma que fora da linha e, em seguida, colocá-la entre { e } ... Na medida em que { não pode ser escapado, esta sintaxe só será reconhecida quando $ segue imediatamente após { ... Usar {\$ imprimir {$ ... Alguns exemplos ilustrativos:

// Mostrar todos os erros
relatório_de_erro (E_ALL);

$ ótimo = "ótimo";

// Não funciona, gera: Isso é (ótimo)
echo "Isto é ($ ótimo)";

// Funciona, produz: isso é ótimo
echo "Isto é ($ ótimo)";

// Trabalho
eco "Este quadrado é largo($ quadrado -> largura) 00 centímetros. ";

// Funciona, as chaves entre aspas só funcionam com a sintaxe de chaves
echo "Isso funciona: ($ arr [" key "])";

// Trabalho
echo "Isso funciona: ($ arr [4] [3])";

// Isso está incorreto pelo mesmo motivo que $ foo fora
// cordas. Em outras palavras, ainda funcionará.
// mas como o PHP procura pela constante foo primeiro, isso irá chamar
// Erro de nível E_NOTICE (constante indefinida).
eco "Não é certo:($ arr [foo] [3]) ";

// Trabalho. Ao usar matrizes multidimensionais internamente
// strings sempre usam colchetes
echo "Isso funciona: ($ arr [" foo "] [3])";

// Trabalho.
echo "Isso funciona:". $ arr ["foo"] [3];

eco "Isso também funciona:($ obj -> valores [3] -> nome) ";

eco "Este é o valor da variável por nome$ name: ($ ($ name)) ";

eco "Este é o valor da variável por nome que a função getName () retorna:($ (getName ())) ";

eco "Este é o valor da variável por nome que \ $ object-> getName () retorna:($ ($ object -> getName ())) ";

// Não funciona, gera: Isto é o que getName () retorna: (getName ())
eco "Isto é o que getName () retorna: (getName ())";
?>

Usando essa sintaxe, também é possível acessar as propriedades do objeto dentro de strings.

classe foo (
var $ bar = "Eu sou bar." ;
}

$ foo = novo foo ();
$ bar = "bar";
$ baz = array ("foo", "bar", "baz", "quux");
echo "($ foo -> $ bar) \ n";
echo "($ foo -> ($ baz [1])) \ n";
?>

O resultado deste exemplo:

Eu sou um bar. Eu sou um bar.

Comente:

Funções, chamadas de método, variáveis ​​de classe estáticas e constantes de classe funcionam internamente {$} desde o PHP 5. No entanto, o valor especificado será tratado como um nome de variável no mesmo contexto da string em que está definido. Usando chaves simples ( {} ) não funcionará para acessar os valores de funções, métodos, constantes de classe ou variáveis ​​de classe estáticas.

// Mostrar todos os erros
relatório_de_erro (E_ALL);

cervejas de classe (
const softdrink = "rootbeer";
public static $ ale = "ipa";
}

$ rootbeer = "A & W";
$ ipa = "Alexander Keith \" s ";

// Isso funciona, gera: eu gostaria de A & W
echo "Eu gostaria de ($ (beers :: softdrink)) \ n";

// Isso também funciona, resulta: eu gostaria de Alexander Keith "s
echo "Eu gostaria de ($ (beers :: $ ale)) \ n";
?>

Acessando e modificando um caractere em uma string

Os caracteres em strings podem ser usados ​​e modificados definindo seu deslocamento desde o início da string, começando em zero, entre colchetes após a string, por exemplo, $ str. Pense em uma string como um array de caracteres para esse propósito. Se você precisar obter ou substituir mais de 1 caractere, pode usar as funções substr () e substr_replace ().

Comente: desde o PHP 7.1.0, valores negativos de offset são suportados. Eles definem o deslocamento do final da linha. Deslocamentos anteriormente negativos causavam um erro de nível E_NOTICE durante a leitura (retornando uma string vazia) E_AVISO enquanto escreve (deixando a linha inalterada).

Comente: Um caractere em uma string também pode ser referenciado usando chaves, por exemplo, $ str (42).

Atenção

A tentativa de escrever para um deslocamento off-line preencherá a linha com espaços até esse deslocamento. Tipos não inteiros serão convertidos em inteiros. O tipo de deslocamento errado causará erro de nível E_AVISO... Apenas o primeiro caractere da string atribuída é usado. A partir do PHP 7.1.0, atribuir uma string vazia causará um erro fatal. Anteriormente, um byte NULL era atribuído neste caso.

Atenção

Strings em PHP são internamente matrizes de bytes. Como resultado, acessar ou modificar uma string no deslocamento não é seguro do ponto de vista da codificação multibyte e só deve ser executado com strings em codificações de byte único, como ISO-8859-1.

Comente: A partir do PHP 7.1.0, usar um índice vazio causa um erro fatal, anteriormente, em um caso semelhante, uma string era convertida em um array sem aviso.

Exemplo # 12 Alguns exemplos de string

// Pega o primeiro caractere da string
$ str = "Isto é um teste." ;
$ primeiro = $ str [0];

// Pega o terceiro caractere da string
$ terceiro = $ str [2];

// Pega o último caractere da string
$ str = "Isto ainda é um teste." ;
$ último = $ str [strlen ($ str) - 1];

// Muda o último caractere da linha
$ str = "Olhe para o mar";
$ str [strlen ($ str) - 1] = "e";

?>

Desde o PHP 5.4, o deslocamento na string deve ser especificado como um inteiro ou como uma string contendo números, caso contrário, um aviso será emitido. Anteriormente, o deslocamento especificado pela linha do formulário "foo", sem avisos convertidos em 0 .

Exemplo # 13 Diferenças entre PHP 5.3 e PHP 5.4

$ str = "abc";

Var_dump ($ str ["1"]);
var_dump (isset ($ str ["1"]));

Var_dump ($ str ["1.0"]);
var_dump (isset ($ str ["1.0"]));

Var_dump ($ str ["x"]);
var_dump (isset ($ str ["x"]));

Var_dump ($ str ["1x"]);
var_dump (isset ($ str ["1x"]));
?>

O resultado da execução deste exemplo no PHP 5.3:

string (1) "b" bool (verdadeiro) string (1) "b" bool (verdadeiro) string (1) "a" bool (verdadeiro) string (1) "b" bool (verdadeiro)

O resultado da execução deste exemplo no PHP 5.4:

string (1) "b" bool (verdadeiro) Aviso: deslocamento de string ilegal "1.0" em /tmp/t.php na linha 7 string (1) "b" bool (falso) Aviso: deslocamento de string ilegal "x" em / tmp / t.php na linha 9 string (1) "a" bool (falso) string (1) "b" bool (falso)

Comente:

Tentar acessar variáveis ​​de outros tipos (excluindo matrizes ou objetos que implementam certas interfaces) usando ou {} retornar silenciosamente NULO.

Comente:

PHP 5.5 adicionou suporte para acessar caracteres em strings literais usando a sintaxe ou {} .

Existem muitas funções úteis para modificar strings.

As funções básicas são descritas na seção sobre funções de string e, para pesquisa avançada e substituição, as funções de expressões regulares compatíveis com Perl.

Convertendo em string

O valor pode ser convertido em uma string usando um elenco (fragmento), ou funções strval ()... Em expressões onde uma string é necessária, a conversão ocorre automaticamente. Isso acontece quando você usa as funções eco ou imprimir, ou quando o valor de uma variável é comparado a uma string. A leitura das seções Tipos e Manipulação de tipo do manual tornará o seguinte mais claro. Veja também settype ().

Arrays são sempre convertidos em string "Variedade" então você não pode exibir o conteúdo do array ( variedade) usando eco ou imprimir para ver o que contém. Para ver um item individual, use algo como echo $ arr ["foo"]... Veja abaixo dicas sobre como exibir / visualizar todo o conteúdo.

Para converter uma variável em tipo "Objeto" em tipo fragmento o método mágico __toString é usado.

Significado NULO sempre se converte em uma string vazia.

Como você pode ver acima, a conversão direta em uma string de arrays, objetos ou recursos não fornece nenhuma informação útil sobre os próprios valores, exceto seus tipos. Uma maneira melhor de gerar valores para depuração é usar funções print_r () e var_dump ().

A maioria dos valores em PHP podem ser convertidos em uma string para armazenamento permanente. Este método é chamado de serialização e pode ser feito usando a função serialize ().

Converter strings em números

Se a string for reconhecida como um valor numérico, o valor e o tipo resultantes serão determinados conforme mostrado abaixo.

Se a string não contiver nenhum dos caracteres ".", "E" ou "E", e o valor do número for colocado dentro do intervalo de inteiros (definido PHP_INT_MAX), a string será reconhecida como um inteiro ( inteiro) Em todos os outros casos, é considerado um número de ponto flutuante ( flutuador).

O valor é determinado pelo início da string. Se a string começar com um valor numérico válido, esse valor será usado. Caso contrário, o valor será 0 (zero). Um valor numérico válido é um ou mais dígitos (que podem conter um ponto decimal), opcionalmente precedido por um sinal seguido por um expoente opcional. Um expoente é um "e" ou "E" seguido por um ou mais dígitos.

$ foo = 1 + "10,5"; // $ foo é float (11.5)
$ foo = 1 + "-1.3e3"; // $ foo is float (-1299)
$ foo = 1 + "bob-1.3e3"; // $ foo é inteiro (1)
$ foo = 1 + "bob3"; // $ foo é inteiro (1)
$ foo = 1 + "10 porquinhos"; // $ foo é inteiro (11)
$ foo = 4 + "10,2 porquinhos"; // $ foo é float (14.2)
$ foo = "10,0 porcos" + 1; // $ foo é float (11)
$ foo = "10,0 porcos" + 1,0; // $ foo é float (11)
?>

Para obter mais informações sobre essa conversão, consulte a seção strtod (3) da documentação do Unix.

Se você quiser testar algum dos exemplos desta seção, copie e cole-o e a seguinte linha para ver o que acontece:

echo "\ $ foo == $ foo; digite:". Gettype ($ foo). "
\ n ";
?>

Não espere obter um código de caractere convertendo-o em um inteiro (como é feito, por exemplo, em C). Para converter caracteres em seus códigos ASCII e vice-versa, use as funções ord () e chr ().

Detalhes de implementação de tipo de string

7 anos atrás

A documentação não menciona, mas um ponto-e-vírgula de fechamento no final do heredoc é realmente interpretado como um ponto-e-vírgula real e, como tal, às vezes leva a erros de sintaxe.

$ foo =<<abcd
FIM;
?>

Isso não:

foo (<<abcd
FIM;
);
// erro de sintaxe, inesperado ";"
?>

Sem ponto-e-vírgula, funciona bem:

foo (<<abcd
FIM
);
?>

3 anos atrás

Você pode usar string como array de char (como C)

$ a = "Teste de array de strings";

var_dump ($ a);
// Retorna string (17) "Teste de array de strings"

var_dump ($ a);
// Retorna string (1) "S"

// - Com elenco de matriz -
var_dump ((array) $ a);
// Retorna array (1) (=> string (17) "Teste de array de strings")

var_dump ((array) $ a);
// Retorna string (17) "S"

Norihiori

15 anos atrás

Você pode usar a sintaxe complexa para colocar o valor das propriedades do objeto E dos métodos do objeto dentro de uma string. Por exemplo ...
classe Teste (
público $ um = 1;
função pública dois () (
return 2;
}
}
$ teste = novo Teste ();
echo "foo ($ test -> um) bar ($ test -> two ())";
?>
Irá produzir "foo 1 bar 2".

No entanto, você não pode fazer isso para todos os valores em seu namespace. Constantes de classe e propriedades / métodos estáticos não funcionarão porque a sintaxe complexa procura o "$".
classe Teste (
const ONE = 1;
}
echo "foo (Test :: ONE) bar";
?>
Isso irá gerar "foo (Test :: one) bar". Constantes e propriedades estáticas exigem que você divida a string.

3 anos atrás

Esteja ciente de que consistente com "Conversão de string em números":

If ("123abc" == 123) echo "(intstr == int) incorretamente é testado como verdadeiro.";

// Como um lado é um número, a string é convertida incorretamente de intstr para int, que então corresponde ao número de teste.

// Verdadeiro para todas as condicionais, como instruções if e switch (provavelmente também loops while)!

// Isso pode ser um grande risco de segurança ao testar / usar / salvar a entrada do usuário, enquanto espera e testa apenas um número inteiro.

// Parece que a única correção é 123 ser uma string como "123", portanto, nenhuma conversão acontece.

?>

6 anos atrás

Zeros à esquerda em strings são (menos surpresa) não tratados como octais.
Considerar:
$ x = "0123" + 0;
$ y = 0123 + 0;
echo "x é $ x, y é $ y"; // imprime "x é 123, y é 83"
em outras palavras:
* zeros à esquerda em literais numéricos no código-fonte são interpretados como "octal", c.f. strtol ().
* zeros à esquerda em strings (por exemplo, dados enviados pelo usuário), quando convertidos (implícita ou explicitamente) em inteiros são ignorados e considerados como decimais, c.f. strtod ().

10 anos atrás

Aqui está um hack fácil para permitir que strings entre aspas duplas e heredocs contenham expressões arbitrárias na sintaxe de chaves, incluindo constantes e outras chamadas de função:

// Declaração de hack
função _expr ($ v) (retornar $ v;)
$ _expr = "_expr";

// Nosso playground
define ("qwe" , "asd");
definir("zxc", 5 );

$ a= 3 ;
$ b= 4 ;

função c($ a, $ b) (Retorna$ a+ $ b; }

// Uso
eco"pré{ $ _expr(1 + 2 )} postar \ n "; // produz "pré 3 pós"
eco"pré{ $ _expr(qwe)} postar \ n "; // gera "pré-pós-publicação"
eco"pré{ $ _expr(c($ a, $ b)+ zxc* 2 )} postar \ n "; // produz "pré 17 pós"

// A sintaxe geral é ($ _expr (...))
?>

2 anos atrás

Achei que seria útil adicionar este comentário para que as informações apareçam pelo menos na página certa no site PHP.

Observe que, se você pretende usar uma string entre aspas duplas com uma chave associativa, pode ocorrer o erro T_ENCAPSED_AND_WHITESPACE. Alguns consideram essa uma das mensagens de erro menos óbvias.

Uma expressão como:

$ fruta= array (
"uma"=> "maçã",
"b"=> "banana",
// etc
);

Imprimir "Isto é um$ fruta[ "uma"] "; // T_ENCAPSED_AND_WHITESPACE
?>

definitivamente vai cair em pedaços.

Você pode resolvê-lo da seguinte maneira:

imprimir"Isto é um$ fruta[ uma] " ; // retira aspas da chave
imprimir"Isto é um${ fruta[ "uma"]} " ; // Complex Syntax
imprimir"Isto é um{ $ fruta[ "uma"]} " ; // Variação de sintaxe complexa
?>

Tenho uma preferência pessoal pela última variação, pois é mais natural e mais próxima de como seria a expressão fora da corda.

Não está claro (para mim, pelo menos) por que o PHP interpreta mal as aspas simples dentro da expressão, mas imagino que tenha algo a ver com o fato de aspas não fazerem parte da string de valor - uma vez que a string já está sendo analisada, as aspas apenas entrar no caminho ...?

2 anos atrás

Ambos devem funcionar :(

classeTestando{
estática pública$ VAR= "estático";
public const VAR ="const";

Função pública digaHelloStatic() {
eco"Olá:{ $ isto:: $ VAR} " ;
}

Função pública digaHelloConst() {
eco"Olá:{ $ isto:: VAR)" ; // Erro de análise: erro de sintaxe, inesperado ")", esperando "["
}
}

$ obj= novoTestando();
$ obj-> digaHelloStatic();
$ obj-> digaHelloConst();

3 anos atrás

Algo que experimentei e que sem dúvida ajudará alguém. ... ...
No meu editor, a sintaxe realçará o HTML e o $ comentário:

$ html =<<<"EOD"
$ comentário
EOD;

Usar isso mostra todos da mesma cor:

$ html =<<$ comentário
EOD;

tornando muito mais fácil trabalhar com

11 anos atrás

Para salvar sua mente, não leia comentários anteriores sobre datas;)

Quando ambas as strings podem ser convertidas em numéricos (no teste ("$ a"> "$ b")), os resultados numéricos são usados, caso contrário, as strings COMPLETAS são comparadas caractere por caractere:

var_dump("1.22" > "01.23" ); // bool (falso)
var_dump("1.22.00" > "01.23.00" ); // bool (verdadeiro)
var_dump("1-22-00" > "01-23-00" ); // bool (verdadeiro)
var_dump((flutuador)"1.22.00" > (flutuar)"01.23.00" ); // bool (falso)
?>

misturado preg_replace(padrão misto, substituição mista, sujeito misto [, limite interno])

Pesquisa o assunto em busca de correspondências de padrão e as substitui por substituição. Se o parâmetro limit for especificado, as ocorrências de limite do modelo serão substituídas; se limite for omitido ou igual a -1, todas as ocorrências do padrão serão substituídas.

A substituição pode conter referências no formato \\ n ou (desde o PHP 4.0.4) $ n, sendo o último o preferido. Cada uma dessas referências será substituída por uma substring correspondente ao subpadrão n "n" entre parênteses. N pode assumir valores de 0 a 99, e a referência \\ 0 (ou $ 0) corresponde a todo o padrão. Os subpadrões são numerado da esquerda para a direita, começando de um ...

Ao usar a substituição de curinga usando referências de subpadrão, pode ser possível que um número siga imediatamente a máscara. Nesse caso, a notação \\ n resulta em um erro: uma referência ao primeiro subpadrão seguido do número 1 será escrita como \\ 11, que será interpretado como uma referência ao décimo primeiro subpadrão. Essa confusão pode ser esclarecida usando a construção \ $ (1) 1, que aponta para uma referência isolada ao primeiro subpadrão seguido pelo dígito 1.

A saída deste exemplo será:

01 de abril de 2003

Se uma correspondência de padrão for encontrada durante a execução da função, o valor do assunto modificado será retornado, caso contrário, o assunto original será retornado.

Os primeiros três parâmetros da função preg_replace () podem ser matrizes unidimensionais. Se a matriz usar chaves, ao processar a matriz, elas serão obtidas na ordem em que estão localizadas na matriz. As chaves de matriz para padrão e substituição são opcionais. Se, no entanto, decidir usar índices, para combinar padrões e strings envolvidos na substituição, use a função ksort () para cada uma das matrizes.

Exemplo 2. Usando matrizes com índices numéricos como argumentos de função preg_replace () $ string = "A ligeira raposa marrom saltou sobre o cão preguiçoso."; $ patterns [0] = "/ quick /"; $ padrões [1] = "/ marrom /"; $ patterns [2] = "/ fox /"; $ replaceements [2] = "urso"; $ substituições [1] = "preto"; $ substituições [0] = "lento"; preg_replace ($ padrões, $ substituições, $ string); ?> Resultado: Resultado: O lento urso preto saltou sobre o cão preguiçoso.

Se o parâmetro do assunto for uma matriz, a pesquisa e a substituição curinga serão realizadas para cada um de seus elementos. O resultado retornado também será uma matriz.

No caso de o padrão de parâmetros e substituição serem matrizes, preg_replace () recupera alternadamente um par de elementos de ambas as matrizes e os usa para a operação de pesquisa e substituição. Se a matriz de substituição contiver mais elementos do que o padrão, strings vazias serão usadas no lugar dos elementos ausentes para substituição. Se o padrão for um array e a substituição for uma string, cada elemento do array padrão será procurado e substituído pelo padrão (o padrão será alternadamente todos os elementos do array, enquanto o string de substituição permanecerá fixo). A variante quando o padrão é uma string e a substituição é um array não faz sentido.

O modificador / e muda o comportamento de uma função preg_replace () de forma que o parâmetro de substituição, após realizar as substituições necessárias, seja interpretado como código PHP e só então será utilizado para substituição. Ao usar este modificador, tome cuidado: o parâmetro de substituição deve conter o código PHP correto, caso contrário, na linha que contém a chamada de função preg_replace (), ocorre um erro de sintaxe.

Exemplo 3. Substituição por vários modelos $ patterns = array ( "/ (19 | 20) (\ d (2)) - (\ d (1,2)) - (\ d (1,2)) /", "/ ^ \ s * ((\ w +)) \ s * = /"); $ replace = array ("\\ 3 / \\ 4 / \\ 1 \\ 2", "$ \\ 1 ="); echo preg_replace ($ patterns, $ replace, "(startDate) = 1999-5-27"); ?> Este exemplo resultará em: Converte todas as tags HTML em maiúsculas

Exemplo 5. Conversor de HTML para texto // $ document na saída deve conter um documento HTML. // É necessário remover todas as tags HTML, seções javascript, // caracteres de espaço em branco. Também é necessário substituir alguns // entidades HTML com seus equivalentes.$ search = array ( ""]*?>.*?"si", // Cut out javaScript ""<[\/\!]*?[^<>] *?> "si", // Remove as tags HTML "" ([\ r \ n]) [\ s] + "", // Remove os caracteres de espaço em branco "" & (quot | # 34); "i", // Substitui entidades HTML "" & (amp | # 38); "i", "" & (lt | # 60); "i", "" & (gt | # 62); "i", "" & (nbsp | # 160); "i", "" & (iexcl | # 161); "i", "" & (cent | # 162); "i", "" & (libra | # 163); "i", "" & (copiar | # 169); "i", "" (\ d +); "e"); // interpretar como código php$ replace = array ("", "" , "\\1" , "\"" , "&" , "<" , ">" , " " , chr (161), chr (162), chr (163), chr (169), "chr (\\ 1)"); $ text = preg_replace ($ search, $ replace, $ document); ?>

Mesas:

C_id | Empresa | Localização
1 Pesquisa LLC | Kudykino Pole 15/3
2 | Elita CJSC | Slunisvalinsk 133/7
3 | OJSC Pyshpysch | Soldatodachestroy 404

Tipo de reparo (repair_types)
r_id | Repair_types |
1 Martelo + pregos
2 | Orientação de beleza
3 | Revisão

Lista de pedidos (lista)
l_id | Quem | Que necessidade | Tempo | Comentário do operador
1 1 2 | % timestamp% | % operator_text%
2 | 2 | 1 | % texto%
3 | 3 | 2 | | % texto%

A Tabela 1 contém uma lista de clientes.
A Tabela 2 contém uma lista de serviços.
A Tabela 3 contém uma lista de pedidos atuais para equipes operacionais. Esta tabela é atualizada regularmente e um formulário da web é usado para preenchê-la. Como há alguns pedidos chegando, os registros são inseridos na tabela na forma de IDs de cliente e serviço.

O problema real é que a terceira tabela deve ser exibida no formulário da web "seleção de pedidos" e, em vez do ID, você precisa substituir os campos correspondentes de outras colunas.

Código:
$ query = "SELECT * FROM list";
$ result = mysql_query ($ query);
while ($ row = mysql_fetch_array ($ result. // pega os resultados de cada linha
(echo ""; // imprimir dados
}

CREATE TABLE "table_name" ("id" int (255) NOT NULL AUTO_INCREMENT, "list" text (80) NOT NULL, PRIMARY KEY ("id".

INSERT INTO "table_name" ("list") VALUES ("bla-bla")

melhor resposta $ query =
"
selecione empresas.Empresa, tipos_de_reparação.Tipos_de_reparação, lista.comment_l
da lista
empresas de junção interna
na lista.Quem = empresas.c_id
junção interna repair_types
na lista. "O que precisa" = repair_types.r_id
";

Recentemente, as discussões da linguagem PHP no Habré foram reduzidas às possibilidades de projetar sistemas complexos, que não podem deixar de se alegrar. No entanto, após olhar para uma dúzia dos frameworks web mais reconhecidos (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ e outros), fiquei sinceramente surpreso ao encontrar algumas falhas significativas em termos de otimização elementar.

Para tornar este tema mais tecnicamente orientado, os resultados são apresentados de forma mais rigorosa, o que pode complicar um pouco a percepção.

Então, vamos lá ... A tarefa é extremamente simples: conduzir experimentos sobre a velocidade de formação de strings a partir de substrings entre aspas simples e duplas. Em princípio, essa questão será relevante por muito tempo devido às peculiaridades do processamento de strings em PHP.

Existem muitos artigos sobre otimização básica de scripts em russo e em outros idiomas. Diz pouco sobre strings, mas observa o fato de "analisar" strings em aspas duplas para variáveis ​​e caracteres de controle (como na documentação oficial). Com base nisso, é lógico supor que o uso de strings com aspas duplas no trabalho será um pouco mais lento do que as mesmas operações com substrings entre aspas simples.

Além da substituição de variáveis ​​em strings e concatenação de variáveis ​​com substrings, o PHP implementa pelo menos mais uma maneira de formar strings: trabalhando com a função sprintf. É lógico supor que este método será significativamente inferior ao "padrão" devido à chamada de função desnecessária e análise da string interna.

A única adição, antes de apresentar o código do script de teste: você precisa considerar 2 opções possíveis para trabalhar com strings entre aspas duplas: levando em consideração o estilo de codificação simples e "avançado". Você não deve prestar atenção ao fato de que as variáveis ​​estão no início das linhas, provavelmente - são apenas exemplos:
$ string = "$ _SERVER [" HTTP_HOST "] - não a administração da região de Ulyanovsk. Amamos a língua russa e não gostamos de quem a usa ..."
e
$ string = "($ _SERVER [" HTTP_HOST "]) - não a administração da região de Ulyanovsk. Amamos a língua russa e não gostamos de quem a usa ..."

Teste número um.
Bem, parece que todas as reservas foram feitas - é hora de mostrar o resultado do trabalho. O código-fonte do testador pode ser encontrado.

As imagens mostram que minha hipótese não foi confirmada. A única suposição correta acabou sendo sobre como trabalhar com strings via sprintf. As mais rápidas são as funções que funcionam com aspas duplas.

Após uma breve consideração da situação, a explicação veio por si mesma: a questão toda é que a string de referência na qual as substituições foram feitas é muito curta: passar o analisador ao longo de tal string é uma questão insignificante. No entanto, mesmo aqui você pode ver que a substituição nativa de uma variável em uma string dá uma vantagem sobre o "estilo avançado".
Esse também é o ponto fraco da abordagem de concatenação: os volumes de dados inseridos excedem os volumes de substrings. A origem dos custos indiretos pode ser lida nos habratópicos já mencionados.

No entanto, mesmo esses pensamentos tiveram que ser confirmados. Isso exigiu um segundo teste com alterações para as possíveis razões mencionadas para tal comportamento imprevisível (para mim). Aparentemente, muito foi ajustado na quinta versão (confesso, na quinta versão do php fiz apenas 1 teste: para percorrer os elementos do array).

Teste número dois.
A segunda hipótese: o alongamento da string de referência acabará por aumentar a porcentagem do tempo de execução das funções de teste associadas à formação de strings entre aspas em relação aos resultados do teste 1. A mesma situação, teoricamente, deve ser observada em relação ao a operação da função sprintf. Isso se deve, em primeiro lugar, à necessidade de analisar strings e ao aumento do tempo despendido nisso. Na situação com a concatenação de substrings entre aspas simples, acho que será observado aproximadamente o mesmo resultado do primeiro teste, o que dará uma pequena diminuição na fração do tempo de execução da função quotes_3 () pelo tempo todo o script está sendo executado (mas não um aumento no desempenho).

As conclusões, na verdade, são apenas positivas e confirmadoras da hipótese. Com um ligeiro aumento na string de referência, surge uma grande carga, o que leva a uma diminuição no desempenho das funções para trabalhar com aspas duplas e sprintf.

A suposição sobre strings entre aspas simples também se mostrou correta: em vez de 36,75% do tempo no primeiro teste, no segundo, a função quotes_3 () ocupou 33,76% do tempo de execução do script

Valor prático.
Em termos simples, abstraindo dos dados, podemos concluir: quanto mais longa a string em que a substituição deve ser feita, mais provável é que a operação de concatenação seja executada mais rapidamente do que a busca por uma variável entre aspas duplas. Os voluntários podem tentar escolher os parâmetros de inserção necessários (o número de variáveis, o comprimento da string de referência, o comprimento das strings nas variáveis) de forma que satisfaçam a igualdade dos tempos de execução.

Isso, na verdade, é tudo. Resta acrescentar que não há ninharias na programação (é o que digo a quem gosta de dizer "poupar nos jogos" (c) Adelf). Conhecendo essas sutilezas e levando-as em consideração, você pode escrever um código que será otimizado em todos os níveis;)

PS:
Testes conduzidos com Zend Studio For Eclipse 6.0.0 (Debugger + Profiler incluído).
PHP versão 5.2.5
Debian Linux OS

PPS:
Eu ficaria feliz se alguém postasse seus resultados desses testes. Acho que isso nos permitirá avaliar mais objetivamente a necessidade de usar um ou outro método de substituição em strings. Eu também ficaria grato por uma crítica saudável ao estilo de apresentação e design.