day06
预解析
对象
对象的遍历
对象的常用方法
预解析
在代码执行前，对代码进行通读并解释
预解析只会对以下两种方式进行极解析
1定义变量
var num =100 //进行预解析，声明变量num(但不赋值，赋值在执行代码阶段)
2定义函数
function fun(){ //进行预解析，声明函数fun,并将函数赋值给fun,但不会执行函数里的代码
alert('hello word')
}
例如
fun() //1
function fun(){
var num = 100
alert(num)
}
fun() //2
对以上代码进行分析
1预解析
声明fun()变量，将函数值赋值给fun()
2执行代码
fun()1执行，因为fun()已经被预解析过了，所以调用fun()的函数，因为num没有被解析，所以先预解析var num ,之后fun()调用函数，将100赋值给num,在输出num
然后在fun()2执行，调用fun()函数，输出num
例
var n =100 //1
fun() //2
function fun(){ //3
n =200 //4
console.log(n） //5
} //6
var fun = 300 //7
fun() //8
对以上代码进行分析
1预解析
1.声明变量 n
3声明变量fun(),将函数赋值给fun()
7声明变量fun
2执行代码
1，将100赋值给n
2,调用fun()函数，4将200赋值给n，调用5输出n=200
7将300赋值给fun fun()被覆盖
8,调用fun(),但fun()被覆盖，报错
函数在定义阶段和调用阶段的任务·
函数定义阶段
1-1 现在堆内存中开辟空间
1-2 把函数体内的代码 原样复制到空间内(我们写代码写在硬盘上)
1-3 把内存的地址 赋值给栈内存的函数名
函数调用阶段
2-1 按照函数名存的地址去找到对应的函数体
先判断栈内存中是否有这个变量
如果存在 也会判断里边是否存储的还一个函数体
2-2 在调用栈 内开辟一个新的 函数执行空间 (一个函数可以被多次调用为了避免一个调用出现的结果影响所有的 调用所以每次的调用都会申请一个执行空间)
2-3 在执行空间内 给形参赋值
2-4 在执行空间内 对函数体内的代码进行预解析
2-5 在执行空间内 对函数体内的代码 执行一遍
2-6 完成以后 这个执行空间被销毁 或者理解为空间被收回
对象
赋值式
var people={
name:'fangye', //,必须有
age:22,
like:function(){
alert('原神')
}
}
alert(people.name)
alert(people.age)
people.like()
声明式
var people = new Object()
people.name='fangye'
people.age=18
people.isman=true
people.like=function(){
alert('原神')
}
当对象的键名只有数字或特殊符号时，需要
1当键名只有数字时
定义时： 对象名[键名] 或者对象名[‘键名’] a[1]=111 a['2']=222
调用时： 对象名[键名] 或者对象名[‘键名’] console.log(a[1]) console.log(a['2'])
如果定义是对象名[‘键名’] ，调用是可以对象名[键名]，反之亦然 console.log(a[2])
2当键名为数字和特殊字符时
定义： 必须有且只有 对象名[键名]
对象名[键名] 与 对象名[‘键名’] 是两个键值对 ‘’会被当做特殊字符
调用 对象名[键名]
var a ={}
//a.3=11 //报错
a[1]=111
a['2']=222
a[111^222]=1234
a['3^4']=12345
console.log(a[1]) //111
console.log(a['2']) //222
console.log(a[2]) //222
console.log(a[111^222])//1234
console.log(a['3^4']) //12345
console.log(a[3^4]) //undefined
对象的遍历
document.write(a) //返回[object,object]
console.log(a) //可以点击查看 一般采用这种
for(var i in a){
// document.write(a[i]) //只输出value的值
console.log(a[i]) //只输出value的值
}
对象的常用方法
增
people.wei=82
删
delete people.age
改
people.name='fangyewang'
查
alert(people.name)
day07
数组
遍历数组
数组常用的方法
数组
定义数组
var a = []
var b = [1,2,3,4,5,6]
var c = new Array()
var d = new Array('a','b','c','d')
数组遍历
var a = [1,2,3,4,5]
for(var i in a){
console.log(a[i]) //12345
}
for(var i =0;i<a.length;i++){
console.log(a[i]) //12345
}
数组
冒泡排序
var arr=[3,1,5,4,2,6]
for(var i=0;i<arr.length-1;i++){
for(var j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j]
arr[j]=arr[j+1]
arr[j+1]=temp
}
}
}
console.log(arr)
选择排序
var arr=[3,1,5,4,2,6]
for(var i=0;i<arr.length;i++){
var minindex=i
for(var j=i+1;j<arr.length;j++){
if(arr[j]<arr[minindex]){
minindex=j
}
}
var temp=arr[i]
arr[i]=arr[minindex]
arr[minindex]=temp
}
console.log(arr)
forEach
var arr = [28,77,90,68,99,59,33]
arr.forEach(function(item,index,origin){
console.log(item,index)
})
数组常用的方法
push 在数组最后添加新元素 栈方法
var a = [1,2,3]
a.push(4)
document.write(a) //1234
pop 删除数组最后一个元素 栈方法
var a = [1,2,3]
a.pop()
document.write(a) //12
unshift 在数组最前面添加新元素 队列
var a = [1,2,3]
a.unshift(0)
document.write(a) //0123
shift 删除数组最前面的元素 队列
var a = [1,2,3]
a.shift()
document.write(a) //23
reverse 反转数组元素
var a = [1,2,3]
a.reverse()
document.write(a) //321
sort 排序(不好用)
var a=[5,1,4,2,3]
a.sort()
document.write(a) //12345
//改进
var a = [5, 1, 4, 2, 3]
function hh(num1, num2) {
if (num1 > num2) {
return 1
}
return -1
}
document.write(a.sort(hh))
splice 截取
var a = [5, 1, 4, 2, 3]
var res = a.splice(2,2)
document.write(a+'<br>') //513
document.write(res) //42
//也可以用作增删改(对原数组)
splice(开始的索引值，0，新增元素1，...)增
splice(开始的索引值，删除的元素数)删
splice(开始的索引值，修改的元素数，修改元素1，...)改
=以上方法原数组会发生改变，以下方法不改变原数组======
concat 在数组后面进行拼接
var a = [1, 2, 3]
a.concat('a',4,5)
var b= a.concat('a',4,5)
document.write(a+'<br>') //123
document.write(b+'<br>') //123a45
join 将数组转化为字符串
var a = [5, 1, 4, 2, 3]
var res = a.join()
document.write(a,typeof a) //5, 1, 4, 2, 3 object
document.write(res,typeof res) //5,1,4,2,3 string
slice 截取数据 注意：slice(开始索引，结束索引) splice(开始索引，个数)
var a = [5, 1, 4, 2, 3]
var res = a.slice(2,3)
//开始可以不填, 默认是 0, 结束索引不填, 默认是 length
document.write(a) //5，1，4，2，3
document.write(res) //4
indexOf 从前到后检索该数据第一次在该数组内出现的位置 不出现返回-1
var a = [5, 1, 4, 2, 3]
var res = a.indexOf(3)
document.write(res) //4
lastIndexOf 从后到前检索该数据第一次在该数组内出现的位置
var a = [5, 1, 4, 2, 3, 2, 1]
var res = a.lastIndexOf(2)
document.write(res) //5
高阶函数，可以调用function的=======================
function(item,index,origin){
=> item: 表示数组的每一项
=> index: 表示数组每一项的索引
=> origin: 表示原始数组
}
forEach 遍历数组
var arr = [28,77,90,68,99,59,33]
arr.forEach(function(item,index,origin){
console.log(item,index)
})
map 映射数组
var a = [5, 1, 4, 2, 3, 2, 1]
var b =a.map(function(item){
return item+10
})
document.write(b) //15,11,14,12,13,12,11
filter 映射数组
var a = [5, 1, 4, 2, 3, 2, 1]
var b =a.filter(function(item){
return item>=3
})
document.write(b)
find 查询数据
var a = [5, 1, 4, 2, 3, 2, 1,7]
var b = a.find(function(item){
return item==7
})
document.write(b) //7
//如果找不到，返回undefined
findIndex 返回第一个被找到的下标
var a = [5, 1, 4, 2, 3, 2, 1,7]
var b = a.findIndex(function(item){
return item==4
})
document.write(b) //2
//找不到返回-1
every 判断数组内是否每一个都满足条件
var a = [5, 1, 4, 2, 3, 2, 1,7]
var b = a.every(function(item){
return item>0
})
document.write(b) //true
some 判断数组内是否有某一个满足条件
var a = [5, 1, 4, 2, 3, 2, 1,7]
var b = a.some(function(item){
return item>7
})
document.write(b) //false
reduce
reduce()
+ 语法: 数组.reduce(function (prev, item, index, origin) {}, init)
=> prev: 表示初始值或者上一次的运算结果
=> item: 表示数组的每一项
=> index: 表示数组每一项的索引
=> origin: 表示原始数组
+ 作用: 用来实现叠加效果
+ 返回值: 最终叠加结果
+ 注意: 叠加条件以 return 的形式书写
+ 注意: prev 的值, 如果你传递了 init, 就是 init 的值, 如果你没有传递 init, 那么就是数组 [0] 的值
+ 注意: 如果你传递了 init, 循环执行 length 次, 如果你没有传递 init, 循环执行 length - 1 次, 少的是第一次
day08
基本包装类型
字符串常用方法
基本包装类型
// 基本包装类型
// 原本只有对象才可以 调用自己的静态属性和动态方法
// 但是系统给予了跟对象一样的权限 可以使用属性和方法
// 所以字符串又称为基本包装类型
// alert(100.4567.toFixed(2))
// 字符串 数值 布尔 又称为 基本包装类型
字符串常用方法
1. charAt()
+ 语法: 字符串.charAt(索引)
+ 返回值: 该索引位置的字符
=> 如果没有该索引位置, 返回的是 空字符串
var a='hello word'
var b = a.charAt(2)
document.write(b) //l
2. charCodeAt()
+ 语法: 字符串.charCodeAt(索引)
+ 返回值: 该索引位置字符的 unicode 编码
=> 如果没有该索引位置, 返回的是 NaN
var a ='12ab'
for(var i=0;i<a.length;i++){
console.log(a.charCodeAt(i)) //49 50 97 98
}
3. toUpperCase()
+ 语法: 字符串.toUpperCase()
+ 返回值: 将原始字符串内的所有字母转换成大写
var a ='abcdef'
var b = a.toUpperCase()
document.write(b) //ABCDEF
4. toLowerCase()
+ 语法: 字符串.toLowerCase()
+ 返回值: 将原始字符串内的所有字母转换成小写
var a ='ABCDEF'
var b = a.toLowerCase()
document.write(b) //abcdef
5. substr() // splice(开始的索引,多少个)
+ 语法: 字符串.substr(开始索引, 多少个)
+ 返回值: 截取出来的部分字符串
var a = 'abcdef'
var b = a.substr(2,3)
document.write(b) //cde
6. substring()
+ 语法: 字符串.substring(开始索引, 结束索引) // slice()
+ 特点: 包前不包后
+ 返回值: 截取出来的部分字符串
var a = 'abcdef'
var b =a.substring(2,4)
document.write(b) //cd
7. slice()
+ 语法: 字符串.slice(开始索引, 结束索引)
+ 特点: 包前不包后, 填写负整数
+ 返回值: 截取出来的部分字符串
var a = 'abcdef'
var b =a.slice(2,4)
document.write(b) //cd
8. split()
+ 语法: 字符串.split('分隔符') //分隔符，靠分隔符分割，
例如：var a= 'abcde*fghijk
var b =a.split('*')
console.log(a)
返回；abcde fghijk
+ 返回值: 是一个数组
=> 按照分隔符把字符串分开成为几段内容
var a = 'abcdef'
var b = a.split('')
console.log(b) //a b c d e f
9. concat()
+ 语法: 字符串.concat(字符串1, 字符串2, ...)
+ 返回值: 拼接好的字符串
var a = 'abcdef'
var b = a.concat('aaa')
console.log(b) //abcdefaaa
10. indexOf()
+ 语法: 字符串.indexOf(查找的字符, 开始索引)
+ 返回值:
=> 如果原始字符串内有该字符串片段, 那么是该字符串片段第一次出现的首字母索引位置
=> 如果原始字符串内没有该字符串片段, 那么是 -1
var a = 'abcdef'
var b = a.indexOf('e',5)
console.log(b) //-1
11. lastIndexOf()
+ 语法: 字符串.lastIndexOf(字符串片段, 开始索引)
+ 返回值:
=> 如果原始字符串内有该字符串片段, 那么是该字符串片段第一次出现的首字母索引位置
=> 如果原始字符串内没有该字符串片段, 那么是 -1
var a = 'abcdef'
var b = a.lastIndexOf('e',5)
console.log(b) //4
12. includes()
+ 语法: 字符串.includes(字符串片段)
+ 作用: 该字符串中是否包含该字符串片段
+ 返回值: 一个布尔值
=> true 说明有该字符串片段
=> false 说明没有该字符串片段
var a = 'abcdef'
var b = a.includes('cde')
console.log(b) //true
13. startsWith()
+ 语法: 字符串.startsWith(字符串片段)
+ 作用: 判断该字符串是否以该字符串片段开头
+ 返回值: 一个布尔值
=> true 说明以该字符串片段开头
=> false 说明不以该字符串片段开头
var a = 'abcdef'
var b = a.startsWith('abc')
console.log(b) //true
14. endsWith()
+ 语法: 字符串.endsWith(字符串片段)
+ 作用: 判断该字符串是否以该字符串片段结尾
+ 返回值: 一个布尔值
=> true 说明以该字符串片段结尾
=> false 说明不以该字符串片段结尾
var a = 'abcdef'
var b = a.endsWith('f')
console.log(b) //true
15. trim()
+ 语法: 字符串.trim()
+ 作用: 去除字符串首尾空白
+ 返回值: 去除首尾空白后的字符串
var a =' a b c '
var b = a.trim()
console.log(a+1)
console.log(b+1)
输出：
a b c 1
a b c1
16. trimStart() / trimLeft()
+ 语法:
=> 字符串.trimStart()
=> 字符串.trimLeft()
+ 返回值: 去除开始位置空白以后的字符串
var a =' a b c '
var b = a.trimStart()
console.log(a+1)
console.log(b+1)
输出：
a b c 1
a b c 1
17. trimEnd() / trimRight()
+ 语法:
=> 字符串.trimEnd()
=> 字符串.trimRight()
+ 返回值: 去除结束位置空白以后的字符串
var a =' a b c '
var b = a.trimEnd()
console.log(a+1)
console.log(b+1)
输出：
a b c 1
a b c1
18. repalce()
+ 语法: 字符串.replace(换下字符, 换上字符)
+ 作用: 替换原始字符串内的片段
+ 注意: 只能替换一个
+ 返回值: 替换好的字符串
var a = 'abcdefa'
var b = a.replace('a','1')
console.log(b) //1bcdef1