Cómo leer los parámetros de la solicitud de publicación usando JavaScript

Estoy tratando de leer los parámetros de la solicitud de publicación desde mi HTML. Puedo leer los parámetros de solicitud de obtención usando el siguiente código en JavaScript.

$wnd.location.search

Pero no funciona para solicitudes posteriores. ¿Alguien puede decirme cómo leer los valores del parámetro de solicitud de publicación en mi HTML usando JavaScript?

Los datos POST son datos que se manejan en el lado del servidor . Y Javascript está del lado del cliente. Por lo tanto, no hay forma de que pueda leer los datos de una publicación usando JavaScript.

Un pequeño fragmento de PHP para que el servidor complete una variable de JavaScript es rápido y fácil:

var my_javascript_variable = <?php echo json_encode($_POST['my_post'] ?? null) ?>;

Luego acceda a la variable JavaScript de la forma habitual.

Tenga en cuenta que no hay garantía de que se publiquen datos o tipos de datos a menos que usted marque: todos los campos de entrada son sugerencias, no garantías.

JavaScript es un lenguaje de programación del lado del cliente, lo que significa que todo el código se ejecuta en la máquina del usuario web. Las variables POST, por otro lado, van al servidor y residen allí. Los navegadores no proporcionan esas variables al entorno de JavaScript, ni ningún desarrollador debe esperar que estén allí mágicamente.

Dado que el navegador no permite que JavaScript acceda a los datos POST, es prácticamente imposible leer las variables POST sin que un actor externo como PHP haga eco de los valores POST en una variable de script o una extensión / complemento que capture los valores POST en tránsito. Las variables GET están disponibles a través de una solución alternativa porque están en la URL que puede ser analizada por la máquina cliente.

Utilice sessionStorage!

$(function(){
    $('form').submit{
       document.sessionStorage["form-data"] =  $('this').serialize();
       document.location.href = 'another-page.html';
    }
});

En otra página.html:

var formData = document.sessionStorage["form-data"];

Enlace de referencia: https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage

¿Por qué no utilizar localStorage o cualquier otra forma de establecer el valor que le gustaría pasar?

¡De esa manera tendrá acceso a él desde cualquier lugar!

Por cualquier lugar me refiero dentro del dominio / contexto dado

Puede leer el parámetro de solicitud de publicación con jQuery-PostCapture ( @ ssut / jQuery-PostCapture ).

El complemento PostCapture consta de algunos trucos.

Cuando hagas clic en el botón Enviar, onsubmitse enviará el evento.

En ese momento, PostCapture serializará los datos del formulario y los guardará en html5 localStorage (si está disponible) o en el almacenamiento de cookies.

POST es lo que el navegador envía desde el cliente (su navegador) al servidor web. Los datos de publicación se envían al servidor a través de encabezados http, y están disponibles solo en el extremo del servidor o entre la ruta (ejemplo: un servidor proxy) desde el cliente (su navegador) al servidor web. Por lo tanto, no se puede manejar desde scripts del lado del cliente como JavaScript. Debe manejarlo a través de scripts del lado del servidor como CGI, PHP, Java, etc. Si aún necesita escribir en JavaScript, debe tener un servidor web que comprenda y ejecute JavaScript en su servidor como Node.js

Si está trabajando con una API de Java / REST, una solución alternativa es fácil. En la página JSP puede hacer lo siguiente:

    <%
    String action = request.getParameter("action");
    String postData = request.getParameter("dataInput");
    %>
    <script>
        var doAction = "<% out.print(action); %>";
        var postData = "<% out.print(postData); %>";
        window.alert(doAction + " " + postData);
    </script>

<script>
<?php
if($_POST) { // Check to make sure params have been sent via POST
  foreach($_POST as $field => $value) { // Go through each POST param and output as JavaScript variable
    $val = json_encode($value); // Escape value
    $vars .= "var $field = $val;\n";
  }
  echo "<script>\n$vars</script>\n";
}
?>
</script>

O utilícelo para ponerlos en un diccionario que una función podría recuperar:

<script>
<?php
if($_POST) {
  $vars = array();
  foreach($_POST as $field => $value) {
    array_push($vars,"$field:".json_encode($value)); // Push to $vars array so we can just implode() it, escape value
  }
  echo "<script>var post = {".implode(", ",$vars)."}</script>\n"; // Implode array, javascript will interpret as dictionary
}
?>
</script>

Luego en JavaScript:

var myText = post['text'];

// Or use a function instead if you want to do stuff to it first
function Post(variable) {
  // do stuff to variable before returning...
  var thisVar = post[variable];
  return thisVar;
}

