【笔试】Javascript

1、Javascript数据类型

值类型(基本类型)：
        String:字符串           
        Number:数值          
        Boolean:布尔值           
        Null:空值           
        Undefined:未定义    
        Symbol：（ES6 引入了一种新的原始数据类型，表示独一无二的值）
引用数据类型（对象类型）：
        Array:数组
        Object:对象
        Function:函数
        Date:日期

2、Javascript常用函数

Math.random(); //随机数，0（包括 0）往上，但是不包括 1（排除 1）
Math.ceil(); //向上取整
Math.floor(); //向下取整

3、匿名函数

匿名函数顾名思义指的是没有名字的函数。

作用：

1、通过匿名函数可以实现闭包。闭包是可以访问在函数作用域内定义的变量的函数。若要创建一个闭包，往往都需要用到匿名函数。

2、模拟块级作用域，减少全局变量。执行完匿名函数，存储在内存中相对应的变量会被销毁，从而节省内存。再者，在大型多人开发的项目中，使用块级作用域，会大大降低命名冲突的问题，从而避免产生灾难性的后果。自此开发者再也不必担心搞乱全局作用域了。

//声明一个普通函数，函数的名字叫fn
function fn(){
    console.log("这是一个普通函数");
}

//匿名函数
(function (){
    console.log("匿名函数");
})

//执行匿名函数
(function (){
    console.log("执行匿名函数");
})()

应用场景：

// 1、对象
var obj={
    name:"小成",
    age:18,
    say:function(){
        return "我叫"+this.name+"今年"+this.age+"岁了！";
    }
};
console.log(obj.say()); //我叫小成今年18岁了！


// 2、函数表达式
//将匿名函数赋值给变量fn。
var fn=function(){
    return "Hello World!"
}
console.log(fn()); //Hello World!


// 3、回调函数
setInterval(function(){
    console.log("回调函数，每次1秒钟会被执行一次");
},1000);


// 4、返回值
//将匿名函数作为返回值
function fn(){
    //返回匿名函数
    return function(){
        return "Hello World!";
    }
}
//调用匿名函数
console.log(fn()()); //Hello World!
//或
var box=fn();
console.log(box()); //Hello World!


// 5、作用域
function fn(){
    (function(){
        var hi="Hello World!";
    })();
    console.log(hi);//报错---hi is not defined
}
fn();

4、异步

5、深拷贝和浅拷贝

https://www.cnblogs.com/xiyouchen/p/10366236.html

6、模板字符串（ES6）

const foo = `this is a ${example}`;

7、数组乱序输出

var arr = [1,2,3,4,5,6,7,8,9,10];
for (var i = 0; i < arr.length; i++) {
  const randomIndex = Math.round(Math.random() * (arr.length - 1 - i)) + i;
  [arr[i], arr[randomIndex]] = [arr[randomIndex], arr[i]];
}
console.log(arr)

8、数组扁平化

 let arr = [1, [2, [3, 4]]];
 
 function flatten(arr) {
        let result = [];
        for(let i = 0; i < arr.length; i++) {
            if(Array.isArray(arr[i])) {
                result = result.concat(flatten(arr[i]));
            } else {
                result.push(arr[i])
            }
        }
        return result;
    }
console.log(flatten(arr));


function flatten(arr) {
    return arr.toString().split(',').map(function(item){
        return +item //+可以快速获得Number类型
    })
}

9、数组去重

// Set数据结构，它类似于数组，其成员的值都是唯一的
function unique(arr){
 return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
}

// 新建一个数组，遍历要去重的数组，当值不在新数组的时候（indexOf 为 -1）就加入该新数组中
function unique(arr){
    var newArr = [];
    for(var i = 0; i < arr.length; i++){
        if(newArr.indexOf(arr[i]) == -1){
            newArr.push(arr[i])
        }
    }
    return newArr;
}  
  
// 用对象的属性不能相同的特点进行去重
function unique(arr){
    var res = [];
    var obj = {};
    for(var i=0; i<arr.length; i++){
       if( !obj[arr[i]] ){
            obj[arr[i]] = 1;
            res.push(arr[i]);
        }
    } 
 return res;
}

10、实现getType

function getType(obj) {
    if (obj === null) {
        return String(obj)
    }
    const toType = (obj) => {
        // '[object RealType]' => realtype
        return Object.prototype.toString.call(obj).replace('[object ', '').replace(']', '').toLowerCase()
    }
    return typeof obj === 'object' ?
        toType(obj) :
        typeof obj;
}

11、快速排序

// 在平均状况下，排序n个项目要O(nLogn)次比较。在最坏状况下则需要O(n^2)次比较
var quickSort = function(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  var pivotIndex = Math.floor(arr.length / 2);
  var pivot = arr.splice(pivotIndex, 1)[0];
  var left = [];
  var right = [];

  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat([pivot], quickSort(right));
};

12、归并排序

function mergeSort(arr) {
  let len = arr.length;
  if (len < 2) return arr;
  let mid = Math.floor(len / 2);
  let left = arr.slice(0, mid);
  let right = arr.slice(mid);
 
  return merge(mergeSort(left), mergeSort(right));
}
 
function merge(left, right) {
  let result = [];
 
  while (left.length > 0 && right.length > 0) {
    if (left[0] <= right[0]) {
      result.push(left.shift());
    } else {
      result.push(right.shift());
    }
  }
 
  while (left.length) result.push(left.shift());
  while (right.length) result.push(right.shift());
 
  return result;
}
 
 
var arr = [3,5,7,1,4,56,12,78,25,0,9,8,42,37];
var res = mergeSort(arr);
console.log(arr, res)

13、易错

// 1、在变量未初始化的情况下就访问变量。在使用let以及const声明变量不会提升，所以就会抛错，而使用var声明的变量，会声明提升，所以会打印出undefined
function test() {
    console.log(b);     // undefined
    console.log(a);     // 报错(Cannot access 'a' before initialization)
    let a = 'a';
    var b = 'b';
}
test()


// 2、
const test2 = () => {
    console.log(this.b);
}
var obj = {
    a: 1,
    b: 2,
    test: function () {
        console.log(this.a);
    },
    test2: test2
}
obj.test(); // 1
obj.test2(); // undefined


// 3  b is not a function、
var b;
(function a() {
	let d = '2'
    b();
    b = function() {
        console.log(d);
        let d = 3
    }
})();

// 4、Cannot access ‘d’ before initialization
var b;
(function a() {
	let d = '2'
    b = function() {
        console.log(d);
        let d = 3
    }
})();
b();

// 5、
var a = 3;
function b() {
	console.log(a)
}
function c() {
	var a = 5;
    b();
}
c(); // 3