JavaScript 基础笔记

参考书 《JavaScript高级程序设计》 人民出版社

本文章不适合用来基础学习，只用于知识点查阅

文章作者幸苦码出来的，转载请说明出处

一·语言基础

        ES区分大小写

        标识符：变量，函数，属性，函数参数的名字

        注释：

1.单行注释
// 注释内容

2.多行注释
/*
注释内容
*/

二·变量（var let）/常量 （const）

变量类型 变量名称 = 存储的数据

命名规范：

1只能由字母、数字、_（下划线）、$（美元符号）组成。
2不能以数字开头。
3命名中不能出现’-‘ ，不能和关键字冲突。

（一）var关键字 P24

 列举：

var a="abc" //定义字符串值为abc的a变量
a=123 //将a变量改变为数值123（可以，但不推荐直接改变类型）
//不推荐直接赋值改变类型，但是在ECMAscript里是有效的

var作用域：

        函数局部变量

        函数内部定义变量，函数退出时被销毁

a="123" //全局变量，不推荐

var声明提升：

        声明的变量会自动提升到函数作用域顶部

        全局声明下会成为window对象属性

//反复多次声明同一变量没问题（let下不能这样操作）
var a=12;
var a=13;
var a=14;

（二）let关键字 P25

列举：

let a="abc" //定义字符串值为abc的a变量

作用域：

        声明范围是块作用域

//不允许同一块作用域中出现重复声明
let a='123'
let a='312' 
//就会出现报错

暂时性死区：

        let声明变量不会在作用域中提升，在作用域中声明变量就自动“绑定”绑定这区域不受外部作用域的影响。

//外部同名变量就不可用
let a=123;
function a(){
    let a=321;
    console.log(a)
}
a() //321

全局声明：

        let全局作用域不会成为window对象属性(var则会)

var a='123'
console.log(window.a) // '123'
let b='123'
console.log(window.b) // undefined

（三）const关键字 P28

列举：

//声明const常量时必须赋值
//常量：不能改变值
const a='123' //ok
const a; //错误声明

//如果a是对象，就可以改变a属性
const a={
    name:'张三'
}
a.name='老王' //ok

三·数据类型 P30

 typeof操作符

        返回任意变量的数据类型

//用法
    typeof '123'; //String
    typeof 123; //Number

//参数
    Undefined //值未定义
    Boolean //布尔值
    String //字符串
    Number //数值
    Object //对象或null （null认为是一个空对象的引用）
    Function //函数
    Symbol //符号

//PS
//如果typeof未声明的变量，输出为undefined
let b;
typeof a; //undefined
typeof b; //undefined (b没有被赋值，自动为undefined)

（1）undefined

        变量声明了，但是没初始化（没值）

let a;
console.log(a) //undefined

---

（2）null P32

        空对象指针（和undefined的最大区别）

        undefined是null派生而来的

        当为布尔用为假值（false）

---

（3）Boolean(布尔)类型 P33

        两个字面值：  true      false

      使用Boolean()转换布尔值

转换规则:

数据类型               转换为true的值                    转换为false的值
-------------------------------------------------------------------------
Boolean               true                            false
String                非空字符串                        ""（空字符串）
Number                非零数组（包括无穷值）              0，NaN
Object                任意对象                          null
Undefined             （不存在）                        undefined


//例如
Boolean("123") //true
Boolean(null) //false

流控制语会自动布尔值转换 

let a= "123";
if(a){
    console.log("a为true")
}else{
    console.log("a为false")
}

//a为true

---

（4）Number(整数)类型 P33

整数 

八进制

//八进制第一位必须是0
let num=070 //八进制的56
let num2=079 //无效八进制 当初79处理
let num3=08 //无效八进制当成8处理

十六进制：

前缀：0x
后尾为十六进制数字：（0～9，A～F）
例如：
let a=0xA; //10
let b=0x1F; //21

浮点数：

        使用内存空间是存储整数值的两倍

科学计数法： 3.125e7 //3125000.  3.125*10^7

返回Infinity为不能再计算了

NaN: 表示不是数值，数值操作失败了

//isNaN（）函数， 判断是否 不是数值
isNaN(123) //false
isNaN("1231") //false 会转换为1231
isNaN("abc") //ture 不可能转换为数值
isNaN(true) //false 会转换为1

数值转换：P36

        Number()函数  :转为整型

//执行规则
Number(true)  //布尔值  true转1 ，false转0
Number(1) //数值 直接返回
Number(null) //返回0
Number(undefined) //返回NaN
Number("123") //字符串 返回123
//字符串返回规则
包含数值：
Number("1")返回1
Number("001")返回1,忽略前面的0
Number("00.1")返回0.1,忽略前面的0
Number("0xf")返回15，自动将十六进制转换为十进制
空字符串：返回0
上述以外的情况：返回NaN

        parseInt()函数 ：按特殊规则转整数

