本来还可以采取reduce方法来兑现。代码有半点单钩。

1.JS招来字符串中起最多的字符

譬如说:求字符串’nininihaoa’中冒出次数最多字符

方法一:

var str = "nininihaoa";
    var o = {};
    for (var i = 0, length = str.length; i < length; i++) {
        var char = str.charAt(i);
        if (o[char]) {
            o[char]++;  //次数加1
        } else {
            o[char] = 1;    //若第一次出现,次数记为1
        }
    }
    console.log(o);   //输出的是完整的对象,记录着每一个字符及其出现的次数
    //遍历对象,找到出现次数最多的字符的次数
    var max = 0;
    for (var key in o) {
        if (max < o[key]) {
            max = o[key];   //max始终储存次数最大的那个
        }
    }
    for (var key in o) {
        if (o[key] == max) {
            //console.log(key);
            console.log("最多的字符是" + key);
            console.log("出现的次数是" + max);
        }
    } 

结果如图所示:

图片 1

方式二,当然还得动用reduce方法来落实:

var arrString = 'abcdaabc';

arrString.split('').reduce(function(res, cur) {
    res[cur] ? res[cur] ++ : res[cur] = 1
    return res;
}, {})

顾念详细了解reduce()方法,可以参考:《JS进阶篇–JS数组reduce()方法详解及高级技术》

 

原文在这里。我勾勒下来仅是为着作个人笔记。

2.JS兑现九九乘法表

 

jQuery实现方式:

var sum=0;
var wite;
for (var i = 1; i < 10; i++){
        var div=$('<div class="class'+i+'"></div>');
        $("body").append(div);
        for(var j = i; j > 0; j--){
                sum = j * i;
                wite = (j+"X"+i+"="+sum);

                div.prepend($(''+wite+''));
        }

} 

实现结果如图所示:

图片 2

原生js实现方式:
css代码:

html,body,ul,li {
    padding: 0; 
    margin: 0; 
    border: 0; 
}
ul { 
    width: 900px;
    overflow: hidden;
    margin-top: 4px;
    font-size: 12px; 
    line-height: 36px;
}
li { 
    float: left; 
    width: 90px; 
    margin: 0 4px; 
    display: inline-block; 
    text-align: center; 
    border: 1px solid #333; 
    background:yellowgreen; 
}

js代码:

for(var i = 1; i <= 9; i++){
    var myUl = document.createElement('ul');
    for(var j = 1; j <= i; j++){
        var myLi = document.createElement('li');
        var myText = document.createTextNode(j + " × " + i + " = " + i*j);
        myLi.appendChild(myText);
        myUl.appendChild(myLi);
    }
    document.getElementsByTagName('body')[0].appendChild(myUl);
}

原生js实现效益如图所示:

图片 3


3.面前端面试:这几鸣前端面试题特别绕吗?做对了几道?

  • 一如既往、考虑以下代码的出口:

第一题

var fun = function(){
    this.name = 'peter';
    return {
    name: 'jack'
    };
}

var p = new fun();
//请问p.name是:

第二题

var fun = function(){
    this.name = 'peter';

    return 'jack';    
    }

var p = new fun();
//请问p.name是:
(function(){
var a = b = 5;
})()
console.log(b);

第三题

var fun = function(){}

fun.prototype = {
    info : {
    name : 'peter',
    age : 25
    }
}

var a = new fun();
var b = new fun();

a.info.name = 'jack';
b.info.name = 'tom';

//请问a.info.name和b.info.name分别是:

结果:5
代码来有限只钩:
相同,看上去是闭包空间内声明两单变量 a、b, 但事实是:a是匿名函数内为此 var
声明的一个变量,而 b 不是。
b 被看做是一个全局变量,并当这匿名函数内被赋值5,所以于函数外尝试对 b
取值是卓有成效的, 但 a 不行。
其次,并没下严格模式 ‘use
strict’,在严厉模式下,会报错,因为严格模式要求出示调用全局变量:

第四题

var fun = function(){
    this.info = {
    name : 'peter',
    age : 25
    }
}

var a = new fun();
var b = new fun();

a.info.name = 'jack';
b.info.name = 'tom';
//请问a.info.name和b.info.name分别是:
(function(){
var a = window.b = 5;
})()
console.log(b);

第五题

var fun = function(){}

fun.prototype = {    
    name : 'peter',    
    age : 25    
}

var a = new fun();
var b = new fun();

a.name = 'jack';
b.name = 'tom';
//请问a.name和b.name分别是:

第六题

var fun = function(){
    this.info = {
    name : 'peter',
    age : 25
    }
}

