JavaScript02: 函数和内置对象

一、函数

​ 函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。

​ 声明前置： 编译器会自动将函数的声明放在最前面。

1、语法

function a( 参数 ){}
var a = function( 参数 ){} 匿名函数

<script type="text/javascript">
    // 声明前置
    b(2, "hi");
	function b(cs1, cs2){
		console.log(cs1, cs2);
	}
    
    // 匿名函数
	var c = function(cs1, cs2, cs3){
		console.log(cs1, cs2, cs3);
	}
	c(1,2,3);

    // 带返回值
	function d(){
		return "this is return function";
	}
	var d1 = d();
	console.log('this is a d1: ',  d1);
</script>

2、函数参数

​ ECMAScript 中的参数在内部用一个数组来表示，在函数体内通过 arguments对象来访问这个数组参数。
说明：

1. arguments 对象只是与数组类似，并不是Array的实例。
2. [ ] 方式访问它的每一个元素。
3. length 属性确定传递参数的个数。
4. javaScript 以函数名作为函数的唯一标识，不存在函数重载，函数用 arguments 对象以数组的形式接受参数，如果声明函数时带了参数，arguments[0] 就是第一个形参，依次类推。

// 无参函数
function inner(){
	console.log(arguments.length);  // 2
	console.log(arguments[1]);      // 5
}
inner(10,5);

// 有参函数
function add(num1,num2){    
	arguments[0]=99;
	console.log(num1);         // 99
    console.log(arguments[5]); // undefined
}
add(55,88)

// 实例：求任意一组数的平均值
function getAvg(){
	// 多所有参数进行求和
	var sum=0,len=arguments.length,i;
	for(i=0;i<len;i++){
		sum+=arguments[i];
	}
	return sum/len;
}
var avg=getAvg(5,66,45,32,88,24,40,199,3900);
console.log(avg);   // 488.777777

二、Array 对象

1、创建数组

• Array构造函数

new Array()

• 数组字面量表示法

  由一对包含数组项的方括号[]表示，多个数组项之间以逗号隔开。

• 数组的长度 array.length

  1. 通过设置length可以从数组的末尾移除项或向数组中添加新项。
  2. 当把一个值放在超出当前数组大小的位置上时，数组就会重新计算其长度值，长度值等于最后一项的索引加1。

// 数组
var cars=new Array();   // 此时cars的长度为0
cars[0]="Saab";         // 此cars长度为1 
cars[1]="Volvo";        // 2, js数组是动态变化的
var x3 = cars.length    // 获取长度

// 数组初始化
var cars=new Array("Saab","Volvo","BMW");
var cars=["Saab","Volvo","BMW"];

// 数组可以放不同类型的数据
var arr=["a", 123, true, 5.2];
console.log(arr.length);  // 4
arr.length=2;
console.log(arr.length);  // 2
arr[99]="z";
console.log(arr.length); // 100
console.log(arr[50]);    // undefined

2、数组栈方法

• push()

  以参数顺序向数组的尾部添加元素，返回添加后数组的新长度。

• unshift()

  以参数顺序向数组的头部添加元素，返回添加后数组的新长度。

• pop()

  删除数组的最后一个元素，返回被删除的元素。

• shift()

  删除数组的第一个元素，返回被删除的元素。

// push
var colors=new Array("red","green");
var len=colors.push("blue","yellow","blank");
console.log(len);

// unshift
var nums=[2,7,8,6];
var size=nums.unshift(99,66);

// pop
var n=nums.pop();
console.log(nums);

// shift
var m=colors.shift();
console.log(m);

3、join、reverse、sort

• join(separator)

  以指定分隔符将数组中的所有元素连成一个字符串。

• reverse()

  以倒序方式返回一个数组。

• sort(sortby)

  以指定方式对数组元素进行排序。

  1. 数组在原数组上进行排序，不生成副本。

  2. 不带排序方式时，默认按照字符编码的顺序进行排序。

  3. 可接受比较函数作为排序方式。

  4. 比较函数规则：

     ① 接受两个参数 a 和 b；

     ② 若 a 小于 b，返回一个小于 0 的值；

     ③ 若 a 等于 b，返回 0；

     ④若 a 大于 b，返回一个大于 0 的值。

// join
var nums=[2,4,5];
var str=nums.join(); 
console.log(str);  // 2,4,5 (默认 , 连接)
var words=["border","left","color"];
var wordstr=words.join("-");
console.log(wordstr);   // border-left-color

// reverse
nums.reverse();
console.log(nums);    // Array[5, 4, 2]
var strs=["a","b","c","d"];
var newstr=strs.reverse().join("")
console.log(newstr);  // dcba

// sort()  匿名函数做参数
var arr=[9,23,15,-99,88,12,-2];
arr.sort();
console.log(arr);   // [-2, -99, 12, 15, 23, 88, 9]
arr.sort(function(a,b){return a-b});  // 升序
console.log(arr);   // [-99, -2, 9, 12, 15, 23, 88]
arr.sort(function(a,b){return b-a});  // 降序
console.log(arr);   // [88, 23, 15, 12, 9, -2, -99]

