JS函数浅析（一）

1.万物皆为对象

　　提起函数首先要知道对象，而对象又是js数据类型中的一种，所以我们从头开始。

　　1）javascript数据类型有哪些?
          原始数据类型:number,undefined,null,string,boolean

　　   引用数据类型:object

　　2）数据类型的检测：

由于js中的变量是松散类型的，所以它提供了一种检测当前变量的数据类型的方法，也就是typeof关键字.

typeof   123　　 //Number

typeof   'abc'　　//String

typeof    true       //Boolean

typeof    undefined   //Undefined

typeof    null        //Object

typeof    { }           //Object

typeof    [ ]           //Object

typeof    console.log()       //Function

null类型进行typeof操作符后，结果是object，原因在于，null类型被当做一个空对象引用。

面试会遇到的坑:

　　  typeof(需要检测的内容) -- number，string，boolean，function，object，undefined （返回的结果类型都是string类型）。

　　  typeof(null)  　　返回的结果类型为object

　　3）引用数据类型：

　　对象都有自己的属性和方法：　

function fun(a,b,c){    //函数类对象

}
console.log(fun)   //fun它也是window对象底下的属性
//fun自己的属性
    console.log(fun.name)   //输出函数的函数名
    console.log(fun.length) //形参的个数
    console.log(fun.prototype)   //原型

//函数也是可以直接当成对象使用的
//对象的增删查改
    fun.abc = 123;  　　　　　　　//增
　　 fun.bcd = function(){　　　　//增一个特殊的元素
　　　　　　console.log("hello")
　　　} 
　　 fun.bcd()；
    fun.abc；　　　//查
    fun.abc = 456;　　//改
    console.log(fun.abc);
    delete fun.abc；　　　　//删

　　　

　　4）原始数据类型：

　　  可以改变的引用类型，和不可以改变的原始类型(这个地方的改变和不改变表示的是存储结构)；

var s = 'hello';
s.toUpperCase();    //返回'HELLO',但是并没有改变s的值
alert(s);           //返回 hello;
var a=1;
//这行语句中包含了两个量：一个是a，他叫变量，这个大多数人都知道；一个是1，他叫数值型常量，这个大多数人都会忽略，以为一个数字、字符串、布尔值跟常量变量扯不上关系。不要以为1不算“量”，1就是值恒为1的常量，2就是值恒为2的常量...
var a=false;
//同上，a是布尔型变量，false是布尔型常量,他的值不能被改变，false永远代表false;
var a='abc';
//同理，'abc'叫字符型常量，或者叫字符串常量。还记得经典的JS报错“未结束的字符串常量”么？意思就是没找到到一个字符串常量的结束符：引号。
//综上，所有为固定值永恒不变的量就是常量，也就是不可变的量。
//其他很多语言可以用const关键字定义一个自己命名的常量，JS中没有用const去定义一个常量的功能，可以定义一个变量当“常量”用，自己别改就行。

　　  原始类型属性的添加；

var str = "hello world";
str.abc = 123;   //自己添加属性

console.log(str.length)   //自己自带的属性

console.log(str.abc)  //原始类型不能添加属性，如果添加，不会报错，添加完成系统检测为原始类型后马上删除

　　  当用new的方式创建一个字符串时：（此时为一个对象，数据类型自然变成了引用数据类型）

var str2 = new String("hello world");    //一定出来的是对象
console.log(str2.length)
str2.abc = 456;
console.log(str2.abc);

　　　number等其他类型也一样：

 var num = 123;
 num.abc = 456;
 console.log(num.abc)

 var numobj = new Number(123);
 numobj.abc = 456;
 console.log(numobj.abc)

　　实例:

var str = "hello world";

            var len = typeof(str);    

            if(len.length == 6){
                len.abc = "typeof检测的结果为string类型";
            }

            console.log(len.abc);     //最后输出的是什么？

输出的是undefined,len.length=6可以走进循环，只是len是原始数据类型，可以添加，但是添加完成马上就删除了。

2.函数作用域

在JavaScript中,ES6以前有三种情况：
 1.全局作用域

　 var num = 100;
   function fun(){
     console.log(num)
     var num1 = 200;
     function fun2(){
       console.log(num1);
     }
   }
  fun()

　　  使用var声明的变量不是全局就是局部，不是用var声明的变量都是全局变量

 　　2.函数作用域 (局部作用域)

function fun(){
   num = 100;
}
fun()； 
console.log(num)；

　　  函数如果不调用，永远不会执行，管你里面的代码是什么东西，再多的错误不执行也是不会抛出的

　　 3.es6中有块级作用域

　　过去，javascript缺乏块级作用域，var声明时的声明提升、属性变量等行为让人困惑。ES6的新语法可以帮助我们更好地控制作用域。（这一部分待后续完善）

3.函数声明和函数表达式

　　函数声明

    function fun(){
                                      //函数声明
    }        

　　函数表达式

　　var abc = function fun(a,b,c,d){    //函数表达式
       console.log("hello")
    }

// 调用abc?fun?
   abc()；
   fun()；　　　　　　　　//会报错

console.log(abc.name) //除了这个地方可以看到fun以外，其他没有任何用处
   console.log(fun.name)//会报错

console.log(abc.length)
   console.log(fun.length)

　　  abc这个时候就是一个函数,当abc变成了表达式以后,函数就会放弃自己的名字，所以要调用abc（）。

函数表达式和函数声明的区别:

function fun(){    //函数声明
   console.log("hello");
 }()

　　

函数声明是直接可以被执行符号执行的,在函数的前面可以加上+-!可以让函数声明变成函数表达式

+function fun(){    //函数声明变成函数表达式
   console.log("hello");
 }()

-function fun(){
   console.log("hello");
 }()

!function fun(){
   console.log("hello");
 }()

4.立即执行函数

1.特点：

1.函数声明了以后直接自己执行,用函数的返回值,适合做初始化的工作
  2.避免写全局变量,所有的内容全部都放在立即执行函数中

2.格式：

//1.
(function(){})()

//2.
(function(){

}())

　　3.功能：

　　 1）初始化

//1加到100的值
var he = (function(n){
    var num = 0;
    for(var i = 1;i<=n;i++){
        num+=i;
    }
    return num;
})(100)；

　　 2）功能型

　　 写功能型的时候，在立即执行函数前面加上分号

;(function(){       console.log(456)})()