fun.prototype = {
    info : {
    name : 'peter',
    age : 25
    }
}

var a = new fun();
var b = new fun();

a.info.name = 'jack';
b.info.name = 'tom';
//请问a.info.name和b.info.name分别是:

 

解答:

1,2题考察之凡构造函数的返回值的问题。

每个函数都发生返回值,如果应用了return语句,则返回return晚与的值,如果无动用return,则默认返回undefined.
专程之,如果是函数是构造函数,则默认返回this对象,如果构造函数内利用了return语句,并且return后及的是一个靶,则是构造函数返回的凡者目标,否则回this.
所以1题中的p = {name: 'jack'},而2题中的p = {name: 'peter'}.

3, 4, 5, 6开还是着眼prototype的知识。

3.简单个都输出tom。首先你如果明白原型模式之行流程:

1.先查找构造函数实例里的属性或方法,如果有,就立即返回。
2.如果构造函数的实例没有,就去它的原型对象里找,如果有,就立即返回

4 .a.info.name 为jackb.info.nametom。原因我怀念你于第三题都得出去了。

5.a.name输出jack,b.name输出tom。原因我怀念你自第三开已经得出去了。

6.a.info.name 为jackb.info.nametom。原因我思你于第三写已经得出来了。

只顾:第三挥毫
a.info.name这段代码,首先去访问了实例对象自我是否生info这个目标,发现没就错过原型上查找了,发现原型上生,所以地方共享了收获的价都是Tom;第五开是有分的,a.name实例本身没有,给当下a这个实例对象执行赋值操作,没有错过拜谒原型上的name。就一定给第三书先看了原型上的info对象,第五题没有看过程,只是于实例上添加了name属性值。

  • 仲、创建内置方法:
    给String对象创建一个repeatify方法,该措施接收一个参数作为字符串的再次数,最后回到指定重复次数的字符串,
    例如:
    console.log(‘Hello’.repeatify(3));
    输出 HelloHelloHello。

4.经过演示搞懂JS闭包

例1

function sayHello(name) 
{
 var text = 'Hello ' + name;
 var sayAlert = function() { console.log(text); }
 sayAlert();
}
sayHello("Bob") // 输出"Hello Bob"

当sayHello()函数中定义并调用了sayAlert()函数;sayAlert()作为内层函数,可以看外层函数sayHello()中之text变量。

String.prototype.repeatify = String.prototype.repeatify || String.prototype.repeatify = function(num){
  var str = '';
  for (var i = 0; i < num; i++){
    str += str;
  }
  return str;
}

例2

function sayHello2(name) 
{
 var text = 'Hello ' + name; // 局部变量
 var sayAlert = function() { console.log(text); }
 return sayAlert;
}

var say2 = sayHello2("Jane");
say2(); // 输出"Hello Jane"

及时题检测我们原型方面的学识,也检测我们是否扩展内置数据类型方法。

例3

function buildList(list) {
 var result = [];
 for(var i = 0; i < list.length; i++) {
    var item = 'item' + list[i];
    result.push( 
        function() {
            console.log(item + ' ' + list[i]);
        } 
     );
 }
 return result;
}

var fnlist = buildList([1,2,3]);
for (var j = 0; j < fnlist.length; j++) {
    fnlist[j](); 
}

抱的结果:连续输出3独”item3 undefined”
剖析:通过执行buildList函数,返回了一个result,那么是result存放的是3个匿名函数。然而当下三单匿名函数其实就是是三只闭包,因为她可看到父函数的一对变量。所以闭包内之保留的i是最终之价也3.所以list[3]定是undefined.
item变量值为item3.

转化如下代码:

function buildList(list) {
 var result = [];
 for(var i = 0; i < list.length; i++) {
    var item = 'item' + list[i];
    result.push( 
        (function(i) {
            console.log(item + ' ' + list[i]);
        })(i)
     );
 }
 return result;
}

var fnlist = buildList([1,2,3]);

博的结果:

item1 1
item2 2
item3 3

释疑:这儿虽然传递了一个数组进去,但是返的是三只由实施的函数。


例4

function newClosure(someNum, someRef) 
{
 var anArray = [1,2,3];
 var num = someNum;
 var ref = someRef;
 return function(x) 
 {
 num += x;
 anArray.push(num);
 console.log('num: ' + num + "; " + 'anArray ' + anArray.toString() + "; " + 'ref.someVar ' + ref.someVar);
 }
}
closure1 = newClosure(40, {someVar: "closure 1"}); 
closure2 = newClosure(1000, {someVar: "closure 2"}); 
closure1(5); // 打印"num: 45; anArray 1,2,3,45; ref.someVar closure 1"
closure2(-10); // 打印"num: 990; anArray 1,2,3,990; ref.someVar closure 2"

