在js中s90问题

2019-08-05 | 阅读：次

问题1:  如何一次性声明多个变量
问题2:  声明变量时没有赋值, 那么值是多少	undefined
问题3: 重复声明相同的变量名, 有什么反应 f     替换
问题4: 声明变量有几种方式 const let
问题5: 请列举10个关键字,保留字
问题1: 了解ES6 新数据类型
问题1: number 还有哪些常用属性、方法和常用函数 ???(js number 数字类型函数)
问题2: 函数 和 方法有什么区别 ???
js中 string还有哪些常用属性、方法 和 常用函数 ???

思考题1

问题1: ES5 和 ES6 有什么区别?

( 可暂时不做, 后期再来了解 )

ES5 新增内容

use strict使用严格

可以在函数定义的第一行通过一个字符串语法把这个函数声明为 严格模式

function() {
  "use strict";
}

在严格模式下，会有如下一些限制：

未声明的变量赋值直接报错，而不是变成全局变量
函数默认的 this 将变成 undefined 而不是默认指向 window
对只读属性进行写操作，删除不可删除属性，对不可拓展的对象添加属性均会抛出异常
禁止使用 with 语句
重名的属性会报错，重名的函数参数会报错

JSON 支持默认支持 JSON.parse 和 JSON.stringify
对象和属性现在可以对一个对象的属性设置 getter setter:
数组新增方法数组新增了如下常用的方法：

map 地图
every每一个
filter 过滤器
forEach 循环数组或集合中的对象、数据
indexOf 指数
reduce降低
reduceRight 减少权利
some一些

ES6 新增内容

1.块级作用域关键字let, 常量const 2.对象字面量的属性赋值简写（property value shorthand） 3.赋值解构

let singer = { first: "Bob", last: "Dylan" };
let { first: f, last: l } = singer; // 相当于 f = "Bob", l = "Dylan"
let [all, year, month, day] = /^(\d\d\d\d)-(\d\d)-(\d\d)$/.exec("2015-10-25");
let [x, y] = [1, 2, 3]; // x = 1, y = 2

4.函数参数 - 默认值、参数打包、数组展开（Default 、Rest 、Spread） 5.箭头函数 Arrow functions (1).简化了代码形式，默认return表达式结果。 (2).自动绑定语义this，即定义函数时的this。

6.字符串模板 Template strings

7.Iterators（迭代器）+ for..of 迭代器有个next方法，调用会返回： (1).返回迭代对象的一个元素：{ done: false, value: elem } (2).如果已到迭代对象的末端：{ done: true, value: retVal }

8.生成器（Generators） 9.Class Class，有constructor、extends、super，但本质上是语法糖（对语言的功能并没有影响，但是更方便程序员使用）。

10.Modules ES6的内置模块功能借鉴了CommonJS和AMD各自的优点： (1).具有CommonJS的精简语法、唯一导出出口(single exports)和循环依赖(cyclic dependencies)的特点。 (2).类似AMD，支持异步加载和可配置的模块加载。

11.Map + Set + WeakMap + WeakSet 四种集合类型，WeakMap、WeakSet作为属性键的对象如果没有别的变量在引用它们，则会被回收释放掉。

12.Math + Number + String + Array + Object APIs 一些新的API

13.Proxies 使用代理（Proxy）监听对象的操作，然后可以做一些相应事情。

14.Symbols 象征( symbol的名词复数 ) 标志 Symbol是一种基本类型。Symbol 通过调用symbol函数产生，它接收一个可选的名字参数，该函数返回的symbol是唯一的。

15.Promises Promises是处理异步操作的对象，使用了 Promise 对象之后可以用一种链式调用的方式来组织代码，让代码更加直观（类似jQuery的 deferred 对象）。

2 问题1: 如何一次性声明多个变量

问题1: 如何一次性声明多个变量

undefined undefined 23 234 234 234

var s1,s2,s3 = 23
var s4=s5 = s6 = 234
console.log(s1,s2,s3,s4,s5,s6)

解构。就是解析数据的结构。并赋值给变量。

例子1：对象结构。
let {username,sex} = {username:"张三",age:18,sex:'男'}；

    let obj = {username:"张三",age:18,sex:'男'}

    let {username,sex} = obj;//就是一次性声明2个变量。

    console.log(username,sex);//打印  张三 男
    
例子2：赋值数组。
 let [,,a,b] = [1,2,'测试',true,456];//把第3、4个数据赋值给a、b变量。

 

例子3：解构赋值的用法。

当后台传递参数过来的时候，可以只接收某些参数。可以使用下面的方式声明接收函数。

//这里直接接受对象内的属性值。直接解构赋值。
    function test({username,sex}) {
        console.log(username,sex);//打印  张三 男
    }
    test(obj);//调用test方法。

const：用于声明常量。

注意：定义的变量的时候，必须同时初始化，且其值之后不可以修改。

var：最常用的声明变量关键字。

定义的变量的时候，若没有初始化，不报错，会输出undefined。其值之后可以修改。 var可以用来声明全局变量，也可以声明局部变量，依据它们声明的位置：

全局变量：在函数外定义的变量；（注意：若没有使用关键字声明的变量，默认为全局变量。）作用域是整个代码文件。局部变量：在函数内定义的变量。作用域是当前的函数内部。

