Gerenciar Postagens do WordPress com PHP – Criar e Atualizar

1. 1. Crie posts e páginas do WordPress usando PHP – um tutorial 101
2. 2. Atualmente lendo: Gerenciar postagens do WordPress com PHP – Criar e atualizar

Como prometido, aqui está a segunda parte do meu primeiro post, ‘Create WordPress Posts And Pages Using PHP – A 101 Tutorial’ . Neste artigo, veremos como podemos estender as funções básicas e a teoria que discuti na Parte 1 para criar uma classe wrapper PHP robusta e confiável.

Como sempre, simpatizo com aqueles de vocês que simplesmente querem mergulhar direto no código. Você pode encontrá-lo em um dos meus repositórios do Github (foi um pouco longo demais para colar diretamente neste artigo!).

O que queremos alcançar:

• Uma estrutura de nível de produção PHP totalmente funcional e confiável.
• Ser capaz de gerenciar não apenas a criação de postagens, mas também gerenciar e atualizar postagens pré-existentes.
• Ser capaz de pesquisar e manipular postagens por seus; IDENTIFICAÇÃO; Título ou Slug.

Haverá 2 seções neste artigo: Notas de uso e um guia passo a passo.

Sem mais delongas, vamos começar!

Uso

Em primeiro lugar, certifique-se de ter incluído o arquivo class.postcontroller.php do Github ou colado o conteúdo desse arquivo em seu documento PHP. Isso não vai funcionar sem ele! Vamos dar uma olhada no código neste arquivo na segunda metade deste tutorial .

Instancie a classe da seguinte forma;

$Poster = new PostController;

O Post Controller funciona assim; você define atributos de postagem usando as funções relevantes. Em seguida, você cria ou atualiza uma postagem. Para atualizar uma postagem, você precisa primeiro pesquisar e encontrar uma para atualizar. Parece simples o suficiente?

Definir atributos

Título

Isso define o título do post. Nenhum HTML é permitido aqui e é removido.

$Poster->set_title( ‘The Title’ );

Tipo

Este método define o tipo de postagem da página. Insira o slug do tipo de postagem, por exemplo. ‘post’ e ‘página’. Tipos de postagem personalizados são suportados.

$Poster->set_type( ‘page’ );

Conteúdo

Este método define o conteúdo do post. HTML é permitido.

$Poster->set_content( ‘<h1>This is my awesome new post!</h1>’ );

Autor

Isso define o autor da postagem. Basta especificar o ID do autor do novo autor. Este deve ser um número inteiro.

$Poster->set_author_id( 12 );

Slug / ‘Nome’

Este é o caminho de URL personalizado do post (se habilitado). Tome cuidado com isso, pois se o slug já estiver em uso, pode causar alguns erros. Eu incluí a validação para tentar evitar isso a todo custo. Nenhum caractere especial ou html permitido.

$Poster->set_post_slug( “new_slug” );

Modelo (somente páginas)

Este método permite definir o modelo da sua página (deve ser uma página). Se aplicado a um tipo de postagem diferente, ele será ignorado e um erro será adicionado à matriz de erros. O formato da entrada será ‘php_template_name.php’ e será exclusivo para cada tema.

$Poster->set_page_template( ‘fullwidth_page.php’ );

State

Este método define o estado do post. Opções disponíveis;

[ ‘rascunho’ | ‘publicar’ | ‘pendente’| ‘futuro’ | ‘privado’ | status registrado personalizado]

$Poster->set_post_state( “pending” );

Crio

O requisito mínimo para criar um post é ter o título definido. Você pode fazer isso usando o código a seguir;

$Poster->set_title( “New Post” );

Depois que isso for definido, basta executar o método create.

$Poster->create();

Nota: O método irá verificar se existe outro post com o mesmo nome (só para garantir que não está fazendo duplicatas). Portanto, é necessário um título exclusivo .

Procurar

Antes de podermos atualizar uma postagem existente, primeiro temos que encontrá-la com a função Pesquisar.

