Verification: a143cc29221c9be0

Parsing int to string php

Enum синтаксис

PHP 8.1 резервирует и использует ключевое слово enum для объявления Enums. Синтаксис аналогичен синтаксису трейта/класса/интерфейса:

enum Status
{
case CREATED;
case COMPLETED;
case CANCELED;
case REFUNDED;
case FAILED;
}

Чувствительность к регистру

Само имя Enum нечувствительно к регистру , и оно соответствует тому, как PHP обрабатывает классы и функции без учета регистра. Отдельные регистры в Enum нечувствительны к регистру.

enum Status
{
case created;
case Completed;
case canCeleD;
}

Enum методы

Перечисления могут содержать методы, как и классы. Это очень мощная функция, особенно в сочетании с оператором match:

enum Status
{
case CREATED;
case COMPLETED;
case CANCELED;

public function color(): string
{
return match($this)
{
Status::CREATED => 'grey',
Status::COMPLETED => 'green',
Status::CANCELED => 'red'
};
}
}

 и далее использовать в коде как:

$status = Status::COMPLETED;
$status->color(); // "green"

 Разрешено использовать статические методы. Также обратите внимание, что вы можете использовать в перечислении self:

enum Status
{
// …

public function color(): string
{
return match($this)
{
self::CREATED => 'grey',
self::COMPLETED => 'green',
self::CANCELED=> 'red',
};
}
}

Enum интерфейсы  

Перечисления могут реализовывать интерфейсы, как и обычные классы:

interface HasColor
{
public function color(): string;
}
enum Status implements HasColor
{
case CREATED;
case COMPLETED;
case CANCELED;

public function color(): string { /* … */ }
}

Перечисления не должны содержать свойств

Одно из наиболее важных различий между Enum и классом заключается в том, что Enums не могут иметь никакого состояния. Объявление или установка свойств не разрешены. Статические свойства также не допускаются. 

enum Foo {
private string $test;
private static string $test2;
}

// Fatal error: Enums may not include member variables in ... on line ...

Кроме того, не допускается динамическая установка свойств:

enum Foo {
case Bar;
}
$bar = Foo::Bar;
$bar->test = 42;

// Error: Enum properties are immutable in ...:...

Enum значения или "Поддерживаемые перечисления"

Изначально значения Enum представлены внутри объектами, но вы можете присвоить им какое-то значение, например для сериализации их в базу данных.

enum Status: string
{
case CREATED = 'created';
case COMPLETED = 'completed';
case CANCELED = 'canceled';
}

Обратите внимание на объявление типа в определении перечисления. Он указывает, что все значения перечисления имеют данный тип. Вы также можете сделать их целочисленными - int. Обратите внимание, что разрешены только типы int и string, как значения перечисления.  

enum Status: int
{
case CREATED = 1;
case COMPLETED = 2;
case CANCELED = 3;
}

Технический термин для такого ввода перечислений называется «поддерживаемые перечисления», поскольку они «подкреплены» более простым значением. Если вы решили присвоить значения перечисления, тогда все варианты должны иметь какое-то значение. Вы не можете смешивать и сочетать их. Перечисления без "поддержки" называются "чистыми перечислениями". 

Сериализация поддерживаемых перечислений

Если вы присвоите значения enum, вам вероятно понадобится способ их сериализации и десериализации. Их сериализация означает, что вам нужен способ доступа к значению перечисления. Это делается с помощью public свойства value, обратите внимание, что оно только для чтения:

$value = Status::CANCELED->value; // 3

Получить перечисление из значения можно с помощью Enum::from 

$status = Status::from(2); // Status::COMPLETED

Также можно использовать tryFrom для возврата null при неизвестном значении. Если бы вы использовали from, то возникло бы исключение. 

$status = Status::from('unknown'); // ValueError
$status = Status::tryFrom('unknown'); // null

Вы также можете использовать встроенные функции serialize и unserialize на перечислениях. Кроме того, вы можете использовать json_serialize в сочетании с поддерживаемыми перечислениями, ее результатом будет значение перечисления. Это поведение можно изменить, реализовав JsonSerializable. 

Список значений перечисления

Вы можете использовать статический метод cases(), чтобы получить список всех доступных "случаев" в перечислении: Enum::cases()

Status::cases();

// [Status::CREATED, Status::COMPLETED, Status::CANCELED]

Перечисления - это объекты

Как уже выше упоминалось, значения перечислений представлены как объекты, хотя на самом деле это одноэлементные объекты. Это означает, что вы можете сравнивать их так:

$statusA = Status::COMPLETED;
$statusB = Status::COMPLETED;
$statusC = Status::CANCELED;

$statusA === $statusB; // true
$statusA === $statusC; // false
$statusC instanceof Status; // true

Перечисления как ключи массива

Поскольку значения перечислений на самом деле являются объектами, в настоящее время их невозможно использовать в качестве ключей массива. Следующий код приведет к ошибке:

$list = [
Status::CREATED => 'created',
// …
];

Существует RFC для изменения этого поведения, но он еще не был принят.

Это означает, что вы можете использовать только перечисления в качестве ключей в SplObjectStorage и WeakMaps. 

Перечисления могут иметь ноль или более значений

Внутри структуры enum может содержаться любое количество case от нуля до бесконечности. Оба этих объявления Enum валидны:

enum ErrorStates {
}
enum HTTPMethods {
case GET;
case POST;
}

Создание экземпляров с помощью new запрещено

Хотя кеймы Enum сами по себе являются объектами, их нельзя создавать с помощью конструкции new. Обе следующие new конструкции не допускаются:

enum Foo {
case Bar;
}

new Foo(); // Fatal error: Uncaught Error: Cannot instantiate enum Foo
new Foo::Bar(); Parse error: syntax error, unexpected identifier "Bar", expecting variable or "$"

Перечисления не могут быть расширены и не должны наследовать

Перечисления объявляются как final, и Enum не может наследоваться от другого Enum или класса.

enum Foo extends Bar {}

// Parse error: syntax error, unexpected token "extends", expecting "{" in ... on line ...

enum Foo {}
class Bar extends Foo {}

// Fatal error: Class Bar may not inherit from final class (Foo) in ... on line ...

Пространства имен

Пространство имен System.Text.Json содержит все точки входа и основные типы. Пространство имен System.Text.Json.Serialization содержит атрибуты и интерфейсы API для сложных сценариев и настройки, характерной для сериализации и десериализации. В примерах кода, приведенных в этой статье, для одного или обоих пространств имен необходимо добавить директивы using:

using System.Text.Json;
using System.Text.Json.Serialization;

Как записать объекты .NET в формате JSON (сериализация)

Чтобы записать JSON в строку или в файл, вызовите метод JsonSerializer.Serialize.

В следующем примере показано создание JSON в виде строки:

string jsonString = JsonSerializer.Serialize(weatherForecast);

В примере ниже для создания JSON-файла используется синхронный код:

jsonString = JsonSerializer.Serialize(weatherForecast);
File.WriteAllText(fileName, jsonString);

