Per anni, imparare a sviluppare blocchi Gutenberg ha richiesto una conoscenza approfondita di tecnologie come React e Node.js, oltre a complesse procedure di compilazione e strumenti JavaScript.

Tuttavia, lo sviluppo di WordPress si sta evolvendo ed è ora possibile creare e gestire blocchi Gutenberg interamente in PHP.

Ciò è particolarmente vantaggioso per chi preferisce evitare lo sviluppo con React e il JavaScript lato server (JS). Riduce la curva di apprendimento, semplifica l’esperienza di sviluppatori e sviluppatrici e consente prestazioni più elevate eliminando il sovraccarico di script front-end non necessari.

Nelle sezioni seguenti vedremo come sfruttare queste nuove funzionalità per creare blocchi Gutenberg esclusivamente in PHP. Nel corso del tutorial impareremo a creare siti web WordPress più snelli, veloci e facili da mantenere.

Molto interessante, vero? Cominciamo.


Cosa sono i blocchi solo PHP e perché sono importanti?

In passato, la creazione di un blocco Gutenberg richiedeva competenze avanzate di programmazione in JavaScript lato server e React. Ciò ha rappresentato un ostacolo all’adozione dell’editor a blocchi da parte degli sviluppatori WordPress di lunga data che forse non possedevano le competenze necessarie in React e Node.js knowledge.

Le cose però stanno cambiando. A partire da Gutenberg 21.8, si possono registrare i blocchi Gutenberg utilizzando nient’altro che PHP. In questo modo si evitano le complessità legate alla configurazione di un ambiente Node.js per chi non lavora con JavaScript lato server.

Con la registrazione dei blocchi esclusivamente in PHP, è possibile registrare e visualizzare i blocchi sia nell’editor che nell’interfaccia pubblica utilizzando lo stesso codice PHP. Ciò incoraggia i siti che utilizzano temi ibridi o le tradizionali funzioni PHP e shortcode ad adottare e sviluppare contenuti nell’editor di blocchi.

Per chi volesse saperne di più, ecco le principali richieste di pull su GitHub dedicate ai blocchi esclusivamente in PHP.

Come creare il primo blocco Gutenberg solo in PHP

Quando un blocco è registrato solo sul lato server — senza file JS — e il nuovo flag di supporto auto_register è impostato su true, l’editor utilizza automaticamente il componente ServerSideRender per registrare il blocco sul lato client e visualizzarne l’anteprima. In sostanza, il contenuto del blocco viene ora generato direttamente dal codice PHP sia nell’editor che nel frontend.

Per chiarire, ecco un semplice esempio in PHP che registra un blocco utilizzando il metodo in solo PHP.

/**
 * Render callback (frontend and editor)
 */
function my_php_only_block_render( $attributes ) {
	return '<div>
		<h3>🚀 PHP-only Block</h3>
		<p>This block was created with only PHP!</p>
	</div>';
}

/**
 * Register the block on the 'init' hook.
 */
add_action( 'init', function() {
	register_block_type( 'my-plugin/php-only-test-block', array(
		'title'           => 'My PHP-only Block',
		'icon'            => 'welcome-learn-more',
		'category'        => 'text',
		'render_callback' => 'my_php_only_block_render',
		'supports'        => array(
			// Automatically registers the block in the Editor JS (previously auto_ssr)
			'auto_register' => true, 
		),
	) );
});

Puoi provare questo codice copiandolo e incollandolo nel file principale di un plugin personalizzato. Dopo aver attivato il plugin, dovresti vedere il blocco “My PHP-Only Block” nel Block Inserter.

Un semplice blocco scritto solo in PHP nell'editor dei blocchi
Un semplice blocco scritto solo in PHP

La funzione register_block_type registra un tipo di blocco sul server. Ora include il nuovo supporto per auto_register, indicando a Gutenberg di trasmettere i metadati dalla registrazione PHP.

La funzione accetta due argomenti:

  • Il nome del tipo di blocco, compreso lo spazio dei nomi. In questo esempio, il nome del blocco è my-plugin/php-only-test-block.
  • Un array di argomenti per il tipo di blocco. Nel codice sopra riportato, abbiamo impostato title, icon, category, render_callback e supports. Anche in questo caso, per i tipi di blocco solo PHP, l’array supports deve includere 'auto_register' => true.

Oltre a semplificare la creazione di tipi di blocchi personalizzati e a facilitarne l’integrazione nei temi ibridi, i blocchi solo PHP possono essere utilizzati come contenitori per funzioni PHP legacy e shortcode. Inoltre, l’uso dei blocchi solo PHP apre la strada a nuove opportunità per integrazioni personalizzate e funzionalità lato server.

