Obtenir un cookie par nom

Une approche, qui évite d'itérer sur un tableau, serait:

 function getCookie(name) { var value = "; " + document.cookie; var parts = value.split("; " + name + "="); if (parts.length == 2) return parts.pop().split(";").shift(); } 

Procédure pas à pas

Le fractionnement d'une chaîne par jeton produira soit un tableau avec une chaîne (même valeur), si le jeton n'existe pas dans une chaîne ou un tableau à deux chaînes, dans le cas où un jeton se trouve dans une chaîne.

Le premier élément (gauche) est une chaîne de ce qui était avant le jeton, et le second (à droite) est ce qui est une chaîne de ce qui était après le jeton.

(NOTE: dans le cas où la chaîne commence par un jeton, le premier élément est une chaîne vide)

Étant donné que les cookies sont stockés comme suit:

 "{name}={value}; {name}={value}; ..." 

Afin de récupérer une valeur de cookie spécifique, il suffit d'obtenir une chaîne qui est après "; {name} =" et avant la prochaine ";". Avant de procéder à un traitement, nous précisons la chaîne de cookies avec ";", de sorte que chaque nom de cookie, y compris le premier, est joint à ";" et "=":

 "; {name}={value}; {name}={value}; ..." 

Maintenant, nous pouvons d'abord diviser par "; {name} =", et si le jeton est trouvé dans une chaîne de cookies (c'est-à-dire que nous avons deux éléments), nous finirons par que le deuxième élément soit une chaîne qui commence par notre valeur de cookie. Ensuite, nous tirons cela d'un tableau (c'est-à-dire pop), et répétons le même processus, mais maintenant avec ";" Comme un jeton, mais cette fois, retirer la chaîne gauche (c.-à-d. Shift) pour obtenir la valeur du jeton réel.

Utiliser un cookie pour obtenir un script:

 function readCookie(name) { var nameEQ = name + "="; var ca = document.cookie.split(';'); for(var i=0;i < ca.length;i++) { var c = ca[i]; while (c.charAt(0)==' ') c = c.substring(1,c.length); if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length); } return null; } 

Puis appelez-le:

 var value = readCookie('obligations'); 

J'ai volé le code ci-dessus à partir de la page des cookies de quirksmode. Vous devriez le lire .

Je préférerais utiliser une seule combinaison d'expression régulière sur le cookie:

 window.getCookie = function(name) { match = document.cookie.match(new RegExp(name + '=([^;]+)')); if (match) return match[1]; } 

Si vous utilisez jQuery, je vous recommande d'utiliser ce plugin:

https://github.com/carhartl/jquery-cookie
https://github.com/carhartl/jquery-cookie/blob/master/jquery.cookie.js

 <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/jquery-cookie/1.4.1/jquery.cookie.min.js"> 

Ainsi, vous pouvez lire des cookies comme ceci:

 var value = $.cookie("obligations"); 

Aussi, vous pouvez écrire des cookies:

 $.cookie('obligations', 'new_value'); $.cookie('obligations', 'new_value', { expires: 14, path: '/' }); 

Supprimer le cookie:

 $.removeCookie('obligations'); 

Les méthodes dans certaines des autres réponses qui utilisent une expression régulière ne couvrent pas tous les cas, en particulier:

1. Lorsque le cookie est le dernier cookie. Dans ce cas, il n'y aura pas de point-virgule après la valeur de cookie.
2. Lorsqu'un autre nom de cookie se termine avec le nom recherché. Par exemple, vous recherchez le cookie nommé «un», et il existe un cookie nommé «fait».
3. Lorsque le nom de cookie inclut des caractères qui ne sont pas interprétés comme eux-mêmes lorsqu'ils sont utilisés dans une expression régulière, sauf s'ils sont précédés d'une barre oblique inverse.

