JavaScript学习笔记5

一、函数function

function 随便起个名(){}
例：


以上情况就是耦合，耦合程度非常高，耦合代码就是低效代码

编程讲究高内聚，弱耦合

第二个就是简便写法：可以用test调用执行，写几个test就调用执行几次

例：

答案：357
写了一个test()；就执行了一遍函数语句，如果不写test()；就相当于有一个框来存东西，但是不执行

例：

        function test() {
            document.write('hello world');
        }

函数function可以先定义功能，之后再去用

二、函数定义

1.函数声明

定义一个函数可以先写一个function，函数就是另一个类型的变量

我声明一个函数test,test是函数名。
写成下面

function test(){
	函数体
}

函数名起名：开发规范要求，函数名和变量名如果由多个单词拼接，必须符号小驼峰原则（第一个单词首字母小写，后面的首字母大写）

function theFirstName() {
            document.write(theFirstName);
        }

答案：function theFirstName(){}。打印出来的是函数体

这与c语言和c++不同，他们打印指针，会输出指针的地址，而js这种弱数据语言（解释性语言）永远不输出地址，输出地址指向房间

2.函数表达式

var test = fuction test (){
document.write(‘a’);
}
test();

答案 a。这种方式像定义一个变量

上面这种方式，可以演变成第三种，匿名表达式【不写 test 这种函数名】

例 var demo = fuction (){
document.write(‘a’);
}

(1)命名函数表达式

上面这个函数的函数名name是abc

在控制台 console 直接输出 test 就会出现函数

在控制台 console 直接输出 abc 会报错，表达式就会忽略他的名字 abc。

在上面例子中，fuction abc(){document.write(‘a’);}这一部分叫表达式，是会忽略abc 这个地方的名字，会变成匿名函数表达式，不如直接写成匿名函数

(2)匿名函数表达式（常用，一般说的函数表达式就是匿名函数表达式

三、组成形式

1. 函数名称

function test(){}其中 function 是函数关键字，test 是函数名，必须有(){}，参数可有可没有，参数是写在()括号里面的。

如果写成 function test(a，b){}，相当于隐式的在函数里面 var a，var b 申明了两个变量，（）括号里面不能直接写 var

function test(a, b){
 document.write(a + b)
}
test(1, 2)

答案 3。上面这个例子，1 就会到 a 里面去，2 就会到 b 里面去，这是传参的形式

2. 参数（可有可没有，但是高级编程必有）

(1)形参（形式参数）：指的是 function sum（a，b）{}括号里面的 a 和 b

(2)实参（实际参数）：指的是 sum（1，2）；里面的 1，2

js天生不定参，形参可以比实参多，实参也可以比形参多

答案 37，参数把函数抽象了，可以组成很多形式

例 如果第一个实参的数大于 10，就减第二个数的运算结果；如果第一个实参的数小于 10，就加第二个数的运算结果

答案 3
上面改成 sum(11,2) //答案 9

例 function sum(a,b){
 document.write(a);
}
sum(11, 2, 3)
//答案 11 

例 function test(a, b, c,d) {
 document.write(a);
document.write(d);
}
sum(11, 2, 3)
//答案 11,undefined，上面这道题是形参多，实参少

js 参数不限制位置，天生不定参数
在每一个函数里面都有一个隐式的东西 arguments 这个是实参列表

function test(a) {
 console.log(arguments);
 console.log(arguments.length);
}
sum(11, 2, 3)

function test(a) {
 for(var i = 0; i < argument.length; i++){
 console.log(arguments[i]);
 } }
sum(11, 2, 3)

形参长度求法
function sum(a, b, c, d) {
 console.log(sum.length);
 }
sum(11, 2, 3)
//答案 4

任意个数求和(不定参才能求出来)

形参永远有尽头，要实现任意的数求和，无法定义形参。

答案是 2。a 变，arguments 跟着变。有一个映射关系。

答案 3。arguments 里面一个变，一个跟着变，但是[1,2]是两个人，相当于映射关系

当形参两个，实参一个

function sum(a, b){
//arguments[1]没值
 b = 2;
 console.log(arguments[1]);
}
sum(1);

//答案 undefined，实参列表出生时有几个，就有几个，
//再写 b=2，也不加在 arguments[1]里面了，此处的 b 就当变量用，他和实参不映射。

形参实参完全对应上才映射

例 function sum(a, b){
 //arguments[1]没值
 a = 2;
 console.log(arguments[0]);
}
sum(1);

//答案 2

3. 返回值 return

结束条件和返回值 return，return 有终止函数的功能

例 function sum(a, b){
 console.log(‘a’);
 console.log(‘b’);
 return;
}
//答案 a，b

例 function sum(a, b){
 console.log(‘a’);
return;
 console.log(‘b’);
}
//答案 a
//没写 return，实际上是加上了一个隐式的 return

return 最常用的是返回值。本意是把一个值返回到函数以外

自己定义的函数也能返回,return 空格 123

<script>
        function sum() {
            console.log(num); //undefined
            return 123;
            console.log('a');
        }
        var num = sum();
        console.log(num); //123
        //闭包
    </script>

答案这里的 num 就是 123，而且 console.log(‘a’);无效，这里的 return 又终止函数，又返回变量

例把 target 转成数字
function myNumber(target){
 return +target; //利用+隐式的转换成了数字类型
}
var num = myNumber(‘123’);
console.log(typeof(num) + “” + num);
//答案 number 123

一般函数处理完一个参数，是为了返回

typeof()也是返回值，也是函数

typeof(123)也可以写成 typeof 123【typeof 空格 123】，只是看起来不方便

四、作业

1.写一个函数，功能是告知你所选定的小动物的叫声。
2.写一个函数，实现加法计数器。
3.定义一组函数，输入数字，逆转并输出汉字形式。
4.写一个函数，实现 n 的阶乘。
5.写一个函数，实现斐波那契数列。

1、此处可用 break，也可以用 return
2、略

3、

reverse 是逆转
str.charAt(0)意思是把第 0 位拿出来
for(var i = num.length - 1; i >= 0)这是倒着拿的意思
一个字符串长度是 3，他的第三位字符串是 2
可以把第二个 function 放第一个里面，但是一般单独写，因为transfer 是转换
str += transfer(num[i]);是先执行后面的 transfer(num[i])，再赋值给前面


字符串的底层也是数组，取字符串中的字母也可以str[0]这样取

4、

方法一 function jc(n){
//n 的阶乘
 for(var i = 1; i <= n; i ++){
 num *=i;
} }
方法二 function mul(n){
 if(n == 1 || n == 0){
 return 1;
}
 return n * mul(n - 1);
}

方法二叫递归：
1 找规律，
2 找出口（找停的点）
递归的优点是代码简洁，缺点慢

5、拿递归写斐波那契数列 fb(n)==fb(n - 1) + fb(n - 2);

答 function fb(n){
if(n == 1 || n== 2){
 return 1;
}
 return fb(n - 1) + fb(n - 2);
}

递归返回的顺序：先执行的最后被返回，最后执行完（等最底层的一层层返回）