接触javascript应该有三个月了，但是一直没有认真去学习这门语言的一些特性，现在结合C++的语言特性来分析一下，对自己脑海中的知识做个总结。

1、C++是静态语言，js是动态语言。区别如下：

静态语言：

1.在不执行的时候也能够做类型检测，可以一定程度上的检测出一些逻辑错误。但是过多的声明使得程序变得冗余。

2.编写代码开始的时候就要考虑变量和算式应该是什么类型，有利于编写好的、高可用性的程序。

3.对编译器提示有作用，同时也对理解代码有作用。

问题：灵活性不够，不定义类型无法写程序。

动态语言：

1.最大优点是代码简洁。

2.十分灵活。

问题：运行速度相对会慢一些，要做类型检查。最大缺点是不执行就无法检测出错误。

2、C++是编译型语言，js是解释型语言。

C++的编译过程：预处理->编译优化->汇编->链接。

Js的解析机制：预处理（分段读取代码预处理）->解释执行

3、C++有指针，js无指针。

在C++中的赋值，所有的基本类型都是直接复制，而自定义类型因为有指针的存在，可以自己选择进行深复制（复制）还是浅复制（引用）。而在js中，所有的基本类型赋值都是复制，而所有的其他类型赋值都是引用。

4、js是函数式编程语言，C++不是。

Js把函数当作对象来处理，可以将它当作函数的输入参数和输出值（高阶函数）。

C++如果要把函数当作其他函数的输入参数，即实现高阶函数，必须要通过函数指针（经常还要多传递一个（void *）类型的参数作为参数的函数的参数）。

5、C++的继承是基于类的，js的继承基于原型

在C++中，继承是通过类来进行的。比较符合人的直观思维。同时在生成一个类之后，是不能够对它进行修改了，除非再去修改它的定义。（Ruby基于开放类的继承可以在定义之后任意追加类的内容）

在js中，继承则是通过原型链的方式来进行的。同样也可以在定义之后修改原型链。同时，也可以修改内置类型的原型链来扩展内置类型（慎用，monkey patching可能导致内置对象大幅度修改产生难以预期的行为）。

（JS特性）

6、js的一个重要特性是闭包（当前作用域可以访问并保存外部作用域的变量）。

Js的闭包在函数返回之后，还能够保持闭包引用到的变量不释放。其最大的用途有两个：一是可以函数返回闭包，让外面可以读取访问到函数内的值，二是让这些变量的值一直保存在内存之中不释放。

有闭包很容易实现内部迭代器（each方法），而C++没有闭包，共有循环外部信息比较麻烦，采取的是外部迭代器方法（vector<int>::iterator）。

注意事项：

1.        如果滥用闭包容易消耗大量内存，同时在IE中会有内存泄漏问题，所以在退出函数之前将不使用的局部变量全部删除。

2.        闭包也会在外部改变父函数内部的值，因此用闭包当共有方法的时候要注意不要随便改变内部的值。

7、js可以显示的设置上下文。

Js可以通过applay和call方法显示指定函数内的this。applay参数传递用数组，call参数分开传。

（未完待续） 

上述浅薄个人看法，如果有错误希望大家能够指正。

  最近在做nodejs的web开发，初次接触到mongoDB这个数据库。
  其实之前对关系型数据库的接触也不是很多，不过在刚接触使用mongoDB的时候还是习惯性的把关系型数据库的设计思维带了进去。在设计数据库的时候，还是把一些关系型数据库设计的思维带进去了，没有发挥出mongoDB文档型数据库的优势。mongoDB可以方便的把一些本来mySQL需要通过一对多关系关联的数据通过数组+对象的方式作为一个文档存储到一个collections里面，并且提供了各种API支持对一个文档里面的数组进行操作。    此次实践选用的node中间件是mongoskin，不过惭愧的是基本没有用到mongoskin的太多特性，基本当作node-mongodb-native来使用。不过写完之后，对于mongoDB的查询API以及node同mongoDB的交互有了一定的了解。
  
  MongoDB常用查询方法与在node中的体现：  
1）数据库连接 
mongoDB： mongo -u username -p password host:port/dbs 
node+mongoSkin: require(“mongoskin”).db(username:password@host:port/dbs);  
 