La méthode suivante gère ces cas:

 function getCookie(name) { function escape(s) { return s.replace(/([.*+?\^${}()|\[\]\/\\])/g, '\\$1'); }; var match = document.cookie.match(RegExp('(?:^|;\\s*)' + escape(name) + '=([^;]*)')); return match ? match[1] : null; } 

Cela renverra null si le cookie n'est pas trouvé. Il renverra une chaîne vide si la valeur du cookie est vide.

Remarques:

1. Cette fonction suppose que les noms de cookie sont sensibles à la casse .
2. document.cookie – Lorsque cela apparaît sur le côté droit d'une tâche, il représente une chaîne contenant une liste de cookies séparés par un point-virgule, qui sont à leur tour des paires name=value . Il semble y avoir un espace unique après chaque point-virgule.
3. String.prototype.match() – Retourne null quand aucune correspondance n'est trouvée. Renvoie un tableau lorsqu'une correspondance est trouvée, et l'élément à l'index [1] est la valeur du premier groupe correspondant.

Notes d'expression régulière:

1. (?:xxxx) – forme un groupe non correspondant.
2. ^ – correspond au début de la chaîne.
3. | – Sépare les modèles alternatifs du groupe.
4. ;\\s* – correspond à un point-virgule suivi de zéro ou plus de caractères d'espace blanc.
5. = – correspond à un signe égal.
6. (xxxx) – forme un groupe correspondant.
7. [^;]* – correspond à zéro ou plus de caractères autre qu'un point-virgule. Cela signifie qu'il va correspondre aux caractères, mais pas inclus, un point-virgule ou à la fin de la chaîne.

J'ai modifié la fonction que Jonathan a fournie ici, en utilisant une expression régulière, vous pouvez obtenir une valeur de cookie par son nom comme celui-ci:

 function getCookie(name){ var pattern = RegExp(name + "=.[^;]*") matched = document.cookie.match(pattern) if(matched){ var cookie = matched[0].split('=') return cookie[1] } return false } 

Si elle renvoie une chaîne vide, cela signifie que le cookie existe mais n'a aucune valeur, s'il renvoie false alors le cookie n'existe pas. J'espère que ça aide.

Je sais que c'est une vieille question, mais j'ai rencontré ce problème aussi. Juste pour le compte rendu, il existe une petite API dans la page web de développeurs Mozilla .

