Cookie nach Namen abrufen

Ein Ansatz, der das Durchlaufen eines Arrays vermeidet, wäre: 

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

Komplettlösung

Durch Aufteilen eines Strings nach Token wird entweder ein Array mit einem String (derselbe Wert) erzeugt, falls Token nicht in einem String vorhanden ist, oder ein Array mit zwei Strings, falls Token in einem String gefunden wird. 

Das erste (linke) Element ist eine Zeichenfolge vor dem Token und das zweite (rechts) ist die Zeichenfolge des Token nach dem Token.

(HINWEIS: Falls 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 Sie nur die Zeichenfolge nach "; {name} =" und vor dem nächsten ";" abrufen. Bevor wir eine Verarbeitung durchführen, fügen wir den Cookie-String mit ";" voran, sodass jeder Cookie-Name, einschließlich des ersten, mit ";" und "=" eingeschlossen ist:

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

Jetzt können wir zuerst nach "; {name} =" aufteilen. Wenn ein Token in einer Cookie-Zeichenfolge gefunden wird (d. H. Wir haben zwei Elemente), endet das zweite Element mit einer Zeichenfolge, die mit unserem Cookie-Wert beginnt. Dann ziehen wir das aus einem Array (d. H. Pop) und wiederholen den gleichen Vorgang, aber jetzt mit ";" als Token, aber diesmal wird die linke Zeichenfolge herausgezogen (d. h. verschoben), um den tatsächlichen Tokenwert zu erhalten.

Ich würde es vorziehen, einen einzigen regulären Ausdruck für das Cookie zu verwenden:

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

Dank an Scott Jungwirth in den Kommentaren verbessert.

verwenden Sie ein Cookie, das ein Skript erhält:

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 nennen Sie es:

var value = readCookie('obligations');

ich habe den Code oben von der Quirksmode-Cookies-Seite gestohlen. du solltest es lesen .

Wenn Sie jQuery verwenden, empfehle ich Ihnen dieses 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">

So kannst du den Cookie so lesen:

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

Sie können auch Cookie 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 Keks der letzte Keks ist. In diesem Fall wird nach dem Cookie-Wert kein Semikolon eingefügt.
2. Wenn ein anderer Cookie-Name endet, wird der Name nachgeschlagen. Sie suchen beispielsweise nach dem Cookie "one" und es gibt ein Cookie mit dem Namen "done".
3. Wenn der Cookie-Name Zeichen enthält, die bei Verwendung in einem regulären Ausdruck nicht als sich selbst interpretiert werden, es sei denn, ihnen wird ein Backslash vorangestellt.

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 gibt null zurück, wenn 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 Cookie-Namen die Groß- und Kleinschreibung berücksichtigen .
2. document.cookie - Wenn dies auf der rechten Seite einer Zuweisung angezeigt wird, stellt es eine Zeichenfolge dar, die eine durch Semikolons getrennte Liste von Cookies enthält, die wiederum name=value-Paare sind. Nach jedem Semikolon scheint ein Leerzeichen zu sein.
3. String.prototype.match() - Gibt null zurück, wenn keine Übereinstimmung gefunden wird. Gibt ein Array zurück, wenn eine Übereinstimmung gefunden wird und das Element am Index [1] der Wert der ersten übereinstimmenden Gruppe ist.

Hinweise zu regulären Ausdrücken:

1. (?:xxxx) - bildet eine nicht übereinstimmende Gruppe.
2. ^ - stimmt mit dem Anfang der Zeichenfolge überein.
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 übereinstimmende Gruppe.
7. [^;]* - Entspricht keinem oder mehreren Zeichen außer einem Semikolon. Dies bedeutet, dass Zeichen mit einem Semikolon oder dem Ende der Zeichenfolge übereinstimmen, jedoch nicht darunter.

Ich habe die Funktion, die Jonathan hier bereitgestellt hat, geändert. Mit Hilfe des regulären Ausdrucks können Sie einen Cookie-Wert anhand seines Namens wie folgt erhalten:

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

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

4 Jahre später, ES6 wesentlich 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 ein Gist erstellt, um es als Cookie-Objekt zu verwenden. z. B. Cookie.set(name,value) und Cookie.get(name)

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

Ich weiß, es ist eine alte Frage, aber ich bin auch auf dieses Problem gestoßen. Nur zur Information: In der mozilla-Webseite gibt es eine kleine API.

Sie können jeden Cookie nur mit JS erhalten. Der Code ist auch sauberer IMHO (mit Ausnahme der langen Zeile, die Sie sicher beheben 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;
}

Beachten Sie, dass bei dieser Methode davon ausgegangen wird, dass Schlüssel und Wert mithilfe von encodeURIComponent () codiert wurden. Entfernen Sie decode & encodeURIComponent (), wenn der Schlüssel und der Wert des Cookies nicht codiert wurden. 

Verwenden Sie object.defineProperty

Damit können Sie leicht 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
        }, {});
    }
});

Ab jetzt können Sie einfach Folgendes tun:

alert( Cookies.obligations );

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

Einfache Funktion für Get cookie with cookie name:

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 gab eine gute Lösung. Wenn zwei Cookie-Werte mit ähnlichen Namen vorhanden sind, schlägt dies jedoch fehl.

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.

Hier ist eine ziemlich kurze Version

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