//执行规则
第一个字符不是数值字符，加号，减号，立即返回NaN，从位置0开始监测
//字符串返回规则
包含数值：
parseInt("F")返回NAN
parseInt("1")返回1
parseInt("12abc")返回12
parseInt("001")返回1,忽略前面的0
parseInt("00.1")返回0,忽略前面的0，检查到.结束转换（自动取整）
parseInt("0xf")返回15，自动将十六进制转换为十进制
空字符串：返回NAN
上述以外的情况：返回NaN


//第二个参数用于指定底数（进制数）
parseInt("10",2) //2，按二进制解析
parseInt("10",8) //8，按八进制解析
parseInt("10",10) //10，按十进制解析
parseInt("10",16) //16，按十六进制解析

        parseFloast()函数 ：解析浮点数

//字符串返回规则
包含数值：
parseFloat("F")返回NAN
parseFloat("1")返回1
parseFloat("12abc")返回12
parseFloat("001")返回1,忽略前面的0
parseFloat("00.1")返回0.1,忽略前面的0
parseFloat("00.1.1")返回0.1,忽略前面的0，只会识别第一个.第二个无效
parseFloat("3.125e7")返回31250000
空字符串：返回NAN

---

（5）String(字符串)类型 P38

三种格式：

let a="内容"
let b='内容'
let c=`内容${1+1}内容` //模版字面量形式，用${...}插值，可写js表达式，解析后强制转字符串

字符字面量 P38

\n   换行
\t   制表
\b   退表
\r   回车
\f   换页
\\   反斜杠(\)
\'   单引号(')
\"   双引号(")
\`   反引号(`)
\xnn  nn表示十六进制编码的字符，x开头，例如 \x41 等于"A"
\unnnn  nnnn表示十六进制编码的Unicode字符，u开头，例如 \u03a3 等于希腊字符 "E"

获取字符串长度 P39

//xx.length获取
let val="abc"
console.log(val.length)//3
console.log(val[0]) //a 取字符串第一个

字符串特点 P40

        ECMAScript中的字符串是不可变的，意思是一旦创建，它们的值就不能变了。
        要修改变量中的字符串值，必须先销毁原始的字符串，再将新字符串保存到该变量中

let lang= "Java" //赋值"Java"字符串
lang = lang + "Script"  //字符串合并
//先分配需要的字符空间，再填充上 "Java"和"Script"组合为JavaScript赋值给lang,最后把原始的Java，Script销毁

转换为字符串

（一）toString() 

//toString() 方法可用于数值、数组、布尔值、对象和字符值
//null和undeined值没有toString()方法

let age=11;
age.toString() //数值转换为字符串"11"

let found=true;
found=toString() //布尔转换为字符串"true"

        toString()传入参数

//传入参数可以得到数值的二进制、八进制、十六进制，或者其他任何有效基数的字符串表示
let num=10
num.toString() //得到字符串"10"
num.toString(2) //得到字符串"1010" 二进制
num.toString(8) //得到字符串"12" 八进制
num.toString(10) //得到字符串"10"
num.toString(16) //得到字符串"a" 有效基数的字符串

（二）String()函数

        也可以转换为字符串，始终返回相应的字符串

String(10) //数值10转字符串,返回"10". 
String(true) //布尔true转字符串,返回"true". 
String(null) //null转字符串,返回"null". 
let value;
String(value) //值undefined转字符串,返回"undefined". 

模版字面量（ES6）

        模版字面量(` `)与单引号、双引号类似，但是多些功能

        严格来讲模版字面量不是字符串，而是一种特殊的JavaScript句法表达式，只不过求值后得到的字符串

//保留换行字符
let value1=`one\ntwo`
console.log(value1) 
//one
//two
----------------------------------
//可以跨行定义字符串
let value2=`one
two`
console.log(value2) 
//one two
------------------------------------
//会保持内部的空格
let value3=`one
            two`
console.log(value3) 
//one            two
----------------------------------------
//内部回车换行和换行符一样
let value4=`
one`
console.log(value4[0]==='\n') 
//true

        模版字面量最常用的特性 字符串插值 ${......}

//字符串插值通过在${}中使用一个JavaScript表达式实现：


//以前字符串插值
let value='abc'
let a='123' + value + '321'
console.log(a) //'123abc321'

//用模版字面量插值
let value='abc'
let a=`123${value}321`
console.log(a) //'123abc321'


/*
    ${}里面可以填任何的JavaScript表达式，包括函数方法
    解析结束后，自动隐式用toString()强制转换为字符串
*/

        模版字面量也支持定义标签函数(tag function)