Secondo Héctor Priethor,

Un modello di registrazione interamente basato su PHP semplificherebbe i requisiti minimi per lo sviluppo di blocchi, rendendoli accessibili a un pubblico più ampio di sviluppatori e contribuendo a far crescere l’ecosistema dei blocchi al di là dell’uso avanzato di JavaScript.

Utilizzo degli attributi per creare l’interfaccia utente delle impostazioni del blocco

La PR 74102 consente la generazione automatica di controlli di verifica a partire dalle definizioni degli attributi dei blocchi. Ciò permette agli utenti di configurare l’aspetto e le funzionalità dei blocchi solo PHP come qualsiasi blocco Gutenberg registrato tramite JavaScript.

In precedenza, in React era necessario creare manualmente un file edit.js e definire i vari controlli di impostazione utilizzando i componenti React.

Ora, Gutenberg legge le definizioni degli attributi e genera automaticamente i campi di immissione corrispondenti nell’editor di WordPress.

Il sistema mappa i tipi di dati definiti nell’array attributes alle definizioni dei campi DataForm.

  • 'type' => 'string' crea un campo di testo.
  • 'type' => 'number' crea un campo numerico.
  • 'type' => 'integer' crea un campo intero.
  • 'type' => 'boolean' crea una casella di selezione.
  • 'type' => 'string' with 'enum' => array() crea un campo di selezione.

Ti accorgerai che puoi utilizzare solo alcuni controlli. Se hai bisogno di controlli specifici, come RichText, RangeControl o ToggleControl, dovrai comunque optare per l’approccio JS/React.

Tuttavia, questa novità offre notevoli vantaggi. Le barriere all’ingresso vengono ulteriormente ridotte e non sarà necessario imparare React, Webpack o NPM per creare blocchi personalizzati con semplici opzioni modificabili.

Nell’esempio seguente, estendiamo il blocco di esempio mostrato nella sezione precedente aggiungendo alcuni attributi.

/**
 * 1. Define the block's HTML output.
 */
function my_php_only_block_render( $attributes ) {
	// Extract attributes
	$title   = esc_html( $attributes['blockTitle'] );
	$count   = intval( $attributes['itemCount'] );
	$enabled = $attributes['isEnabled']; // Boolean from the ToggleControl
	$size    = esc_attr( $attributes['displaySize'] );
	
	// Start building the output
	$output = sprintf( '<div class="my-php-block" style="font-size: %s; border: 1px solid #ccc; padding: 15px;">', 
		$size === 'large' ? '20px' : ($size === 'small' ? '12px' : '16px') 
	);
	
	$output .= sprintf( '<h3>🚀 %s</h3>', $title );
	
	// If the toggle is ON, show the list. If OFF, show a fallback message.
	if ( $enabled ) {
		$output .= '<ul>';
		for ( $i = 1; $i <= $count; $i++ ) {
			$output .= sprintf( '<li>Item %d</li>', $i );
		}
		$output .= '</ul>';
	} else {
		$output .= '<p><em>The list is currently disabled.</em></p>';
	}
	
	$output .= '</div>';
	return $output;
}

/**
 * 2. Register the block on 'init'.
 */
add_action( 'init', function() {
	register_block_type( 'my-plugin/php-only-test-block', array(
		'title'           => 'My PHP-only Block',
		'icon'            => 'welcome-learn-more',
		'category'        => 'text',
		'render_callback' => 'my_php_only_block_render',

		// Attributes used to generate the Inspector UI
		'attributes'      => array(
			'blockTitle'  => array(
				'type'    => 'string',
				'default' => 'PHP-only Block',
			),
			'itemCount'   => array(
				'type'    => 'integer',
				'default' => 3,
			),
			'isEnabled'   => array(
				'type'    => 'boolean',
				'default' => true,
			),
			'displaySize' => array(
				'type'    => 'string',
				'enum'    => array( 'small', 'medium', 'large' ),
				'default' => 'medium',
			),
		),

		'supports'        => array(
			'auto_register' => true, 
		),
	) );
});

