Ottieni cookie per nome

Ho un vantaggio per ottenere il valore da un cookie.

Ora ho 2 cookie per nome shares=e nome obligations=.

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

Come faccio a fare questo? Quindi fordivide 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 l'iterazione su un array, sarebbe:

function getCookie(name) {
  const value = `; ${document.cookie}`;
  const 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) è la 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 un valore specifico del cookie, dobbiamo solo ottenere una stringa che sia dopo "; {name} =" e prima del prossimo ";". Prima di eseguire qualsiasi elaborazione, anteponiamo la stringa di cookie con ";", in modo che ogni nome di cookie, incluso il primo, sia racchiuso tra ";" e "=":

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

Ora, possiamo prima dividere per "; {name} =", e se il token viene trovato in una stringa di cookie (ovvero abbiamo due elementi), finiremo con il secondo elemento che è una stringa che inizia con il nostro valore di cookie. Quindi lo estraiamo da un array (cioè pop) e ripetiamo lo stesso processo, ma ora con ";" come token, ma questa volta estraendo la stringa sinistra (ovvero shift) per ottenere il valore del token effettivo.

Preferirei utilizzare una singola corrispondenza di espressione regolare sul cookie:

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

OPPURE Siamo in grado di utilizzare come funzione, controlla sotto il codice.

function check_cookie_name(name) 
    {
      var match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
      if (match) {
        console.log(match[2]);
      }
      else{
           console.log('--something went wrong---');
      }
   }

Migliorato grazie a Scott Jungwirth nei commenti.

utilizzare uno script per ottenere cookie:

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 cookie 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

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

Quindi puoi leggere i cookie in questo modo:

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 che viene cercato. Ad esempio, stai cercando il cookie denominato "uno" e esiste un cookie denominato "fatto".
3. Quando il nome del cookie include caratteri che non vengono interpretati come se stessi se utilizzati 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 tornerà nullse il cookie non viene trovato. Restituirà una stringa vuota se il valore del cookie è vuoto.

Appunti:

1. Questa funzione presuppone che i nomi dei cookie facciano distinzione tra maiuscole e minuscole .
2. document.cookie- Quando appare sul lato destro di un'assegnazione, rappresenta una stringa contenente un elenco di cookie separati da punto e virgola, che a loro volta sono name=valuecoppie. Sembra che ci sia un singolo spazio dopo ogni punto e virgola.
3. String.prototype.match()- Ritorna nullquando 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 modelli alternativi per il gruppo.
4. ;\\s* - corrisponde a un punto e virgola seguito da zero o più caratteri di spazi bianchi.
5. = - corrisponde a un segno 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 compreso, un punto e virgola o alla fine della stringa.

4 anni dopo, ES6 versione 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'essenza per usarla come Cookieoggetto. ad es. Cookie.set(name,value)eCookie.get(name)

Questo legge tutti i cookie invece di scansionarli. Va bene per un piccolo numero di cookie.

Ho modificato la funzione che Jonathan ha fornito qui, usando un'espressione regolare puoi ottenere un valore di cookie con il suo nome in questo modo:

function getCookie(name){
    var pattern = RegExp(name + "=.[^;]*")
    var 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 alcun valore, se restituisce falso il cookie non esiste. Spero che questo possa essere d'aiuto.

Ecco una riga per ottenere un cookie con un nome specifico senza la necessità di alcuna lib esterna:

var cookie = ("; "+document.cookie).split("; YOUR_COOKIE_NAME=").pop().split(";").shift();

Questa risposta si basa sulla brillante soluzione di Kirlich . L'unico compromesso di questa soluzione è che otterrai una stringa vuota quando il cookie non esiste. Nella maggior parte dei casi, tuttavia, questo non dovrebbe essere un problema.

So che è una vecchia domanda, ma ho riscontrato anche questo problema. Solo per la cronaca, c'è una piccola API nella pagina web degli sviluppatori mozilla .

Puoi ottenere qualsiasi cookie per nome usando solo JS. Il codice è anche più pulito IMHO (ad eccezione della linea lunga, che sono sicuro che puoi risolvere facilmente).

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

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

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

Includi nel tuo HTML:

<script src="https://cdn.jsdelivr.net/npm/js-cookie@2/src/js.cookie.min.js"></script>

Per creare un cookie:

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

Per leggere un cookie:

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

Ecco una versione piuttosto breve

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

Nota che ho usato le stringhe di template di ES6 per comporre l'espressione regex.

Uso object.defineProperty

Con questo, puoi accedere facilmente 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 semplicemente fare:

alert( Cookies.obligations );

Anche questo si aggiornerà automaticamente, quindi se cambi un cookie, Cookiescambierà anche.

Kirlich ha dato una buona soluzione. Tuttavia, non riesce 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();
}

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. Puro vecchio buono JavaScript.

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

Funzione semplice per ottenere 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] : "";
}

Apparentemente MDN non ha mai sentito parlare della classe di caratteri regex del limite di parole \b, che corrisponde a contigui \w+che è delimitato da 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');

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 il seguente:

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

Se hai solo bisogno di verificare l'esistenza di alcuni cookie, fai semplicemente questo:

document.cookie.split('logged=true').length == 2

se il cookie registrato = vero esiste, otterrai 2, se non 1.

logg = true: modificalo con il nome cookie = valore o solo con un nome

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

impostato da JavaScript

document.cookie = 'cookiename=tesing';

ottenere da jquery con il plugin jquery-cookie

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

alert(value);

riferimento: https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie

document.cookie = "test1=Hello";
document.cookie = "test2=World";

var cookieValue = document.cookie.replace(/(?:(?:^|.*;\s*)test2\s*\=\s*([^;]*).*$)|^.*$/, "$1");

  alert(cookieValue);

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 indefinito se il nome del cookie non esiste

L'ho fatto in questo modo. in modo che ottenga un oggetto a cui accedere per separare i valori. Con questo puoi passare il cookie al genitore e quindi puoi accedere ai tuoi 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;
        }  

Un approccio funzionale per trovare i cookie esistenti. Restituisce un array, quindi supporta più occorrenze con lo stesso nome. Non supporta la corrispondenza parziale delle chiavi, ma è banale sostituire il === nel filtro con una 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);
    });
}

Basta usare la seguente funzione (un codice javascript puro)

const getCookie = (name) => {
 const cookies = Object.assign({}, ...document.cookie.split('; ').map(cookie => {
    const name = cookie.split('=')[0];
    const value = cookie.split('=')[1];

    return {[name]: value};
  }));

  return cookies[name];
};

Ottieni cookie per nome basta passare il nome del cookie alla funzione di seguito

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

La seguente funzione restituirà una key-valuecoppia del cookie richiesto, dove si keytrova il nome del cookie e valuesarà 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