1、Array类型是我们日常开发中非常常用的数据类型。创建一个数组的方式非常简单：
 
var arr = [1,'name',true,null,undefined,{},[]];
 
这是以字面量，也是最常用的创建数组的形式,其中可以包含任何类型的数据。访问其中的某项，可通过索引：
 
arr[0] //1
 
索引值从0开始计算，即0代表数组中的第一项，1代表第二项，以此类推。
 
2、length属性
 
数组包含一个不可遍历的length属性，反映数组的长度。
 
var arr = [1,2,3,4];
arr.length //4 数组中有4个项
 
3、数组的检测方法
 
3.1 instanceof操作符用来检测左侧的对象是否为右侧的构造函数的实例。若构造函数的原型出现在实例对象的原型链中，结果返回true，否则返回false。
 
var arr = [1,2,3,4];

arr instanceof Array //true
 
3.2 isArray方法
 
instanceof操作符在某种情况下会出现问题，就是在一个网页中包含多个框架的情况下，如果将框架1中的数组传入到框架2中，在跨越环境的情况下使用instanceof符进行检测就会返回false，因为虽然被检测的对象确实是数组类型，但这个数组是框架1中的Array构造函数的实例，而不属于框架2中的Array构造函数，为了解决这个问题，es5新增了isArray方法，该方法用于检测一个值是否为数组，而不受环境的影响。
 
Array.isArray(arr);
 
4、转换方法
 
数组的toLocaleString、toString、valueOf方法继承自Object原型对象，这个三个方法都会返回由数组中的每个项拼接成的以逗号分隔的字符串。
 
var arr = [1,2,3,4];
arr.toString() //'1,2,3,4'
arr.toLocaleString() //'1,2,3,4'
arr.valueOf() //'1,2,3,4'
 
5、join方法
 
数组的join方法的功能类似于toLocaleString、toString、valueOf方法，可以将数组转换为字符串的形式，不同的是，join能够接受一个参数，用来指定分隔每个项的字符，其余三个方法均以逗号分隔。
 
var arr = [1,2,3,4];
arr.join('-');  //'1-2-3-4'
 
若传入空字符串，可实现合并字符的功能：
 
var arr = [1,2,3,4];
arr.join('');  //'1234'
 
6、栈方法
 
6.1 push方法 用于向数组末尾添加项目，并返回数组新的长度
 
var arr = [1,2,3,4];
arr.push(5); //[1,2,3,4,5]
 
6.2 pop方法 用于移除数组的最后一项，并返回该项
 
var arr = [1,2,3,4];
arr.prop(); //[1,2,3,4]
 
6.3 shift方法 用于移除数组中的头一项，并返回该项
 
var arr = [1,2,3,4];
arr.shift(); //[2,3,4]
 
6.4 unshift方法 用于向数组首部添加项目，并返回数组新的长度
 
var arr = [1,2,3,4];
arr.unshift(0); //[0,1,2,3,4]
 
7、排序方法
 
7.1 reverse方法 用于将数组项原有的顺序进行反转,并返回转换后的数组
 
var arr = [1,2,3,4];
arr.reverse() //[4,3,2,1]
 
7.2 sort方法 可用于实现数组的升序或降序排列方式，默认情况下，sort采用从小到大的升序排列方式：
 
var arr = [2,1,4,3];
arr.sort(); // [1, 2, 3, 4]
 
srot方法会对每个项调用toString方法，比较字符串形式化的值，以此来确定如何排序，任何类型的值都是如此，在对字符串之间进行比较的时候，只会比较两者中的首字符。
 
var arr = [2,11];
arr.sort(); //[11,2]
 
之所以会有这样的结果，是因为sort方法比较的不是2与11，而是2与11中的首字符1,1小于2，于是11被排到2的前面。不过sort方法还接受一个比较函数，可以解决此问题。sort方法会依次向比较函数传入两个相邻的数组项，而不会调用toString方法，如果比较函数的返回值为负数，表示第一个参数将排在第二个参数之前，若是整数，则表示第一个参数将排在第二个参数之后。
 