Basta dare un’occhiata a questo codice per rendersi conto di quanto sia facile registrare un blocco personalizzato con tutte le sue impostazioni di configurazione utilizzando la nuova API. Gli attributi ora vengono utilizzati non solo per memorizzare i dati inseriti dall’utente, ma anche per definire lo schema dell’interfaccia utente. Il codice sopra riportato svolge le seguenti operazioni:

  • La funzione register_block_type registra il tipo di blocco my-plugin/php-only-test-block.
  • Il secondo argomento passato alla funzione è un array contenente i seguenti elementi: title, icon, category, render_callback, attributes, e supports.
  • L’array attributes contiene gli attributi del blocco. Nell’esempio sopra riportato, l’array include gli elementi blockTitle, itemCount, isEnabled e displaySize.
  • 'auto_register' => true abilita la registrazione automatica lato server.

Ecco cosa fa la funzione di callback my_php_only_block_render:

  • In primo luogo, la funzione estrae i valori degli attributi dall’array $attributes e li assegna alle variabili $title, $count, $enabled e $size.
  • Quindi, genera il contenuto del blocco.

Ecco il risultato sullo schermo:

Un blocco solo PHP con impostazioni del blocco
Un blocco solo PHP con impostazioni del blocco

Un esempio concreto di blocchi solo PHP

Sebbene ci siano molti casi in cui JavaScript è ancora necessario, è già possibile fare molto con i blocchi basati esclusivamente su PHP, specialmente se utilizzati insieme alle proprietà dei blocchi.

Nell’esempio seguente, utilizziamo la funzione get_block_wrapper_attributes(), che genera una serie di attributi per il blocco corrente in fase di rendering. Il blocco riceverà automaticamente i colori, i bordi e le ombre impostati dall’utente e applicherà gli stili corrispondenti al contenitore principale. In questo modo, il blocco è personalizzabile tramite gli strumenti nativi di Gutenberg, proprio come un blocco basato su React.

Per vedere come funziona, crea una cartella smart-pricing-widget sul tuo computer. All’interno di questa cartella, crea un file style.css con il seguente codice CSS:

/* style.css */
.pricing-card {
	display: flex;
	flex-direction: column;
	align-items: center;
	text-align: center;
	box-sizing: border-box;
}

.pricing-card h3 {
	margin: 0;
	font-size: 1.5rem;
}

.pricing-card .price-value {
	font-size: 3.5rem;
	font-weight: 800;
	margin: 15px 0;
}

.pricing-card ul {
	list-style: none;
	padding: 25px 0;
	margin: 20px 0;
	width: 100%;
	border-top: 1px solid rgba(128,128,128,0.3);
	display: flex;
	flex-direction: column;
	gap: 12px;
}

.pricing-card li {
	display: flex;
	align-items: center;
	justify-content: center;
	gap: 10px;
}

.pricing-card .cta-button {
	margin-top: auto;
	padding: 15px 25px;
	border-radius: 8px;
	text-decoration: none;
	font-weight: bold;
	transition: opacity 0.2s;
}

.pricing-card .cta-button:hover {
	opacity: 0.8;
}

