转载的部分面试题

一. 输入url后底加载过程

由输入 URL
到页面加载成功的进程被还起了哟

微机网络体系结构

  • 应用层(HTTP、SMTP、FTP、POP3)
  • 运输层(TCP、UDP)
  • 网络层(IP(路由器))
  • 多少链路层(网桥(CSMA/CD、PPP))
  • 物理层(集线器)

1. 查找域名对诺IP地址

当即同一步包括 DNS
具体的查找过程,包括:浏览器缓存->系统缓存->路由于器缓存…
(1) 浏览器搜索自己之 DNS 缓存(维护一摆域名及 IP 地址的对应表);
(2) 搜索操作系统被的 DNS 缓存(维护一布置域名及 IP 地址之对应表);
(3) 搜索操作系统的 hosts 文件( Windows 环境下,维护一张域名和 IP
地址之对应表);
(4) 操作系统将域名发送到 LDNS(本地区域名服务器),LDNS 查询 自己之 DNS
缓存(一般找成功率在 80%
左右),查找成功则归结果,失败则提倡一个迭代 DNS 解析呼吁:

① LDNS 向 Root Name Server (根域名服务器,如
com、net、org等的剖析的甲级域名服务器的地点)发起呼吁,此处,Root Name
Server 返回 com 域的一流域名服务器的地方;

② LDNS 向 com 域的世界级域名服务器发起呼吁,返回 baidu.com
域号称服务器地址;

③ LDNS 向 baidu.com 域名服务器发起呼吁,得到 www.baidu.com 的 IP
地址;

(5) LDNS 将取得的 IP 地址返回给操作系统,同时自己吧拿 IP 地址缓存起来;

(6) 操作系统将 IP 地址返回给浏览器,同时自己吗拿 IP 地址缓存起来;

2. 立连接(TCP的老三不行握手)

(1) 主机为服务器发送一个树连接的要;

(2) 服务器收到请求后发送同意连接的信号;

(3) 主机接到兴连接的信号后,再次朝着服务器发送了认同信号 ;

瞩目:这里的老三差握手中主机两次向服务器发送确认,第二软是为了防范已经失效的接连要报文段传至服务器造成错误。

3. 构建网页

(1) 浏览器根据 URL 内容生成 HTTP
请求,请求被寓呼吁文件的职务、请求文件之计等等;

(2) 服务器收到请求后,会因 HTTP 请求被的内容来控制哪些收获相应的 HTML
文件;

(3) 服务器将得到的 HTML 文件发送给浏览器;

(4) 在浏览器还不曾完全接纳 HTML 文件时虽开渲染、显示网页;

(5) 在履行 HTML
中代码时,根据需要,浏览器会持续要图片、音频、视频、CSS、JS等文件,过程与求
HTML ;

浏览器渲染展示网页过程

  1. HTML代码转化为DOM(DOM Tree)
  2. CSS代码转化成CSSOM(CSS Object Model)
  3. 成DOM和CSSOM,生成一蔸渲染树(包含每个节点的视觉信息)(Render
    Tree)
  4. 变动布局(layout),即将有渲染树的装有节点进行平面合成
  5. 将布局绘制(paint)在屏幕上

4. 断开连接(TCP的季次于挥手)

(1) 主机向服务器发送一个断开连接的呼吁;

(2)
服务器收到请求后发送确认收到请求的信号;(此时服务器可能还有多少而发送至主机)

(3) 服务器向长机发送断开通知;(此时服务器确认没有如于长机发送的数码)

(4)
主机接到断开通知后断开连接并报告一个确认信号,服务器收到确认信号后断开连接;

小心:这里的季涂鸦指挥手中服务器两次等向长机发送信息,第一不成是过来主机已吸收断开的伸手,第二次于是为长机确认是否断开,确保数量传截止。

ECMAScript 1

其三次握手 && 四次挥手


二. 有询问了Common.js吗?

发现就方面的材料十分少啊,都并未入选的比好掌握的。

浅析JS中之模块规范(CommonJS,AMD,CMD)

前者模块化(CommonJs,AMD和CMD)

ECMAScript 2

前端模块化

前端模块化

三. 有询问过React.js吗?

