js5

函数语法：

函数是不调用不执行的

函数的调用：方法名（）
函数的声明提升：function声明的函数会自动提升到最顶部
变量声明提升：赋值不提前，就是在后面的声明也算声明了，但不赋值

function 方法名(参数) {干啥事}

function grade(){
var gra=65;
if (gra<60){
alert(“不及格”)}
else if(gra<80){
alert(“及格”)}
else if(gra<90)
{alert(“良好”)}
else
{alert(“优秀”)}
}

grade()

参数就是变量，a+b ,给a b 赋不同的值，就生成不同的结果

形参 形式上的参数，函数定义时传入的参数
实参 实际上的参数，函数调用时传入的参数

如果函数定义了形参，那函数调用时必须传入实参

实例：

身高体重指数

bmi（身高体重指数）

function bmi(name,weight,height){

var index=weight/(height*height);
if (index<18.5)
{alert (name+“你太瘦了”)}
else if（index<23.9）
{alert (name+“恭喜你，你很正常”)}
else if（index<27.9）
{alert (name+“你有点胖啊”)}
else
{alert (“你太胖了”)}
}

var ljyh=1.8;
var ljyw=100;
var ccqh=1.75
var ccqw=75
var zqtw=46
var zqth=1.57

bmi(“林俊逸”， ljyw，ljyh)
bmi(“陈慈强”，ccqw，ccqh)
bmi(“陈慈强”，zqtw， zqth)

function dream(height,sex){
var target
if(sex==“男”){
target=(height-80) *0.7}
else{
target=(height-70) *0.6}
}
alert (“你的理想体重是”+target)
}

dream{180,“男”}

作用域：一个变量的可用范围：
全局作用域：除了函数之内的
局部作用域：在函数内的
**函数作用域，只有在函数调用时才创建，函数调用后立即销毁；

全局变量：在全局作用域内声明的变量
局部变量：在function函数内声明的变量

**全局作用域不能访问局部，局部作用域可以访问全局

**函数是一个过程，没有结果。如果想要结果，在函数内加入关键字 return，后面跟着你想要的数据

**return是退出函数的意思
因为函数内的数据不能直接调取，数据局部变量，所以需要用return来调取

比如： function fn(a,b){

return a+b
}

var a=fn(3,5)

console.log(a)

js7课程

**作用域的经典案例——闭包：
其实就是解决作用域的的问题；

定义：里面的函数使用了外面函数定义的局部变量；

var n=0;
function num(){

return n++
}

num()

console.log(num())
console.log(num())
console.log(num())
console.log(num())
console.log(num())

**对于未声明的变量直接赋值，那么js会在全局自动帮你声明

为了保证变量不是全局的，不会在后面被篡改：

**利用functon函数的嵌套可以解决这个问题,
**用来解决变量的全局污染问题；

**弊端：内存泄漏
性能
最先选择局部变量，

**5.循环结构：程序反复执行同一套代码

循环三要素：
1.循环条件，循环继续运行的条件；
2.循环变量：循环中做判断的量；循环变量一定是向着循环退出的趋势变化
3.循环体：循环中做的事情

新的语法
while（条件）{干什么事}

案例；
var n=5;
while(n<10){
console.log(“我执行了一次”)
}

**这个是一个死循环

var n=5;
while(n<10){
console.log(“我执行了一次”)
n++；
}
console.log(“我执行完了”)

——————————————————

for循环
语法：for（var i=0;i<10;i++）{
console.log(“我执行了一次”)
}

**for循环完全等效于while循环，但是可以把变量放在条件中

**6.数据类型：
原始数据类型：数据保存在变量本地，保存的栈中；number，string，boolean，null，undefined
引用数据类型：数据不保存在变量本地，保持在堆中；array，object

数组：相当于多个变量的集合，没有任何数据类型的限制；

**栈和堆其实就是两种内存中的存储空间；只是大小的区别；
栈里面只能放单个数据，但是不能放数组；
数组可以放在堆里面，然后在栈里放个指针（地址）；

var arr=[数据1，数据2，数据3]

比如：
var names=[“小明”，“小红”，“小刚”]

**如果要访问数组中的某一个值，用角标访问，

names[下标]

比如：
var name=[“小明”，“小红”，“小刚”]
console.log(name[2])

输出的是：小红

**数组中的变量也可以更改

var arr=[1,2,3,4,5,]
arr[0]=9;

例2:如果想把1改成星期1:
var arr=[1,2,3,4,5,6,7]
arr[0]=“星期”+arr[0]

for(var i=0;i<7,i++){
arr[i]=“星期”+arr[i]
}

数组遍历：用for函数
封装函数：
数组的length属性返回的是数组的长度
比如：name.lengh

