Holen Sie sich Cookie mit Namen

Ich habe einen Getter, um den Wert eines Cookies zu ermitteln.

Jetzt habe ich 2 Cookies mit dem Namen shares=und mit dem Namen obligations=.

Ich möchte diesen Getter nur machen, um die Werte aus dem Verpflichtungs-Cookie zu erhalten.

Wie mache ich das? Das forteilt die Daten also in separate Werte auf und fügt sie in ein Array ein.

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

Ein Ansatz, der das Iterieren über ein Array vermeidet, wäre:

function getCookie(name) {
  const value = `; ${document.cookie}`;
  const parts = value.split(`; ${name}=`);
  if (parts.length === 2) return parts.pop().split(';').shift();
}

Exemplarische Vorgehensweise

Wenn Sie eine Zeichenfolge nach Token aufteilen, wird entweder ein Array mit einer Zeichenfolge (gleicher Wert) erstellt, falls in einer Zeichenfolge kein Token vorhanden ist, oder ein Array mit zwei Zeichenfolgen, falls Token in einer Zeichenfolge gefunden wird.

Das erste (linke) Element ist eine Zeichenfolge dessen, was vor dem Token war, und das zweite (rechts) ist eine Zeichenfolge dessen, was nach dem Token war.

(HINWEIS: Wenn die Zeichenfolge mit einem Token beginnt, ist das erste Element eine leere Zeichenfolge.)

In Anbetracht dessen, dass Cookies wie folgt gespeichert werden:

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

Um einen bestimmten Cookie-Wert abzurufen, müssen wir nur eine Zeichenfolge abrufen, die nach "; {name} =" und vor dem nächsten ";" steht. Bevor wir eine Verarbeitung durchführen, stellen wir der Cookie-Zeichenfolge ";" voran, sodass jeder Cookie-Name, einschließlich des ersten, mit ";" und "=" eingeschlossen wird:

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

Jetzt können wir zuerst durch "; {name} =" teilen. Wenn ein Token in einer Cookie-Zeichenfolge gefunden wird (dh wir haben zwei Elemente), wird das zweite Element eine Zeichenfolge sein, die mit unserem Cookie-Wert beginnt. Dann ziehen wir das aus einem Array (dh Pop) und wiederholen den gleichen Vorgang, aber jetzt mit ";" als Token, aber diesmal ziehen Sie die linke Zeichenfolge (dh Shift) heraus, um den tatsächlichen Token-Wert zu erhalten.

Ich würde es vorziehen, eine einzige Übereinstimmung mit regulären Ausdrücken für das Cookie zu verwenden:

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

ODER Auch können wir als Funktion verwenden, überprüfen Sie den folgenden Code.

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

Verbessert dank Scott Jungwirth in den Kommentaren.

Verwenden Sie ein Skript zum Abrufen von Cookies:

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

dann nenne es:

var value = readCookie('obligations');

Ich habe den obigen Code von der Quirksmode-Cookies-Seite gestohlen. du solltest es lesen .

Wenn Sie jQuery verwenden, empfehle ich Ihnen, dieses Plugin zu verwenden:

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

So können Sie Cookies wie folgt lesen:

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

Sie können auch Cookies schreiben:

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

Cookie löschen:

$.removeCookie('obligations');

Die Methoden in einigen anderen Antworten, die einen regulären Ausdruck verwenden, decken nicht alle Fälle ab, insbesondere:

1. Wenn der Cookie der letzte Cookie ist. In diesem Fall wird nach dem Cookie-Wert kein Semikolon angezeigt.
2. Wenn ein anderer Cookie-Name mit dem nachgeschlagenen Namen endet. Beispielsweise suchen Sie nach dem Cookie "Eins", und es gibt ein Cookie mit dem Namen "Fertig".
3. Wenn der Cookie-Name Zeichen enthält, die bei Verwendung in einem regulären Ausdruck nicht als sie selbst interpretiert werden, es sei denn, ihnen geht ein Backslash voraus.