4、concat、slice

• concat(array1, array2, …)

  连接两个或多个数组。

• slice(start, end)

  从已有的数组中返回选定的元素。

  1. start： （必需）规定从何处开始选取，如果是负数，则从数组尾部开始算起。
  2. end：（可选）规定从何处结束选取，该参数是数组片断结束处的数组下标。
  3. 没有指定 end 表示切分到数组末尾。
  4. 最后一个元素为 -1。

var arr1=["a", "b", "c"],
	arr2=["d", "e", 1, 3],
	arr3;
// concat
arr3=arr1.concat(arr2,["m",99,8]);
console.log(arr3);  // ["a", "b", "c", "d", "e", 1, 3, "m", 99, 8]

// slice(start,end)
var colors=["red","green","blue","yellow","orange"];
var newColors=colors.slice(1,3);   // ["green", "blue"]
var newColors2=colors.slice(2,4);  // ["blue", "yellow"]
var newColors3=colors.slice(-4,3); // ["green", "blue"]

// 实现b数组对a数组的拷贝
var a=[1,"yes",3],
	b;
// 1、数组遍历,push
b=new Array();
for(var i=0;i<a.length;i++){
	b.push(a[i]);
}
// 2、concat()
b=[].concat(a);
// 3、slice();
b=a.slice(0);

5、splice

• 删：splice(index, count)

  删除从index处开始的零个或多个元素。

  1. count是要删除的项目数量；
  2. 如果设置为0，则不会删除，如果不设置，则删除从index开始的所有值。

• 插入：splice(index, 0, item1 … itemX)

  在指定位置插入值。

  1. Index ：起始位置
  2. 0 ：删除0项
  3. item1 … itemX ：要插入的项

• 替换：splice(index, count, item1 … itemX)

  在指定位置插入值，且同时删除任意数量的项

  1. Index ：起始位置
  2. count：要删除的项数
  3. item1 … itemX ：要插入的项

var arr=["a","b","c","d","e","f"];
// 删除
var delArr=arr.splice(2,3);
console.log(delArr);  // ["c", "d", "e"]
console.log(arr);     // ["a", "b", "f"]
// 插入
var insertArr=arr.splice(3,0,"m","n",88);
console.log(insertArr); // []
console.log(arr);       // ["a", "b", "f", "m", "n", 88]
// 替换
var replaceArr=arr.splice(1,2,"x","y","z");
console.log(replaceArr); // ["b", "f"]
console.log(arr);        // ["a", "x", "y", "z", "m", "n", 88]

6、indexOf、lastIndexOf

• indexOf(searchvalue , startIndex)

  从数组的指定位置（默认0）开始向后查找项在数组中的位置，没有找到返回 -1。

  1. searchvalue：必需，要查找的项；

  2. startIndex：可选，起点位置的索引。

• lastIndexOf(searchvalue , startIndex)

  从数组的指定位置（默认最后）开始向前查找项在数组中的位置，没有找到返回 -1。

  1. searchvalue：必需，要查找的项；
  2. startIndex：可选，起点位置的索引。

说明： 比较时会使用全等操作，即严格相等。

var nums=[1,7,5,7,8,1,6,9];
var pos=nums.indexOf(7,2);    // 3
var pos=nums.lastIndexOf(1);  // 5
var pos=nums.indexOf("7");    // -1

7、filter

​ 返回数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。

• filter( function(currentValue, index, arr), thisValue)
  1. function(currentValue, index, arr) ： 必须，数组中的每个元素都会执行这个函数；
  2. currentValue ： 必须，当前元素的值；
  3. index ： 可选， 当前元素的索引值；
  4. arr ： 可选，当前元素属于的数组对象；
  5. thisValue ： 可选，对象作为该执行回调时使用，传递给函数，用作 “this” 的值。
     如果省略了 thisValue ，“this” 的值为 “undefined”

var nums=[1, 2, 5, 8, 10, 9, 3, 6];
// 打印数组中所有的偶数
var newNums3=nums.filter(function(item,index,arr){
	if(item%2==0) return item;
	})
console.log(newNums3);  // [2, 8, 10, 6]

8、map、forEach、reduce

• map( function(currentValue, index, arr), thisValue )

  返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

  参数同上。

• forEach( function(currentValue, index, arr), thisValue)

  用于调用数组的每个元素，并将元素传递给回调函数，返回值：undefined 。

• reduce(function(total, currentValue, currentIndex, arr), initialValue)

  ​ 接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值， 对于空数组是不会执行回调函数的。

  1. function(total,currentValue, index,arr) ： 必需，用于执行每个数组元素的函数；
  2. total ： 必需，初始值或者计算结束后的返回值；
  3. currentValue ： 必需，当前元素；
  4. currentIndex ： 可选，当前元素的索引；
  5. arr ： 可选，当前元素所属的数组对象；
  6. initialValue ： 可选，传递给函数的初始值。