Para fazer isso, usamos o método de pesquisa.

$Poster->search( ‘SEARCH_BY’ , ‘DATA’ );

Este método aceita 2 parâmetros, o atributo para pesquisar e os dados para pesquisar.

Você pode pesquisar por título ;

$Poster->search( ‘title’ , ‘DATA’ );

Você pode pesquisar por ID ;

$Poster->search( ‘id’ , ‘DATA’ );

E você pode pesquisar por slug ;

$Poster->search( ‘slug’ , ‘DATA’ );

O parâmetro de dados aceitará uma string (se estiver pesquisando por título ou slug) ou um inteiro (se estiver pesquisando por ID). Se uma postagem ou página não puder ser encontrada com os parâmetros especificados, um erro será adicionado ao array $errors . Você pode chamar e exibir isso com o código a seguir.

$error = $Poster->get_var( ‘errors’ );

$Poster->PrettyPrint( $error );

Atualizar

Depois que uma postagem for encontrada, você poderá atribuir novos atributos a ela. Depois que os atributos forem definidos, basta chamar o método de atualização.

$Poster->update();

Por exemplo, se você deseja alterar o título do post 1 (ID = 1), use o seguinte código.

$Poster->search( ‘id’, 1 );

$Poster->set_title( ‘New Title’ );

$Poster->update();

Todos os atributos podem ser atualizados desta forma.

Recuperando Variáveis

Para recuperar variáveis definidas, você pode usar o método get_vars.

$Poster->get_var( ‘title’ );   // Returns the title (if you have set it)

$Poster->get_var( ‘type’ );    // Returns the post type (if you have set it)

$Poster->get_var( ‘content’ ); // Returns the content (if you have set it)

$Poster->get_var( ‘category’ ); // Returns the category as an array (if set)

$Poster->get_var( ‘template’ ); // Returns the template (if you have set it)

$Poster->get_var( ‘slug’ );    // Returns the slug (if you have set it)

$Poster->get_var( ‘auth_id’ ); // Returns the author id (if you have set it)

$Poster->get_var( ‘status’ );  // Returns the post’s status (if you have set it)

$Poster->get_var( ‘errors’ );  // Returns the errors array

/** AFTER YOU HAVE EITHER CREATED A POST OR SUCCESSFULLY SEARCHED FOR ONE YOU CAN USE THESE **/

// Returns the a PHP Object of the post. This can be used to check if the search method was successful

$Poster->get_var( ‘current_post’ );

// Returns the selected post’s ID (integer).

$Poster->get_var( ‘current_post_id’ );

// Returns the URL permalink of the selected post

$Poster->get_var( ‘current_post_permalink’ );

Isso é isso! Se você tiver alguma dúvida sobre o uso, pode me perguntar nos comentários aqui. Se você encontrar um bug, por favor me conte no Github .

Preparados para a segunda parte?

Construindo a aula: guia passo a passo

Agora que vimos como usar a classe , vamos voltar ao início.

Nossa classe será chamada PostController ;

class PostController {

. . . class functions go here . . .

}

Para aqueles que não são bem versados em PHP Classes, uma Classe é definida como um objeto que contém uma coleção de funções e variáveis que estão trabalhando juntas. Confira a introdução do PHP.net para mais detalhes sobre a sintaxe e a teoria que usaremos para criar nosso framework. O próximo passo em nossa lista de tarefas é declarar todas as variáveis que usaremos.

// Variables for Post Data

public $PC_title;

public $PC_type;

public $PC_content;

public $PC_category;

public $PC_template;

public $PC_slug;

public $PC_auth_id;

public $PC_status = “publish”;

// Variables for Post Updating

public $PC_current_post;

public $PC_current_post_id;

public $PC_current_post_permalink;

// Error Array

public $PC_errors;

