函数，也称之为方法，是完成某个功能的代码块
function 是定义函数的关键字
函数分为：1.无参函数 2.带参函数 3.带返回值的函数
1.定义无参函数，函数的()里面没有定义参数，这样的函数就是无参函数
function fun1(){
let num1 = 100
let num2 = 200
console.log(`${num1}+${num2}=${num1+num2}`);
}
函数必须要调用后，才会执行里面的代码
fun1() //输出100+200=300
console.log('----------------------------');
2.定义带参数函数，函数的()里面需要传参数，参数可以传多个，参数名是自定义的
函数在定义时候，定义的参数是：形参
function fun2(num1,num2){
console.log(`${num1}+${num2}=${num1+num2}`);
}
带有带参数的函数时，传递具体的实际值（函数在调用时，传递的参数是：实参）
fun2(100,200) //输出100+200=300
fun2(1000,2000) //输出1000+2000=3000
fun2(10,20) //输出10+20=30
调用带参数的方法时，如果没有传递参数，那么参数就是值就是undefined
fun2() //输出undefined+undefined=NaN
console.log('----------------------------');
3.带返回值的函数
function fun3(num1,num2){
let sum = num1+num2
return关键字，只能用的函数中，用于返回函数的执行结果
return sum;
}
调用带返回值的函数，需要通过变量接收函数的返回值。
let sum = fun3(100,200)
console.log(sum); //输出300
定义函数真正的作用，其实就对代码进行封装，让一段代码可以重复使用。
1.定义一个格式化日期的方法
function formatDate(date){
//获取年月日，时分秒
let year = date.getFullYear()
let month = date.getMonth() + 1
let day = date.getDate()
let hour = date.getHours()
let minute = date.getMinutes()
let second = date.getSeconds()
//将获取到的时间信息，拼接成一个字符串
let str = [repair0(year), repair0(month), repair0(day)].join('-') +
' ' + [repair0(hour), repair0(minute), repair0(second)].join(':')
return str
}
2.定义一个补零的方法
function repair0(num){
return (num+'').length>1 ? num : '0'+num
//转字符串
}
3.定义一个对数组排序的方法
function mySort(arr){
// 第一层循环，控制每轮选择的数
for(let i=0;i<arr.length-1;i++){
// 第二层循环，控制每轮参与比较的数（第一轮，j从1-4；第二轮，j从2-4）
for(let j=i+1;j<arr.length;j++){
//如果选择的数 大于 参与比较的数 就互换
if(arr[i] > arr[j]){
let temp = arr[i]
arr[i] = arr[j]
arr[j] = temp
}
}
}
}
<!-- 导入外部js -->
<script src="./js/kai.js"></script>
<script>
//创建一个当前日期
let date1 = new Date()
//创建一个指定日期
let date2 = new Date('2020-1-1 12:8:8')
//根据时间戳创建一个日期对象
let date3 = new Date(123234214213)
console.log(formatDate(date1)); //输出2021-11-26 10:15:21
console.log(formatDate(date2)); //输出2020-01-01 12:08:08
console.log(formatDate(date3)); //输出1973-11-27 15:43:34
console.log('-----------------------------');
let arr1 = [11,66,33,245,7,99]
let arr2 = [77,234,5,66,28]
mySort(arr1)
mySort(arr2)
console.log(arr1); //输出(6) [7, 11, 33, 66, 99, 245]
console.log(arr2); //输出(5) [5, 28, 66, 77, 234]
手写实现字符串的函数
let str = 'abcdefg'
1.获取一个字符串指定下标的字符
function charAt(index){
return str[index]
}
console.log(charAt(3)); //输出d
console.log('------------------------------');
2.定义一个函数，返回字符串中指定字符第一次出现的位置
let str2 = "abc你好def你好gwt"
function indexOf(str){
let index = -1; //定义一个变量，用于表述字符串的位置
//循环出字符串中所有的字符串
for(let i=0;i<str2.length;i++){
if(str2[i]===str){
//如果相对，就返回对应的下标
index = i;
break;
}
}
return index;
}
console.log(indexOf('你')); //输出3
console.log(indexOf('好')); //输出4
console.log('------------------------------');
3.定义一个函数：返回字符串中指定字符最后一次出现的位置
function lastIndexOf(str){
let index = -1 //定义一个变量，用于表述字符串的位置
//循环出字符串中所有的字符串
for(let i=str2.length-1;i>=0;i--){
//挨个比较字符串中所有的字符
if(str2[i]===str){
//如果相对，就返回对应的下标
index = i;
break
}
}
return index
}
console.log(lastIndexOf('你')); //输出8
console.log(lastIndexOf('好')); //输出9
console.log('-----------------------------');
4.定义一个函数：用于截取指定区间范围内的字符串，如果只传一个参数，从起始位置往后全部截取
let str3 = 'abcdefghijklmn'
function substring(index1,index2){
let sum = ''; //定义一个变量，用于保存截取的结果
//如果index2没有值，截取到最后
if(index2==null){
for(let i=index1;i<str3.length;i++){
sum+=str3[i];
}
}else{
//确定循环的范围
for(let i=index1;i<index2;i++){
sum+=str3[i];
}
}
return sum;
}
console.log(substring(3,7)); //输出defg
console.log(substring(3)); //输出defghijklmn
console.log('------------------------------');
5.定义一个函数：用于截取指定长度的字符串，第一个参数是位置，第二个参数是长度
function substr(index,len){
let sum = ''; //定义一个变量，用于保存截取的结果
//如果len是空，那么就从起始位置到最后全部截取
if(!len){
for(let i=index;i<str3.length;i++){
sum+=str3[i];
}
}else{
for(let i=index;i<index+len;i++){
sum+=str3[i];
}
}
return sum;
}
console.log(substr(3,7)); //输出defghij
console.log(substr(3)); //输出defghijklmn
手写实现数组的函数
1.手写一个数组函数，用于从数组中检查指定的数据是否存在，存在返回true，不存在返回false
let arr1 = [11, 22, 33, 44, 55]
function includes(val) {
let isFind = false; //定义一个变量，用于表示是否找到
//循环数组
for (let i = 0; i <= arr1.length; i++) {
//判断数组中的每一个元素
if (arr1[i] == val) {
isFind = true;
break; //加上这个break，可以提高性能
}
return isFind;
}
}
console.log(includes(33)); //输出true
console.log(includes(88)); //输出false
console.log('----------------------');
2.手写一个数组函数：用于将一个数组根据某个字符串拼接成字符串，该方法不传参数，默认是根据逗号拼接
function join(str) {
let sum = '' //定义一个字符串，用于拼接
//如果str是空，赋值为逗号
if (str == null) {
for (let i = 0; i < arr1.length - 1; i++) {
sum += arr1[i] + ','
}
sum += arr1[arr1.length - 1]
return sum;
} else {
//拼接数组最后一位前面的所有数据
for (let i = 0; i < arr1.length - 1; i++) {
sum += arr1[i] + str
}
//最后再拼接数组的最后一位
sum += arr1[arr1.length - 1]
return sum;
}
}
console.log(join('你好')); //输出11你好22你好33你好44你好55
console.log(join()); //输出11,22,33,44,55
console.log('-------------------------');
3.手写push
function push(val) {
//增加一个数组空间，存储数据
arr1[arr1.length] = val
}
push(66)
console.log(arr1); //输出(6) [11, 22, 33, 44, 55, 66]
push(77)
console.log(arr1); //输出(7) [11, 22, 33, 44, 55, 66, 77]
console.log('-------------------------');
4.手写pop
function pop() {
//重新设置数组的长度，会去掉最新长度后面的元素。
arr1.length = arr1.length - 1
}
pop()
console.log(arr1); //输出(6) [11, 22, 33, 44, 55, 66]
console.log('-------------------------');
5.手写unshift
function unshift(str) {
let strs = []
strs[0] = str
for (let i = 1; i <= arr1.length; i++) {
strs[i] = arr1[i - 1]
}
return strs;
}
console.log(unshift(33)); //输出(7) [33, 11, 22, 33, 44, 55, 66]
6.手写shift
function shift(arr) {
let strs = []
for (let i = 0; i < arr.length - 1; i++) {
strs[i] = arr[i + 1]
}
return strs;
}
console.log(shift(arr1)); //输出(5) [22, 33, 44, 55, 66]
7.手写reverse
方法一：
function reverse() {
let strs = [];
let len = arr1.length;
for (let j = 0; j < len; j++) {
for (let i = len - 1; i >= j; i--) {
strs[j] = arr1[i];
}
}
return strs;
}
console.log(reverse()); //输出(6) [11, 22, 33, 44, 55, 66]
方法二：
/* function reverse() {
//算出比较的次数（6个数比较3次，7个数也是比较3次）
let count = Math.floor(arr1.length / 2)
//循环比较的次数
for (let i = 0; i < count; i++) {
//将前面的数，通过一个中间变量保存
let temp = arr1[i]
//将后面的数赋值给前面的数
arr1[i] = arr1[arr1.length - 1 - i]
//再将中间变量的值，赋给后面的数
arr1[arr1.length - 1 - i] = temp
}
}
reverse()
console.log(arr1); */
定义函数的三种方式
1.第一种方式：通过function关键字直接定义
function fun1(){
console.log('我是方法一');
}
fun1() //输出我是方法一
2.第二种方式：定义一个变量，接收定义的函数
let fun2 = function(){
console.log('我是方法二');
}
fun2(); //输出我是方法二
3.第三种方式：箭头函数，其实就是第二种方式的简写。(ES6新推出的一种方式)
let fun3 = ()=>{
console.log('我是方法三');
}
fun3() //输出我是方法三
console.log('---------------------');
/* let fun4 = (num1,num2)=>{
return num1 + num2
} */
4.如果箭头函数的函数体，只有一条语句，可以省略大括号，如果这一条语句还是返回语句，return关键字必须省略
let fun4 = (num1,num2)=>num1 + num2
console.log(fun4(100,200)); //输出300
let fun5 = (num1,num2)=>console.log(`${num1}+${num2}=${num1+num2}`);
fun5(100,200) //输出100+200=300
5.如果箭头函数的参数，只有一个，那么可以省略小括号
let fun6 = num=>console.log(num*3);
fun6(100) //输出300
6.如果箭头函数没有参数，通常要保留小括号，如果非要去掉小括号，需要写一个下划线占一个位置
let fun7 = _=>console.log('我是箭头函数')
fun7() //输出我是箭头函数
定义几个工具方法
1.判断是否是闰年的方法
let isLeapYear = year => year % 4 === 0 && year % 100 !== 0 || year % 400 === 0
2. 对个位数字补零的方法
let repair0 = val => val < 10 ? '0' + val : val
3.返回一个日期的短日期格式方法
let miniDate = (date, type) => {
let year = date.getFullYear(); //年
let month = date.getMonth() + 1; //月
let day = date.getDate(); //日
let hour = date.getHours(); //时
let minute = date.getMinutes(); //分
let second = date.getSeconds(); //秒
let week = date.getDay(); //周几
4.定义一个返回值，默认拼接：年，月，日
let ret = [repair0(year), repair0(month), repair0(day)].join("-");
if (type == "1") {
ret += " " + [repair0(hour), repair0(minute), repair0(second)].join(":");
} else if (type == "2") {
ret +=
" " +
[repair0(hour), repair0(minute), repair0(second)].join(":") +
" 星期" +
"日一二三四五六"[week];
}
return ret;
};
5.对字符串反转的方法
let reverseStr = str => str.split('').reverse().join('');
console.log(isLeapYear(2000)); //输出true
console.log(isLeapYear(2003)); //输出false
console.log('------------------------');
console.log(repair0(15)); //输出15
console.log(repair0(5)); //输出05
console.log('------------------------');
console.log(miniDate(new Date())); //输出2021-11-26
console.log(miniDate(new Date(), '1')); //输出2021-11-26 11:36:56
console.log(miniDate(new Date(), '2')); //输出2021-11-26 11:36:56 星期五
console.log('------------------------');
console.log(reverseStr('abcdefg')); //输出gfedcba
递归方法
什么是递归方法：就是一个方法，自己调用自己
// 注意：递归方法，一定要控制好何时跳出，否则就是死循环
// 经典面试题：使用递归算法1-20之间所有数之和
function calc(num){
//这个if是退出递归的条件
if(num===1) {
return num
}
return num + calc(num-1)
}
console.log(calc(1)); //输出1
console.log(calc(2)); //输出3
console.log(calc(3)); //输出6
console.log(calc(20)); //输出210
递归方法的实际应用
实现系统菜单
方法一：用循环
function fun1(){
let menu = 0
do{
menu = parseInt(prompt('1.添加 2.修改 3.删除 4.查询 0.退出'))
switch(menu){
case 1:
alert('执行添加')
break;
case 2:
alert('执行修改')
break;
case 3:
alert('执行删除')
break;
case 4:
alert('执行查询')
break;
default:
alert('欢迎下次继续使用');
break;
}
}while(menu!==0)
}
// fun1()
方法二：用递归
function fun2(){
let menu = parseInt(prompt('1.添加 2.修改 3.删除 4.查询 0.退出'))
switch(menu){
case 1:
alert('执行添加')
fun2() //在方法内部，又重新调用自己
break;
case 2:
alert('执行修改')
fun2()
break;
case 3:
alert('执行删除')
fun2()
break;
case 4:
alert('执行查询')
fun2()
break;
default:
alert('欢迎下次继续使用');
break;
}
}
fun2()