React.js 只是一个视图库

  (1)声明式设计

  (2)高效:通过对DOM的学,最要命限度的滑坡及DOM的互动。

  (3)灵活:可以和曾掌握之框架或库很好之配合。

  (4)JSX:是js语法的壮大,不必然用,但建议就此。

  (5)组件:构建组件,使代码更便于得复用,能够好好地以在充分类别之支出中。

  (6)单为响应的数据流:React实现了一头响应的数据流,从而减少了再度代码,这为是讲了它们怎么比传统数码绑定更简单。

react 通过prop管理组件通信,通过state 驱动视图比较差异进行更新操作

作者:第七页
链接:https://www.zhihu.com/question/39825457/answer/83544390
来源:知乎
著作权归作者所有,转载请联系作者获得授权。

angular 是MV* 框架, react是为此来构建而重复使用的UI组件的,
可以看做是单供工具的library。
react 可以与 angular 的 directive做比较。 这样于的讲话,
react是比angular directive 在组建UI上又powerful的。

作者:空空
链接:https://www.zhihu.com/question/23444167/answer/24957302
来源:知乎
著作权归作者所有,转载请联系作者获得授权。

React.js 初家应明白的 9
项事

React之特点及广大用法

React 入门实例教程

借问 React 和 Angular
各出什么优缺点,各自以符合啊开状况?


四. angular和vue的区别

唉,这个真的太碍事总结了,求评论!!!

Vue拥有类似 Angular 的双向数据绑定,以及近似 React 的杜撰DOM。

ECMAScript 3

angular && vue && react

Vue.js 很好,但会比 Angular 或 React
更好吗?

vue.js与angular,react等框架分析比

浅析angular,react,vue.js
jQuery使用分别


五. less的特点

每次吃讯问到这自不得不想起less中的定义变量,用太久less都忘记了css不能够嵌套,醉了醉了。

  1. 变量
  2. 混合(Mixins)
  3. 嵌套规则
  4. 运算
  5. 函数
  6. 命名空间
  7. 作用域
  8. 注释
  9. 导入(Import)

Less语言特性

sass-vs-less

Sass和Less的区别

sass 与 less
的区分与学习


六. less的原理

实为上,less
包含一拟由定义的语法及一个解析器,用户因这些语法定义自己之体裁规则,这些规则最终见面经解析器,less
把这些体规则编译成浏览器可识别的 css 样式。less 并没裁剪 css
原有的性状,更不是因此来代替 css 的,而是于现有 css 语法的根基及,为 css
加入程序式语言的特性。less 最终需要编译成 css
文件才能够起至样式的效益,我们得以称 less 为 css 样式生成工具。


七. gulp的特点

  1. 采取 gulp.js,你的构建脚论是代码,而休是部署文件;
  2. 应用标准库(node.js standard library)来修脚本;
  3. 插件都很简单,只担负好同样码事-基本上都是 20 行左右底函数;
  4. 任务都因为最好特别的连发数来执行;
  5. Gulp是一个基于流的构建系统,使用代码优于配备的方针。输入/输出(I/O)是依据“流式”的。

作用

  1. Sass、Less编译
  2. Css Js 图片压缩
  3. Css Js 合并
  4. Css Js 内联
  5. Html的include功能
  6. Autoprefixer(自动处理浏览器css前缀)
  7. 自行刷新
  8. 去缓存
  9. Handlebars模板文件的预编译
  10. 雪碧图
  11. ESLint
  12. rem移动端适配方案

旁补偿

  gulp grunt
速度
格式 和node差不多 json套json
操作基于 二进制流 文件

gulp VS grunt

前端工程的构建工具对比 Gulp vs
Grunt

ECMAScript 4

模块化 && 构建

dist是指distribution——分配,分发——发布得的文书夹一般命名dist。

dest则是destination——目的地,终点——用于grunt文件路径相关的配备起,一般会及src配对出现。比如文件减少插件:压缩源(src)文件,生成减少包及(dest)。

作者:峰子
链接:https://www.zhihu.com/question/29199796/answer/82862432
来源:知乎
著作权归作者所有,转载请联系作者获得授权。

常规GruntFile.js && gulpFile.js

  • GruntFile.js