// 数组每个元素*2
var nums=[3, 8, 5, 7, 6];
var newNums=nums.map(function(item,index,array){
	return item*2;
})
console.log(nums);  // [3, 8, 5, 7, 6]

var strs=["display", "transform", "transition"];
var newstrs=strs.map(function(item,index,array){
	return "->"+item;
})
console.log(newstrs);  // ["->display", "->transform", "->transition"]
 
// forEach
var colors=["red", "green", "blue"];
colors.forEach(function(item,i,array){
	console.log(item); // red   green   blue
})

// reduce 
var nums=[1,6,8,9,11];
var sum=nums.reduce(function(prev,cur,index,array){
	return prev+cur; 
})
console.log(sum);  // 35

9、更多

​ 参见：http://www.runoob.com/jsref/jsref-obj-array.html

三、String 对象

1、charAt、charCodeAt

• charAt( index )

  返回指定位置的字符。

• charCodeAt( index )

  返回指定位置的字符的 Unicode 编码。

var str = "HELLO WORLD";
var n = str.charAt(2)      // L
var m = str.charCodeAt(0); // 72

2、indexOf、lastIndexOf

• indexOf(searchvalue, start)

  返回某个指定的字符串值在字符串中从指定位置向后（默认0）出现的位置，没有返回-1。

• lastIndexOf(searchvalue, start)

  返回某个指定的字符串值在字符串中从指定位置向前（默认最后）出现的位置，没有返回-1。

var str="Hello world, welcome to the universe.";
var n=str.indexOf("welcome");   // 13
var m=str.lastIndexOf("to");    // 21

3、slice、substring、substr

• slice(start, end)

  使用 start（包含） 和 end（不包含，省略表示截取到最后） 参数来指定字符串提取的部分，可以为负数，用法与数组中的情况一致。

• substring(from, to)

  使用 from（包含） 和 to（不包含，省略表示截取到最后） 参数来指定字符串提取的部分，参数为负时，将自动转化为0。

• substr(start, length)

  在字符串中抽取从指定位置开始的指定数目的字符。

  1. start ： 必需，指定开始位置，当为负时，表示从后往前数；
  2. length : 截取字符串的总数，省略截取到末尾，为0时返回空串。

var str="Hello world!";
var n=str.slice(1,5);     // ello
var m=str.substring(3,7); // lo w
var l=str.substr(2);      // llo world!

4、split、replace

• split(separator, limit)

  以指定分隔符把一个字符串分割成字符串数组。

  1. separator : 可选，字符串或正则表达式指定分隔位置。
  2. limit ： 可选，数组的最大长度，返回的子串不会多于这个参数指定的数组。

• replace(searchvalue, newvalue)

  用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

var str="How are you doing today?";
var n=str.split();   // How are you doing today?

var str="Visit Microsoft! Visit Microsoft!";
var n=str.replace("Microsoft","Runoob");  // Visit Runoob!Visit Microsoft!

5、toUpperCase、toLowerCase

• toUpperCase()

  用于把字符串转换为大写。

• toLowerCase()

  用于把字符串转换为小写。

var str1="big";
var str2 = str1.toUpperCase();  // BIG

var str3="SMALL";
var str2 = str3.toLowerCase();  // small

6、更多

​ 参考：http://www.runoob.com/jsref/jsref-obj-string.html

四、Math 对象

1、min()、max()

​ 求一组数的最小、最大值。

2、ceil()、floor()、round()

​ 向上取整、向下取整、四舍五入取整。

3、abs()、random()

​ 绝对值、0-1之间的随机数（前闭后开）

4、更多

​ 参见： http://www.runoob.com/jsref/jsref-obj-math.html

五、Date对 象

1、new Date();

​ 创建一个日期时间对象。

1. 不传参的情况下，返回当前的日期时间对象。
2. 如果想根据特定的日期和时间创建日期对象，必须传入表示该日期的毫秒数或者是一组用逗号隔开的表示年月日时分秒的参数。

new Date() // 当前日期和时间
new Date(milliseconds) // 从 1970 年 1 月 1 日至今的毫秒数
new Date(dateString)
new Date(year, month, day, hours, minutes, seconds, milliseconds)

var today = new Date()
var d1 = new Date("October 13, 1975 11:13:00")
var d2 = new Date(79,5,24)
var d3 = new Date(79,5,24,11,33,0)

2、getXXX()、setXXX()

• getDate()

  从 Date 对象返回一个月中的某一天 (1 ~ 31)。

• getDay()

  从 Date 对象返回一周中的某一天 (0 ~ 6)。

• getMonth()

  从 Date 对象返回月份 (0 ~ 11)。

• getTime()

  返回 1970 年 1 月 1 日至今的毫秒数。

3、更多

​ 参看：http://www.runoob.com/jsref/jsref-obj-date.html

六、更多

​ 参看： http://www.runoob.com/jsref/jsref-tutorial.html