golang的基本类型分类
 
***golang中的基本类型分为值类型和引用类型***参考Go中的值类型和引用类型
 
函数传参的两种方式
 
1.值传递
 2.引用传递
 
注：
 
golang函数传参都是以复制变量的方式，不支持引用的方式
特殊的是：go语言闭包函数对外部变量是以引用的方式使用 参考由"go语言闭包函数对外部变量是以引用的方式使用"引发的闭包探讨
 
摘自go语言高级编程里的一段话：
 
 
golang传递基本类型的不同
 
golang传递值类型是指复制了一份值之后传递，改变形参并不能改变原有实参的值
 
package main

import (
	"fmt"
)

func main() {
	a := 888
	changeint(a)
	fmt.Println(a) //888
}
func changeint(int1 int) {
	int1 = 999
}

 
golang传递引用类型是传递地址，改变形参会改变原有实参的值
 
package main

import (
	"fmt"
)

func main() {
	a := make(map[int]int)
	a[1] = 888
	fmt.Println(a) //map[1:888]
	changemap(a)
	fmt.Println(a) //map[1:999]
}

func changemap(map1 map[int]int) {
	map1[1] = 999
}
 
golang引用类型传递之后整体赋值，并不能改变原有实参的值
 
package main

import (
	"fmt"
)

func main() {
	a := make(map[int]int)
	a[1] = 888
	fmt.Println(a) //map[1:888]
	changemap(a)
	fmt.Println(a) //map[1:888]
}

func changemap(map1 map[int]int) {
	map2 := make(map[int]int)
	map2[1] = 999
	map1 = map2
}
 
注：引用进行第二次赋值的时候，实际上把这份引用指向了另外一个变量，所以之后对这个变量的操作不会影响到外部的对象。
 
golang任何类型的全局变量都能被形参改变
 
package main

import (
	"fmt"
)

var map1 = make(map[int]int)

func main() {
	map1[1] = 888
	map2 := make(map[int]int)
	map2[1] = 999
	changemap(map2)
	fmt.Println(map1) //map[1:999]
}

func changemap(map2 map[int]int) {

	map1 = map2
}
 
golang传递值类型想要改变实参，需要传递值类型的指针
 
package main

import (
	"fmt"
)