var arr = [2,11,9,4];
arr.sort((value1,value2) => {
    return value1 < value2 ? -1 : 1;
});
console.log(arr) //[2, 4, 9, 11]
 
若想实现降序排序，可直接将数组进行反转。
 
8、合并数组
 
concat方法可接受一个或多个数组，该方法会创建目标数组的副本，并将接受到的数组中的每个项添加到副本的尾部并返回副本，不影响源数组。
 
var arr = [1,2,3,4]
arr.concat([1,2,3,4]) //[1, 2, 3, 4, 1, 2, 3, 4]
 
9、在数组中进行截取
 
slice方法接受两个参数，参数1表示截取的起点，参数2表示截取的终点，该方法返回一个拥有截取内容的新数组，不影响源数组。如果省略第二个参数，会默认截取至末尾。
 
var arr = [1,2,3,4,5,6]
arr.slice(1) //[2, 3, 4, 5, 6]
arr.slice(1,5) //[2, 3, 4, 5]
 
需要用索引来表示终点与起点，slice方法将截取至终点索引值的前一个位置。
 
10、splice方法
 
splice方法会返回一个拥有所删除的项目的数组，并且该方法的所有操作都会影响源数组。
 
10.1 删除
 splice方法接受两个参数，第一个表示删除的起点，第二个表示要删除的项目的数量，
 
var arr = [1,2,3,4,5,6]    	
arr.splice(1,2) //[2, 3]
arr //[1, 4, 5, 6]
 
10.2 插入
 splice的第三个参数表示要插入的值：
 
var arr = [1,2,3,4,5,6]
arr.splice(1,0,1) //[1, 1, 2, 3, 4, 5, 6]
 
以上表示从索引为1的位置开始，删除0个项目，并插入新值1，若需插入更多的值，可在第三个参数后面传入第四个参数，可插入多个值。
 
10.3 替换
 与插入同理，利用第二个参数删除指定项，在通过后面的参数指定插入的新项
 
var arr = [1,2,3,4,5,6]
arr.splice(1,1,1) //[1, 1, 3, 4, 5, 6]
 
以上表示从索引值为1的位置开始，删除一个项，并在这个位置上插入新值1。
 
11、查询
 
indexOf和lastIndexOf可用于从数组中查询某个值是否存在，它们都接受两个参数，第一个表示要搜索的值，第二个可选参数表示搜索的起始位置，indexOf方法是从头开始查找，而lastIndexOf方法是从末尾开始查找，如果找到匹配的项，则返回该项的索引，否则返回-1，需要注意的是，两个值之间必须是全等才算匹配。
 
var arr = [1,2,3,4,5,6]
arr.indexOf(2) //1
 
数组的遍历
 
es5为数组新增了5个迭代方法：
 
every方法：对数组的每项运行一个给定的函数，如果给定函数对每一项都返回true，则every方法最终返回true。
 
filter方法：对数组的每项运行一个给定的函数，filter方法最终返回一个包含所有调用给定函数结果为true的数组项。
 
forEach方法：对数组的每项运行一个给定的函数，没有返回值。
 
map方法：对数组的每项运行一个给定的函数，最终返回一个由给定函数的返回值组成的数组。
 
some方法：对数组的每项运行一个给定的函数，只要给定的函数的运行有一次返回true，则some方法返回true。
 
这些方法都接受两个参数，第一个参数是将对每项调用的函数，第二个可选参数可以指定给定函数所运行的作用域。
 给定的函数又可接受三个参数，第一个参数为数组项的值，第二个为数组项的索引，第三个参数为调用迭代方法的对象。
 
例1：
 
var arr = [1,2,3,4,5,6]
    	
var result = arr.every(function (val,index,arr) {
	return val < 10 ? true : false;
})

console.log(result) //true
 
上例中，使用every方法检查数组中的每项值是否小于10，结果返回true，如果你会数组添加一个大于10的值，该方法将返回false。
 
例2：
 
var arr = [11,21,31,41,51,6]
    	
var result = arr.some(function (val,index,arr) {
	return val < 10 ? true : false;
})

console.log(result) //true
 
