Если вам просто нужно проверить, существуют ли какие-либо куки, просто сделайте это:

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

если cookie logged = true существует, вы получите 2, если не 1.

logged = true - замените это на cookie имя = значение или просто имя

ссылка: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);

Ты можешь использоватьjs-cookie библиотека для получения и установки файлов cookie JavaScript.

Включить в ваш HTML:

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

Чтобы создать Cookie:

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

Чтобы прочитать Cookie:

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

Я бы предпочел использовать одно совпадение с регулярным выражением в куки:

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

Улучшено благодаря Скотту Юнгвирту в комментариях.

Очевидно, MDN никогда не слышал о классе символов регулярных выражений\b, что соответствует смежным\w+ который ограничен с обеих сторон\W+:

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

var obligations = getCookie('obligations');

Просто чтобы добавить "официальный" В ответ на этот ответ я копирую / вставляю решение для установки и извлечения файлов cookie изMDN (здесьJSfiddle

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

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

    function alertCookieValue() {
      alert(cookieValue);
    }

В конкретном случае вы бы использовали следующую функцию

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

Обратите внимание, что я заменил только "test2" из примера с «обязательствами».

устанавливается javascript

document.cookie = 'cookiename=tesing';

получить с помощью JQueryплагин jquery-cookie

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

alert(value);

Спустя 4 года ES6 значительно упростила версию.

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

Я также создалсуть использовать его какCookie объект. например.,Cookie.set(name,value) а такжеCookie.get(name)

Это читает все куки вместо сканирования. Это нормально для небольшого количества файлов cookie.

Я сделал это таким образом. так что я получаю объект для доступа к отдельным значениям. С этим вы можете передать cookie родительскому элементу, а затем вы можете получить доступ к своим значениям с помощью ключей, таких как

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

Простая функция для получения куки с именем куки:

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

Методы в некоторых других ответах, которые используют регулярное выражение, не охватывают все случаи, в частности:

1. When the cookie is the last cookie. In this case there will not be a semicolon after the cookie value.
2. When another cookie name ends with the name being looked up. For example, you are looking for the cookie named "one", and there is a cookie named "done".
3. When the cookie name includes characters that are not interpreted as themselves when used in a regular expression unless they are preceded by a backslash.

Следующий метод обрабатывает эти случаи:

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

Это вернетсяnull если печенье не найдено Он вернет пустую строку, если значение cookie пустое.

Заметки:

1. This function assumes cookie names are case sensitive.
2. document.cookie - When this appears on the right-hand side of an assignment, it represents a string containing a semicolon-separated list of cookies, which in turn are name=value pairs. There appears to be a single space after each semicolon.
3. String.prototype.match() - Returns null when no match is found. Returns an array when a match is found, and the element at index [1] is the value of the first matching group.

Примечания регулярного выражения:

1. (?:xxxx) - forms a non-matching group.
2. ^ - matches the start of the string.
3. | - separates alternative patterns for the group.
4. ;\\s* - matches one semi-colon followed by zero or more whitespace characters.
5. = - matches one equal sign.
6. (xxxx) - forms a matching group.
7. [^;]* - matches zero or more characters other than a semi-colon. This means it will match characters up to, but not including, a semi-colon or to the end of the string.

Функциональный подход к поиску существующих файлов cookie. Он возвращает массив, поэтому он поддерживает несколько вхождений с одним и тем же именем. Он не поддерживает частичное совпадение ключей, но тривиально заменить === в фильтре регулярным выражением.

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

Здесь уже есть хорошие ответы для получения куки, однако вот мое собственное решение:

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

использование: `

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

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

Вот довольно короткая версия

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

Обратите внимание, что я использовал строки шаблона ES6 для составления выражения регулярного выражения.

kirlich дал хорошее решение. Тем не менее, это не удается, когда есть два значения cookie с похожими именами, вот простое исправление для этой ситуации:

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

Мне нравится использовать замыкание для получения значений cookie по имени. Приведенное ниже закрытие позволит вам получить значение cookie по имени, но будет анализировать только строку cookie, если она была обновлена.

Вы можете получить значение cookie с помощью следующего:

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

Код:

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

Мое решение таково:

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

Эта функция использует функцию Underscorejs _.find. Возвращает неопределенное значение, если имя файла cookie не существует

Use object.defineProperty

С этим вы можете легко получить доступ к куки

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

Отныне вы можете просто сделать:

alert( Cookies.obligations );

Это также автоматически обновится, поэтому, если вы измените файл cookie,Cookies тоже изменится.

Я бы сделал что-то вроде этого:

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

Это вернет ваш cookie как объект.

И тогда вы можете назвать это так:

getCookie(document.cookie)['shares']

Пример файлов cookie:пример 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;
   }
}

Храните массивы и объекты с помощью json или xml

Следующая функция вернетkey-value пара необходимых файлов cookie, гдеkey это имя куки иvalue будет значение куки.

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

Я знаю, что это старый вопрос, но я тоже сталкивался с этой проблемой. Просто для записи, есть немного API в разработчикахвеб-страница Mozilla.

Yoy может получить любой файл cookie по имени, используя только JS. ИМХО код также чище (за исключением длинной строки, которую, я уверен, вы можете легко исправить).

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

Как указано в комментариях, имейте в виду, что этот метод предполагает, что ключ и значение были закодированы с использованием encodeURIComponent (). Удалить декодирование & amp; encodeURIComponent (), если ключ и значение файла cookie не были закодированы.

всегда хорошо работает

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

No requirements for jQuery or anything. Pure old good JavaScript.

Если вы используете jQuery, я рекомендую вам использовать этот плагин:

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

Таким образом, вы можете прочитать cookie следующим образом:

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

Также вы можете написать cookie:

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

Удалить куки:

$.removeCookie('obligations');

Я изменил функцию, которую Джонатан предоставил здесь, используя регулярное выражение, вы можете получить значение cookie по его имени, например так:

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

Если он возвращает пустую строку, это означает, что файл cookie существует, но не имеет значения, если он возвращает значение false, то файл cookie не существует. Надеюсь, это поможет.

Один подход, который избегает итерации по массиву, был бы:

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

Walkthrough

Разделение строки по токену приведет либо к массиву с одной строкой (с одинаковым значением), если токен отсутствует в строке, либо к массиву с двумя строками, если токен найден в строке.

Первый (левый) элемент - это строка того, что было до токена, а второй (справа) - это строка того, что было после токена.

(ПРИМЕЧАНИЕ: если строка начинается с токена, первый элемент является пустой строкой)

Учитывая, что куки хранятся следующим образом:

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

чтобы получить определенное значение cookie, нам просто нужно получить строку после & quot ;; {Имя} = & Quot; и перед следующим & quot ;; & quot ;. Прежде чем приступить к какой-либо обработке, мы добавляем строку cookie с & quot ;; & quot ;, чтобы каждое имя файла cookie, включая первое, заключалось в & quot ;; & Quot; и & quot; = & quot ;:

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

Теперь мы можем сначала разделить на & quot ;; {name} = & quot ;, и если токен найден в строке cookie (то есть у нас есть два элемента), мы получим второй элемент, представляющий собой строку, начинающуюся с нашего значения cookie. Затем мы извлекаем это из массива (то есть pop) и повторяем тот же процесс, но теперь с & quot ;; & quot; как токен, но на этот раз вытащив левую строку (т.е. сдвиг), чтобы получить фактическое значение токена.

В своих проектах я использую следующую функцию для доступа к куки по имени

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

Мне кажется, вы могли бы разделить пары ключ-значение cookie на массив и основывать свой поиск на этом:

var obligations = getCookieData("obligations");

Который запускает следующее:

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

Скрипки:http://jsfiddle.net/qFmPc/

Или, возможно, даже т, он следующий:

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