Jak uzyskać zmienne GET (ciąg zapytania) w Express.js na Node.js?

Czy możemy uzyskać zmienne w ciągu zapytania w Node.js, tak jak $_GETw PHP?

Wiem, że w Node.js możemy uzyskać adres URL w żądaniu. Czy istnieje metoda uzyskania parametrów ciągu zapytania?

W Express jest to już zrobione i możesz po prostu użyć req.query do tego:

var id = req.query.id; // $_GET["id"]

W przeciwnym razie w NodeJS możesz uzyskać dostęp do req.url i wbudowanego urlmodułu do [url.parse] ( https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost ) ręcznie:

var url = require('url');
var url_parts = url.parse(request.url, true);
var query = url_parts.query;

Ponieważ w tagach wspomniałeś o Express.js, oto odpowiedź specyficzna dla Express: użyj req.query . Na przykład

var express = require('express');
var app = express();

app.get('/', function(req, res){
  res.send('id: ' + req.query.id);
});

app.listen(3000);

W programie Express użyj req.query.

req.paramspobiera tylko parametry trasy, a nie parametry ciągu zapytania. Zobacz dokumentację ekspresową lub żagle :

(req.params) Sprawdza parametry trasy, np .: / user /: id

(req.query) Sprawdza parametry ciągu zapytania, np .:? id = 12 Sprawdza parametry ciała w urlencoded

(req.body), np .: id = 12 Aby korzystać z treści żądań zakodowanych w trybie url, req.body powinien być obiektem. Można to zrobić za pomocą oprogramowania pośredniego _express.bodyParser.

To powiedziawszy, przez większość czasu chcesz uzyskać wartość parametru niezależnie od jego źródła. W takim przypadku użyj req.param('foo').

Wartość parametru zostanie zwrócona bez względu na to, czy zmienna znajdowała się w parametrach trasy, ciągu zapytania lub w zakodowanym treści żądania.

Na marginesie - jeśli chcesz uzyskać przecięcie wszystkich trzech typów parametrów żądania (podobnych do PHP $_REQUEST), po prostu musisz połączyć parametry razem - oto jak to ustawiłem w Sails . Należy pamiętać, że obiekt path / route parameters ( req.params) ma właściwości tablicowe, więc kolejność ma znaczenie (chociaż może się to zmienić w Express 4 )

W przypadku Express.js chcesz req.params:

app.get('/user/:id', function(req, res) {
  res.send('user' + req.params.id);    
});

Nauczyłem się z innych odpowiedzi i postanowiłem używać tego kodu w całej witrynie:

var query = require('url').parse(req.url,true).query;

Następnie możesz po prostu zadzwonić

var id = query.id;
var option = query.option;

gdzie powinien znajdować się adres URL get

/path/filename?id=123&option=456

//get query&params in express

//etc. example.com/user/000000?sex=female

app.get('/user/:id', function(req, res) {

  const query = req.query;// query = {sex:"female"}

  const params = req.params; //params = {id:"000000"}

})

Jeśli używasz ES6 i Express , wypróbuj to destructuringpodejście:

const {id, since, fields, anotherField} = request.query;

W kontekście:

const express = require('express');
const app = express();

app.get('/', function(req, res){
   const {id, since, fields, anotherField} = req.query;
});

app.listen(3000);

Możesz również użyć wartości domyślnych z destructuring:

// sample request for testing
const req = {
  query: {
    id: '123',
    fields: ['a', 'b', 'c']
  }
}

const {
  id,
  since = new Date().toString(),
  fields = ['x'],
  anotherField = 'default'
} = req.query;

console.log(id, since, fields, anotherField)

Istnieją 2 sposoby przekazywania parametrów za pomocą metody GET

Metoda 1: Podejście MVC, w którym przekazujesz parametry takie jak / routeename /: paramname
W tym przypadku możesz użyć req.params.paramname, aby uzyskać wartość parametru Na przykład zapoznaj się z poniższym kodem, w którym I oczekuję, że identyfikator jako param
link może wyglądać tak: http://myhost.com/items/23

var express = require('express');
var app = express();
app.get("items/:id", function(req, res) {
    var id = req.params.id;
    //further operations to perform
});
app.listen(3000);

Metoda 2: Podejście ogólne: przekazywanie zmiennych jako ciągu zapytania za pomocą „?” operator
Na przykład zapoznaj się z poniższym kodem, w którym oczekuję, że identyfikator jako parametr parametru zapytania
może wyglądać tak: http://myhost.com/items?id=23

var express = require('express');
var app = express();
app.get("/items", function(req, res) {
    var id = req.query.id;
    //further operations to perform
});
app.listen(3000);

Powinieneś być w stanie zrobić coś takiego:

var http = require('http');
var url  = require('url');

http.createServer(function(req,res){
    var url_parts = url.parse(req.url, true);
    var query = url_parts.query;

    console.log(query); //{Object}

    res.end("End")
})

AKTUALIZACJA 4 maja 2014 r

