Pobierz i ustaw pojedynczy plik Cookie z węzłem.serwer HTTP js

Jeśli używasz biblioteki express, tyle węzłów.Programiści js tak robią, jest łatwiejszy sposób. Sprawdź ekspres.strona dokumentacji js, aby uzyskać więcej informacji.

Powyższy przykład parsowania działa, ale express daje Ci ładną funkcję, aby się tym zająć:

app.use(express.cookieParser());

Aby ustawić plik cookie:

res.cookie('cookiename', 'cookievalue', { maxAge: 900000, httpOnly: true });

Aby wyczyścić plik cookie:

res.clearCookie('cookiename');

RevNoah miał najlepszą odpowiedź z sugestią użycia parsera cookie Express . Ale ta odpowiedź ma teraz 3 lata i jest nieaktualna.

Używając Express , możesz odczytać plik cookie w następujący sposób

var express = require('express');
var cookieParser = require('cookie-parser');
var app = express();
app.use(cookieParser());
app.get('/myapi', function(req, resp) {
   console.log(req.cookies['Your-Cookie-Name-Here']);
} 

I zaktualizuj swoje package.json z następującymi, zastępując odpowiednie stosunkowo najnowsze wersje.

"dependencies": {
    "express": "4.12.3",
    "cookie-parser": "1.4.0"
  },

Więcej operacji, takich jak ustawianie i analizowanie plików cookie, jest opisanych tutaj

Możesz korzystać z modułu "cookies" npm, który ma kompleksowy zestaw funkcji.

Dokumentacja i przykłady na:
https://github.com/jed/cookies

Pliki cookie są przesyłane przez HTTP-Headers
Będziesz musiał tylko przeanalizować nagłówki żądań i umieścić nagłówki odpowiedzi.

Aby uruchomić rozdzielacz plików cookie z plikami cookie, które mają " = "w wartościach plików cookie:

var get_cookies = function(request) {
  var cookies = {};
  request.headers && request.headers.cookie.split(';').forEach(function(cookie) {
    var parts = cookie.match(/(.*?)=(.*)$/)
    cookies[ parts[1].trim() ] = (parts[2] || '').trim();
  });
  return cookies;
};

Następnie, aby uzyskać indywidualny plik cookie:

get_cookies(request)['my_cookie']

Jako uzupełnienie odpowiedzi @ Corey Hart, przepisałem parseCookies() używając:

• String.prototyp.split - konwertuje łańcuch ciasteczek na listę
• Array.prototyp.reduce - konwertuje listę do pojedynczego obiektu
• RegExp.prototyp.exec - use regex to parse" nazwa=wartość " strings

Oto przykład roboczy:

var http = require('http');

function parseCookies(cookie) {
    return cookie.split(';').reduce(
        function(prev, curr) {
            var m = / *([^=]+)=(.*)/.exec(curr);
            var key = m[1];
            var value = decodeURIComponent(m[2]);
            prev[key] = value;
            return prev;
        },
        { }
    );
}

function stringifyCookies(cookies) {
    var list = [ ];
    for (var key in cookies) {
        list.push(key + '=' + encodeURIComponent(cookies[key]));
    }
    return list.join('; ');
}

http.createServer(function (request, response) {
  var cookies = parseCookies(request.headers.cookie);
  console.log('Input cookies: ', cookies);
  cookies.search = 'google';
  if (cookies.counter)
    cookies.counter++;
  else
    cookies.counter = 1;
  console.log('Output cookies: ', cookies);
  response.writeHead(200, {
    'Set-Cookie': stringifyCookies(cookies),
    'Content-Type': 'text/plain'
  });
  response.end('Hello World\n');
}).listen(1234);

Zauważam również, że OP używa modułu http. Jeśli OP używałrestify , może użyć of restify-cookies :

var CookieParser = require('restify-cookies');
var Restify = require('restify');
var server = Restify.createServer();
server.use(CookieParser.parse);
server.get('/', function(req, res, next){
  var cookies = req.cookies; // Gets read-only cookies from the request
  res.setCookie('my-new-cookie', 'Hi There'); // Adds a new cookie to the response
  res.send(JSON.stringify(cookies));
});
server.listen(8080);

Oto zgrabna łatka copy-n-paste do zarządzania plikami cookie w węźle. Zrobię to w CoffeeScript, dla piękna.

http = require 'http'

http.IncomingMessage::getCookie = (name) ->
  cookies = {}
  this.headers.cookie && this.headers.cookie.split(';').forEach (cookie) ->
    parts = cookie.split '='
    cookies[parts[0].trim()] = (parts[1] || '').trim()
    return

  return cookies[name] || null

http.IncomingMessage::getCookies = ->
  cookies = {}
  this.headers.cookie && this.headers.cookie.split(';').forEach (cookie) ->
    parts = cookie.split '='
    cookies[parts[0].trim()] = (parts[1] || '').trim()
    return

  return cookies

http.OutgoingMessage::setCookie = (name, value, exdays, domain, path) ->
  cookies = this.getHeader 'Set-Cookie'
  if typeof cookies isnt 'object'
    cookies = []

  exdate = new Date()
  exdate.setDate(exdate.getDate() + exdays);
  cookieText = name+'='+value+';expires='+exdate.toUTCString()+';'
  if domain
    cookieText += 'domain='+domain+';'
  if path
    cookieText += 'path='+path+';'

  cookies.push cookieText
  this.setHeader 'Set-Cookie', cookies
  return

Teraz będziesz mógł obsługiwać ciasteczka tak, jak byś się spodziewał:

server = http.createServer (request, response) ->
  #get individually
  cookieValue = request.getCookie 'testCookie'
  console.log 'testCookie\'s value is '+cookieValue

  #get altogether
  allCookies = request.getCookies()
  console.log allCookies

  #set
  response.setCookie 'newCookie', 'cookieValue', 30

  response.end 'I luvs da cookies';
  return

server.listen 8080

Jeśli nie obchodzi cię, co jest w cookie i po prostu chcesz go użyć, spróbuj tego czystego podejścia za pomocą request (popularny moduł węzła):

var request = require('request');
var j = request.jar();
var request = request.defaults({jar:j});
request('http://www.google.com', function () {
  request('http://images.google.com', function (error, response, body){
     // this request will will have the cookie which first request received
     // do stuff
  });
});

Inny prosty sposób JavaScript, aby uzyskać wartość cookie za pomocą klucza bez użycia regex:

function getCookieValue(k) {
    var str = document.cookie; // 'k1=v1=v11=v12; k2=v2; k3=v3'
    var i = str.indexOf(k + '=');
    if (i === -1) {
        return undefined;
    }
    if (i > 0 && str[i - 1] !== ' ') {
        return undefined;
    }
    var j = i + k.length + 1;
    var end = str.indexOf(';', j);
    return decodeURIComponent(str.slice(j, end === -1 ? undefined : end));
}

Aby uzyskać pojedyncze ciasteczko ten kod byłby szybszy niż parsowanie wszystkich ciasteczek:

getSingleCookie = (cookie, name) ->
  vIx = cookie.indexOf "#{name}="
  if vIx != -1
    egalIx = vIx+name.length+1
    colIx = cookie.indexOf ';', egalIx
    v = if colIx == -1
      cookie.substring egalIx
    else
      cookie.substring egalIx, colIx
    return v

Należy używać w następujący sposób:

getSingleCookie request.headers, 'my_cookie'

Najpierw należy utworzyć plik cookie (jako przykład zawinąłem token w pliku cookie), a następnie ustawić go w response.To użyj pliku cookie w następujący sposób zainstaluj cookieParser

app.use(cookieParser());

Przeglądarka zapisze go w zakładce "zasoby" i będzie używana do każdego żądania, przyjmując początkowy adres URL jako podstawę

var token = student.generateToken('authentication');
        res.cookie('token', token, {
            expires: new Date(Date.now() + 9999999),
            httpOnly: false
        }).status(200).send();

Uzyskanie pliku cookie z żądania po stronie serwera jest również łatwe.Musisz wyodrębnić plik cookie z żądania, dzwoniąc do właściwości "cookie" żądania obiekt.

var token = req.cookies.token; // Retrieving Token stored in cookies