/* Theme Variations */
.pricing-card.theme-light { background-color: #ffffff; color: #000000; }
.pricing-card.theme-light .cta-button { background-color: #21759b; color: #ffffff; }

.pricing-card.theme-dark { background-color: #1a1a1a; color: #ffffff; }
.pricing-card.theme-dark .cta-button { background-color: #ffffff; color: #1a1a1a; }

.pricing-card.theme-blue { background-color: #21759b; color: #ffffff; }
.pricing-card.theme-blue .cta-button { background-color: #000000; color: #ffffff; }

/* Utility Classes */
.pricing-card .is-full-width {
	width: 100%;
	display: block;
	align-self: stretch;
}

Non commenteremo questo codice, poiché si tratta di un semplice foglio di stile per il tuo blocco widget.

Ora crea il file principale del tuo plugin, chiamalo smart-pricing-widget.php e incolla il seguente codice:

<?php
/**
 * Plugin Name: Smart Pricing Widget
 * Plugin URI:  https://example.com/
 * Description: PHP-only Pricing Table block
 * Version:     1.2.0
 * Author:      Your Name
 * Text Domain: smart-pricing-widget
 */

if ( ! defined( 'ABSPATH' ) ) exit;

/**
 * Render callback
 */
function render_smart_pricing_block( $attributes ) {
	$plan_name = esc_html( $attributes['planName'] );
	$price     = intval( $attributes['price'] );
	$theme     = $attributes['blockTheme'];
	$btn_text  = esc_html( $attributes['buttonText'] );
	$btn_size  = $attributes['buttonSize'];

	$features_raw = $attributes['featuresList'];
	$features_array = array_filter( array_map( 'trim', explode( ',', $features_raw ) ) );

	$wrapper_attributes = wp_kses_data( get_block_wrapper_attributes( array(
		'class' => "pricing-card theme-{$theme}",
	) ) );

	$output = sprintf( '<div %s>', $wrapper_attributes );
	$output .= sprintf( '<h3>%s</h3>', $plan_name );
	$output .= sprintf( '<div class="price-value">€%d</div>', $price );

	if ( ! empty( $features_array ) ) {
		$output .= '<ul>';
		foreach ( $features_array as $feature ) {
			$is_checked = strpos( $feature, '+' ) === 0;
			$clean_text = esc_html( ltrim( $feature, '+- ' ) );
			$icon       = $is_checked ? '✅' : '❌';
			$style      = $is_checked ? '' : 'style="opacity: 0.6;"';
			
			$output .= sprintf( '<li %s><span>%s</span> %s</li>', $style, $icon, $clean_text );
		}
		$output .= '</ul>';
	}

	$btn_class = 'cta-button' . ( $btn_size === 'full' ? ' is-full-width' : '' );
	$output .= sprintf( '<a href="#" class="%s">%s</a>', esc_attr( $btn_class ), $btn_text );
	$output .= '</div>';

	return $output;
}

/**
 * Register Assets and Block
 */
add_action( 'init', function() {
	// 1. Register the CSS file
	wp_register_style(
		'smart-pricing-style',
		plugins_url( 'style.css', __FILE__ ),
		array(),
		'1.2.0'
	);

	// 2. Register the Block
	register_block_type( 'tutorial/smart-pricing', array(
		'api_version'     => 3,
		'title'           => 'Pricing Card',
		'icon'            => 'cart',
		'category'        => 'widgets',
		'render_callback' => 'render_smart_pricing_block',
		// Link the registered style handle here
		'style'           => 'smart-pricing-style',
		'attributes'      => array(
			'planName'     => array( 'type' => 'string', 'default' => 'Professional' ),
			'price'        => array( 'type' => 'integer', 'default' => 49 ),
			'buttonText'   => array( 'type' => 'string', 'default' => 'Choose Plan' ),
			'buttonSize'   => array( 'type' => 'string', 'enum' => array( 'auto', 'full' ), 'default' => 'auto' ),
			'blockTheme'   => array( 'type' => 'string', 'enum' => array( 'light', 'dark', 'blue' ), 'default' => 'light' ),
			'featuresList' => array( 'type' => 'string', 'default' => "+ Support, + Updates, - Domain" ),
		),
		'supports'        => array(
			'auto_register' => true,
			'color'         => array( 'background' => true, 'text' => true ),
			'spacing'       => array( 'margin' => true, 'padding' => true ),
			'typography'    => array( 'fontSize' => true ),
			'shadow'        => true,
			'__experimentalBorder' => array( 'color' => true, 'radius' => true, 'style' => true, 'width' => true ),
			'border'        => array( 'color' => true, 'radius' => true, 'style' => true, 'width' => true ),
		),
	) );
});

Questo script include due funzioni. La funzione register_block_type() costituisce il cuore del tuo plugin. Ecco i suoi elementi principali:

  • Il primo argomento è l’identificatore del blocco, compreso lo spazio dei nomi (tutorial/smart-pricing).
  • Il secondo argomento è un array di argomenti. Nel codice sopra riportato, abbiamo impostato la versione dell’API, il titolo, l’icona, la categoria, la funzione di callback di rendering, lo stile, gli attributi e i supporti.
  • Gli attributi presenti nell’array generano i controlli che gli utenti utilizzeranno per aggiungere contenuti e configurare il blocco. L’elemento type specifica il tipo di controllo da aggiungere all’inspector del blocco. In questo esempio, si tratta di campi di testo ('type’ => 'string’), un numero intero ('type’ => 'integer’) e un paio di menu a tendina ('type’ => 'string’, 'enum’ => array()).
  • Gli elementi dell’array supports aggiungono funzionalità che rendono personalizzabile lo stile del blocco. Come accennato in precedenza, l’unico supporto richiesto in un blocco basato esclusivamente su PHP è auto_register, che consente la generazione automatica dell’interfaccia utente per gli attributi personalizzati. Gli altri supporti dichiarati sopra includono colore, spaziatura, tipografia, ombra e bordo.

La funzione di callback render_smart_pricing_block() genera il codice HTML del blocco. Di seguito è riportata una descrizione dettagliata del funzionamento di questa funzione:

  • Estrae e pulisce gli attributi del blocco, quindi aggiunge il codice CSS che determina l’aspetto del blocco nell’interfaccia utente e nell’editor.
  • Le caratteristiche da visualizzare nel blocco ($attributes['featuresList'];) vengono gestite separatamente. Al momento non è possibile aggiungere controlli avanzati alla barra laterale delle impostazioni del blocco. Per creare un elenco, come ad esempio un elenco di caratteristiche, è possibile utilizzare solo un semplice campo di testo. In questo esempio, è necessario inserire manualmente le caratteristiche del prodotto, separate da virgole.
  • La variabile $wrapper_attributes è un contenitore per gli attributi del wrapper forniti dalla funzione get_block_wrapper_attributes. Questa funzione non si limita ad aggiungere le classi specificate nel codice (pricing-card theme-{$theme}), ma recupera automaticamente tutte le personalizzazioni di stile che l’utente imposta nell’ispettore dei blocchi, inclusi colori, bordi, riempimento, margini, ombreggiatura, tipografia e le classi standard dei blocchi (wp-block-tutorial-smart-pricing).
  • wp_kses_data verifica che nella stringa non siano presenti tag o script dannosi (XSS).
  • Il resto del codice genera il contenuto del blocco.

Attiva il plugin e crea un nuovo articolo o una nuova pagina. Apri l’inseritore di blocchi e scorri verso il basso fino alla sezione Widget. Qui dovresti vedere il blocco “Pricing Card”, riconoscibile dall’icona del carrello.

Un blocco personalizzato solo PHP nell'editor di blocchi
Un blocco personalizzato solo PHP nell’editor di blocchi

L’immagine qui sopra mostra il blocco con il tema chiaro predefinito.

Nell’immagine qui sotto puoi vedere la versione scura del blocco e le impostazioni che abbiamo configurato nel plugin.

Il blocco solo PHP con le impostazioni del blocco
Il blocco in solo PHP con le impostazioni del blocco

L’immagine seguente mostra i controlli di stile che abbiamo aggiunto con i supporti del blocco.

Il tema scuro del blocco in solo PHP con colori personalizzati
Il tema scuro del blocco in solo PHP con colori personalizzati

Vale inoltre la pena notare che gli stili aggiunti dai supporti hanno la precedenza sugli stili del tema del blocco. Ciò consente una maggiore personalizzazione dell’aspetto del blocco, come mostrato nell’immagine seguente:

Una tabella dei prezzi per 3 livelli di servizio con tre istanze del blocco in solo PHP
Una tabella dei prezzi per 3 livelli di servizio con tre istanze del blocco in solo PHP

Convertire gli shortcode tradizionali in blocchi Gutenberg utilizzando solo PHP

Uno degli usi più immediati dei blocchi PHP è quello di contenitori per gli shortcode. Con Gutenberg è ancora possibile utilizzare gli shortcode nei propri contenuti, ma è necessario inserirli manualmente in un blocco Shortcode, il che non è proprio il massimo della comodità.

Supponiamo che tu abbia il seguente shortcode:

function my_custom_alert_shortcode( $atts ) {
	$options = shortcode_atts( array(
		'type'    => 'info',
		'message' => 'Default alert message',
	), $atts );

	$styles = array(
		'info'    => 'background: #d1ecf1; color: #0c5460; border-color: #bee5eb;',
		'warning' => 'background: #fff3cd; color: #856404; border-color: #ffeeba;',
		'error'   => 'background: #f8d7da; color: #721c24; border-color: #f5c6cb;'
	);

	$style = $styles[ $options['type'] ] ?? $styles['info'];

	return sprintf(
		'<div class="sc-alert-box" style="%s padding: 20px; border: 1px solid; border-radius: 6px; margin: 10px 0;">
			<strong style="text-transform: uppercase;">%s:</strong> %s
		</div>',
		esc_attr( $style ),
		esc_html( $options['type'] ),
		esc_html( $options['message'] )
	);
}
add_shortcode( 'sc_alert', 'my_custom_alert_shortcode' );

Questo codice genera un semplice riquadro che puoi inserire nei contenuti utilizzando il seguente shortcode:

[sc_alert type="alert" message="Hello"]

In Gutenberg, dovrai utilizzare un blocco “Shortcode” per inserire il riquadro nel tuo contenuto, come mostrato nell’immagine seguente:

Un blocco Shortcode
Un blocco Shortcode

La situazione cambia completamente con i blocchi solo PHP. Ora è possibile inserire lo shortcode in un blocco Gutenberg solo PHP e configurarlo tramite i controlli dell’interfaccia utente. Ecco il codice da aggiungere al plugin:

/**
 * Rendering callback
 */
function render_shortcode_alert_wrapper_block( $attributes ) {

	$type    = esc_attr( $attributes['alertType'] );
	$message = esc_attr( $attributes['alertMessage'] );

	$shortcode_string = sprintf( '[sc_alert type="%s" message="%s"]', $type, $message );

	$wrapper_attributes = wp_kses_data( get_block_wrapper_attributes( array(
		'class' => 'wp-block-shortcode-alert-wrapper',
	) ) );

	return sprintf(
		'<div %s>%s</div>',
		$wrapper_attributes,
		do_shortcode( $shortcode_string )
	);
}

/**
 * Register the block type on the server
 */
add_action( 'init', function() {
	register_block_type( 'tutorial/alert-wrapper', array(
		'api_version'     => 3,
		'title'           => 'Alert (Shortcode wrapper)',
		'icon'            => 'feedback',
		'category'        => 'widgets',
		'render_callback' => 'render_shortcode_alert_wrapper_block',
		
		'attributes'      => array(
			'alertType' => array(
				'type'    => 'string',
				'enum'    => array( 'info', 'warning', 'error' ),
				'default' => 'info',
			),
			'alertMessage' => array(
				'type'    => 'string',
				'default' => 'Type your alert message here...',
			),
		),

		'supports'        => array(
			'auto_register' => true,
			'spacing'       => array( 'margin' => true, 'padding' => true ),
			'typography'    => array( 'fontSize' => true ),
		),
	) );
});

Il codice sopra riportato è simile a quello della sezione precedente. Ciò che cambia in questo caso è la funzione di callback per il rendering.

  • $shortcode_string memorizza la stringa dello shortcode ([sc_alert type="%s" message="%s"]).
  • La funzione restituisce il codice HTML del contenitore del blocco e dello shortcode incluso (do_shortcode( $shortcode_string )).

Ora apri il Block Inserter e cerca il blocco “Shortcode wrapper” tra i widget. Inseriscilo nel tuo contenuto e configuralo dalla barra delle impostazioni del blocco. Il blocco apparirà identico sia nell’editor che nell’interfaccia pubblica.

Un esempio di shortcode racchiuso in un blocco solo PHP
Un esempio di shortcode racchiuso in un blocco solo PHP

Come cambia lo sviluppo di WordPress con i blocchi basati esclusivamente su PHP?

Allo stato attuale, i blocchi PHP puri sono in fase sperimentale e presentano ancora funzionalità limitate. Gutenberg offre funzionalità più potenti, come i block pattern e le variazioni di blocchi, che forniscono tutte le funzionalità di modifica dei blocchi nativi di Gutenberg e dei blocchi personalizzati realizzati in JavaScript. Tuttavia, esistono scenari in cui i blocchi PHP offrono opportunità significative.

In primo luogo, i blocchi in solo PHP dovrebbero favorire una più ampia diffusione dell’editor a blocchi, soprattutto tra gli sviluppatori WordPress meno orientati allo sviluppo di JavaScript lato server.

Inoltre, rappresentano contenitori ideali per funzioni personalizzate e shortcode, come illustrato nell’esempio riportato in questo articolo. Consentono inoltre una facile integrazione con servizi esterni.

È inoltre lecito aspettarsi futuri miglioramenti e l’aggiunta di nuove funzionalità, maggiori opzioni di configurazione e integrazioni con gli strumenti Gutenberg esistenti.

Una cosa è certa: grazie ai blocchi basati esclusivamente su PHP, creare blocchi Gutenberg è diventato molto più semplice.

Se ti occupi di sviluppo WordPress, Kinsta ti offre gli strumenti per developer di cui hai bisogno, permettendoti di concentrarti sullo sviluppo di WordPress, eliminando la necessità di configurazioni complesse e di noiose attività di manutenzione: SSH, SFTP, integrazione Git, aggiornamenti automatici, staging a un solo clic, uno strumento di sviluppo locale integrato, e molto altro. Provalo subito con il primo mese gratis.

Carlo Daniele Kinsta

Carlo è cultore appassionato di webdesign e front-end development. Gioca con WordPress da oltre 20 anni, anche in collaborazione con università ed enti educativi italiani ed europei. Su WordPress ha scritto centinaia di articoli e guide, pubblicati sia in siti web italiani e internazionali, che su riviste a stampa. Lo trovate su LinkedIn.