{"id":59908,"date":"2024-01-12T15:35:19","date_gmt":"2024-01-12T10:05:19","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=59908"},"modified":"2024-01-17T15:52:16","modified_gmt":"2024-01-17T10:22:16","slug":"php-8-unleashed-a-deep-dive-into-enhanced-features","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/php-8-unleashed-a-deep-dive-into-enhanced-features\/","title":{"rendered":"PHP 8 Unleashed: A Deep Dive into Enhanced Features"},"content":{"rendered":"

Introduction:<\/strong><\/h2>\n

PHP, a server-side scripting language powering a vast majority of websites, has taken a giant leap forward with the release of PHP 8. Packed with innovative features and improvements, PHP 8 promises to revolutionize the way developers build web applications. In this comprehensive blog post, we’ll explore the enhanced features of PHP 8, dive into real-world examples to illustrate their practical applications, and ensure that we navigate the topic with due consideration to copyright issues.<\/p>\n

1: JIT Compiler – Turbocharging PHP Performance<\/h2>\n

Traditional PHP interpreters work by translating source code into an intermediate representation, which the Zend Engine then executes. The JIT compiler takes a different approach, translating PHP code into machine code just before execution, optimizing it for the specific system architecture.<\/p>\n

The primary motivation behind the JIT compiler is to improve the execution speed of PHP code significantly. By converting PHP code into machine code at runtime, repetitive tasks can be executed more efficiently, reducing overall execution time. This can profoundly impact the performance of web applications, especially those dealing with complex computations or large datasets.
\nConsider a scenario where a web application involves complex mathematical computations, such as generating statistical reports. Before PHP 8, developers might optimize the algorithm or use caching mechanisms to alleviate performance bottlenecks. With the JIT compiler, the performance of such computations can be enhanced without the need for extensive manual optimizations.<\/p>\n

Example:<\/h4>\n
\n
\/\/ Before PHP 8<\/span><\/code>\r\nfunction<\/span> calculateFactorial<\/span>($n<\/span><\/span>) <\/span>{<\/code>\r\nif<\/span> ($n<\/span> <= 1<\/span>) {<\/code>\r\n\u00a0 \u00a0 return<\/span> 1<\/span>;<\/code>\r\n  }<\/code>\r\n\u00a0 return<\/span> $n<\/span> * calculateFactorial<\/span>($n<\/span> - 1<\/span>);<\/code>\r\n}<\/code>\r\n\/\/ With PHP 8 JIT Compiler<\/span><\/code>\r\n$result<\/span> = calculateFactorial<\/span>(10<\/span>);<\/code>\r\necho<\/span> $result<\/span>;\r\n<\/code><\/pre>\n<\/div>\n
In this example, the JIT compiler optimizes the recursive factorial calculation, resulting in improved performance.<\/p>\n
2: Named Arguments – Clarity and Flexibility in Function Calls<\/h2>\n
PHP 8 introduces named arguments, a feature designed to enhance code readability and provide developers greater flexibility when calling functions. Named arguments make function calls more readable by allowing developers to pass values by explicitly specifying parameter names.<\/p>\n
Example:<\/h4>\n
\n
\/\/ Before PHP 8<\/span><\/code>\r\nfunction<\/span> createPerson<\/span>($name<\/span>, $age<\/span>, $city<\/span><\/span>) <\/span>{<\/code>\r\n  \/\/ Function logic<\/span><\/code>\r\n}<\/code>\r\ncreatePerson<\/span>(\"John Doe\"<\/span>, 25<\/span>, \"New York\"<\/span>);<\/code>\r\n\/\/ With Named Arguments<\/span><\/code>\r\nfunction<\/span> createPersonWithNamedArgs<\/span>($name<\/span>, $age<\/span>, $city<\/span><\/span>) <\/span>{<\/code>\r\n  \/\/ Function logic<\/span><\/code>\r\n}<\/code>\r\ncreatePersonWithNamedArgs<\/span>(name<\/span>: \"John Doe\"<\/span>, age<\/span>: 25<\/span>, city<\/span>: \"New York\"<\/span>);\r\n<\/code><\/pre>\n<\/div>\n
Named arguments improve code readability and reduce the chance of passing arguments in the wrong order.<\/p>\n
Flexibility in Function Calls<\/h3>\n
Named arguments allow developers to skip optional parameters or specify only the ones they need. This is particularly useful when dealing with functions that have a large number of parameters.<\/p>\n
Example:<\/h4>\n
\/\/ Without Named Arguments<\/span>\r\nconfigureDatabase<\/span>(\"localhost\"<\/span>, \"username\"<\/span>, \"password\"<\/span>, \"my_database\"<\/span>, true<\/span>, true<\/span>);\r\n\r\n\/\/ With Named Arguments<\/span>\r\nconfigureDatabase<\/span>(\r\n    host<\/span>: \"localhost\"<\/span>,\r\n    username<\/span>: \"username\"<\/span>,\r\n    password<\/span>: \"password\"<\/span>,\r\n    database<\/span>: \"my_database\"<\/span>\r\n);<\/code><\/pre>\n
We’ve skipped the optional parameters, providing only the values for the necessary ones. This enhances the expressiveness of the code and reduces the chance of errors due to misplaced arguments.<\/p>\n
3: Attributes – Adding Metadata to Code<\/h2>\n
Attributes, also known as annotations in other languages, allow developers to add metadata to code elements, providing additional information to frameworks and tools.<\/p>\n
Example:<\/h4>\n
\n
\/\/ Define an attribute<\/span><\/code>\r\n#[Author<\/span>(\"Jane Smith\"<\/span>)]<\/span><\/code>\r\nclass<\/span> Article<\/span><\/span>{<\/code>\r\n\u00a0 #[Title<\/span>(\"PHP 8 Enhanced Features\"<\/span>)]<\/span><\/code>\r\npublic<\/span> function<\/span> publish<\/span>() <\/span>{<\/code>\r\n  \u00a0 \/\/ Publishing logic<\/span><\/code>\r\n  }<\/code>\r\n}<\/code>\r\n\/\/ Accessing attributes<\/span><\/code>\r\n$classAttributes<\/span> = attributes<\/span>(Article<\/span>::class<\/span>);<\/code>\r\n$methodAttributes<\/span> = attributes<\/span>([Article<\/span>::class<\/span>, 'publish'<\/span>]);\r\n<\/code><\/pre>\n<\/div>\n
Attributes enhance code expressiveness and facilitate better documentation.<\/p>\n
4: Union Types – Enhanced Type Safety<\/h2>\n
PHP 8 introduces union types, allowing developers to specify that a variable can have one of several types. Traditional type declarations in PHP often involve specifying a single type for a variable, limiting the flexibility to accept multiple valid types.<\/p>\n
Example:<\/h4>\n
\n
\/\/ Before PHP 8<\/span><\/code>\r\nfunction<\/span> processUserData<\/span>($data<\/span><\/span>) <\/span>{<\/code>\r\n  \/\/ Process user data<\/span><\/code>\r\n}<\/code>\r\n\/\/ With Union Types<\/span><\/code>\r\nfunction<\/span> processUserDataWithUnionType<\/span>(string<\/span>|int<\/span> $data<\/span><\/span>) <\/span>{<\/code>\r\n  \/\/ Process user data<\/span><\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
Union types provide clearer type declarations, reducing the likelihood of unexpected runtime errors.<\/p>\n
Enhanced Type Safety:<\/h3>\n
Union types contribute to enhanced type safety by explicitly declaring the acceptable types for a variable. This reduces the likelihood of runtime errors caused by unexpected types.<\/p>\n
Example:<\/h4>\n
function<\/span> divideNumbers<\/span>(float<\/span>|int<\/span> $a<\/span>, float<\/span>|int<\/span> $b<\/span><\/span>): float<\/span>|int<\/span> <\/span>{<\/code>\r\n\u00a0 if<\/span> ($b<\/span> === 0<\/span>) {<\/code>\r\n\u00a0 \u00a0 return<\/span> 0<\/span>; \/\/ Handle division by zero<\/span><\/code>\r\n  }<\/code>\r\n\u00a0 return<\/span> $a<\/span> \/ $b<\/span>;<\/code>\r\n}\r\n<\/code><\/pre>\n
In this example, the divideNumbers<\/code> function can handle both float and int types for its parameters, improving type safety.<\/p>\n
Union types play well with nullable types, allowing developers to specify that a variable can be of a certain type or null<\/code>.<\/p>\n
5: Match Expression – Simplifying Switch Statements<\/h2>\n
The match expression in PHP 8 is an enhanced version of the switch statement, offering a more concise syntax and improved functionality.<\/p>\n
Example:<\/h4>\n
\n
\/\/ Before PHP 8<\/span><\/code>\r\nfunction<\/span> getStatusMessage<\/span>($status<\/span><\/span>) <\/span>{<\/code>\r\n\u00a0 switch<\/span> ($status<\/span>) {<\/code>\r\n\u00a0 \u00a0 case<\/span> 'success'<\/span>:<\/code>\r\n\u00a0 \u00a0 \u00a0 return<\/span> 'Operation successful'<\/span>;<\/code>\r\n\u00a0 \u00a0 case<\/span> 'error'<\/span>:<\/code>\r\n\u00a0 \u00a0 \u00a0 return<\/span> 'An error occurred'<\/span>;<\/code>\r\n\u00a0 \u00a0 default<\/span>:<\/code>\r\n\u00a0 \u00a0 \u00a0 return<\/span> 'Unknown status'<\/span>;<\/code>\r\n  }<\/code>\r\n}<\/code>\r\n\/\/ With Match Expression<\/span><\/code>\r\nfunction<\/span> getStatusMessageWithMatch<\/span>($status<\/span><\/span>) <\/span>{<\/code>\r\n\u00a0 return<\/span> match<\/span> ($status<\/span>) {<\/code>\r\n\u00a0 \u00a0 'success'<\/span> => 'Operation successful'<\/span>,<\/code>\r\n\u00a0 \u00a0 'error'<\/span> => 'An error occurred'<\/span>,<\/code>\r\n\u00a0 \u00a0 default<\/span> => 'Unknown status'<\/span>,<\/code>\r\n  };<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
The match expression simplifies the syntax and enhances code readability.<\/p>\n
Handling Complex Conditions:<\/h3>\n
One of the match expression’s strengths lies in its ability to handle complex conditions more efficiently than switch statements.<\/p>\n
Example:<\/h4>\n
$grade<\/span> = 'B'<\/span>;\r\n$result<\/span> = match<\/span> (true<\/span>) {\r\n    $grade<\/span> == 'A'<\/span> => 'Excellent'<\/span>,\r\n    $grade<\/span> == 'B'<\/span> => 'Good'<\/span>,\r\n    $grade<\/span> == 'C'<\/span> => 'Average'<\/span>,\r\n    default<\/span> => 'Fail'<\/span>,\r\n};\r\necho<\/span> $result<\/span>;<\/code><\/pre>\n
Here, the match expression evaluates a set of conditions and returns the corresponding result based on the first true condition.<\/p>\n
6: Nullsafe Operator – Mitigating Null Pointer Woes<\/h2>\n
Handling null values and preventing null pointer exceptions has long been a concern for developers. Traditional null checks can lead to verbose and error-prone code, especially when dealing with nested objects or arrays. The nullsafe operator (?-><\/code>) simplifies and streamlines null checks, allowing developers to access properties or call methods on potentially null objects without the need for explicit checks.<\/p>\n
Example:<\/h4>\n
\n
\/\/ Before PHP 8<\/span><\/code>\r\n$length<\/span> = 0<\/span>;<\/code>\r\nif<\/span> ($user<\/span> !== null<\/span>) {<\/code>\r\n\u00a0 $address<\/span> = $user<\/span>->getAddress<\/span>();<\/code>\r\n\u00a0 if<\/span> ($address<\/span> !== null<\/span>) {<\/code>\r\n\u00a0 \u00a0 $length<\/span> = $address<\/span>->getLength<\/span>();<\/code>\r\n  }<\/code>\r\n}<\/code>\r\n\/\/ With Nullsafe Operator<\/span>\r\n$length<\/span> = $user<\/span>?->getAddress<\/span>()?->getLength<\/span>() ?? 0<\/span>;\r\n<\/code><\/pre>\n<\/div>\n
In this example, if $user<\/code>, $user->getAddress()<\/code>, or $user->getAddress()->getLength()<\/code> is null, the entire expression evaluates to 0. This helps prevent null pointer exceptions and ensures a default value in case of null. The nullsafe operator reduces the need for verbose null checks, resulting in cleaner code.<\/p>\n
The nullsafe operator in PHP 8 offers a powerful and concise solution to the longstanding challenge of handling null values. By simplifying the syntax for null checks, it improves code readability and reduces the risk of null pointer exceptions.<\/p>\n
7: Constructor Property Promotion – Streamlining Object Initialization<\/h2>\n
Constructor property promotion in PHP 8 allows developers to declare and initialize class properties directly in the constructor, reducing the need for repetitive boilerplate code.<\/p>\n
Example:<\/h4>\n
\n
\/\/ Before PHP 8<\/span><\/code>\r\nclass<\/span> MainPoints<\/span> <\/span>{<\/code>\r\n\u00a0 public<\/span> float<\/span> $x<\/span>;\r\npublic<\/span> float<\/span> $y<\/span>;<\/code>\r\n\u00a0 public<\/span> function<\/span> __construct<\/span>(float<\/span> $x<\/span>, float<\/span> $y<\/span><\/span>) <\/span>{<\/code>\r\n\u00a0 \u00a0 $this<\/span>->x = $x<\/span>;\r\n$this<\/span>->y = $y<\/span>;<\/code>\r\n  }<\/code>\r\n}<\/code>\r\n\/\/ With Constructor Property Promotion<\/span><\/code>\r\nclass<\/span> MainPointsWithPromotion<\/span> <\/span>{<\/code>\r\n\u00a0 public<\/span> function<\/span> __construct<\/span>(public<\/span> float<\/span> $x<\/span>, public<\/span> float<\/span> $y<\/span><\/span>) <\/span>{}<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
Constructor property promotion enhances code maintainability by reducing redundancy in property initialization. Constructor property promotion supports visibility modifiers (public, protected, private) and other property modifiers such as static<\/code>.<\/p>\n
Type Declarations with Promotion:<\/h3>\n
Constructor property promotion supports type declarations, enhancing code clarity and contributing to type safety.<\/p>\n
Example:<\/h4>\n
\n
class<\/span> Order<\/span> <\/span>{<\/code>\r\n\u00a0 public<\/span> function<\/span> __construct<\/span>(\r\npublic<\/span> string<\/span> $orderId<\/span>,\r\npublic<\/span> array<\/span> $items<\/span>,\r\npublic<\/span> DateTime $orderDate<\/span>\r\n<\/span>) <\/span>{<\/code>\r\n  \u00a0 \/\/ Initialization logic<\/span><\/code>\r\n  }<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
In this example, the Order<\/code> class ensures that $orderDate<\/code> is an instance of DateTime<\/code>, contributing to more precise type declarations.<\/p>\n
8: Error Exceptions in PHP 8<\/h2>\n
Named Errors:<\/h3>\n
In PHP 8, named errors provide a more descriptive and meaningful way to handle errors. Previously, developers had to rely on error codes or constants to identify specific errors. Named errors make error handling more expressive and easier to understand.<\/p>\n
Example:<\/h4>\n
\n
try<\/span> {<\/code>\r\n  \/\/ Some code that may throw an error<\/span><\/code>\r\n} catch<\/span> (MyCustomError $error<\/span>) {<\/code>\r\n\u00a0 \/\/ Handle MyCustomError<\/span>\r\necho<\/span> \"Caught MyCustomError: \"<\/span> . $error<\/span>->getMessage<\/span>();<\/code>\r\n} catch<\/span> (AnotherError $error<\/span>) {<\/code>\r\n\u00a0 \/\/ Handle AnotherError<\/span>\r\necho<\/span> \"Caught AnotherError: \"<\/span> . $error<\/span>->getMessage<\/span>();<\/code>\r\n} catch<\/span> (Exception<\/span> $e<\/span>) {<\/code>\r\n\u00a0 \/\/ Generic catch for other exceptions<\/span>\r\necho<\/span> \"Caught generic exception: \"<\/span> . $e<\/span>->getMessage<\/span>();<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
Here, MyCustomError<\/code> and AnotherError<\/code> are named errors that provide more context about the nature of the error being caught.<\/p>\n
Throwable Interface:<\/h3>\n
PHP 8 introduces the Throwable<\/code> interface, which is the base interface for all errors and exceptions in PHP. This unification allows developers to catch both errors and exceptions using a single catch block.<\/p>\n
Example:<\/h4>\n
\n
try<\/span> {<\/code>\r\n  \/\/ Some code that may throw an error or exception<\/span><\/code>\r\n} catch<\/span> (Throwable<\/span> $throwable<\/span>) {<\/code>\r\n\u00a0 \/\/ Handle both errors and exceptions<\/span>\r\necho<\/span> \"Caught throwable: \"<\/span> . $throwable<\/span>->getMessage<\/span>();<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
Now, a single catch block can handle any object that implements the Throwable<\/code> interface, providing a more consistent approach to error handling.<\/p>\n
Throw Expression:<\/h3>\n
PHP 8 introduces the throw expression, allowing exceptions to be thrown in expressions. This feature enhances the conciseness of code by enabling developers to throw exceptions directly within an expression.<\/p>\n
Example:<\/h4>\n
\n
function<\/span> divide<\/span>($numerator<\/span>, $denominator<\/span><\/span>) <\/span>{<\/code>\r\n  \/\/ Using throw expression to handle division by zero<\/span><\/code>\r\n\u00a0 $result<\/span> = $denominator<\/span> !== 0<\/span> ? $numerator<\/span> \/ $denominator<\/span> : throw<\/span> new<\/span> Exception<\/span>(\"Cannot divide by zero\"<\/span>);<\/code>\r\n\u00a0 return<\/span> $result<\/span>;<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
In this example, the throw new Exception(...)<\/code> expression is part of the conditional operator (? :<\/code>), allowing for concise error handling within the expression itself.<\/p>\n
9: Weak Maps in PHP 8 – Managing Object References<\/h2>\n
In PHP, traditional arrays or objects that reference other objects can inadvertently prevent those objects from being garbage collected. This can lead to memory leaks and increased resource usage. Weak Maps addresses this challenge by allowing developers to associate data with objects without creating strong references. This means the object referenced in a Weak Map can still be garbage collected if no other references exist.<\/p>\n
The basic syntax of Weak Maps involves creating a new WeakMap object and using its set<\/code> and get<\/code> methods to associate and retrieve data, respectively.<\/p>\n
\n
\n
Example:<\/h4>\n<\/div>\n<\/div>\n
$weakMap<\/span> = new<\/span> WeakMap<\/span>();\r\n\r\n\/\/ Associating data with an object<\/span>\r\n$object<\/span> = new<\/span> stdClass<\/span>();\r\n$weakMap<\/span>->set<\/span>($object<\/span>, 'Associated Data'<\/span>);\r\n\r\n\/\/ Retrieving data from the Weak Map<\/span>\r\n$data<\/span> = $weakMap<\/span>->get<\/span>($object<\/span>);\r\n\r\n\/\/ Removing the association<\/span>\r\n$weakMap<\/span>->delete<\/span>($object<\/span>);<\/code><\/pre>\n
Caching:<\/h3>\n
Weak Maps are useful for implementing caching mechanisms where data is associated with objects but doesn’t prevent those objects from being garbage collected.<\/p>\n
\n
\n
Example:<\/h4>\n<\/div>\n<\/div>\n
\n
class<\/span> Cache<\/span> <\/span>{<\/code><\/pre>\n
\u00a0 private<\/span> WeakMap<\/span> $cache<\/span>;<\/code><\/p>\n
public<\/span> function<\/span> __construct<\/span>() <\/span>{<\/p>\n
\u00a0 \u00a0 $this<\/span>->cache = new<\/span> WeakMap<\/span>();<\/code>\r\n  }<\/code>\r\n\u00a0 public<\/span> function<\/span> getData<\/span>(object<\/span> $key<\/span><\/span>): ?string<\/span><\/span>{<\/code>\r\n\u00a0 \u00a0 return<\/span> $this<\/span>->cache->get<\/span>($key<\/span>);<\/code>\r\n  }<\/code>\r\n\u00a0 public<\/span> function<\/span> cacheData<\/span>(object<\/span> $key<\/span>, string<\/span> $data<\/span><\/span>) <\/span>{<\/code>\r\n\u00a0 \u00a0 $this<\/span>->cache->set<\/span>($key<\/span>, $data<\/span>);<\/code>\r\n  }<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
Memoisation:<\/h3>\n
Weak Maps can be used in memoisation to store calculated values associated with specific objects, allowing the objects to be garbage collected when no longer needed.<\/p>\n
\n
\n
Example:<\/h4>\n<\/div>\n<\/div>\n
\n
class<\/span> Calculator<\/span> <\/span>{<\/code><\/pre>\n
\u00a0 private<\/span> WeakMap<\/span> $results<\/span>;<\/code><\/p>\n
public<\/span> function<\/span> __construct<\/span>() <\/span>{<\/p>\n
\u00a0 \u00a0 $this<\/span>->results = new<\/span> WeakMap<\/span>();<\/code>\r\n  }<\/code>\r\n\u00a0 public<\/span> function<\/span> calculateExpensiveOperation<\/span>(object<\/span> $input<\/span><\/span>): int<\/span><\/span>{<\/code>\r\n  \u00a0 \/\/ Check if result is already memoized<\/span><\/code>\r\n\u00a0 \u00a0 if<\/span> ($this<\/span>->results->has<\/span>($input<\/span>)) {<\/code>\r\n\u00a0 \u00a0 \u00a0 return<\/span> $this<\/span>->results->get<\/span>($input<\/span>);<\/code>\r\n  \u00a0 }<\/code>\r\n  \u00a0 \/\/ Perform the expensive operation<\/span><\/code>\r\n\u00a0 \u00a0 $result<\/span> = \/* perform calculation *\/<\/span>;<\/code>\r\n  \u00a0 \/\/ Memoize the result<\/span><\/code><\/pre>\n
\u00a0 \u00a0 $this<\/span>->results->set<\/span>($input<\/span>, $result<\/span>);<\/code><\/p>\n
return<\/span> $result<\/span>;<\/p>\n
  }<\/code>\r\n}\r\n<\/code><\/pre>\n<\/div>\n
Benefits of Weak Maps:<\/h3>\n
    \n
  1. Preventing Memory Leaks:<\/strong> Weak Maps prevent unintentional memory leaks by allowing objects to be garbage collected when no longer in use.<\/li>\n
  2. Cleaner Resource Management:<\/strong> When dealing with object references, Weak Maps provides a cleaner way to associate data without creating strong references that impede garbage collection.<\/li>\n
  3. Efficient Caching:<\/strong> In scenarios where caching is involved, Weak Maps ensures that cached data is associated with objects only as long as those objects are reachable.<\/li>\n<\/ol>\n
    Conclusion: Embracing the Future of PHP Development<\/h2>\n
    In conclusion, PHP 8 has ushered in a new era for PHP development, offering a suite of features that enhance performance, readability, and maintainability. As developers, embracing these enhancements can lead to more efficient and robust codebases. However, it’s crucial to remain mindful of copyright issues when incorporating code examples and snippets from external sources. Always attribute and seek permission when necessary, ensuring ethical and responsible sharing of knowledge within the developer community. With PHP 8, the future of web development looks brighter than ever, and by staying informed and respecting intellectual property rights, developers can navigate this exciting landscape responsibly.<\/p>\n
    <\/div>","protected":false},"excerpt":{"rendered":"
    Introduction: PHP, a server-side scripting language powering a vast majority of websites, has taken a giant leap forward with the release of PHP 8. Packed with innovative features and improvements, PHP 8 promises to revolutionize the way developers build web applications. In this comprehensive blog post, we’ll explore the enhanced features of PHP 8, dive […]<\/p>\n","protected":false},"author":1527,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":4},"categories":[3602],"tags":[5261,227,477,5597],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/59908"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1527"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=59908"}],"version-history":[{"count":3,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/59908\/revisions"}],"predecessor-version":[{"id":60084,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/59908\/revisions\/60084"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=59908"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=59908"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=59908"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}