JavaScript
基本概念：js是一门客户端脚本语言，运行在客户端浏览器中的，每个浏览器都有一个js的解析引擎，JS是是一个弱类型的语言
脚本语言：不需要编译的，直接可以被浏览器解析运行的
功能：用来增强用户和html页面的交互，也可以用来控制html元素
现在的javaScript：ECMAScript+JavaScript特有的东西（DOM+COM）
JS在HTML中的用法
1，行内写法，将js代码写在html标签中
2，文档内部写法，将js代码写在一对<script> 标签中
3，外部引入js文件 ， 将js代码，单独写在一个文件中，使用<script>标签引入进
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
</head>
<!-- 外部引入方式 -->
<script src="js/test.js"></script>
<!-- 行内引入方式 -->
<body>
<button onclick="javascript:alert('按钮被点击了')" >按钮</button>
</body>
<!-- 文档内容部编写方式 -->
<script>
alert("弹出弹框");
</script>
</html>
alert("你好啊，这是外部引入的js代码")JS中的常用内容
注释 ： 和Java中一样
1.注释：单行注释：//
多行注释：/* */
输出内容：
1.弹出弹框 alert()
2.在页面上输出document write()
3.控制台输出 console.log()
4.通过dom展现到标签中 document.getElementBy("id"值).innerHTML='展示内容'
JS中的数据类型
1.原始数据类型
Number:整数、小数 、NaN(not a number)非数字
String：双引号或者单引号括起来的
Boolean:true 或者false
Null: null
Undefined:undefined(未被定义的)
2、引用数据类型：对象、数组、函数......
JS中的变量
变量的概念：程序运行的过程中，用来存储数据的一个名称，值可以发生改变的，本质上是内存的一个空间
Java是强类型语言，js是弱类型语言，声明变量的区别
强类型：开辟内存空间时，必须要指定一个类型，将来该空间只能存放指定的类型。
弱类型：开辟空间的时候，不指定存放的类型，可以存放任意的数据类型
语法： var 变量名 = 值；let 变量 = 值；const 变量名 = 值；
var a = 10;
a = "abc";
a = true;
a = undefined;
b = 200;
//Number类型
var num =100.1;
var num2 =200;
var num3 =NaN;
console.log(num);
console.log(typeof(num));
//字符串类型
var s1="abc";
var s2='abc'
var s3=s1+s2;
console.log(s3);
//boolean
var b1 =true;
//Null
var s4=null;
var s5=undefined;
var s6;
console.log(s4);
console.log(s5);
console.log(s6);
function fun(){
var name='jack';
age=18;
let gender='男';
}
console.log(name);//var定义的是全局变量，在整个script中都有效
console.log(gender);//变量未声明 let定义的是局部变量（方法内生效，方法外无效）
console.log(5/3);//js中除法会返回小数
console.log(5%3);
JS中的运算符
赋值运算符：
赋值运算符 ： =
算数运算符 ： + - * / %
js中除法会返回小数
比较运算符 ： > < >= <= == ===
== : js中的==是判断值是否相同，不同类型，值相同也返回true
=== ： js中的=== 判断值和类型是否都相同，如果都相同，则返回true
逻辑运算符 ：&&，|| ，！
!取反，在js中可以完成数据隐式的转换
console.log(5/3);//js中除法会返回小数
console.log(5%3);
var num4=100;
var num5="100";
console.log(num4 == num5);//true
console.log(num4 === num5);//false
逻辑运算符 &&，||，！
js中的&&也具有短路效果，用法与java中的短路与&&一致，而 || 相对的也具有短路或的作用
!=取反，在js中可以完成数据隐式转换
var num4 = -100;
var num5 = "100";
console.log(num4 == num5);//值相等
console.log(num4 === num5); //false
// console.log( 3 < 5 &num4++ < 200);
//非o数字加上取反默认被当做布尔值中的true，o被当做false
console.log ( !num4);
//非空的字符串遇到!取反，也会被当做布尔值中的true,空字符是false
console.log( !num5) ;
一元运算符： ++ --
++a,先将a+1，再将a参与表达式的运算
a++，先将a参与表达式运算，再将a+1
二元运算符： += ，-= ，*= ，/=
三元运算符
变量 =表达式 ？ 值1 ：值2
如果表达式返回true，则变量的最终结果取值1，
如果表达式返回false，则变量的最终结果取值2
JS中的流程控制语句
if -esle 和java中的完全相同
switch case语句和java中的完全相同
JS中的循环语句
for循环：和java中的完全相同
增强for循环
while循环 ：和java中的完全相同
do-while循环：和java中的完全相同
小练习：使用js写一个乘法口诀表
<style>
table{
border-collapse: collapse;/* 边框塌陷 */
}
td{
border: 1px solid black;
padding: 10px;
}
</style>
<script>
document.write("<table>");
for(var i=1;i<10;i++)
{
document.write("<tr>");
for(var j=1;j<=i;j++){
document.write("<td>");
document.write(j+"*"+i+"="+(i*j)+" ");
document.write("</td>");
}
document.write("</tr>");
}
document.write("<table>");
</script>
JS中常用对象
JS的数组
JS中的数组对象，可以使用单独的变量名。存储多个不同类型的值，其实JS的数组就是一个容器，装了很多元素，JS数组中可以存放任意类型的数据
数组索引从零开始：数组中的第一个元素是 0，第二个元素是 1，依此类推。
Array 属性
属性 描述
constructor 返回创建 Array 对象原型的函数。
length 设置或返回数组中元素的数量。
prototype 允许您向数组添加属性和方法。
Array 方法
| 方法 | 描述 |
| 连接两个或多个数组，并返回已连接数组的副本。 | |
| 将数组中的数组元素复制到指定位置或从指定位置复制。 | |
| 返回键/值对数组迭代对象。 | |
| 检查数组中的每个元素是否通过测试。 | |
| 用静态值填充数组中的元素。 | |
| 使用数组中通过测试的每个元素创建新数组。 | |
| 返回数组中第一个通过测试的元素的值。 | |
| 返回数组中通过测试的第一个元素的索引。 | |
| 为每个数组元素调用函数。 | |
| 从对象创建数组。 | |
| 检查数组是否包含指定的元素。 | |
| 在数组中搜索元素并返回其位置。 | |
| 检查对象是否为数组。 | |
| 将数组的所有元素连接成一个字符串。 | |
| 返回 Array Iteration 对象，包含原始数组的键. | |
| 在数组中搜索元素，从末尾开始，并返回其位置。 | |
| 使用为每个数组元素调用函数的结果创建新数组。 | |
| 删除数组的最后一个元素，并返回该元素。 | |
| 将新元素添加到数组的末尾，并返回新的长度。 | |
| 将数组的值减为单个值（从左到右）。 | |
| 将数组的值减为单个值（从右到左）。 | |
| 反转数组中元素的顺序。 | |
| 删除数组的第一个元素，并返回该元素。 | |
| 选择数组的一部分，并返回新数组。 | |
| 检查数组中的任何元素是否通过测试。 | |
| 对数组的元素进行排序。 | |
| 从数组中添加/删除元素。 | |
| 将数组转换为字符串，并返回结果。 | |
| 将新元素添加到数组的开头，并返回新的长度。 | |
| 返回数组的原始值。 |
JS常用重要方法（数组创建，遍历，排序等）
下面是JS数组的一些重要方法
<script>
//数组的定义
//1.使用new关键字来创建数组对象
var arr= new Array();
var arr1=new Array(3);//创建长度为3的数组
console.log(arr[0]);//undefined
console.log(arr1[3]);//没有发生数组越界，仍然返回undefined
//2.使用new的时候，直接给数组赋初始值
var arr2=new Array("1",2,"3",4);
console.log(arr2[0]);
console.log(arr2[1]);
console.log(arr2[2]);
console.log(arr2[3]);
console.log(arr2[4]);//undefined
//3.直接使用中括号[]声明数组
var arr3=["hello","world","java"];//java中使用的是大括号
console.log(arr3[2]);//java
//常见的数组操作
//添加
//1.直接通过下标来赋值
arr[0]="hello";
arr[1]="java";
arr[2]="world"
console.log(arr);
//2.使用js Array中的push()方法(添加放在数组的末尾，放回新的数组的长度)
var num=arr.push("oracle");
console.log(num);//新的数组长度为4
console.log(arr);
//3.使用unshift()方法（添加放在数组的开头，放回新的数组的长度）
var num1=arr.unshift("mysql")
console.log(num1);//新的数组长度为5
console.log(arr);
//删除数组中的元素
//pop删除最后一个
var s1= arr.pop();
console.log(s1);//oracle
console.log(arr);
//shift删除第一个
var s2 =arr.shift();
console.log(s1);//oracle
console.log(arr);
//splice可以同时删除、添加
arr.splice(1,1,"orcale","mysql","spring");
/* 第一个数字1是开始操作的下标位置（arr[1]）,第二个数字是删除元素的个数
而添加的位置就是从操作的位置开始,后面的元素就是删完元素后重新添加的元素 */
console.log(arr);
/* 从下标0元素开始操作，删掉两个元素，同时在其位置添加三个元素 */
arr.splice(0,2,"nihao","zaijian","chuntian");
console.log(arr); /* 打印arr数组 */
/*上面两次splice()方法执行后，遍历数组结果如下所示：
Array(5) [ "hello", "orcale", "mysql", "spring", "world" ]
数组.html:55:11
Array(6) [ "nihao", "zaijian", "chuntian", "mysql", "spring", "world" ] */
//数组的遍历
//1普通for循环
for (var i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
console.log("---------------------------");
//增强for循环
for(var key in arr){/* var key 的var 可以加可以不加 */
console.log(arr[key])
}
console.log("-------------------------");
/*map方法遍历元素(map方法可以对数组里的元素进行一些人为操作，
并将修改后的元素编程一个新数组，同时map方法还可以遍历数组)*/
arr.map(function(value,index){
/*数组的map方法中传入一个function方法(里面传入元素值value和数组下标index)*/
console.log(index +"--" +value);
})
//其他常用方法
//concat()方法：连接多个数组
var newArr=arr.concat(arr1,arr2);
/*拼接的数组不会在调用方法的数组基础上进行，
而是拼接一个形成一个全新数组，所以要创建新的数组来接收*/
/*filter()方法：为数组中的每个元素执行的函数。
它应该返回一个真值以将元素保留在结果数组中，否则返回一个假值。*/
var arr4=[10,15,20,16,9,11,42];
//将arr4中大于15的元素
var newArr2=arr4.filter(function(num){
if (num>15){
return num;
}
})
console.log(newArr2);//16,20,42
/* ps:这里可以讨论一下js中map方法和filter方法的区别 */
//join方法
var newArr3 =arr.join("@");
console.log(newArr3);//nihao@zaijian@chuntian@mysql@spring@world
//sort()
var arr5=[10,25,32,4,54,24,52,9,85]
arr5.sort();//默认排序是按照每个元素的第一位的大小来排序，
//如果第一位数值相同则比较第二位
console.log(arr5);//Array(9) [ 10, 24, 25, 32, 4, 52, 54, 85, 9 ]
arr5.sort(function(a,b){
return a-b;//这里如果改成return b-a;则按照从大到小进行排序
//这里function(a,b)里面的方法进行的大概意思是将数组元素里的值进行前后
//大小比较，如果前一个值大于后一个值，则两值进行交换
})
console.log(arr5);//Array(9) [ 4, 9, 10, 24, 25, 32, 52, 54, 85 ]
//数组从小到大进行排序
</script>JS中类型及转换方法
数字类型方法
toString()将数字作为字符串返回。
toFixed() 返回带小数位数的数字。
类型相关转换
Number()转换数值，String()转换字符串，Boolean()转换布尔值
parseInt()解析字符串并返回整数。
parseFloat() 解析字符串并返回浮点数。
var num = 10.0254152;
console.log(num);
var s = num.toString();
console.log(s);
//保留小数位
console.log(num.toFixed());
console.log(num.toFixed(2));
console.log(num.toFixed(4));
console.log(num.toFixed(6));
//字符串转数字
var str = "100";
var n1 = Number(str);
console.log(n1 + "--" + typeof(n1));
console.log(parseInt("10"));
console.log(parseInt("10.25"));
console.log(parseInt("10 20 30"));
console.log(parseInt("10abc"));
console.log(parseFloat("10"));
console.log(parseFloat("10.255165"));
console.log(parseFloat("10.25 20 30"));
console.log(parseFloat("10.12abc"));JS中的字符串
JavaScript 字符串方法和属性
属性
constructor 返回字符串的构造函数。
length 返回字符串中的字符数。
prototype 允许您向对象添加属性和方法。
方法 描述
charAt() 返回指定位置处的字符。
charCodeAt() 返回指定位置处字符编码。
codePointAt() 返回字符串中索引（位置）处的 Unicode 值。
concat() 返回两个或多个连接的字符串。
endsWith() 返回字符串是否以指定值结尾。
fromCharCode() 将 Unicode 值作为字符返回。
includes() 返回字符串是否包含指定值。
indexOf() 返回值在字符串中第一次出现的位置。
lastIndexOf() 返回值在字符串中最后一次出现的位置。
localeCompare() 使用基于本地的顺序来比较字符串。
match() 在字符串中搜索值或正则表达式，并返回匹配项。
repeat() 返回拥有多个字符串副本的新字符串。
replace() 在字符串中搜索值或正则表达式，并返回替换值的字符串。
search() 检索字符串中与正则表达式匹配的子串。
slice() 提取字符串的一部分并返回新字符串。
split() 将字符串拆分为子字符串数组。
startsWith() 检查字符串是否以指定字符开头。
substr() 从字符串中抽取子串，该方法是 substring() 的变种。
substring() 从字符串中抽取子串。
toLocaleLowerCase() 使用主机的语言环境返回转换为小写字母的字符串。
toLocaleUpperCase() 使用主机的语言环境返回转换为大写字母的字符串。
toLowerCase() 返回转换为小写字母的字符串。
toString() 将字符串或字符串对象作为字符串返回。
toUpperCase() 返回转换为大写字母的字符串。
trim() 返回删除了空格的字符串。
trimEnd() 返回从末尾删除空格的字符串。
trimStart() 返回从开头删除空格的字符串。
valueOf() 返回字符串或字符串对象的原始值。
<script>
var s1 = "helloworld";
var s2 = "java";
console.log(s1.charAt(4)); // o
var s3 = s1.concat(s2);
console.log(s3);
console.log(s1.endsWith("D"));
console.log(s1.indexOf("l"));
console.log(s1.lastIndexOf("l"));
console.log(s1.length);
var s4 = s1.replace("l","x");
console.log(s4);
console.log(s1);
var s5 = s1.split("d");
console.log(s5);
var s6 = s1.substring(1,3); //从第1位截取，截取到第3个
console.log(s6);
var s6 = s1.substr(1,3); //从第1位截取，截取3个
console.log(s6);
</script>练习
//求 大字符串中"aaglsgjavafekwegjavakjkwaegnjavafwaegwegjava"
//中小字符串java出现的次数
//1,方法一
var str1 = "aaglsgjavafekwegjavakjkwaegnjavafwaegwegjava";
var str2 = "java";
var arr = str1.split(str2);
console.log(arr.length-1);
//2,方法二
var count = 0;
var flag = true;
while(flag){
var str3 = str1.replace(str2,"");
if(str1 != str3){
count++;
// console.log(count);
str1 = str3;
}else{
flag = false;
}
}
console.log(count);JS正则表达式
RegExp 对象
正则表达式是一种字符模式。
该模式用于对文本进行模式匹配的“搜索和替换”功能。
修饰符
修饰符用于执行不区分大小写和全局的搜索：
修饰符 描述
g 执行全局匹配（查找所有匹配而不是在第一个匹配后停止）。
i 执行不区分大小写的匹配。
m 执行多行匹配。
方括号
方括号用于查找某个范围内的字符：
表达式 描述
[abc] 查找括号之间的abc字符。
[^abc] 查找任何不在方括号之间的字符。
[0-9] 查找任何从 0 至 9 的数字。
[^0-9] 查找任何不在括号内的字符（任何非数字）。
(x|y) 查找任何指定的选项。
元字符
元字符是具有特殊含义的字符：
元字符 描述
. 查找单个字符，除了换行符或行终止符。
\w 查找单词字符。
\d 查找数字。
量词
量词 描述
n+ 匹配任何包含至少一个 n 的字符串。
n* 匹配任何包含零个或多个 n 的字符串。
n? 匹配任何包含零个或一个 n 的字符串。
n{X} 匹配包含 X 个 n 的序列的字符串。
n{X,Y} 匹配包含 X 至 Y 个 n 的序列的字符串。
n{X,} 匹配包含至少 X 个 n 的序列的字符串。
n$ 匹配任何以 n 结尾的字符串。
^n 匹配任何以 n 开头的字符串。
?=n 匹配任何其后紧接指定字符串 n 的字符串。
?!n 匹配任何其后没有紧接指定字符串 n 的字符串。
RegExp 对象方法
方法 描述
exec() 测试字符串中的匹配项。返回第一个匹配项。
test() 测试字符串中的匹配项。返回 true 或 false。
toString() 返回正则表达式的字符串值。
正则表达式小练习
<script>
//匹配电话
var tel = "我的电话是:13333338888";
var reg = /1[3-9][0-9]{9}/;
console.log(reg.exec(tel));
console.log(reg.test(tel));
console.log(tel.match(reg));
//匹配内容
var s1 = "gagewgweaAAWEGaa";
var reg = /[a]/gi;
console.log(s1.match(reg));
//匹配日期格式
var str1 = "1999-11-10";
var reg2 = /^[\d]{4}-[\d]{1,2}-[\d]{1,2}$/;
console.log(reg2.test(str1));
//写一个邮箱的正则表达式格式
// 12314@qq.com gaweg1241@163.com waggw3e12@yahool.com.cn
var reg3 = /[\w]{2,16}@[\w]{2,10}\.[\w]{2,3}/;
var str2 = "12314@qq.com";
console.log(reg3.exec(str2));
</script>JS中的对象创建
JS中的对象Object,是以键值对的形式存储属性的集合，每个属性都是自己定义的一个名称，以及名称对应的值。
创建对象的方式：
1，通过对象的构造器来定义
构造器就是一个构造函数
函数的定义方法：function(参数){ }
2，通过new Object()来定义
3，通过{}来定义
<script>
//1,创建对象，es5中，先去创建对象的构造函数
var User = function(userid,username){
this.userid = userid;
this.username = username;
}
//通过new关键字结合对象的构造函数，完成对象的创建及初始化
var user1 = new User(1001,"jack");
console.log(user1.userid);
console.log(user1.username);
var user2 = new User(1002,"tom");
console.log(user2.userid);
console.log(user2.username);
//2,通过new关键字结合Object对象，创建空对象
var user3 = new Object();
user3.id = 1003;
user3.name = 'lucy';
console.log(user3.id);
console.log(user3.name);
//3, js中可以通过 {} 来直接声明对象，声明的时候进行赋值
var user4 = {id:1004,name:"tonny"};
console.log(user4.id);
console.log(user4.name);
var user5 = {};
user5.id = 1005;
user5.name = 'jandy';
console.log(user5.id);
console.log(user5.name);
</script>es6中的面向对象
将来前端开发的过程中，大部分情况下，不需要去通过定义类的方式来完成开发，但是很多时候，我们会去使用别人定义好的类(很多的前端框架中，都有这些定义)
<script>
class Animal{
//构造函数
constructor(name,age){
this.name = name;
this.age = age;
}
say(){
console.log("我的名字是"+ this.name
+",年龄是" + this.age);
}
}
class Dog extends Animal{
constructor(name,age,gender){
super(name,age);
this.gender = gender;
}
}
var dog = new Dog("旺财",2,"母");
dog.say();
console.log(dog.gender);
</script>JS中对象的属性和方法
js中的属性可以动态的添加
<script>
//1.创建一个对象的构造函数,使用new关键字
var User =function(userid,username){
this.userid=userid;
this.username=username;
}
var user1=new User(1001,"李华");
console.log(user1.userid);
console.log(user1.username);
var user2=new User(1002,"jack");
console.log(user2.userid);
console.log(user2.username);
/* 写法二 */
function User(userid,username){
this.userid=userid;
this.username=username;
}
//2.通过new关键字，结合object创建空对象
var user3=new Object();
user3.id=1003;
user3.name="lucy";
console.log(user3.id);
console.log(user3.name);
//3.js中可以通过{}来直接声明对象，声明的时候进行赋值
var user4={id:1004,name:"tonny"};
console.log(user4.id);
console.log(user4.name);
var user5={};
user5.id=1005;
user5.name="李四";
console.log(user5.id);
console.log(user5.name);
//对象中的属性
console.log(user1.userage);
//添加属性
//通过对象.属性=值 和 对象[属性名] -值
user1.userage= 20;
user1["gender"]="男";
console.log(user1);
//Object { userid: 1001, username: "李华", userage: 20, gender:"男"}
//删除属性
delete user1.userage;
console.log(user1);//Object { userid: 1001, username: "李华", gender: "男" }
//Object { userid: 1001, username: "李华", gender: "男" }
//js中的每一个对象都是独立，只要是单独给某个对象添加属性，都不会影响到其他的对象。
//但是统一由同一个构造器创建的多个对象因为构造器相同，
//因此如果创建构造器发生变化，他们的属性会发生变化
//对象中方法的创建
//对象的方法也可以动态的添加、删除、方法只能通过对象.方法名来创建
user1.product = [];
user1.chooseProduct= function(product){
user1.product.push(product);
}
//调用方法
user1.chooseProduct("电脑");
user1.chooseProduct("手机");
user1.chooseProduct("空调");
console.log(user1);
//对象的遍历
//Object.values()、JSON.stringify()
var userArr=Object.values(user1);
console.log(userArr);//Array(5) [ 1001, "李华", "男", (3) […], chooseProduct(product) ]
var userJSON=JSON.stringify(user1);
console.log(userJSON);
//{"userid":1001,"username":"李华","gender":"男","product":["电脑","手机","空调"]}
//json键值对，一个键对应一个值
</script>js对象方法相应小练习
<script>
//练习
//创建一个Student对象
var Student =function(sname,sage){
this.sname=sname;
this.sage=sage;
}
var stu1=new Student("张三",18);
var stu2=new Student("李四",20);
//动态添加一个班级属性
stu1.sclass="终极一班";
stu1.classname=[];
//添加一个选课方法，将所有的课程加入到课程classname中
stu1.chooseClass=function(classname){
stu1.classname.push(classname);
}
stu1.chooseClass("语文");
stu1.chooseClass("数学");
stu1.chooseClass("英语");
console.log(stu1);
//创建一个遍历学生对象信息的方法
var stuJSONInfo=JSON.stringify(stu1)
console.log(stuJSONInfo);
</script>
JS中的函数创建
js中的函数主要由：函数名、参数、函数体、返回值这四个部分组成
语法：
function 函数名(参数){
函数体;
return 返回值;
}
<script>
//函数的声明和调用
//1声明的时候指定函数名称
function fun1(){
console.log("fun1函数被执行了");
}
//调用函数fun1
fun1();
//2.构造一个匿名函数，赋值给一个变量（变量的名称就会变成方法的名称）
var fun2= function(){
fun1();
console.log("fun2函数被执行了")
}
fun2();
//3.通过new关键字，调用Function()构造函数
var fun3 =new Function(console.log("函数fun3被调用了"));
</script>函数提升现象（重点，面试可能会问）
<script>
//函数声明的提升现象
//1.
fun =function(x,y){
return x-y;
}
/* 函数声明的提升
使用function声明的函数,提升优先级比变里提升要高不会被变量声明覆盖,但是会被变量的赋值覆盖 */
//2.
function fun(x,y){
return x+y;
}
/* 为什么返回-1，因为2处声明的函数提升到了最顶部，之后又被1处的函数赋值所覆盖，
所以,这里执行的fun其实是1处的函数 */
var num =fun(1,2);//-1
console.log(num);
</script>执行结果如下
JS中的函数是一个对象
通过typeof()方法测试发现，函数是一个function对象
所以，js中函数也存在一些属性和方法
属性 ：
arguments.length 可以返回函数被调用的时候，传入的参数的个数
方法：
toString() 返回函数的字符串格式
function fun4(a,b){
return arguments.length;
}
var num = fun4(1,2);
console.log(num);
//toString()方法
console.log(fun4.toString());es6中的函数
箭头函数的用法（非常非常重要）
箭头函数就是允许使用更加简单的写法来表达函数表达式，使用箭头函数的时候可以不写function关键字、return、花括号
<script>
//es5
var f1=function(a,b){
return a+b;
}
var n =f1(1,2);
//es6 箭头函数（让函数更加简洁，并没有其他实际的意义）
//使用箭头函数不会发生函数提升问题
const f2 = (a,b) => a+b;//const一般修饰常量，因为函数名一般不会被改变，
而且使用const不会影响方法功能
console.log(f1(1,2));//3
console.log(f2(1,2));//3
</script>
JS函数中的参数
js的函数的参数在函数声明的时候，并没有指定类型，参数可以传入任意类型
//无参函数
function f3(){
console.log("abc");
}
//有参函数
function f4(a,b){
console.log(a+b);
}
console.log("======================")
//不定长的参数
function f5(...param){
for (var i = 0; i < param.length; i++) {
console.log(param[i]);
}
}
f5(1,2,3,5,6,7);
参数的默认值设置
将来如果调用函数时，用户没有指定值，方法则会赋予一开始设定的默认值，如果给予了参数值，则会将原先的默认值覆盖。
//函数的默认值
function f6(name,age){
name= name ||"jack";
age =age || 18;
console.log(name+"--"+age);
}
f6();
f6("tom");
f6("lucy",20);
f6(30);
JS函数中的arguments对象
如果函数中调用的参数太多了，可以使用arguments来获取某些参数
//写一个函数，可以找到最小值,调用函数的时候可以传入一些数值
//(不指定不定长参数，而是通过arguments对象获取参数)
function findMin(){
var min =0;
for (var i = 0; i < arguments.length; i++) {
if(arguments[i]<min){
min=arguments[i];
}
}
return min;
}
var n =findMin(1,25,5.41,557,-9);
console.log(n);//-9
JS中this关键字的用法
js中的this，表示拥有当前函数的对象
1、this表示全局对象
当我们声明的函数的时候，没有将函数声明在对象中，那么函数中的this，就表示当前的窗口对象，也称为全局对象，在浏览器中，全局对象，指的就是window对象
2，this表示当前对象
如果将函数声明在对象中的时候，函数中的对象，就表示函数的所属对象
var user={
name:"jack",
age:20,
say:()=>{return this;}, //this使用在箭头函数中，指的是全局对象，
//可以把箭头函数当成一个单独的函数，没有特指的对象，找不到对象因此指向全局对象：Window(窗口)
show: function(){
return this;//而this使用在普通function函数中，指的就是当前调用该show方法的对象也就是user
//属于object对象
}
}
var j=user.say();
var k=user.show();
console.log(j);//指向windo
console.log(k);//指向user(隶属于Object)
JS中函数参数的传值方式
<script>
//传值调用
function fun1(s){
s="hello";
}
var s1="你好";
fun1(s1);
console.log(s1);//你好
//传底子调用
function fun2(user){
user.name="李四";
}
var stu ={name:"张三"};
fun2(stu);
console.log(stu.name);//李四
//传函数调用，根据传入的函数完成实际调用
//将函数作为参数传入到另一个参数中做运算
function add(a,b){
return a+b;
}
function sub(a,b){
return a-b;
}
function operate(a,b,fun){
return fun(a,b);
}
var n=operate(10,20,add);
console.log(n);//30
</script>
JS中的比值函数
用来比较两个数值的大小的，返回值是一个正数、负数、0，返回值是负数，从小到大，正数，从大到小
function（a,b）{
return a-b;
}
JS中内置函数（对象）
数学对象Math
基本和java中的math类相同
math对象方法
方法 描述
abs(x) 返回x的绝对值
ceil(x) 对x进行上舍入
floor(x) 对x进行下舍入
max(x,y,z...n) 返回最高值
min(x,y,z...n)返回最低值
pow(x,y) 返回x的y次幂
random() 返回 0~1之间的随机数
round(x)把x四舍五入为最接近的整数
日期对象Date
创建date对象
date对象由新的date（）构造函数创建。
有4种方法创建新的日期对象：
new Date（）
new Date(year,month,day,hours,minutes,seconds,milliseconds)
new Date(milliseconds)
new Date(date string)
日期获取方法
获取方法用于获取日期的某个部分（来自日期对象的信息）。下面是最常用的方法（以字母顺序排序）：
方法 描述
getDate() 以数值返回天（1-31）
getDay() 以数值获取周名（0-6）
getFullYear() 获取四位的年（yyyy）
getHours() 获取小时（0-23）
getMilliseconds() 获取毫秒（0-999）
getMinutes() 获取分（0-59）
getMonth() 获取月（0-11）
getSeconds() 获取秒（0-59）
getTime() 获取时间（从 1970 年 1 月 1 日至今）
<script>
var date = new Date();
console.log(date.getFullYear());
console.log(date.getMonth()+1);
console.log(date.getDate());
console.log(date.getDay());
console.log(date.getHours());
console.log(date.getMinutes());
console.log(date.getSeconds());
console.log(date.getTime());
</script>
3032
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