Ok, então vamos dividir isso em três blocos. O primeiro bloco conterá os dados de postagem que VOCÊ especificou. Estes serão os dados que serão usados para atualizar e criar uma postagem (quando chegarmos a ela). Embora você provavelmente possa adivinhar pelos nomes das variáveis, aqui está uma lista dos dados que queremos armazenar.

1. Título
2. Tipo (Página/Post etc.)
3. Contente
4. Categoria/Categorias
5. Modelo de página
6. lesma
7. ID do autor e
8. Status do Post (por exemplo, publicado/rascunho)

O segundo bloco conterá os dados reais da postagem do WordPress que nossa consulta de pesquisa retornará (ou os dados sobre uma postagem criada após a criação). A variável ‘$PC_current_post’ conterá um objeto de todo o post. Isso contém todos os dados sobre a postagem, incluindo (importantemente) os dados listados acima. Da mesma forma, as variáveis Post ID e Permalink manterão esses dados sobre a postagem existente.

O terceiro e último bloco possui apenas uma variável: o array errors. Se um problema for encontrado em um ponto de ‘pinçamento’ conhecido, uma mensagem sobre o problema será adicionada a esta matriz para sua referência. Observe que incluí o ‘PC_’ apenas por bom hábito: os nomes das variáveis nunca devem ser ambíguos. PC significa ‘PostController’. Se você alterar isso, lembre-se de alterar também o prefixo na função get_var().

Certo, agora que temos tudo configurado, vamos mergulhar em nossa primeira função.

// Creation functions

public function create() {

if ( isset( $this->PC_title ) ) {

if ( $this->PC_type == ‘page’ ) {

$post = get_page_by_title( $this->PC_title, ‘OBJECT’, $this->PC_type );

} else {

$post = get_page_by_title( $this->PC_title, ‘OBJECT’, $this->PC_type );

}

$post_data = array(

‘post_title’    => wp_strip_all_tags($this->PC_title),

‘post_name’     => $this->PC_slug,

‘post_content’  => $this->PC_content,

‘post_status’   => $this->PC_status,

‘post_type’     => $this->PC_type,

‘post_author’   => $this->PC_auth_id,

‘post_category’ => $this->PC_category,

‘page_template’ => $this->PC_template

);

if ( ! isset( $post ) ) {

$this->PC_current_post_id        = wp_insert_post( $post_data, $error_obj );

$this->PC_current_post           = get_post( ( integer ) $this->PC_current_post_id, ‘OBJECT’ );

$this->PC_current_post_permalink = get_permalink( ( integer ) $this->PC_current_post_id );

return $error_obj;

} else {

$this->update();

$this->errors[] = ‘That page already exists. Try updating instead. Control passed to the update() function.’;

return FALSE;

}

} else {

$this->errors[] = ‘Title has not been set.’;

return FALSE;

}

}

Para aqueles que leram a Parte 1 desta Série: Criar Postagens e Páginas do WordPress Usando PHP – Um Tutorial 101 , esta função parecerá familiar para você. Esta é apenas a função finalizada desse tutorial depois de ser adaptada para esta nova configuração. Para ler a explicação desta função em particular, recomendo verificar a parte 1. A única grande diferença para a função em si é que, em vez de adicionar a função à cabeça do WordPress, ela é executada imediatamente.

Como uma rápida execução, a função verifica se um título foi definido (este é o requisito mínimo para a criação de postagem). Em seguida, ele verifica se há uma postagem existente (por título).

Se uma postagem for encontrada, uma mensagem será adicionada ao array errors e o controle será passado para a função update() . Se uma postagem não for encontrada com este título, o $post_data será usado para criar uma nova postagem. A variável Current Post (assim como as outras 2 variáveis de dados) são atualizadas para conter os dados desta nova postagem. Isso é bom para verificar o post que você acabou de fazer. Se houver problemas, uma mensagem será adicionada ao array $errors .

Desculpe se foi um pouco rápido: se você está um pouco confuso, eu recomendo que você confira meu artigo 101 sobre isso.

