数组去重，斐波那契数列，驼峰命名，判断数组类型，快排

数组去重

第一个参数：表示Array的某个元素。另外两个参数：表示元素的位置和数组本身；去除重复元素依靠的是 indexOf 总是返回第一个元素的位置，后续的重复元素位置与 indexOf 返回的位置不相等，因此被 filter 滤掉了。

var arr = [1, 2, 3, 3, 3, 4, 5, 5, 5]

var result = arr.filter(function (element, index, self) {
    return self.indexOf(element) === index
})

function unique(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j]) {
                arr.splice(j, 1)
                j--
            }
        }
    }
    return arr
}

function unique(arr) {
    let result = []
    let json = {}
    for (let i = 0; i < arr.length; i++) {
        if (!json[arr[i]]) {
            result.push(arr[i])
            json[arr[i]] = 1
        }
    }
    return result
}

斐波那契数列

function fib(max) {
    var arr = [0, 1];
    var temp = 0;
    var a = 0;
    var b = 1;
    while (arr.length < max) {
        temp = a;
        a = b;
        b = temp + b;
        arr.push(b);
    }
    return arr;   // 可以输出长度为n的数组
}

function* fib(max) {
    var t = 0;
    var a = 0;
    var b = 1;
    var n = 1;
    while (n <= max) {
        yield a;
        t = a + b;
        a = b;
        b = t;
        n++;
    }
    return a;
}
var f = fib(5);
console.log(f.next());    // {value: 0, done: false}
f.next();    // {value: 1, done: false}
f.next();    // {value: 1, done: false}
f.next();    // {value: 2, done: false}
f.next();    // {value: 3, done: true}

for (var x of fib(7)) {
    console.log(x);    // 依次输出0, 1, 1, 2, 3
}

function fb(n) {
    let res = [1, 1];
    if (n === 1 || n === 2) {
        return 1;
    }
    for (let i = 2; i < n; i++) {
        res[i] = res[i - 1] + res[i - 2];
    }
    return res[n - 1];  // 可以输出第n位是多少
    // return res;      // 输出长度为n的数组
}
fbnq(10);  //55  

转成驼峰命名

var s = "style-sheet-base";

var a = s.split("-");
var o = a[0];
for (var i = 1; i < a.length; i++) {
    o = o + a[i].slice(0, 1).toUpperCase() + a[i].slice(1);
}

判断数组类型

ECMAScript5将 Array.isArray() 正式引入 JavaScript，目的就是准确地检测一个值是否为数组。IE9+、 Firefox 4+、Safari 5+、Opera 10.5+和Chrome都实现了这个方法。但是在IE8之前的版本是不支持的。

var arr = [1,2,3,1];
var arr2 = [{ abac : 1, abc : 2 }];
function isArrayFn(value){
  if (typeof Array.isArray === "function") {   // 兼容性问题
    return Array.isArray(value);
  } else {
    return Object.prototype.toString.call(value) === "[object Array]";
  }
}
alert(isArrayFn(arr));   // true
alert(isArrayFn(arr2));  // true

Object.prototype.toString 的行为：首先，取得对象的一个内部属性[[Class]]，然后依据这个属性，返回一个类似于"[object Array]"的字符串作为结果(看过ECMA标准的应该都知道，[[]] 用来表示语言内部用到的、外部不可直接访问的属性，称为“内部属性”)。利用这个方法，再配合call，我们可以取得任何对象的内部属性 [[Class]]，然后把类型检测转化为字符串比较，以达到我们的目的。

call 改变 toString 的this引用为待检测的对象，返回此对象的字符串表示，然后对比此字符串是否是'[object Array]'，以判断其是否是Array的实例。

为什么不直接o.toString()？虽然Array继承自Object，也会有 toString方法，但是这个方法有可能会被改写而达不到我们的要求，而Object.prototype 能一定程度保证其“纯洁性” 。

JavaScript 标准文档中定义: [[Class]] 的值只可能是下面字符串中的一个： Arguments, Array, Boolean, Date, Error, Function, JSON, Math, Number, Object, RegExp, String。这种方法在识别内置对象时有用，但对于自定义对象不要使用这种方法。

JS实现快排

function quickSort(arr) {
    if (arr.length <= 1) return arr;             // 递归停止条件
    // 选取基准值
    var pivotIndex = Math.ceil(arr.length / 2);  // Math.ceil():向上取整
    var pivot = arr.splice(pivotIndex, 1)[0];   // 基准值
    var left = [], right = [];
    // 如果大于基准值，移到数组right中；小于基准的值，移到数组left中
    for (var i = 0; i < arr.length; i++) {
        arr[i] > pivot ? right.push(arr[i]) : left.push(arr[i]);
    }
    return quickSort(left).concat([pivot], quickSort(right));
};
console.log(quickSort(arr));