let：块级;

作用域。在块级{}里面用let定义的变量，离开当前的块{}之后，就不能使用（有点像局部变量，但作用域不一样）。注意：{…}一对花括弧就就是一个特定的代码块，包括直接的{}，流程语句的{}，函数的{},….。函数声明时本身就带有{}，也是属于一个代码块。

var c=11;
{
    let c=12;
    console.log(c);//输出12
}
console.log('代码块外c的值：',c);//输出11

3 问题2: 声明变量时没有赋值, 那么值是多少

undefined

4 问题3: 重复相同的变量名

重复声明相同的变量名, 有什么反应

替换

5 问题4: 声明变量有几种方式

var const let 直接写变量

6 问题5: 请列举10个关键字,保留字

和其他任何编程语言一样，JavaScript 保留了一些关键字为自己所用。

一、JavaScript 所有关键字：

break case catch continue default delete(删除对象（而非构造方法或原型）的某个属性) do else finally for function if in instanceof new return switch this throw try typeof var void while with

打破案件抓住继续

默认删除做其他

最后对于功能如果

在的instanceof 新返回

开关这个扔尝试

类型 VAR 空虚而同

JavaScript 所有保留字

保留字是为以后js的扩展用的，不能作为普通变量名。

abstract boolean byte char class const debugger double enum export extends final float goto implements import int interface long native

package private protected public short static super synchronized throws transient volatile

抽象布尔字节烧焦

类常量调试器双

枚举出口扩展最后

浮动去器物进口

INT 接口长本地人

包私人的保护上市

短静态的超同步

投短暂的挥发物

关键字
abstract	else	instanceof	super	摘要	其他	instanceof	超级
boolean	enum	int	switch	布尔	枚举 int	开关
break	export	interface	synchronized	打破	出口	界面	同步
byte	extends	let	this	字节	延伸	让	这个
case	false	long	throw	案例	错误	长	扔
catch	final	native	throws	抓	最后	本机	抛出
char	finally	new	transient	字符	最后	新	瞬态
class	float	null	true	类	浮动	空	真实
const	for	package	try	const	为	包装	尝试
continue	function	private	typeof	继续	功能	私人	类型
debugger	goto	protected	var	调试器	转到	受保护	var
default	if	public	void	默认值如果	公共	无效
delete	implements	return	volatile	删除	工具	返回	易挥发
do	import	short	while	做	进口	短	当
double	in	static	with	双	在	静态	与

问题6 :带var和不带var区别

声明变量时 ,带var和不带var的区别

var aaa = 11;
function test4(){
    var aaa = 22;
    console.log(aaa);
}
test4();    //22
console.log(aaa);   //11
// 函数内的var aaa声明是内部变量,这时结果是第一个aaa的值.

var abc = 11;
function test4(){
    abc = 22;
    console.log(abc);
}
test4();    //22
console.log(abc);   //22，注意这里

function test4(){
    bbb = 33;
}
test4();
console.log(bbb);   //33

结论1: 函数或者对象构造内声明的变量是私有的. 外部无法访问到. 包括原型继承后的对象.
这就是有var 和没有 var的声明的区别.
结论2: 不加var 在函数或者构造内就是赋值, 从函数内往上一层层寻找变量bbb,一直到顶层没有. 就在顶层声明一个 var bbb;
很可怕假如一个大的项目,在这里改变了bbb的值, 并没有添加var 碰巧整个项目全局变量有个同名bbb被改变,不加var不是只作用在这个函数或对象内. 出了错误很难找.
声明变量改加的就加不能怕麻烦. 结果是完全不同的

7 问题: ES6 新数据类型

了解ES6 新数据类型

ES6的出现,对js的发展会起到很大的作用。对前端的一些功能实现也起到了很大帮助。我们都知道es5 为我们提供了六种数据类型。分别是：

对象（Object）、数字类型（Number）、布尔类型（Boolean）、字符串类型（String）、空类型（Null）、未定义类型（Undefind）

Symbol 类型（基本）他表示独一无二的值。

Set 类型（复杂）

Map 类型（复杂）

WeakSet 类型（复杂）

WeakMap 类型（复杂）

TypedArray 类型（复杂）

这样下来js 就有七种数据类型了。

Symbol是一种特殊的数据类型,其特点为一旦定义了之后就不可更改,故此适合用来作为对象的属性名.使其在上游定义的属性不会再下游被重写和覆盖掉. Symbol()对象是symbol基本类型数据的隐式对象包装器.其相当与String()和string、Number()和number、Boole()和boole. symbol是基本数据类型.

let s = Symbol();
s // Symbol()

内置的Symbol值:

Symbol.hasInstance 对象的Symbol.hasInstance属性，指向一个内部方法。当其他对象使用instanceof运算符，判断是否为该对象的实例时，会调用这个方法。比如，foo instanceof Foo在语言内部，实际调用的是FooSymbol.hasInstance。

Symbol.isConcatSpreadable 对象的Symbol.isConcatSpreadable属性等于一个布尔值，表示该对象使用Array.prototype.concat()时，是否可以展开。

Symbol.species 对象的Symbol.species属性，指向当前对象的构造函数。创造实例时，默认会调用这个方法，即使用这个属性返回的函数当作构造函数，来创造新的实例对象。

