颠覆认知的『JavaScript』篇——04 函数基础与种类、形实参及映射、变量类型

一、函数的基础与种类

1. 函数的作用

功能的封装、解耦合

2. 函数名命名规则

1. 不能以数字开头
2. 字母_$开头
3. 可以包含数字
4. 小驼峰命名法

函数的定义：

// 函数声明的方式定义
function name(arg1, arg2) {
	...
}
  
// 函数表达式的方式定义
var name = function(arg1, arg2) {
	...
}

var test = function test1() {
  var a = 1,
      b = 2;
  // 可以在函数内部调用test1()
  console.log(a, b);
}

// 如果是匿名函数，则打印test
console.log(test.name); // 'test1'
test(); // 1 2

二、形实参以及映射

1. 形参，占位用的

函数定义里的参数

2. 实参

函数调用时传入的参数

var aa = Number(window.prompt('a'));
var bb = Number(window.prompt('b'));

// a, b 形参
function test(a, b) {
  console.log(a + b);
}

// aa,bb 实参
test(aa, bb);

3. 形参和实参的个数可以不相等

function test(a, b) {
  // 函数形参个数
  console.log(test.length); // 2
  // 函数实参个数
  console.log(arguments.length); // 3
}

test(1, 2, 3);
//实参多一个不会报错



function test(a,b,c){
    console.log(a,b,c);
}
test(1,2);

//这了c没有传值，就是undefined，不会报错

4. arguments

1．类数组对象。

2. 存储实参列表。

3. 可以在函数内部修改传入的实参值。

4. 实参未传入时，在函数内部给行参赋值无效。

这就是一种映射关系，改变一个，对应的就会改变。
 

function test(a, b, c) {
  a = 3;
  c = 5;
  console.log(arguments[0]); // 3
  console.log(arguments[2]); // undefined
}

test(1, 2);

5. 根据传入的实参可以求和

function sum(){
    var a =0;
    for(var i=0;i<arguments.length;i++){
        a+=arguments[i];
    }
    console.log(a);
}

6. return语句

1．终止函数执行

2．返回相应的值

js引擎会在函数体中末尾加入隐式return;

只有被执行了才会返回undefined否则返回函数体
 

function test(name) {
  return name || '你没有填写姓名';
}

console.log(test()); // '你没有填写姓名'


console.log(function cc(){});//ƒ cc(){}
function dd(){}
console.log(dd);//ƒ dd(){}
console.log(dd());//undefined

三、变量类型

1. 全局变量

1．在全局环境下声明的变量在任何地方都可以访问。

2．在函数内定义变量时省酪var操作符，可以创建一个全局变量。只要调用一次该函数,

就会定义这个变量，并且可以在函数外部访问到。
 

2. 局部变量

使用var操作符定义的变量会成为包含它的函数的局部变量，该变量将在函数退出时销毁。
 

// 全局变量
a = 1;
function test1() {
  // 局部变量
  var b = 2;
  console.log(a, b);	// 1 2
  // 重新赋值全局变量a    a -> 4
  a = 4;

  function test2() {
    // 局部变量
    var c = 3;
    // 重新赋值test1内的变量b   b -> 5
    b = 5;
    console.log(b);		// 5
  }
  test2();
  // test2函数运行完时局部变量c被销毁
  console.log(c); // ReferenceError
}

test1();

函数就是一个固定的功能或者是程序段被封装的过程，实现一个固定的功能或者是程序，在这个封装体中需要一个入口和一个出口，入口就是参数，出口就是返回

四、作业

定义一个函数，从wp接收一个饮料的名称，函数返回对应的价格
 

function test1(name) {
  switch (name) {
    case '可乐':
      console.log('3￥');
      break;
    case '矿泉水':
      console.log('1￥');
      break;
    case '脉动':
      console.log('5￥');
      break;
    case '营养快线':
      console.log('4￥');
      break;
    default:
      console.log('无');
  }
}

var name = window.prompt('请输入饮料的名称');
test1(name);

定义一个函数，从wp接收第一个数，接收一个运算符号(+-*/ %)，接收第二个数，利用这个函数做运算，并返回运算结果
 

function test2(value1, type, value2) {
  switch (type) {
    case '+':
      console.log(value1 + value2);
      break;
    case '-':
      console.log(value1 - value2);
      break;
    case '*':
      console.log(value1 * value2);
      break;
    case '/':
      console.log(value1 / value2);
      break;
    case '%':
      console.log(a % b);
      break;
    default:
      console.log('输入格式错误');

  }
}

var value1 = Number(window.prompt('请输入第一个数字'));
var type = window.prompt('请输入运算符');
var value2 = Number(window.prompt('请输入第二个数字'));
test2(value1, type, value2);

定义一个函数，从wp接收一个n，算出n的阶乘，不能用for循环
 

function test3(n) {
  if (n < 0) {
    return '请输入一个正整数';
  }
  if (n === 0) {
    return 1;
  } else if (n > 0){
    return test3(n - 1) * n;
  }
}
var n = parseInt(window.prompt('请输入一个正整数'));
console.log(test3(n));

定义一个函数，从wp接收一个n，算出斐波那契数列的第n项，不能用for循环
 

function test4(n) {
  if (n <= 0) {
    return 0;
  }
  if (n === 1 || n === 2) {
    return 1;
  } else {
    return test3(n - 1) + test3(n - 2);
  }
}
var n = parseInt(window.prompt('请输入一个正整数'));
console.log(test4(n));