Yoy peut obtenir n'importe quel cookie par nom en utilisant uniquement JS. Le code est également plus pur IMHO (à l'exception de la ligne longue, que je suis sûr que vous pouvez facilement réparer).

 function getCookie(sKey) { if (!sKey) { return null; } return decodeURIComponent(document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" + encodeURIComponent(sKey).replace(/[\-\.\+\*]/g, "\\$&") + "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null; } 

Comme indiqué dans les commentaires, sachez que cette méthode suppose que la clé et la valeur ont été codées en utilisant encodeURIComponent (). Supprimez le décodage et encodeURIComponent () si la clé et la valeur du cookie n'ont pas été codées.

Fonctionne toujours bien:

 function getCookie(cname) { var name = cname + "=", ca = document.cookie.split(';'), i, c, ca_length = ca.length; for (i = 0; i < ca_length; i += 1) { c = ca[i]; while (c.charAt(0) === ' ') { c = c.substring(1); } if (c.indexOf(name) !== -1) { return c.substring(name.length, c.length); } } return ""; } function setCookie(variable, value, expires_seconds) { var d = new Date(); d = new Date(d.getTime() + 1000 * expires_seconds); document.cookie = variable + '=' + value + '; expires=' + d.toGMTString() + ';'; } 

Aucune exigence pour jQuery ou quoi que ce soit. Pure old good JavaScript.

Utilisez object.defineProperty

Avec cela, vous pouvez accéder facilement aux cookies

 Object.defineProperty(window, "Cookies", { get: function() { return document.cookie.split(';').reduce(function(cookies, cookie) { cookies[cookie.split("=")[0]] = unescape(cookie.split("=")[1]); return cookies }, {}); } }); 

A partir de maintenant, vous pouvez simplement:

 alert( Cookies.obligations ); 

Cela sera automatiquement mis à jour aussi, donc si vous modifiez un cookie, les Cookies vont également changer.

Dans mes projets, j'utilise la fonction suivante pour accéder aux cookies par leur nom

 function getCookie(cookie) { return document.cookie.split(';').reduce(function(prev, c) { var arr = c.split('='); return (arr[0].trim() === cookie) ? arr[1] : prev; }, undefined); } 

Kirlich a donné une bonne solution. Cependant, il échoue lorsqu'il existe deux valeurs de cookie avec des noms similaires, voici une solution simple pour cette situation:

 function getCookie(name) { var value = "; " + document.cookie; var parts = value.split("; " + name + "="); if (parts.length >= 2) return parts.pop().split(";").shift(); } 

Il me semble que vous pouvez diviser les paires de clés-valeurs de cookie en un tableau et fonder votre recherche sur cela:

 var obligations = getCookieData("obligations"); 

Ce qui suit:

 function getCookieData( name ) { var pairs = document.cookie.split("; "), count = pairs.length, parts; while ( count-- ) { parts = pairs[count].split("="); if ( parts[0] === name ) return parts[1]; } return false; } 

Fiddle: http://jsfiddle.net/qFmPc/

Ou peut-être même ce qui suit:

 function getCookieData( name ) { var patrn = new RegExp( "^" + name + "=(.*?);" ), patr2 = new RegExp( " " + name + "=(.*?);" ); if ( match = (document.cookie.match(patrn) || document.cookie.match(patr2)) ) return match[1]; return false; } 

Défini par javascript

 document.cookie = 'cookiename=tesing'; 

Obtenir par jquery

 var value = $.cookie("cookiename"); alert(value); 

Ma solution est la suivante:

 function getCookieValue(cookieName) { var ca = document.cookie.split('; '); return _.find(ca, function (cookie) { return cookie.indexOf(cookieName) === 0; }); } 

Cette fonction utilise la fonction Underscorejs _.find. Retourne indéfinie si le nom de cookie n'existe pas

Dustin Diaz (l'incroyable) a classé cette fonction fonctionnelle de tous les temps dans JS. Dans ses propres mots:

"Je déteste les implémentations de DOM de configurer des cookies en JavaScript. En PHP, c'est tellement facile, et c'est facile pour une raison principale, ils fonctionnent comme la fonction ci-dessous" …

Voir: http://www.dustindiaz.com/top-ten-javascript

 function getCookie(name) { var start = document.cookie.indexOf(name + "="); var len = start + name.length + 1; if ((!start) && (name != document.cookie.substring(0, name.length))) { return null; } if (start == -1) return null; var end = document.cookie.indexOf(';', len); if (end == -1) end = document.cookie.length; return unescape(document.cookie.substring(len, end)); } 

Fonction simple pour obtenir un cookie avec le nom de cookie:

 function getCookie(cn) { var name = cn+"="; var allCookie = decodeURIComponent(document.cookie).split(';'); var cval = []; for(var i=0; i < allCookie.length; i++) { if (allCookie[i].trim().indexOf(name) == 0) { cval = allCookie[i].trim().split("="); } } return (cval.length > 0) ? cval[1] : ""; } 

La fonction suivante renverra une paire key-value du cookie requis, où la key est le nom et la valeur du cookie sera la valeur du cookie.

 /** * Returns cookie key-value pair */ var getCookieByName = function(name) { var result = ['-1','-1']; if(name) { var cookieList = document.cookie.split(';'); result = $.grep(cookieList,function(cookie) { cookie = cookie.split('=')[0]; return cookie == name; }); } return result; }; 

Exemple de cookies: exemple JS:

 document.cookies = { create : function(key, value, time){ if (time) { var date = new Date(); date.setTime(date.getTime()+(time*24*60*60*1000)); var expires = "; expires="+date.toGMTString(); } else var expires = ""; document.cookie = key+"="+value+expires+"; path=/"; }, erase : function(key){ this.create(key,"",-1); }, read : function(key){ var keyX = key + "="; var ca = document.cookie.split(';'); for(var i=0;i < ca.length; i++) { var c = ca[i]; while (c.charAt(0)==' ') c = c.substring(1,c.length); if (c.indexOf(keyX) == 0) return c.substring(keyX.length,c.length); } return null; } } 

Arrays et objets de magasin avec json ou xml

Je ferais quelque chose comme ça:

 function getCookie(cookie){ return cookie .trim() .split(';') .map(function(line){return line.split(',');}) .reduce(function(props,line) { var name = line[0].slice(0,line[0].search('=')); var value = line[0].slice(line[0].search('=')); props[name] = value; return props; },{}) } 

Cela renverra votre cookie en tant qu'objet.

Et puis vous pouvez l'appeler comme ceci:

 getCookie(document.cookie)['shares'] 

J'aime utiliser une fermeture pour obtenir des valeurs de cookie par nom. La fermeture ci-dessous vous permettra d'obtenir une valeur de cookie par nom, mais ne fera que analyser la chaîne de cookies si elle a été mise à jour.

Vous pouvez récupérer la valeur d'un cookie avec les éléments suivants:

 var foo = cookies.get( "bar" ); 

Code:

 var cookies = ( function() { var cookieString = null; var cookieArray = []; function getValOf( name ) { if ( newCookies() ) { parseCookieString() } return cookieArray[ name ]; } // Check if new cookies have been added function newCookies() { return cookieString === document.cookie; } function parseCookieString() { cookieString = document.cookie; // Separate cookies var cookies = cookieString.split( ";" ); // Empty previous cookies cookieArray = []; // Update cookieArray with new name-value pairs for ( var i in cookies ) { // Separate name and value var nameVal = cookies[ i ].split( "=" ); var name = nameVal[ 0 ].trim(); var value = nameVal[ 1 ].trim(); // Add cookie name value pair to dictionary cookieArray[ name ] = value; } } return { /** * Returns value or undefined */ get: function( name ) { return getValOf( name ); } }; })(); 

Voici une version assez courte

  function getCookie(n) { let a = `; ${document.cookie}`.match(`;\\s*${n}=([^;]+)`); return a ? a[1] : ''; } 

Notez que j'ai utilisé les chaînes de modèles ES6 pour composer l'expression regex.

 function getCookie(name) { var pair = document.cookie.split('; ').find(x => x.startsWith(name+'=')); if (pair) return pair.split('=')[1] } 

Il y a déjà de belles réponses pour obtenir le cookie, mais voici ma propre solution:

 function getcookie(cookiename){ var cookiestring = document.cookie; var cookiearray = cookiestring.split(';'); for(var i =0 ; i < cookiearray.length ; ++i){ if(cookiearray[i].trim().match('^'+cookiename+'=')){ return cookiearray[i].replace(`${cookiename}=`,'').trim(); } } return null; } 

Usage: `

  getcookie('session_id'); // gets cookie with name session_id 

Une approche fonctionnelle pour trouver les cookies existants. Il renvoie un tableau, donc il prend en charge plusieurs occurrences du même nom. Il ne supporte pas la correspondance partielle des touches, mais il est banal de remplacer le === dans le filtre par un regex.

 function getCookie(needle) { return document.cookie.split(';').map(function(cookiestring) { cs = cookiestring.trim().split('='); if(cs.length === 2) { return {'name' : cs[0], 'value' : cs[1]}; } else { return {'name' : '', 'value' : ''}; } }) .filter(function(cookieObject) { return (cookieObject.name === needle); }); }