上例中，使用some方法，检查数组中是否存在小于10的值，只要函数有一次返回true，那么some方法就会返回true，而every方法则需要函数每次都返回true时，every方法才最终返回true。
 
例3：
 
var arr = [1,2,3,4,5,6,11,20,100]
    	
var result = arr.filter(function (val,index,arr) {
	return val < 10 ? true : false;
})

console.log(result) //[1, 2, 3, 4, 5, 6]
 
上例中，使用filter方法检查数组中的每项是否小于10，并将小于10的数组项装进数组进行返回。
 
例4：
 
var arr = [1,2,3,4,5,6,11,20,100]
    	
var result = arr.forEach(function (val,index,arr) {
	console.log(val)
})
 
例5：
 
var arr = [1,2,3,4,5,6]
    	
var result = arr.map(function (val,index,arr) {
	return ++val;
})

console.log(result) //[2, 3, 4, 5, 6, 7]
 
上例中，使用map方法对数组中的每个项进行++操作，函数的返回值会被包装成一个数组进行返回。
 
reduce和reduceRight方法
 
这两个方法都可接受四个参数，第一个参数为对每个数组项调用的函数，第二个可选的值为缩小基础的初始值。
 方法中的函数可接受四个参数：
 第一个参数代表前一个值，在第一轮迭代中，这个参数代表数组中的索引为0的数组项，在第二轮及往后的迭代中，这个参数代表的是上一轮迭代中函数的返回值。
 第二个参数代表下一个数组项，即从索引为1的数组项开始，每次迭代，都会往前挪一位。
 第三个参数为数组项的索引
 第四个参数为调用迭代方法的对象
 这两个方法最终会返回最后一次计算的结果。
 
var arr = [1,2,3,4,5,6]
var result = arr.reduce(function (prev,next) {
	return prev+next;
})
console.log(result) //21
 
上例中，第一次迭代从索引为1的数组项开始,这时候prev为前一个数组项1，next为索引为1的数组项2，在第二轮迭代中，prev为上次迭代中函数的返回值，也就是3，next为下一个数组项，即索引为2的数组项3，reduce方法最终返回最后一次计算的结果，即15+6=21;
 
reduceRight方法与reduce方法一致，只不过reduce是从左往右进行迭代，而reduceRight方法则是从右往左进行迭代。

 JavaScript  - 基本面函数  -  找到数组中所有返回 true 的数并计算长度, 需要考虑到`意外`的情况
 
function isTrue(array) {
  return array.filter(Boolean).length;
}
 
 

