整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线:

32.Javascript循环结构

32.Javascript循环结构

编写程序时,我们经常需要重复执行某些操作,这时候循环结构就显得非常有用。JavaScript 提供了多种循环结构,以适应不同的编程场景。以下是 JavaScript 中常见的循环结构:

for 循环

for 循环是最常见的循环结构之一,它允许我们指定循环开始前的初始化代码、循环继续的条件以及每次循环结束时要执行的代码。

基本语法

for (初始化表达式; 循环条件; 循环后的操作表达式) {
    // 循环体代码
}

示例:输出 1 到 10 的数字

for (var i=1; i <=10; i++) {
    console.log(i);
}

while 循环

while 循环在给定条件为真时将不断循环执行代码块。与 for 循环不同,while 循环只有循环条件,没有初始化和迭代表达式。

基本语法

while (条件) {
    // 循环体代码
}

示例:使用 while 循环输出 1 到 10 的数字

var i=1;
while (i <=10) {
    console.log(i);
    i++;
}

do...while 循环

do...while 循环和 while 循环类似,但它至少会执行一次循环体,无论条件是否为真。

基本语法

do {
    // 循环体代码
} while (条件);

示例:使用 do...while 循环输出 1 到 10 的数字

var i=1;
do {
    console.log(i);
    i++;
} while (i <=10);

for...in 循环

for...in 循环用于遍历对象的属性。

基本语法

for (var key in 对象) {
    // 使用 key 访问对象属性
}

示例:遍历对象的属性

var person={
    name: "张三",
    age: 30,
    job: "软件工程师"
};

for (var key in person) {
    console.log(key + ": " + person[key]);
}

for...of 循环

for...of 循环用于遍历可迭代对象(如数组、字符串等)的元素。

基本语法

for (var item of 可迭代对象) {
    // 使用 item 访问元素
}

示例:遍历数组的元素

var fruits=["苹果", "香蕉", "橘子"];
for (var fruit of fruits) {
    console.log(fruit);
}

总结

JavaScript 的循环结构为我们提供了强大的工具来处理重复任务。for 循环适合于当我们知道循环次数时使用;while 和 do...while 循环适合于循环次数未知,但是循环条件明确的情况;for...in 和 for...of 循环则让对象和数组的遍历变得更加简洁。掌握这些循环结构有助于我们编写更加高效和可读性更强的代码。

件语句的代码可以被想象成是一条条分支的路径,而循环语句的代码则是程序路径的一个回路,可以让一部分代码重复执行。JavaScript中的循环语句有for语句和while语句。

一、for语句

for语句的语法如下:

1 for(初始值;布尔值;计数器){
2     //语句块
3 }

在for语句中,如果布尔值是true,就会一直执行语句块中的内容,为了防止死循环,需要有一个计数器,当数值达到指定值,布尔值就会变成false,循环便停止了,下面的示例代码使用for循环输出0~9九个数字示例代码如下:

1 for(var i=0;i<10;i++){  
2     // i的初始值是0
3     // 判断i是否小于10,如果小于10则执行花括号中的代码
4     // 每次执行完花括号中的代码后,i的值加1
5     console.log(i);
6 }

通过上面的例子我们进一步理解了for语句的用法,下面我们来做一个联系,利用for循环语句输出100以内所有正整数的加和示例代码如下:

1 var sum=0;                 //sum用来存储循环过程中正整数的加和
2 for(var i=1;i<=100;i++){
3     sum +=i;
4 }
5 console.log(sum); //这时候输出的就应该是5050

二、while语句

while语句语法如下所示:

1 while(bool){
2     //bool为true,循环执行
3 }

当bool为true的时候,花括号中的内容会循环执行。为了防止死循环,需要在循环的过程实现类似for计数器的功能,让循环在有限的次数内定制,下面我们使用while语句输出0~9是个数字示例代码如下:

1 var n=0;
2 while(n<10){
3     console.log(n);
4     n++;
5 }

在每次循环的过程中都会让n的值加1,这样当n的值等于10,循环便停止,下面我来使用while语句输出100以内所有正整数的加和示例代码如下:

1 var n=0;
2 var sum=0;
3 while(n<=100){
4     sum +=n;
5     n++;
6 }
7 console.log(sum); 

三、continue

continue可以结束本次循环,直接进入到下一次循环,例如我们用for循环语句来实现输出0 ~ 5,7 ~ 9九个数字(跳过6)示例代码如下:

1 for(var i=0;i<10;i++){
2     if(i===6){
3         continue;
4     }
5     console.log(i);
6 }

上面的代码通过判断,实现当i的值为6的时候,跳过本次循环,直接接入下一次循环。下面我们使用continue来实现计算100以内所有不能被7整除的正整数加和示例代码如下:

1 var sum=0;
2 for(var i=0;i<=100;i++){
3     if(i%7===0){
4         continue;
5     }
6     sum +=i;
7 }
8 console.log(sum);

四、break

在学switch语句中,我们已经接触到了break,它可以让分支语句在结束一个case之后,跳出switch语句,break同样可以用在循环语句当中,当代码执行到break时,直接结束循环示例代码如下:

1 for(var i=0;i<10;i++){
2     if(i===6){
3         break;  
4     }
5     console.log(i);
6 }

如上面的代码所示,当控制带输出5之后,循环结束。

五、课后练习

    1. 分别用for和while语句在控制台输出100以内(包括100)所有正整数的加和。
    2. 分别用for和while语句在控制台输出100以内(包括100)所有偶数的加和。

【融职教育】在工作中学习,在学习中工作

wift 使用自动引用计数(ARC)这一机制来跟踪和管理应用程序的内存

通常情况下我们不需要去手动释放内存,因为 ARC 会在类的实例不再被使用时,自动释放其占用的内存。

但在有些时候我们还是需要在代码中实现内存管理。

ARC 功能

  • 当每次使用 init() 方法创建一个类的新的实例的时候,ARC 会分配一大块内存用来储存实例的信息。

  • 内存中会包含实例的类型信息,以及这个实例所有相关属性的值。

  • 当实例不再被使用时,ARC 释放实例所占用的内存,并让释放的内存能挪作他用。

  • 为了确保使用中的实例不会被销毁,ARC 会跟踪和计算每一个实例正在被多少属性,常量和变量所引用。

  • 实例赋值给属性、常量或变量,它们都会创建此实例的强引用,只要强引用还在,实例是不允许被销毁的。

ARC 实例

class Person {
 let name: String
 init(name: String) {
 self.name=name print("\(name) 开始初始化")
 }
 deinit {
 print("\(name) 被析构")
 }}// 值会被自动初始化为nil,目前还不会引用到Person类的实例var reference1: Person?var reference2: Person?var reference3: Person?// 创建Person类的新实例reference1=Person(name: "Runoob")//赋值给其他两个变量,该实例又会多出两个强引用reference2=reference1
reference3=reference1//断开第一个强引用reference1=nil//断开第二个强引用reference2=nil//断开第三个强引用,并调用析构函数reference3=nil

以上程序执行输出结果为:

Runoob 开始初始化Runoob 被析构

类实例之间的循环强引用

在上面的例子中,ARC 会跟踪你所新创建的 Person 实例的引用数量,并且会在 Person 实例不再被需要时销毁它。

然而,我们可能会写出这样的代码,一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用,并让对方不被销毁。这就是所谓的循环强引用。

实例

下面展示了一个不经意产生循环强引用的例子。例子定义了两个类:Person和Apartment,用来建模公寓和它其中的居民:

class Person {
 let name: String
 init(name: String) { self.name=name }
 var apartment: Apartment?
 deinit { print("\(name) 被析构") }}class Apartment {
 let number: Int
 init(number: Int) { self.number=number }
 var tenant: Person?
 deinit { print("Apartment #\(number) 被析构") }}// 两个变量都被初始化为nilvar runoob: Person?var number73: Apartment?// 赋值runoob=Person(name: "Runoob")number73=Apartment(number: 73)// 意感叹号是用来展开和访问可选变量 runoob 和 number73 中的实例// 循环强引用被创建runoob!.apartment=number73
