ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದಿನಾಂಕವನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸುವುದು. ಈಗ ಕುಕೀ ಕಾರ್ಯದಲ್ಲಿ ವಿವರಿಸಲಾಗಿಲ್ಲ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದಿನಾಂಕವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು. ಕುಕೀ ರಚನೆಯಲ್ಲಿ ಈಗ ಸಂಚಿಕೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಕುಕೀಗಳಂತಹ ಡೈನಾಮಿಕ್ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ. ದಿ ದಿನಾಂಕ.ಈಗ() ಕುಕೀ ರಚನೆಯಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ವಿಶಿಷ್ಟವಾದ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಒದಗಿಸುವ, ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪಡೆಯಲು ವಿಧಾನವನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನವನ್ನು ಬಳಸುವಾಗ ಡೆವಲಪರ್‌ಗಳು ಅನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ಎದುರಿಸುವ ಸಂದರ್ಭಗಳಿವೆ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಡೆವಲಪರ್ ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ ದಿನಾಂಕ.ಈಗ() ಒಂದು ಕಾರ್ಯದೊಳಗೆ ತಪ್ಪಾಗಿ, ವಿವರಿಸಲಾಗದ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಇದು ಕಾರ್ಯವು ವಿಫಲಗೊಳ್ಳಲು ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಡೈನಾಮಿಕ್ ಹೆಸರುಗಳೊಂದಿಗೆ ಕುಕೀಗಳನ್ನು ರಚಿಸುವಾಗ. ಅಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ಪರಿಹರಿಸಲು ಮುಖ್ಯ ಸಮಸ್ಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.

ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಡೈನಾಮಿಕ್ ಹೆಸರಿನೊಂದಿಗೆ ಕುಕೀಯನ್ನು ರಚಿಸುವುದು ಇಲ್ಲಿ ಪ್ರಾಥಮಿಕ ಗುರಿಯಾಗಿದೆ. ಹಾಗೆ ಮಾಡುವ ಮೂಲಕ, ಪ್ರತಿ ಕುಕೀಯನ್ನು ಅನನ್ಯವಾಗಿ ಗುರುತಿಸಲಾಗುತ್ತದೆ, ಉತ್ತಮ ಡೇಟಾ ಟ್ರ್ಯಾಕಿಂಗ್ ಮತ್ತು ಸೆಶನ್ ನಿರ್ವಹಣೆಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಆದರೂ ಸಮರ್ಪಕವಾಗಿ ಅನುಷ್ಠಾನಗೊಳಿಸಿಲ್ಲ ದಿನಾಂಕ.ಈಗ(), ಈ ವಿಧಾನವು ಮುರಿಯಬಹುದು.

ಕೆಳಗಿನ ವಿಭಾಗಗಳಲ್ಲಿ, ಏಕೆ ಎಂದು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ ದಿನಾಂಕ.ಈಗ() ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ ವಿಧಾನವು ವಿವರಿಸದೆ ಹಿಂತಿರುಗಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಿಮ್ಮ ಕುಕೀ ರಚನೆ ಕಾರ್ಯವು ಮನಬಂದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಸರಳ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತೇವೆ.

Date.now ನೊಂದಿಗೆ JavaScript ಕುಕೀ ರಚನೆಯನ್ನು ಎಕ್ಸ್‌ಪ್ಲೋರ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಮೇಲಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆಗಳು ಬಳಕೆಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತವೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ದಿನಾಂಕ.ಈಗ() ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಅನನ್ಯ ಹೆಸರುಗಳೊಂದಿಗೆ ಕುಕೀಗಳನ್ನು ರಚಿಸಲು ಕಾರ್ಯ. ಮೊದಲ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪ್ರಸ್ತುತ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಹೆಸರಿನೊಂದಿಗೆ ಕುಕೀಯನ್ನು ರಚಿಸಲು ಫ್ರಂಟ್-ಎಂಡ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಇದನ್ನು ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ ದಿನಾಂಕ.ಈಗ() ವಿಧಾನ, ಇದು ಜನವರಿ 1, 1970 ರಿಂದ ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಪ್ರತಿ ಕುಕೀಗೆ ವಿಶಿಷ್ಟವಾದ ಹೆಸರು ಇದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಿಶ್ವಾಸಾರ್ಹ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಕುಕೀ ಹೆಸರಿನ ಘರ್ಷಣೆಯನ್ನು ತಪ್ಪಿಸಲು ಈ ವಿಧಾನವು ನಿರ್ಣಾಯಕವಾಗಿದೆ, ಇದು ಅಧಿವೇಶನದಲ್ಲಿ ಬಹು ಕುಕೀಗಳನ್ನು ರಚಿಸಿದಾಗ ಸಂಭವಿಸಬಹುದು.