Para todos vocês que ainda estão comigo, vamos continuar.

// SET POST’S TITLE

public function set_title( $name ) {

$this->PC_title = $name;

return $this->PC_title;

}

// SET POST’S TYPE

public function set_type( $type ) {

$this->PC_type = $type;

return $this->PC_type;

}

// SET POST’S CONTENT

public function set_content( $content ) {

$this->PC_content = $content;

return $this->PC_content;

}

// SET POST’S AUTHOR ID

public function set_author_id( $auth_id ) {

$this->PC_auth_id = $auth_id;

return $this->PC_auth_id;

}

// SET POST’S STATE

public function set_post_state( $content ) {

$this->PC_status = $content;

return $this->PC_status;

}

Este pouco é bastante simples. As funções create() e update() usam variáveis locais como fonte de seus dados. Portanto, precisamos de uma maneira de definir esses dados. As primeiras 5 variáveis são definidas como você pode ver acima. ‘E os outros 3?’, eu ouço você perguntar. Não se preocupe, aqui estão eles, mas você verá que há um pouco de validação para verificar suas entradas (para maximizar a confiabilidade).

// SET POST SLUG

public function set_post_slug( $slug ) {

$args = array(‘name’ => $slug);

$posts_query = get_posts( $args );

if ( ! get_posts( $args ) && ! get_page_by_path( $this->PC_slug ) ) {

$this->PC_slug = $slug;

return $this->PC_slug;

} else {

$this->errors[] = ‘Slug already in use.’;

return FALSE;

}

}

// SET PAGE TEMPLATE

public function set_page_template( $content ) {

if ( $this->PC_type == ‘page’ ) {

$this->PC_template = $content;

return $this->PC_template;

} else {

$this->errors[] = ‘You can only use template for pages.’;

return FALSE;

}

}

// ADD CATEGORY IDs TO THE CATEGORIES ARRAY

public function add_category( $IDs ){

if ( is_array( $IDs ) ) {

foreach ( $IDs as $id ) {

if ( is_int( $id ) ) {

$this->PC_category[] = $id;

} else {

$this->errors[] = ‘<b>’ .$id . ‘</b> is not a valid integer input.’;

return FALSE;

}

}

} else {

$this->errors[] = ‘Input specified in not a valid array.’;

return FALSE;

}

}

Esses três últimos são um pouco mais complicados, mas muito importantes para evitar erros horríveis.

set_post_slug()

A função set_post_slug() é algo que você precisa ter muito cuidado . O slug de postagem é essencialmente a string adicionada ao final da URL base para criar o endereço individual da postagem. Isso também é usado como um identificador de postagem fundamental pelo WordPress. Por exemplo. O slug deste post é ‘manage-wordpress-posts-php-create-update’ .

Isso é adicionado ao final da URL base, http://wpexplorer.com/ , para criar a URL exclusiva deste artigo: http://www.wpexplorer.com/manage-wordpress-posts-php-create-update/ . Tenho certeza que você pode imaginar os problemas que encontraria se mais de uma postagem tivesse o mesmo slug (e, portanto, URL). É uma bagunça verdadeiramente desagradável que deve ser evitada se possível.

O Post Slug DEVE ser ÚNICO

Este é o motivo da validação. O que está acontecendo é que a função procura por posts com o slug especificado. Se nenhum for encontrado E não houver páginas com isso como caminho (essencialmente o mesmo que o slug neste contexto), ótimo! Defina a variável. Caso contrário, um erro é adicionado ao array $errors e a variável não é definida (a função retorna um booleano FALSE).

set_page_template() & add_category()

set_page_template() atribui um template de página (no formato my_page_template.php ) a uma Page , e apenas uma página. A validação aqui simplesmente verifica se o tipo de postagem foi definido como ‘página’. Se true, armazene os dados. Se não, não se incomode.

add_category() permite que você adicione um array de inteiros às categorias do post (ainda deve estar em um array, mesmo adicionando apenas 1 número). Os números inteiros representam os IDs de categoria.