Beachten Sie, dass ich zum Erstellen des Regex-Ausdrucks die Vorlagen-Strings von ES6 verwendet habe.

In meinen Projekten verwende ich folgende Funktion, um auf Cookies anhand des Namens 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);
}

Es scheint mir, dass Sie die Cookie-Schlüssel-Wert-Paare in ein Array aufteilen und Ihre Suche darauf aufbauen könnten:

var obligations = getCookieData("obligations");

Was läuft wie folgt:

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 das Folgende:

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

Sie können js-cookie library verwenden, um JavaScript-Cookies abzurufen und festzulegen.

In HTML einfügen:

<script src="https://cdn.jsdelivr.net/npm/[email protected]/src/js.cookie.min.js"></script>

So erstellen Sie ein Cookie:

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

So lesen Sie ein Cookie:

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

durch Javascript eingestellt

document.cookie = 'cookiename=tesing';

jQuery mit dem Jquery-Cookie-Plugin

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

alert(value);

Es gibt bereits nette Antworten, um den Cookie zu erhalten. Hier ist 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

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

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

Meine Lösung ist folgende:

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

Diese Funktion verwendet die Underscorejs _.find-Funktion. Gibt undefined zurück, wenn der Name des Cookies nicht existiert

Ich habe es so gemacht. damit ich ein Objekt bekomme, um darauf zuzugreifen, um die Werte zu trennen. Damit können Sie den Cookie an das übergeordnete Element weitergeben und dann können Sie Ihre Werte über die Schlüssel wie 

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

Anscheinend hat MDN noch nie von der Word-Boundary-Regex-Zeichenklasse \b gehört, die mit zusammenhängendem \w+ übereinstimmt, das auf beiden Seiten mit \W+ begrenzt ist:

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

var obligations = getCookie('obligations');

Wenn Sie nur prüfen müssen, ob ein Cookie existiert, tun Sie dies einfach:

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

wenn Cookie = true existiert, erhalten Sie 2, falls nicht 1.

protocol = true - ändern Sie dies in Ihren Cookie-Namen = Wert oder nur einen Namen

Ein funktionaler Ansatz, um vorhandene Cookies zu finden. Es gibt ein Array zurück und unterstützt daher mehrere Vorkommen desselben Namens. Es unterstützt keine partiellen Schlüsselübereinstimmungen, aber es ist einfach, das === im Filter durch einen Regex 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);
    });
}

Die folgende Funktion gibt ein key-value-Paar des erforderlichen Cookies zurück, wobei key der Name des Cookies ist und value der Wert des Cookies ist.

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

Um eine "offizielle" Antwort auf diese Antwort hinzuzufügen, kopiere/füge ich die Lösung ein, um Cookies von MDN (hier ist die JSfiddle

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

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

    function alertCookieValue() {
      alert(cookieValue);
    }

In Ihrem speziellen Fall würden Sie die folgende Funktion verwenden

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

Beachten Sie, dass ich "test2" aus dem Beispiel nur durch "Verpflichtungen" ersetzt habe.

Ich benutze gerne einen Verschluss, um Cookie-Werte anhand des Namens zu erhalten. Mit dem folgenden Abschluss können Sie einen Cookie-Wert anhand des Namens abrufen, die Cookie-Zeichenfolge jedoch nur analysieren, wenn sie aktualisiert wurde.

Sie können den Wert eines Cookies mit folgendem Befehl abrufen: 

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

Ich würde so etwas machen:

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

Dadurch wird Ihr Cookie als Objekt zurückgegeben.

Und dann kannst du es so nennen:

getCookie(document.cookie)['shares']

jetzt können Sie Cookies als Array zurückgeben lassen, wenn Sie Cookies in einem Array-Format gespeichert haben. Ihr Cookie lautet beispielsweise array [35] = Khóa; Array [36] = Tử; Array [37] = Cửa; und dieser Code auch mit utf8. Eine Sache funktioniert nicht gut, wenn der Inhalt Ihres Cookie-Namens [] darin ist und Sie die Cookies nicht im Array speichern.

function getCookie(cname) {

            var ca = decodeURIComponent(document.cookie).split(';');


            if (cname.indexOf('[]') > 0) {
                var returnVAlue = [];
                var nameArray = cname.replace("[]", "");

                for(var i = 0; i < ca.length; i++) {
                    var c = ca[i];
                   // console.log(c);
                    while (c.charAt(0) == ' ') {
                        c = c.substring(1);
                    }

                    if (c.indexOf(nameArray) >= 0) {
                        var valueString = c.substr(nameArray.length, c.length);

                        var valueStringSlit = valueString.split('=');
                        valueStringSlit[0] = valueStringSlit[0].substr(1,(valueStringSlit[0].length - 2));
                    //    console.log(valueStringSlit);

                        returnVAlue.Push(valueStringSlit);
                    }
                }
            } else {
                var returnVAlue = '';
                var name = cname + "=";

                for(var i = 0; i < ca.length; i++) {
                    var c = ca[i];
                   // console.log(c);
                    while (c.charAt(0) == ' ') {
                        c = c.substring(1);
                    }
                    if (c.indexOf(name) == 0) {
                        returnVAlue = c.substr(name.length, c.length);
                    } 
                }
            }


            if (returnVAlue != ''){
                return returnVAlue;
            } 
            return "";
        }

       // console.log(decodeURIComponent(document.cookie));


        console.log(getCookie('array[]'));

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