Symbol.match 对象的Symbol.match属性，指向一个函数。当执行str.match(myObject)时，如果该属性存在，会调用它，返回该方法的返回值。

Symbol.replace 对象的Symbol.replace属性，指向一个方法，当该对象被String.prototype.replace方法调用时，会返回该方法的返回值。

Symbol.search 对象的Symbol.search属性，指向一个方法，当该对象被String.prototype.search方法调用时，会返回该方法的返回值。

Symbol.split 对象的Symbol.split属性，指向一个方法，当该对象被String.prototype.split方法调用时，会返回该方法的返回值。

Symbol.iterator 对象的Symbol.iterator属性，指向该对象的默认遍历器方法。

Symbol.toPrimitive 对象的Symbol.toPrimitive属性，指向一个方法。该对象被转为原始类型的值时，会调用这个方法，返回该对象对应的原始类型值。

Symbol.toStringTag 对象的Symbol.toStringTag属性，指向一个方法。在该对象上面调用Object.prototype.toString方法时，如果这个属性存在，它的返回值会出现在toString方法返回的字符串之中，表示对象的类型。也就是说，这个属性可以用来定制[object Object]或[object Array]中object后面的那个字符串。

Symbol.unscopables 对象的Symbol.unscopables属性，指向一个对象。该对象指定了使用with关键字时，哪些属性会被with环境排除。

8 问题: number

还有哪些常用属性、方法和常用函数 ???(js number 数字类型函数)

Number方法（整体转换0）:

var a = "+100";
alert( a+100 ); // "100100"
alert(Number(a)); // 100 

var a1="000100";
alert(Number(a1));//100

var a2 = "";
alert( Number(a1) ); // 0

var a3 = "  ";
alert( Number(a1) ); // 0

var a4 = []; //[""]  [123]  ["123"] [1,2,3]
alert( Number(a4) ); // 0  0  123  123  NaN

var a5 = null;
alert( Number(a5) ); // 0

var a6；
alert( Number(a6) ); // NaN

var a7=function(){alert(0)};
alert( Number(a7) ); // NaN

var json={abc:123}
alert( Number(json) ); // NaN

Number 对象方法(方法描述)

toString 把数字转换为字符串，使用指定的基数。 toLocaleString 把数字转换为字符串，使用本地数字格式顺序。 toFixed 把数字转换为字符串，结果的小数点后有指定位数的数字。 toExponential 把对象的值转换为指数计数法。 toPrecision 把数字格式化为指定的长度。 valueOf 返回一个 Number 对象的基本数字值。

Number 对象属性(属性描述) constructor 返回对创建此对象的 Number 函数的引用。 MAX_VALUE 可表示的最大的数。 MIN_VALUE 可表示的最小的数。 NaN 非数字值。 NEGATIVE_INFINITY 负无穷大，溢出时返回该值。 POSITIVE_INFINITY 正无穷大，溢出时返回该值。 prototype 使您有能力向对象添加属性和方法。

9 问题: 函数和方法区别

函数和方法有什么区别

Number()
函数： 函数名（）
方法：对象.方法名（）
属性：对象.属性

the difference

函数（function）是可以执行的javascript代码块，由javascript程序定义或javascript实现预定义。函数可以带有实际参数或者形式参数，用于指定这个函数执行计算要使用的一个或多个值，而且还可以返回值，以表示计算的结果。

　　方法（method）是通过对象调用的javascript函数。也就是说，方法也是函数，只是比较特殊的函数。

假设有一个函数是fn，一个对象是obj，那么就可以定义一个method：

　obj.method = fn;
　obj.method();    //定义之后的调用

函数是可以用函数直接量定义，也就是函数可以直接储存在变量之中，因为函数和字符串、数值一样也是数据类型。

假如储存函数的变量是全局变量，也即是window对象的一个属性。因此，当你调用这个函数时，实际上也是调用window对象的一个方法。所以在函数和方法之间并没有技术上的区别，真正的差别在于设计和目的，

方法是用来对this对象进行操作的，this对象是方法的一个重要属性，当this对象出现在方法主体内部，this值就指向调用该方法的对象。而函数通常是独立的，并不需要经常使用this对象。

function Rect(w, h){    //使用this对象，避免自己调用自己
    this.width = w;
    this.height = h;
}
function area(){
    return this.width * this.height;
}
var r = new Rect(4, 5);
r.area = area;    //将函数赋值给对象的属性，来定义方法

var result = r.area();    //20

问题10: js中 string

属性、方法和常用函数 ???

JavaScript String对象常用方法、属性
length属性
小写转换toLowerCase()
大写转换toUpperCase()
字符串替换replace()
字符串匹配match()
字符串拼接concat()
字符串分割split()
字符串检索indexOf()

问题11: 如何删除数组的值

如何删除数组中的某个值, 有几种方法

11 js中使用splice删除数组中某一项或几项的几种方法

splice(a,b,c) a 是下标定位的位置；

b是从a起，之后b个字母，b= 0 时候，

c 是插入的字符串，数组

js中的splice方法
　　splice(index,len,[item])    注释：该方法会改变原始数组。
splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值
index:数组开始下标        len: 替换/删除的长度       item:替换的值，删除操作的话 item为空
如：arr = ['a','b','c','d']