<span style="font-size:18px;"><%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>

 

 

 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

 

 

 <html xmlns="http://www.w3.org/1999/xhtml">

 <head runat="server">

     <title></title>

     <script type="text/javascript">

         var array = new Array(4, 5, 4,7, 8, 4,2,67,5,89,5,67);

         var count = 1;

         var yuansu= new Array();//存放数组array的不重复的元素比如{4,5,7,8,2,67,89,}

         var sum = new Array(); //存放数组array中每个不同元素的出现的次数

         for (var i = 0; i < array.length; i++) { 

             for(var j=i+1;j<array.length;j++)

             {

                 if (array[i] == array[j]) {

                     count++;//用来计算与当前这个元素相同的个数

                     array.splice(j, 1); //没找到一个相同的元素，就要把它移除掉，

                     j--; 

                 }

             }

             yuansu[i] = array[i];//将当前的元素存入到yuansu数组中

             sum[i] = count;  //并且将有多少个当前这样的元素的个数存入sum数组中

             count =1;  //再将count重新赋值，进入下一个元素的判断

         }

         var str = '';

         //算出array数组中不同的元素出现的次数

         for (var i = 0; i < yuansu.length; i++) { 

            str+=yuansu[i]+"出现的次数为："+sum[i]+"<br/>";

         }

        document.write(str);

        //算出array数组中出现次数最多的两个元素

        var newsum = new Array(); //  sum;

        for (var item in sum) {

            newsum[item] = sum[item];

        }

        newsum.sort();

        //document.write(sum.toString()+"<br/>");

        //document.write(newsum.toString() + "<br/>");

        var first = ''; //存放出现次数最多的元素，以及个数

        var second = '';  //存放出现次数居第二位的元素，以及个数

        var fcount = 1; //计算出现次数最多的元素总共有多少个

        //算出出现次数最多的元素及个数

        document.write("<br/>");

        for (var i = 0; i < sum.length; i++) {

            if (sum[i] == newsum[newsum.length - 1]) {

                //document.write("出现次数最多的元素是：" + yuansu[i] + "次数为：" + sum[i] + "<br/>");

                first += "出现次数最多的元素是：" + yuansu[i] + "次数为：" + sum[i] + "<br/>";

                fcount++;

            }

 

 

        }

        //算出出现次数居第二位的元素及个数

        for (var i = 0; i < sum.length; i++) {

         

            if (sum[i] == newsum[newsum.length - fcount]) {

                //document.write("出现次数居第二位的元素是：" + yuansu[i] + "次数为：" + sum[i] + "<br/>");

                second += "出现次数居第二位的元素是：" + yuansu[i] + "次数为：" + sum[i] + "<br/>"

            }

        }

        document.write("出现次数最多的元素有"+(fcount-1)+"个<br/>"+first+"<br/>"+second);

     </script>

 </head>

 <body>

     <form id="form1" runat="server">

     <div>

     </div>

     </form>

 </body>

 </html>

 </span>

 
 
 
 /*
 
 编程环境: xcode 7.0 beta6
 
 */
 
 
 
 
 
 
 
 
 
 
 /*---------------------------一.数组的创建-------------------------*/
 
 //[someType]  等同于 Array<someType>,都代表可以装有someType这种类型数据的数组,下边我只使用[someType]这种形式:
 
 
 
 
 /*
 
 1. 变量数组,常量数组: 
 
 变量数组可以进行更改,对应OC可变数组:NSMutableArray,常量数组不可以进行修改, 对应OC不可变数组:NSArray
 
 */
 
 var arr1_1:[Int]     //变量数组
 
 let arr1_2: [Int]    //常量数组,可以不直接赋值, 但是当第一次赋值过后就不可以更改了
 
 
 
 
 /*
 
 2. 数组的创建你可以指定这个数组装有什么类型,如果你指定特定的类型, 那么这个数组只能装这个类型的数据,或者这个类型的子类的数据;
 
 */
 
 let arr1_3: [String] = ["ab","cd"] //只能添加字符串类型
 
 
 
 
 /*
 
 3. 如果你不指定的类型, swift会有类型推断,根据你在等号右边赋的值来进行类型推断:
 
 */
 
 //(1). 如果赋的值都是某个特定类型的数据,比如说都是[1, 2, 3], 那么类型推断为[Int];
 
 var arr1_4 = [1,2, 3]    //这时arr1_4为[Int]类型
 
 arr1_4 = []              //这种情况, arr1_4依旧是[Int]类型
 
 
 
 
 //(2). 如果你所赋的值都为NSObject类的对象或者继承与NSObject类的对象,或者String, Int, Double等一些基础类型, 那么swift将这个数组推断为[NSObject]类型;
 
 let NSStr1_1: NSString ="NSString"
 
 let arr1_5 = [1,"123", NSStr1_1]   //这时arr1_5为[NSObject]类型
 
 
 
 
 //(3). 如果数组中包含不止继承与NSObject类的数据(没有任何继承与任何类的对象),或者不继承与NSObject又不是基础类型数据,比如说Array Dictionary, swift将其推断为NSArray类型(原来是OC中的类型, swift中一样有这个类型,  实现了部分OC中的方法), NSArray这个类型可以和swift中的[Element]相互转换, [Element](这个涉及到泛型,  就是一个占位类型, 你往数组添加任何类型的数据都可以);
 
 let arr1_6 = [1,"123", arr1_5]   //识别为NSArray类型
 
 let arr1_7 =  Array(arr1_6)        //将其转换为[Element]类型,注意[Element]这个类型不可以直接声明;
 
 /*如果想得到一个,空的泛型数组可以这样写:*/
 
 let arr1_8 = []              //这个时候识别为NSArray类型
 
 var arr1_9 =  Array(arr1_8) //arr1_9就是一个空的[Element]类型的数组
 
 
 
 
 //4. 创建一个有多个元素重复的数组
 
 var arr1_10 = Array(count:3, repeatedValue: 1.3)
 
 print(arr1_10)
 
 /*打印结果
 
 [1.3, 1.3, 1.3]  //含有3个 1.3的数组
 
 */
 
 
 
 
 //5. 通过两个数组相拼接的方式获取新数组
 
 var arr1_11 =  arr1_7 + arr1_9//等号后边两个数组必须是相同类型的数组,比如这两个都是泛型数组[Element]
 
 print(arr1_11)
 
 /*打印结果
 
 [1, 123, (
 
 1,
 
 123,
 
 NSString
 
 )]
 
 */
 
 
 
 
 //6. 通过 Array(arrayLiteral: <#T##Element...##Element#>)来创建数组:
 
 var NSStr1_2: NSString ="NSString2"
 
 let arr1_12 =  Array(arrayLiteral:1, "123",1.23, NSStr1_2)     //这后边只能填NSObject类的对象或者继承与NSObject类的对象,以及Int, Double, String 一些基础类型,这时arr1_12被识别为[NSObject]类型
 
 
 
 
 //7. 通过范围运算符 0...1来创建数组:
 
 //0...1 表示 0  到 1 的开区间(0..<1表示0 到 1  的半开半闭区间,不包括1)
 
 let arr1_13 = [0,1, 2, 3,  4, 5]
 
 var arr1_14 =  arr1_13[0...3]   //这个时候arr1_14为ArraySlice类型(ArraySlice类型和Array类型很像,像截取数组的一部分的时候, 都会被识别为ArraySlice类型,可以被理解为迷你版的Array, Array和 ArraySlice 类型和可以相互转换)
 
 var arr1_15 =  Array(arr1_14)  //转换为Array<Int>类型
 
 
 
 
 
 
 
 
 
 
 /*---------------------------二.遍历数组-------------------------*/
 
 
 
 
 //1 首先说一下如何查看数组的元素,以及获取数组的一些基础属性
 
 var arr2_1 = [999,10, 99, 4]
 
 //(1)首先说一下数组名[下标]的方式来访问或者修改数组元素 eg:
 
 print(arr2_1[0])
 
 /*打印结果
 
 999
 
 */
 
 
 
 
 arr2_1[0] =110
 
 print(arr2_1)
 
 /*修改后的打印结果
 
 [110, 10, 99, 4]
 
 */
 
 
 
 
 //(2)通过0...1(这个表示0到 1 的开区间)的这种范围方式来访问数组:
 
 print(arr2_1[0...1])
 
 /*打印结果
 
 [110, 10]
 
 */
 
 
 
 
 //(3)获取数组某些特定位置的元素:
 
 print(arr2_1.first)    //获取数组的第一个元素    打印结果: Optional(110)
 
 print(arr2_1.last)     //获取数组的最后一个元素  打印结果: Optional(4)
 
 
 
 
 //(4)获取数组元素的数量:
 
 print(arr2_1.count)   //打印结果: 4
 
 
 
 
 //2. for in 数组遍历
 
 //(1)for in 遍历全部元素
 
 for id in  arr2_1 {
 
     print(id)
 
 }
 
 /*打印结果
 
 999
 
 10
 
 99
 
 4
 
 */
 
 
 
 
 //(2)for in 遍历数组某一个区间的元素
 
 for id in  arr2_1[1...3]{
 
     print(id)
 
 }
 
 /*打印结果:
 
 10
 
 99
 
 4
 
 */
 
 
 
 
 //3. for 循环数组遍历
 
 for var i =0; i < arr2_1.count; ++i {
 
     let id = arr2_1[i]
 
     print(id)
 
 }
 
 /*打印结果
 
 999
 
 10
 
 99
 
 4
 
 */
 
 
 
 
 //4. 使用枚举法,进行遍历
 
 for (a, b) inarr2_1.enumerate(){
 
     print("\(a) =\(b)")
 
 }
 
 /*打印结果
 
 0 = 999
 
 1 = 10
 
 2 = 99
 
 3 = 4
 
 */
 
 
 
 
 //5. 模拟系统给出的枚举法遍历数组
 
 var en = arr2_1.enumerate().generate()
 
 var temp: (Int,Int)? = en.next()
 
 while temp !=nil {
 
     print(temp!)
 
     temp = en.next()
 
 }
 
 /*打印结果
 
 (0, 999)
 
 (1, 10)
 
 (2, 99)
 
 (3, 4)
 
 */
 
 
 
 
 
 
 
 
 
 
 /*---------------------------三.给数组添加元素-------------------------*/
 
 //1. 在数组的后边添加一个元素
 
 var arr3_1 = ["hello"]
 
 arr3_1.append("world")
 
 print(arr3_1)
 
 /*打印结果:
 
 [hello, world]
 
 */
 
 
 
 
 //2. 在数组的某个位置添加元素:
 
 arr3_1.insert("my", atIndex:1)
 
 print(arr3_1)
 
 /*
 
 [hello, my, world]
 
 */
 
 
 
 
 //3.使用 +=给数组拼接另一个数组:  在老版本是可以使用 +=拼接一个元素的, 但这个版本把这个功能去掉了
 
 arr3_1 += ["codeWorm","dear"]
 
 print(arr3_1)
 
 /*打印结果:
 
 [hello, my, world, codeWorm, dear]
 
 */
 
 
 
 
 //4. 在数组的某个index位置,添加一个相同类型的数组:
 
 arr3_1.insertContentsOf(["123","456"], at:0)
 
 print(arr3_1)
 
 /*打印结果:
 
 ["123", "456", "hello", "my", "world", "codeWorm", "dear"]
 
 */
 
 
 
 
 
 
 
 
 
 
 /*---------------------------四.删除数组的元素-------------------------*/
 
 var arr4_1 = [1,2, 3, 4,  5]
 
 
 
 
 //1. 删除最后一个元素,返回值为被删除的元素
 
 let remove1 = arr4_1.removeLast()
 
 print(arr4_1)
 
 /*打印结果
 
 [1, 2, 3, 4]
 
 */
 
 
 
 
 //2. 删除某个index的元素,返回值为被删除的元素
 
 let remove2 = arr4_1.removeAtIndex(0)
 
 print(arr4_1)
 
 /*打印结果
 
 [2, 3, 4]
 
 */
 
 
 
 
 //3. 删除某个范围的元素
 
 arr4_1.removeRange(Range(start:0, end: 1))
 
 print(arr4_1)
 
 /*打印结果
 
 [3, 4]
 
 */
 
 
 
 
 //4. 删除数组的所有元素,并且不保留数组所占的空间
 
 arr4_1.removeAll()
 
 
 
 
 //5. 删除数组的所有元素,但是所占的内存空间将被保留
 
 arr4_1.removeAll(keepCapacity:true)
 
 
 
 
 
 
 
 
 
 
 /*---------------------------五.修改数组的元素-------------------------*/
 
 var arr5_1 = [1,2, 3, 4,  5, 6,7]
 
 
 
 
 //1. 可以用数组名[下标数]这种形式 来修改某个index的元素值
 
 arr5_1[0] =99 //将第0个元素的值修改为99
 
 print(arr5_1)
 
 /*打印结果
 
 [99, 2, 3, 4, 5, 6, 7]
 
 */
 
 
 
 
 
 
 
 //2. 将数组某个范围的元素替换为后面的这段数组的元素,注意这个范围最大数不能超过数组的count值 - 1否则会运行时崩溃
 
 arr5_1[1...3] = [100,101, 102]
 
 print(arr5_1)
 
 /*打印结果
 
 [99, 100, 101, 102, 5, 6, 7]
 
 */
 
 
 
 
 //3. 使用 arr5_1.replaceRange(<#T##subRange: Range<Int>##Range<Int>#>, with: <#T##C#>) 来替换元素, 这里第一个参数为范围,  第二个参数是要替换的数组或者表示数组的指针
 
 arr5_1.replaceRange(Range(start:0, end: 4), with: [0,1, 2, 3,  4])
 
 print(arr5_1)
 
 /*打印结果
 
 [0, 1, 2, 3, 4, 5, 6, 7]
 
 */
 
 
 
 
 //replaceRange 替换UnsafeMutableBufferPointer数组的指针类型:
 
 var arr5_2 = [999,1000, 1001]
 
 var pointer = UnsafeMutableBufferPointer<Int>(start: &arr5_2, count:arr5_2.count)    //这是用来表示字符串的指针类型
 
 arr5_1.replaceRange(0..<1, with: pointer)    //第一个参数range的另一种表现形式, 0到 1 的半开半闭区间(0...1 表示0  到 1的开区间), 这里也就是表示,  将arr5_1的第0个元素替换成这个数组指针对应数组的元素
 
 print(arr5_1)
 
 /*打印结果
 
 [999, 1000, 1001, 1, 2, 3, 4, 5, 6, 7]
 
 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 /*---------------------------六.对于数组的一些基础的判断-------------------------*/
 
 
 
 
 //1. 判断数组是否为空
 
 var arr6_1: [Int] = []
 
 print(arr6_1.isEmpty)//判断的前提是数组已经被实例化
 
 /*打印结果
 
 true
 
 */
 
 
 
 
 //2. 判断数组是否包含某个元素:
 
 var arr6_2 = ["hello","world", "I","am",  "code"]
 
 //(1)可以直接这么调用:
 
 print(arr6_2.contains("hello"))
 
 /*打印结果
 
 true
 
 */
 
 //(2) 可以使用闭包为参数进行判断
 
 let isContain =arr6_2.contains { (obj) -> Boolin      //这个运行原理就是,编译器调用你的闭包,将数组内的元素顺次作为闭包的参数传入, 进行判断, 当然判断逻辑是你写的,直到闭包的返回值为true 或者将数组内的所有元素传参完毕闭包调用结束,否则继续传入下一个数组的元素作为参数调用这个闭包,如果闭包的返回值出现为true的情况,则contains返回值为true,如果直到闭包调用完毕都没有出现true的情况,则contains返回值为false
 
     if obj == "木哈哈" {
 
         return  true
 
     }
 
     return  false
 
 }
 
 //简写:
 
 let isContainSam =arr6_2.contains{$0 =="木哈哈"}   //$0 就是第一个参数的意思, $1第二个, 多个参数同理,  当一个闭包只有一个return语句时, return可以省略
 
 print(isContain)
 
 /*打印结果
 
 false
 
 */
 
 
 
 
 
 
 
 
 
 
 /*---------------------------七.数组分割为字符串, 字符串拼接数组-------------------------*/
 
 //这个如果有OC基础就知道这个:
 
 //1. 使用某个字符串来分割字符串,分割结果为数组:
 
 let str7_1 =  "www.baidu.com/www.v1.cn/haha"
 
 let arr7_1 =  str7_1.componentsSeparatedByString(".")
 
 print(arr7_1)
 
 /*打印结果
 
 ["www", "baidu", "com/www", "v1", "cn/haha"]
 
 */
 
 
 
 
 //2. 使用NSCharacterSet类型来分割字符串:
 
 let arr7_2 = str7_1.componentsSeparatedByCharactersInSet(NSCharacterSet(charactersInString:"./"))    //分别以.和 /来分割
 
 print(arr7_2)
 
 /*打印结果
 
 ["www", "baidu", "com", "www", "v1", "cn", "haha"]
 
 */
 
 
 
 
 //3. 将数组拼接成字符串
 
 let str7_2 =  arr7_2.joinWithSeparator("我是 (空格)")
 
 print(str7_2)
 
 /*打印结果
 
 www我是 (空格)baidu我是 (空格)com我是 (空格)www我是 (空格)v1我是 (空格)cn我是 (空格)haha
 
 */
 
 
 
 
 
 
 
 
 
 
 /*---------------------------八.数组的一些其他方法-------------------------*/
 
 
 
 
 //1. sortInPlace 排序
 
 var arr8_1 = [2,32, 1, 5,  3, 4]
 
 //sortInPlace方法就是原来的sort方法
 
 arr8_1.sortInPlace { (id1, id2) ->Bool in      //传入闭包的原理类似与将冒泡排序的排序准则传入,编译器来实现冒泡排序, 然后根据你的准则来判断是否交换元素位置, eg:
 
     if id1 > id2{
 
         return  true
 
     }
 
     return  false
 
 }
 
 //上边这个可以简写为:
 
 //arr8_1.sortInPlace {$0 > $1}       //$0  就是第一个参数的意思, $1  第二个, 多个参数同理,当一个闭包只有一个return语句时, return可以省略
 
 print(arr8_1)
 
 /*打印结果
 
 [32, 5, 4, 3, 2, 1]
 
 */
 
 
 
 
 //2. reverse 翻转数组:
 
 let arr8_2 = [9,6, 3, 0,  2, 4,5]
 
 let arr8_3 = Array(arr8_2.reverse())
 
 print(arr8_3)
 
 /*打印结果:
 
 [5, 4, 2, 0, 3, 6, 9]
 
 */
 
 
 
 
 //3. filter 过滤数组:
 
 let arr8_4 = [-5, -4, -3, -2,0, 1, 2,  3, 4,5, 6, 7,  8]
 
 let arr8_5 = arr8_4.filter{$0 %2 == 0 && $0 >0}  //过滤出数组中的正偶数
 
 //展开为:
 
 //let arr8_5 = arr8_4.filter { (obj) -> Bool in
 
 //    return obj % 2 == 0 && obj > 0
 
 //}
 
 print(arr8_5)
 
 /*打印结果:
 
 [2, 4, 6, 8]
 
 */
 
 
 
 
 //4. map 遍历计算数组
 
 let arr8_6 = [1,2, 3, 4,  5]
 
 let arr8_7 = arr8_6.map{$0 *2} //通过计算形成新数组
 
 print(arr8_7)
 
 /*打印结果:
 
 [2, 4, 6, 8, 10]
 
 */
 
 
 
 
 //5. reduce 方法
 
 let arr8_8 = [2.0 ,9.0]
 
 let result8_1 = arr8_8.reduce(9.0) { (obj1, obj2) ->Double in
 
     return obj1/obj2
 
 }
 
 //reduce, 需要传一个初始值,这里传的是9.0, 第一次传入闭包两个参数分别为初始值本身和 数组的第一个元素,第二次传的两个参数分别为, 第一次闭包的运算结果和数组的第二个元素,直到所有数组的元素全部被运算完毕, 最后一次调用闭包完毕返回的值为最终的值,  这里做的计算也就是: 9.0/2.0/9.0 = 0.5
 
 
 
 
 //简写为:
 
 //let result8_1 = arr8_8.reduce(9.0){$0/$1}     这里涉及到尾随闭包的知识,  在网上搜一下尾随闭包就知道怎么回事了
 
 
 
 
 print(result8_1)
 
 /*打印结果:
 
 0.5
 
 */
 
 
 
 
 
 
 
 
 
 
 /*---------------------------九.数组拷贝-------------------------*/
 
 /*
 
 在swift刚一出现的时候,数组是作为引用类型出现的, 虽然作为一个结构体,但是更像是类的对象的性质, 这可见数组的这个结构体的底层不单单是像C语言和OC中在栈区开辟空间去存储值类型那么简单,猜测也是要去堆区开辟空间的, 在后来更新版本中, Array取消了这样的性质,而是只作为值类型出现, 这样就让新学习swift的人来说不会有"为什么值类型还可以做引用的操作?"这样的困惑, 下面是一个eg:
 
 */
 
 var arr9_1 = [1,2, 3]
 
 var arr9_2 = arr9_1
 
 arr9_2[0] =999
 
 print("arr9_1 =\(arr9_1) arr9_2 =\(arr9_2)")
 
 /*打印结果:
 
 arr9_1 = [1, 2, 3] arr9_2 = [999, 2, 3]
 
 */
 
 
 
 
 //可见现在的数组是一个值类型了!