每次调用newClosure()都见面创造独立的闭包,它们的一对变量num与ref的值并不相同。

  • 老三、考虑以下代码的出口:

例5

function sayAlice() 
{
 var sayAlert = function() { console.log(alice); }
 var alice = 'Hello Alice';
 return sayAlert;
}

var sayAlice2 = sayAlice();
sayAlice2(); // 输出"Hello Alice"

alice变量在sayAlert函数之后定义,这从没影响代码执行。因为归函数sayAlice2所指向的闭包会包含sayAlice()函数中的富有有变量,这当然包括了alice变量,因此得以健康打印”Hello
Alice”。

例6

function setupSomeGlobals() {
 var num = 666;
 gAlertNumber = function() { console.log(num); }
 gIncreaseNumber = function() { num++; }
 gSetNumber = function(x) { num = x; }
}
setupSomeGlobals();
gAlertNumber(); // 输出666
gIncreaseNumber();
gAlertNumber(); // 输出667
gSetNumber(5);
gAlertNumber(); // 输出5

解释:首先gAlertNumber,gIncreaseNumber,gSetNumber是三只全局变量,并且该三独价值都是匿名函数,然而就三个匿名函数本身还是闭包。他们操作的num都是保存在内存中之跟一个num,所有见面得有方的结果。

function test(){
  console.log(a);
  console.log(foo());
  var a = 1;
  function foo(){
    return 2;
  }
}
test();

5.JS重复出口一个加的字符串

如下:

再输出一个加以的字符串(str率先只参数)n 次
num仲独参数),如果第二个参数num免是正数的时刻,返回空字符串。

function repeatStringNumTimes(str, num) {
  return str;
}
repeatStringNumTimes("abc", 3);

供测试情况:

repeatStringNumTimes("*", 3) //应该返回 "***".
repeatStringNumTimes("abc", 3) //应该返回 "abcabcabc".
repeatStringNumTimes("abc", 4) //应该返回 "abcabcabcabc".
repeatStringNumTimes("abc", 1) //应该返回 "abc".
repeatStringNumTimes("*", 8) //应该返回 "********".
repeatStringNumTimes("abc", -2) //应该返回 "".

结果:undefined,2。
变量 a 和函数 foo 的扬言还能够于提升及标函数 test 的顶部。
然而此时之变量 a
并从未为赋值,也就是是变量声明被提升,但赋值不会见于升级。也不怕一定给 var a
声明在 console.log(a) 之前,但 a = 1赋值在 console.log(a)
之后。上面代码相当给:

解题思路

自己以介绍三种办法:

  1. 使用 `while` 循环
  2. 运递归
  3. 使用ES6 `repeat()`
function test(){
  var a;
  function foo(){
    return 2;
  }
  console.log(a);
  console.log(foo());
  a = 1;
}
test();

方法1:通过 `while` 循环重复输出一个字符串

function repeatStringNumTimes(string, times) {
  var repeatedString = "";
  while (times > 0) {
    repeatedString += string;
    times--;
  }
  return repeatedString;
}
repeatStringNumTimes("abc", 3);

只是此尚得起几个变种:

对于老前端来说,首先一个可能会见用字符串拼接,修改为
数组join()合龙接字符串,例如:

function repeatStringNumTimes(string, times) {
  var repeatedArr = []; //
  while (times > 0) {
    repeatedArr.push(string);
    times--;
  }
  return repeatedArr.join("");
}
repeatStringNumTimes("abc", 3)

成千上万老前端都发生因此数组join()合接字符串的“情怀”,因为十分早以前普遍认为数组join()并接字符串比字符串+东拼西凑速度要及早得差不多。不过本不见得,例如,V8
+合龙接字符串,要较数组join()合并接字符串快。我用这半单法子测试了3万不行又输出,只去了几乎毫秒。

其余一个变种可以就此 for 循环:

function repeatStringNumTimes(string, times) {
  var repeatedString = "";
  for(var i = 0; i < times ;i++) {
    repeatedString += string;
  }
  return repeatedString;
}
repeatStringNumTimes("abc", 3)

措施2:通过规范判断与递归重复输出一个字符串

递归是同种通过重复地调用函数本身,直到她达到达结果得了的迭代操作的艺。为了要其正常工作,必须概括递归的局部生死攸关特性。

function repeatStringNumTimes(string, times) {
  if(times < 0) 
    return "";
  if(times === 1) 
    return string;
  else 
    return string + repeatStringNumTimes(string, times - 1);
}
repeatStringNumTimes("abc", 3);
  • 季、考虑以下代码的出口:

方法3:使用ES6 `repeat()` 方法还输出一个字符串

是解决方案于新潮,您将应用 String.prototype.repeat() 方法:

repeat()
方法构造并赶回一个新字符串,该字符串包含被连于齐的指定数量的字符串的副本。
这个法子来一个参数 count 表示再次数,介于0与正无穷大之间的平头 :
[0, +∞)
。表示在初组织的字符串中重复了有些遍原字符串。重复次数不能够吧负数。重复次数要低于
infinity,且长不会见过最丰富的字符串。

function repeatStringNumTimes(string, times) {
  if (times > 0)
    return string.repeat(times);
  else
    return "";
}
repeatStringNumTimes("abc", 3);

汝可以采用三首表达式作为 if/else 语句的快捷方式,如下所示:

function repeatStringNumTimes(string, times) {
  return times > 0 ? string.repeat(times) : "";
}
repeatStringNumTimes("abc", 3);

转载地址:http://www.css88.com/archives/7045

6.函屡扬言相关

var x=1,
    y=0,
    z=0;
function add(n){
    n=n+1;
}
y=add(x);
z=x+y;
console.log("y1:"+y);
console.log("z1:"+z);

function add(n){
    n=n+3;
}
y=add(x);
z=x+y;
console.log("y2:"+y);
console.log("z2:"+z);

求y,z的值。

结果为:

y1:undefined
z1:NaN
y2:undefined
z2:NaN

变更一下:

var x=1,
    y=0,
    z=0;
function add(n){
    return n=n+1;
}
y=add(x);
z=x+y;
console.log("y1:"+y);
console.log("z1:"+z);

function add(n){
   return n=n+3;
}
y=add(x);
z=x+y;
console.log("y2:"+y);
console.log("z2:"+z);

求y,z的值

答案:

y1:4
z1:5
y2:4
z2:5
var name = 'Tom';
var obj = {
  name: 'Jerry',
  prop: {
    name: 'Kitty',
    getName: function(){
      return this.name;
    }
  }
}
console.log(obj.prop.getName);
var test = obj.prop.getName;
console.log(test());

7.作用域范围(Scope)

思以下代码:

(function(){
    var a = b = 5;
})();
console.log(b);

控制台(console)见面打印出什么?

答案
上述代码会打印出5
斯题材的圈套就是,在即时施行函数表达式(IIFE)中,有个别独命名,但是中变量是透过重点词var来声称的。这便意味着a是者函数的片变量。与此相反,b是当全局意图域下的。

这题目外一个骗局就是,在函数中他从没以”严格模式
(‘use strict’;)。如果 严格模式
开启,那么代码就见面报发出不捕获引用错误(Uncaught ReferenceError):b没有定义。记住,严格模式要求你以用使用全局变量时,明确地引用该变量。因此,你用像下这么写:

(function(){
    'use strict'
    var a = window.b = 5;
})();
console.log(b);

再度看如下一个例证:

var a = 6;
setTimeout(function () {
    alert(a);
    a = 666;
}, 1000);
a = 66;

结果:66

结果:Kitty,Tom
JavaScript 中 this
所指代的函数上下文,取决于调用的方,而无是受定义之法。
首先单 console.log() 中,getName 为 obj.prop 对象调用,于是回到obj.prop
的 name 属性值。
当 obj.prop.getName 赋值给全局变量 test 时,当前高达下文指代全局对象(因为
test 被隐式看作是大局对象的性质),基于这个,getName 返回 window 的 name。

8.创建 “原生(native)” 方法

在 String 对象及定义一个 repeatify 函数。这个函数接受一个整数参数,来明确字符串需要再行几不好。这个函数要求字符串重复指定的次数。举个例子:

console.log('hello'.repeatify(3));

应当打印出hellohellohello.

答案:

String.prototype.repeatify = String.prototype.repeatify || function(times) {
   var str = '';

   for (var i = 0; i < times; i++) {
      str += this;
   }

   return str;
};

每当此间,另一个关键点是,看你怎样避免再写可能就定义了底艺术。这得经在概念自己之不二法门之前,检测方法是否已存在。

String.prototype.repeatify = String.prototype.repeatify || function(times){
    /*code here*/
};

当您需要呢原浏览器实现向后相当的函数时,这无异于技非常中。


9.变量升任(Hoisting)

行以下代码的结果是呀?为什么?

function test() {
   console.log(a);
   console.log(foo());

   var a = 1;
   function foo() {
      return 2;
   }
}

test();