删除 ----  item不设置
arr.splice(1,1)  
//arr = ['a','c','d']         删除起始下标为1，长度为1的一个值，len设置的1，如果为0，则数组不变

arr.splice(1,2)  
//arr = ['a','d']          删除起始下标为1，长度为2的一个值，len设置的2

替换 ---- item为替换的值

arr.splice(1,1,'ttt')      
//['a','ttt','c','d']         替换起始下标为1，长度为1的一个值为‘ttt’，len设置的1

arr.splice(1,2,'ttt')        
//['a','ttt','d']         替换起始下标为1，长度为2的两个值为‘ttt’，len设置的1

添加 ----  len设置为0，item为添加的值

arr.splice(1,0,'ttt')        //['a','ttt','b','c','d']         表示在下标为1处添加一项‘ttt’

11-2：delete

delete删除掉数组中的元素后，会把该下标出的值置为undefined,数组的长度不会变

var arr = ['a','b','c','d'];
delete arr[1];
arr;  
//["a", undefined × 1, "c", "d"] 中间出现两个逗号，数组长度不变，有一项为undefined
更新2016-11-17：在stackoverflow看到jquery之父John Resig曾经的文章写过的一个代码：



// 跑不了
// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};
下面给出一些实际的用例：

// 移除数组中的第二项
array.remove(1);
// 移除数组中的倒数第二项
array.remove(-2);
// 移除数组中的第二项和第三项（从第二项开始，删除2个元素）
array.remove(1,2);
// 移除数组中的最后一项和倒数第二项（数组中的最后两项）
array.remove(-2,-1);
这个例子跟上面第一个的还是挺相似的，不过没有检查元素的具体项目，而是通过元素在数组的下标位置来定位删除。

问题12: 有哪些常用的数组方法 or 函数???

不改变原数组的方法：

//1.indexOf() 和lastIndexOf()

//1.1 indexOf() : 返回元素在数组的索引，从0开始。若数组不存在该元素，则返回-1。
arr.indexOf(10); //-1


//1.2 lastIndexOf():
//返回元素在数组中最后一次出现的索引，如果没有出现则返回-1.
arr.lastIndexOf(2); // 4


2.slice(): 与字符串的substring()方法一样，截取数组的一部分，返回一个新的数组。
2.1 通常，接受2个参数作为一个左闭右开区间，即包括开始索引位置的元素，但不包括结束索引位置的元素。
var arr = [1, 2, 3,4,5,6];
arr.slice(0,2)    //[1, 2]； 只返回索引0,1位置的元素


2.2 可以省略第二个参数，即截取到原数组的最后一个元素。
arr.slice(2,);    //[3, 4, 5, 6] 


2.3 如果没有传参数，则返回一个从头到尾截取所有元素的新数组。可以用来复制一个数组。
var copyArr = arr.slice();
copyArr;   //[1, 2, 3, 4, 5, 6]


3.concat(): 合并数组。把当前的数组和另一个数组连接起来，并返回一个新的数组。
var a  = copyArr.concat(arr)

3.1 concat()方法的参数可以有多个，也可以任意任意类型，数值、字符串、布尔值、数组、对象 都可以，参数会被被添加到新的数组中。

var arr1 =  [1, 2, 3,4,5,6];
var arr2 = ['a','b','c'];
var arr3 = arr1.concat(arr2);
arr3;   //[1, 2, 3, 4, 5, 6, "a", "b", "c"]


3.2 注意，如果参数是数组, 会被拉平一次，即数组会被拆开来，加入到新的数组中。具体看示例：

var arr1 = [1, 2, 3];
var arr2 = arr1.concat(66,'abc',true,[10,20],[30,[31,32]],{x:100});
arr2;  //[1, 2, 3, 66, "abc", true, 10, 20, 30, [31,32], {x:100}]


4.join(): 转成字符串。它会把当前Array的每个元素都用指定的字符串连接起来，然后返回连接后的字符串。
4.1 参数是用来指定连接的字符串。见示例代码：

var arr = [1, 2, 3];
arr.join('*')   //"1*2*3"


4.2 如果没有指定参数，默认是用,连接。

var arr = [1, 2, 3];
arr.join()   //"1,2,3"

5.toString(): 返回数组的字符串形式

var arr = [1, 2, 3];
arr.toString() // "1,2,3"



6.valueOf():返回数组本身

var arr = [1, 2, 3];
arr.valueOf() // [1, 2, 3]


7.map():

7.1 对数组的所有成员依次调用一个函数，返回值是一个新数组。

var arr = [1, 2, 3];
arr.map(function(elem){
    return elem*2;
});
//[2, 4, 6, 8]
arr; //[1, 2, 3]



7.2 map方法接受一个函数作为参数,该函数调用时，map方法会将其传入3个参数，分别是当前成员、当前位置和数组本身(后2个参数可选)。

arr.map(function(elem, index, arr) {
    return elem * index;
}); 
//[0, 2, 6]


7.3 map方法还可以接受第2个参数，表示回调函数执行时this所指向的对象。

8.forEach(): 与map方法很相似，也是遍历数组的所有成员，执行某种操作。注意：forEach方法一般没有返回值