<script>
    module.exports = function(grunt) {
        // 导入模块
        grunt.loadNpmTasks('grunt-contrib-uglify');
        grunt.loadNpmTasks('grunt-contrib-cssmin');
        grunt.loadNpmTasks('grunt-contrib-htmlmin');
        grunt.loadNpmTasks('grunt-contrib-imagemin');
        grunt.loadNpmTasks('grunt-contrib-watch');

        // 配置任务
        grunt.initConfig({
            // js压缩 默认加密压缩
            uglify: { // 主任务名称
                options: { // [配置选项]
                    mangle: false // 是否加密压缩
                },
                a: { // 子任务名称
                    expand: true, // 是否分开压缩
                    src: 'js/*.js',    // 源文件
                    dest: 'build'    // 目标文件 自动创建源文件文件夹
                }
            },
            cssmin: {
                a: {
                    expand: true,
                    src: 'css/*.css',
                    dest: 'build'
                }
            },
            htmlmin: {
                options: {
                    removeComments: true,    // 是否移除注释
                    collapseWhitespace: false    // 是否去掉空白
                },
                a: {
                    src: '*.html',
                    dest: 'build'
                }
            },
            // imagemin: {
            //     a: {
            //         expand: true, //分开执行
            //         cwd: 'images',
            //         src: ['**/*.{png,jpg}'],
            //         dest: 'build/images'
            //     }
            // },
            watch: {
                a: {
                    files: ['*.html', 'css/*.css', 'js/*.js'],
                    tasks: ['cssmin', 'htmlmin', 'uglify']
                }
            }
        });

        // 注册一个默认任务
        grunt.registerTask('default', ['uglify', 'cssmin', 'htmlmin', 'watch']);
    }
</script>
  • gulpfile.js

<script>
    // 导入模块
    var gulp = require('gulp');
    var cssmin = require('gulp-cssmin');
    var uglify = require('gulp-uglify');
    var htmlmin = require('gulp-htmlmin');
    var concat = require('gulp-concat');
    var rename = require('gulp-rename');    // 改名

    // 配置任务
    gulp.task('uglify:css', function() {
        gulp.src('css/*.css')
            .pipe(cssmin())        // 压缩
            .pipe(concat('all.min.css'))    // 合并
            .pipe(gulp.dest('build/css'))    // 输出
    });
    gulp.task('uglify:js', function() {
        gulp.src('js/*.js')
            .pipe(uglify())                    // 压缩
            .pipe(gulp.dest('build/js'))    // 输出
    });
    gulp.task('uglify:html', function() {
        gulp.src('*.html')
            .pipe(htmlmin({                    // 压缩
                collapseWhitespace: true,
                removeComments: true
            }))
            .pipe(gulp.dest('build'))        // 输出
    });

    gulp.watch('*.*', ['uglify:css', 'uglify:js', 'uglify:html']);

    gulp.task('default', ['uglify:css', 'uglify:js', 'uglify:html']);
</script>

<script>
    var gulp = require('gulp');
    var uglify = require('gulp-uglify');
    var clean = require('gulp-clean-css');
    var sass = require('gulp-sass');

    gulp.task('uglify',function(){
        return(
            gulp.src('./src/*.js')
                .pipe(uglify())
                .pipe(gulp.dest('dist'))
        )
    })

    gulp.task('minify-css',function(){
        return (
            gulp.src('./src/*.css')
                .pipe(clean())
                .pipe(gulp.dest('dist'))
        )
    })

    gulp.task('compile-sass',function(){
        return (
            gulp.src('./src/*.scss')
                .pipe(sass().on('error', sass.logError))
                .pipe(gulp.dest('dist'))
        )
    })

    gulp.task('default',function(){
        gulp.watch('./src/*.js',['uglify']);
        gulp.watch('./src/*.css',['minify-css']);
        gulp.watch('./src/*.scss',['compile-sass']);
    })
</script>

八. ajax的原理

  • 在原始的交互方式中,由用户触发一个HTTP请求到服务器,服务器对其开展拍卖后更回到一个初的HTHL页到客户端,
    每当服务器处理客户端提交的乞求时,客户还不得不闲等待,并且即使只有是同差不行有点之竞相、只需要从劳动器端得到充分粗略的一个数码,都设返回一个完好的HTML页,而用户每次都使浪费时间和带动富去再读取整个页面。而用Ajax后用户从感觉上几乎拥有的操作都见面快速响应没有页面重载(白屏)的等候。

  • Ajax的法则简单的话是在用户与服务器之间加了—个中间层(AJAX引擎),通过XmlHttpRequest对象来向服务器发异步请求,从服务器获得多少,然后用javascript来操作DOM而创新页面。使用户操作与服务器响应异步化。这个中最要的等同步就是是从服务器获得请数据。

    • Ajax的进程就关乎JavaScript、XMLHttpRequest和DOM。XMLHttpRequest是ajax的中坚机制,它是于IE5中第一引入的,是相同种植支持异步请求的技术。简单的游说,也尽管是javascript可以马上为服务器提出请求与处理应,而未打断用户。达到无刷新的功效。