Stara odpowiedź została zachowana tutaj: https://gist.github.com/stefek99/b10ed037d2a4a323d638

1) Zainstaluj ekspresowe: npm install express

app.js

var express = require('express');
var app = express();

app.get('/endpoint', function(request, response) {
    var id = request.query.id;
    response.end("I have received the ID: " + id);
});

app.listen(3000);
console.log("node express app started at http://localhost:3000");

2) Uruchom aplikację: node app.js

3) Odwiedź w przeglądarce: http://localhost:3000/endpoint?id=something

Otrzymałem identyfikator: coś

(wiele rzeczy zmieniło się od mojej odpowiedzi i uważam, że warto je aktualizować)

Mały serwer HTTP Node.js nasłuchujący na porcie 9080, analizujący dane GET lub POST i wysyłający go z powrotem do klienta w ramach odpowiedzi to:

var sys = require('sys'),
url = require('url'),
http = require('http'),
qs = require('querystring');

var server = http.createServer(

    function (request, response) {

        if (request.method == 'POST') {
                var body = '';
                request.on('data', function (data) {
                    body += data;
                });
                request.on('end',function() {

                    var POST =  qs.parse(body);
                    //console.log(POST);
                    response.writeHead( 200 );
                    response.write( JSON.stringify( POST ) );
                    response.end();
                });
        }
        else if(request.method == 'GET') {

            var url_parts = url.parse(request.url,true);
            //console.log(url_parts.query);
            response.writeHead( 200 );
            response.write( JSON.stringify( url_parts.query ) );
            response.end();
        }
    }
);

server.listen(9080);

Zapisz go jako parse.jsi uruchom na konsoli, wpisując „node parse.js”.

Whitequark odpowiedziała ładnie. Ale w obecnych wersjach Node.js i Express.js wymaga jeszcze jednej linii. Pamiętaj, aby dodać „wymagaj http” (drugi wiersz). Zamieściłem tutaj pełniejszy przykład, który pokazuje, jak to połączenie może działać. Po uruchomieniu wpisz http://localhost:8080/?name=abel&fruit=applew przeglądarce, a otrzymasz fajną odpowiedź na podstawie kodu.

var express = require('express');
var http = require('http');
var app = express();

app.configure(function(){
    app.set('port', 8080);
});

app.get('/', function(req, res){
  res.writeHead(200, {'content-type': 'text/plain'});
  res.write('name: ' + req.query.name + '\n');
  res.write('fruit: ' + req.query.fruit + '\n');
  res.write('query: ' + req.query + '\n');
  queryStuff = JSON.stringify(req.query);
  res.end('That\'s all folks'  + '\n' + queryStuff);
});

http.createServer(app).listen(app.get('port'), function(){
    console.log("Express server listening on port " + app.get('port'));
})

To takie proste:

Przykładowy adres URL:

http://stackoverflow.com:3000/activate_accountid=3&activatekey=$2a$08$jvGevXUOvYxKsiBt.PpMs.zgzD4C/wwTsvjzfUrqLrgS3zXJVfVRK

Możesz wydrukować wszystkie wartości ciągu zapytania, używając:

console.log("All query strings: " + JSON.stringify(req.query));

Wynik

Wszystkie ciągi zapytań: {"id": "3", "activatekey": "2 $ 08 USD $ jvGevXUOvYxKsiBt.PpMs.zgzD4C / wwTsvjz fUrqLrgS3zXJVfVRK"}

Aby wydrukować konkretny:

console.log("activatekey: " + req.query.activatekey);

Wynik

activatekey: 2 $ a 08 $ $ jvGevXUOvYxKsiBt.PpMs.zgzD4C / wwTsvjzfUrqLrgS3zXJVfVRK

Możesz użyć

request.query.<varible-name>;

Możesz używać z ekspresowym ^ 4.15.4:

var express = require('express'),
    router = express.Router();
router.get('/', function (req, res, next) {
    console.log(req.query);
});

Mam nadzieję że to pomoże.

Aby express.jsuzyskać całkiem proste, wszystko, co musisz zrobić w funkcji kontrolera, to:

app.get('/', (req, res, next) => {
   const {id} = req.query;
   // rest of your code here...
})

I to wszystko, zakładając, że używasz składni es6.

PD. {id}oznacza Object destructuringnową funkcję es6.

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);    
});

Możesz użyć tego lub możesz wypróbować body-parser do parsowania specjalnego elementu z parametrów żądania.

To naprawdę proste:

const express= require('express');
const app = express();

app.get('/post', (req, res, next) => {
  res.send('ID:' + req.query.id + ' Edit:'+ req.query.edit);
});

app.listen(1000);

// localhost:1000/post?id=123&edit=true
// output: ID: 123 Edit: true

możesz użyć modułu url do zbierania parametrów za pomocą url.parse

var url = require('url');
var url_data = url.parse(request.url, true);
var query = url_data.query;

W expressjs odbywa się to przez

var id = req.query.id;