var arr = [1, 2, 3];
function log(element, index, array) {
    console.log('[' + index + '] = ' + element);
}
arr.forEach(log);
// [0] = 1
// [1] = 2
// [2] = 3
注意: forEach方法无法中断执行，总是会将所有成员遍历完。如果希望符合某种条件时，就中断遍历，要使用for循环。

9.filter():

9.1 筛选数组的元素，返回值是符合筛选条件元素组成的一个新数组。

var arr = [1, 2, 3, 4, 5];
arr.filter(function (elem) {
  return (elem > 3);
});
//[4, 5]
9.2 filter方法接受一个函数作为参数,该函数调用时，fitler方法会将其传入3个参数，分别是当前成员、当前位置和数组本身(后2个参数可选)。

var arr = [1, 2, 3, 4, 5];
arr.filter(function (elem, index, arr) {
  return index % 2 === 1;
});
//[2, 4]
9.3 filter方法还可以接受第2个参数，指定测试函数所在的上下文对象（即this对象）。

10.some()和every(): 类似“断言”（assert），用来判断数组成员是否符合某种条件。

10.1 接受一个函数作为参数，所有数组成员依次执行该函数，返回一个布尔值。该函数接受三个参数，依次是当前位置的成员、当前位置的序号和整个数组。

10.2 some方法是只要有一个数组成员的返回值是true，则整个some方法的返回值就是true，否则false。

var arr = [1, 2, 3, 4];
arr.some(function (elem, index, arr) {
  return elem >= 3;
});
// true
10.3 every方法则是所有数组成员的返回值都是true，才返回true，否则false。

var arr = [1, 2, 3, 4];
arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false
10.4 注意，对于空数组，some方法返回false，every方法返回true

10.5 some和every方法还可以接受第2个参数，用来绑定函数中的this关键字。

11.reduce()和reduceRight(): 依次处理数组的每个成员，最终累计为一个值。

11.1reduce是从左到右处理（从第一个成员到最后一个成员）

arr.reduce(function(x, y){
  console.log(x, y)
  return x + y;
});
// 1 2
// 3 3
// 6
11.2reduceRight则是从右到左处理（从最后一个成员到第一个成员）

arr.reduceRight(function(x, y){
  console.log(x, y)
  return x + y;
});
// 3 2
// 5 1
// 6
改变原数组的方法：
1.push(): 向数组的末尾添加若干元素。返回值是改变后的数组长度。

var arr = [1, 2];
arr.push(3) ;// 3
arr; //  [1, 2, 3]
arr.push('b','c'); //5
arr; //[1, 2, 3, "b", "c"]
arr.push([10,20]); //6
arr; //[1, 2, 3, "b", "c", [10,20]]
2.pop(): 删除数组最后一个元素。返回值是删除的元素。

var arr =[1, 2, 3, "b", "c", [10,20]];
arr.pop(); //[10, 20]
arr;  // [1, 2, 3, "b", "c"]
3.unshift(): 向数组头部添加若干元素。返回值是改变后的数组长度。

var arr = [1, 2];
arr.unshift(3,4 );  //4
arr;  // [3, 4, 1, 2]
4.shift(): 删除数组最后一个元素。返回值是删除的元素。

var arr = ['a', 'b', 1, 2];
arr.shift(); //'a'
arr;  //['b', 1, 2]
5.sort(): 数组排序。

5.1 注意：默认是将所有元素转换成字符串，再按字符串Unicode码点排序。返回值是新的数组。

var arr = [1, 2, 12, 'a', 'b', 'ab', 'A', 'B']
arr.sort();  //[1, 12, 2, "A", "B", "a", "ab", "b"] 注意：12排在了2的前面
5.2 如果元素都是数字，要按从小到大排序，可以传入一个回调函数作为参数。

var arr = [1, 2, 12, 100]

arr.sort(function(a,b){
    return a-b;
});
// [1, 2, 12, 100]
5.3 如果想要从大到小排序：

arr.sort(function(a,b){
    return b-a;
});
//[100, 12, 2, 1]
6.reverse(): 颠倒数组中元素的位置

var arr = [1, 2, 12, 'a', 'b', 'ab', 'A', 'B'];
arr.reverse();
//["B", "A", "ab", "b", "a", 12, 2, 1]
7.splice(): 修改数组元素（新增、删减、替换）。从指定的索引开始删除若干个元素，然后再从该位置添加若干个元素。返回值是删除的元素组成的数组。参数1是删除元素的起始索引，参数2是删除的元素个数，之后的参数为待添加的元素。

7.1 只删除,不添加。可以传入2个参数：

var arr = ['Alibaba', 'Tencent', 'Baidu', 'XiaoMi', '360'];

// 从索引2开始删除3个元素
arr.splice(2, 3); // 返回删除的元素 ['Baidu', 'XiaoMi', '360']
arr; // ['Alibaba', 'Tencent']
7.2 只添加,不删除。第2个参数设为0，即不删除元素。

arr.splice(2, 0, 'Toutiao', 'Meituan', 'Didi'); // 返回[],因为没有删除任何元素
arr; //["Alibaba", "Tencent", "Toutiao", "Meituan", "Didi"]
7.3 先删除若干元素，然后在删除的位置上在添加若干个元素。