原始字符串

        使用模版字面量可以获取原始字面量内容（如换行符或Unicode的字符），而不是转译字符

         使用String.raw标签函数显示原内容

//Unicode示例
// \u00A9
console.log(`\u00A9`).  //©
console.log(String.raw`\u00A9`) // "\u00A9"

// \n 换行符
console.log(`\n`).  // ' '
console.log(String.raw`\n`) // "\n"

//实际的换行（回车换行）是不会被转译
console.log(String.raw`a
b`) 
// "a b"


-------------------------------------------

//也可以通过标签函数的第一个参数.raw属性转换（p44）

（6）Symbol(符号)类型（ES6） P44 

特点：

Symbol符号实例是唯一、不可变的
主要用途：确保对象属性使用唯一标识符，不会发生属性冲突危险

简单来讲就是Symbol 可以创建一个独一无二的值（但并不是字符串）

//使用Symbol函数初始化 一个唯一的值
let sym=Symbol();
console.log(typeof sym) //symbol


//可以传入参数，但是参数与符号定义 没任何关系
//传入的参数 相当于注释而已
let sym1=Symbol("a");
let sym2=Symbol("a");
console.log(sym1==sym2) //false

let sym3=Symbol();
let sym4=Symbol();
console.log(sym1==sym2) //false 初始化的符号是唯一的


//标签作为对象属性
let s1=Symbol("name");
let car={
    [s1]:"宝马"
}
console.log(car) //{Symbol("name"):"宝马"}
console.log(car[s1]) //宝马

（7）Object(对象)类型 P56

ECMAScript 中的对象 就是一组数据和功能的集合

简单来讲：

一个对象拥有什么数据和功能,一辆车有什么功能，有什么参数，一个游戏人物有什么参数

//创建新对象

//方法1 构造函数创建
let car=new Object()
let car1=new Object //合法，但不推荐

//方法2 对象字面量创建,可以直接在里面添加属性
let car2={
    name:"宝马"
}
//方法3  (ES5)
let car3=Object.create() //返回新对象

-----------------------------------------------------
//对象里 字符串，整型，数组，方法，对象 都可以为属性
//用点语法给对car象添加属性。obj.xxx=xxx
car.name="宝马"      //给car对象添加属性name，参数为"宝马"
car.run=()=>{console.log("I can fiy")}   //给car对象添加方法run
car.seat={
    seat1:"张三",
    seat2:"张三的老婆",
    seat3:null,
    seat4:null,
} //给car对象添加对象seat，seat对象再添加了4个属性
------------------------------------------------------
//取对象属性值
car.name //返回 "宝马"
//执行car里的run方法
car.run() //返回"I can fiy"
//删除car里的name属性
delete car.name

对象方法

1.合并对象

let obj1={
	a:"1"
}
let obj2={
	b:"2"
}
let obj3={
	c:"3"
}

//（方法一）Object.assign()
Object.assign(obj1,obj2,obj3) //把后面的全部对象合并到第一个，返回第一个对象
console.log(obj1) //{a:"1",b:"2",c:"3"}

//（方法二） {...obj,..obj2} 
obj1={...obj1,...obj2,...obj3} //使用... 把对象展开，合并成新的对象
console.log(obj1) //{a:"1",b:"2",c:"3"}

2.获取对象的键

//Object.keys(obj)
let obj1={
	a:"1",
    b:"2"
}
let val=Object.keys(obj1)
console.log(val) //["1","2"]

3.获取对象的值

//Object.values(obj)
let obj1={
	a:"1",
    b:"2"
}
let val=Object.values(obj1)
console.log(val) //["1","2"]

4.获取对象的键和值

//Object.entries(obj)
let obj1={
	a:"1",
    b:"2"
}
let val=Object.entries(obj1)
console.log(val) //[["a","1"],["b","2"]] 返回二维数组

5.创建新的对象

//Object.create()
let obj1={
	a:"1",
    b:"2"
}
let val=Object.create(obj1) //返回新的对象，如果参数传入对象，就带着原型对象
console.log(val) //新对象 返回{}
console.log(val.__proto__) //使用__proto__指向原型对象 返回{a: '1', b: '2'}

四·操作符

（一）一元操作符 P56

只操作一个值的操作符叫一元操作符

// 递增/递减操作符
let age=29;
console.log(++age) //30
console.log(age++) //29
console.log(--age) //28
console.log(age--) //29

//放前面为先操作符再赋值，放后面为 先赋值再操作符

//一元加和减
//一元加操作符 相当于使用了Number()
let age="123"
age =+age //返回整型 123
//一元减，变成相应负值
let age=true
age= -age //返回整型 0