В следующем примере для создания JSON-файла используется асинхронный код:

using FileStream createStream = File.Create(fileName);
await JsonSerializer.SerializeAsync(createStream, weatherForecast);

В предыдущих примерах для сериализуемого типа используется определение типа. Перегрузка Serialize() принимает параметр универсального типа:

jsonString = JsonSerializer.Serialize(weatherForecast);

Пример сериализации

Ниже приведен пример класса, который содержит свойства типа коллекции и определяемый пользователем тип:

public class WeatherForecastWithPOCOs
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public string Summary { get; set; }
    public string SummaryField;
    public IList DatesAvailable { get; set; }
    public Dictionary TemperatureRanges { get; set; }
    public string[] SummaryWords { get; set; }
}

public class HighLowTemps
{
    public int High { get; set; }
    public int Low { get; set; }
}

Совет

POCO означает традиционный объект среды CLR. POCO — это тип .NET, который не зависит от каких-либо типов платформы, например посредством наследования или атрибутов.

Выходные данные JSON из сериализации экземпляра предыдущего типа выглядят следующим образом. По умолчанию выходные данные JSON сокращены (удалены пробелы, отступы и символы новой строки):

{"Date":"2019-08-01T00:00:00-07:00","TemperatureCelsius":25,"Summary":"Hot","DatesAvailable":["2019-08-01T00:00:00-07:00","2019-08-02T00:00:00-07:00"],"TemperatureRanges":{"Cold":{"High":20,"Low":-10},"Hot":{"High":60,"Low":20}},"SummaryWords":["Cool","Windy","Humid"]}

В следующем примере показан тот же объект JSON, но с форматированием (т. е. структурированный с пробелами и отступами):

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": 20,
      "Low": -10
    },
    "Hot": {
      "High": 60,
      "Low": 20
    }
  },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}

Сериализация в UTF-8

Чтобы выполнить сериализацию в UTF-8, вызовите метод JsonSerializer.SerializeToUtf8Bytes:

byte[] jsonUtf8Bytes =JsonSerializer.SerializeToUtf8Bytes(weatherForecast);

Также доступна перегрузка Serialize, которая принимает Utf8JsonWriter.

Сериализация в UTF-8 происходит примерно на 5-10 % быстрее, чем при использовании строковых методов. Разница заключается в том, что байты (например, UTF-8) не нужно преобразовывать в строки (UTF-16).

Поведение сериализации

К поддерживаемым типам относятся:

Для обработки дополнительных типов или для обеспечения функциональности, которая не поддерживается встроенными преобразователями, можно реализовать пользовательские преобразователи.

Как считать JSON как объекты .NET (десериализация)

Чтобы выполнить десериализацию из строки или файла, вызовите метод JsonSerializer.Deserialize.

В следующем примере показано считывание JSON из строки и создание экземпляра класса WeatherForecastWithPOCOs, показанного ранее для примера сериализации:

weatherForecast = JsonSerializer.Deserialize(jsonString);

Чтобы выполнить десериализацию из файла с помощью синхронного кода, выполните считывание файла в строку, как показано в следующем примере:

jsonString = File.ReadAllText(fileName);
weatherForecast = JsonSerializer.Deserialize(jsonString);

Чтобы выполнить десериализацию из файла с помощью асинхронного кода, вызовите метод DeserializeAsync:

using FileStream openStream = File.OpenRead(fileName);
weatherForecast = await JsonSerializer.DeserializeAsync(openStream);

Десериализация из UTF-8

Для десериализации из UTF-8 вызовите перегрузку JsonSerializer.Deserialize, которая принимает значения ReadOnlySpan или Utf8JsonReader, как показано в следующих примерах. В примерах предполагается, что JSON находится в массиве байтов jsonUtf8Bytes.

var readOnlySpan = new ReadOnlySpan(jsonUtf8Bytes);
WeatherForecast deserializedWeatherForecast = 
    JsonSerializer.Deserialize(readOnlySpan);
var utf8Reader = new Utf8JsonReader(jsonUtf8Bytes);
WeatherForecast deserializedWeatherForecast = 
    JsonSerializer.Deserialize(ref utf8Reader);

Поведение десериализации

При десериализации JSON применяются следующие правила поведения:

Для обеспечения функциональности, которая не поддерживается встроенными преобразователями, можно реализовать пользовательские преобразователи.

Сериализация в форматированный JSON

Чтобы структурировать выходные данные JSON, задайте для JsonSerializerOptions.WriteIndented значение true.

var options = new JsonSerializerOptions
{
    WriteIndented = true,
};
jsonString = JsonSerializer.Serialize(weatherForecast, options);

Ниже приведен пример типа для сериализации и структурирования данных JSON:

public class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public string Summary { get; set; }
}
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot"
}

При многократном использовании JsonSerializerOptions с одинаковыми параметрами не создавайте новый экземпляр JsonSerializerOptions при каждом использовании. Повторно используйте один и тот же экземпляр для каждого вызова. Дополнительные сведения см. в разделе Повторное использование экземпляров JsonSerializerOptions.

Включение полей

Используйте глобальный параметр JsonSerializerOptions.IncludeFields или атрибут [JsonInclude] для включения поля при сериализации или десериализации, как показано ниже:

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Fields
{
    public class Forecast
    {
        public DateTime Date;
        public int TemperatureC;
        public string Summary;
    }

    public class Forecast2
    {
        [JsonInclude]
        public DateTime Date;
        [JsonInclude]
        public int TemperatureC;
        [JsonInclude]
        public string Summary;
    }

    public class Program
    {
        public static void Main()
        {
            var json =
                @"{""Date"":""2020-09-06T11:31:01.923395"",""TemperatureC"":-1,""Summary"":""Cold""} ";
            Console.WriteLine($"Input JSON: {json}");

            var options = new JsonSerializerOptions
            {
                IncludeFields = true,
            };
            var forecast = JsonSerializer.Deserialize(json, options);

            Console.WriteLine($"forecast.Date: {forecast.Date}");
            Console.WriteLine($"forecast.TemperatureC: {forecast.TemperatureC}");
            Console.WriteLine($"forecast.Summary: {forecast.Summary}");

            var roundTrippedJson =
                JsonSerializer.Serialize(forecast, options);

            Console.WriteLine($"Output JSON: {roundTrippedJson}");

            var forecast2 = JsonSerializer.Deserialize(json);

            Console.WriteLine($"forecast2.Date: {forecast2.Date}");
            Console.WriteLine($"forecast2.TemperatureC: {forecast2.TemperatureC}");
            Console.WriteLine($"forecast2.Summary: {forecast2.Summary}");

            roundTrippedJson = JsonSerializer.Serialize(forecast2);
            
            Console.WriteLine($"Output JSON: {roundTrippedJson}");
        }
    }
}