答案:

马上段代码的推行结果是undefined 和 2

此结果的缘故是,变量和函数都为升级(hoisted) 到了函数体的顶部。因此,当打印变量a时常,它就是在为函数体(因为a一度给声称),但依旧是undefined。换言之,上面的代码等同于下的代码:

function test() {
   var a;
   function foo() {
      return 2;
   }

   console.log(a);
   console.log(foo());

   a = 1;
}

test();

重拘留如下代码:

(function() {
   console.log(typeof foo); 
   console.log(typeof bar); 

   var foo = 'hello',
       bar = function() {
           return 'world';
       };

   function foo() {
       return 'hello';
   }

}());

结果:

function
undefined
  • 五、修复前一个题目,是次单 console.log() 输出 Kitty。
    通过采取 apply() / call() 强制转换上下文:
    console.log(test.apply(obj.prop));
    console.log(test.call(obj.prop));

10. 以javascript中,this是哪行事的

以下代码的结果是啊?请说你的答案。

var fullname = 'John Doe';
var obj = {
   fullname: 'Colin Ihrig',
   prop: {
      fullname: 'Aurelio De Rosa',
      getFullname: function() {
         return this.fullname;
      }
   }
};

console.log(obj.prop.getFullname());

var test = obj.prop.getFullname;

console.log(test());

答案:

当即段代码打印结果是:Aurelio De Rosa 和 John Doe 。原因是,JavaScript中要字this所引用的是函数上下文,取决于函数是怎调用的,而非是怎受定义之。

当第一独console.log()getFullname()是作为obj.prop目标的函数被调用。因此,当前底上下文指代后者,并且函数返回这个目标的fullname属性。相反,当getFullname()为赋值给test变量时,当前底上下文是大局对象window,这是盖test受隐式地看成全局对象的特性。基于这一点,函数返回windowfullname,在本例中即使为率先尽代码设置的。

[完]

11.call() 和 apply()

修复前一个题材,让最终一个console.log() 打印输出Aurelio De Rosa.

答案:

是题目得以经过采用call()或者apply()法强制转换上下文环境。

console.log(test.call(obj.prop));

12.闭包(Closures)

考虑下的代码:

var nodes = document.getElementsByTagName('button');
for (var i = 0; i < nodes.length; i++) {
   nodes[i].addEventListener('click', function() {
      console.log('You clicked element #' + i);
   });
}

试问,如果用户点击第一个和季单按钮的时,控制台分别打印的结果是啊?为什么?

答案:

片涂鸦打印还是nodes.length的价值。

那修复上题的问题,使得点击第一只按钮时输出0,点击第二独按钮时输出1,依此类推。

发多种计可以缓解此题材,下面要利用简单种植艺术解决之题目。

首先单缓解方案以即时执行函数表达式(IIFE)再创一个闭包,从而取得所愿意的i的值。实现这道的代码如下:

var nodes = document.getElementsByTagName('button');
for (var i = 0; i < nodes.length; i++) {
   nodes[i].addEventListener('click', (function(i) {
      return function() {
         console.log('You clicked element #' + i);
      }
   })(i));
}

任何一个缓解方案免采用IIFE,而是以函数移到循环的以外。这种方法由下的代码实现:

function handlerWrapper(i) {
   return function() {
      console.log('You clicked element #' + i);
   }
}

var nodes = document.getElementsByTagName('button');
for (var i = 0; i < nodes.length; i++) {
   nodes[i].addEventListener('click', handlerWrapper(i));
}

代码有一:

var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc : function(){
    return function(){
       return this.name;
    };
   }
  };
alert(object.getNameFunc()());

结果:The Window

代码有二:

var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc : function(){
    var that = this;
    return function(){
      return that.name;
    };
  }
};

alert(object.getNameFunc()()); 

结果:My Object

文章地址:http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html

 

13.数据类型问题

 

考虑如下代码:

 

console.log(typeof null);
console.log(typeof {});
console.log(typeof []);
console.log(typeof undefined);

 

答案:

 

object
object
object
undefined

 

14.轩然大波循环

 

下代码运行结果是啊?请说明。

 

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

 

答案:

 

1
4
3
2

 

相思明白为何输出顺序是这般的,你得为了解setTimeout()召开了哟,以及浏览器的波循环规律。浏览器有一个风波循环用于检查事件队列,处理延迟的事件。UI事件(例如,点击,滚动等),Ajax回调,以及供于setTimeout()setInterval()的回调都见面挨个给事件循环处理。因此,当调用setTimeout()函数时,即使延迟的辰给设置为0,提供的回调也会见叫排队。回调会瞠目结舌在排中,直到指定的工夫之所以了晚,引擎起实施动作(如果它在目前未执行外的动作)。因此,即使setTimeout()回调被推0毫秒,它还是会被排队,并且直到函数中另外非延迟的言语为实施了了后来,才见面执行。

 

