Ottieni cookie per nome

Ho un getter per ottenere il valore da un cookie.

Ora ho 2 cookie con il nome shares= e con il nome obligations= .

Voglio fare questo getter solo per ottenere i valori dal cookie obbligazioni.

Come faccio a fare questo? Quindi il ‘for’ divide i dati in valori separati e li inserisce in un array.

  function getCookie1() { // What do I have to add here to look only in the "obligations=" cookie? // Because now it searches all the cookies. var elements = document.cookie.split('='); var obligations= elements[1].split('%'); for (var i = 0; i < obligations.length - 1; i++) { var tmp = obligations[i].split('$'); addProduct1(tmp[0], tmp[1], tmp[2], tmp[3]); } } 

Un approccio, che evita di scorrere su un array, sarebbe:

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

Procedura dettagliata

La suddivisione di una stringa per token produrrà, una matrice con una stringa (stesso valore), nel caso in cui il token non esista in una stringa o una matrice con due stringhe, nel caso in cui il token venga trovato in una stringa.

Il primo elemento (a sinistra) è una stringa di ciò che era prima del token e il secondo (a destra) è la stringa di ciò che era dopo il token.

(NOTA: nel caso in cui la stringa inizi con un token, il primo elemento è una stringa vuota)

Considerando che i cookie sono memorizzati come segue:

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

per recuperare il valore specifico del cookie, dobbiamo solo ottenere una stringa che sia dopo “; {name} =” e prima di next “;”. Prima di procedere con l’elaborazione, viene anteposta la stringa dei cookie con “;”, in modo che ogni nome di cookie, incluso il primo, sia racchiuso tra “;” e “=”:

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

Ora possiamo dividere per “; {name} =”, e se il token si trova in una stringa di cookie (cioè abbiamo due elementi), il secondo elemento sarà una stringa che inizia con il nostro valore di cookie. Quindi lo estraiamo da un array (ovvero pop) e ripetiamo lo stesso processo, ma ora con “;” come token, ma questa volta tirando fuori la stringa sinistra (cioè shift) per ottenere il valore token effettivo.

Preferirei utilizzare una singola corrispondenza di espressioni regolari sul cookie:

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

Migliorato grazie a Scott Jungwirth nei commenti.

usa un cookie per ottenere lo 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; } 

quindi chiamalo:

 var value = readCookie('obligations'); 

ho rubato il codice sopra dalla pagina dei cookies di quirksmode. dovresti leggerlo

Se usi jQuery ti consiglio di usare questo plugin:

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

  

Quindi puoi leggere cookie come questo:

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

Inoltre puoi scrivere cookie:

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

Elimina cookie:

 $.removeCookie('obligations'); 

I metodi in alcune delle altre risposte che usano un’espressione regolare non coprono tutti i casi, in particolare:

  1. Quando il cookie è l’ultimo cookie. In questo caso non ci sarà un punto e virgola dopo il valore del cookie.
  2. Quando un altro nome di cookie termina con il nome cercato. Ad esempio, stai cercando il cookie denominato “uno” e c’è un cookie denominato “done”.
  3. Quando il nome del cookie include caratteri che non sono interpretati come se stessi quando usati in un’espressione regolare a meno che non siano preceduti da una barra rovesciata.

Il seguente metodo gestisce questi casi:

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

Questo restituirà null se il cookie non viene trovato. Restituirà una stringa vuota se il valore del cookie è vuoto.

Gli appunti:

  1. Questa funzione presuppone che i nomi dei cookie siano case sensitive .
  2. document.cookie – Quando appare sul lato destro di un compito, rappresenta una stringa contenente un elenco di cookie separati da punto e virgola, che a loro volta sono coppie name=value . Sembra esserci un singolo spazio dopo ogni punto e virgola.
  3. String.prototype.match() – Restituisce null quando non viene trovata alcuna corrispondenza. Restituisce una matrice quando viene trovata una corrispondenza e l’elemento all’indice [1] è il valore del primo gruppo corrispondente.

Note sulle espressioni regolari:

  1. (?:xxxx) – forma un gruppo non corrispondente.
  2. ^ – corrisponde all’inizio della stringa.
  3. | – separa i modelli alternativi per il gruppo.
  4. ;\\s* – corrisponde a un punto e virgola seguito da zero o più caratteri di spaziatura.
  5. = – corrisponde a un segno di uguale.
  6. (xxxx) : forma un gruppo corrispondente.
  7. [^;]* – corrisponde a zero o più caratteri diversi da un punto e virgola. Ciò significa che abbinerà i caratteri fino a, ma non includendo, un punto e virgola o alla fine della stringa.

Ho modificato la funzione che Jonathan ha fornito qui, utilizzando l’espressione regolare è ansible ottenere un valore del cookie con il suo nome in questo modo:

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

Se restituisce una stringa vuota significa che il cookie esiste ma non ha valore, se restituisce false quindi il cookie non esiste. Spero che aiuti.

So che è una vecchia domanda, ma mi sono imbattuto in questo problema. Solo per la cronaca, C’è una piccola API nella pagina web di mozilla per sviluppatori.

Yoy può ottenere qualsiasi cookie per nome usando solo JS. Il codice è anche più pulito IMHO (tranne per la lunga linea, che sono sicuro che si può facilmente risolvere).

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

