Obtener cookie por nombre

Tengo un captador para obtener el valor de una cookie.

Ahora tengo 2 cookies por el nombre shares=y por el nombre obligations=.

Quiero hacer que este captador solo obtenga los valores de la cookie de obligaciones.

¿Cómo hago esto? Entonces, fordivide los datos en valores separados y los coloca en una matriz.

 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 enfoque, que evita iterar sobre una matriz, sería:

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

Tutorial

Dividir una cadena por un token producirá una matriz con una cadena (mismo valor), en caso de que el token no exista en una cadena, o una matriz con dos cadenas, en caso de que el token se encuentre en una cadena.

El primer elemento (izquierda) es la cadena de lo que estaba antes del token, y el segundo (derecha) es la cadena de lo que estaba después del token.

(NOTA: en caso de que la cadena comience con un token, el primer elemento es una cadena vacía)

Teniendo en cuenta que las cookies se almacenan de la siguiente manera:

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

para recuperar un valor de cookie específico, solo necesitamos obtener una cadena que esté después de "; {name} =" y antes del siguiente ";". Antes de realizar cualquier procesamiento, anteponemos la cadena de cookies con ";", de modo que cada nombre de cookie, incluido el primero, esté encerrado con ";" y "=":

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

Ahora, primero podemos dividir por "; {name} =", y si el token se encuentra en una cadena de cookies (es decir, tenemos dos elementos), terminaremos con el segundo elemento como una cadena que comienza con nuestro valor de cookie. Luego sacamos eso de una matriz (es decir, pop) y repetimos el mismo proceso, pero ahora con ";" como un token, pero esta vez tirando de la cadena izquierda (es decir, shift) para obtener el valor real del token.

Preferiría usar una sola coincidencia de expresión regular en la cookie:

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

O bien, también podemos usarlo como una función, verifique el código a continuación.

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

Mejorado gracias a Scott Jungwirth en los comentarios.

use un script de obtención de 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;
}

entonces llámalo:

var value = readCookie('obligations');

Robé el código anterior de la página de cookies quirksmode. deberías leerlo .

Si usa jQuery, le recomiendo que use este complemento:

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

Entonces puedes leer una cookie como esta:

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

También puedes escribir cookie:

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

Eliminar cookie:

$.removeCookie('obligations');

Los métodos en algunas de las otras respuestas que usan una expresión regular no cubren todos los casos, particularmente:

1. Cuando la cookie es la última cookie. En este caso, no habrá punto y coma después del valor de la cookie.
2. Cuando otro nombre de cookie termina con el nombre que se busca. Por ejemplo, está buscando la cookie llamada "one", y hay una cookie llamada "done".
3. Cuando el nombre de la cookie incluye caracteres que no se interpretan como ellos mismos cuando se usan en una expresión regular a menos que estén precedidos por una barra diagonal inversa.

El siguiente método maneja estos casos:

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

Esto regresará nullsi no se encuentra la cookie. Devolverá una cadena vacía si el valor de la cookie está vacío.

Notas:

1. Esta función asume que los nombres de cookies distinguen entre mayúsculas y minúsculas .
2. document.cookie- Cuando esto aparece en el lado derecho de una tarea, representa una cadena que contiene una lista de cookies separadas por punto y coma, que a su vez son name=valuepares. Parece que hay un solo espacio después de cada punto y coma.
3. String.prototype.match()- Regresa nullcuando no se encuentra ninguna coincidencia. Devuelve una matriz cuando se encuentra una coincidencia, y el elemento en el índice [1]es el valor del primer grupo coincidente.

Notas de expresiones regulares:

1. (?:xxxx) - forma un grupo no coincidente.
2. ^ - coincide con el inicio de la cadena.
3. | - separa patrones alternativos para el grupo.
4. ;\\s* - coincide con un punto y coma seguido de cero o más caracteres de espacio en blanco.
5. = - coincide con un signo igual.
6. (xxxx) - forma un grupo coincidente.
7. [^;]*- coincide con cero o más caracteres que no sean punto y coma. Esto significa que coincidirá con los caracteres hasta, pero sin incluir, un punto y coma o al final de la cadena.

4 años después, ES6 versión más simple.

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

También he creado una esencia para usarlo como un Cookieobjeto. por ejemplo, Cookie.set(name,value)yCookie.get(name)

