#第一天知识点 ##1.js的组成 ECMAScript和DOM和BOM三者组成
1.ES定义了js的语法规范 描述了语言的基本语法和数据类型
简单来说js来怎么写需要根据ES的规定
2.DOM(文档对象模型)
有一套成熟的操作DOM节点的API,通过DOM可以操作页面中的元素(其实就是标签)
比如:+div del一个span 修改h1标签的内容
3.BOM (浏览器对象模型)
有一套成熟的操作BOM的API
浏览器跳转 获取浏览器的尺寸与相关信息
##2.js的书写方式
1.行内式
onclick="要执行的js代码" onclick 单击这个标签会触发
不推荐 代码多了 不好维护
2.内嵌式
内嵌式的script标签一般写在body标签的尾部
如果代码量多了,不推荐
3.外联式
目前公司都是外联式,因为公司项目代码量比较大
实例
<button style="width: 100px;height: 100px;background-color: red;"></button> css写法
<button onclick="alert('你好')">按钮</button> js的写法 第一种
<script>
alert('我是内嵌的js')
发现有一个alert弹出框,弹出的内容是小括号里引出引号的包裹内容
</script> 第二种
<script src="02.js"></script> 第三种
##3.js的基本数据类型(面试的时候容易问到)
1. Number 类型 数字类型(100 1.1 0 -6 2000) 都是数字 不区分 整数 浮点数
2. string 类型 字符串 类型: 只要是引号包裹的内容,就是字符串类型(引号不区分单双引号)
3.undefined 类型 他是一个数据,表明未定义变量只定义 不赋值的时候,默认的值就是 undefined表明未定义
4.布尔类型
boolean 类型
只有两个值 true false
true 真 正确
false 假 错误的
5.Null 类型
代表空 是一种数据类型
null和undefined 不同!!!
使用场景:在创建对象的时候 如果开始不知道对象里面有什么,可以给一个null
类似于在创建变量的时候,只定义,不赋值的时候默认是一个为undefined
##4.js的变量与书写
变量是计算机存储数据的一个标识符,通过这个标识符可以找到内存中存储的数据
变量就相当于是一个容器,内部可以存储任意类型的值,使用变量的时候,用的是内部存储的数值
使用变量需要有两步
1.定义变量
语法:var 变量名
2.赋值变量
变量名 = 值
备注:js中 一个等号 叫做赋值号
打印: console.log(要打印的值)
实例
定义变量
var a
var b
var c
赋值变量(暂时只使用数字作为值)
a = 100
b = 200
c = 500
console.log(a)
定义变量与赋值变量的简化
var q = 666
var w = 888
console.log(q)
console.log(w)
##5.js的数据类型的检测
js的数据类型的检测
通过一个方法 去检测 语法-->typeof
typeof(要检测的数据类型的值)除了null以外的值都能检测正确
从而引发下列面试题
##6.面试题2关于typeof不能正确显示null数据类型的原因?
typeof的问题不能检测出null这个类型的实际类型检测出来打印结果为object
因为null的含义为空 空对象 不会把null当作一个对象去输出
##7.变量的命名规则与规范
变量的命名规则与规范
1.规则(必须遵守的,如果不遵守会报错)
在书写变量名的时候 必须由数字 字母 下划线 $符号(英文的)组成,并且不能以数字开头
如: var a a1 a1_ a1_$ 都可
不符合的
var 6qwer = 100 这种写法 开头是数字 不符合命名规则 报错
书写时区分大小写
var a = 100
var A = 100
console.log(a)
console.log(A)
书写变量名时,不能使用关键字或者保留字变成变量名
关键字:js中具有特殊含义的字母组成
var if for function
保留字 在js中没有特殊含义 但在将来的某个版本会用到
在ES6还没出现之前具有的保留字
Let const promise
2.规范(建议遵守,不遵守也不会报错)
变量名具有含义,符合见名知意
尽量不要用字母作为变量名,除非是练习
多个单词的组合时,使用驼峰命名法(多个单词拼写时,后一个单词的首字母大写)
bigbox->bigBox
<div class="big_box"></div> 起名公司常用
8.js的数据类型的转换
js的数据类型的转换
1.转换为数字类型
1.number(数据)
可以用于任何类型,将其转化为数字类型
如果转换为字符串是纯数字组成的.那么直接转化为数字
如果转换为字符串是空字符或者是空白字符串,那么直接转化成数字0
其他类型的字符串(不是 空--空白---纯数字字符串)会转化为NaN
NaN:表示的是一个number的数字,但是没有办法通过常规的数字表明他
2.布尔值转化
true 转化为1
false 转化为0
3.undefined
会直接转化为NaN
4.Null 转数字
会直接转化为0
parseInt(数据)
会将数值类型转化为number类型 并且值是整数 没有四舍五入直接省掉小数点
在转化的时候 如果数据是纯数字串的话,或者是以数字开头的字符串 会显示数字且为整数 其他的全部显示为NaN
parsefloat 转化为小数 除此和parseInt一样的
2.转换为字符串类型
3.转换为布尔类型
#第二天知识点总结 #1.js的数据类型的转换(补充)
2.2.转换为字符串类型
1.变量.toString() 方法
注意 ubndefined 类型和 null 不能使用tostring 方法 js不提供此方法转
2.String(变量) 与上一种方法一样但是全部都能转化 不出在转化报错
3.扩展
变量+ '' 暂时不考虑原理
换结果与string类型相似,更方便简洁,推荐使用
3.转换为布尔类型
1.boolean(变量) 转换为true 或false 数字中非零即真 除了零都是true
2.undefined 和null 都为false (重点 以后会常用,记住)
3.''也为false 其他的字符串都为true 字符串转换为布尔值,只有空字符串会转化为false其他的都会转为true
#2.js的运算符
1.算术运算符
加减乘除 取余(求余数)
+ - * / %
注意:+ 运算符, 相加是两边都是数字,那么会相加
相加时如果两边有一个表示数字的,比如出现一个字符串,那么运行的就是两个值的拼接 只有加法有
其他运算符 在遇到两边有非数字的类型时,会将其为数字(这就叫做隐式转换)转化为数字然后再进行计算 (减法 乘法 除法 取余)
2.赋值运算符
= 例: var a = 1 console.log(a)
+= 相当于是"我自身"加上一个新值可以用 +=来优化 a = a + 10 优化后 a += 10
-= *+ /+ %= 原理一样 原理相同 ------->>>>练习在下面
// var a = 1
// a = a + 10
// console.log(a)
3.比较运算符
比较运算符两边的值之后,返回一个布尔值, 也就是返回一个true或是false
> < >= <=
== 在js中 等号出现两次或者是三次时代表等于的意思
两个等号与三个等号的区别
== 在js中判
断时会做隐式转换.也就是说 只会对比值是否相等 不会对比数据类型
=== 在js中也叫做全等, 在判断中不会做隐式转换,也就是说在做对比值的时候 还会判断数据类型
判断不相等
!= 只会对比值是否相等 不会对比数据类型
!== 做对比值的时候 还会判断数据类型
共同点:
判断符号两边的值是否不相等,不相等时返回true 相等时返回false
不同点
!=不会对比数据类型
!== 会对比数据类型
4.逻辑运算符
&& 逻辑与(相当于 并且的意思)
逻辑与运算符的特性!!!
符号左边的值,如果为真 及为真 那么会返回 符号右边的值
如果为假 也就是转为布尔值为false 那么会将自身返回出去
|| 逻辑或(相当于或者的意思)
逻辑或运算符的特性!!!
符号左边的值,如果为真 那么会将自身返回出去
如果为假,那么符号右侧的值返回出去
! 逻辑非(取反,反义词)
逻辑非运算符的特性!!!
语法 ! 值
返回值:将值转化为布尔值之后,做一个取反的操作,也就是true 改变false false变为true
5.自增自减运算符
++ --两种
++ ----->自增 两种一样
语法: ++值 或 值++
++ 自身的值加一 (自减同理)
++值在前
那么会先将自身的值+1 然后参与其他的
++值在后
那么会先参加与周围的运算,然后将自身的值+1
自减完全相同
#3.if语句的分支使用
一个需求
想法 打开页面 1和2只会执行其中一个,但是我要求这两行代码都要写 ---->需要用js的分支语句完成
分支语句 根据我们设置好的条件 来执行我们要执行的代码
if分支语句 语法:
if (条件) 满足执行 不满足不运行 (为真执行 假不执行)----->返回的为布尔值
####==案例及操作==
if语句 2 if else 嵌套写法
var a = 5
if (a === 3){
console.log(3)
} else if (a === 4){
console.log(4)
} else {
console.log(a) // 最后一个else可以作为容错操作
}
个人练习
var a = 10
if(a === 8){
console.log(8)
} else if( a === 10){
console.log(100)
} else {
console.log(a)
}
判断一个正整数, 是不是偶数, 如果是偶数, 在控制台打印 "偶数", 否则在控制台打印 "不是偶数"
var a = 15
if (a %2 === 0){
console.log('偶数')
} else{
console.log('不是偶数')
}
2.判断一个数字 在10到20之间 不在输出不在此区间
var a = 15
if (a >=10 && a <=20){
console.log('在此区间')
} else {
console.log('不在此区间')
}
console.log(false<1)
成立 true 先判断前面 然后是true true再和20比较 true=1 1<20 所以永远成立
console.log(10 <=200 <= 20)
##4.运算符优先顺序
1.小括号优先级最高
2.一元运算符++ -- !
3.算术运算符 先 * / % 后 + -
4.比较运算符 (大于小于) > >= < < >=
5.比较运算符(等于不等于) == != === !==
6.逻辑运算符 先 && 后 ||
7.赋值运算符
#知识点第三天
##1.swith语句
switch 分支语句 和 if相同 也仍属于条件分支语句
书写方式 : // switch(也要判断的变量){}
switch(要判断的变量) {
case 1:
情况一:
要执行的代码
break;
case :情况二:
要执行的代码
break;
default:
console.log('以上情况都不满足时,我会执行')
}
判断逻辑:判断的变量 是否 === case 上说明的情况
switch...case 在判断时,执行的是全等 也就是 ===
所以数据类型不同时,也不会正确执行
穿透语法 switch 在书写的时候 如果不写 break的话 会出现穿透现象
找到第一个满足的条件时候,开始执行此代码
执行完毕后如果没有break 会继续执行下一个case 直到遇到一个break 或者分支语句全部执行完毕
##2.三元表达式
三元表达式(官方叫法)
别名: 三目表达式 三目运算符 三目 问号冒号表达式
语法: 条件 ? 条件为时执行的代码 : 条件为假时执行的代码
意义:对 if分支语句 做一个简化操作
注意: 不管条件真还是假的代码 都只能写一行!!!
#例题
练习 三目
var a = 10
a > 2
? console.log('输出正确') : console.log('输出错误')
利用三元表达式 给变量赋追
var b = 0
var c = b === 0 ? '女' : '男'
console.log(c)
##3.循环语句
意义:帮助我们去执行 重复的代码
含义 根据给出的某些条件 重复执行一段代码
循环语句
1.初始化
2.条件判断
3.要执行的代码
4.改变自身的(初始化的内容)
1.while 循环
语法 : while (条件){
满足条件时执行的代码
}
#知识点第四天
##1.for 循环
也是循环语句的一种 但是语法和其他的语法不同
for 语法 for (1.初始化; 2.条件; 3.改变自身{4.循环要执行的代码})
(1.初始化,初始化,var a = 1,b = 0; a<=100;a++; 2.条件; 3.改变自身{4.循环要执行的代码})
目前 for 循环的使用场景来看 要稍微多一点 但是不代表 可以完全取代 while 循环或者是do...while 循环
##2.do ... while 循环
do ... while 循环 是一个类似的循环语句
while 循环在开始的时候,会先判断条件是否成立,然后决定是否执行代码
do ... while 循环在开始的第一次的时候 不会判断条件 也就是说 不管条件成功还是失败都执行
##3. 流程控制语句
流程控制语句
通过两个关键字,可以起到控制循环的一个作用,这就是流程控制
1.break
2.continue 跳出当前这一轮循环,直接开始下一轮循环
##4.循环嵌套
for (var a = 0; a < 3;a++){
console.log(a);
}
for (var j =2; j<10; j++){
for (var a = 0; a < 12;a++){
console.log(a);
}
}
#12.23知识点 ##1.函数
概念
首先要明确 和数学中的函数完全不一样
在js中,函数可以理解为 在一段程序(页面上),多次出现的代码段 封装起来的盒子
简单来说 js就是一个盒子 盒子里面装的是 在当前页面 多次出现的较为复杂的代码段
##2.函数的参数
函数的参数如何书写?
书写在function后的小括号里哦参数的作业
如果一个函数没有书写参数 那么这个函数的功能相对单一
如果写了参数 能够使参数更加灵活
参数的书写 分为两个
1.function 后的小括号咯 书写的参数我们叫做"形参"!!!!!
(创建对象)形参的作用: 书写之后 相当于在函数内部创建了一个变量 变量实际的值由实参传递
实参的作用:将自身的值,按照一一对应的关系,传递给形参
##3.函数的返回值 函数的返回值 一个函数只有一个return
js有一个规定 在函数内部创建的变量 只能在函数内部使用
后续会将学习域的时候,了解
如果想在函数外部得到函数内部的一个值的话 可以使用return 这个关键词来使用
##4.函数的使用 函数的使用
1.函数的定义(创建一个盒子)
2.函数的调用(使用盒子内的代码)
3.如果函数只定义,无调用 无意义
1.函数的定义
1.1声明式定义
语法:function fn(){}
function: 关键字--> 表明后续的是一段函数
fn: 函数的名字----> 将来的函数调用的时候需要用到 函数名自定义
(): 内部填写参数 --> 后续详细说
{}: 内部填写的函数调用时要执行的代码段
1.2赋值式定义
语法 : var fn = function(){}
##5.函数参数的注意事项 函数的参数 形参和实参 两个的数量 要一一对应
1.形参的数量如果大于实参
如果形参的数量大于实参的话,一一对应之后 多出来的形参 只定义未赋值 使用值为 undefined
2.如果实参大于形参的话
如果实参大于形参的话 多出来的实参会不显示 因为没接收使用不显示
函数参数的默认值
函数在创建形参的时候,默认给一个值 将来在调用函数的时候
如果没有传递那么这个形参的值也不会是underfined而是给的默认值
##6.声明式和赋值式的区别
声明式和赋值式的区别
1.写法不同
2.调用上略有不同
声明式定义的函数 可以在函数定义前去调用
赋值式函数,不能在函数定义前 去调用
赋值式定义不能在定义前调用的原因
赋值式定义 其实就是声明一个变量 然后给他赋值为一个函数
在js 中 如果在定义变量之前 使用变量的话 那么变量的值为 undefined (变量提升 面试可能会问)
声明式定义函数
fn1()
console.log('我是fn1调用前的函数');
function fn1(){
console.log('我是fn1函数');
}
fn1()
赋值式的函数
fn2()
console.log('我是fn2调用前的函数');
var fn2 = function(){
console.log('我是fn2函数');
}
console.log(fn2); 打印的是fn2 这个变量内部存储的值
console.log(fn2()); 打印了fn2 这个函数的执行结果 一般默认的是undefined 如果修改 以后再说
##第二周知识点
#12.26知识点
##1.函数的预解析
####==面试可能会问==
预解析的一个表现是 声明式函数再定义前可以被调用
预解析是什么 ? (面试题可能会用到!!!!!)
js在执行代码的时候 会有一个所谓的解析阶段
解析阶段 会有函数提升 就是将声明式函数的定影 提升到当前作用域的最顶端
作用域的最顶端
暂时理解为 当前页面的最开始的位置
只是针对声明式函数的
面试题可能会问到
##2.函数的作用域
####==面试可能会问==
什么是作用域? (面试题会问)
就是变量可以起作用的范围
分为两个
1.1全局作用域(直接在 script 内书写的代码)
再此作用域创建的变量 我们叫做全局变量 在当前是script标签内 都可以使用
1.2局部作用域 (在js中 只有函数能够创建局部作用域)
超出这个作用域这个范围就会失效
1.3在js中,全局作用域中有一个提前准备好的对象(一种数据格式,后续会详细的讲解) 这个对象叫做window
我们创建的全局变量 就会自动添加到window中
##3.作用域链
##==作用域链 (面试可能会问 稳定机会大 纯概念的东西)==
3.1作用域链 就是在访问一个变量的时候 如果当前作用域没有会去自己的父级作用域,也就是上一层作用域内查找,如果找到就直接使用,如果没有找到继续向上层查找直到查找到最顶层的全局作用域,如果找到就直接使用 如果没有找到 报错提示变量不存在(未定义)
=====>这种层层向上查找的规律 就叫做作用域链
##递归函数
本质上还是一个函数
当一个函数在函数的内部 调用了自身 那么就算是一个所谓的递归函数(只不过有点小缺陷)
第二天知识点
1.认识对象
什么是对象?
js中是一种数据格式,对象在js中的数据类型数据为:引用数据类型(复杂数据类型)
如何像变量中 存储一个叫做对象的数据呢?
语法1: var obj = {键值对}
键值对-->key:value
如果对象内部有多个键值对, 需要使用逗号隔开
什么是键值对 拿obj为例
a为key 100为对应的value 或者是 a为键 100为对应的值
另一种叫法 a为属性名 100 对应属性值
固定写法:
var obj = {
a : 100,
b : 300,
c : 400
}
console.log(obj);
2.创建对象
两种方式
1.1字面量的形式
var obj = {键值对} 使用频率比较高!!!!
1.2内置构造函数的创建
1.2.1 var obj1 = new Object()创建一个空对象
1.2.2 var obj1 = new Object({a : 1}) 注意 O是大写哦
面试官:js 中创建对象的方式有哪些?
目前是两种
1.字面量的方式
2.内置构造函数的创建
3.对象的操作
换句话说,就是对内部的属性的操作
分为两种
1.点语法 ---------> 用的多!!!!! 但是一些特殊场景中就只能使用中括号法!!!!!!!!
2.中括号语法(数组语法)
4.两种操作语法的差别
一般大部分情况下,点语法与中括号语法,作用相同,怎么选择都可以
特殊情况下我们需要使用中括号语法
1.对象的属性名,有纯数字或者特殊符号,这个时候,就只能使用中括号语法
2.如果涉及变量相关的时候,也需要使用中括
5.创建数组
分两种
1.字面量的方式
语法: var arr = [1,2,3,'e',true,undefined,false]
console.log(arr);
2.内置构造函数的方式
语法1:var arr = new Array() 创建一个空数组
语法2:var arr = new Array(5) 创建一个有长度空数组
语法3:var arr = new Array(1,2,3) 创建一个有内容的空数组
6.认识数组数据类
数组是一种数据类型 他也是属于 引用数据类型(复杂数据类型)
更完善的说法: 数组是存放一些数据的集合
创建一个数组 并在内部存储一个数组
var arr = [1,2,3,'e',true,undefined,false]
console.log(arr);
7.数组的索引
索引 也有人加做 下标
就是一个数据 在这个数组内排列到第几个 位置上
注意:在js中,索引(下标)是从0开始计算的
如果想要获取到数组指定位置的值 可以通过下标来获取
语法:数组名[下标]
var arr = ['a','b','c',1,2]
0 1 2 3 4
console.log(arr);
console.log(arr[0]);
8.数组的leng
数组的length 属性 就是长度的意思
9.for...in遍历对象
对象关于key 的要求 或者是对于属性名的要求 或者是对于键值对的键 的要求
1.推荐使用符合变量命名规则与规范的名字
2.对象的key 也可以使用 纯数字来当作键名(属性名/key)
3.可以使用任何特殊符号(但是需要使用引号包裹)
第一种用的多,其他两种基本不用
10.遍历数组
想办法 拿到数组的每一个成员
想拿到数组的所有成员 需要先想办法拿到数组 的所有下标
规律:所有数组的下标都是从0开始 然后到数组 .length - 1 结束
var arr = ['a','b','c',1,2]
console.log(arr);
for (var i = 0 ; i < arr.length;i++){
console.log(arr[i]);
}
第三天知识点
1.冒泡排序
属于数组排序的算法之一
其实就是提供一种算法 将一个乱序的数组,调整为指定的数组(从大到小)
什么是算法?
解决某一个问题最简单的方式 / 最高效的方式
2.数据类型之间的区别
数据类型之间的区别
数据类型分为两种
1.基本数据类型(简单数据类型)
2.引用数据类型(复杂数据类型)
1.存储
变量的数据存储的地方是内存中 分为两个 栈内存 和堆内存
基本数据类型存储在栈内存中 比如 string number underfinef null boolean
复杂数据类型 将数据本体存放在堆内存中 比如对象或者数组或者函数
然后将指向该内存的地址 存放在数组名或者是对象名或者是函数名中
数组/对象/函数 名 存放在栈内存中
面试官可能会问:数据类型有什么区别
基本数据类型有哪些 然后他们存储的地方是栈内存中
引用数据类型有哪些 然后他们存储在堆内存中 然后变量名存储在位置是 栈内存中
2.赋值
基本数据类型: 赋值以后 两个变量之间没有任何关系 你我分明 赋值后没有任何关系
复杂数据类型: 赋值以后,因为变量内部存储的是指向堆内存的地址,所以在赋值的时候,
是将地址给了另一个变量相当于这两个变量存储的是同一个钥匙
所以在操作其中一个变量的时候会影响另一个变量
3.比较
基本数据类型:简单来说就是值得对比
引用数据类型:比较的时候 比较的是存储地址
4.传参
基本数据类型: 将值拷贝一份传递给形参, 在函数内修改不会影响外界
引用数据类型: 将存储地址赋值给形参, 在函数内修改会影响外界
3.冒泡排序
属于数组排序的算法之一
其实就是算法, 将 一个乱序的数组, 调整为指定顺序的数组(从大到小/从小到大)
什么是算法?
解决某一个问题最简单的方式 / 最高效的方式
常规写法: 后一位 - 前一位 如果 差值 === 2 那么就找出来了
第四天知识点 1.数组的常用方法
var arr = [1, 2, 3]
console.log('原始数组: ', arr)
1. push
语法: 数组.push(数据)
作用: 向数组末尾添加数据
返回值: 追加数据后, 数组最新的长度(length)
var len = arr.push(500)
console.log(len) 4
console.log(arr) [1, 2, 3, 500]
2. pop
语法: 数组.pop()
作用: 删除数组最后一条数据
返回值: 被删除的数据
var po = arr.pop()
console.log(po) 3
console.log(arr) [1, 2]
3. unshift
语法: 数组.unshift(数据)
作用: 向数组开头添加数据
返回值: 添加数据后, 数组最新的长度(length)
var len = arr.unshift(666)
console.log(len) 4
console.log(arr) [666, 1, 2, 3]
4. shift
语法: 数组.shift()
作用: 删除数组第一条数据
返回值: 被删除的数据
var st = arr.shift()
console.log(st) 1
console.log(arr) [2, 3]
5. reverse
语法: 数组.reverse()
作用: 反转数组
返回值: 反转后的数组
var newArr = arr.reverse()
console.log('newArr: ', newArr)
console.log('arr: ', arr)
6. sort
语法1: 数组.sort()
作用: 会将数据转换为 字符串后, 一位一位的对比
语法2: 数组.sort(function (a, b) {return a - b})
作用: 会按照数字大小升序排列
语法3: 数组.sort(function (a, b) {return b - a})
作用: 会按照数字大小降序排列
返回值: 排序后的数组
var arr = [100, 101, 200, 10, '999', 'qwe', '123abc']
console.log('原始数组: ', arr)
var newArr = arr.sort()
console.log('newArr', newArr)
console.log('arr', arr)
var newArr = arr.sort(function (a, b) {return a - b})
console.log('newArr', newArr)
console.log('arr', arr)
var newArr = arr.sort(function (a, b) { return b - a })
console.log('newArr', newArr)
console.log('arr', arr)
7. splice
语法1: 数组.splice(开始索引, 多少个)
作用: 截取数组部分内容
语法2: 数组.splice(开始索引, 多少个, 插入的数据1, 插入的数据2, 插入的数据3...)
作用: 截取数组部分内容, 并插入新的数据
返回值: 截取出来的部分内容 组成的 数组
数组的方法 能够改变原数组的 就只有上边说的 7 个
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log('原始数组: ', arr)
var newArr = arr.splice(3, 4) 从 下标3 开始截取, 截取 4 个 成员/数据
console.log('newArr', newArr) [4, 5, 6, 7]
console.log('arr', arr) [1, 2, 3, 8, 9]
var newArr = arr.splice(2, 3, '数据1', '数据2', '数据3', '数据4', '数据5')
console.log('newArr', newArr)
console.log('arr', arr)
8. slice
语法: 数组.slice(开始索引, 结束索引)
参数:
包前不包后: 包含开始索引位置的数据, 不包含结束索引位置的数据
不写开始索引, 默认是0; 不写 结束索引, 默认是 数组的length
参数支持写负数, 表示倒数第几个, 其实就是 length + 负数
作用: 截取数组部分内容
返回值: 截取出来的部分内容组成的新数组
面试题: 数组中有两个方法, splice 与 slice, 你能描述一下他们两个的区别吗?
1. 参数含义不同, 然后介绍一下 参数哪里不同
2. splice 会改变原数组, 而 slice 不会
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log('原始数组: ', arr)
var newArr = arr.slice(3, 4)
console.log('newArr', newArr) [4]
console.log('arr', arr)
var newArr = arr.slice(5)
console.log(newArr) [6, 7, 8, 9]
9. concat
语法: 原始数组.concat(数组1, 数组2, ...., 数据1, 数据2, ....)
作用: 进行数据拼接, 把数组...数据之类的小括号里的内容, 拼接在原始数组中
返回值: 拼接好的数组
var newArr = arr.concat([4, 5, 6], [10, 20], ['a', 'b', 'c'], 'qwer')
console.log('newArr', newArr)
console.log('arr', arr)
10. join
语法: 数组.join('连接符')
作用: 使用 "连接符", 把数组内的每一个数据连接成一个字符串 (不写连接符, 默认使用的是 逗号)
返回值: 连接好的字符串
var newArr = arr.join() 不传递连接符, 默认使用的是 逗号连接
var newArr = arr.join('!') 使用 ! 将数组内的所有数据拼接成 字符串
console.log(newArr)
11. indexOf
语法1: 数组.indexOf(要检查的数据)
作用: 从前到后(从左到右) 检查该数据第一次在该数组内出现 索引
语法2: 数组.indexOf(要检查的数据, 开始索引)
作用: 在开始索引的位置, 按照从左到右的顺序, 检查该数据第一次在该数组内出现的 索引
返回值: 找到数据的情况下, 会将该数据第一次出现的下标(索引)返回
没找到的情况下, 会直接返回一个 -1
备注: 开始索引不写的时候 默认是0
var num = arr.indexOf(100)
此时要检查的数据是 数字100, 但是数组中没有出现过 数字 100, 所以返回值应该是 -1
var num = arr.indexOf(0)
var num = arr.indexOf(1)
var num = arr.indexOf(1, 3)
console.log(num)
12. lastIndexOf
语法1: 数组.lastIndexOf(要检查的数据)
作用: 从后向前(从右向左), 检查该数据第一次在该数组内出现的 索引
语法2: 数组.lastIndexOf(要检查的数据, 开始索引)
作用: 在开始索引的位置, 按照从右向左的顺序, 检查该数据第一次在该数组内出现的 索引
返回值: 找到数据的情况下, 返回第一次出现的下标(索引)
没找到的情况下, 直接返回一个 -1
var num = arr.lastIndexOf(3)
此时按照从右向左的顺序查找, 发现第一次出现的位置是 下标 5 的位置
var num = arr.lastIndexOf(3, 2)
console.log(num)
2.数组遍历的常用方法
1. forEach
* 语法: 数组.forEach(function (item, index, origin) {})
* item: 数组的每一项 的值
* index: 数组的每一项 对应的下标
* origin: 原始数组 (了解即可, 一般没人用)
* 作用: 遍历数组
* 返回值: 该方法永远没有返回值 (undefined)
2. map
* 语法: 数组.map(function (item, index, origin) {}) 三个参数的意义与 forEach 相同
* 作用: 映射数组
* 返回值: 返回一个和原数组长度相同的数组, 但是内部数据可以经过我们的映射加工
* 映射加工: 就是在函数内 以 return 的形式书写
有一道面试题: 数组常用的遍历方法中, 有一个forEach 和 一个 map, 这两个方法有什么区别?
1. forEach 的作用是用来遍历数组, 而 map 的作用是用来映射数组
2. forEach 没有返回值, 而 map 是可以有返回值的
3. filter
* 语法: 数组.filter(function (item, index, origin) {}) 三个参数的意义与 forEach 相同
* 作用: 过滤数组
* 返回值: 返回一个新数组, 内部存储的是原始数组过滤出来的部分内容
* 过滤条件: 过滤条件以 return 的形式书写
4. find
* 语法: 数组.find(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
* 作用: 在数组内查找满足条件的第一项
* 返回值: 找到的数据, 如果没找到返回的是 undefined
* 查找条件以 return 的形式书写
5. findIndex
* 语法: 数组.findIndex(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
* 作用: 在数组内查找满足条件的第一项 的下标
* 返回值: 找到的数据 的下标, 如果没找到返回的是 -1
* 查找条件以 return 的形式书写
6. some
* 语法: 数组.some(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
* 作用: 判断数组内是否有一个满足条件
* 返回值: 一个布尔值 true/false
* 判断条件以 return 的形式书写
7. every
* 语法: 数组.every(function (item, index, origin) {}) 三个参数的意义 与 forEach 相同
* 作用: 判断数组内是否全都满足条件
* 返回值: 一个布尔值 true/false
* 判断条件以 return 的形式书写
8. reduce
* 语法: 数组.reduce(function (prev, item, index, origin) {}, init)
* prev: 表示初始值或者上一次的运算结果
* item: 表示数组的每一项 的值
* index: 表示数组的每一项 的下标(索引)
* origin: 原始数组
* 作用: 用来实现叠加效果
* 返回值: 最终叠加的结果
* 注意:
+ 叠加条件以 return 的形式书写
+ prev 第一次的值, 如果你传递了 init, 就是 init 的值, 如果没有传递 init, 那么就是 数组[0] 的值
+ 如果传递了 init, 循环执行 数组.length 次, 如果没有传递 init, 循环执行 数组.length - 1 次
第五天作业 1.数学方法
在 JS 中 Math 对象给我们提供了操作数据的一些方法(数学的方法)
1. random
* 语法: Math.random()
* 作用: 得到一个随机数, 每次生成的数字都不一样, 但一定是0~1之间的, 包含0, 不包含1, 也就是说最大值可能是 0.99999....
2. round
* 语法: Math.round(数字)
* 作用: 将这个数字(小数), 按照四舍五入的形式变成整数
3. ceil
* 语法: Math.ceil(数字)
* 作用: 将这个数字(小数) 向上取整
4. floor
* 语法: Math.floor(数字)
* 作用: 将这个数字(小数) 向下取整
5. abs
* 语法: Math.abs(数字)
* 作用: 返回这个数字的绝对值
6. sqrt
* 语法: Math.sqrt(数字)
* 作用: 求 平方根
7. pow
* 语法: Math.pow(基数, 幂)
* 作用: 返回基数的几次幂
8. max
* 语法: Math.max(数字1, 数字2, 数字3...)
* 作用: 返回传入的数字中 最大的哪一个
9. min
* 语法: Math.min(数字1, 数字2, 数字3...)
* 作用: 返回传入的数字中 最小的哪一个
10. PI
语法: Math.PI
作用: 返回 π
2.js的严格模式
JS 是一个相对不是很严谨的语言, 在开发的时候一些代码也不是很严格
换句话说严格模式就是对开发的时候, 你写的代码做了一些要求
严格模式的规则
1. 声明变量必须要 var 关键字
2. 函数的形参不可以重复
JS 中默认是没有开启严格模式, 如果想要开启严格模式, 需要手动在代码最开始的位置(script标签内第一行), 写一个字符串 'use strict'
现在的公司的项目中, 基本都是按照严格模式开发的
3.了解字符集
计算机只能存储二进制数据 0101010
我们的 大写字母 小写字母 符号之类的内容 都是由 二进制数字组成
或者说我们在敲一个字符的时候, 都有一个对应的编号, 计算机存储的时候存储的是这些编号,
只不过我们看到的时候, 是通过这些编号解析成我们看到的内容
前身: ASCII as key (128) 只够 美国人用英语的使用
国内 推出了一个属于中国的 GBK 国标码 前128位 ASCII码, 后边从129位开始就是汉字
unicode (万国码) 前 128 位还是 ASCII码, 后边开始是各个国家的文字码
八位十六进制编码 容量小, 但是占用内存也小 UTF-8
十六位的十六进制编码 容量大, 但是占用内存也大