每日10单前端知识点:ajax &&
jsonp

ajax过程

  1. 获得ajax
  2. 开拓地址
  3. 发送数据
  4. 接收数据

<script>
 // 1.获得ajax
 if (window.XMLHttpRequest) { //查看当前浏览器XMLHttpRequest是否是全局变量
     var oAjax = new XMLHttpResquest();
 } else {
     var oAjax = new ActiveXObject('Microsoft.XMLHTTP'); //IE6,传入微软参数
 }

 // 2.打开地址
 switch (json.type.toLowerCase()) {
     case 'get':
         oAjax.open('GET', json.url + '?' + jsonToURL(json.data), true); // 提交方式(大写),url,是否异步
         oAjax.send(); // 3.发送数据
         break;
     case 'post':
         oAjax.open('POST', json.url, true);
         oAjax.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
         oAjax.send(jsonToURL(json.data)); // 3.发送数据
         break;
 }

 // 4.接收数据
 oAjax.onreadystatechange = function() { //监控状态
     if (oAjax.readyState == 4) {
         json.complete && json.complete();
         if (oAjax.status >= 200 && oAjax.status < 300 ||
             oAjax.status == 304) {
             json.success && json.success(oAjax.responseText); //执行成功的回调函数, responseText为响应内容
         } else {
             json.error && json.error(oAjax.status); //执行失败的回调函数
         }
     }
 };
</script>

九. 有了解过ES6吧?

哈哈哈,这个后面会写一整篇,敬请期待!

【探秘ES6】系列专栏(一):ES6简介


十. git merge

git merge 和 git rebase
小结


十一. less未指构建转css

自我猜测这道面试题应该吗非给用 lessc ,哈哈哈!

还是求评论,我仅见面lessc和构建转化诶。

甩上gulp构建转化

<script>
    var gulp = require('gulp'),
        less = require('gulp-less');

    gulp.task('testLess', function() {
        gulp.src(['src/less/index.less', 'src/less/detail.less']) //多个文件以数组形式传入
            .pipe(less())
            .pipe(gulp.dest('src/css')); //将会在src/css下生成index.css以及detail.css 
    });

    gulp.task('testWatch', function() {
        gulp.watch('src/**/*.less', ['testLess']); //当所有less文件发生改变时,调用testLess任务
    });
</script>

十二. 冒泡、快排

本条后面呢时有发生相同篇简单的算法篇,敬请期待!

  • 冒泡排序
    老是比相邻之简单独数,如果后一个较前一个略带,换位置。
    时间复杂度:O(n^2)