Esto lee todas las cookies en lugar de escanear. Está bien para una pequeña cantidad de cookies.

He modificado la función que Jonathan proporcionó aquí, mediante el uso de expresiones regulares puede obtener un valor de cookie por su nombre como este:

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
}

Si devuelve una cadena vacía, significa que la cookie existe pero no tiene valor; si devuelve false, la cookie no existe. Espero que esto ayude.

Aquí hay una guía para obtener una cookie con un nombre específico sin la necesidad de ninguna lib externa:

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

Esta respuesta se basa en la brillante solución de kirlich . El único compromiso de esta solución es que obtendrá una cadena vacía cuando la cookie no exista. Sin embargo, en la mayoría de los casos esto no debería ser un factor decisivo.

Sé que es una vieja pregunta, pero también me encontré con este problema. Solo para que conste, hay una pequeña API en la página web de desarrolladores de Mozilla .

Yoy puede obtener cualquier cookie por nombre usando solo JS. El código también es más limpio en mi humilde opinión (excepto por la larga línea, que estoy seguro de que puede solucionar fácilmente).

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

Como se indicó en los comentarios, tenga en cuenta que este método supone que la clave y el valor se codificaron usando encodeURIComponent (). Elimine decode & encodeURIComponent () si la clave y el valor de la cookie no estaban codificados.

Puede usar la biblioteca js-cookie para obtener y configurar cookies de JavaScript.

Incluir en tu HTML:

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

Para crear una cookie:

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

Para leer una cookie:

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

Aquí hay una versión bastante corta

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

Tenga en cuenta que hice uso de las cadenas de plantilla de ES6 para componer la expresión regex.

Utilizar object.defineProperty

Con esto, puede acceder fácilmente a las cookies.

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

A partir de ahora solo puedes hacer:

alert( Cookies.obligations );

Esto también se actualizará automáticamente, por lo que si cambia una cookie, Cookiestambién cambiará.

Kirlich dio una buena solución. Sin embargo, falla cuando hay dos valores de cookies con nombres similares, aquí hay una solución simple para esta situación:

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

siempre funciona bien:

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 hay requisitos para jQuery ni nada. Puro viejo buen JavaScript.

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

Función simple para Obtener cookie con nombre de 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] : "";
}

Aparentemente, MDN nunca ha oído hablar de la clase de caracteres regex de límite de palabra \b, que coincide con contigua \w+que está delimitada a ambos lados con \W+:

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

var obligations = getCookie('obligations');

Me parece que podría dividir los pares clave-valor de cookies en una matriz y basar su búsqueda en eso:

var obligations = getCookieData("obligations");

Que ejecuta lo siguiente:

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

Violín: http://jsfiddle.net/qFmPc/

O posiblemente incluso lo siguiente:

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

En mis proyectos utilizo la siguiente función para acceder a las cookies por nombre

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

Si solo necesita verificar si existe alguna cookie, simplemente haga esto:

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

si la cookie registrada = true existe, obtendrá 2, si no 1.

registrado = verdadero: cámbielo a usted nombre de cookie = valor, o simplemente un nombre

Ya hay buenas respuestas aquí para obtener la cookie. Sin embargo, esta es mi propia solución:

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

uso: `

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

establecido por javascript

document.cookie = 'cookiename=tesing';

pasa por jquery con el complemento jquery-cookie

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

alert(value);

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

Mi solución es esta:

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

Esta función utiliza la función Underscorejs _.find. Devuelve indefinido si el nombre de la cookie no existe

Lo he hecho de esta manera. para que pueda acceder a un objeto para separar los valores. Con esto, puede pasar la cookie al padre y luego puede acceder a sus valores mediante las teclas como

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 enfoque funcional para encontrar cookies existentes. Devuelve una matriz, por lo que admite múltiples ocurrencias del mismo nombre. No admite la coincidencia parcial de teclas, pero es trivial reemplazar el === en el filtro con una expresión regular.

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

Simplemente use la siguiente función (un código 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];
};

Obtenga la cookie por nombre, simplemente pase el nombre de la cookie a la siguiente función

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 siguiente función devolverá un key-valuepar de la cookie requerida, donde keyestá el nombre de la cookie y valueserá el valor de la 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;
};

Ejemplo de cookies: ejemplo 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;
   }
}

Almacene matrices y objetos con json o xml