func main() {
	a := 888
	changeint(&a)
	fmt.Println(a) //999

}
func changeint(int1 *int) {
	*int1 = 999

 
6.golang传递值类型时通常传递指针（在对象较大时能够提升性能，减少内存使用），同时传递类型要做到统一
 
又吵起来了，Go 是传值还是传引用？

直接开门见山，上代码！
 
var a = 1;
function func(args) {
	args = 10;
	console.log("args:"+args);
}
func(a);
console.log("a:"+a);

/**

args:10
a:1

**/
 
var a = {
	'x':1
};
function func(args) {
	args.x = 10;
	console.log("args.x:"+args.x);
}
func(a);
console.log("a.x:"+a.x);

/**

args.x:10
a.x:10

**/
 
PS：就这？有点基础的程序员都会！！
 
这两道题确实没人会回答错。。。让我想写这篇问题的是下面这道题。
 
var a = {
	'x':1
};
function func(args) {
	args = 10;
	console.log("args:"+args);
	console.log("args.x:"+args.x);
}
func(a);
console.log("a:"+a);
console.log("a.x:"+a.x);
 
这里可能就有人会错了。有人觉得变量a的值是10，a.x的值是undefined，当然也有人觉得a的值还是之前声明的值，其属性也没变化。为了解决这个疑惑，所以有了这篇文章。
 
先说说上面例子的运行结果：
 
args:10
args.x:undefined
a:[object Object]
a.x:1
 
在解释答案之前，我们需要重新回头看一下一些基础知识。
 
js的数据类型
 
js的数据类型分两种：
 
基本类型：undefined,null,number,boolean,string,symbol
 
引用类型：object（包含 function、Array、Date等）
 
基本类型
 
存储
 
基本数据类型是存放在栈区的。
 
var name = "jozo";
var city = "guangzhou";
var age = 22;
 
那么它的存储结构如下图：
 
 
栈区包括了变量的标识符和变量的值。
 
 
 
赋值
 
基本数据类型的赋值是简单赋值。如果一个变量向另一个变量赋值基本类型的值，会在变量对象上创建一个新值，然后把该值复制到为新变量分配的位置上。
 
var a = 10;
var b = a;
a++;
console.log(a)//11
console.log(b)//10
 
上面的代码中，a中保存的值是10.当使用a的值来初始化b时，b中也保存了值10.但b中的10和a中的10是完全独立的.b中的值知识a中值的一个副本.所以这两个变量可以参与任何操作而不会相互影响.如下图：
 
 
 
 
比较
 
基本数据类型的比较是值的比较。
 
var person1 = '{}';
var person2 = '{}';
console.log(person1 == person2); // true

var a = 10;
var b = a;
a++;
console.log(a == b); // false
 
 
 
引用类型
 
储存
 
引用类型是同时保存在栈区和堆区中的。引用类型的存储需要在内存的栈区和堆区共同完成，栈区保存变量标识符和指向堆内存的地址，堆区存放具体的值。
 
 
 
赋值
 
引用类型的赋值是对对象引用。
 
var a = {};
var b= a;
a.name = "change";
console.log(a.name)//change;
console.log(b.name)//change
b.age = 29;
console.log(a.age)//29
console.log(b.age)//29
 
当从一个变量向另一个变量赋值引用类型的值时，同样也会将储存在变量中的对象的值复制一份放到为新变量分配的空间中.引用类型保存在变量中的是对象在堆内存中的地址，所以，与基本数据类型的简单赋值不同，这个值的副本实际上是一个指针，而这个指针指向存储在堆内存的一个对象.那么赋值操作后，两个变量都保存了同一个对象地址，而这两个地址指向了同一个对象.因此，改变其中任何一个变量，都会互相影响。
 
 
因此，引用类型的赋值其实是对象保存在栈区地址指针的赋值，所以两个变量指向同一个对象，任何变量对该对象的操作都会互相影响。
 
 
 
比较
 
引用类型的比较是引用的比较，也就是地址指针的比较。
 
var person1 = {};
var person2 = {};
console.log(person1 == person2)//false
 
上面例子中，两个对象看起来一摸一样，但是却不相等！因为引用类型的比较是引用的比较，换句话说，就是比较两个对象保存在栈区的指向堆内存的地址是否相同，此时，虽然person1和person2看起来都是一个空对象{}，但是他们保存在栈区中的指向堆内存的地址却是不同的，所以两个对象不相等。 
 
 
 
 
js函数传参
 
js函数传参分两种情况：按值传递和按引用传递。
 
这里需要注意的是，在红宝书的中，有这么一句话“ECMAScript中所有函数的参数都是按值传递的”。那为什么我说的是两种？之所以这里说俩种，是因为结合引用传参更容易理解。不管是按值传递和按引用传递，归根结底到底都是按值传递，因为按引用传递中传递的是一个地址指针，这其实也是一个值。
 
值传参针对基本类型，引用传参针对引用类型，传参可以理解为复制变量值。基本类型复制后俩个变量完全独立，之后任何一方改变都不会影响另一方；引用类型复制的是引用（即指针），之后的任何一方改变都会映射到另一方。简单来说，传参就是把函数外部变量的值复制给函数内部的变量（函数参数），就和把值从一个变量复制到另一个变量一样。
 
 
 
按值传递
 
function addTen(num) {
    num += 10;
    return num;
}

var count = 20;
var result = addTen(count);  //按值传递 num = count
alert(count);  // 20, 没变化
alert(result);  // 30
 
很好理解，因为是按值传递的，传递完后俩个变量各不相干！
 
 
 
按引用传递
 
var a = [1];
function b(args){
    var c = args
    c.push(2);
};
console.log(a);  // [1,2]
 
如果理解了文章之前引用类型赋值那一块的知识，那这里其实也很好理解。
 
function setName(obj) {
    obj.name = "Nicholas";
}

var person = new Object();
setName(person);   // obj = person
alert(person.name);   // "Nicholas"
 
当 var person = new Object(); 时，可以用下图表示变量和对象的关系：
 
 
当调用函数 setName(person); 时，下图可以表示全局变量person和局部变量obj的关系：
 
 
以上代码中创建一个对象，并将其保存在变量person中。然后，这个变量被传递到setName(obj)函数中之后就被复制给了obj。在这个函数内部，obj和person引用的是同一个对象。换句话说，即使ECMAScript说这个变量是按值传递的（此时的值是地址指针），但obj也会按引用来访问同一个对象。于是，在函数内部为obj添加name属性后，函数外部的person也将有所反应；因为这时的person和obj指向同一个堆内存地址。
 
看完这两个传参类型，我们来试一下下面的例子，看看你能不能答对？
 
function setName(obj) {
    obj.name = "Nicholas";
    obj = new Object();
    obj.name = "Greg";
}

var person = new Object();
setName(person);
alert(person.name);
 
能算出person.name的值吗？我来一步一步分析吧。
 
第一步，person = new Object();的时候，栈内存有个变量叫person，其值只想堆内存里面的Object对象（即{}）。
 
第二步，setName(person);的时候，变量person拷贝的它的值，赋予了参数obj，此时person ==obj，都是指向同一个对象。
 
第三部，obj.name = "Nicholas";的时候，修改了对象的属性，由于此时person也指向这个对象，所以person.name的值变成了"Nicholas"。
 
第四步，obj = new Object();的时候，这是关键的一句代码，new Object()生成了一个新对象，存放在堆内存中，其指针地址赋值给了obj。也就是说，这时候的obj的值变化了，不再跟person的值相同。所以这时候person和obj分别指向两个不同的对象。
 
 
第五步，obj.name = "Greg";的时候，不管对obj的属性做什么样的修改，都不会影响到person所指向的对象，因为它们现在毫不相干。
 
第六步，alert(person.name);的时候，person的属性name的值由于在第三步的时候被修改成了"Nicholas"，所以输出的值就是"Nicholas"。
 
 
 
现在再回头看看这个例子，你就懂了。
 
var a = {
	'x':1
};
function func(args) {
	args = 10;
	console.log("args:"+args);
	console.log("args.x:"+args.x);
}
func(a);
console.log("a:"+a);
console.log("a.x:"+a.x);
 
 
 
总结
 
授人以鱼不如授人以渔，本文没总结。
 
靠自己总结出来的东西才能更加深理解，不懂就把文章多看几遍。
 
【ps：明明是作者自己偷懒不写。】
 
好了，本文到此就写完了。
 

 
 

分享知识 传递快乐
 
 
 
1、函数定义
 
linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。Shell 函数定义的语法格式如下：
 
[function] funname [()]{
    函数体
    [return int;]
}
 
格式1：
 
简化写法，不写 function 关键字：
 
函数名(){
    函数体
}
 
格式2：
 
这是标准写法，也推荐大家使用的写法：
 
function 函数名(){
	命令序列
}
 
这样方便做到一看就懂。
 
格式3：
 
如果写了 function 关键字，也可以省略函数名后面的小括号：
 
function 函数名{
	命令序列
}
 

说明：
 
function 是 Shell 中的关键字，专门用来定义函数；可以带function funname () 定义，也可以直接funname () 定义，不带任何参数；
funname 是函数名；
函数体 是函数要执行的代码，也就是一组语句；
return int 表示函数的返回值，其中 return 是 Shell 关键字，专门用在函数中返回一个值；这一部分可以写也可以不写，如果不加，将以最后一条命令运行结果，作为返回值。
 
 
2、函数变量
 
Shell 函数的变量不像其它语言中需要在变量前定义变量类型什么的，更没有结果符号等。语法：
 
num=1
 
变量作用域
 
局部变量：作用域是函数的生命周期；在函数结束时被自动销毁。定义局部变量的方法：
 
local VAR=VALUE
 
本地变量：作用域是运行脚本的shell进程的生命周期；因此，其作用范围为当前shell
 
示例一：
 
#!/bin/bash

#在函数外定义本地变量
var="Hello,World"

function show() {
    #在函数内改变变量内容
    var="Hi,var is changed"
}
echo "$var"
show
echo "$var"
 
输出结果：
 
[guest@localhost shell]$ ./tempsh.sh
Hello,World
Hi,var is changed
 
结果显示在调用函数后，原有的本地变量var被替换了。还好这个变量并不是重要的部分，想想若是PATH被替换了，那么这个函数的罪过就大了。因此我们如何即调用函数中定义的变量同时又不对本地变量造成任何影响呢？局部变量的出现就是为了解决这个问题。
 
下面看看在使用了局部变量后的效果。
 
#!/bin/bash
#在函数外定义本地变量
var="Hello,World"

function show() {
    #在函数内改变变量内容
    local var="Hi,var is changed"
    echo "$var"
}
echo "$var"
show
echo "$var"
 
输出结果
 
[guest@localhost shell]$ ./tempsh.sh
Hello,World
Hi,var is changed
Hello,World
 
该实验结果说明，使用局部变量后，函数体中出现的变量作用范围只存在于当前函数生命周期。
 
 
 
3、函数调用
 
定义函数的代码段不会自动执行，而是在调用时执行；在函数定义好后，用户可以在shell 中直接调用，调用时不用带上()；调用 Shell 函数时可以给它传递参数，也可以不传递。如果不传递参数，直接给出函数名字即可。
 
示例一：
 
#!/bin/bash

# 函数定义
function show(){
    echo "Hello word"
}

# 函数调用
show
 
输出结果：
 
Hello word
 
函数调用成功。上边的例子是把函数把在脚本上边，那么如果放函数放在下边会怎样呢？
 
无非就两种结果：1成功，2失败
 
下面我们举例测试一下：
 
示例二：
 
#!/bin/bash

# 函数调用
show

#函数定义
function show(){
    echo "Hello word"
}
 
输出结果：
 
./tempsh.sh:行4: show: 未找到命令
 
系统报错，为啥？为什么会报错呢？
 
首先，脚本的执行顺序是从上到下顺序执行的，因此会先执行show，通过定义的环境变量$PATH定义的路径找不到show对应的命令因此报“show：未找到命令”。
 
我们在终端命令行中输错命令报错也是这个原因。终端命令行默认会将最左面输入的内容当做命令，因此若是错误的命令，不是命令的命令等内容都会报错。
 
通过上面的对比，我们至少知道函数的调用若是在同一个脚本中，调用操作需要在定义的函数后面。
 
 
 
4、函数传参
 
函数传参调用语法：
 
函数名 参数1 参数2 ....
 
如果传递参数，那么多个参数之间以空格分隔：
 
funname param1 param2 param3
 
不管是哪种形式，函数名字后面都不需要带括号。和其它编程语言不同的是，Shell 函数在定义时不能指明参数，但是在调用时却可以传递参数，并且给它传递什么参数它就接收什么参数。
 
在Shell中，调用函数时可以向其传递参数。在函数体内部，函数中的变量均为全局变量，没有局部变量，若使用局部变量需要在变量前加上 local，通过 $n 的形式来获取参数的值，例如，$1表示第一个参数，$2表示第二个参数....
 
示例：
 
#!/bin/bash

function show(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第十个参数为 $10 !"
    echo "第十个参数为 ${10} !"
    echo "第十一个参数为 ${11} !"
    echo "参数总数有 $# 个!"
    echo "作为一个字符串输出所有参数 $* !"
}

show 0 1 2 3 4 5 6 7 8 9 10 11
 
输出结果：
 
第一个参数为 0 
第二个参数为 1 
第十个参数为 10 
第十个参数为 9 
第十一个参数为 10 
参数总数有 12 个
作为一个字符串输出所有参数 0 1 2 3 4 5 6 7 8 9 10 11 
 
注意：$10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。
 
另外，还有几个特殊字符用来处理参数：
 
参数处理
说明
$#
传递到脚本的参数个数
$*
以一个单字符串显示所有向脚本传递的参数
$$
脚本运行的当前进程ID号
$!
后台运行的最后一个进程的ID号
$@
与$*相同，但是使用时加引号，并在引号中返回每个参数。
$-
显示Shell使用的当前选项，与set命令功能相同。
$?
显示最后命令的退出状态。0表示没有错误，其他任何值表明有错误。
 
 
5、函数返回值
 
退出状态码
 
在介绍函数返回值前先了解一下跟函数返回值有关的状态退出码。
 
Shell 中运行的每个命令都使用退出状态码（exit status）来告诉shell它完成了处理。退出状态码是一个0-255之间的整数值，在命令结束运行时由命令传给shell。你可以捕获这个值并在脚本中使用。
 
如何查看退出状态码呢？
 
Linux提供了 $? 专属变量来保存上个执行的命令的退出状态码。你必须在你要查看的命令之后马上查看或使用 $? 变量。它的值会变成Shell中执行的最后一条命令的退出状态码。
 
退出状态码大体分两种：
 
一种是命令正确执行的状态码，该状态码为：0
一种是命令错误执行的状态码，为1-255
 Linux退出状态码
 
状态码
描述
0
命令成功结束
1
通用未知错误
2
误用shell命令
126
命令不可执行
127
没找到命令
128
无效退出参数
128+x
Linux信号x的严重错误
130
命令通过Ctrl+C终止
255
退出状态码越界
在脚本中也可以指定退出状态码的值，通过命令exit实现。
 
状态码取值范围为0-255，如果在指定的状态码大于255，那么shell会通过模（模就是256）运算得到相应的退出状态码。
 
示例一：
 
成功的
 
#!/bin/bash

# 函数定义
function show(){
    echo $(date +%Y%m%d)
}
show
echo $?
 
输出结果：
 
0
 
示例二：
 
失败的
 
#!/bin/bash

SYS_DATE=$(date +%Y%m%d)

echo $SYS_DATE

# 函数定义
function show(){
    log=`lt`
	echo log
}
show
echo $?
 
输出结果：
 
[guest@localhost shell]$ ./tempsh.sh 
20191123
./tempsh.sh:行10: lt: 未找到命令
log
0
 
这次，由于函数最后一行命令正确执行，函数的退出状态码就是0，尽管函数中有一条命令没有成功运行。
 
使用函数的默认退出状态码是很危险的，幸运的是return命令可以解决这个问题。
 
示例：
 
#!/bin/bash

SYS_DATE=$(date +%Y%m%d)

echo $SYS_DATE

# 函数定义
function show(){
    log=`lt`
	echo log
	return 2
}
show
echo $?
 
输出结果：
 
[guest@localhost shell]$ ./tempsh.sh 
20191123
./tempsh.sh:行10: lt: 未找到命令

2
 
还是使用相同的函数，在函数最后加上return指定的状态码2。
 
 
 
函数返回值
 
Shell函数返回值，常用的两种方式：return、echo。
 
 
 
1）return 语句
 
Shell函数的返回值，可以和其他语言的返回值一样，通过return语句返回，return只能用来返回整数值。
 
示例一：
 
#!/bin/bash

function getResultFun(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

getResultFun
echo $?
 
输出结果：
 
这是我的第一个 shell 函数!
2
 
Shell 函数返回值只能是整形数值，一般是用来表示函数执行成功与否的，0表示成功，其他值表示失败。用函数返回值来返回函数执行结果是不合适的。如果return某个计算结果，比如一个字符串，往往会得到错误提示：“numeric argument required”。
 
如果一定要让函数返回一个或多个值，可以定义全局变量，函数将计算结果赋给全局变量，然后脚本中其他地方通过访问全局变量，就可以获得那个函数“返回”的一个或多个执行结果了。
 
示例：
 
#!/bin/sh

function getStr(){
	return "string"
}

getStr
echo $?
 
输出如下：
 
./test.sh: line 5: return: string: numeric argument required
255
 
可以看到已经提示要求return 整数类型，真实返回值是255。当面对这种问题怎么解决呢？
 
别急，断续看下去你就会找到你想要的答案了。
 
 
 
2）echo 语句
 
echo是通过输出到标准输出返回，可以返回任何类型的数据。
 
示例：
 
#!/bin/sh

function test()  {
	echo "arg1 = $1"
	if [ $1 = "1" ] ;then
		echo "1"
	else
		echo "0"
	fi
}

echo
echo "test 1"
test 1

echo
echo "test 0"
test 0

echo
echo "test 2"
test 2
 
输出结果：
 
test 1
arg1 = 1
1

test 0
arg1 = 0
0

test 2
arg1 = 2
0
 
 
 
3）函数返回值总结
 
学习了上面的函数返回值的操作后我们下面做个知识总结，我们先看一用例：
 
#!/bin/bash

function getResultFun(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

getResultFun
echo $?

function getResultFun2(){
 echo "这是我的第二个 shell 函数!"
 expr 1 + 1
}

getResultFun2
echo $?

getResultFun
echo 在这里插入命令！
echo $?
 
输出结果：
 
这是我的第一个 shell 函数!
2
这是我的第二个 shell 函数!
2
0
这是我的第一个 shell 函数!
在这里插入命令！
0
 
这是为什么？
 
因为调用 getResultFun2 后，函数最后一条命令 expr 1 + 1 得到的返回值（$?值）为 0，意思是这个命令没有出错。所有的命令的返回值仅表示其是否出错，而不会有其他有含义的结果。
 
第二次调用 getResultFun 后，没有立即查看 $? 的值，而是先插入了一条别的 echo 命令，最后再查看 $? 的值得到的是 0，也就是上一条 echo 命令的结果，而 getResultFun 的返回值被覆盖了。下面这个测试，连续使用两次 echo $?，得到的结果不同，更为直观：
 
#!/bin/bash

function getResult(){
    echo "这是我的第一个 shell 函数!"
    return `expr 1 + 1`
}

getResult
echo $?
echo $?
 
输出结果：
 
这是我的第一个 shell 函数!
2
0
 
 
 
6、获取函数返回值
 
我们上面谈到了函数定义、传参、调用、返回结果，那我们如果得到返回结果呢？上面也谈到了一种获取返回结果的方法 $? ，难道只有这一种方式吗？答案肯定不止。
 
示例一：
 
用 $? 获取返回值，上面已有介绍，在这里就不做介绍了。
 
示例二：
 
#!/bin/sh

function getStr(){
	return "string"
}

#方法一
echo `getStr` 

#方法二
echo $(getStr) 
 
两种写法的原理一样的，将getStr当成命令执行，然后获取其标准输出。
 
示例三：函数传参
 
#!/bin/bash

#创建目录
function createDir(){
	if [ ! -d $1 ]; then
		mkdir -p $1
	fi
}

DIR="temp/"
# 两者二先一
#$(createDir $DIR)
$(createDir "temp/")
 
函数返回值获取的方法总结：
 
用变量接收函数返回值，函数用echo等标准输出将要返回的东西打印出来。
用 $? 来接收函数的执行状态，但是 $? 要紧跟在函数调用处的后面。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
———————————
 相互学习，共同进步
 如有不足请留言指正

 
函数里的传参取参相当于在函数内部放一个占位符，这个占位符的内容由外部调用的时候传入
 
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta http-equiv="X-UA-Compatible" content="ie=edge">
     <title>函数调用</title>
     <style>
         #tim {
             width: 100px;
             height: 100px;
             background: red;
             margin: 0 auto;
         }
     </style>
 </head>
 <body>
     <button id="taller" onclick="change('height','300px')">增高</button>
     <button id="longer" οnclick= "change('width','300px')">增长</button>
     <button id="changebg" οnclick= "change('background','black')">改变背景颜色</button>
     <div id="tim"></div>
     <script>
         var oDiv = document.getElementById('tim')
         function change(styleattr,value){
             //两种方法一样，但如果需要传入变量就需要用第二种
             //oDiv.style.styleattr=value 常量
             oDiv.style[styleattr]=value //变量
         }
     </script>
 </body>
 </html>
 
 
函数参数不是必需的，JavaScript允许省略参数。
 
 function f(a, b) {
   return a;
 }
 
 f(1, 2, 3) // 1
 f(1) // 1
 f() // undefined
 
 f.length // 2
 
 
  
 
以上代码中函数f定义了两个参数，但是运行时无论提供多少个参数(或者不提供参数)，JavaScript都不会报错。省略的参数值就变为undefined。需要注意的是，函数的length属性与实际传入的参数个数无关，只反映预期传入参数的个数。
 
 
但是，没有办法只省略靠前的参数，而保留靠后的参数。如果一定要省略靠前的参数，只有显式传入undefined。
 
 
 function f(a, b) {
   return a;
 }
 
 f( , 1) // SyntaxError: Unexpected token ,(…)
 f(undefined, 1) // undefined
 
  
上述代码中，如果省略第一个代码，就会报错。
 
 
传递方式
 
  
函数参数如果是原始类型的值（数值，字符串，布尔值），传递方式是传值传递。这意味着，在函数体内修改参数值，不会影响到函数外部。
 
 var p = 2;
 function f(p) {
   p = 3;
 }
 f(p);
 p // 2
 
在上面代码中，变量p是一个原始类型的值，传入函数f的方式是传值传递。因此，在函数内部，p的值是原始值的拷贝，无论怎样修改，都不会影响到原始值。
 
  
如果函数参数是复合类型的值（数组，对象，其他函数），传递方式是传址传递。也就是说，传入函数的原始值的地址，因此在函数内部修改参数，将会影响到原始值。
 
var obj = { p: 1 };
function f(o) {
  o.p = 2;
}
f(obj);
obj.p // 2
 
 
上面代码中，传入函数f的是参数对象obj的地址。因此，在函数内部修改obj的属性p，将会影响到原始值。