Die folgende Methode behandelt diese Fälle:

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

Dies wird zurückgegeben, nullwenn das Cookie nicht gefunden wird. Es wird eine leere Zeichenfolge zurückgegeben, wenn der Wert des Cookies leer ist.

Anmerkungen:

1. Diese Funktion setzt voraus, dass bei Cookie-Namen zwischen Groß- und Kleinschreibung unterschieden wird .
2. document.cookie- Wenn dies auf der rechten Seite einer Zuweisung angezeigt wird, handelt es sich um eine Zeichenfolge, die eine durch Semikolons getrennte Liste von Cookies enthält, die wiederum name=valuePaare sind. Nach jedem Semikolon scheint ein einzelnes Leerzeichen zu stehen.
3. String.prototype.match()- Gibt zurück, nullwenn keine Übereinstimmung gefunden wurde. Gibt ein Array zurück, wenn eine Übereinstimmung gefunden wird, und das Element am Index [1]ist der Wert der ersten übereinstimmenden Gruppe.

Hinweise zu regulären Ausdrücken:

1. (?:xxxx) - bildet eine nicht übereinstimmende Gruppe.
2. ^ - entspricht dem Anfang der Zeichenfolge.
3. | - trennt alternative Muster für die Gruppe.
4. ;\\s* - Entspricht einem Semikolon, gefolgt von null oder mehr Leerzeichen.
5. = - entspricht einem Gleichheitszeichen.
6. (xxxx) - bildet eine passende Gruppe.
7. [^;]*- Entspricht null oder mehr Zeichen als einem Semikolon. Dies bedeutet, dass Zeichen bis zu einem Semikolon oder bis zum Ende der Zeichenfolge abgeglichen werden, diese jedoch nicht enthalten.

4 Jahre später, ES6 viel einfachere Version.

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

Ich habe auch einen Kern erstellt , um es als CookieObjekt zu verwenden. zB Cookie.set(name,value)undCookie.get(name)

Dadurch werden alle Cookies gelesen, anstatt sie zu durchsuchen. Es ist in Ordnung für eine kleine Anzahl von Cookies.

Ich habe die Funktion, die Jonathan hier bereitgestellt hat, geändert. Wenn Sie einen regulären Ausdruck verwenden, können Sie einen Cookie-Wert mit dem folgenden Namen erhalten:

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
}

Wenn eine leere Zeichenfolge zurückgegeben wird, bedeutet dies, dass das Cookie vorhanden ist, aber keinen Wert hat. Wenn es false zurückgibt, ist das Cookie nicht vorhanden. Ich hoffe das hilft.

Hier ist ein Einzeiler, um ein Cookie mit einem bestimmten Namen zu erhalten, ohne dass eine externe Bibliothek erforderlich ist:

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

Diese Antwort basiert auf Kirlichs brillanter Lösung . Der einzige Kompromiss dieser Lösung besteht darin, dass Sie eine leere Zeichenfolge erhalten, wenn das Cookie nicht vorhanden ist. In den meisten Fällen sollte dies jedoch kein Deal Breaker sein.

Ich weiß, dass es eine alte Frage ist, aber ich bin auch auf dieses Problem gestoßen. Nur zur Veranschaulichung: Es gibt eine kleine API auf der Entwickler- Mozilla-Webseite .

Yoy kann jedes Cookie mit Namen nur mit JS erhalten. Der Code ist meiner Meinung nach auch sauberer (mit Ausnahme der langen Schlange, die Sie sicher leicht reparieren können).

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

Wie in den Kommentaren angegeben, wird bei dieser Methode davon ausgegangen, dass der Schlüssel und der Wert mit encodeURIComponent () codiert wurden. Entfernen Sie decode & encodeURIComponent (), wenn der Schlüssel und der Wert des Cookies nicht codiert wurden.