15.算法题材

 

写一个isPrime()函数,当其为质数时返回true,否则回false

 

答案:

 

自道就是面试中最普遍的问题有。然而,尽管这题材经常出现并且也非常简短,但是于被面试人提供的答案中可知十分好地观望被面试人数的数学和算法水平。

 

先是,
因为JavaScript不同为C或者Java,因此而无可知相信传递来之数据类型。如果面试官没有明显地报告你,你当了解外是否要开输入检查,还是未进行检讨直接写函数。严格上说,应该对函数的输入进行反省。

 

老二接触使铭记:负数不是质数。同样的,1和0也未是,因此,首先测试这些数字。此外,2是质数中绝无仅有的偶数。没有必要就此一个循环往复来验证4,6,8。再则,如果一个数字不可知为2收拾除了,那么它不能够吃4,6,8当整除。因此,你的大循环必须超过了这些数字。如果您测试输入偶数,你的算法将徐2加倍(你测试双倍数字)。可以行使任何一些双重明智的优化手段,我这边用的是适用于多数场面的。例如,如果一个数字不能够给5打点除,它吗无见面给5之翻番整除。所以,没有必要检测10,15,20等等。

 

末一点,你不待检查比输入数字的开方还要大之数字。我感觉到人们会遗留漏掉就一点,并且为未会见因是而得消极的申报。但是,展示起立刻一头的知会叫您额外加分。

 

本若抱有了是题材的背景知识,下面是总以上所有考虑的化解方案:

 

function isPrime(number) {
   // If your browser doesn't support the method Number.isInteger of ECMAScript 6,
   // you can implement your own pretty easily
   if (typeof number !== 'number' || !Number.isInteger(number)) {
      // Alternatively you can throw an error.
      return false;
   }
   if (number < 2) {
      return false;
   }

   if (number === 2) {
      return true;
   } else if (number % 2 === 0) {
      return false;
   }
   var squareRoot = Math.sqrt(number); //平方根,比如Math.sqrt(9)为3
   for(var i = 3; i <= squareRoot; i += 2) {
      if (number % i === 0) {
         return false;
      }
   }
   return true;
}

 

内代码中因故到了Number.isInteger(),该措施是ES6法,用来判定一个值是否为整数。

 

例如:

 

Number.isInteger(25) // true
Number.isInteger(25.0) // true
Number.isInteger(25.1) // false
Number.isInteger("15") // false
Number.isInteger(true) // false

 

亟需注意的是,在JavaScript内部,整数和浮点数是一模一样的存储方法,所以 style=”color: #c7254e; background-color: #f9f2f4;”>25暨 style=”color: #c7254e; background-color: #f9f2f4;”>25.0为视为与一个价。

16.记腾讯一次糟糕的笔试面试更(转)

JS考察

1、基本数据类:undefined、null、String、Number、boolean。
2、有以下简单独函数,定义一个目标要该拥有这点儿单函数属性。

function mobile(){
        return  'mobile';
    }
    function phone(){
        return 'phone';
    }
    var a = {};
    a.mobile = mobile();
    a.phone = phone();
    console.log(a);

3、(考察了对象变量和积聚内存)

 var a = {n:10,m:20};
 var b = a;
 b.n = 30;
 console.log(a.n);
 console.log(b);

结果:

30
Object {n: 30, m: 20}

4、(考察闭包)

var x = 20;
    var a = {
        x : 15,
        fn : function(){
            var x = 30;
            return function(){
                return this.x;
            };
        }
    };
    console.log(a.fn());
    console.log((a.fn())());
    console.log(a.fn()());
    console.log(a.fn()() == (a.fn())());
    console.log(a.fn().call(this));
    console.log(a.fn().call(a));

结果:

1)、function(){return this.x;}
2)、20
3)、20
4)、true
5)、20
6)、15

5、(数组去再项)

var arr = ['a','g','q','d','a','e','q'];
    Array.prototype.unique = function(){
        for(var i = 0; i < this.length; i++){
            for(var j = i+1; j < this.length; j++){
                if(this[i] == this[j]){
                    this.splice(j,1);
                }
            }
        }
        return this;
    };
    console.log(arr.unique());

