Je veux pouvoir définir un seul cookie et lire ce cookie unique à chaque demande adressée à l'instance de serveur nodejs. Cela peut-il être fait en quelques lignes de code, sans avoir besoin de tirer une bibliothèque tierce?

var http = require('http');

http.createServer(function (request, response) {
  response.writeHead(200, {'Content-Type': 'text/plain'});
  response.end('Hello World\n');
}).listen(8124);

console.log('Server running at http://127.0.0.1:8124/');

J'essaie juste de prendre le code ci-dessus directement à partir de nodejs.org et d'y insérer un cookie.

Il n'y a pas d'accès rapide aux fonctions pour obtenir / configurer des cookies, j'ai donc proposé le hack suivant:

var http = require('http');

function parseCookies (request) {
    var list = {},
        rc = request.headers.cookie;

    rc && rc.split(';').forEach(function( cookie ) {
        var parts = cookie.split('=');
        list[parts.shift().trim()] = decodeURI(parts.join('='));
    });

    return list;
}


http.createServer(function (request, response) {

  // To Read a Cookie
  var cookies = parseCookies(request);

  // To Write a Cookie
  response.writeHead(200, {
    'Set-Cookie': 'mycookie=test',
    'Content-Type': 'text/plain'
  });
  response.end('Hello World\n');
}).listen(8124);

console.log('Server running at http://127.0.0.1:8124/');

Cela stockera tous les cookies dans l'objet cookies, et vous devez définir des cookies lorsque vous écrivez la tête.

Si vous utilisez la bibliothèque express, comme le font de nombreux développeurs node.js, il existe un moyen plus simple. Consultez la page de documentation d'Express.js pour plus d'informations.

L'exemple d'analyse ci-dessus fonctionne mais express vous offre une fonction intéressante pour vous en occuper:

app.use(express.cookieParser());

Pour définir un cookie:

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

Pour effacer le cookie:

res.clearCookie('cookiename');

RevNoah a eu la meilleure réponse avec la suggestion d'utiliser l' analyseur de cookies d'Express . Mais, cette réponse a maintenant 3 ans et est obsolète.

En utilisant Express , vous pouvez lire un cookie comme suit

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']);
})

Et mettez à jour votre package.jsonavec ce qui suit, en remplaçant les versions relativement récentes appropriées.

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

D'autres opérations telles que la configuration et l'analyse des cookies sont décrites ici et ici

Pour améliorer la réponse de @Corey Hart, j'ai réécrit l' parseCookies()utilisation:

• RegExp.prototype.exec - utilise regex pour analyser les chaînes "nom = valeur"

Voici l'exemple de travail:

let http = require('http');

function parseCookies(str) {
  let rx = /([^;=\s]*)=([^;]*)/g;
  let obj = { };
  for ( let m ; m = rx.exec(str) ; )
    obj[ m[1] ] = decodeURIComponent( m[2] );
  return obj;
}

function stringifyCookies(cookies) {
  return Object.entries( cookies )
    .map( ([k,v]) => k + '=' + encodeURIComponent(v) )
    .join( '; ');
}

http.createServer(function ( request, response ) {
  let 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);

Je note également que l'OP utilise le module http. Si l'OP utilisait restify , il peut utiliser 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);

Vous pouvez utiliser le module "cookies" npm, qui dispose d'un ensemble complet de fonctionnalités.

Documentation et exemples sur:
https://github.com/jed/cookies

Pour faire fonctionner un séparateur de cookies avec les cookies qui ont «=» dans les valeurs de 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;
};

puis pour obtenir un cookie individuel:

get_cookies(request)['my_cookie']

Les cookies sont transférés via les en-têtes HTTP.
Vous n'aurez qu'à analyser les en-têtes de requête et mettre les en-têtes de réponse.

Voici un correctif copier-coller pour gérer les cookies dans node. Je vais le faire dans CoffeeScript, pour la beauté.

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

Vous pourrez désormais gérer les cookies comme vous vous en doutez:

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

Permettez-moi de répéter cette partie de la question dont les réponses ici ignorent:

Cela peut-il être fait en quelques lignes de code, sans avoir besoin de tirer une bibliothèque tierce?

Lire les cookies