A validação simplesmente percorre o array especificado, verificando se cada célula tem um valor inteiro. Se a célula tiver um valor inteiro, ela será adicionada à matriz de categorias mestras. Caso contrário, ele será ignorado e um erro será adicionado à matriz de erros. Brilhante! Agora podemos atribuir todas as variáveis que precisamos.

Procurando

No início deste tutorial, dissemos que queríamos criar um sistema que tivesse a capacidade de atualizar as postagens existentes do WordPress. Para que isso seja possível, primeiro precisamos encontrar o post que queremos editar. Para isso, usaremos a função search() .

// Search for Post function

public function search( $by, $data ) {

switch ( $by ) {

// SEARCH FOR POST USING IT’S ID

case ‘id’ :

if ( is_integer( $data ) && get_post( ( integer ) $data ) !== NULL ) {

$this->PC_current_post           = get_post( ( integer ) $data, ‘OBJECT’ );

$this->PC_current_post_id        = ( integer ) $data;

$this->PC_current_post_permalink = get_permalink( (integer) $data );

return TRUE;

} else {

$this->errors[] = ‘No post found with that ID.’;

return FALSE;

}

break;

case ‘title’ :

$post = get_page_by_title( $data );

if ( ! $post ) {

$post = get_page_by_title( $data, OBJECT, ‘post’ );

}

$id = $post->ID;

if ( is_integer($id) && get_post( (integer)$id) !== NULL ) {

$this->PC_current_post           = get_post( (integer)$id, ‘OBJECT’ );

$this->PC_current_post_id        = (integer) $id;

$this->PC_current_post_permalink = get_permalink( (integer) $id );

return TRUE;

} else {

$this->errors[] = ‘No post found with that title.’;

return FALSE;

}

break;

// SEARCH FOR POST USING IT’S SLUG

case ‘slug’ :

$args = array(

‘name’          => $data,

‘max_num_posts’ => 1

);

$posts_query = get_posts( $args );

if ( $posts_query ) {

$id = $posts_query[0]->ID;

} else {

$this->errors[] = ‘No post found with that slug.’;

}

if ( is_integer($id) && get_post( (integer)$id) !== NULL ) {

$this->PC_current_post           = get_post( (integer)$id, ‘OBJECT’ );

$this->PC_current_post_id        = (integer)$id;

$this->PC_current_post_permalink = get_permalink((integer)$id);

return TRUE;

} else {

$this->errors[] = ‘No post found with that slug.’;

return FALSE;

}

break;

default:

$this->errors[] = ‘No post found.’;

return FALSE;

break;

}

}

