javascript常见知识点整理1

末蓝、 2022-09-21 15:25 266阅读 0赞

1.==和===

  1. false==0;//true
  2. false===0;//false

第一种是==比较，它会自动转换数据类型再比较;

第二种是===比较，它不会自动转换数据类型，如果数据类型不一致，返回false，如果一致，再比较。
2.NaN 与所有其他的值都不相等，包括它自己

  1. NaN===NaN;//false

3.null表示一个空的值，它与0和空字符串都不同，0是一个数值，空字符串表示长度为0的字符串，而null表示为空。
undefined:表示值未定义
4 var声明的是局部变量，没有var则是全局变量

  1. var a=3;//局部变量
  2. a=3;//全局变量

5字符串是不可变的

  1. var s="Test";
  2. s[0]='X';
  3. alert(s);//s仍然是Test

javascript为字符串提供了一些常用的方法，调用这些方法本身不会改变原有字符串的内容，而是返回一个新字符串

  1. toUpperCase:把一个字符串全部变为大写
  2. toLowerCase:把一个字符串全部变为小写
  3. indexOf:会搜索指定字符串出现的位置
  4. substring返回指定索引区间的子串
  5. var s='hello,world';
  6. s.substring(0,5);//从索引0开始到5（不包括5），返回'hello'
  7. s.substring(7);//从索引7开始到结束，返回'world'

6 数组

  1. var arr = [1, 2, 3];
  2. arr.length; // 3
  3. arr.length = 6;
  4. arr; // arr变为[1, 2, 3, undefined, undefined, undefined]
  5. arr.length = 2;
  6. arr; // arr变为[1, 2]

slice()对应的是string的substring()版本，它截取部分元素，然后返回一个新的Array，包括开始的索引，不包括结束的索引。
如果不传递任何参数，它就会从头到尾截取所有元素。

  1. var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
  2. arr.slice(0, 3); // 从索引0开始，到索引3结束，但不包括索引3: ['A', 'B', 'C']
  3. arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']

push用来向array末尾添加若干元素，pop则把数组最后一个元素删除掉。空的数组pop不会报错，返回undefined

unshift用来给数组头部添加若干元素，shift用来把数组的第一个元素删除

  1. var arr = [1, 2];
  2. arr.unshift('A', 'B'); // 返回Array新的长度: 4
  3. arr; // ['A', 'B', 1, 2]
  4. arr.shift(); // 'A'
  5. arr; // ['B', 1, 2]

sort会对当前数组进行排序，它会直接修改当前数组元素位置。

  1. var arr = ['B', 'C', 'A'];
  2. arr.sort();
  3. arr; // ['A', 'B', 'C']

reverse实现数组翻转

  1. var arr = ['one', 'two', 'three'];
  2. arr.reverse(); 
  3. arr; // ['three', 'two', 'one']

splice可以从指定索引开始删除若干元素，然后从该位置添加若干元素。

  1. var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
  2. // 从索引2开始删除3个元素,然后再添加两个元素:
  3. arr.splice(2, 3, 'Google', 'Facebook'); 
  4. arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
  5. // 只删除,不添加:
  6. arr.splice(2, 2); // ['Google', 'Facebook']
  7. arr; // ['Microsoft', 'Apple', 'Oracle']
  8. // 只添加,不删除:
  9. arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因为没有删除任何元素
  10. arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

concat方法把当前Array和另一个Array连接起来，并返回一个新的Array

  1. var arr = ['A', 'B', 'C'];
  2. var added = arr.concat([1, 2, 3]);
  3. added; // ['A', 'B', 'C', 1, 2, 3]
  4. arr; // ['A', 'B', 'C']

并没有改变原来的数组，而是返回了一个新的数组

concat()可以接收任意个元素和Array，并且自动把数组拆开，然后全部添加到新的数组里。

  1. var arr = ['A', 'B', 'C'];
  2. arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

join()方法是一个非常实用的方法，它把当前数组的每个元素都用指定的字符串连接起来，然后返回连接后的字符串

  1. var arr = ['A', 'B', 'C', 1, 2, 3];
  2. arr.join('-'); // 'A-B-C-1-2-3'

7对象
用一个{ }表示对象

  1. var xiaoming={
  2.   name:'xiaoming',
  3.   age:18,
  4.   height:180
  5. };

xiaoming.name; // xiaoming
xiaoming.age; //18

属性名必须是一个有效的变量名。如果属性名包含特殊字符，必须用单引号括起来

  1. var xiaohong={
  2.  name:'小红'，
  3.  'middle-school':'no.1 middle school'
  4. }

访问这个特殊的属性
xiaohong[‘middle-school’]; // ‘No.1 Middle School’
xiaohong[‘name’];// 小红
xiaohong.name; // 小红
xiaohong.age ; //不存在的属性不会报错，返回undefined