2)索引 person.ensureIndex({“name”:1},{“unique”:true}, callback);
第一个参数是selector，第二个参数是选项，有unique（唯一索引）等mongoDB索引选项。
ensureIndex先查找是否存在这个索引，如果不存在，则建立索引，因此不会出现重复建立的情况。

3）新建数据
person.save({“name”:”jobs”, age:32, gender:”male”}, callback);
person.save({“name”：”tim”, age:29, gender:”male”}, callback);

4）查询 
findOne方法：查询符合selector条件的结果，取第一条给callBack，err是错误信息，如果没有错误，则为undefined，data数据为一个js对象。 
person.findOne({“name“:”jobs”}), callBack(err, data));  

find方法：查询符合selector条件，并且还可以加入一系列参数，最后通过toArray方法，把数据生成数组的方式传递给callback。 
person.find({“gender”:”male”},{sort:[['name', 1]],skip:pageNum*(page-1), limit:pageNum}).toArray(callback(err, data){}) 
同时查询的时候可以通过$in,$gt,$lt等方式来确定selector的范围。  

5）更改 
有两点要注意：
1.update方法如果是要更新文档中的一个或几个属性的时候，必须要用形如{$set:{age:33}}的形式，如果写成{age:33}的形式，则这个文档的其他内容都会被删除，只剩{age:32}这一个属性。 
2.update方法默认是只更新找到的第一个文档，如果需要所有的文档都更新，则需要在option部分再加上{multi:true},如果想要在查找不到这条记录的时候新增一条，则要在option部分加上{upsert:true}。 
person.update({“name”:”jobs”}, {$set{“age”:33}}, {multi:true}, callback(err))  

6)删除 person.remove({“name”:”jobs”},callback(err){});  

7）selector中使用mongoDB自动生成的_id 
mongoDB会为每一个文档生成一个_id属性，类似于mySQL的主键，是唯一的。_id的类型是mongoDB自己定义的objectID类型，因此尽管在查询的时候可以得到一个12位或者24位的_id字符串，但是如果想在selector里面通过_id进行查找或其他操作的时候，必须要先通过db.collection.id()方法进行类型转换。 
person.remove({“_id”:person.id(stringID)}, callback(err){});  