number73!.tenant=runoob// 断开 runoob 和 number73 变量所持有的强引用时,引用计数并不会降为 0,实例也不会被 ARC 销毁// 注意,当你把这两个变量设为nil时,没有任何一个析构函数被调用。// 强引用循环阻止了Person和Apartment类实例的销毁,并在你的应用程序中造成了内存泄漏runoob=nilnumber73=nil

解决实例之间的循环强引用

Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题:

  • 弱引用

  • 无主引用

弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。

对于生命周期中会变为nil的实例使用弱引用。相反的,对于初始化赋值后再也不会被赋值为nil的实例,使用无主引用。

弱引用实例

class Module {
 let name: String
 init(name: String) { self.name=name }
 var sub: SubModule?
 deinit { print("\(name) 主模块") }}class SubModule {
 let number: Int
 init(number: Int) { self.number=number }
 weak var topic: Module?
 deinit { print("子模块 topic 数为 \(number)") }}var toc: Module?var list: SubModule?toc=Module(name: "ARC")list=SubModule(number: 4)toc!.sub=list
list!.topic=toc
toc=nillist=nil

以上程序执行输出结果为:

ARC 主模块子模块 topic 数为 4

无主引用实例

class Student {
 let name: String
 var section: Marks?
 init(name: String) {
 self.name=name }
 deinit { print("\(name)") }}class Marks {
 let marks: Int
 unowned let stname: Student
 init(marks: Int, stname: Student) {
 self.marks=marks self.stname=stname }
 deinit { print("学生的分数为 \(marks)") }}var module: Student?module=Student(name: "ARC")module!.section=Marks(marks: 98, stname: module!)module=nil

以上程序执行输出结果为:

ARC学生的分数为 98

闭包引起的循环强引用

循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性,并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性,例如self.someProperty,或者闭包中调用了实例的某个方法,例如self.someMethod。这两种情况都导致了闭包 "捕获" self,从而产生了循环强引用。

实例

下面的例子为你展示了当一个闭包引用了self后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement的类,用一种简单的模型表示 HTML 中的一个单独的元素:

class HTMLElement {
 let name: String
 let text: String?
 lazy var asHTML: () -> String={
 if let text=self.text {
 return "<\(self.name)>\(text)</\(self.name)>"
 } else {
 return "<\(self.name) />"
 }
 }
 init(name: String, text: String?=nil) {
 self.name=name self.text=text }
 deinit {
 print("\(name) is being deinitialized")
 }
 }// 创建实例并打印信息var paragraph: HTMLElement?=HTMLElement(name: "p", text: "hello, world")print(paragraph!.asHTML())

HTMLElement 类产生了类实例和 asHTML 默认值的闭包之间的循环强引用。

实例的 asHTML 属性持有闭包的强引用。但是,闭包在其闭包体内使用了self(引用了self.name和self.text),因此闭包捕获了self,这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。

解决闭包引起的循环强引用:在定义闭包时同时定义捕获列表作为闭包的一部分,通过这种方式可以解决闭包和类实例之间的循环强引用。


弱引用和无主引用

当闭包和捕获的实例总是互相引用时并且总是同时销毁时,将闭包内的捕获定义为无主引用。

相反的,当捕获引用有时可能会是nil时,将闭包内的捕获定义为弱引用。

如果捕获的引用绝对不会置为nil,应该用无主引用,而不是弱引用。

实例

前面的HTMLElement例子中,无主引用是正确的解决循环强引用的方法。这样编写HTMLElement类来避免循环强引用:

class HTMLElement {
 let name: String
 let text: String?
 lazy var asHTML: () -> String={
 [unowned self] in
 if let text=self.text {
 return "<\(self.name)>\(text)</\(self.name)>"
 } else {
 return "<\(self.name) />"
 }
 }
 init(name: String, text: String?=nil) {
 self.name=name self.text=text }
 deinit {
 print("\(name) 被析构")
 }
 }//创建并打印HTMLElement实例var paragraph: HTMLElement?=HTMLElement(name: "p", text: "hello, world")print(paragraph!.asHTML())// HTMLElement实例将会被销毁,并能看到它的析构函数打印出的消息paragraph=nil

以上程序执行输出结果为:

<p>hello, world</p>p 被析构