var  arr =["Alibaba", "Tencent", "Toutiao", "Meituan", "Didi"]
arr.splice(2,2,'Apple','Google');  //["Toutiao", "Meituan"]
arr; //["Alibaba", "Tencent", "Apple", "Google", "Didi"]
Array.isArray()
用来判断一个值是否为数组, 如果参数为数组，返回true，否则，返回false.

var arr = [1,2]
Array.isArray(arr);  //true;

Array.isArray('a'); //false

问题13: 如何删除对象中的某个属性

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/delete

从对象中真正删除属性的唯一方法是使用删除操作符;将属性设置为undefined或为null只会删除与属性关联的值，而不删除键。下面的输出bar undefined和foo null-仅删除了baz，因此从输出中将其丢失。

var obj = {
    bar: 1,
    foo: 2,
    baz: 3
};
obj.bar = undefined;
obj.foo = null;
delete obj.baz;
 
for(var i in obj) {
    if (obj.hasOwnProperty(i)) {
        console.log(i, '' + obj[i]);
    }
}

//例如有对象

var person={"name": "xiaojiayu", "age": 24, "gender": "man"};
1
///则删除年龄属性age的方法

delete person.age

问题14: 字符串, null, undefined 自动类型转换时会变成什么值

https://juejin.im/post/5a7172d9f265da3e3245cbca

隐式转换中主要涉及到三种转换：

1、将值转为原始值，ToPrimitive()。

2、将值转为数字，ToNumber()。

3、将值转为字符串，ToString()。

const a = {
  i: 1,
  toString: function () {
    return a.i++;
  }
}
if (a == 1 && a == 2 && a == 3) {
  console.log('hello world!');
}

JavaScript25题

写在前面
出题: 邹义良 2019-08-08
不定项选择题，0个或多个，如果没有正确答案，填E

以下说法正确的是____。

A. js是跨平台、面向对象的动态编程语言 
B. js是一种具有函数优先的解释型编程语言   c语言可以传来传去的
C. js是基于原型、多范式的编程语言       
不是基于面向对象的，是原型链的继承考核。函数式执行-面向对象式的编程
D. js的核心语言叫ECMAScript
es5 es6  ecsa这个组织定了这个标准。
   
   
abcd 学习前端框架

以下说法正确的是____。

A. js能运行在浏览器中
B. js能运行在服务端
C. js能绘制出动态图像
D. js具有基于事件循环的并发模型
   
abcd
   
nodejs  
画布-canvas

下面代码运行结果____。

var userName = "jack"
console.log(username)
   
A. 输出:jack
B. 报错:缺少分号
C. 报错: username is not defined
D. 报错: console.log is not a function
   
   
c
知识点。
职业敏感性。--name
js的class不区分大小写。

下面代码运行结果____。

if(true){
    var foo = 1
    let bar = 2
}
   
console.log(foo)
console.log(bar)
   
A. 输出 1 然后报错 bar is not defined
B. 输出 1 2
C. 报错 foo is not defined 然后输出 2
D. 没有输出，只报错 bar is not defined
   
a
var是在函数作用域中生效的，
   
