中的12种循环遍历方法,iOS学习16之OC集结遍历和

插入排序,是循环遍历二个严节数组(举个例子有13个成分),把遍历出来的数值(第i个因素)插入到已经排过种种的数组(这一个不改变数组有10-i个成分)中。

1、集结遍历

1、for 循环

用三个 数组 比方:

 1> 遍历

  集结(Collection):OC中提供的容器类:数组,字典,集合。

  遍历:对聚焦相月素依次收取的过称叫做遍历。

  二种形式:① for循环遍历; ② NSEnumerator遍历; ③ for...in遍历

let arr = [1,2,3];
for (let i=0; i<arr.length; i  ){
 console.log(i,arr[i])
}
// 0 1
// 1 2
// 2 3

开首数组:1, 89, 4, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 

 2> for循环遍历

for 循环是 Js 中最常用的一个循环工具,平时用来数组的巡回遍历。

第四回巡回(i=0):1, 89, 4, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 

  ① 数组遍历

   原理:通过for循环的循环变量用作数组成分下标来获得不一致下标的要素。

   循环次数就是数组元素的个数。

1 // 数组
2 for (int i = 0; i < arr.count; i  ) {
3     NSLog(@"%@", arr[i]);
4 }

中的12种循环遍历方法,iOS学习16之OC集结遍历和数组排序。2、for in 循环

其次次巡回(i=1):  1, 89, 4, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 

  ② 字典遍历

   原理:先获得字典中有着的key,存款和储蓄到数组中,遍历数组依次收取每三个key,然后依照key从字典中收取对应的value

   循环次数便是字典成分的个数。

1         // 字典
2         // 获取字典中所有的key值
3         NSArray *allKey = [dict allKeys];
4         // 遍历key值数组,访问对应的object值
5         for (int i = 0; i < allKey.count; i  ) {
6             NSString *key = allKey[i];
7             NSLog(@"%@", [dict objectForKey:key]);
8         }
let obj = {name:'zhou',age:'**'}
for(let i in obj){
 console.log(i,obj[i])
}
// name zhou
// age **

其一次巡回(i=2):  1, 4, 89, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 

  ③ 集结遍历

   原理:用集结的allObjects属性先取到集结的全数因素存储到数组中,再通过for循环的循环变量用作下标来取到各个成分。

1         // 集合
2         // 取出集合中的所有元素放到数组中
3         NSArray *setArray = [set allObjects];
4         for (int i = 0; i < setArray.count; i  ) {
5             NSLog(@"%@", setArray[i]);
6         }

for in 循环首要用于遍历普通对象,i 代表对象的 key 值,obj[i] 代表对应的 value,当用它来遍历数组时候,非常多场地下也能落得平等的成效,可是你不用这么做,那是有风险的,因为 i 输出为字符串方式,而不是数组需求的数字下标,那意味在好几意况下,会发生字符串运算,导致数据失实,比方:'52' 1 = '521' 而不是大家必要的 53。

第七回巡回(i=3):1, 4, 34, 89, 56, 40, 59, 60, 39, 1, 40, 90, 48 

 3> NSEnumerator

除此以外 for in 循环的时候,不仅仅遍历本人的性质,还大概会找到 prototype 上去,所以最棒在循环体内加一个推断,就用 obj[i].hasOwnProperty(i),那样就幸免遍历出太多无需的习性。

... ...

  ① 概述 

   枚举器,遍历集合中的成分。

   依赖于集结类(NSArray,NSSet,NSDictionary),未有用来创造实例的接口。

   NSEnumerator的 nextObject 方法能够遍历种种集合成分,甘休再次来到 nil ,通过与 while 结合使用可遍历集合中享有因素。

   对可变集结(数组,字典,集结)举行枚举操作时,不能够因此抬高或删除对象那类格局来改造集结容器的成分个数。

3、while 循环