// Produces output like the following example:
//
//Input JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
//forecast.Date: 9/6/2020 11:31:01 AM
//forecast.TemperatureC: -1
//forecast.Summary: Cold
//Output JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
//forecast2.Date: 9/6/2020 11:31:01 AM
//forecast2.TemperatureC: -1
//forecast2.Summary: Cold
//Output JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}

Чтобы пропустить поля, предназначенные только для чтения, используйте глобальный параметр JsonSerializerOptions.IgnoreReadOnlyFields.

Методы расширения HttpClient и HttpContent

Сериализация и десериализация полезных данных JSON из сети являются обычными операциями. Методы расширения в HttpClient и HttpContent позволяют выполнять эти операции в одной строке кода. Эти методы расширения используют стандартные параметры веб-приложений для JsonSerializerOptions.

В следующем примере демонстрируется применение HttpClientJsonExtensions.GetFromJsonAsync и HttpClientJsonExtensions.PostAsJsonAsync:

using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Threading.Tasks;

namespace HttpClientExtensionMethods
{
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Username { get; set; }
        public string Email { get; set; }
    }

    public class Program
    {
        public static async Task Main()
        {
            using HttpClient client = new()
            {
                BaseAddress = new Uri("https://jsonplaceholder.typicode.com")
            };

            // Get the user information.
            User user = await client.GetFromJsonAsync("users/1");
            Console.WriteLine($"Id: {user.Id}");
            Console.WriteLine($"Name: {user.Name}");
            Console.WriteLine($"Username: {user.Username}");
            Console.WriteLine($"Email: {user.Email}");

            // Post a new user.
            HttpResponseMessage response = await client.PostAsJsonAsync("users", user);
            Console.WriteLine(
                $"{(response.IsSuccessStatusCode ? "Success" : "Error")} - {response.StatusCode}");
        }
    }
}

// Produces output like the following example but with different names:
//
//Id: 1
//Name: Tyler King
//Username: Tyler
//Email: Tyler @contoso.com
//Success - Created

Для System.Text.Json существуют также методы расширения на HttpContent.

Методы расширения на HttpClient и HttpContent недоступны в System.Text.Json для .NET Core 3.1.

Синтаксис

    Строка может быть определена тремя различными способами.

Одинарные кавычки

Простейший способ определить строку - это заключить ее в одинарные кавычки (символ ").

Чтобы использовать одинарную кавычку внутри строки, как и во многих других языках, ее необходимо предварить символом обратной косой черты (\), т. е. экранировать ее. Если обратная косая черта должна идти перед одинарной кавычкой либо быть в конце строки, вам необходимо продублировать ее. Обратите внимание, что если вы попытаетесь экранировать любой другой символ, обратная косая черта также будет напечатана! Так что, как правило, нет необходимости экранировать саму обратную косую черту.

Замечание: В PHP 3 в данном случае будет выдано сообщение уровня E_NOTICE.

Замечание: В отличие от двух других синтаксисов, переменные и экранирующие последовательности для специальных символов, встречающиеся в строках, заключенных в одинарные кавычки, не обрабатываются.

Echo "это простая строка"; echo "Также вы можете вставлять в строки символ новой строки таким образом, поскольку это нормально"; // Выведет: Однажды Арнольд сказал: "I"ll be back" echo "Однажды Арнольд сказал: "I\"ll be back""; // Выведет: Вы удалили C:\*.*? echo "Вы удалили C:\\*.*?"; // Выведет: Вы удалили C:\*.*? echo "Вы удалили C:\*.*?"; // Выведет: Это не вставит: \n новую строку echo "Это не вставит: \n новую строку"; // Выведет: Переменные $expand также $either не подставляются echo "Переменные $expand также $either не подставляются";

Двойные кавычки

Если строка заключена в двойные кавычки ("), PHP распознает большее количество управляющих последовательностей для специальных символов:

Таблица 11-1. Управляющие последовательности

Повторяем, если вы захотите мнемнонизировать любой другой символ, обратная косая черта также будет напечатана!

Но самым важным свойством строк в двойных кавычках является обработка переменных. Смотрите более подробно: обработка строк.

Heredoc

Другой способ определения строк - это использование heredoc-синтаксиса ("

Закрывающий идентификатор должен начинаться в первом столбце строки. Кроме того, идентификатор должен соответствовать тем же правилам именования, что и все остальные метки в PHP: содержать только буквенно-цифровые символы и знак подчеркивания, и должен начинаться с нецифры или знака подчеркивания.

Внимание

Очень важно отметить, что строка с закрывающим идентификатором не содержит других символов, за исключением, возможно, точки с запятой (;). Это означает, что идентификатор не должен вводиться с отступом и что не может быть никаких пробелов или знаков табуляции до или после точки с запятой. Важно также понимать, что первым символом перед закрывающим идентификатором должен быть символ новой строки, определенный в вашей операционной системе. Например, на Macintosh это \r.

Если это правило нарушено и закрывающий идентификатор не является "чистым", считается, что закрывающий идентификатор отсутствует и PHP продолжит его поиск дальше. Если в этом случае верный закрывающий идентификатор так и не будет найден, то это вызовет ошибку в обработке с номером строки в конце скрипта.

Heredoc-текст ведет себя так же, как и строка в двойных кавычках, при этом их не имея. Это означает, что вам нет необходимости экранировать кавычки в heredoc, но вы по-прежнему можете использовать вышеперечисленные управляющие последовательности. Переменные обрабатываются, но с применением сложных переменных внутри heredoc нужно быть также внимательным, как и при работе со строками.

Пример 11-2. Пример определения heredoc-строки

$str = foo = "Foo"; $this->bar = array("Bar1", "Bar2", "Bar3"); } } $foo = new foo(); $name = "МоеИмя"; echo foo. Теперь я вывожу {$foo->bar}. Это должно вывести заглавную букву "A": \x41 EOT;

Замечание: Поддержка heredoc была добавлена в PHP 4.

Обработка переменных

Если строка определяется в двойных кавычках, либо при помощи heredoc, переменные внутри нее обрабатываются.

Существует два типа синтаксиса: простой и сложный. Простой синтаксис более легок и удобен. Он дает возможность обработки переменной, значения массива (array) или свойства объекта (object).

Сложный синтаксис был введен в PHP 4 и может быть распознан по фигурным скобкам, окружающих выражение.

Простой синтаксис

Если интерпретатор встречает знак доллара ($), он захватывает так много символов, сколько возможно, чтобы сформировать правильное имя переменной. Если вы хотите точно определить конец имени, заключайте имя переменной в фигурные скобки.

$beer = "Heineken"; echo "$beer"s taste is great"; // работает, """ это неверный символ для имени переменной echo "He drank some $beers"; // не работает, "s" это верный символ для имени переменной echo "He drank some ${beer}s"; // работает echo "He drank some {$beer}s"; // работает

Точно также могут быть обработаны элемент массива (array) или свойство объекта (object). В индексах массива закрывающая квадратная скобка (]) обозначает конец определения индекса. Для свойств объекта применяются те же правила, что и для простых переменных, хотя с ними невозможен трюк, как с переменными.

