精华内容
下载资源
问答
  • 计算array。 对于未排序的原始数字arrays , var unsorted = [ 5 , 3 , 2 , 4 ] ; var m1 = median ( unsorted ) ; // returns 3.5 该函数接受两options : sorted : 指示输入array是否按升序sorted ...
  • Array数组类型

    千次阅读 2019-02-02 14:59:01
    1、Array类型是我们日常开发非常常用的数据类型。创建一个数组的方式非常简单: var arr = [1,'name',true,null,...索引值从0开始计算,即0代表数组中的第一项,1代表第二项,以此类推。 2、length属性 ...

    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; }  

     JavaScript  - 基本面函数  -  找到数组中所有返回 true 的数并计算长度, 需要考虑到`意外`的情况

    function isTrue(array) {
      return array.filter(Boolean).length;
    }

     

    展开全文
  • 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,} ... //存放数组array中不同元
    <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>
    展开全文
  • swift Array 数组 总结

    千次阅读 2015-09-09 14:58:51
    在swift刚一出现的时候, 数组是作为引用类型出现的, 虽然作为一结构体, 但是更像是类的对象的性质, 这可见数组的这结构体的底层不单单是像C语言和OC在栈区开辟空间去存储值类型那么简单, 猜测也是要去堆区开辟...


    /*

    编程环境: 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_14ArraySlice类型(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]

    */


    //可见现在的数组是一个值类型了!



    展开全文
  • 超详细的JavaScript Array数组相关汇总

    千次阅读 2017-11-29 17:09:21
    前言在RN涉及到比较多的数组的相关操作,所以在这里对这块内容进行一整理总结,也是对这块知识的学习! 本文前一部分内容,根据菜鸟教程整理!创建数组创建数组一般来说有下边三种方式:var array = new Array...
  • NumPy学习笔记(2)--Array数组和矩阵基本运算

    万次阅读 多人点赞 2017-02-17 12:52:06
    有句话对于我这初学者来说觉得还是挺符合的,翻书看视频浏览教程贴啊什么的,会发现很多知识点,一开始并不用非得记下都有些什么函数,问题是好像也记不住,学过去之后只要知道这东西它都能实现什么些什么功能...
  • 常用PHP array数组函数

    2017-08-11 16:19:50
    如果选出的元素不止一,则返回包含随机键名的数组,否则返回该元素的键名。 $a=array("red","green","blue","yellow","brown"); $random_keys=array_rand($a,3); echo $a[$random_keys[0]].""; echo $a[$random...
  • 分析:数组中任意找一个数,它的左边都小于它,它的下边都大于它。如果要找的(target)大于这个数,那就向下找;小于这个数就向左找。那么我们应该取哪个与target做比较呢?首先我们先想到是数组...
  • JS中Array类型属于引用类型,是除了Object之外最常用的类型。 JS的数组与其他语言的数组有着相当大的区别,它十分灵活,在JS数组的每一项都可以是任何类型的数据 (也就是数组各项的类型可以不同)。 数组的...
  • js对象数组计算总计Knowing how to quickly iterate through an array and count objects is deceptively simple. The length() method will tell you the total number of values in the array, but what if you ...
  • python统计数组中元素个数

    千次阅读 2020-04-07 19:28:38
    import pandas as pd import numpy as np arr = np.random.random((2,3)) # 需要进行统计的...arr_gb = arr.flatten() # 数组转为1维 arr_gb = pd.Series(arr_gb) # 转换数据类型 arr_gb = arr_gb.value_counts()...
  • 在一二维数组中(每一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一函数,输入这样的一二维数组和一整数,判断数组中是否含有该整数。 时间...
  • python中数组(numpy.array)的基本操作

    万次阅读 多人点赞 2018-10-21 11:23:44
    为什么要用numpy  Python提供了list容器,可以当作数组使用。但列表的元素可以是任何对象,... Python虽然也提供了array模块,但其只支持一维数组,不支持多维数组(在TensorFlow里面偏向于矩阵理解),也...
  • 关注前端达人,与你共同进步开篇因为数组操作的方法有很多,我们在实际项目又会经常使用,本篇文章笔者一次性整理常用的数组操作方法 ( 包含 ES6 的 map、forEac...
  • PHP 数组array

    2015-07-01 06:33:04
    PHP 数组实际上是一有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化,因此可以把它当成真正的数组,或列表(向量),散...array() 语言结构来新建一个数组。它接受任意数量用逗号分
  • 计算个数组的差集

    千次阅读 2018-04-17 15:12:40
    给你两分别有 5000 元素的数组计算他们的差集 方案1 循环第一个数组 ,判断item是否在第二个数组里,如果在,则unset掉这键,最后剩下的数组就是差集 function array_diff($array_1, $array_2) { ...
  • 长度为N的整形数组数组中元素的取值范围是[0,N-1],写一算法判断数组中是否存在重复的数字 bool IsDuplicateNumber(int *array, int n) { if(array==NULL) return false; int i,temp; for(i=0;i;i...
  • JS中数组去重并统计个数

    千次阅读 2020-07-22 15:36:54
    用两for循环进行比较,如果数组中存在相同的属性,那么删掉后出现的重复属性,因为在JS如果用delete删除的仅仅是属性值,并没有将这属性全部删除,其标签还在,其值变为empty(undefine),故需要再加入一...
  • 统计numpy数组中值的个数

    万次阅读 2019-05-01 19:58:59
    import numpy as np from collections import Counter data = np.array([1.1,2,3,4,4,5]) Counter(data) # {label:sum(label)} #简单方法 sum(data==4)
  • 数组 Array相关函数

    2018-04-22 23:07:18
    Array数组的内置支持 object----Array构造函数: new Array() new Array(size) //size:设定的数组元素个数,返回数组的length属性等于size new Array(element0,element1,……,elementn) //element参数列表...
  • TypeScript Array(数组操作)

    万次阅读 2019-05-30 12:41:42
    连接两或更多的数组,并返回结果。 以下代码连接两个数组: const letters = ['a', 'b', 'c']; const numbers = [1, 2, 3]; letters.concat(numbers); // result in ['a', 'b', 'c', 1, 2, 3] ...
  • 对于升序排列组,数组中有正数、负数、或0,求数组中元素的绝对值最小的。例如数组[-10,-5,-2,7,15,50]绝对值最小的为-2。 分析: 方法一:顺序比较法 最简单的方法就是从头到尾遍历数组元素,对每...
  • 题目要求:从一堆给定的无序不重复数组中寻找某一指定数在数组中出现的位置;思考方向:通过空间换时间的方法,将每个数组中的元素放入一map容器,将数组中的值作为key,下标作为value即可。
  • 21、将数组的后面m个数移动为前面m个数 题目:
  • 数组中任意相加的和等于剩下的相加的和: 比如{1,2,3} 1+2=3,所以是满足条件的。 仔细分析下这样的数组其实首先要满足一下几条件: 1.数组整个相加要是偶数。(a+b+c+*+****=2d) 2.数组中的最大不能...
  • c++内置的原生数组可以存储一固定大小的相同类型元素的顺序集合,并且其中的特定元素可以通过索引访问。它由连续的内存位置组成,最低的地址对应第一元素,最高的地址对应最后一元素。声明格式如下: type ...
  • 基本思路:就是排序后下标为数组长度/2的元素  这里,可以采用快速排序的思路(详细快速排序不多介绍,可参考这里)。即将不断地划分为左右两区域,左边区域内的所有元素都小于某个主元,右边区域内的元素...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 167,686
精华内容 67,074
关键字:

计算array数组中true个数