Eu tenho um plugin que chama um script php independente (myAjax.php) através de um script jQuery.ajax () dentro do plugin.

Preciso colocar o seguinte código no arquivo myAjax.php:

require_once('../../../wp-load.php');

if (!is_user_logged_in()){
    die("You Must Be Logged In to Access This");
}
if( ! current_user_can('edit_files')) {
    die("Sorry you are not authorized to access this file");
}

No entanto, eu gostaria de um método mais à prova de balas para especificar o caminho para o wp-load.php, caso o caminho relativo real seja diferente do meu exemplo.

Você pode usar __DIR__constante. Como o arquivo está dentro do plug-in ou da pasta do tema, sempre localizados dentro da wp-contentpasta. Você pode simplesmente obter o caminho do arquivo e aparar tudo a wp-contentpartir dele:

$path = preg_replace('/wp-content.*$/','',__DIR__);

Se você precisa garantir que o wp não esteja dentro de alguma pasta de conteúdo wp (quem sabe? As coisas acontecem) - use lookahead negativo:

$path = preg_replace('/wp-content(?!.*wp-content).*/','',__DIR__);

(como é mais fácil garantir que o seu próprio plug-in que você está desenvolvendo não esteja localizado em outra pasta wp-content)

Aaand .. você wp-loadestá aí:

include($path.'wp-load.php');

Mas!

Como os caras mencionados anteriormente, para o AJAX, você pode usar a técnica de ajax nativa do WP-s .

Obviamente, há casos em que a técnica AJAX nativa do WP não é suficiente.

Sei que essa é uma pergunta antiga, mas queria adicionar minha própria resposta, que acho que pode ajudar alguns usuários que tentam alcançar a mesma coisa.

Sim, é sempre melhor (e mais fácil) usar a API nativa do WP Ajax, mas pode ficar muito lenta porque carrega toda a instância do WP.

Minha solução: é bastante simples e deve funcionar para recuperar a rootinstalação do wordpress. Em qualquer script em que você esteja executando a chamada AJAX personalizada, certifique-se de registrar primeiro o script wp_register_script()(não o coloque ainda na fila). Em seguida, use wp_localize_script()e analise o ABSPATH(esta é uma constante definida dentro wp-load.phpe manterá o caminho raiz). Agora você pode recuperar isso dentro do seu script e analisá-lo junto com a chamada AJAX. Finalmente, é claro, certifique-se de enfileirar o script wp_enqueue_script().

Exemplo:

O snippet PHP abaixo enfileirará seu script.jsarquivo e permitirá recuperar o rootdiretório chamando pluginslug_scriptname_i18n.wp_root. Basicamente, wp_localize_script()é usado para fazer traduções, mas isso também se torna útil para analisar dados nos scripts que você recuperou no servidor.

        $handle = 'pluginslug-scriptname'; // Set script handle
        $name = str_replace( '-', '_', $handle ) . '_i18n'; // Will convert handle to pluginslug_scriptname_i18n
        wp_register_script( $handle, plugin_dir_url( __FILE__ ) . 'script.js', array(), '1.0.0', false );  
        wp_localize_script(
            $handle,
            $name,
            array( 
                'ajax_url' => plugin_dir_url( __FILE__ ) . 'ajax-handler.php', // @THIS WILL HOLD YOUR AJAX URL :) To retrieve this inside your script.js simply call: pluginslug_scriptname_i18n.ajax_url
                'wp_root' => ABSPATH // @THIS WILL HOLD THE ROOT PATH :) To retrieve this inside your script.js simply call: pluginslug_scriptname_i18n.wp_root
            )
        );
        wp_enqueue_script( $handle );

Você script.jspode ficar assim:

    var xhttp = new XMLHttpRequest();
    xhttp.onreadystatechange = function() {
        if (this.readyState == 4 ){
            if (this.status == 200) {
                // Success:
            }
            // Complete:
        }
    };
    xhttp.onerror = function () {
      console.log(this);
      console.log("** An error occurred during the transaction");
    };
    xhttp.open("POST", pluginslug_scriptname_i18n.ajax_url, true);
    xhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
    var params = JSON.stringify({
        first_name: 'Johny',
        wp_root: pluginslug_scriptname_i18n.wp_root
    });
    xhttp.send(params);

Agora, dentro do seu, ajax-handler.phpvocê pode recuperar wp_content_dire carregar o seguinte wp-load.php:

// Set proper content type
header('Content-Type: text/html');
// Disable caching
header('Cache-Control: no-cache');
header('Pragma: no-cache');
// Get's the payload
$request_body = json_decode( file_get_contents('php://input'), true );  

// Set this to true to just load the basics!
// Only set this to true if you know what you are doing
// Lookup SHORTINIT inside wp-settings.php for more details
define( 'SHORTINIT', false ); 

// Include wp-load.php
require_once( $request_body['wp_root'] . 'wp-load.php' );
die();

Lembre-se de que o wp_rootlado do cliente pode ser alterado.

Como uma nota rodapé:

Outro truque que alguns de vocês podem não estar cientes é que, antes de incluir, wp-load.phpvocê pode definir uma constante chamada SHORTINIT(booleana). Isso instruirá o WordPress a carregar apenas o básico (o que significa que você perderá muitas funções principais do WP), mas acelerará o tempo de carregamento, pois não incluirá todos os arquivos necessários para uma instância regular do WP. O arquivo SHORTINITé definido por dentro wp-settings.php(basta abrir o arquivo e procurar SHORTINIT. Você entenderá melhor o que está acontecendo sob o capô. Esse truque bacana acelerará ainda mais os tempos de carregamento (até 75% nos meus testes que fiz) Há algum tempo). Mas isso dependerá da versão do WP. Lembre-se também de que as wp-load.phpalterações são frequentes nas novas versões das versões do WP, portanto, se você usarSHORTINITcertifique-se de que seu script sempre funcione mesmo nas versões futuras do WordPress e também na versão inferior do WordPress. Em resumo, se você fizer coisas complexas que dependem de grande parte do códice do WordPress, certifique-se de NÃO definir SHORTINITcomo verdadeiro .

Você pode usar o código abaixo para usar o wp-load.php para incluir o wp-load de qualquer local

require_once( trailingslashit( ABSPATH ) .'wp-load.php' );