Date.now() ಅನ್ನು ಬಳಸುವುದರ ಜೊತೆಗೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಹ ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ document.cookie ಕ್ಲೈಂಟ್ ಬದಿಯಲ್ಲಿ ಕುಕೀಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಆದೇಶ. ಬ್ರೌಸರ್ ಕುಕೀಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಈ ಆಜ್ಞೆಯು ಪ್ರಮುಖವಾಗಿದೆ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕುಕೀಗಳ ಹೆಸರು, ಮೌಲ್ಯ ಮತ್ತು ಮುಕ್ತಾಯವನ್ನು ಹೊಂದಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕುಕೀಯನ್ನು 360 ಸೆಕೆಂಡುಗಳ ನಂತರ ಮುಕ್ತಾಯಗೊಳಿಸಲು ಹೊಂದಿಸಲಾಗಿದೆ, ಇದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ ಗರಿಷ್ಠ ವಯಸ್ಸು ಕುಕೀ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ. ಸೆಷನ್ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಸರ್ವರ್ ಸಂವಹನವಿಲ್ಲದೆ ಸರಿಯಾದ ಕುಕೀ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಕ್ಲೈಂಟ್-ಸೈಡ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಈ ಉದಾಹರಣೆಯು ವಿವರಿಸುತ್ತದೆ.

ಹಿಂಭಾಗದ ಭಾಗದಲ್ಲಿ, ಇದೇ ವಿಧಾನವನ್ನು ಬಳಸಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ Node.js ಮತ್ತು ಸರ್ವರ್‌ನಲ್ಲಿ ಕುಕೀಗಳನ್ನು ನಿರ್ವಹಿಸಲು Express.js. ದಿ res.cookie() ಕಾರ್ಯವು ಇಲ್ಲಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಕ್ಲೈಂಟ್‌ಗೆ ಸೆಟ್-ಕುಕಿ ಹೆಡರ್ ಅನ್ನು ಕಳುಹಿಸಲು ಸರ್ವರ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ, ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕುಕೀಯನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಸರ್ವರ್-ಸೈಡ್ ಸೆಶನ್ ನಿರ್ವಹಣೆಗೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಕುಕೀಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಒಳಬರುವ ವಿನಂತಿಗಳ ಆಧಾರದ ಮೇಲೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಕುಕೀ ಹೆಸರಿನಲ್ಲಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಸೇರಿಸಲು Date.now() ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, ಪ್ರತಿ ಸೆಶನ್ ಅನ್ನು ಅನನ್ಯವಾಗಿ ಗುರುತಿಸಲಾಗಿದೆ ಎಂದು ಸರ್ವರ್ ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಈ ಅಳವಡಿಕೆಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು, ಘಟಕ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸಿ ರಚಿಸಲಾಗಿದೆ ಮೋಚಾ ಮತ್ತು ಚೈ ಮುಂಭಾಗದ ತುದಿಗೆ, ಮತ್ತು ಸೂಪರ್ ಟೆಸ್ಟ್ ಹಿಂಬದಿಯ ಕೊನೆಯಲ್ಲಿ. ಈ ಪರೀಕ್ಷೆಗಳು ಕುಕೀಗಳನ್ನು ಸರಿಯಾಗಿ ರಚಿಸಲಾಗಿದೆಯೇ ಮತ್ತು ಸಂಗ್ರಹಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳು ಕುಕೀ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿಸಲು ಸಮರ್ಥನೆಗಳನ್ನು ಬಳಸುತ್ತವೆ ಮತ್ತು ಸಮಯಸ್ಟ್ಯಾಂಪ್‌ಗಳೊಂದಿಗೆ ಅವುಗಳ ಸರಿಯಾದ ರಚನೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತವೆ. ಪರಿಹಾರವು ದೃಢವಾಗಿದೆ ಮತ್ತು ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ವಿಶ್ವಾಸದಿಂದ ನಿಯೋಜಿಸಬಹುದು ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಮೊದಲೇ ಹಿಡಿಯಬಹುದು, ವಿವಿಧ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಕುಕೀಗಳು ನಿರೀಕ್ಷಿಸಿದಂತೆ ವರ್ತಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