第13次循环(i=12)(结束):1, 1, 4, 34, 39, 40, 40, 48, 56, 59, 60, 89, 90

  ② 数组遍历

   正序(objectEnumerator)

1         // 数组(正序)
2         // 创建正序的枚举器对象
3         NSEnumerator *arrayEnum1 = [arr objectEnumerator];
4         id value1 = nil;
5         // 判断value部位空打印数据
6         while ((value1 = [arrayEnum1 nextObject])) {
7             NSLog(@"%@", value1);
8         }    

   倒序(reverseObjectEnumerator)

1         // 数组(倒序)
2         // 创建倒序的枚举器对象
3         NSEnumerator *arrayEnum2 = [arr reverseObjectEnumerator];
4         id value2 = nil;
5         while ((value2 = [arrayEnum2 nextObject])) {
6             NSLog(@"%@", value2);
7         }

  注:枚举器的nextObject方法只好抽出八个对象,所以必要和while循环结合把富有因素依次抽取。

  ③ 字典遍历

1         // 字典
2         // 遍历到的是字典中的value值
3         NSEnumerator *dictEnum = [dict objectEnumerator];
4         id value3 = nil;
5         while ((value3 = [dictEnum nextObject])) {
6             NSLog(@"%@", value3);
7         }

  注:字典中存放的数额是冬天的,未有反向枚举的概念。

  ④ 集结遍历

1         // 集合
2         NSEnumerator *setEnum = [set objectEnumerator];
3         id value4 = nil;
4         while ((value4 = [setEnum nextObject])) {
5             NSLog(@"%@", value4);
6         }

  注:集结中存放的数码是冬日的,未有反向枚举的概念。

同样的遍历 cars 数组,先用 for 循环方法

int[] sort = new int[13] { 1, 4, 89, 34, 56, 40, 59, 60, 39, 1, 40, 90, 48 };  // 输入一个数组
for (int i = 0; i < sort.Length; i  )
    {
         int temp = sort[i];   // 临时存储第i个数的值
         int j = i;

         for (; j > 0 && temp < sort[j - 1]; j--)  // 遍历有j 个数的有序数组(j从0开始),当 temp 临时值小于sort[j-1](初始是,有j个数,j-1 为最后一个数)时,把当前第(j-1)位上的数向后移一位(j)
              {
                  sort[j] = sort[j - 1];

              }
                sort[j] = temp;  // 退出循环后,把temp 放到 第j 个位置上(j 是经过循环处理后得到的)

    }
for (int i = 0; i < sort.Length; i  ) // 输出
    {
         Console.Write(sort[i]   " ");
    }

 4> for...in 遍历

let cars=["BMW","Volvo","Saab","Ford"];
let i=0;
for (;cars[i];)
{
console.log(cars[i])
i  ;
};
// BMW
// Volvo
// Saab
// Ford

 

  ① 概述

   for...in:快速枚举,是在NSEnumerator的根底上包裹的愈益有益的长足的遍历集合成分的艺术。

   格式:for (集结中目的的品种 * 成分名 in 被遍历的汇合) {

      语句;

       }

   对可变集结(数组,字典,集结)实行高效枚举操作时,无法透过抬高或删除对象那类格局来改动群集容器的因素个数。

  ② 数组遍历

1         // 数组
2         for (id value in arr) {
3             NSLog(@"%@", value);
4         }

  ③ 字典遍历

1         // 字典 遍历的是字典的key
2         for (id value in dict) {
3             NSLog(@"%@", dict[value]);
4         }

  ④ 集结遍历

1         // 集合
2         for (id value in set) {
3             NSLog(@"%@", value);
4         }

接下来是 while 循环方法

2、数组排序

 数组是一动不动容器,由此集结中独有数组技巧排序。