其一办法有欠缺,比如var arr =
[‘a’,’a’,’a’,’g’,’q’,’d’,’a’,’e’,’q’]; 那么得的结果:[“a”, “a”, “g”, “q”,
“d”,
“e”]。知道原委吧?不明了要查看数组去重的方《JS基础篇–JS实现多次组去还法总结》

6、编写一个函数fn(Number
n),将数字转为大写输出,如输入123,输出一百二十三

function fn(n){
        if(!/^([1-9]\d*)/.test(n)){
            return '非法数据';
        }
        var unit = '千百十亿千百十万千百十个';
        if(n.length > unit.length){
            return '数据过长';
        }
        var newStr = '';
        var nlength = n.length;
        unit = unit.substr(unit.length - nlength);
        for(var i = 0; i < nlength; i++){
            newStr += '零一二三四五六七八九'.charAt(n[i]) + unit.charAt(i);
        }
        newStr = newStr.substr(0,newStr.length-1);
        newStr = newStr.replace(/零(千|百|十)/g,'零').replace(/(零)+/g,'零').replace(/零(亿|万)/g,'$1');
        return newStr;
    }
    console.log(fn('205402002103'));

CSS

1、考察了盒子模型
2、内联元素、块元素
3、css3的贝塞尔曲线(张鑫旭大神的解说)
4、弹性盒子flexbox

概括考察

1、js跨域问题

算法考察

1、有36辆电动赛车与6久跑道,没有计时器的前提下,最少用几不善交锋可以筛选产生最抢的老三部跑车?

2、一面墙,单独工作经常,A花18小时砌好,B花24钟头,C花30时,现A, B,
C的各个轮流砌,每人工作1小时换班,完工经常,B总并涉及了稍稍时?

A. 9小时
B. 8小时
C. 7小时
D. 6小时48分

答案:B,C

原因:

按照A,BC轮流砌,没有征谁先起来。

1/18 + 1/24 + 1/30 = 47/360;

共同完成7钟头:7*47/360 = 329/360,还差31/360;

如果A先砌:则B砌了7小时44分钟。

如果B先砌:则B砌了8小时。

如果C先砌:则B砌了7小时。

17.语义化标签

1)tite与h1的区别

2)b与strong的区别

3)i与em的区别

PS:不要轻视这些开,80%丁报不上来

 

title与h1的区别

概念:title是网站标题,h1是文章主题

用意:title概括网站消息,可以直接告知搜索引擎以及用户之网站是关于什么主题和内容之,是亮在网页Tab栏里的;h1突出文章主题,面对用户,更突出该视觉效果,指向页面主体信息,是展示在网页遭到之。

b与strong的区别

概念:b(bold)是实业标签,用来给文加粗,而strong是逻辑标签,作用是增高字符语气

区分:b标签只是加粗的体制,没有实际意义,常用来表述无强调要要意味的粗体文字,比如文章摘要中的重要性词、评测文章中之产品名称、文章的导言;
而strong表示标签内字符重要,用以强调,其默认格式是加多少,但是可以经过CSS添加样式,使用别的样式强调。

建议:为了顺应CSS3的科班,b应尽量少用要改用strong

i与em的区别

概念:i(italic)是实体标签,用来要字符倾斜,而em(emphasis)是逻辑标签,作用是强调文本内容

区别:i标签只是斜体的体,没有实际意义,常用来发挥无强调要根本意味的斜体,比如生物学名、术语、外来语(比如「de
facto
」这样的英语里常用之拉丁语短语);而em表示标签内字符重要,用以强调,其默认格式是斜体,但是可以通过CSS添加样式

提议:为了契合CSS3的规范,i应竭尽少用而反用em

 

下扩展部分别样的签属性区别:

img中的alt与title属性

alt属性是当你的图纸以某种原因不克加载时在页面显示的提示信息,它会一直出口在原先加载图片的地方

title属性是在你鼠标悬停在拖欠图形及时时展示一个稍微提示,鼠标离开就从来不了,有接触类似jQuery的hover

src与href的区别

概念:href指定网络资源的职位树立链接或者关系,用当link和a等元素上。src将表面资源嵌入至当下签所在位置,如img图片及js脚本等

区别:我们当可替换的元素上采用src,然而把href用于在涉的文档和外部资源中确立一个关系。
浏览器解析src属性时,会搁浅其他资源的下载和处理,直至将该资源加载,编译,执行完毕。
浏览器解析及href的时光会识别该链接内容,对其开展下载不会见告一段落对当下文档的拍卖

18.波绑定相关

addEventListener,第三独参数是用来代表事件是为事件冒泡还是事件捕获这个各位都了解!但是他问的问题是:

我们受一个dom同时绑定两单点击事件,一个于是捕获,一个之所以冒泡,你的话下会执行几不好事件,然后会事先实行冒泡还是捕获!!!

