function  sum() {
console.log('hello')
console.log('饥人谷')
}
这是声明函数，调用就直接：
sum()

另一种声明方式：
var sum = function() {
console.log('hello')
console.log('饥人谷')
};
sum()

参数：
 function sum( a , b) {
console.log( a + b)
return a + b
};
sum( 3 ,4)
得到7。

 function sum( a , b ,c) {
console.log( a + b +c)
return a + b
};
sum( 3 ,4)
输出NaN,因为c是undefined。而且声明下，在控制台的输出的是console.log的执行的功能后展示的内容。
这里顺便联想了一下，console.log语句或表达式输出的内容是这个语句在控制台的一种功能作用的结果，它相当于控制台的一个工具，而这个表达式或语句本身的值是undefined。
而return的才是给读者的反馈。同时，return必须放到函数内部，只有在内部，才可以使参数有意义的。

function say( name,age) {
console.log( name + 'says: I am' +age +'years old')
}
say( '小哥',6)
’小哥says: I am  6 years old'

function say( name,age) {
console.log( name + 'says: I am' +age +'years old')
}
says( 6)
'6 says: I am  undefined years old'
6是name的值，剩下的undefined。

var result =sum( 4 ,6)
function sum(a ,b)  {
console.log(a + b)
}
console.log(result)
输出10，这里是console.log到调试里的显示结果，返回值是return的值。sum没有返回值，默认为undefined值。console.log(a)是运行显示了a，但是这句话本身的结果是undefined。

遇到return,后面就完全停了。
function fn( score){
if(score < 0){ 
return
}
console.log(score)
}
fn( -3 )
return 后面没有赋值，就是返回undefined的意思。
调用时，fn( -3 )
返回undefined,后面不执行了。
这个等同于——
function fn(score) {
if(score <0)  {

}else {
console.log(score)
}
}
fn(-3)

参数相关和arguments:
function printName () {
var name = arguments[0]
console.log(name)
}
printName('Byron')

还有一种写法——
function printName(name){
    console.log(name);
}
printName('Byron');
第二种是最直接的命名然后就可以用了，逻辑很简单的，第一种是把参数name值通过arguments传递了过来，如果这时候没有赋值，arguments值为undefined输出为undefined。


声明提前——
js文件都是顺序执行的哦。
变量的：
console.log(a)
console.log(b)
var a=3
执行的结果是a输出undefined不报错，b输出undefined报错了。
为什么？var a =3等同于——
var a   //这是声明，规则是放到所在区块的前端，然后再执行。
a = 3

也就是在浏览器逻辑解析下，就是这个样子执行：
var a
console.log(a)
console.log(b)
 a=3
这样就明白了吧，a现在已经声明了，但是执行console.log时，3的值还没生效，为undefined，当然把执行语句放到a=3后面执行，就可以了。
b又没声明，又没值。

函数的：

sum(3,5)
function sum(a ,b){
console.log( a + b)
}
这时候运行起来，得到8。甚至在sum和函数中间加点语句也会显示。这里要说，函数声明跟变量声明类似，在执行之前，把所有的变量声明和函数声明拿到执行语句的前面。
表达式的声明：
fn()
var  fn = function(){
console.log('haha')
}
运行报错了。为什么？
函数表达式的角度看，上面的代码等同于：
var  fn
fn()
fn = function(){
console.log('haha')
}
按顺序来，fn现在只是声明了，是undefined,而fn()是把fn当成函数了，所以报错了。

立刻执行的函数表达式——
（function(){
console.log('haha')
}）()
输出"haha",小括号的优先级高，被认为是个值，一个值加()，被认为是函数。
相当于：
var fn = function(){
console.log('haha')
}
fn ()

命名冲突——

var fn = 3
function fn(){  }
console.log(fn)
等同于
var fn  //声明，fn is undefined
function fn(){ }  // fn赋予了函数声明，覆盖了undefined状态
fn = 3  //  3的值赋予到a，这个操作才是最终的结果
console.log(fn)  // 3

function fn(){  }
console.log(fn)
var fn = 3
等同于：
function fn(){  } //声明,fn不仅有了var fn的意义，更进一步添加了函数的内在身份
var fn   //声明 ，无所谓影响了，最
console.log(fn)   // function fn(){  }
 fn = 3  // 赋值

function fn(fn ){
console.log( fn )
var fn = 3
console.log( fn )
}
fn(10)
如果出现了参数与函数命名重复了怎么办？假设一个arguments[0]。
变成如此：
function fn( ){
var fn = arguments[0] //这时候把10赋予过来了
console.log( fn )  // 输出10
var fn = 3  //3覆盖掉10的值
console.log( fn )  //输出3
}
fn(10)  //10,3

这里就有些类似于我高考的数学变形题目了，fn(fn)跟fn(10)的关系就是得到了现在fn=10，回归到函数内部，就还有一个语句运行环境的观念，千万不要想当然，整个函数运行起来，fn=10适用于所有语句了。能说它嵌套吗？也不算。

递归函数——
function fn(n ){
if (n ==1){
return 1
}     // 限制n为1时的0或者出现负数
return n*fn(n-1)  //这是表达式
}
fn (4) //24，就是1*2*3*4
效率低，需要计算1,2,3,4,的，算4次，就是逻辑清晰简单而已。

作用域——————
{
var a = 3
}
console.log(a) //1，也没报错，直接写大括号没作用域

js里没有块级作用域。
循环：
for(var i =0; i<10; i++){
var a = 3
}
console.log(a) //3,这里的意思就是循环语句里的变量作用于全局的，也就是没有作用域，包括里面的i。当然循环语句会声明前置到代码顶部。
这里很容易混淆，因为重点就是讲函数的作用域的。
function fn(){
var a =1
if (a>2){
var b =3
}
console.log(b)
}
fn()//1<2，直接运行后面的console.log(b),b没声明，undefined
console.log(a)// 报错了，因为函数作用域，a是函数内部变量，全局里没有它。

这里的意思就是变量都是有作用区域的，声明区域多大，它的意义就发挥在多大空间，跟数学函数的自变量的范围差不多。函数内的变量只能有意义在这个函数内部，那全局变量对函数本身内部呢？

function fn(){
a = 2
}
fn()
console.log(a)//2，不写var去声明变量，就是全局的性质，外部可以用它了。所有以后声明变量一定要逻辑清晰，慎重。在最外层写全局的，能写var就写上。