Esta é a função search() . Estou usando a instrução Switch do PHP (uma forma diferente de instruções IF, que neste caso será mais eficiente do que vários Ifs aninhados. Saiba mais sobre Switch no Manual do PHP.net A função search() aceita 2 parâmetros;

1. O valor ‘Pesquisar por’

2. Os dados a serem pesquisados

Você pode ver pelo código acima que existem 3 opções de ‘Pesquisar por’; ‘id’, ‘title’ e ‘slug’. Vamos olhar cada um um pouco mais de perto.

Pesquisar por ID

Este é o método de pesquisa mais simples e requer apenas que você conheça o ID inteiro da postagem. Se os dados especificados forem um número inteiro, a função enviará uma consulta ao seu banco de dados WordPress (usando a função get_post() embutida). Se existir um post com esse inteiro, então o objeto post será retornado e armazenado na variável PC_current_post (assim como o ID e o permalink sendo armazenados também). Simples!

Pesquisar por título

Eu não acho que isso realmente precise de muita explicação: é praticamente o mesmo que pesquisar por ID, mas pesquisa o post pelo título. Se você tiver posts/páginas com o mesmo nome (algo que eu não recomendo ) então o post com o menor ID será escolhido. Se você sabe que tem postagens com os mesmos nomes, não use esse método para evitar confusão. Observação: você verá este código;

$post = get_page_by_title( $data );

if ( ! $post ) {

$post = get_page_by_title( $data, OBJECT, ‘post’ );

}

A razão pela qual temos que fazer isso é porque, embora get_page_by_title() possa retornar dados para postagens e páginas, ele retornará apenas páginas, a menos que o terceiro parâmetro seja especificado como ‘post’.

Não quero dizer o óbvio, mas perceba que se você estiver pesquisando por título e alterando o título ao mesmo tempo, o código só poderá ser executado uma vez (a primeira vez). Depois disso, ele retornará um erro 404 Not Found.

Pesquisar por Slug

Este é um método agradável e confiável de encontrar postagens. Não deve haver ambiguidade porque, como eu disse anteriormente, o slug deve ser único . Confira a seção SET_POST_SLUG() se você não está claro o que quero dizer com ‘slug’. Para fazer isso, simplesmente precisávamos executar uma consulta de postagens do WordPress para encontrar postagens com o slug específico.

Podemos recuperar o ID deste método e definir as variáveis post atuais da mesma forma que os outros 2 métodos. Da mesma forma que pesquisar por título, pesquisar e alterar o slug juntos causará problemas. Cuidado!

Atualizar e gerenciar

Certo! Agora que a pesquisa está fora do caminho, podemos passar para a função update() real .

// Update Post

public function update(){

if ( isset($this->PC_current_post_id ) ) {

// Declare ID of Post to be updated

$PC_post[‘ID’] = $this->PC_current_post_id;

// Declare Content/Parameters of Post to be updated

if ( isset($this->PC_title ) && $this->PC_title !== $this->PC_current_post->post_title ) {

$PC_post[‘post_title’] = $this->PC_title;

}

if ( isset( $this->PC_type ) && $this->PC_type !== $this->PC_current_post->post_type ) {

$PC_post[‘post_type’] = $this->PC_type;

}

if ( isset($this->PC_auth_id) && $this->PC_auth_id !== $this->PC_current_post->post_type ) {

$PC_post[‘post_author’] = $this->PC_auth_id;

}

if ( isset($this->PC_status) && $this->PC_status !== $this->PC_current_post->post_status ) {

$PC_post[‘post_status’] = $this->PC_status;

}

if ( isset($this->PC_category) && $this->PC_category !== $this->PC_current_post->post_category ) {

$PC_post[‘post_category’] = $this->PC_category;

}

if ( isset($this->PC_template )

&& $this->PC_template !== $this->PC_current_post->page_template

&& ( $PC_post[‘post_type’] == ‘page’ || $this->PC_current_post->post_type == ‘page’ )

) {

PC_post[‘page_template’] = $this->PC_template;

}

if ( isset( $this->PC_slug ) && $this->PC_slug !== $this->PC_current_post->post_name ) {

$args = array(‘name’ => $this->PC_slug);

}

if ( ! get_posts( $args ) && !get_page_by_path( $this->PC_slug ) ) {

$PC_post[‘post_name’] = $this->PC_slug;

} else {

$errors[] = ‘Slug Defined is Not Unique’;

}

if ( isset($this->PC_content) && $this->PC_content !== $this->PC_status->post_content ) {

$PC_post[‘post_content’] = $this->PC_content;

}

wp_update_post( $PC_post );

}

return( $errors );

}

Não vou mentir, essa parte é realmente muito fácil. Essencialmente, a função de atualização verifica se algum dos 8 parâmetros de postagem foi definido. Em caso afirmativo, ele cria e preenche um array compatível com wp_update_post() . Ele roda wp_update_post() e pronto! Trabalho bem feito. Para eficiência, adicionaremos uma verificação simples antes de atribuir cada variável. Só é atualizado se tiver mudado. Embora eu seja um pouco tendencioso, tenho que admitir que esse é um código lindo!

Os valores definidos são comparados com os valores retornados pelo próprio WordPress. Apenas uma comparação simples é necessária então. Você notará que as instruções template e slug IF têm um pouco mais de validação do que as outras. Embora já tenhamos incluído a validação para filtrar os erros, não há mal nenhum em verificar novamente!

A verificação do modelo de página (ela verifica se o tipo de postagem está definido como página) é simplesmente porque tentar definir um modelo de página para uma não postagem é um bug bear meu. Desculpe o exagero! A verificação do slug, por outro lado, é importante! Você REALMENTE não quer ter conflitos de lesma. Nesse caso, não existe exagero. Isso é praticamente isso para update() . Finalmente, temos algumas funções gerais úteis.

Funções adicionais

Agora que a maior parte da classe foi escrita, é sempre uma boa ideia adicionar algumas funções úteis/economizadoras de tempo. Dar uma olhada;

// General functions

public function get_content() {

if ( isset( $this->PC_current_post->post_content ) ) {

return $this->PC_current_post->post_content;

}

}

public function get_var( $name ) {

$name = ‘PC_’.$name;

if ( isset( $this->$name ) ) {

return $this->$name;

}

}

public function unset_all() {

foreach ( get_class_vars(get_class($this)) as $name => $default ) {

$this->$name = $default;

}

}

public function __toString() {

return ‘Use the PrettyPrint function to return the contents of this Object. E.g;<pre>$my_post->PrettyPrintAll();</pre>’;

}

public function PrettyPrint($data) {

echo “<pre>”;

print_r( $data );

echo “</pre>”;

}

public function PrettyPrintAll() {

echo “<pre>”;

print_r( $this );

echo “</pre>”;

}

Explicações Rápidas;

• get_content() : Esta função retorna o conteúdo da postagem que você pesquisou (isso é fornecido pelo WordPress e não definido por você). Isso não aceita nenhum parâmetro.
• get_var( ‘var_name’ ) : Às vezes pode ficar confuso quando você configurou muitos dados. Isso aceita um parâmetro: uma string do nome da variável que você deseja. Aqui está uma lista dos ‘var_name’s disponíveis;
• ‘title’ – O título do post que você definiu.
• ‘type’ – O tipo de postagem que você definiu.
• ‘conteúdo’ – O conteúdo que você definiu.
• ‘category’ – As categorias que você definiu (retorna o array).
• ‘template’ – O modelo de página que você definiu.
• ‘slug’ – O Slug que você definiu.
• ‘auth_id’ – O ID do autor que você definiu.
• ‘status’ – O Status do Post que você definiu.
• ‘current_post’ – O objeto WP Post retornado após a pesquisa.
• ‘current_post_id’ – O WP Post ID retornado após a pesquisa.
• ‘current_post_permalink’ – O link permanente do WP Post retornou após a pesquisa.
• ‘errors’ – A Matriz de Erros (muito útil).
• unset_all() : Sem parâmetros. Um trabalho. Exclui todos os dados armazenados na instância da classe. Cuidado.
• __toString() : Isto é o que é executado quando a instância da própria classe é impressa. Mensagem de erro impressa. Usar Usar PrettyPrintAll()

// Start new class

$Poster = new PostController();

// Echoes error message

echo $Poster;

• PrettyPrint() : Esta é apenas uma função útil que exibe objetos e arrays bem em tags ‘pre’. Leva um parâmetro: os dados a serem ‘PrettyPrinted’.
• PrettyPrintAll() : É o mesmo que PrettyPrint(), exceto ‘PrettyPrints’ toda a instância da classe (incluindo todas as variáveis).

E isso é um embrulho!

Obrigado por ler meu artigo: Espero que você tenha achado útil e esclarecedor!

Você pode encontrar a versão mais recente da classe PostController no Github: PostController . Se você gostou deste tutorial, por favor, compartilhe! (Uma menção também seria muito errada: @harribellthomas ). Se você tiver alguma dúvida, deixe-a na seção de comentários abaixo.