Les cookies sont lus à partir des demandes avec l'en- Cookietête. Ils incluent uniquement un nameet value. En raison du fonctionnement des chemins, plusieurs cookies du même nom peuvent être envoyés. Dans NodeJS, tous les cookies sont en une seule chaîne lorsqu'ils sont envoyés dans l'en- Cookietête. Vous les avez séparés ;. Une fois que vous avez un cookie, tout ce qui se trouve à gauche de l'égal (si présent) est le name, et tout ce qui suit est le value. Certains navigateurs acceptent un cookie sans signe égal et présument que le nom est vide. Les espaces ne comptent pas comme faisant partie du cookie. Les valeurs peuvent également être placées entre guillemets ( "). Les valeurs peuvent également contenir =. Par exemple, formula=5+3=8est un cookie valide.

/**
 * @param {string} [cookieString='']
 * @return {[string,string][]} String Tuple
 */
function getEntriesFromCookie(cookieString = '') {
  return cookieString.split(';').map((pair) => {
    const indexOfEquals = pair.indexOf('=');
    let name;
    let value;
    if (indexOfEquals === -1) {
      name = '';
      value = pair.trim();
    } else {
      name = pair.substr(0, indexOfEquals).trim();
      value = pair.substr(indexOfEquals + 1).trim();
    }
    const firstQuote = value.indexOf('"');
    const lastQuote = value.lastIndexOf('"');
    if (firstQuote !== -1 && lastQuote !== -1) {
      value = value.substring(firstQuote + 1, lastQuote);
    }
    return [name, value];
  });
}

const cookieEntries = getEntriesFromCookie(request.headers.Cookie); 
const object = Object.fromEntries(cookieEntries.slice().reverse());

Si vous n'attendez pas de noms dupliqués, vous pouvez convertir en un objet, ce qui facilite les choses. Ensuite, vous pouvez accéder à comme object.myCookieNamepour obtenir la valeur. Si vous prévoyez des doublons, vous souhaitez effectuer une itération cookieEntries. Les navigateurs alimentent les cookies par ordre de priorité décroissante, donc l'inversion garantit que le cookie de priorité la plus élevée apparaît dans l'objet. (Le but .slice()est d'éviter la mutation du tableau.)

Cookies de paramètres

"L'écriture" des cookies se fait en utilisant l'en- Set-Cookietête dans votre réponse. L' response.headers['Set-Cookie']objet est en fait un tableau, vous y pousserez donc. Il accepte une chaîne mais a plus de valeurs que juste nameet value. Le plus difficile est d'écrire la chaîne, mais cela peut être fait en une seule ligne.

/**
 * @param {Object} options
 * @param {string} [options.name='']
 * @param {string} [options.value='']
 * @param {Date} [options.expires]
 * @param {number} [options.maxAge]
 * @param {string} [options.domain]
 * @param {string} [options.path]
 * @param {boolean} [options.secure]
 * @param {boolean} [options.httpOnly]
 * @param {'Strict'|'Lax'|'None'} [options.sameSite]
 * @return {string}
 */
function createSetCookie(options) {
  return (`${options.name || ''}=${options.value || ''}`)
    + (options.expires != null ? `; Expires=${options.expires.toUTCString()}` : '')
    + (options.maxAge != null ? `; Max-Age=${options.maxAge}` : '')
    + (options.domain != null ? `; Domain=${options.domain}` : '')
    + (options.path != null ? `; Path=${options.path}` : '')
    + (options.secure ? '; Secure' : '')
    + (options.httpOnly ? '; HttpOnly' : '')
    + (options.sameSite != null ? `; SameSite=${options.sameSite}` : '');
}

const newCookie = createSetCookie({
  name: 'cookieName',
  value: 'cookieValue',
  path:'/',
});
response.headers['Set-Cookie'].push(newCookie);

N'oubliez pas que vous pouvez définir plusieurs cookies, car vous pouvez en fait définir plusieurs en- Set-Cookietêtes dans votre demande. C'est pourquoi c'est un tableau.

Remarque sur les bibliothèques externes:

Si vous décidez d'utiliser le express,, cookie-parserou cookie, notez que leurs valeurs par défaut ne sont pas standard. Les cookies analysés sont toujours décodés par URI (décodés en pourcentage). Cela signifie que si vous utilisez un nom ou une valeur !#$%&'()*+/:<=>?@[]^`{|}contenant l' un des caractères suivants: ils seront traités différemment avec ces bibliothèques. Si vous définissez des cookies, ils sont encodés avec%{HEX} . Et si vous lisez un cookie, vous devez le décoder.

Par exemple, tant que email=name@domain.comest un cookie valide, ces bibliothèques l'encoderont comme email=name%40domain.com. Le décodage peut présenter des problèmes si vous utilisez le %dans votre cookie. Ça va être mutilé. Par exemple, votre cookie qui était: secretagentlevel=50%007and50%006devient secretagentlevel=507and506. C'est un cas limite, mais quelque chose à noter en cas de changement de bibliothèque.

De plus, sur ces bibliothèques, les cookies sont définis par défaut, path=/ce qui signifie qu'ils sont envoyés à chaque demande d'URL à l'hôte.

Si vous souhaitez encoder ou décoder ces valeurs vous-même, vous pouvez utiliser respectivement encodeURIComponentou decodeURIComponent.

Références:

• Syntaxe des cookies
• Syntaxe de Set-Cookie

Information additionnelle:

• https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cookie
• https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie

Tout d'abord, il faut créer un cookie (j'ai enveloppé le jeton dans le cookie comme exemple), puis le définir en réponse.Pour utiliser le cookie de la manière suivante, installez cookieParser

app.use(cookieParser());

Le navigateur l'aura sauvegardé dans son onglet 'Ressource' et sera utilisé pour chaque demande par la suite en prenant l'URL initiale comme base

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

Obtenir un cookie à partir d'une requête côté serveur est également facile. Vous devez extraire le cookie de la requête en appelant la propriété 'cookie' de l'objet de requête.

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

Si vous ne vous souciez pas de ce qu'il y a dans le cookieet que vous voulez juste l'utiliser, essayez cette approche propre en utilisant request(un module de nœud populaire):

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
  });
});

var cookie = 'your_cookie';
var cookie_value;
var i = request.headers.indexOf(cookie+'=');
if (i != -1) {
  var eq = i+cookie.length+1;
  var end = request.headers.indexOf(';', eq);
  cookie_value = request.headers.substring(eq, end == -1 ? undefined : end);
}

Utilisation de certains ES5 / 6 Sorcery & RegEx Magic

Voici une option pour lire les cookies et les transformer en un objet de paires clé, valeur pour le côté client, pourrait également l'utiliser côté serveur.

Remarque : s'il y a un =dans la valeur, pas de soucis. S'il y a un =problème dans la clé, au paradis.

Plus de notes : Certains peuvent discuter de la lisibilité, alors décomposez-la comme vous le souhaitez.

J'aime les notes : L'ajout d'un gestionnaire d'erreurs (try catch) ne ferait pas de mal.

const iLikeCookies = () => {
    return Object.fromEntries(document.cookie.split('; ').map(v => v.split(/=(.+)/))); 
}

const main = () => {
    // Add Test Cookies
    document.cookie = `name=Cookie Monster;expires=false;domain=localhost`
    document.cookie = `likesCookies=yes=withARandomEquals;expires=false;domain=localhost`;

    // Show the Objects
    console.log(document.cookie)
    console.log('The Object:', iLikeCookies())

    // Get a value from key
    console.log(`Username: ${iLikeCookies().name}`)
    console.log(`Enjoys Cookies: ${iLikeCookies().likesCookies}`)
}

Que se passe-t-il?

iLikeCookies()divisera les cookies par ;( espace après; ):

["name=Cookie Monster", "likesCookies=yes=withARandomEquals"]

Ensuite, nous mappons ce tableau et le divisons par la première occurrence de l' =utilisation de parens de capture de regex :

[["name", "Cookie Monster"], ["likesCookies", "yes=withARandomEquals"]]

Ensuite, utilisez notre ami `Object.fromEntries pour en faire un objet de paires clé, val.

Nooice.

J'ai écrit cette fonction simple juste passer req.headers.cookieet le nom du cookie

const getCookieByName =(cookies,name)=>{
    const arrOfCookies = cookies.split(' ')
    let yourCookie = null

    arrOfCookies.forEach(element => {
        if(element.includes(name)){
            yourCookie = element.replace(name+'=','')
        }
    });
    return yourCookie
}