几例前端面试基础题

本中所选的关于前端的基础题目均来自微信公众号《前端大全》和《前端JavaScript》

直接上代码desu

/***************************经典面试题*******************************/
//判断引用类型
/*var obj={},arr=[],fun=function(){};
console.log(Object.prototype.toString.call(obj));
console.log(Object.prototype.toString.call(arr));
console.log(Object.prototype.toString.call(fun));
console.log(typeof asss)

//
var myObject={
    foo:'bar',
    func:function(){
        var self=this;
        (function(test){
            console.log(test.foo);
            console.log(self.foo);
        }(self))
    }
}
myObject.func();

////IIFE
//循环中定时输出数据项
for(var i=0;i<5;i++){
    (function(i){
        setTimeout(function(){
            console.log(i)
        },1000)
    }(i))
}

//jQuery/Node插件和模块开发中避免变量污染
(function($){

}(jQuery))

//JS解析器自动填充分号机制
function foo1(){
    return {
        bar:1
    };
}
function foo2(){
    return
    {
        bar:1
    };
}//返回undefined
//对于return break continue 若后面紧接换行，解析器会自动在后面填充分号

(function(){
    console.log(1);
    setTimeout(function(){console.log(2)},1000);
    setTimeout(function(){console.log(3),0});
    console.log(4);
}())//1 4 3 2


//判断一个字符串是不是回文字符窜
function isPalindrome(str) {
    return (str == str.split('').reverse().join(''));
}
alert(isPalindrome('上海自来水来自海上'))

//array.reverse()不创建新数组，改变原数组
var arr1 = "john".split(''); 
var arr2 = arr1.reverse(); 
var arr3 = "jones".split(''); 
arr2.push(arr3);//此处推进了一个数组作为arr2的一个元素
console.log("array 1: length=" + arr1.length + " last=" + arr1.slice(-1));
console.log("array 2: length=" + arr2.length + " last=" + arr2.slice(-1));



//空数组与空对象的布尔类型转换
console.log([]==false,Number([]));//true
console.log({}==false,Number({}));//false
console.log(Boolean([]));//true
console.log(Boolean({}));//true
console.log(1==true,'a'==true,2==true);//true，false,false
//空数组，空对象对应的布尔值类型均为true，因此在if从句判断中，空数组空对象均可以视为true；
//与布尔值进行比较时，符号两边均转化为数字，即调用Number()函数，(注意不是调用valueOf()函数)




//为对象设置属性时，JavaScript会隐式调用toString()函数
var o={};
var b={key:'b'};
var c={key:'c'};
o[b]=123;//隐式调用后b转化为[object Object]，下同，故与下式实为同一属性
o[c]=456;
console.log(o[b]);//456

////堆栈溢出及优化
//溢出
function isEven(num){
    if(num == 0){return true;}
    if(num == 1){return false;}
    return isEven(Math.abs(num)-2);

}
console.log(isEven(100000))


//闭包函数优化
function isEven(num){
    function isEvenInner(num){
        if(num === 0){return true;}
        if(num === 1){return false;}
        return function(){
            return isEvenInner(Math.abs(num)-2);
        }
    }

    function simplify(func,num){
        var value=func(num);
        while(typeof value == 'function'){
            value=value();
        }
        return value;
    }

    return simplify.bind(null,isEvenInner)(num)
}

console.log(isEven(100000));//这种方法num太大也不可以
*/

//调用定时器

//溢出
/*function factorial(n){
    if(n === 1) {return 1;}
    return n*factorial(n-1);
}
console.log(factorial(10000));


//尾调用优化
function tailFactorial(n, total) {
  if (n === 1) return total;
  return tailFactorial(n - 1, n * total);
}
console.log(tailFactorial(5,1))
function factorial(n) {
  return tailFactorial(n, 1);
}

console.log(factorial(10000))

//currying
function currying(fn,n){//柯里化要绑定的参数
    return function(m){//柯里化的函数，m对应输入的唯一一个参数
        return fn.call(this,m,n)    
}//柯里化
}
var factorial_1=currying(tailFactorial,1);
console.log(factorial_1(5));*/




/*****************************关于作用域和VO、AO的几题*****************************/
/*function test(){
    console.log(foo);//function hello
    console.log(bar);//undefined
    var foo='Hello';
    console.log(foo);//Hello
    var bar=function(){
        return 'world';
    }
    function foo(){
        return 'hello'
    }
}
test();

//变量编译与执行
var str='a';
function test(){
    console.log(str);
    var str='b';
    console.log(str);
}
test();//试下改为 srt='b'?

//连续赋值对作用域的影响
(function(){
    var user=author='a';
}());
console.log(author);
console.log(user);
//连续赋值中只有user是通过var变量声明的，声明在了私有作用域中，所以author在全局作用域中

//函数间的变量访问关系
var user='a';
function first(){
    console.log(user)
}
function second(){
    var user='b';
    first();
}
second();

//形参与作用域
var user='a';
function changeUser(user){
    user='b'                //形参不能被外部作用域访问，等价于var user=user; user='b';
}
changeUser(user);
console.log(user);

//VO建立过程1
function test(){
    function a(){
        return 1
    }
    alert(a());
    function a(){
        return 2 
    }
    alert(a())
}
test()

//VO建立过程2
function test(){
    var a=1;
    alert(a);
    var a=2;
    alert(a);
}
test()

//形参与作用域2
var user='a';
function test(user){
    console.log(user);       //等价于var user=user;console.log(user);var user='b';console.log(user);
    var user='b';
    console.log(user)
}
test(user);

//函数名与作用域
var user='a';
function test(){
    user='b';
    return;
    function user(){
        console.log('c')
    }
}
test();
console.log(user);
//test函数执行顺序：user先被声明为局部函数，之后修改为'b'，但仍为局部变量，之后返回，故全局变量中user不变。*/