number

//int 整数 
1
//float
0.1
//科学计数法
1.23e4
//八进制、十六进制、二进制 法
0123/0x3f/0b11

重点 0 +0 -0 不一样

1/-0
// -Infinity
1/0
// Infinity
1/+0
// Infinity

NaN 无法表示的数字

0/0
// NaN

string

'你好'
"你好"
`你好`

转义

'it\'s ok '
\' 表示 '
\" 表示 "
\n 表示换行
\r 表示回车
\t 表示 tab 制表符
\\ 表示 \
\uFFFF 表示对应的 Unicode 字符
\xFF 表示前 256 个 Unicode 字符

属性

'123'.length //3个字符串
'\n\t\r'.length //3个字符串
'\\\\\\'.length //3个字符串
''.length //0个字符串
' ',length  //1个字符串，空格也算是一个字符串
<!.......................!>
index 从 0 开始 
let s = 'hello';
 s[5] // undefined，居然不报错
 s[4] // 'o'

bool

真 true 假 false

1>2    // false
3<4 //true

falsy 相当于false 但又不是false的值

undefined null 0 NaN  ''

除了以上值其他都是真的 例如 ‘0’ 是真的

symbol

不常见 笔记无

undefined和null

细节一

如果一个变量声明了，但没有赋值，那么默认值就是 undefined，而不是 null

细节二

如果一个函数，没有写 return，那么默认 return undefined，而不是 null

细节三

前端程序员习惯上，把非对象的空值写为 undefined，把对象的空值写为 null

变量声明

// 旧版变量声明
var a = 1 
// 变量声明
let a = 1 
// 常量声明
const a = 1

let声明

规则

遵循块作用域，即使用范围不能超出 { }

不能重复申明

可以赋值，也可以不赋值

必须先声明再使用，否则报错

全局声明的 let 变量，不会变成 window 的属性

for 循环配合 let 有奇效

for(let i = 1 ;i<5 ;i++){
setTimeout(()=>{console.log(i),0})
}
// 执行如下：
    /*
    1
    2
    3
    4
    */

const声明

跟 let 几乎一样

只有一条不一样：声明时就要赋值，赋值后不能改

name和’name’的区别

name 是变量

值可变，可能是 ‘name’，也可能是 ‘hello’

‘name’ 是字符串常量

常量就是不变量

‘name’ 只能是 ‘name’，不能是其他值

类型转换

// 数字变字符串
String(1)
1+'';
// 字符串变number
Number(n)
n-0
+n
let n = 1
// X 变 变布尔
Boolean(n)
!!1
// X变字符串
String(n)
n.toString()

object

只有对象才有属性

声明对象的语法：

let obj = { 'name': 'frank', 'age': 18 }
let obj = new Object({'name': 'frank'})
console.log({ 'name': 'frank, 'age': 18 })

细节

• 键名是字符串，不是标识符，可以包含任意字符，键名永远是字符串
• 引号可省略，省略之后就只能写标识符
• 就算引号省略了，键名也还是字符串（重要）
• Object.keys(obj) 可以得到 obj 的所有 key

一定要用变量当键名也就是属性名 下面示例：

let obj = { [a] = 'frank'}
let p1 ='name'
let obj = { [p1] : 'frank' }   //这样写，属性名为 'name'

删属性

          let obj = {
            name: 'jack',
            age: 18
        }
        obj.name = undefined
        delete obj.name

undefined 删除属性值

obj.name = undefined
// 打出来如下
{name: undefined, age: 18}

delete 删除属性名和属性值

 delete obj.name
 // 打出来如下
    {age: 18}

delete obj.xxx 或 delete obj['xxx']
// 即可删除 obj 的 xxx 属性
// 请区分「属性值为 undefined」和「不含属性名」
// 不含属性名
'xxx' in obj === false
// 含有属性名，但是值为 undefined
'xxx' in obj && obj.xxx === undefined
// 注意 obj.xxx === undefined
// 不能断定 'xxx' 是否为 obj 的属性 可以用 xxx in obj 来判断是否是xxx的属性

读属性（查看）

     let obj = {
            name: 'jack',
            age: 18,
            sex: '女'
        }
    // 获取所有属性名
       console.log(Object.keys(obj));
    // 获取所有属性值
       console.log( Object.values(obj));
    // 获取所有 属性名和属性值
       console.log(Object.entries(obj));
    // 查看自身+共有属性
       console.dir(obj)
    // 判断一个属性是自身的还是共有的
       obj.hasOwnProperty('toString')
    // 查看单独的属性
        obj.name
        obj['name']
        obj.name === obj['name']
    // 简单来说，这里的 name 是字符串，而不是变量

‘name’ in obj和obj.hasOwnProperty(‘name’) 的区别

我们先创建一个空对象

let obj = {}
然后给他的__proto__添加一个name属性
obj.__proto__.nmae ='123'
现在用  'name' in obj                会得到 true
然后用   obj.hasOwnProperty('name')  会得到 false

上面例子得出：

‘name’ in obj 判断obj中是否有属性’name’时 ，若自身没有，在原型中找到也是返回true。

obj.hasOwnProperty(‘name’) 判断obj是否含有’name’属性时，只有自身有才后悔返回true,不回去原型中找。

写属性（增加/修改）

修改自身属性

    let obj = {
            name: 'jack',
            age: 18,
            sex: '女'
        }
    // 修改单个
    obj['name'] = 'tom'
    obj.name = 'jack'
    // 修改多个
    Object.assign(obj,{sex:20,name:'lisa'})
    // 添加单个
    obj['hubby'] = 'eat'
    obj.hubby = 'eat'
    // 添加多个
    Object.assign(obj,{p1:1,p2:2,p3:3,p4:4})

修改或增加共有属性

// 无法通过自身修改或增加共有属性
          let obj = {},
            obj2 = {}
        obj.toString = 'xxx'

上面创建了 2个 obj 然后在ob上修改了toString为xxx

这个只会修改 obj上的自身属性 不会修改原型 obj 和 obj2 上的属性

如果非要修改或增加原型上的属性就直接去原型上改

Object.prototype.toString = 'xxx'

原型上增加原型

let obj = {}
var common ={'nmae':'jack'}
obj.__proto__ = common

不推荐使用 proto 推荐使用 Object.create

var common ={'nmae':'jack'}
// 给 obj 添加原型
let obj = Object.create(common)
// 给objt添加属性
obj.sex= '女'