<script>
    var arr = [3, 1, 4, 6, 5, 7, 2];

    function bubbleSort(arr) {
        for (var i = 0; i < arr.length - 1; i++) {
            for(var j = 0; j < arr.length - 1; j++) {
                if(arr[j + 1] < arr[j]) {
                    var temp;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    console.log(bubbleSort(arr));
</script>
  • 高效排序
    使用二私分效仿,取出中间数,数组每次跟高中级数较,小的放权左边,大之嵌入右边。
    岁月复杂度:O(nlog2(n))

<script>
    var arr = [3, 1, 4, 6, 5, 7, 2];

    function quickSort(arr) {
        if(arr.length == 0) {
            return [];    // 返回空数组
        }

        var cIndex = Math.floor(arr.length / 2);
        var c = arr.splice(cIndex, 1);
        var l = [];
        var r = [];

        for (var i = 0; i < arr.length; i++) {
            if(arr[i] < c) {
                l.push(arr[i]);
            } else {
                r.push(arr[i]);
            }
        }

        return quickSort(l).concat(c, quickSort(r));
    }

    console.log(quickSort(arr));
</script>

十三. promise

Promise对象来以下简单个特性。

  1. 靶的状态不叫外界影响。Promise对象表示一个异步操作,有三种状态:Pending(进行中)、Resolved(已完成,又称
    Fulfilled)和Rejected(已破产)。只有异步操作的结果,可以操纵时是啊一样种植状态,任何其他操作都心有余而力不足转移是状态。这也是Promise这个名字的缘故,它的英语意就是是“承诺”,表示其余手段无法转移。

  2. 一经状态改变,就未见面重新转移,任何时候还足以获这个结果。Promise对象的状态改变,只生一定量栽可能:从Pending变为Resolved和从Pending变为Rejected。只要这片种植情形时有发生,状态就扎实了,不见面再度变了,会一直保持此结果。就算改变就闹了,你再次对Promise对象上加回调函数,也会见就获得这个结果。这与事件(Event)完全两样,事件之特性是,如果你失去了它,再失去监听,是得无顶结果的。

ECMAScript 6入门 –
Promise对象


十四. 性能优化

翔性能优化篇!


十五. js的冒泡(Bubbling Event)和捕获(Capture Event)的区别

js之波冒泡和波捕获详细介绍

  1. 冒泡型事件:事件仍自不过特定的事件目标及最好无特定的风波目标(document对象)的顺序触发。

  2. 捕获型事件(event capturing):事件由太无确切的靶子(document
    对象)开始接触,然后至最纯正(也堪在窗口级别捕获事件,不过要由开发人员特别指定)。

  3. DOM事件流:同时支持少数栽事件模型:捕获型事件与冒泡型事件,但是,捕获型事件先来。两种事件流会触及DOM中之享有目标,从document对象开始,也在document对象了。
    DOM事件模型最与众不同之属性是,文本节点吧点事件(在IE中无会见)。

示例
而一个元素div,它来一个下面元素p。

<div>
  <p>元素</p>
</div>

即有限单元素还绑定了click事件,如果用户点击了p:

  • 事件捕获
    当您采取事件捕获时,父级元素先点,子级元素后点,即div先触发,p后触及。
  • 事件冒泡
    当你下事件冒泡时,子级元素先点,父级元素后点,即p先触发,div后点。

addEventListener函数,它来三单参数,第三只参数若是true,则表示用事件捕获,若是false,则象征以事件冒泡。
IE只支持事件冒泡,不支持事件捕获。

ECMAScript 5

Paste_Image.png

拦冒泡

• 在W3c中,使用stopPropagation()方法
• 在IE下设置cancelBubble = true

于捕获的进程被stopPropagation();后,后面的冒泡过程也非会见时有发生了。

阻拦捕获

阻挡事件之默认行为,例如click <a>晚的跳转
• 在W3c中,使用preventDefault()方法;
• 在IE下设置window.event.returnValue = false;


十六. 频繁组的掉(非reverse)

<script>
    var arr=[1,2,3,4];
    var arr2=[];
    while(arr.length) {
        var num=arr.pop();
        arr2.push(num);
    }
    alert(arr2);
</script>

数组更多利用详见:每天10个前端知识点:数组应用篇


十七. js的Object和其它语言的object的分别

js对象的创建
js对象及java对象的异

面向对象分为基于原型的面向对象和依据模板的面向对象。

  • Java:基于模板的面向对象。

class A
{
   private String name;
   public void fun(){

   }
}

A a = new A();
a.fun();
  • JavaScript:基于原型的面向对象,基于事件之网页脚本语言。

<script>
    function CreateObject() {

    }

    CreateObject.prototype = {
        constructor: CreateObject,  // 可特意声明constructor指向 CreateObject
        name: 'xxx',
        age: '11',
        children: ['aaa', 'bbb'],
        getName: function() {
            return this.name;
        }
    }

    var p = new CreateObject();
    console.log(p.name); // 'xxx'
</script>

十八. js的Element和Node的区别

JavaScript中Element与Node的区别,children与childNodes的区别

  • Element继承了Node类,也就是说Element是Node多种类型中之一模一样栽。
  • children是Element的属性,childNodes是Node的属性

HTML中的Node和Element的区别

  • NODE是对立TREE这种多少结构而言之。TREE就是出于NODE组成。
    node有几个子类型:Element,Text,,Attribute,RootElement,Comment,Namespace等。
  • ELEMENT则是HTML里之概念,是素即标签包含其中属性和内容的完整,是HTML中之数的片段之一。

十九. svn与git的区别

  1. git是分布式的,svn不是。
    git跟svn一样有温馨之集中式版本库或服务器。但git更赞成被给下让分布式模式,克隆版本库后即便没有网络为会commit文件,查看历史版本记录,创建项目分等,等网络还连达Push到服务器端。

  2. git把内容仍首数据方式囤,而svn是以文件。
    备的资源支配体系还是管公文之正负信息隐藏于一个类似.svn,.cvs等的文件夹里。
    git目录是处在你的机及之一个克隆版的版本库,它有着核心版本库上保有的事物,例如标签,分支,版本记录等。

  3. git没有一个大局的版本号,svn有。

  4. git的情节完整性优于svn。
    为git的情存储使用的是SHA-1哈希算法。

  5. git可以产生太个版库,svn只能有一个点名中央版本库。
    当svn中央版本库发生题目经常,所有工作成员都一头瘫痪直到版本库维修结束或者新的版本库设立完成。
    各级一个git都是一个本库,区别是它们是否具活跃目录(Git Working
    Tree)。如果要版本库(例如:置於GitHub的版本库)有问题,工作成员依然可以当团结的本土版本库(local
    repository)提交,等待主要版本库恢复即可。工作成员为足以交到至任何的版本库!


二十. 定时器

旋即是同鸣笔试题,小白就是小白啊,还第一次于见到定时器的老三独参数,还是如此写的。

广义上我们遇到定时器的题目一般是这么的

  • setTimeout

<script>
    for (var i = 0; i < 3; i++) {
        var t = setTimeout(function() {
            console.log(i);  // 2. 输出三次3
        }, 10);
    }
    console.log(i);  // 1. 3
</script>

这次遇到的凡如此的ECMAScript:

巡回只进行有限破

<script>
    for (var i = 1; i < 4; i++) {
        var t = setTimeout(function(i) {
            console.log(i);  // 2. 1  4.2
            console.log(t);  // 3. 3  5.3
            clearTimeout(t);
        }, 10, i);
    }
    console.log(i);  // 1. 4
</script>

于是自己检测了以下变形

巡回只进行有限潮

<script>
    for (var i = 1; i < 4; i++) {
        var t = setTimeout(function(i) {
            console.log(i);  // 2. 2  4. 2
            console.log(t);  // 3. 3  5. 3
            clearTimeout(t);
        }, 10, 2);
    }
    console.log(i);  // 1. 4
</script>

巡回只进行简单不好

<script>
    for (var i = 1; i < 4; i++) {
        var t = setTimeout(function(i) {
            console.log(i);  // 2. 2  4. 2
            console.log(t);  // 3. 3  5. 3
            clearTimeout(t);
        }, 10, 2);
    }
    console.log(i);  // 1. 4
</script>

循环只进行个别不良

<script>
    for (var i = 1; i < 4; i++) {
        var t = setTimeout(function(i, t) {
            console.log(i);  // 2. 2  4. 2
            console.log(t);  // 3. 3  5. 3
            clearTimeout(t);
        }, 10, 2, 3);
    }
    console.log(i);  // 1. 5
</script>

只有这次是循环输出3不善

<script>
    for (var i = 1; i < 4; i++) {
        var t = setTimeout(function(i, t) {
            console.log(i); // 2. 1  4. 2  6. 3
            console.log(t); // 3. undefined  5. 1  7. 2
            clearTimeout(t);
        }, 10, i, t);
    }
    console.log(i); // 1. 5
</script>
  • setInterval

<script>
    for (var i = 0; i < 4; i++) {
        var t = setInterval(function() {
            console.log(i);  // 2. 一直输出4
        }, 10);
    }
    console.log(i);  // 1. 4
</script>

这次遇到的增长这么:

<script>
    for (var i = 0; i < 4; i++) {
        var t = setInterval(function(i, t) {
            console.log(i);  // 2. 0,1,2,3,3,3,...
            clearInterval(t);
        }, 10, i, t);
    }
    console.log(i);  // 1. 4
</script>

乃我开了以下测试

<script>
    for (var i = 1; i < 4; i++) {
        var t = setInterval(function(i, t) {
            console.log(i);  // 2. 2  4. 2  6. 2...
            console.log(t);  // 3. 3  5. 3  7. 3...
            clearInterval(t);
        }, 10, 2, 3);
    }
    console.log(i);  // 1. 4
</script>

<script>
    for (var i = 0; i < 4; i++) {
        var t = setInterval(function(i, t) {
            console.log(i);  // 2. 0  4. 1   6. 2  8. 3  10. 3...
            console.log(t); // 3. undefined  5. 1  7. 2  9. 3  11. 3...
            clearInterval(t);
        }, 10, i, t);
    }
    console.log(i); // 1. 4
</script>