Come affermato nei commenti, tenere presente che questo metodo presuppone che la chiave e il valore siano stati codificati utilizzando encodeURIComponent (). Rimuovi decode e encodeURIComponent () se la chiave e il valore del cookie non sono stati codificati.

4 anni dopo, la versione semplificata di ES6 è più semplice.

 function getCookie(name) { let cookie = {}; document.cookie.split(';').forEach(function(el) { let [k,v] = el.split('='); cookie[k.trim()] = v; }) return cookie[name]; } 

Ho anche creato un gist per usarlo come object Cookie . ad esempio, Cookie.set(name,value) e Cookie.get(name)

Questo legge tutti i cookie anziché la scansione. Va bene per un numero limitato di cookie.

Usa object.defineProperty

Con questo, puoi facilmente accedere ai cookie

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

D’ora in poi puoi solo fare:

 alert( Cookies.obligations ); 

Anche questo verrà aggiornato automaticamente, quindi se cambi un cookie, cambieranno anche i Cookies .

funziona sempre bene:

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

Nessun requisito per jQuery o altro. Pure vecchio buon JavaScript.

Funzione semplice per Ottieni cookie con nome 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] : ""; } 

kirlich ha dato una buona soluzione. Tuttavia, fallisce quando ci sono due valori di cookie con nomi simili, ecco una semplice soluzione per questa situazione:

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

Mi sembra che potresti dividere le coppie chiave-valore del cookie in un array e basare la tua ricerca su questo:

 var obligations = getCookieData("obligations"); 

Che esegue quanto segue:

 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/

O forse anche il seguente:

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

Nei miei progetti utilizzo la seguente funzione per accedere ai cookie per nome

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

Ecco una versione piuttosto breve

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

Si noti che ho fatto uso delle stringhe di template di ES6 per comporre l’espressione regex.

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

Ci sono già delle belle risposte qui per ottenere il cookie, tuttavia ecco la mia soluzione:

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

utilizzo: `

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

La mia soluzione è questa:

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

Questa funzione utilizza la funzione _find di Underscorejs. Restituisce undefined se il nome del cookie non esiste

L’ho fatto in questo modo. in modo che ottenga l’accesso a un object per separare i valori. Con questo si può passare il cookie al genitore e quindi è ansible accedere ai propri valori con le chiavi come

 var cookies=getCookieVal(mycookie); alert(cookies.mykey); function getCookieVal(parent) { var cookievalue = $.cookie(parent).split('&'); var obj = {}; $.each(cookievalue, function (i, v) { var key = v.substr(0, v.indexOf("=")); var val = v.substr(v.indexOf("=") + 1, v.length); obj[key] = val; }); return obj; } 

impostato da javascript

 document.cookie = 'cookiename=tesing'; 

get by jquery con il plugin jquery-cookie

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

Apparentemente MDN non ha mai sentito parlare della class di caratteri regex boundary word \b , che corrisponde a \w+ contigua che è limitata su entrambi i lati con \W+ :

 getCookie = function(name) { var r = document.cookie.match("\\b" + name + "=([^;]*)\\b"); return r ? r[1] : null; }; var obligations = getCookie('obligations'); 

Un approccio funzionale per trovare i cookie esistenti. Restituisce un array, quindi supporta più occorrenze con lo stesso nome. Non supporta la corrispondenza di chiavi parziali, ma è banale sostituire il === nel filtro con un’espressione regolare.

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

Puoi utilizzare la libreria js-cookie per ottenere e impostare i cookie JavaScript.

Includi nel tuo codice HTML:

  

Per creare un cookie:

 Cookies.set('name', 'value'); 

Per leggere un cookie:

 Cookies.get('name'); // => 'value' 

La funzione seguente restituirà una coppia key-value del cookie richiesto, dove la key è il nome del cookie e il value sarà il valore del 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; }; 

Esempio di cookie: esempio 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; } } 

Archivia array e oggetti con json o xml

Farei qualcosa di simile a questo:

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

Ciò restituirà il tuo cookie come un object.

E quindi puoi chiamarlo così:

 getCookie(document.cookie)['shares'] 

Mi piace usare una chiusura per ottenere i valori dei cookie per nome. La chiusura qui sotto ti permetterà di ottenere un valore del cookie per nome, ma analizzerà solo la stringa del cookie se è stata aggiornata.

È ansible recuperare il valore di un cookie con il seguente:

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

Codice:

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

Solo per aggiungere una risposta “ufficiale” a questa risposta, sto copiando / incollando la soluzione per impostare e recuperare i cookie da MDN (ecco il JSfiddle

  document.cookie = "test1=Hello"; document.cookie = "test2=World"; var cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)test2\s*\=\s*([^;]*).*$)|^.*$/, "$1"); function alertCookieValue() { alert(cookieValue); } 

Nel tuo caso particolare, useresti la seguente funzione

  function getCookieValue() { return document.cookie.replace(/(?:(?:^|.*;\s*)obligations\s*\=\s*([^;]*).*$)|^.*$/, "$1"); } 

Nota che ho sostituito “test2” solo dall’esempio, con “obbligazioni”.