美团真题练习

class A {
	String i = "op";
	void func(String s) {
		s = "" + 9;
}
static void test() {
	A a = new A();
	a.func(a.i)
	}
}

问：
变量i,s,a在堆还是栈中？
第8行执行后a.i的值是什么？
考察点：
栈内存
主要用于存储各种基本类型的变量，包括Boolean、Number、String、Undefined、Null、以及对象变量的指针
栈内存主要用于存储各种基本类型的变量，包括Boolean Number String Undefined Null及对象变量的指针
堆内存
主要存储object对象
注意：A是new出来的，存储在堆内存中，对应地址是指针a存的内容，所以a还是在栈内存中

参数传递（考察按值传递）
ECMAScript中所有函数的参数都是按值传递的

题目分析，
isa表示的是基本类型的变量，所以还是存储栈内存中
a是A的一个实例，所以a.i=‘op’，执行a.func(a.i)函数，相当于传入’op’参数，该函数会赋值一个变量，
两个变量是完全独立的，s=‘’+9只是在赋值的变量上执行了，函数体外的a.i没有改变
2

var name ='global
var obj = {
	name:'local'
	foo:function(){
		this.name = 'foo';
}.bind(window)

};
var bar = new obj.foo();
setTimeout(function(){
	console.log(window.name);
},0);
console.log(bar.name);

var bar3=bar2=bar;
bar2.name = 'foo2';
console.log(bar3.name)

考察点：

EventLoop
同步异步不同情况，以及定时器的使用
绑定
不同绑定优先级的问题
引用类型赋值
复杂类型值的赋值是引用赋值，均指向同一个对象

题目分析

‘foo’ //bind 返回的是一个函数，这个函数是绑定在window上的，通过new堆该函数进行了构造，返回了一个新的对象，函数体中的this指向该对象，bind为硬绑定，new绑定的优先级高于硬绑定，
所以this还是绑定在bar上,bar.name = this.name = foo
foo2// var bar3=bar2=bar 复杂类型赋值时引用赋值，bar3 bar2 bar指向的都是同一个对象，所以堆bar进行修改的时候，bar3和bar的内容也会背修改掉，所以bar3.name=bar2.name=foo2
global // setTimeOut 设置了一个定时器，会将回调的执行放在所有事件的末尾执行，不可以插队，所以console.log(window.name)输出的是全局下的name=‘global’

3
请写出如下代码运行后产生的结果，并给出解释，说明结果是如何得出的

setTimeout() => console.log('a'));
Promise.resolv().then(
	() => console.log('b');
).then(
	() => Promise.resolve('c').then(
		(data) => {
			setTimeout(() => console.log('d'));
			console.log('f');
			return data;
}
)

).then(data => console.log(data))

考察点

promise(微任务) 和setTimeout（宏任务）的执行先后顺序

题目分析

执行顺序： Promise —> 其后的(b) —>同步的f

.resolve异步的(c)
.JS执行原理从上到下的(a)
.then() -->setTimeout 异步的

需要学习的知识点

• 宏任务和微任务
  如果函数里面只有一个表达式，可以省略{} 和 return
  如果由多个表达式，则不能省略{} 和return，题目中缺少括号
• 箭头函数的resolve传递的参数作为下一个then的参数

请写出下面的ES6代码编译后所生成的ES5代码

class Person {
	constructor (name) {
		this.name = name;
}
greet () {
		console.log(`hi,my name is $(this.name)`);
}
greetDelay (time) {
	setTimeout(() =>{
		console.log(`hi,my name is ${this.name}`)
},time);
}
}

考察点

ES6语法理解，JS原型理解，this指向理解
ES5使用JS原型来进行输出，以及this在window下的定义，需要中间变量传递，
greet() 和greetDelay （） 两个函数其实就是Person原型链下的两个实例函数对象

Var  Person = (function() {
	function Person (name) {
			this._name - name
}
Person.prototype.greet () {
	console.log('hi,my name is +this._name')
}
Person.prototype.greetDelay = function (time) {
	var _this = this;
	setTimeout(function() {
		console.log('hi,my name is "+_name"');
},time)
}

})();

Promise 结合setTimeout

console.log('start')
setTimeout(() => {
console.log('time')
})
Promise.resolve().then(() => {
	console.log('resolve')
})
console.log('end')

输出：
start
end
resolve
time

分析

1. 执行同步代码
   打印start
   设置计时器（setTimeout）,回调函数进入宏任务队列
   执行Promise。resolve.then() ,回调函数是异步函数，进入微任务队列

• setTimeout到底是宏任务还是微任务？？
• 宏任务
  打印end
  检查微任务队列，将其中那个任务放入执行栈执行
  检查宏任务队列，将其中任务放入执行栈中执行

题目二

const promise = new Promise((resolve,reject) => {
	console.log(1);
	setTimeout(() => {
		console.log("timerStart");
		resolve("success");
		console.log(timerEND)
},0);
console.log(2);
})
promise.then((res) => {
	console.log(res);
});
console.log(4)

}

输出
1
2
4
timeStart
timerEND
sucess

题目三

Promise.resolve().then(() => { //定义一个微任务
	console.log('promise1');
	const timer2 = setTimeout(()=> { // 定义一个宏任务
			console.log('timer2)
}，0）
});
const timer1 = setTimeout(() = > {
	console.log('timer1')
	Promise.resolve().then(() => {
		console.log('promise2')
})},0)
console.log('start')

})

}

输出

start
promise1
timer1
promise2
timer2

分析

1 执行同步代码
Promise.resolve.then() 给resolve赋予一个箭头函数，该回调加入本轮微任务队列中，其中的定时器timer2将
加入次轮宏任务队列
给timer1设置一个定时器，回调函数加入本轮宏任务队列，promise.then加入次轮微任务队列
打印start
2 检查微任务队列
第一个promise的解决处理函数被放入执行栈
打印promise1
为timer2添加定时器，回调函数加入本轮宏任务队列
执行栈为空
检查宏任务队列
timer1定时器的回调函数转移道执行栈上
打印timer1
将第二个promise的解决处理函数加入本轮微任务队列
执行栈为空
4 检查微任务队列
一旦微任务队列不为空就需要从宏仁五队列离开去执行微任务，打印promise2
检查宏任务队列
打印timer2

题目来源

http://t.zoukankan.com/liulangbxc-p-15338736.html

美团笔试选择题目2017

如果在activity中对一些资源以及状态进行保存操作，最好在生命周期的那个函数中进行呢？
onPause()
onCreat()
onResume()
onStart()
解析： 在暂停的时候保存，在onpause（）时候保存状态，才能保存用户最终的使用状态