// Frontend solution using JavaScript and Date.now to create cookies correctly
// Problem: timestamp.now is undefined because Date() doesn’t have a 'now' property
// Solution: Use Date.now() for correct timestamp and dynamic cookie creation

// Function to save the data in a cookie with a timestamp
function save(saveData) {
    // Get the current timestamp in milliseconds
    let timestamp = Date.now();
    // Construct the cookie name dynamically
    let cookieName = "test" + timestamp;
    // Set the cookie (you can use your own cookie library or direct JavaScript)
    document.cookie = cookieName + "=" + saveData + "; max-age=360; path=/";
}

// Example usage: save("session data") will create a cookie like 'test123456789=session data'
save("session data");

// Note: Ensure the max-age and path match your needs. 'max-age=360' sets the cookie to last 360 seconds.

// Backend solution for dynamic cookie creation using Node.js and Express.js
// Requires Node.js and the Express framework to handle HTTP requests and responses

// Import necessary modules
const express = require('express');
const app = express();
const port = 3000;

// Middleware to parse JSON and URL-encoded data
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Route to create a dynamic cookie with a timestamp
app.post('/set-cookie', (req, res) => {
    const saveData = req.body.saveData || "defaultData";
    const timestamp = Date.now();
    const cookieName = "test" + timestamp;
    // Set the cookie with HTTP response
    res.cookie(cookieName, saveData, { maxAge: 360000, httpOnly: true });
    res.send(`Cookie ${cookieName} set successfully`);
});

// Start the server
app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
});

// You can test this by sending a POST request to '/set-cookie' with 'saveData' in the body

// Unit test to validate the functionality of save() using Mocha and Chai
const assert = require('chai').assert;

describe('save function', () => {
    it('should create a cookie with a valid timestamp', () => {
        // Mock document.cookie
        global.document = { cookie: '' };
        save('testData');
        assert.match(document.cookie, /test\d+=testData/);
    });
});

// Unit test to validate dynamic cookie creation in Express.js
const request = require('supertest');
const express = require('express');
const app = require('./app'); // Assuming the above app is saved in app.js

describe('POST /set-cookie', () => {
    it('should set a cookie with a timestamp', (done) => {
        request(app)
            .post('/set-cookie')
            .send({ saveData: 'testData' })
            .expect('set-cookie', /test\d+=testData/)
            .expect(200, done);
    });
});

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕುಕೀ ನಿರ್ವಹಣೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲಾಗುತ್ತಿದೆ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕುಕೀ ನಿರ್ವಹಣೆಯ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಕುಕೀಗಳು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಸುರಕ್ಷಿತ ಮತ್ತು ಗೌಪ್ಯತೆ ನಿಯಮಗಳಿಗೆ ಅನುಗುಣವಾಗಿರುತ್ತದೆ. ಕುಕೀಗಳನ್ನು ರಚಿಸುವಾಗ, ವಿಶೇಷವಾಗಿ ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ಹೊಂದಿರುವಂತಹವುಗಳು, ಭದ್ರತಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಅನ್ವಯಿಸುವುದು ಅತ್ಯಗತ್ಯ Http ಮಾತ್ರ ಮತ್ತು ಸುರಕ್ಷಿತ. HttpOnly ಗುಣಲಕ್ಷಣವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಕ ಕುಕೀಯನ್ನು ಪ್ರವೇಶಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ XSS (ಕ್ರಾಸ್-ಸೈಟ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್) ದಾಳಿಗಳು. ಅಂತೆಯೇ, ಸುರಕ್ಷಿತ ಗುಣಲಕ್ಷಣವು ಕುಕೀಯನ್ನು HTTPS ಸಂಪರ್ಕಗಳ ಮೂಲಕ ಮಾತ್ರ ಕಳುಹಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ಅಸುರಕ್ಷಿತ ನೆಟ್‌ವರ್ಕ್‌ಗಳ ಮೂಲಕ ರವಾನೆಯಾಗದಂತೆ ರಕ್ಷಿಸುತ್ತದೆ.