Este es solo un ejemplo y no debe usarse para ningún dato sensible como una contraseña, etc. El método POST existe por una razón; enviar datos de forma segura al backend, por lo que frustraría el propósito.

Pero si solo necesita un montón de datos de formulario no confidenciales para ir a su página siguiente sin /page?blah=value&bleh=value&blahbleh=valuesu URL, esto lo haría para una URL más limpia y su JavaScript puede interactuar inmediatamente con sus datos POST.

Tengo un código simple para hacerlo:

En su index.php:

<input id="first_post_data" type="hidden" value="<?= $_POST['first_param']; ?>"/>

En su main.js:

let my_first_post_param = $("#first_post_data").val();

Entonces, cuando incluya main.js en index.php ( <script type="text/javascript" src="./main.js"></script>), podría obtener el valor de su entrada oculta que contiene los datos de su publicación.

Puede 'json_encode' para codificar primero sus variables de publicación a través de PHP. Luego cree un objeto JS (matriz) a partir de las variables de publicación codificadas en JSON. Luego use un bucle de JavaScript para manipular esas variables ... Como, en este ejemplo a continuación, para completar un formulario HTML:

<script>

    <?php $post_vars_json_encode =  json_encode($this->input->post()); ?>

    // SET POST VALUES OBJECT/ARRAY
    var post_value_Arr = <?php echo $post_vars_json_encode; ?>;// creates a JS object with your post variables
    console.log(post_value_Arr);

    // POPULATE FIELDS BASED ON POST VALUES
    for(var key in post_value_Arr){// Loop post variables array

        if(document.getElementById(key)){// Field Exists
            console.log("found post_value_Arr key form field = "+key);
            document.getElementById(key).value = post_value_Arr[key];
        }
    }


</script>

Una opción es configurar una cookie en PHP.

Por ejemplo: una cookie denominada no válida con el valor de $invalidcaducar en 1 día:

setcookie('invalid', $invalid, time() + 60 * 60 * 24);

Luego, vuelva a leerlo en JS (usando el complemento JS Cookie ):

var invalid = Cookies.get('invalid');

if(invalid !== undefined) {
    Cookies.remove('invalid');
}

Ahora puede acceder al valor de la invalidvariable en JavaScript.

Depende de lo que defina como JavaScript. Actualmente tenemos JS en programas del lado del servidor como NodeJS. Es exactamente el mismo JavaScript que codifica en su navegador, excepto como idioma del servidor. Entonces puedes hacer algo como esto: ( Código de Casey Chu: https://stackoverflow.com/a/4310087/5698805 )

var qs = require('querystring');

function (request, response) {
    if (request.method == 'POST') {
        var body = '';

        request.on('data', function (data) {
            body += data;

            // Too much POST data, kill the connection!
            // 1e6 === 1 * Math.pow(10, 6) === 1 * 1000000 ~~~ 1MB
            if (body.length > 1e6)
                request.connection.destroy();
        });

        request.on('end', function () {
            var post = qs.parse(body);
            // use post['blah'], etc.
        });
    }
}

Y de ahí su uso, post['key'] = newVal;etc ...

Las variables POST solo están disponibles para el navegador si ese mismo navegador las envió en primer lugar. Si otro formulario de sitio web se envía a través de POST a otra URL, el navegador no verá los datos de POST.

SITIO A: tiene un formulario enviado a una URL externa (sitio B) usando POST SITE B: recibirá al visitante pero solo con variables GET

function getParameterByName(name, url) {
            if (!url) url = window.location.href;
            name = name.replace(/[\[\]]/g, "\\$&");
            var regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"),
                results = regex.exec(url);
            if (!results) return null;
            if (!results[2]) return '';
            return decodeURIComponent(results[2].replace(/\+/g, " "));
        }
var formObj = document.getElementById("pageID");
formObj.response_order_id.value = getParameterByName("name");

$(function(){
    $('form').sumbit{
        $('this').serialize();
    }
});

En jQuery, el código anterior le daría la cadena de URL con los parámetros POST en la URL. No es imposible extraer los parámetros POST.

Para usar jQuery , debe incluir la biblioteca jQuery. Utilice lo siguiente para eso:

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.1/jquery.min.js" type="text/javascript"></script>

Podemos recopilar los parámetros de formulario enviados mediante POST con el concepto de serialización .

Prueba esto:

$('form').serialize(); 

Solo adjúntelo alerta, muestra todos los parámetros incluidos los ocultos.

<head><script>var xxx = ${params.xxx}</script></head>

Usando la expresión EL $ {param.xxx} <head>para obtener los parámetros de un método de publicación, y asegúrese de que el archivo js esté incluido después <head>para que pueda manejar un parámetro como 'xxx' directamente en su archivo js.