Sie können die js-cookie- Bibliothek verwenden, um JavaScript-Cookies abzurufen und zu setzen.

In Ihren HTML-Code aufnehmen:

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

So erstellen Sie ein Cookie:

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

So lesen Sie ein Cookie:

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

Hier ist eine ziemlich kurze Version

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

Beachten Sie, dass ich die Vorlagenzeichenfolgen von ES6 verwendet habe, um den Regex-Ausdruck zu erstellen.

Verwenden object.defineProperty

Damit können Sie einfach auf Cookies zugreifen

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

Von nun an können Sie einfach Folgendes tun:

alert( Cookies.obligations );

Dies wird ebenfalls automatisch aktualisiert. Wenn Sie also ein Cookie ändern, Cookiesändert sich auch das.

kirlich gab eine gute lösung. Es schlägt jedoch fehl, wenn zwei Cookie-Werte mit ähnlichen Namen vorhanden sind. Hier ist eine einfache Lösung für diese Situation:

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

funktioniert immer gut:

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

Keine Anforderungen für jQuery oder irgendetwas. Reines altes gutes JavaScript.

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

Einfache Funktion zum Abrufen von Cookies mit Cookie-Namen:

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] : "";
}

Anscheinend hat MDN noch nie von der Wortgrenzen-Regex-Zeichenklasse gehört \b, die zusammenhängend \w+ist und auf beiden Seiten begrenzt ist mit \W+:

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

var obligations = getCookie('obligations');

Mir scheint, Sie könnten die Schlüssel-Wert-Paare für Cookies in ein Array aufteilen und Ihre Suche darauf aufbauen:

var obligations = getCookieData("obligations");

Welches läuft das folgende:

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

Geige: http://jsfiddle.net/qFmPc/

Oder vielleicht sogar folgendes:

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

In meinen Projekten verwende ich die folgende Funktion, um namentlich auf Cookies zuzugreifen

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

Wenn Sie nur überprüfen müssen, ob ein Cookie vorhanden ist, gehen Sie wie folgt vor:

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

Wenn Cookie protokolliert = true vorhanden ist, erhalten Sie 2, wenn nicht 1.

logged = true - Ändern Sie dies in Ihren Cookie-Namen = Wert oder nur einen Namen

Hier gibt es bereits nette Antworten, um den Cookie zu erhalten. Hier ist jedoch meine eigene Lösung:

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

Verwendung: `

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

durch Javascript gesetzt

document.cookie = 'cookiename=tesing';

Holen Sie sich durch JQuery mit dem JQuery-Cookie-Plugin

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

alert(value);

Referenz: 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);

Meine Lösung lautet:

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

Diese Funktion verwendet die Funktion Underscorejs _.find. Gibt undefiniert zurück, wenn der Cookie-Name nicht vorhanden ist

Ich habe es so gemacht. Damit bekomme ich ein Objekt, auf das ich zugreifen kann, um die Werte zu trennen. Damit kannst du das Cookie an das übergeordnete Element übergeben und dann kannst du über die Schlüssel wie auf deine Werte zugreifen

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

Ein funktionaler Ansatz, um vorhandene Cookies zu finden. Es gibt ein Array zurück, sodass mehrere Vorkommen mit demselben Namen unterstützt werden. Es wird keine teilweise Schlüsselübereinstimmung unterstützt, aber es ist trivial, das === im Filter durch einen regulären Ausdruck zu ersetzen.

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

Verwenden Sie einfach die folgende Funktion (ein reiner Javascript-Code)

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

Cookie nach Namen abrufen, geben Sie den Namen des Cookies einfach an die unten stehende Funktion weiter

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

Die folgende Funktion gibt ein key-valuePaar des erforderlichen Cookies zurück, wobei keyder Cookie-Name und valueder Wert des Cookies angegeben sind.

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

Beispiel für Cookies: Beispiel 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;
   }
}

Speichern Sie Arrays und Objekte mit json oder xml