ಭದ್ರತೆಯನ್ನು ಮೀರಿ, ಕುಕೀಗಳಿಗೆ ಸರಿಯಾದ ಮುಕ್ತಾಯ ಸಮಯವನ್ನು ಹೊಂದಿಸುವುದು ಅಧಿವೇಶನದ ನಿರಂತರತೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಮುಖ್ಯವಾಗಿದೆ. ಮುಂತಾದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ಗರಿಷ್ಠ ವಯಸ್ಸು ಅಥವಾ ಅವಧಿ ಮುಗಿಯುತ್ತದೆ, ಕುಕೀ ಎಷ್ಟು ಕಾಲ ಮಾನ್ಯವಾಗಿ ಉಳಿಯುತ್ತದೆ ಎಂಬುದನ್ನು ಡೆವಲಪರ್‌ಗಳು ನಿಯಂತ್ರಿಸಬಹುದು. ಅಲ್ಪಾವಧಿಯ ಅವಧಿಗಳಿಗಾಗಿ, ಗರಿಷ್ಠ-ವಯಸ್ಸನ್ನು ಬಳಸುವುದು ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಕುಕೀಯನ್ನು ರಚಿಸಿದಾಗಿನಿಂದ ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಅವಧಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, ಅವಧಿ ಮುಗಿಯುವ ಗುಣಲಕ್ಷಣವು ಕುಕೀಯ ಮುಕ್ತಾಯಕ್ಕೆ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಅಧಿವೇಶನದ ಅವಧಿಯ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ.

ಆಧುನಿಕ ವೆಬ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ವಿವಿಧ ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ ಕುಕೀಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ವಿಭಿನ್ನ ಕುಕೀ ನೀತಿಗಳಿಂದಾಗಿ ಸವಾಲಾಗಬಹುದು. ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಮುಖ್ಯ ಅದೇ ಸೈಟ್ ಗುಣಲಕ್ಷಣ, ಇದು ಕ್ರಾಸ್-ಸೈಟ್ ವಿನಂತಿಗಳೊಂದಿಗೆ ಕುಕೀಗಳನ್ನು ಕಳುಹಿಸಲಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಇದು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಸಿ.ಎಸ್.ಆರ್.ಎಫ್ ಬಾಹ್ಯ ಸೈಟ್ ವಿನಂತಿಗಳಿಗೆ ಕುಕೀಗಳನ್ನು ಲಗತ್ತಿಸಿದಾಗ ಸೀಮಿತಗೊಳಿಸುವ ಮೂಲಕ (ಕ್ರಾಸ್-ಸೈಟ್ ವಿನಂತಿ ಫೋರ್ಜರಿ) ದಾಳಿಗಳು. SameSite ಅನ್ನು ಕಟ್ಟುನಿಟ್ಟಾದ ಅಥವಾ Lax ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಅನಧಿಕೃತ ಸೈಟ್‌ಗಳನ್ನು ಬಳಕೆದಾರರ ಕುಕೀಗಳನ್ನು ಬಳಸದಂತೆ ತಡೆಯಬಹುದು, ಒಟ್ಟಾರೆ ಸುರಕ್ಷತೆ ಮತ್ತು ಗೌಪ್ಯತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.