**JS是面向“对象”编程，对应的是面对“过程”编程

object和数组一样，都是用来存多个数据的；
对象相当于多个变量（key／value）的集合；对象的值是没有任何数据类型限制的

var obj={name：“小明”，age：18 }
console.log(obl.age)

访问可以直接用name和age去访问
访问对象的值： 对象名.属性名 obj.name

对象的属性名一定是字符串；

var obj={123,week:[1,2,3,4],movie:{“name”:尖峰时刻}}

console.log(obj.movie.name)
改名 obj.movie.name=“新警察故事”

**如果希望对象的属性名为变量，属性名外加【】

var my=function(){}

**方法是可以作为对象的属性的，方法名被当作属性名

***数组用来存一系列同类数据，对象是一个事物的多维数据

var car={name:“bmw”,model:“750”;color:“white”;price:“1500000”;cuntry:“gemany”;run:function(){alert(“我能跑”)}}

console.log(car.run)

**对象到底有什么用？

面向对象编程， 不是面向过程的：

就是知道结果如何实现就可以了；

js里哟17个内容对象，满足不同方面的功能需求；

***对象就是为了装在一个特定的功能，为了达到某个综合的目的，可以调用不同的对象里面的功能！

**js是利用现成的或者封装函数这种工具，去直接调用实现功能！

2.对象的循环

for in

样式： for(var 属性名 in 你要遍历的对象)
对象的属性名如果是变量的话，那么属性名需要加中括号[]

对象的循环中，如果需要取值的话，对象名[]

var car={name:“bmw”,model:“750”;color:“white”;price:“1500000”;cuntry:“gemany”;run:function(){alert(“我能跑”)}}

for（var key in car){

console.log(car[key]))

}

3.null 是空对象指针

用来主动释放对象

var obj=(…)

obj=null （这样就释放内存了）

4.对象的方法

之前写的都是自定义对象，程序里还有内置对象；

内置对象；js里定义好的对象，有现成的属性和方法供我们使用；

一共有17个内置对象；

1.array 数组对象，数组就是一个特殊的对象

数组的length（访问数组的长度）
数组的取值，中间加点

1. 向数组的结尾追加元素，可以直接修改原数组，不需要重新赋值
   push（）

例子： var arr=[1,2,3,4,5]

arr.push(6);

console.log(arr)

push里可以加多个元素，甚至加一个数组,对象
push（1,2,3）

**当然用角标赋值的方式也可以实现
arr[6]=6

输出：1,2,3,4,5,6

2)pop() 删除数组最后一位元素

3）unshift 向数组的开头增加元素

4）shift 删除数组的第一位元素

5）reverse 反转数组，把原来的数组倒序

6）join连接数组，将数组连接成字符串；
样式：join（“连接符”）

join（“-”）

**任何东西都可以当作连接符，包括空字符，空格；

**join可以把一个数组变成字符串

7）slice 用来截取子数组，含头不含尾
var arr=[“h”,“e”,“l”,“i”“o”]
arr=arr.slice(1)
console.log(arr)

8)splice 用来删除／插入／替换元素
如果splice方法超过两个参数，那么后几个作为新值插入进来；
** 第一个数字是指从哪一位开始删，第二个数字是指删几个元素；从第三个开始为新加入的值；

var arr=[“h”,“e”,“l”,“i”“o”]
arr.splice[1,3,4,5,6] 其中4，5，6就是新加入值
console.log(arr)

最后输出：h 4 5 6 o

9）sort（） 数组排序
var arr=[4,5,6,12,14]

arr.sort()

实现从小到大的排序

sort按照unicode编码来排序的；所有语言都对应一个unicode编码；

大写字母：65-90
小写字母 97-122
数字 48-57

**** sort不适合于数字的排序

10）map 数组的循环方法，对数组的每个元素进行处理，返回一个全新的数组

语法 map（function（item,index）{return 进行的操作 }）
item代表循环中的每一项，index代表的是角标

var arr=[1,2,3.4,5,6.7]

arr=arr.map(function(item,index){
return “星期”+item
}
)
console.log(arr)

11）concat 连接多个数组成一个数组，不同于join（把数组连接成字符串）
语法 数组1.concat（数组2）

var arr1=[1,2.3]
var arr2=[4,5.6]

var arr3=arr1.concat(arr2)

console.log(arr3)

输出结果 1，2，3，4，5，6

**多个数组合并：
语法 数组1.concat（数组2，数组3，数组3）

***数组去重的方法

var arr={0.1.2.23，3，5，6，6，2，3.4}
for（var i=0,i<arr.lengh,I++）{
for( var j=1;j<i; j++){
if(arr[i)===arr[j]){
arr.splice(j,1)
i–
}
}
}

console.log(arr)