Na przykład:

var express = require('express');
var app = express();

app.get('/login', function (req, res, next) {
    console.log(req.query);
    console.log(req.query.id); //Give parameter id
});

W Express możemy po prostu użyć req.query.<name>. Działa tak samo jak $_GET['name']w PHP.

Z mojego punktu widzenia uważam, że wiele osób łączy dwie różne koncepcje. Podczas tworzenia REST znałem przekazywanie informacji w adresie URL na dwa sposoby: „zmienne ścieżki” i „parametry żądania” (parametry zapytania). RFC opisuje części URI w ten sposób: wpisz opis linku tutaj Więc zrozumiałem, że autor chciałby wiedzieć, jak przekazać parametry żądania. Chciałbym tylko, aby ten temat był łatwiejszy do zrozumienia, ale rozwiązanie zostało tu wspomniane wiele razy.

Możesz uzyskać parametry zapytania z URI request.query.<name of the parameter>, drugim wspomnianym rozwiązaniem było request.params.<name of the parameter>i dzięki temu możesz uzyskać zmienne ścieżki.

Istnieją dwa sposoby otrzymania tego „identyfikatora”: 1) przy użyciu parametrów: parametry kodu będą wyglądały mniej więcej tak: Powiedzmy, że mamy tablicę,

const courses = [{
    id: 1,
    name: 'Mathematics'
},
{
    id: 2,
    name: 'History'
}
];

Następnie dla parametrów możemy zrobić coś takiego:

app.get('/api/posts/:id',(req,res)=>{
    const course = courses.find(o=>o.id == (req.params.id))
    res.send(course);
});

2) Inną metodą jest użycie parametrów zapytania. więc adres URL będzie wyglądał mniej więcej tak: „..... \ api \ xyz? id = 1” gdzie „? id = 1” to część zapytania. W tym przypadku możemy zrobić coś takiego:

app.get('/api/posts',(req,res)=>{
    const course = courses.find(o=>o.id == (req.query.id))
    res.send(course);
});

var express = require('express');
var app = express();

app.get('/', function(req, res){
  res.send('id: ' + req.query.id);
});

app.listen(3000);

Jeśli kiedykolwiek będziesz musiał wysłać GETzapytanie do ( IPa także w Domaininnych odpowiedziach nie wspomniano, że możesz podać portzmienną), możesz skorzystać z tej funkcji:

function getCode(host, port, path, queryString) {
    console.log("(" + host + ":" + port + path + ")" + "Running httpHelper.getCode()")

    // Construct url and query string
    const requestUrl = url.parse(url.format({
        protocol: 'http',
        hostname: host,
        pathname: path,
        port: port,
        query: queryString
    }));

    console.log("(" + host + path + ")" + "Sending GET request")
    // Send request
    console.log(url.format(requestUrl))
    http.get(url.format(requestUrl), (resp) => {
        let data = '';

        // A chunk of data has been received.
        resp.on('data', (chunk) => {
            console.log("GET chunk: " + chunk);
            data += chunk;
        });

        // The whole response has been received. Print out the result.
        resp.on('end', () => {
            console.log("GET end of response: " + data);
        });

    }).on("error", (err) => {
        console.log("GET Error: " + err);
    });
}

Nie przegap wymaganych modułów na górze pliku:

http = require("http");
url = require('url')

Pamiętaj też, że możesz używać httpsmodułu do komunikacji przez bezpieczne domeny i ssl. więc te dwie linie zmieniłyby się:

https = require("https");
...
https.get(url.format(requestUrl), (resp) => { ......

dlaczego nie zmieszać z kodem serwera

np. php

<script>
var ip=<?php echo($_SERVER['REMOTE_ADDR']);?>

</script>

Używam MEANJS 0.6.0 z [email protected], to dobrze

Klient:

Kontroler:

var input = { keyword: vm.keyword };
ProductAPi.getOrder(input)

usługi:

this.getOrder = function (input) {return $http.get('/api/order', { params: input });};

serwer

trasy

app.route('/api/order').get(products.order);

kontroler

exports.order = function (req, res) {
  var keyword = req.query.keyword
  ...

-------- Dostęp do danych ciągu zapytania -------
Załóżmy, że jest to link http://webapplog.com/search?term=node.js&page=1

W ekspresowym trybie możesz użyć:

• req.query.term
• req.query.page lub
• req.query(pobierze zapytanie do obiektu)
  
  // Przykład
  app.get('http://webapplog.com/search?term=node.js&page=1',(req, res)=>{ res.json({term:req.query.term, page:req.query.page}) })

-------- Uzyskiwanie dostępu do parametrów adresu URL -------
Załóżmy, że jest to link http://webapplog.com/node.js/pages/100
Tak więc możesz użyć: app.get('/:term/pages/:page',....)

• req.params.term
• req.params.page
  
  // Przykład
  app.get('http://webapplog.com/:term/pages/:page',(req, res)=>{ res.json({term:req.params.term, page:req.params.page}) })