var foo =1 
fun()[{ var foo =2  }
let  es6 限制在这个花阔的 里面， var 是可以到里面去的，let访问的到
   
if也是花阔好{}, 所以访问不到。

下面代码运行结果____。

var a = 1
var a = 2
{
    let a = 3
}
console.log(a)
   
A. Identifier 'a' has already been declared
B. Uncaught SyntaxError: Unexpected identifier
C. 输出2
D. 输出3
   
es6
自闭和的函数：{}  用let
就是做成一个作用域，不污染全局空间。
var a 
var a.这个不会报错，
   
let b 
let b。不会报错，能用代码 ，
花阔好是语句，不是对象。

下面代码运行结果____。

const PI = 3.14
function test(){
    var PI = 3.14159
}
test()
console.log(PI)
   
A. 输出 3.14
B. 输出 3.14159
C. Identifier 'PI' has already been declared
   
var是定义到全局，
但是在函数里面不会改变。所以选择a

下面代码运行结果____。

let foo = 1
const bar = 2
foo = 3
bar = 4
console.log(foo)
console.log(bar)
   
A. 输出 3 4
B. 输出 3 2
C. 输出 1 2
D. 报错 Assignment to constant variable
   
d

下面代码能正确运行的有____。

A. var 姓名 = "张三";       console.log(姓名)
B. var $name = "李四";     console.log($name)
C. var 7niu = "王五";      console.log(7niu)
D. var user-name = "赵六"; console.log(user-name)
   
   
尊严之战。
$ 解块润， 可以单用¥变量,
js  字母 数字 下划线 $ 还支持 中文 繁体 小日本 法文，  
这种表情符号，用excel 是存不进去的  
mysql 都是 uff8m64 字符
   
不能数字开头
ab

下面代码运行结果____。

var foo
console.log(foo)
   
A. null   赋值为空
B. undefined  声明了 但是没赋值；
C. false
D. None
   
   
b

下面代码运行结果____。

var myvar = "foo"
    
function test(){
  console.log(myvar)
  var myvar = "bar"   //变量的声明提前，在同一个作用里面就会比输出提前。
}
test()
    
A. undefined
B. null
C. foo
D. bar
    
    
堆
栈：从上往下压， 
同一个作用域就混乱，所以找不到，
var a = 2
==> var a;
		a = 2
    		
变量都是先声明，再使用
    
a

下面代码在Chrome中运行结果____。

var myvar = "foo";
    
console.log(myvar)
console.log(window.myvar)
console.log(globalThis.myvar)
    
A. foo undefined undefined
B. foo null null
C. foo foo foo
D. foo 
    window.myvar is not defined 
    globalThis.myvar is not defined 
        
语言本身是数据类型：变量 循环 math数学对象。7个核心对象
settimeout console 的宿主 node 浏览器都可以用，mongodb也可以运行js。
    
alter数组环境中找，window.alter 
    
window   window.alter 顶层对象，
var a=1 ,全局对象就是 wondow.a =1  ; 如果 是放在函数中，定义定义的都是局部变量。
globathis。 是不论什么环境都是顶层对象，
globa。 顶层对象，放一些无归的，panseInt就在顶层对象中，， 
myvar
    
api 小到一个登陆接口，get post ；java中 函数的调用 也是api
js 可以定义：node  浏览器  手机开发里；浏览器对象模型；提供了环境。
浏览器中定义了很多东西有多高，浏览器都是大家抄的；
    
    
    
宿主环境不同
    
    
    
c

最新的 ECMAScript 标准定义的数据类型，选出正确的____。abd

A. boolean、number
B. null、undefined
C. int、string
D. symbol、object
    
js无int 有number
剩下都是他的数据类型。
    
boo t f
number -1  0 1  0.1 
3/0是正无穷大Infinity  -3/0 -Infinity
abc 转不出的东西是NaN 非数值（not a number）
passInt 是number类型
bigint 不能和int做运算的；
js中是比较完备的数字类型
    
fuction也是对象。
原始数据类型 是7中。
对象： boo num null undef string symbol  bigint
    
    
    
    
symbol符号:成为不相等的，用来做唯一标记的
const u =symbol() 都是调用不同的东西
    
对象是默认就是引用的；
var u = { name :"a"}
var u2 = u 
在内存中都是一个，只是两个名字， 存储在堆中；
go就是结构体，没有对象
c就是指针
php $ 就是饮用传递
数组是拷贝，对象的赋值是用的
    
abd

下面代码运行结果____。

var a = 1
var b = 2
var c = "3"
console.log(a+b+c)
console.log(a+c-b)
    
A. 6   2
B. 123 2
C. 15  11
D. 33  11 
    
    
    
    
d

下面代码运行结果____。

var n = "2"
switch(n){
    case 1:
        console.log("星期一")
    case 2:
        console.log("星期二")
}
    
A. 星期一
B. 星期二
C. 星期一 星期二
D. 什么也不输出
    
    
js是弱类型，但是也是注意数据类型，类型不统一就是什么也不输出
d

下面代码运行结果____。

function test(n){
    try{      
        throw new Error("foo")   //js的反印号解析变量
        console.log(n)
    }catch(e){   
        console.log(e.message)
        return
    }finally{    //无论如何都会执行
        console.log("{$n}")
    }
}
    
test("bar");
    
A. foo {$n}
B. foo bar
C. bar foo
D. bar foo {$n}
    
    
a

下面代码运行结果____。

for(var i=0;i<=3;i++){
    if(i==2){
        continue
    }
    console.log(i)
}
    
A. 0 1
B. 0 1 2
C. 0 1 3
D. 0 2 3
    
continue 跳过当前
break 结束
return函数返回
c

下面代码运行结果____。

var data = ['a','b','c','d']
for(var i in [1,2,3]){
    console.log(data[i])
}
    
A. abc
B. bcd
C. 123
C. 012
    
for ---in 取 0，1，2 取的索引
for ----of 取得1，2，3。  php ：for each  python ：for --in
arr =[ 4,5,4]
结果一样都是
    
a

下面代码运行结果____。

let arr = [3, 5, 7];
arr.foo = "hello";
    
for (let i of arr) {
   console.log(i)
}
    
A. 0 1 2 foo
B. 3 5 7
C. 0 1 2 hello
D. 3 5 7 hello
    
    
    
of 换成 of 就是a
b

下面代码能正确输出3的是____。

let arr = [3, 5, 7];
A. console.log(arr.count)
B. console.log(arr.length)
C. console.log(len(arr))
D. console.log(size(arr))
    
    
b
a无count
解块瑞size

下面代码运行结果____。

let arr = [3, 5, 7];
A. console.log(arr.count)
B. console.log(arr.length)
C. console.log(len(arr))
D. console.log(size(arr))

下面代码运行结果____。

var name = 'mary'
var foo = {
    name:'jack',
    say1: function(){console.log(this.name)}, //是方法
    say2(){console.log(this.name)},  //(){} 就是方法，是等价的
    say3:()=>{console.log(this.name)},  //箭头函数 ，是函数，继承最外层的对象。出现的概率很高。
}
    
foo.say1()
foo.say2()
foo.say3()
    
A. jack mary undefined
B. jack jack jack
C. jack jack mary
D. jack jack undefined
    
    
js set几何 互异 无序 不重复 关注的value值 ，不可以重复的
		php数组的key 就是一个set集合
		python
		并发冲突：全局变量里面， i = 1 1+1=2  1 +1 
    数据库中并发冲突，都会2 ，做100个就是95，并发；如果是set userId就可以解决。
    加锁，还在用，不能读；别并发变成串形化
    
redis
    
let
算法很重要
    
    
怎么看是不是js es6
setIncate(function test(){  this })  //函数是对象，7种数据类型，剩下都是对象object
<==>setT（ ()=>{} ）
不等价；箭头函数无this ， 自己无this ，如果有就是继承过来的。
    
    
ajax
name = jaek
hi(){
    
var _this = this  //加这个
$get（URL，function(res){
setmeout(fuction{
    
_this.name =res //z这句不行
}
)}
}
    
    
==》指向外层对象的时候，我们用箭头函数，上面就是window
name = jaek
hi(){
$get(url ,res=>)
    
    
最外层是个大的对象。
答案：c

下面代码运行结果____。

var a = "b"
var user = {
    a,
    [a]:"c",
    "c":"d"
}
console.log(user.a)
console.log(user.b)
console.log(user.c)
console.log(user[a])
console.log(user['a'])
    
答案：bcdcb
    
    
    
    
var a = "b"
var user = {
    a,   		// 前面是keys：value<=>'name'=name<=>name: name <==>name缩写，属性的缩写；方法的缩写，
    [a]:"c",  [a] //<==>求值 ‘b’= 后面的值“c”
    "c":"d"
}
//console.log(user['a'])
console.log(user.a)  //就直接找  a= ['a'] 加引号就是自变量找a
    
console.log(user.b)
console.log(user.c)
console.log(user[a])  //就是调用求出a ，找b的值
    
A. b c d c
B. b undefined d b
C. a undefined d undefined
D. b c d undefined
    
    
a

下面代码运行结果____。

const p1 = new Promise(function (resolve, reject) {
    setTimeout(() => resolve("data1"), 2000)   //2s
})
    
const p2 = new Promise(function (resolve, reject) {
    setTimeout(() => reject(new Error('fail')), 1000)  //1s
})
    
Promise.all([p1, p2]).then(result => {
    console.log(result[0])				//自动对应上
    console.log(result[1])
}).catch(error => console.log(error.message))
    
A. data1 fail
B. fail data1
C. fail fail
D. fail
    
Promise.all会等待1，2都回来执行。自动等。//自动对应上，他的结果。顺序对应。
任意一个都是执行一次，解决多个异步，多个执行，。Promise.all就是解决这个问题。
Promise.all可以解决很多场景，都类似
    
    
    
a文件
b文件
a+b文件合并
    
希望并发执行；ajax
    
版本一：串形的。
ajax(url,(res)=>{
	ajax(url,(res)=>{
		ajax(url3,(res3)={
				ok
    			
		})
	})
})
    
版本二：
定时器
首先 返回每个阐述结束
set	写一个定时器 然后进行循环结束这个定时器，进行 ajax3
    
版本三：
    
    
    
d

下面代码能正确将该div的类名改为active的是____。

<div id="foo" class="invalid">
    
A. document.getElementById('foo').class="active"
B. document.getElementById('foo').className="active"
C. document.getElementById('#foo').className="active"
D. document.getElementById('#foo').class="active"
    
    
    
    
b

下面代码运行结果____。

var f = (function(i){
    console.log(i)
    i++
    return function(i){
        console.log(i)
    }
})
    
f(2)(3)
    
    
    
    
var f = (function(i){
    console.log(i)
      
})(1)
    
    
变形：
var f = (function(i){
    console.log(i)
    i++
    return function(i){console.log(i) }})
    
f(2)(3)
    
    
    
    
两个函数无关系。
A. 2 2
B. 2 3
C. 2 4
D. 3 4
    
b

wangdu

王基权

在js中s90问题

问题1: ES5 和 ES6 有什么区别?

2 问题1: 如何一次性声明多个变量

3 问题2: 声明变量时没有赋值, 那么值是多少

4 问题3: 重复相同的变量名

5 问题4: 声明变量有几种方式

6 问题5: 请列举10个关键字,保留字

问题6 :带var和不带var区别

7 问题: ES6 新数据类型

8 问题: number

9 问题: 函数和方法区别

问题10: js中 string

问题11: 如何删除数组的值

问题12: 有哪些常用的数组方法 or 函数???

问题13: 如何删除对象中的某个属性

问题14: 字符串, null, undefined 自动类型转换时会变成什么值

JavaScript25题

参考文档

问题1: ES5 和 ES6 有什么区别?

2 问题1: 如何一次性声明多个变量

3 问题2: 声明变量时没有赋值, 那么值是多少

4 问题3: 重复相同的变量名

5 问题4: 声明变量有几种方式

6 问题5: 请列举10个关键字,保留字

问题6 :带var和不带var区别

7 问题: ES6 新数据类型

8 问题: number

9 问题: 函数 和 方法区别

问题10: js中 string

问题11: 如何删除数组的值

问题12: 有哪些常用的数组方法 or 函数???

问题13: 如何删除 对象中的某个属性

问题14: 字符串, null, undefined 自动类型转换时会变成什么值

JavaScript25题

参考文档

9 问题: 函数和方法区别

问题13: 如何删除对象中的某个属性