可以动态的添加属性和删除属性

  1. var xiaoming = {
  2.     name: '小明'
  3. };
  4. xiaoming.age; // undefined
  5. xiaoming.age = 18; // 新增一个age属性
  6. xiaoming.age; // 18
  7. delete xiaoming.age; // 删除age属性
  8. xiaoming.age; // undefined

判断一个对象是否拥有某个属性：
‘name’ in xiaoming; // true

注意in判断的属性存在，这个属性不一定是xiaoming的，它可能是xiaoming继承到的。

  1. 'toString' in xiaoming;//true

因为toString定义在object对象中，而所有对象最终都会在原型链上指向object，所以xiaoming也有toString属性

判断一个属性是不是对象自身拥有的，而不是继承得到的，可以使用hasOwnProperty()方法

  1. var xiaoming = {
  2.     name: '小明'
  3. };
  4. xiaoming.hasOwnProperty('name'); // true
  5. xiaoming.hasOwnProperty('toString'); // false

8 判断和循环
JavaScript把null、undefined、0、NaN和空字符串”视为false，其他值一概视为true。

  1. var s='123';
  2. if(s.length){ alert('this is a string'); }

for …in…循环可以把一个对象所有属性依次循环出来

  1. var o = {
  2.     name: 'Jack',
  3.     age: 20,
  4.     city: 'Beijing'
  5. };
  6. for (var key in o) {
  7.     alert(key); // 'name', 'age', 'city'
  8. }

要过滤掉对象继承的属性，用hasOwnProperty()实现

  1. var o={
  2.  name:'lwg',
  3.  city:'beijing'
  4. };
  5. for (var key in o){
  6.  if (o.hasOwnProperty(key)){
  7.  alert(key);//'name','city'
  8. }
  9. }

数组的遍历：

  1. var a=['A','B','C'];
  2. for (var i in a){
  3.  alert(i);//0 1 2 输出的是字符串
  4.  alert(a[i]); // A B C
  5. }

注意for..in..对数组的循环得到的是String而不是Number

9 Map和Set

  1. var m=new Map([
  2. ['zhansan',90],
  3. ['lisi' ,80] ,
  4. ['xiaoming',100]
  5. ]);
  6. m.get('lisi');//80

初始化Map需要一个二维数组

  1. var m = new Map(); // 空Map
  2. m.set('Adam', 67); // 添加新的key-value
  3. m.set('Bob', 59);
  4. m.has('Adam'); // 是否存在key 'Adam': true
  5. m.get('Adam'); // 67
  6. m.delete('Adam'); // 删除key 'Adam'
  7. m.get('Adam'); // undefined

由于一个key只能对应一个value，所以多次对一个key放入value，后面的值会把前面的值覆盖掉。

Set也是一组key的组合，但不存储value。由于key不能重复，所以在Set中，没有重复的key。

  1. var s1 = new Set(); // 空Set
  2. var s2 = new Set([1, 2, 3]); // 含1, 2, 3

重复的元素在Set中自动被过滤

  1. var s = new Set([1, 2, 3, 3, '3']);
  2. s; // Set { 1, 2, 3, "3"}

通过add(key)方法可以添加元素到Set中，可以重复添加，但是不会有效果。通过delete(key)方法可以删除元素。

  1. var s = new Set([1, 2, 3]);
  2. s; // Set { 1, 2, 3} s.delete(3);
  3. s; // Set { 1, 2}

通过使用for ..of..遍历map和set

  1. var a = ['A', 'B', 'C'];
  2. var s = new Set(['A', 'B', 'C']);
  3. var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
  4. for (var x of a) { // 遍历Array
  5.     alert(x);
  6. }
  7. for (var x of s) { // 遍历Set
  8.     alert(x);
  9. }
  10. for (var x of m) { // 遍历Map
  11.     alert(x[0] + '=' + x[1]);
  12. }

for..in..的遍历是对象属性名称。一个数组实际也是一个对象，它的每个元素的索引被视为一个属性。手动给数组添加额外的属性后，会出现一些问题

  1. var a = ['A', 'B', 'C'];
  2. a.name = 'Hello';
  3. for (var x in a) {
  4.     alert(x); // '0', '1', '2', 'name'
  5. }

for…in…循环把name包括在内，但Array的length属性却不包括在内。

for..of..循环则完全修复了这些问题，它只循环集合本身的元素

  1. var a=['A','B','C'];
  2. a.name='hello';
  3. for(var x of a){
  4.  alert(x);// A B C
  5. }

然而，更好的方式是直接使用iterable内置的forEach方法，它接收一个函数，每次迭代就自动回调该函数。

发表评论

表情：
评论列表 （有 0 条评论，266人围观）

还没有评论，来说两句吧...

相关阅读