昨天下了QQ浏览器来用，查看关于发现QQ浏览器的内核是Chromium的。那个Chrome和Chromium是什么关系呢？

chromium是谷歌的开源项目，有很多开发者共同的去改进，谷歌收集改进后会发布安装包，也就是chromium，然后会将chromium的东西更新到chrome中，chrome不是开源项目，而在chrome内的更新也有一个过程，先更新到chrome的金丝雀版（未验证bug），接着到dev版（大问题已经验证），接着beta（小问题已经验证），都没问题了，再更新到稳定版。

Chrome浏览器各版本的特点：
1、Chromium
Chromium是Google为发展Chrome浏览器而启动的开源项目，Chromium相当于Chrome的工程版或称实验版（尽管Chrome自身也有β版阶段），新功能会率先在Chromium上实现，待验证后才会应用在Chrome上，故Chrome的功能会相对落后但较稳定（实际上稳定性也差不多）；Chromium的更新速度很快，每隔数小时即有新的开发版本。
2、Chrome dev
基于最新的Chromium Build，经常每周就更新推出新功能；与Beta版十分相似，但稳定性较差，不适合公共使用。
3、Chrome beta
基于Chrome dev；按月更新；崩溃等重大故障较少发生，功能比dev更加完善。
4、Chrome stable

然后…然后我瞬间找到了我的QQ浏览器为什么一直崩溃he的原因了。

题目来源

指定和值的二叉树路径查找

现在有一个二叉树，找出这个二叉树中是否有存在这样一条根到叶子的路径能使路径节点上的值加起来等于给定的值。
比如下面这个二叉树，给定的值是22，5->4->11->2 这条路径是满足条件的。

      5
     / \
    4   8
   /   / \
  11  13  4
 /  \      \
7    2      1

思路

这就是一个二叉树遍历，从根节点往下，每找到一个节点将节点的value和当前路径相加，判断是否和sum相等。

• 如果相等，并且是叶子节点，则返回true，找到
• 如果不相等，相等但不是叶子节点，则继续查找，直到所有的节点都遍历过。

实现

JavaScript:

var checkNext =function(root, sum, currentSum,flag){
    if (root) {

        if (root.val + currentSum === sum) {
            if (root.left === null && root.right === null) {
                return true;
            }
        }
        if(root.left===null&&root.right===null){
            return false;
        }

        if (root.left !== null) {
            flag = checkNext(root.left, sum, root.val + currentSum,flag);
        }
        if(flag){
            return true;
        }
        if (root.right !== null) {
            flag = checkNext(root.right, sum, root.val + currentSum,flag);
        }
        return flag;


    } else {
        return false;
    }
}
var hasPathSum = function (root, sum) {

    if(checkNext(root, sum, 0,false)){
        return true
    }else{
        return false
    }
  };

PS:这是我在leetcode上做的第一个题，最初没有搞明白玩法，一直在自己实现二叉树，后面才发现原来二叉树已经写好，只要给遍历方法就好了。

转帖：原文

Google退出WebKit项目，创建自己的渲染引擎Blink。这其实不能说完全没有先兆，合合分分，纯属正常。

其实，之前关于WebKit2，双方的争论就非常的大。Apple希望它可以随便加入和删除代码而无需担心它会破坏其它Ports的代码，这遭到很多人的反对和不满。

同时，另一方面，Google有很多新的功能希望加入WebKit中，但是WebKit可能并不认可他们。双方分歧越来越多，终于分道扬镳。

这里面有个误区，就是Google的Blink是一个全新的引擎。其实不是这样，Blink目前就是从WebKit直接复制出一个版本出来，然后将与chromium无关的Ports全部移除掉，将代码结构重新整理，就目前而言，Blink的渲染和WebKit是一样，但是，以后两者将各自走不同的路。这有点类似于之前WebKit从KHTML中复制出来一样，历史总是惊人的相似。

目前参与Blink和Chromium大致一样，拥有Chromium的commit权限对Blink也适用。原来一些WebKit的committer和reviewer也开始成为blink的committer。它的提交代码流程，review流程等都是chromium的风格，这对chromium的开发者来说非常熟悉。

目前遇到的场景，直接在webstorm上打断点，然后shift+ctrl+D, 就可以调试了。

后面遇到更复杂的场景再继续研究。

给定一个集合，求出它的所有子集。例如给[1,2,3], 那么输出应该是[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3].

Node入门

很久前就把它加入了手机的书签栏，然后陆陆续续利用吃饭排队的事件看完的。

文章是翻译的，写得很清晰易懂，node细节的我就不说了，因为也不是完全懂，就谈谈读后感。

nodejs很早就听过，也很早就去看过一些介绍的文章、入门的文章，快速搭建的文章，在JS权威指南里也有关于nodejs的介绍。

为什么这次看的这篇文章和以前看的感觉就不一样呢？

我仔细地想了下。

因为那时我还不知道JS是单线程的，是基于事件驱动的

没有这样的一层基础去看node(注意是【看】 不是【学习】)，根本理解不了，只能是别人说什么是什么，然后转天就忘了。

在学习的路上，我们看了很多东西。