来吧,谁能够说出来。。。。

19.CSS选择器问题

着眼优先级问题,反正会发出不少莫名其妙的变形,比如以style标签写于body后与body前有啊界别,比如同一dom应用多单class其当如何呈现,比如class
a定义颜色吗blue,class
b定义颜色为red,同时使及dom上,dom作何显示。。。

哼吧各位去对吧。。。。。

20.均等段落关于JS中this应用奇葩代码引发的思考

function DemoFunction(){
    this.init = function(){
        var func = (function(va){
        this.va = va;
        return function(){
            va += this.va;
            return va;
        }
        })(function(va1, va2){
            var va3 = va1 + va2; 
            return va1;
        }(1,2));
        console.log(func(20));

        this.func = func;

        console.log(this.func(100));
    }
}
var a = new DemoFunction();
a.init();

结果:

2
NAN

首先我们得生如下几只概念:

  • 尽上下文:每次当控制器转至ECMAScript可实施代码时,即会进一个不过实行上下文,参考文献:深切理解JavaScript系列(11):执行上下文(Execution
    Contexts)

  • this:this的创办是于 “进入实施上下文”
    时创建的,在代码执行过程遭到是不可变的,参考文献:深深了解JavaScript系列(13):This?
    Yes,this!

  • 于实施函数:准确的话应该给:立即调用函数表达式。因为他宣称后虽行,参考文献:深入了解JavaScript系列(4):立即调用的函数表达式

详见说明是段子代码

一律、首先看DemoFunction的构造函数

及时是代码的要,第一重合代码可以减掉为如下:

function DemoFunction(){
    this.init = function(){
        //省略代码....
    }
}

意味着也DemoFunction的实例提供init方法(声明:此处有误导成分,方法应竭尽在原型链接上,也即是prototype上。),对外公开之接口。

其次、在init方法被,再次省略代码如下:

var func = (function(va){
    this.va = va;
    return function(){
        va += this.va;
        return va;
    }
})(/*省略代码...*/);

//省略代码....

方代码介绍:

  • 首先定义了一个即时施行函数,并拿此函数的实行结果赋值给func。

  • 用留意这实施函数中this.va=va这行代码,由于当下执行函数没有调用者,所以于进而实施上下文时,this会被赋值为Global(浏览器被吗window对象)。

  • 再也待专注这实施函数,返回的凡一个匿名函数,也是一个闭包,在这边一定要小心一个问题:this是当上但实行上下文时创建的。

老三、在init方法被,注意如下代码:

var func = (function(va){
    this.va = va;
    return function(){
        va += this.va;
        return va;
    }
})(function(va1, va2){
    var va3 = va1 + va2;
    return va1;
}(1,2));
//省略代码....

va的实际参数是一个自执行匿名函数,这个匿名函数接受了点儿独参数va1,va2,但才回了va1。以这个吧本,那么可以规定va的价为就为1。接着便执行this.va=va这句代码,由于当下this为window,所以参数va的价为赋值到了window的一个深受va的性上。

季、在init方法吃,加上输出语句:

var func = (function(va){
    this.va = va;
    return function(){
        va += this.va;
        return va;
    }
    })(function(va1, va2){
        var va3 = va1 + va2;
        return va1;
    }(1,2));

    console.log(func(20));

    this.func = func;
    console.log(this.func(100));
}

结果分析:

  • 第一独console.log输出的凡func(20),这里一定要顾调用者是不曾实际指定的,此时默认的饶是Global(也不怕是widnow对象),因此输出为:2

  • 仲单console.log输出的凡this.func(100),可以观看this.func与func是依赖为同一个函数的援,但此刻底调用者则指定为this,也就算是目前目标的实例,因此输出为:NaN。原因:this(当前目标的实例)作为调用者,在func的函数中va
    +=
    this.va这句代码中的this是乘为当前目标的实例,但眼下目标的实例上是未曾va属性的。但是va是有值的,当前值也2了。是盖闭包把va值存到外存中了。那么如何让第二软获得的价为是2啊,结果大粗略,如下:

    function DemoFunction(){

    this.va = 0;
    this.init = function(){
        var func = (function(va){
        this.va = va;
        return function(){
            va += this.va;
            return va;
        }
        })(function(va1, va2){
            var va3 = va1 + va2; 
            return va1;
        }(1,2));
        console.log(func(20));
    
        this.func = func;
    
        console.log(this.func(100));
    }
    

    }
    var a = new DemoFunction();
    a.init();

继往开来面试题逐步丰富

 

相关文章