document.domain

  {"name": "aisensiy", "age": 24}

  callbackFunction({"name": "aisensiy", "age": 24});

document.domain = 'company.com';

Access-Control-Allow-Origin:*

Access-Control-Allow-Origin:https://example.com

var http = require('http');
http.createServer(function(req, res) {
	res.writeHead(200, {
        'ContentType': 'text/plain',
        'Access-Control-Allow-Origin': 'https://localhost:3000'});
	res.end('Hello node\n');
}).listen(8000);

console.log('Server running...');

var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function() {
  if (xhr.readState == 4) {
    if (xhr.status >= 200 && xhr.status < 300 || xhr.status == 304) {
      alert(xhr.responseText);
    } else {
      alert(xhr.status);
    }
  }
};

xhr.open('GET', 'https://localhost:8000/');

int ELFHash(char* str, int len) {
    unsigned int hash = 0;
    unsigned int    x = 0;
    int i = 0;

    for (i = 0; i < len; i++) {
        /* 这就相当于在构造一个 16 进制的大整数，每次加新的数字前进位 */
        hash = (hash << 4) + str[i];
        /* 但是一个整型最多就 32 位，如果再往左进位，高位就会丢失。那么，
           就要考虑把高位的数字与低位的做异或运算保存下来 */
        if ((x = hash & 0xf0000000L) != 0) {
            hash ^= x >> 24;
            /* 既然高位数字以及放在低位异或了，那么就可以把高位制空 */
            hash &= ~x;
        }
    }
    /* 最后为了返回给有符号整数，把最高位制零，如果你返回的是无符号数，
       那就忽略这行 */
    hash = hash & 0x7fffffffL;
    return hash;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define N 100
#define LEN 39

int ELFHash(char* str, int len) {
    unsigned int hash = 0;
    unsigned int    x = 0;
    int i = 0;

    for (i = 0; i < len; i++) {
        hash = (hash << 4) + str[i];
        if ((x = hash & 0xf0000000L) != 0) {
            hash ^= x >> 24;
            hash &= ~x;
        }
    }
    hash = hash & 0x7fffffffL;
    return hash;
}

/* 这是我们的核心数据结构，其实就是链表的节点 */
typedef struct node {
    char data[N];
    struct node *next;
} node;

/* 初始化一个节点，设置字符串为空，next 指针指向 NULL */
void node_init(node *point) {
    point->data[0] = '\0';
    point->next = NULL;
}

/* 创建一个新的节点并初始化 */
node *node_create() {
    node *point = (node*)malloc(sizeof(node));
    node_init(point);
    return point;
}

node* hash_find(char *str, node **root);
node** hash_create();
node* hash_add(char *str, node **root);
int hash_delete(char *str, node **root);

/* 创建一个新的 hash 数据结构，桶的个数为 LEN */
node** hash_create() {
    int i;
    node **root = (node**)malloc(LEN * sizeof(node*));
    for (i = 0; i < LEN; i++) {
        root[i] = NULL;
    }
    return root;
}

/* 添加一个新的元素 */
node* hash_add(char *str, node **root) {
    int hash, index;
    node *current, *tmp, *base, *prev;
    /* 首先检查这个元素是否已经存在了，如果存在就不必再次添加 */
    if (hash_find(str, root)) return;
    hash = ELFHash(str, strlen(str));
    index = hash % LEN;
    prev = current = root[index];
    /* 冲突总会有的，要把冲突的情况考虑在内 */
    while (current) {
        prev = current;
        current = current->next;
    }

    tmp = node_create();
    strcpy(tmp->data, str);

    if (!prev) {
        root[index] = tmp;
    } else {
        prev->next = tmp;
    }

    return tmp;
}

/* 在 hash 结构中找一个元素是否存在 */
node* hash_find(char *str, node **root) {
    int hash, index;
    node *current_node;

    hash = ELFHash(str, strlen(str));
    index = hash % LEN;
    current_node = root[index];

    while (current_node) {
        if (strcmp(current_node->data, str) == 0) {
            return current_node;
        }
    }

    return NULL;
}

/* 删除已有的元素 */
int hash_delete(char *str, node **root) {
    int hash, index;
    node *current_node, *prev, *tmp;

    hash = ELFHash(str, strlen(str));
    index = hash % LEN;
    current_node = prev = root[index];

    while (current_node) {
        if (strcmp(current_node->data, str) == 0) {
            if (current_node == root[index]) {
                free(current_node);
                root[index] = NULL;
            } else {
                prev->next = current_node->next;
                free(current_node);
            }
            return 1;
        }
        prev = current_node;
        current_node = current_node->next;
    }
    return 0;

}

/* 一点点测试 */
int main(int argc, const char *argv[]) {

    char *test1 = "test";
    char *test2 = "test2";
    node *result;
    int r;

    node **root = hash_create();
    hash_add(test1, root);
    result = hash_find(test2, root);
    assert(!result);
    result = hash_find(test1, root);
    assert(result);
    hash_add(test2, root);
    result = hash_find(test2, root);
    assert(result);

    hash_add(test1, root);
    r = hash_delete(test1, root);
    assert(r == 1);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define CHAR_BIT 8
#define WORD_SIZE 32
#define TRUE 1
#define FALSE 0
#define SETBIT(a, n) (a[n/CHAR_BIT] |= (1<<(n%CHAR_BIT)))
#define GETBIT(a, n) (a[n/CHAR_BIT] & (1<<(n%CHAR_BIT)))

typedef unsigned int (*hashfunc)(const char *);
typedef struct bloom {
    int char_size;
    char *container;
    int nearest_bit;
    int func_size;
    int *seeds; /* 注意，我这里给的不是一堆hash函数，而已hash函数里面的一个参数 */
} Bloom;

Bloom *bloom_create(int char_size, int func_size);
void *bloom_add(const char *str, Bloom* bloom);
int bloom_find(const char *str, Bloom* bloom);

/* 生成多个hash值的关键在于传递给这个函数的 k 值的区别。这个方法是算法导论里面的乘法
   生成 hash 的部分提到的，去那里看比较靠谱，我说不清楚啊 o_o */
unsigned int multi_hash(int a, int k, int r, int bit_size) {
    return ((unsigned int)(a * k) >> (WORD_SIZE - r)) % bit_size;
}

int nearest_bitsize(int size) {
    int i = 1, n = 2;
    while (size > n) {
        i++;
        n *= 2;
    }
    return i;
}

int ELFHash(const char* str) {
    unsigned int hash = 0;
    unsigned int    x = 0;
    int i = 0;
    int len = strlen(str);

    for (i = 0; i < len; i++) {
        hash = (hash << 4) + str[i]; if ((x = hash & 0xf0000000L) != 0) {
            hash ^= x >> 24;
            hash &= ~x;
        }
    }
    hash = hash & 0x7fffffffL;
    return hash;
}

/* >min < max */
int randint_in_range(int min, int max) {
    return rand() % (max - min + 1) + min + 1;
}

int *generate_hash_seed(int size, int min, int max) {
    int i, seed = time(NULL);
    int *seeds = (int*)malloc(size * sizeof(int));
    for (i = 0; i <size; i++) {
       srand(seed);
       seeds[i] = randint_in_range(min, max);
       seed = seeds[i];
    }
    return seeds;
}

int main(int argc, const char *argv[]) {
    Bloom *bloom = bloom_create(400, 8);
    bloom_add("aisensiy", bloom);
    printf("%d\n", bloom_find("aisensiy", bloom));
    printf("%d\n", bloom_find("aisensiy1", bloom));
    return 0;
}

Bloom *bloom_create(int char_size, int func_size) {
    int i, min, max, bit_size;

    Bloom *bloom = (Bloom*)malloc(sizeof(Bloom));
    bloom->char_size = char_size;
    bloom->container = (char*)malloc(sizeof(char) * char_size);

    /* set all char to 0 */
    for (i = 0; i < char_size; i++) {
        bloom->container[i] = 0;
    }

    bit_size = char_size * CHAR_BIT;
    bloom->nearest_bit = nearest_bitsize(bit_size);
    /* 这里的最大值与最小值也是与生成 hash 函数有关，建议去看算法导论 */
    max = 1<<(WORD_SIZE - 1);
    min = 1<<(WORD_SIZE - bloom->nearest_bit);

    bloom->func_size = func_size;
    bloom->seeds = generate_hash_seed(func_size, min, max);

    return bloom;
}

void *bloom_add(const char *str, Bloom* bloom) {
    int hash, i, position, bit_size;

    hash = ELFHash(str);
    bit_size = bloom->char_size * CHAR_BIT;

    /* 用这 N 个哈希函数生成哈希值 */
    for (i = 0; i < bloom->func_size; i++) {
        position = multi_hash(bloom->seeds[i], hash, bloom->nearest_bit, bit_size);
        printf("position: %d\n", position);
        SETBIT(bloom->container, position);
    }
    printf("position end\n");
}

int bloom_find(const char *str, Bloom* bloom) {
    int hash, i, position, bit_size;

    hash = ELFHash(str);
    bit_size = bloom->char_size * CHAR_BIT;

    /* 通过检查这 N 个哈希值来判断元素是否存在 */
    for (i = 0; i < bloom->func_size; i++) {
        position = multi_hash(bloom->seeds[i], hash, bloom->nearest_bit, bit_size);
        printf("position: %d\n", position);
        if (GETBIT(bloom->container, position) == FALSE) {
            return FALSE;
        }
    }
    printf("position end\n");

    return TRUE;
}