8）mongoDB对文档内的数组进行操作（通过update方法） 
1.通过$addToSet方法向数组中插入记录，插入前该方法会先查找是否存在这条记录，如果存在则不插入。如果想要插入重复的值，则可以通过$push进行添加。 
person.update({“name”:”jobs”}, {$addToSet: {
company: {
name: “google”,
address: USA,
workingTime: 3
}
}, function(err){});

2.修改数组中的数据：通过$符。如果在数组中查询的时候要匹配两个属性，必须要使用$elemMatch方法，如果只通过{"name":”google”, "address":USA}去查找，会选择到所有name为google或者address为USA的元素。在定位到这个元素之后，通过$来选定它进行修改。

person.update({

“name”:”jobs”,

company:{$elemMatch:{"name":”google”, "address":USA}}

}, {$set:{"company.$.workingTime":4}},function(){})

3.删除数组中的数据：通过$pull方法

person.update({

“name”:”jobs”,

},{$pull:{company:{“name”:”google”, “address”:”USA”}}},function(err){})

一、编译过程： 
1）预处理，生成.i文件 
2）转换成为汇编语言，生成.s文件 
3）汇编变为目标代码（机器代码），生成.o文件 
4）链接目标代码，生成可执行程序。  

二、常用编译选项 
tips：选项必须独立给出：‘-pg’和‘-p -g’完全不同  

-c：编译或汇编源文件，不做连接。 
G++ -c test.cpp输出test.o  

-o file：制定输出文件为file  

-Wall： 输出所有编译警告（最好加上）  

-Dmacro=XXX：定义宏。  

-shared：生成一个共享库文件 
g++ -shared -o libtest.so test.o  

-fPIC：生成位置无关目标代码，适用于动态连接。  

-llibrarytest：连接名字为librarytest的库 
真正名字是liblibrarytest.so(a) so是动态库，a是静态库。 
严格按照文件名搜索，版本号要创建软连接。 
编译搜索目录：
用户-L指定， LIBRARY_PATH，系统目录/lib  /usr/lib 
运行搜索目录：
LD_LIBRARY_PATH，ld.so.cache & /etc/ld.so.conf ，系统目录  /lib  /usr/lib 
动态库和静态库同名，优先动态库。  

-Ldir：添加库文件搜索路径 -Idir（include）：添加头文件搜索路径  

-g：产生调试信息  

-olevel：优化级别，一般用o2  

三、静态库、共享库 
静态库：一些.o文件打包，在被连接后成为程序的一部分。 
编译方法 
-g++ -c test.cpp 
-ar res libtest.a test.o 
链接方法： 
-g++ -Wall -o test testMain.cpp -ltest -L./  

共享库：链接的时候不会被复制到程序中。 
编译方法： 
g++ -c fPIC test.cpp	
//要动态 g++ -shared -WI, -soname, libtest.so, -o libtest.so.1.0.1 test.o 
mv libtest.so.1.0.1 /usr/lib 
sudo ldconfig & || ll /user/lib/libtest.so //创建一个软连接。     
链接方法：
g++ -o test test.cpp ./libtest.so -ldx_cxx  

四、常用命令 
ldd：显示程序依赖的同台共享库。  
file：查看文件格式信息。  
ldconfig：在搜寻目录下搜索出可以共享的动态链接库 

   lower_bound&upper_bound是二分查找的一种版本，在已排序的区间中寻找可插入value的第一个位置和第一个不小于value的位置。
   lower_bound的实现（forward_iteratror版本，其random_access_iterator版本不需要用distance函数，直接用+）：

template<class ForwardIterator, class T, class Distance>
ForwardIterator __lower_bound(ForwardIterator first,
                              ForwardIterator last,
                              const T& value,
                              Distance*,
                              forward_iterator_tag)
{
    Distance len=0;
    distance(first, last, len);    //求整个区间的长度
    Distance half;
    ForwardIterator middle;

    while(len>0)
    {
        half=len>>1;            //除以二
        middle=first;
        advance(middle, half);    //middle指向中间位置
        if(*middle<value)
        {
            first = middle;
            ++first;
            len=len-half-1;        //修正len
        }
        else
            len=half;
    }
    return first;
}

template<class ForwardIterator, class T, class Distance>
ForwardIterator __lower_bound(ForwardIterator first,
                              ForwardIterator last,
                              const T& value,
                              Distance*,
                              forward_iterator_tag)
{
    Distance len=0;
    distance(first, last, len);    //求整个区间的长度
    Distance half;
    ForwardIterator middle;

    while(len>0)
    {
        half=len>>1;            //除以二
        middle=first;
        advance(middle, half);    //middle指向中间位置
        if(value<*middle)
        {
            len=half;
        }
        else
        {
            first = middle;
            ++first;
            len=len-half-1;        //修正len
        }
    }
    return first;
}

make_heap(first, middle);
for(RandomAccessIterator i = middle; i<last; ++i)    //只能是随机迭代器
    if(*i<*first)
        __pop_heap(first, middle, i ,T(*i), dfistance_type(first));
    sort_heap(first, middle);

inline void sort(RandomAccessIterator first, RandomAccessIterator last)
{
    if(first != last)
    {
        __introsort_loop(first, last, value_type(first)        //内省式排序
                         __lg(last-first)*2);
        __final_insertion_sort(first, last);                //最终进行一次插入排序
    }
}

template<class Size>
inline Size __lg(size n)
{
    Size k;
    for(k=0; n>1; n>>=1) ++k;
    return k;
}

void __introsort_loop(RandomAccessIterator first, RandomAccessIterator last.
                      T*, Size depth_limit)
{
    while(last-first>__stl_threshold)    //__stl_threshold=const int 16
    {
        if(depth_limit==0)
        {
            partial_sort(first, last, last);    //改用heapsort
            return;
        }

        --depth_limit;
        RandomAccessIterator cut = __unguarded_partition(first, last, T(__median(*first,
            *(first+(last-first)/2,
            *(last-1)))));
        //cur为三点中值法求出来的pivot
        //右半段递归
        __introsort_loop(cut, last, value_type(first), depth_limit);
        last=cut;//定位到左半段再递归处理(左右共用一个depth_limit)
    }
}

RandomAccessIterator __unguarded_partition(RandomAccessIterator first,
                                           RandomAccessIterator last,
                                           T pivot)
{
    while(true)
    {
        while(*first < pivot) ++first;
        --last;
        while(pivot < *last) --last;
        if(!(first<last)) return first;
        iter_swap(first, last);
        ++first;
    }
}