有些让你豁然开朗，有些让你越看越迷糊。豁然开朗的就很有兴趣地看下去，越看越迷糊的就被搁浅了，而搁浅的时间以年为单位。

看完文章，我想到之前ES6中的一个generator概念还是不清楚，或许现在可以更好地理解了。

• 事件轮询
• 非阻塞的实现机制
• generator

晚饭后散步，bf一心在看手机刷微博。

我趴在扶栏上，看飞机慢慢降落。我问bf:”为什么冥王星有个心呢？”

bf果断答：“没有心。”

“有心。”我继续问，“为什么冥王星有个心呢？”

“没有心。”

“照片都出来了，怎么没有？可为什么冥王星有个心呢？”

bf还是很确定：“没有心。”

“为什么冥王星有个心呢？”

“没有心。”

“为什么冥王星有个心呢？”

“没有心。”

“为什么冥王星有个心呢？”

“没有心。”

…..

如此重复了很多遍之后，我终于忍不了了:”为什么明明有心你要说没心！”

然后bf也忍不住笑场了：“否定掉冥王星有心就不会继续追问,反正你一直问一直问也不是真正想要知道。”

因为最近在做事件绑定的时候总是出现一些问题，看来有必要去研究下了。
先占个坑，以后再填。

主要是看阮一峰的入门教程
还有csdn上的探秘ES6
github上的es6 feature

说起来好惭愧，一直都没有去了解ECMAScript,枉做前端。

ES6有哪些酷炫的新特性呢？

新增箭头操作符=> ,简化函数书写

coffeescript的语法糖里也是有样，各种回调需要写function,现在用=> 代替function关键字

新增基本类型

JS有null,undefined,boolean,number,string五种基本类型，object是引用类型。
现在新增Symbol这个基本类型，避免与已有代码命名冲突

var key = Symbol("key");

自带Promise

现在已经很多js的类库都支持Promise了，比如Jquery。ES6正式引入，提供原生的Promise对象。

新增块级变量的定义 关键字let

JS是变量var定义是不存在块级生命周期的。现在新增let关键字，仅可以在块级中使用。

for(let i = 0; i < arr.length; i++){}

console.log(i)
//ReferenceError: i is not defined

变量的解构赋值

自动解析数组或对象中的值，并给对应变量进行赋值，这被称为解构（Destructuring）。

var [x,y]=getVal(),//函数返回值的解构
    [name,,age]=['wayou','male','secrect'];//数组解构

function getVal() {
    return [ 1, 2 ];
}

console.log('x:'+x+', y:'+y);//输出：x:1, y:2 
console.log('name:'+name+', age:'+age);//输出： name:wayou, age:secrect

据说在函数传参中很有用。
如果函数的参数列表很长，又不想记住他们的顺序，我们对参数对象使用解构赋值，这样，在访问对象属性时，便可以避免重复调用这一参数对象

for of 的遍历

我们以前用for in 遍历数组，但拿到的是数组的索引值，这点很烦。for of 拿到的值不是索引，完全没有这个烦恼。

for (var value of myArray) { 
    console.log(value); 
}

另外，我们以前也用forEach遍历数组，for(var i of array){} 和forEach(function(i){})比起来，优势在于还可以有break,continue,return这些操作。

Generator函数

没有看明白这是干什么，mark下

引入模块化 Module

模块功能主要由两个命令构成：export和import。
export命令用于用户自定义模块，规定对外接口；
import命令用于输入其他模块提供的功能，同时创造命名空间（namespace），防止函数名冲突。
这个对于代码管理很有用啊。越来越像java了…

还有一些其他的新增api，新增的map和set集合等等，到时再看了。

概念

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。
然后再按此方法对这两部分数据分别进行快速排序，以此达到整个数据变成有序序列。

思路

一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j—)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

时间复杂度

假设其数组长度为n，其算法复杂度为o（nlog（n））

实现

//var array = [3, 8, 1, 9, 0, 6, 5, 2, 4, 7];
var array = [111,34,231,89,22,90,1,23,7,45,222,55,2456,34,33,9,3,55,1234,67,3,80,46,37,48,24,16];
  console.log(array.toString());

function quickSort(array) {
    var count = 0;


    function sortPartial(front, back) {

        var key = array[front], i = front, j = back;
        if(j-i>=1){

            while ( i < j) {
                //从后往前遍历，找到第一个比key小的替换位置。
                for (; j >i; j--) {

                    if (array[j] < key) {
                        array[i] = array[j];
                        array[j] = key;
                        console.log(array.toString());
                        break;
                    }
                }
                //从前往后遍历，找到第一个比key大的替换位置
                for (; i < j; i++) {
                    count++;
                    if (array[i] > key) {
                        array[j] = array[i];
                        array[i] = key;
                        console.log(array.toString());
                        break;
                    }
                }
            }

            //当前key的位置确定，开始递归key前半部分，和key后半部分。
             sortPartial(front, i-1);
             sortPartial(j+1, back);
        }

    }

    sortPartial(0, array.length - 1);
    return array;

}

console.log(quickSort(array).toString());

PS: 写了一个小时。。。也真是醉了。