JavaScript

2022-05-11  本文已影响0人  张_何
ES6 和 JavaScript 的关系
var a = 1;
a = 'hello';

var x = 1;
var x; // 这次是无效的
x // 1

但是，如果第二次声明的时候还进行了赋值，则会覆盖掉前面的值。

var x = 1;
var x = 2; //会覆盖前面的值 等同于 var x; x = 2;

console.log(a);
var a = 1;

最后的结果是显示undefined，表示变量a已声明，但还未赋值。

x = 1; <!-- x = 2;
--> x = 3;

上面代码中，只有x = 1会执行，其他的部分都被注释掉了。需要注意的是，-->只有在行首，才会被当成单行注释，否则会当作正常的运算。

var x = 1;

switch (x) {
  case true:
    console.log('x 发生类型转换');
    break;
  default:
    console.log('x 没有发生类型转换');
}

上面代码中，由于变量x没有发生类型转换，所以不会执行case true的情况。这表明，switch语句内部采用的是“严格相等运算符”

top:
  for (var i = 0; i < 3; i++){
    for (var j = 0; j < 3; j++){
      if (i === 1 && j === 1) break top;
      console.log('i=' + i + ', j=' + j);
    }
  }

上面代码为一个双重循环区块，break命令后面加上了top标签（注意，top不用加引号），满足条件时，直接跳出双层循环。如果break语句后面不使用标签，则只能跳出内层循环，进入下一次的外层循环。

top:
  for (var i = 0; i < 3; i++){
    for (var j = 0; j < 3; j++){
      if (i === 1 && j === 1) continue top;
      console.log('i=' + i + ', j=' + j);
    }
  }

上面代码中，continue命令后面有一个标签名，满足条件时，会跳过当前循环，直接进入下一轮外层循环。如果continue语句后面不使用标签，则只能进入下一轮的内层循环。

数据类型

获取变量类型
if (typeof v === "number") {

}
数值
0.1 + 0.2 === 0.3    // false
0.3 / 0.1   // 2.9999999999999996 
(0.3 - 0.2) === (0.2 - 0.1)     // false

-0 === +0 // true
(-0).toString() // '0'
(+0).toString() // '0'
(1 / +0) === (1 / -0) // false ,这是因为除以正零得到+Infinity，除以负零得到-Infinity，这两者是不相等的
NaN
Math.acos(2) // NaN
Math.log(-1) // NaN
Math.sqrt(-1) // NaN
Infinity
与数值相关的全局方法
parseInt('8a') // 8
parseInt('12**') // 12
parseInt('12.34') // 12
parseInt('15e2') // 15
parseInt('15px') // 15

字符串

'Did she say \'Hello\'?'
// "Did she say 'Hello'?"

"Did she say \"Hello\"?"
// "Did she say "Hello"?"

var longString = 'Long \
long \
long \
string';

var s = 'hello';
s[0] // "h"
s[1] // "e"
s[4] // "o"

s[1] = 'a'; // 尝试修改索引值为 1 的字符
s // "hello"

var f\u006F\u006F = 'abc';
foo // "abc"

对象

// key 加不加引号都可以
var obj = {
  foo: 'Hello',
  bar: 'World'
};
// 或
var obj = {
  'foo': 'Hello',
  'bar': 'World'
};
// 如果 key 是数值,会被自动转换为字符串
var obj = {
  1: 'a',
  3.2: 'b',
  1e2: true,
  1e-2: true,
  .234: true,
  0xFF: true
};

var obj = {
  p: 'Hello World'
};
obj.p // "Hello World"
obj['p'] // "Hello World"

var obj = {};
obj.foo = 'Hello';
obj['bar'] = 'World';

var obj = { p: 1 };
'p' in obj // true
'toString' in obj /

var person = { name: '老张' };

for (var key in person) {
  if (person.hasOwnProperty(key)) {
    console.log(key);
  }
}
// name

var obj = {
  p1: 1,
  p2: 2,
};
with (obj) {
  p1 = 4;
  p2 = 5;
}
// 等同于
obj.p1 = 4;
obj.p2 = 5;

函数

function f(a, b) {
  return a;
}

f(1, 2, 3) // 1
f(1) // 1
f()

f.length // 2 , 函数的length属性与实际传入的参数个数无关，只反映函数预期传入的参数个数。

function f(a, b) {
  return a;
}
f( , 1) // SyntaxError: Unexpected token ,(…)
f(undefined, 1) // undefined

var f = function (one) {
  console.log(arguments[0]);
  console.log(arguments[1]);
  console.log(arguments[2]);
}

f(1, 2, 3)
// 1
// 2
// 3

数组

var arr = ['a', 'b', 'c'];
Object.keys(arr)
// ["0", "1", "2"] ,可以看到 arr 的健名是 0、1、2

var a = [1, , 1];
a.length // 3

运算符

布尔运算符
't' && '' // ""
't' && 'f' // "f"
't' && (1 + 2) // 3
'' && 'f' // ""
'' && '' // ""

if (i) {
  doSomething();
}
// 等价于
i && doSomething();

't' || '' // "t"
't' || 'f' // "t"
'' || 'f' // "f"
'' || '' // ""
console
var languages = [
  { name: "JavaScript", fileExtension: ".js" },
  { name: "TypeScript", fileExtension: ".ts" },
  { name: "CoffeeScript", fileExtension: ".coffee" }
];
console.table(languages);

输出为:
(index) name fileExtension
0 "JavaScript" ".js"
1 "TypeScript" ".ts"
2 "CoffeeScript" ".coffee"

Object 对象

Object(value)与new Object(value)两者的语义是不同的，Object(value)表示将value转成一个对象，new Object(value)则表示新生成一个对象，它的值是value

{
  value: 123, // 是该属性的属性值，默认为undefined。
  writable: false, // 表示属性值（value）是否可改变（即是否可写），默认为true
  enumerable: true, // 表示该属性是否可遍历，默认为true。如果设为false，会使得某些操作（比如for...in循环、Object.keys()）跳过该属性。
  configurable: false, // 表示属性的可配置性，默认为true。如果设为false，将阻止某些操作改写属性描述对象，比如无法删除该属性，也不得改变各种元属性（value属性除外）
  get: undefined, // 表示该属性的取值函数（getter），默认为undefined。
  set: undefined // 表示该属性的存值函数（setter），默认为undefined。
}

ES6

ES6 的标签模板字符串
    function test(...args) {
      console.log(args);
    }

通常调用 test 函数时,是通过test("abc","bcd")调用的;
现在还有另一种调用方式就是通过标签模板字符串的方式,比如:

test`aaa`; // 输出 [["aaa"]]
const name = 'zhang';
const age = 18;
test`my name is ${name},age is ${age}`; // 输出[["my name is ", ",age is ", ""],"zhang",18], 这里以插入的${age}结尾, 所以第一个元素多了一个空字符串
上一篇 下一篇

猜你喜欢

热点阅读