cars=["BMW","Volvo","Saab","Ford"];
var i=0;
while (cars[i])
{
console.log(cars[i]   "<br>")
i  ;
};

 1> NSSortDescriptor(排序描述符)概述

  该类可以方便的贯彻对数组中的对象实行升序也许降序的排序。

  它能够把成分的有些属性作为key举办升序或降序的排序,每个NSSortDescriptor对象正是多少个排序条件。

大家开采,它们能够完成均等的功效,事实上它们底层的拍卖是同等的,可是 for 循环能够把定义、条件决断、自增自减操作放到三个尺码里实践,代码看起来方便一些,仅此而已。

 2> NSSortDescriptor创建方法

  初步化方法

  - (instancetype)initWithKey:(NSString *)key ascending:(BOOL)ascending;

  key:遵照数组中目的的哪位属性举办排序,借使数组中寄放的是可以直接排序的靶子(比方:字符串),直接使 @"self" 也许 nil 就能够;假使存放的是自定义类的目的,使用想要进行排序的属性名就能够(比方:想安份守己Person类的name进行排序, 使用 @"name" 作为参数)。
       ascending:排序的标记,是升序还是降序。 YES - 升序, NO - 降序。

NSSortDescriptor创建

1 NSSortDescriptor *sortDes1 = [[NSSortDescriptor alloc] initWithKey:@"self" ascending:YES]; // 升序
2 NSSortDescriptor *sortDes2 = [[NSSortDescriptor alloc] initWithKey:@"name" ascending:NO]; // 降序

4、do while 循环

  ① 不可变数组

排序

1 // 基本数据类型不可变数组
2 array = [array sortedArrayUsingDescriptors:@[sortDes1]];
3 NSLog(@"%@", array);
4 // 自定义对象不可变数组
5 // 按照名字排序
6 personArray = [personArray sortedArrayUsingDescriptors:@[sortDes2]];
7 NSLog(@"%@", personArray);

 ② 可变数组

排序

1 // 基本类型可变数组
2 [mArray sortUsingDescriptors:@[sortDes1]];
3 NSLog(@"%@", mArray);
4 // 自定义对象可变数组
5 // 按照名字排序
6 [personMArray sortUsingDescriptors:@[sortDes2]];
7 NSLog(@"%@", personMArray);
let i = 3;
do{
 console.log(i)
 i--;
}
while(i>0)
// 3
// 2
// 1

 3> 使用数组中 七个因素比较的点子名 实行排序

do while 循环是 while 循环的四个变体,它首先实践二次操作,然后才开展规范剖断,是 true 的话再继续实行操作,是 false 的话循环结束。

  ① 不可变数组排序:(排序结果生成新数组, 原数组无更换)

   - (NSArray *)sortedArrayUsingSelector:(SEL)comparator;

   注:SEL类型的参数comparator:必要传入二个回到结果是NSComparisonResult的措施名。

1 // 不可变数组(基本数据类型)
2 array = [array sortedArrayUsingSelector:@selector(compare:)];
3 NSLog(@"%@", array);
4 // 不可变的数组(自定义类型的对象)
5 // 按照名字排序
6 personArray = [personArray sortedArrayUsingSelector:@selector(compareByName:)]; // compareByName为Person类中自定义的方法
7 NSLog(@"%@", personArray);

5、Array forEach 循环

  ② 可变数组排序:(直接对原数组操作,无新数组变化)

   - (void)sortUsingSelector:(SEL)comparator;

   注:SEL类型的参数comparator:须要传入多个回去结果是NSComparisionResult的函数

1 // 可变数组(基本数据类型)
2 [mArray sortUsingSelector:@selector(compare:)];
3 NSLog(@"%@", mArray);
4 // 可变的数组(自定义类型的对象)
5 // 按照名字排序
6 [personMArray sortUsingSelector:@selector(compareByName:)];
7 NSLog(@"%@", personMArray);

  Person类中compareByName方法:

1          // 比较方法的声明
2          - (NSComparisonResult)compareByName:(Person *)anotherPerson;
3          // 比较方法的实现
4          - (NSComparisonResult)compareByName:(Person *)anotherPerson {
5          return [self.name compare:anotherPerson.name];
6          }

 

let arr = [1,2,3];
arr.forEach(function(i,index){
 console.log(i,index)
})
// 1 0
// 2 1
// 3 2

forEach循环,循环数组中每一个因素并采纳操作, 未有重回值, 能够毫无知道数首席实践官度,他有八个参数,独有首先个是须要的,代表当前下标下的 value。

别的请留意,forEach 循环在富有因素调用完结从前是不能够止住的,它从未 break 语句,借使您不能够不要结束,能够尝尝 try catch 语句,正是在要强制退出的时候,抛出一个 error 给 catch 捕捉到,然后在 catch 里面 return,那样就能够暂停循环了,若是你经常用这几个点子,最佳自定义二个这么的 forEach 函数在你的Curry。

6、Array map()方法

let arr = [1,2,3];
let tt = arr.map(function(i){
 console.log(i)
 return i*2;
})
// [2,4,6]

map() 方法重返三个新数组,数组中的成分为原始数组成分调用函数管理后的值。
留意:map 和 forEach 方法都以不得不用来遍历数组,不可能用来遍历普通对象。

7、Array filter() 方法

let arr = [1,2,3];
let tt = arr.filter(function(i){
 return i>1;
})
// [2,3]

filter 方法是 Array 对象放置方法,它会回去经过过滤的要素,不转移原先的数组。

8、Array some() 方法

let arr = [1,2,3];
let tt = arr.some(function(i){
 return i>1;
})
// true

some() 方法用于检查评定数组中的成分是或不是满意钦定条件(函数提供),重回 boolean 值,不更改原数组。

9、Array every() 方法

let arr = [1,2,3];
let tt = arr.some(function(i){
 return i>1;
})
// 检测数组中元素是否都大于1
// false

every() 方法用于检查实验数组全体因素是不是都符合内定条件(通过函数提供),返回boolean 值,不更改原数组。

10、Array reduce()方法

let arr = [1,2,3];
let ad = arr.reduce(function(i,j){
 return i j;
})
// 6

reduce() 方法接收二个函数作为累计器,数组中的每一种值(从左到右)开头削减,最后计算为一个值。

11、Array reduceRight()方法

let arr = [1,2,3];
let ad = arr.reduceRight(function(i,j){
 return i j;
})
// 6

reduceRight()方法,和 reduce() 功用是平等的,它是从数组的末尾处向前起初猜想。

12、for of 循环

let arr = ['name','age'];
for(let i of arr){
 console.log(i)
}
// name
// age

for of 循环是 Es6 中新增加的口舌,用来替代 for in 和 forEach,它同意你遍历 Arrays(数组), Strings(字符串), Maps(映射), Sets(会集)等可迭代(Iterable data)的数据结构,注意它的包容性。

总结

以上就是自己计算的 Js 四川中国广播企业余大学的大循环遍历方法,随着 Es6 标准的包容性越来越好,笔者意识众多落实方案逐步都不再必要了,比方let、const 代替var 后,在一些情状下的闭包函数也就不设有了。

您大概感兴趣的稿子:

  • js 实现获取name 一样的页面成分并循环遍历的艺术
  • JavaScript中利用for循环遍历数组
  • Javascript数组循环遍历之forEach详解
  • JS简单循环遍历json数组的主意
  • JavaScript中循环遍历Array与Map的章程小结
  • JS 使用for循环遍历子节点查找成分
  • JS使用for循环遍历Table的装有单元格内容
  • JS数组的遍历情势for循环与for...in
  • js数组循环遍历数组内全数因素的秘技
  • javascript forEach通用循环遍历方法

本文由星彩网app下载发布于计算机编程,转载请注明出处:中的12种循环遍历方法,iOS学习16之OC集结遍历和

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。