// Эти примеры специфически об использовании массивов внутри // строк. Вне строк всегда заключайте строковые ключи вашего // массива в кавычки и не используйте вне строк {скобки}. // Давайте покажем все ошибки error_reporting(E_ALL); $fruits = array("strawberry" => "red", "banana" => "yellow"); // Работает, но заметьте, что вне кавычек строки это работает по-другому echo "A banana is $fruits."; //Работает echo "A banana is {$fruits["banana"]}."; // Работает, но PHP, как описано ниже, сначала ищет // константу banana. echo "A banana is {$fruits}."; // Не работает, используйте фигурные скобки. Это вызовет ошибку обработки. echo "A banana is $fruits["banana"]."; // Работает echo "A banana is " . $fruits["banana"] . "."; // Работает echo "This square is $square->width meters broad."; // Не работает. Для решения см. сложный синтаксис. echo "This square is $square->width00 centimeters broad.";

Для чего-либо более сложного вы должны использовать сложный синтаксис.

Сложный (фигурный) синтаксис

Он называется сложным не потому, что труден в понимании, а потому что позволяет использовать сложные выражения.

Фактически, вы можете включить любое значение, находящееся в пространстве имени в строке с этим синтаксисом. Вы просто записываете выражение таким же образом, как и вне строки, а затем заключаете его в { и }. Поскольку вы не можете экранировать "{", этот синтаксис будет распознаваться только когда $ следует непосредственно за {. (Используйте "{\$" или "\{$" чтобы отобразить "{$"). Несколько поясняющих примеров:

// Давайте покажем все ошибки error_reporting(E_ALL); $great = "fantastic"; // Не работает, выведет: This is { fantastic} echo "This is { $great}"; // Работает, выведет: This is fantastic echo "This is {$great}"; echo "This is ${great}"; // Работает echo "Этот квадрат шириной {$square->width}00 сантиметров."; // Работает echo "Это работает: {$arr}"; // Это неверно по той же причине, что и $foo неверно вне // строки. Другими словами, это по-прежнему будет работать, // но поскольку PHP сначала ищет константу foo, это вызовет // ошибку уровня E_NOTICE (неопределенная константа). echo "Это неправильно: {$arr}"; // Работает. При использовании многомерных массивов, внутри // строк всегда используйте фигурные скобки echo "Это работает: {$arr["foo"]}"; // Работает. echo "Это работает: " . $arr["foo"]; echo "Вы даже можете записать {$obj->values->name}"; echo "Это значение переменной по имени $name: {${$name}}";

Доступ к символу в строке и его изменение

Символы в строках можно использовать и модифицировать, определив их смещение относительно начала строки, начиная с нуля, в фигурных скобках после строки.

Замечание: Для обеспечения обратной совместимости, вы по-прежнему имеете возможность использовать в тех же целях скобки массива. Однако, начиная с PHP 4, этот синтаксис нежелателен к использованию.

Пример 11-3. Несколько примеров строк

// Получение первого символа строки $str = "Это тест."; $first = $str{0}; // Получение третьего символа строки $third = $str{2}; // Получение последнего символа строки $str = "Это все еще тест."; $last = $str{strlen($str)-1}; // Изменение последнего символа строки $str = "Посмотри на море"; $str{strlen($str)-1} = "я";

Полезные функции и операторы

Строки могут быть объединены при помощи оператора "." (точка). Обратите внимание, оператор сложения "+" здесь не работает. Дополнительную информацию смотрите в разделе Строковые операторы.

Для модификации строк существует множество полезных функций.

Основные функции описаны в разделе строковых функций, функции регулярных выражений для расширенного поиска и замены (в двух частях: Perl и POSIX расширенный).

Также существуют функции для URL-строк, и функции для шифрования/дешифрования строк (mcrypt и mhash).

Наконец, если вы все еще не нашли, что искали, смотрите также функции для символьного типа.

Преобразование в строку

Вы можете преобразовать значение в строку, используя приведение (string), либо функцию strval() . В выражениях, где необходима строка, преобразование происходит автоматически. Это происходит, когда вы используете функции echo() или print() , либо когда вы сравниваете значение переменной со строкой. Прочтение разделов руководства Типы и Манипуляции с типами сделает следующее более понятным. Смотрите также settype() .

Булево (boolean) значение TRUE преобразуется в строку "1", а значение FALSE представляется как "" (пустая строка). Этим способом вы можете преобразовывать значения в обе стороны - из булева типа в строковый и наоборот.

Целое (integer) или число с плавающей точкой (float) преобразуется в строку, представленную числом, состоящим из его цифр (включая показатель степени для чисел с плавающей точкой).

Массивы всегда преобразуются в строку "Array", так что вы не можете отобразить содержимое массива (array), используя echo() или print() , чтобы узнать, что он содержит. Чтобы просмотреть один элемент, вам нужно сделать что-то вроде echo $arr["foo"]. Смотрите ниже советы о том, как отобразить/просмотреть все содержимое.

Объекты всегда преобразуются в строку "Object". Если вы хотите вывести значение переменной-члена объекта (object) с целью отладки, прочтите следующие абзацы. Если вы хотите получить имя класса требуемого объекта, используйте get_class() .

Ресурсы всегда преобразуются в строки со структурой "Resource id #1", где 1 - это уникальный номер ресурса (resource), присвоенный ему PHP во время выполнения. Если вы хотите получить тип ресурса, используйте .

NULL всегда преобразуется в пустую строку.

Как вы могли видеть выше, вывод массивов, объектов или ресурсов не предоставляет вам никакой полезной информации о самих значениях. Более подходящий способ вывода значений для отладки - использовать функции print_r() и var_dump() .

Вы также можете преобразовать значения PHP в строки для постоянного хранения. Этот метод называется сериализацией и может быть выполнен при помощи функции serialize() . Кроме того, если в вашей установке PHP есть поддержка WDDX, вы можете сериализовать значения PHP в структуры XML.

Преобразование строк в числа

Если строка распознается как числовое значение, результирующее значение и тип определяется так как показано далее.

Строка будет распознана как float, если она содержит любой из символов ".", "e", или "E". Иначе она будет определена как целое.

Значение определяется по начальной части строки. Если строка начинается с верного числового значения, будет использовано это значение. Иначе значением будет 0 (ноль). Верное числовое значение - это одна или более цифр (могущих содержать десятичную точку), по желанию предваренных знаком, с последующим необязательным показателем степени. Показатель степени - это "e" или "E" с последующими одной или более цифрами.

$foo = 1 + "10.5"; // $foo это float (11.5) $foo = 1 + "-1.3e3"; // $foo это float (-1299) $foo = 1 + "bob-1.3e3"; // $foo это integer (1) $foo = 1 + "bob3"; // $foo это integer (1) $foo = 1 + "10 Small Pigs"; // $foo это integer (11) $foo = 4 + "10.2 Little Piggies"; // $foo это float (14.2) $foo = "10.0 pigs " + 1; // $foo это float (11) $foo = "10.0 pigs " + 1.0; // $foo это float (11)

Более подробную информацию об этом преобразовании смотрите в разделе о strtod(3) документации Unix.

Если вы хотите протестировать любой из примеров этого раздела, вы можете скопировать и вставить его и следующую строку, чтобы увидеть, что происходит:

Echo "\$foo==$foo; тип: " . gettype ($foo) . "
\n";

Не ожидайте получить код символа, преобразовав его в целое (как вы могли бы сделать, например, в C). Для преобразования символов в их коды и обратно используйте функции ord() и

Я не эксперт в программировании на PHP, но меня немного смущает, почему я вижу некоторый код в PHP со строкой, заключенной в одинарные, а иногда и в двойные кавычки.

Я просто знаю, что в.NET или языке Си, если он в одинарных кавычках, это означает, что это символ, а не строка.

Решение

То, что вы должны знать,

$a = "name"; $b = "my $a"; == "my name" $c = "my $a"; != "my name"

В PHP люди используют одинарные кавычки для определения постоянной строки, например "a" , "my name" , "abc xyz" при использовании двойной кавычки для определения строки, содержащей идентификатор, такой как "a $b $c $d" ,

И другое дело,

Echo "my name";

быстрее чем

Echo "my name";

Echo "my " . $a;

медленнее, чем

Echo "my $a";

Это верно для других используемых строк.

В PHP текст в одинарных кавычках рассматривается как строковое значение, а текст в двойных кавычках будет анализировать переменные путем замены и обработки их значения.

$test = "variable"; echo "Hello Mr $test"; // the output would be: Hello Mr variable echo "Hello Mr $test"; // the output would be: Hello Mr $test

Здесь двойная кавычка анализирует значение, а одинарная кавычка рассматривается как строковое значение (без разбора переменной $ test.)

Оба вида вложенных символов являются строками. Один тип цитаты удобно использовать для заключения другого типа цитаты. """ а также """ , Самое большое различие между типами кавычек заключается в том, что ссылки на вложенные идентификаторы заменяются внутри двойных кавычек, а не внутри одинарных кавычек.

Замечание : В PHP 7.0.0 на 64-битных платформах нет каких-либо достижимых ограничений для длины строки, в 32-битных системах и в более ранних версиях PHP, строки не могут быть более 2 ГБ (2147483647 байт).

Синтаксис

Строка может быть определена четырьмя различными способами:

  • одинарными кавычками
  • двойными кавычками
  • nowdoc-синтаксисом (начиная с PHP 5.3.0)

Одинарные кавычки

Простейший способ определить строку - это заключить ее в одинарные кавычки (символ " ).

Чтобы использовать одинарную кавычку внутри строки, проэкранируйте ее обратным слешем (\ ). Если необходимо написать сам обратный слеш, продублируйте его (\\ ). Все остальные случаи применения обратного слеша будут интерпретированы как обычные символы: это означает, что если вы попытаетесь использовать другие управляющие последовательности, такие как \r или \n , они будут выведены как есть вместо какого-либо особого поведения.

echo "это простая строка" ;

echo "Также вы можете вставлять в строки
символ новой строки вот так,
это нормально"
;

// Выводит: Однажды Арнольд сказал: "I"ll be back"
echo "Однажды Арнольд сказал: "I\"ll be back"" ;

Echo "Вы удалили C:\\*.*?" ;

// Выводит: Вы удалили C:\*.*?
echo "Вы удалили C:\*.*?" ;

// Выводит: Это не будет развернуто: \n новая строка
echo "Это не будет развернуто: \n новая строка" ;

// Выводит: Переменные $expand также $either не разворачиваются
echo "Переменные $expand также $either не разворачиваются" ;
?>

Двойные кавычки

Если строка заключена в двойные кавычки ("), PHP распознает следующие управляющие последовательности специальных символов:

Управляющие последовательности
Последовательность Значение
\n новая строка (LF или 0x0A (10) в ASCII)
\r возврат каретки (CR или 0x0D (13) в ASCII)
\t горизонтальная табуляция (HT или 0x09 (9) в ASCII)
\v вертикальная табуляция (VT или 0x0B (11) в ASCII) (с PHP 5.2.5)
\e escape-знак (ESC или 0x1B (27) в ASCII) (с PHP 5.4.4)
\f подача страницы (FF или 0x0C (12) в ASCII) (с PHP 5.2.5)
\\ обратная косая черта
\$ знак доллара
\" двойная кавычка
\{1,3} последовательность символов, соответствующая регулярному выражению символа в восьмеричной системе счисления, который молча переполняется, чтобы поместиться в байт (т.е. "\400" === "\000")
\x{1,2} последовательность символов, соответствующая регулярному выражению символа в шестнадцатеричной системе счисления
\u{+} последовательность символов, соответствующая регулярному выражению символа Unicode, которая отображается в строка в представлении UTF-8 (добавлено в PHP 7.0.0)

Как и в строке, заключенной в одинарные кавычки, экранирование любого символа выведет также и сам символ экранирования. До версии PHP 5.1.1, обратный слеш в \{$var} не печатался.

Heredoc

Третий способ определения строк - это использование heredoc-синтаксиса: . После этого оператора необходимо указать идентификатор, затем перевод строки. После этого идет сама строка, а потом этот же идентификатор, закрывающий вставку.

Строка должна начинаться с закрывающего идентификатора, т.е. он должен стоять в первом столбце строки. Кроме того, идентификатор должен соответствовать тем же правилам именования, что и все остальные метки в PHP: содержать только буквенно-цифровые символы и знак подчеркивания, и не должен начинаться с цифры (знак подчеркивания разрешается).

Внимание

Очень важно отметить, что строка с закрывающим идентификатором не должна содержать других символов, за исключением точки с запятой (; ). Это означает, что идентификатор не должен вводиться с отступом и что не может быть никаких пробелов или знаков табуляции до или после точки с запятой. Важно также понимать, что первым символом перед закрывающим идентификатором должен быть символ новой строки, определенный в вашей операционной системе. Например, в UNIX системах, включая macOS, это \n . После закрывающего идентификатора также сразу должна начинаться новая строка.

Если это правило нарушено и закрывающий идентификатор не является "чистым", считается, что закрывающий идентификатор отсутствует и PHP продолжит его поиск дальше. Если в этом случае верный закрывающий идентификатор так и не будет найден, то это вызовет ошибку парсинга с номером строки в конце скрипта.

Пример #1 Пример неправильного синтаксиса

class foo {
public $bar = bar
EOT;
// отступ перед закрывающим идентификатором недопустим
}
?>

Пример #2 Пример правильного синтаксиса

class foo {
public $bar = bar
EOT;
}
?>

Heredoc не может быть использован для инициализации полей класса. Начиная с версии PHP 5.3, это ограничение распространяется только на heredoc, содержащие внутри себя переменные.

Heredoc-текст ведет себя так же, как и строка в двойных кавычках, при этом их не имея. Это означает, что вам нет необходимости экранировать кавычки в heredoc, но вы по-прежнему можете использовать вышеперечисленные управляющие последовательности. Переменные обрабатываются, но с применением сложных переменных внутри heredoc нужно быть также внимательным, как и при работе со строками.

Пример #3 Пример определения heredoc-строки

$str = Пример строки,
охватывающей несколько строк,
с использованием heredoc-синтаксиса.
EOD;

Class foo
{
var $foo ;
var $bar ;

Function __construct ()
{
$this -> foo = "Foo" ;
$this ->
}
}

$foo = new foo ();
$name = "Имярек" ;

echo Меня зовут " $name ". Я печатаю $foo -> foo .
Теперь я вывожу
{ $foo -> bar [ 1 ]} .
Это должно вывести заглавную букву "A": \x41
EOT;
?>

Меня зовут "Имярек". Я печатаю Foo. Теперь, я вывожу Bar2. Это должно вывести заглавную букву "A": A

Также возможно использовать heredoc-синтаксис для передачи данных через аргументы функции:

Начиная с версии 5.3.0, стала возможной инциализация статических переменных и свойств/констант класса с помощью синтаксиса heredoc:

Пример #5 Использование heredoc для инциализации статических переменных

// Статические переменные
function foo ()
{
static $bar = Здесь ничего нет...
LABEL;
}

// Константы/свойства класса
class foo
{
const BAR = Пример использования константы
FOOBAR;

Public $baz = Пример использования поля
FOOBAR;
}
?>

Начиная с PHP 5.3.0, можно также окружать идентификатор Heredoc двойными кавычками:

Nowdoc

Nowdoc - это то же самое для строк в одинарных кавычках, что и heredoc для строк в двойных кавычках. Nowdoc похож на heredoc, но внутри него не осуществляется никаких подстановок . Эта конструкция идеальна для внедрения PHP-кода или других больших блоков текста без необходимости его экранирования. В этом он немного похож на SGML-конструкцию тем, что объявляет блок текста, не предназначенный для обработки.

Nowdoc указывается той же последовательностью , что используется в heredoc, но последующий за ней идентификатор заключается в одинарные кавычки, например, . Все условия, действующие для идентификаторов heredoc также действительны и для nowdoc, особенно те, что относятся к закрывающему идентификатору.

Пример #7 Пример использования nowdoc

echo Пример текста,
занимающего несколько строк,
с помощью синтаксиса nowdoc. Обратные слеши всегда обрабатываются буквально,
например, \\ и \".
EOD;

Результат выполнения данного примера:

Пример текста, занимающего несколько строк, с помощью синтаксиса nowdoc. Обратные слеши всегда обрабатываются буквально, например, \\ и \".

Пример #8 Nowdoc string quoting example with variables

/* Более сложный пример с переменными. */
class foo
{
public $foo ;
public $bar ;

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

$foo = new foo ();
$name = "Имярек" ;

echo Меня зовут "$name". Я печатаю $foo->foo.
Теперь я печатаю {$foo->bar}.
Это не должно вывести заглавную "A": \x41
EOT;
?>

Результат выполнения данного примера:

Меня зовут "$name". Я печатаю $foo->foo. Теперь я печатаю {$foo->bar}. Это не должно вывести заглавную "A": \x41

Пример #9 Пример использования статичных данных

class foo {
public $bar = bar
EOT;
}
?>

Замечание :

Поддержка nowdoc была добавлена в PHP 5.3.0.

Обработка переменных

Если строка указывается в двойных кавычках, либо при помощи heredoc, переменные внутри нее обрабатываются.

Существует два типа синтаксиса: простой и сложный . Простой синтаксис более легок и удобен. Он дает возможность обработки переменной, значения массива (array ) или свойства объекта (object ) с минимумом усилий.

Сложный синтаксис может быть определен по фигурным скобкам, окружающим выражение.

Простой синтаксис

Если интерпретатор встречает знак доллара ($ ), он захватывает так много символов, сколько возможно, чтобы сформировать правильное имя переменной. Если вы хотите точно определить конец имени, заключайте имя переменной в фигурные скобки.

$juice = "apple" ;

echo "He drank some $juice juice." . PHP_EOL ;

// Некорректно. "s" - верный символ для имени переменной, но переменная имеет имя $juice.
echo "He drank some juice made of $juices ." ;

// Корректно. Строго указан конец имени переменной с помощью скобок:
echo "He drank some juice made of ${ juice } s." ;
?>

Результат выполнения данного примера:

He drank some apple juice. He drank some juice made of . He drank some juice made of apples.

Аналогично могут быть обработаны элемент массива (array ) или свойство объекта (object ). В индексах массива закрывающая квадратная скобка (] ) обозначает конец определения индекса. Для свойств объекта применяются те же правила, что и для простых переменных.

Пример #10 Пример простого синтаксиса

define ("KOOLAID" , "koolaid1" );
$juices = array("apple" , "orange" , "koolaid1" => "purple" );

echo "He drank some $juices [ 0 ] juice." . PHP_EOL ;
echo "He drank some $juices [ 1 ] juice." . PHP_EOL ;
echo "He drank some $juices [ koolaid1 ] juice." . PHP_EOL ;

class people {
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Public $smith = "Smith" ;
}

$people = new people ();

echo " $people -> john drank some $juices [ 0 ] juice." . PHP_EOL ;
echo " $people -> john then said hello to $people -> jane ." . PHP_EOL ;
echo " $people -> john "s wife greeted $people -> robert ." . PHP_EOL ;
echo " $people -> robert greeted the two $people -> smiths ." ; // Не сработает
?>

Результат выполнения данного примера:

He drank some apple juice. He drank some orange juice. He drank some purple juice. John Smith drank some apple juice. John Smith then said hello to Jane Smith. John Smith"s wife greeted Robert Paulsen. Robert Paulsen greeted the two .

В PHP 7.1.0 добавлена поддержка отрицательных числовых индексов.

Пример #11 Отрицательные числовые индексы

$string = "string" ;
echo "Символ с индексом -2 равен $string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
echo "Изменение символа на позиции -3 на "o" дает следующую строку: $string ." , PHP_EOL ;
?>

Результат выполнения данного примера:

Символ с индексом -2 равен n. Изменение символа на позиции -3 на "o" дает следующую строку: strong

Для чего-либо более сложного, используйте сложный синтаксис.

Сложный (фигурный) синтаксис

Он называется сложным не потому, что труден в понимании, а потому что позволяет использовать сложные выражения.

Любая скалярная переменная, элемент массива или свойство объекта, отображаемое в строку, может быть представлена в строке этим синтаксисом. Просто запишите выражение так же, как и вне строки, а затем заключите его в { и } . Поскольку { не может быть экранирован, этот синтаксис будет распознаваться только когда $ следует непосредственно за { . Используйте {\$ , чтобы напечатать {$ . Несколько поясняющих примеров:

// Показываем все ошибки
error_reporting (E_ALL );

$great = "здорово" ;

// Не работает, выводит: Это { здорово}
echo "Это { $great }" ;

// Работает, выводит: Это здорово
echo "Это { $great } " ;

// Работает
echo "Этот квадрат шириной { $square -> width } 00 сантиметров." ;

// Работает, ключи, заключенные в кавычки, работают только с синтаксисом фигурных скобок
echo "Это работает: { $arr [ "key" ]} " ;

// Работает
echo "Это работает: { $arr [ 4 ][ 3 ]} " ;

// Это неверно по той же причине, что и $foo вне
// строки. Другими словами, это по-прежнему будет работать,
// но поскольку PHP сначала ищет константу foo, это вызовет
// ошибку уровня E_NOTICE (неопределенная константа).
echo "Это неправильно: { $arr [ foo ][ 3 ]} " ;

// Работает. При использовании многомерных массивов внутри
// строк всегда используйте фигурные скобки
echo "Это работает: { $arr [ "foo" ][ 3 ]} " ;

// Работает.
echo "Это работает: " . $arr [ "foo" ][ 3 ];

echo "Это тоже работает: { $obj -> values [ 3 ]-> name } " ;

echo "Это значение переменной по имени $name : {${ $name }} " ;

echo "Это значение переменной по имени, которое возвращает функция getName(): {${ getName ()}} " ;

echo "Это значение переменной по имени, которое возвращает \$object->getName(): {${ $object -> getName ()}} " ;

// Не работает, выводит: Это то, что возвращает getName(): {getName()}
echo "Это то, что возвращает getName(): {getName()}" ;
?>

С помощью этого синтаксиса также возможен доступ к свойствам объекта внутри строк.

class foo {
var $bar = "I am bar." ;
}

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

Результат выполнения данного примера:

I am bar. I am bar.

Замечание :

Функции, вызовы методов, статические переменные классов, а также константы классов работает внутри {$} , начиная с версии PHP 5. Однако, указываемое значение будет обработано как имя переменной в том же контексте, что и строка, в которой она определяется. Использование одинарных фигурных скобок ({} ) не будет работать для доступа к значениям функций, методов, констант классов или статических переменных класса.

// Показываем все ошибки
error_reporting (E_ALL );

class beers {
const softdrink = "rootbeer" ;
public static $ale = "ipa" ;
}

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

// Это работает, выводит: Я бы хотел A & W
echo "Я бы хотел {${ beers :: softdrink }} \n" ;

// Это тоже работает, выводит: Я бы хотел Alexander Keith"s
echo "Я бы хотел {${ beers :: $ale }} \n" ;
?>

Доступ к символу в строке и его изменение

Символы в строках можно использовать и модифицировать, определив их смещение относительно начала строки, начиная с нуля, в квадратных скобках после строки, например, $str . Думайте о строке для этой цели, как о массиве символов. Если нужно получить или заменить более 1 символа, можно использовать функции substr() и substr_replace() .

Замечание : начиная с PHP 7.1.0, поддерживаются отрицательные значения смещения. Они задают смещение с конца строки. Ранее отрицательные смещение вызывали ошибку уровня E_NOTICE при чтении (возвращая пустую строку) либо E_WARNING при записи (оставляя строку без изменений).

Замечание : К символу в строке также можно обращаться с помощью фигурных скобок, например, $str{42} .

Внимание

Попытка записи в смещение за границами строки дополнит строку пробелами до этого смещения. Нецелые типы будет преобразованы в целые. Неверный тип смещения вызовет ошибку уровня E_WARNING . Используется только первый символ присваемой строки. Начиная с PHP 7.1.0, присвоение пустой строки вызовет фатальную ошибку. Ранее в таком случае присваивался нулевой байт (NULL).

Внимание

Строки в PHP внутренне представляют из себя массивы байт. Как результат, доступ или изменение строки по смещению небезопасно с точки зрения многобайтной кодировки, и должно выполняться только со строками в однобайтных кодировках, таких как, например, ISO-8859-1.

Замечание : Начиная с PHP 7.1.0, использование пустого индекса вызывает фатальную ошибку, ранее в подобном случае строка преобразовывалась в массив без предупреждения.

Пример #12 Несколько примеров строк

// Получение первого символа строки
$str = "This is a test." ;
$first = $str [ 0 ];

// Получение третьего символа строки
$third = $str [ 2 ];

// Получение последнего символа строки
$str = "This is still a test." ;
$last = $str [ strlen ($str )- 1 ];

// Изменение последнего символа строки
$str = "Look at the sea" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

Начиная с PHP 5.4 смещение в строке должно задаваться либо целым числом, либо строкой, содержащей цифры, иначе будет выдаваться предупреждение. Ранее смещение, заданное строкой вида "foo" , без предупреждений преобразовывалось в 0 .

Пример #13 Различия между PHP 5.3 и 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" ]));
?>

Результат выполнения данного примера в PHP 5.3:

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

Результат выполнения данного примера в PHP 5.4:

string(1) "b" bool(true) Warning: Illegal string offset "1.0" in /tmp/t.php on line 7 string(1) "b" bool(false) Warning: Illegal string offset "x" in /tmp/t.php on line 9 string(1) "a" bool(false) string(1) "b" bool(false)

Замечание :

Попытка доступа к переменным других типов (исключая массивы или объекты, реализующие определенные интерфейсы) с помощью или {} молча вернет NULL .

Замечание :

В PHP 5.5 была добавлена поддержка доступа к символам в строковых литералах с помощью синтаксиса или {} .

Для модификации строк существует множество полезных функций.

Основные функции описаны в разделе строковых функций , а для расширенного поиска и замены - функции Perl-совместимых регулярных выражений .

Преобразование в строку

Значение может быть преобразовано в строку с помощью приведения (string) , либо функции strval() . В выражениях, где необходима строка, преобразование происходит автоматически. Это происходит, когда вы используете функции echo или print , либо когда значение переменной сравнивается со строкой. Прочтение разделов руководства Типы и Манипуляции с типами сделает следующее более понятным. Смотрите также settype() .

Массивы всегда преобразуются в строку "Array" , так что вы не можете отобразить содержимое массива (array ), используя echo или print , чтобы узнать, что он содержит. Чтобы просмотреть отдельный элемент, используйте что-нибудь вроде echo $arr["foo"] . Смотрите ниже советы о том, как отобразить/просмотреть все содержимое.

Для преобразования переменной типа "Object" в тип string используется магический метод __toString .

Значение NULL всегда преобразуется в пустую строку.

Как вы могли видеть выше, прямое преобразование в строку массивов, объектов или ресурсов не дает никакой полезной информации о самих значениях, кроме их типов. Более подходящий способ вывода значений для отладки - использовать функции print_r() и var_dump() .

Большинство значений в PHP может быть преобразовано в строку для постоянного хранения. Этот метод называется сериализацией и может быть выполнен при помощи функции serialize() .

Преобразование строк в числа

Если строка распознается как числовое значение, результирующее значение и тип определяется так, как показано далее.

Если строка не содержит какой-либо из символов ".", "e", или "E", и значение числа помещается в пределы целых чисел (определенных PHP_INT_MAX ), строка будет распознана как целое число (integer ). Во всех остальных случаях она считается числом с плавающей точкой (float ).

Значение определяется по начальной части строки. Если строка начинается с верного числового значения, будет использовано это значение. Иначе значением будет 0 (ноль). Верное числовое значение - это одна или более цифр (могущих содержать десятичную точку), по желанию предваренных знаком с последующим необязательным показателем степени. Показатель степени - это "e" или "E" с последующими одной или более цифрами.

$foo = 1 + "10.5" ; // $foo это float (11.5)
$foo = 1 + "-1.3e3" ; // $foo это float (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo это integer (1)
$foo = 1 + "bob3" ; // $foo это integer (1)
$foo = 1 + "10 Small Pigs" ; // $foo это integer (11)
$foo = 4 + "10.2 Little Piggies" ; // $foo это float (14.2)
$foo = "10.0 pigs " + 1 ; // $foo это float (11)
$foo = "10.0 pigs " + 1.0 ; // $foo это float (11)
?>

Более подробную информацию об этом преобразовании смотрите в разделе о strtod(3) документации Unix.

Если вы хотите протестировать любой из примеров этого раздела, скопируйте и вставьте его и следующую строку, чтобы увидеть, что происходит:

echo "\$foo== $foo ; тип: " . gettype ($foo ) . "
\n" ;
?>

Не ожидайте получить код символа, преобразовав его в целое (как это делается, например, в C). Для преобразования символов в их ASCII-коды и обратно используйте функции ord() и chr() .

Подробности реализации строкового типа

7 years ago

The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.

$foo = abcd
END;
?>

This does not:

foo (abcd
END;
);
// syntax error, unexpected ";"
?>

Without semicolon, it works fine:

foo (abcd
END
);
?>

3 years ago

You can use string like array of char (like C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

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

// -- With array cast --
var_dump((array) $a);
// Return array(1) { => string(17) "String array test"}

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

Norihiori

15 years ago

You can use the complex syntax to put the value of both object properties AND object methods inside a string. For example...
class Test {
public $one = 1 ;
public function two () {
return 2 ;
}
}
$test = new Test ();
echo "foo { $test -> one } bar { $test -> two ()} " ;
?>
Will output "foo 1 bar 2".

However, you cannot do this for all values in your namespace. Class constants and static properties/methods will not work because the complex syntax looks for the "$".
class Test {
const ONE = 1 ;
}
echo "foo {Test::ONE} bar" ;
?>
This will output "foo {Test::one} bar". Constants and static properties require you to break up the string.

3 years ago

Beware that consistent with "String conversion to numbers":

If ("123abc" == 123 ) echo "(intstr == int) incorrectly tests as true." ;

// Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number.

// True for all conditionals such as if and switch statements (probably also while loops)!

// This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer.

// It seems the only fix is for 123 to be a string as "123" so no conversion happens.

?>

6 years ago

Leading zeroes in strings are (least-surprise) not treated as octal.
Consider:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x is $x, y is $y"; //prints "x is 123, y is 83"
in other words:
* leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
* leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().

10 years ago

Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:

// Hack declaration
function _expr ($v ) { return $v ; }
$_expr = "_expr" ;

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

$a = 3 ;
$b = 4 ;

function c ($a , $b ) { return $a + $b ; }

echo "pre { $_expr (1 + 2 )} post\n" ; echo "pre { $_expr (qwe )} post\n" ; echo "pre { $_expr (c ($a , $b )+ zxc * 2 )} post\n" ;

// General syntax is {$_expr(...)}
?>

2 years ago

I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site.

Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages.

An expression such as:

$fruit =array(
"a" => "apple" ,
"b" => "banana" ,
);

Print "This is a $fruit [ "a"]" ; ?>

will definitely fall to pieces.

You can resolve it as follows:

print "This is a $fruit [ a ] " ; print "This is a ${ fruit [ "a" ]} " ; print "This is a { $fruit [ "a" ]} " ; ?>

I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.

It’s not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string - once the string is already being parsed the quotes just get in the way … ?

2 years ago

Both should work:(

class Testing {
public static
$VAR = "static" ;
public const VAR =
"const" ;

Public function sayHelloStatic () {
echo
"hello: { $this :: $VAR } " ;
}

Public function sayHelloConst () {
echo
"hello: { $this ::VAR} " ; }
}

$obj = new Testing ();
$obj -> sayHelloStatic ();
$obj -> sayHelloConst ();

3 years ago

Something I experienced which no doubt will help someone . . .
In my editor, this will syntax highlight HTML and the $comment:

$html = $comment
EOD;

Using this shows all the same colour:

$html = $comment
EOD;

making it a lot easier to work with

11 years ago

To save Your mind don"t read previous comments about dates ;)

When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:

var_dump ("1.22" > "01.23" ); var_dump ("1.22.00" > "01.23.00" ); var_dump ("1-22-00" > "01-23-00" ); var_dump ((float) "1.22.00" > (float) "01.23.00" ); ?>

Строки в PHP обрамляются одинарными или двойными кавычками. Главное различие в том, что в двойные кавычки можно подставить переменную:

Теперь мы можем придумать ещё одно решение задачи из урока Переменные в PHP :

$title"; echo "

$content

"; ?>

Как PHP находит переменную в строке?

Всё просто. Помните, какие символы могут использоваться в названии переменной? Это цифры, буквы и подчёркивание _ .

Вот PHP и принимает за название всё, что находится между символом $ и первым запрещённым символом.

В следующем коде PHP неправильно определит название переменной и выдаст ошибку:

Результат в браузере:

Notice: Undefined variable: priceруб in D:\OpenServer\domains\сайт\index.php on line 3

Чтобы PHP правильно определил название переменной в строке, нужно поместить её в фигурные скобки {} :

Результат в браузере:

1499руб

Нет однозначного мнения, какие кавычки нужно использовать для обычных строк, в которые ничего не нужно подставлять. Однако, многие программисты предпочитают использовать одинарные кавычки.

Дело в том, что двойные кавычки у многих вызывают ассоциацию "в эту строку что-то должно подставляться". Поэтому я рекомендую использовать одинарные кавычки для обычного текста, а двойные - только когда в текст нужно подставить переменную. Пример:

Экранирование кавычек

Если вам нужно поместить кавычки внутрь строки, есть 2 способа это сделать:

Во втором примере обратный слеш \ экранирует следующую за ним кавычку, чтобы PHP воспринял её как строку.

Как думаете, что нужно сделать, чтобы вывести на экран только обратный слеш? Ведь он будет экранировать закрывающую кавычку. Забавно, но нужно написать второй слеш для экранирования первого:

1 Технические характеристики

Фабрика HTTP - это метод, с помощью которого можно создавать новые объекты HTTP, определенные PSR-7. Фабрика HTTP должна реализовывать эти интерфейсы для каждого типа объекта, предоставляемого пакетом.