포어치 루프

각 루프는 거의 항상 일련의 요소에서 항목을 반복하기 위해 사용됩니다.

Foreach 루프(또는 각 루프)는 컬렉션 내의 항목을 통과하기 위한 제어 흐름문입니다.보통 foreach는 loop 문의 표준 대신 사용됩니다.그러나 다른 루프 구조와는 달리 foreach^[1] 루프는 일반적으로 명시적인 카운터를 유지하지 않습니다. 즉, 기본적으로 "이 x번 실행"이 아니라 "이 집합의 모든 것에 실행"이라고 말합니다.이것에 의해, 잠재적인 오프 바이 에러가 발생하지 않게 되어, 코드를 간단하게 읽을 수 있습니다.객체 지향 언어에서는 암묵적인 경우에도 반복기가 종종 통과 수단으로 사용됩니다.

일부 언어의 foreach 문에는 컬렉션의 각 항목을 처음에서 마지막까지 처리하는 순서가 정의되어 있습니다.다른 많은 언어, 특히 배열 프로그래밍 언어의 foreach 문에는 특별한 순서가 없습니다.이를 통해 일반적으로 루프 최적화가 간소화되며, 특히 컬렉션 내의 항목을 동시에 벡터 처리할 수 있습니다.

구문

구문은 언어에 따라 다릅니다.대부분은 간단한 단어를 사용한다.for대략 다음과 같습니다.

컬렉션의 각 항목에 대해: 항목에 대해 작업 수행

언어 지원

는 foreach 루프를 지원하는 프로그래밍 언어 ABC, 액션 스크립트, 에이다, C++11, C#, 콜드 퓨전 생성 언어(CFML), 코브라, D, Daplex(쿼리 언어), 델피, ECMA스크립트, 얼랑, 자바(1.5이후), 자바 스크립트, 루아, 오브젝티브-C(2.0이후), ParaSail, 펄, PHP, Prolog,[2]파이썬, 고로 REALbasic, Rebol,[3]Red,[4]루비, Scala, 스몰 토크, Swift,을 포함한다.도구 명령 언어, tcsh, Unix 쉘, Visual Basic.NET 및 Windows PowerShell.포어치가 없는 주요 언어로는 C와 C++ 이전 C++11이 있습니다.

액션 스크립트 3.0

ActionScript는 다음을 위해 ECMAScript 4.0 Standard를^[5] 지원합니다.for each .. in^[6] 각 인덱스의 값을 끌어옵니다.

변화하다 후우:물건 = {  "애플":1,  "실패":2 };  위해서 각각 (변화하다 가치:인트 에 후우) {   추적하다(가치);  }  // "1"을 반환한 후 "2"를 반환합니다. 

또,for .. in^[7] 각 인덱스에서 키를 당깁니다.

위해서 (변화하다 열쇠:스트링 에 후우) {   추적하다(열쇠);  }  // "apple"을 반환한 후 "supply"를 반환합니다. 

아다

Wikibook Ada Programming 에는 다음 항목에 대한 페이지가 있습니다.

Ada는 일반 for 루프의 일부로 foreach 루프를 지원합니다.X를 어레이라고 합니다.

위해서 I 에 X'범위 고리    X (I) := Get_Next_Element(다음 요소); 끝. 고리; 

이 구문은 대부분 어레이에서 사용되지만 전체 반복이 필요한 경우 다른 유형에서도 작동합니다.

Ada 2012에는 모든 종류의 컨테이너(어레이, 목록, 맵 등)에서 루프를 포레치하는 범용 루프가 있습니다.

위해서 옵지 의 X 고리    -- Obj에 대한 작업 끝. 고리; 

C

C 언어에는 컬렉션이나 foreach 구문이 없습니다.그러나 수집으로 사용할 수 있는 몇 가지 표준 데이터 구조를 가지고 있으며 매크로로 쉽게 Forach를 만들 수 있습니다.

다만, 다음의 2개의 명백한 문제가 발생합니다.

• 매크로는 비위생적입니다.루프 후에 남아 있는 기존 범위에서 새로운 변수를 선언합니다.
• 서로 다른 컬렉션 유형(예: 배열 및 링크 목록)에서 작동하거나 사용자 유형으로 확장 가능한 하나의 foreach 매크로를 정의할 수 없습니다.

char 컬렉션으로서의 C 문자열

#실패하다 <stdio.h>  /* 매크로에서 문자열을 char 값 집합으로 표시 */ #syslog foreach(ptrvar, strvar) \ char* ptrvar; \ for (ptrvar = strvar; (*ptrvar) != '\0', *ptrvar++)  인트 주된(인트 argc, 차** argv) {  차* s1 = "defg";  차* s2 = "123456789";  앞지르다 (p1, s1) {   인쇄물("루프 1: %c\n", *p1);  }  앞지르다 (p2, s2) {   인쇄물("루프 2: %c\n", *p2);  }  돌아가다 0; } 

int 컬렉션으로서의 C int 어레이(컴파일 시 알려진 어레이 크기)

#실패하다 <stdio.h>  /* 매크로에서 int 값의 배열을 int 값의 집합으로 표시합니다*/ #syslog foreach(intpvar, intarr) \ int* intpvar; \ (intpvar = intarr; intpvar < (intar + (sizeof(intar)/sizeof(intar[0])), ++intpvar)  인트 주된(인트 argc, 차** argv) {  인트 a1[] = {1, 1, 2, 3, 5, 8};  인트 a2[] = {3, 1, 4, 1, 5, 9};  앞지르다 (p1, a1) {   인쇄물("루프 1: %d\n", *p1);  }  앞지르다 (p2, a2) {   인쇄물("루프 2: %d\n", *p2);  }  돌아가다 0; } 

일반: 컬렉션으로서의 문자열 또는 배열(실행 시 알려진 컬렉션 크기)

주의:idxtype제거할 수 있으며typeof(col[0])GCC로 대체하여 사용

#실패하다 <stdio.h> #실패하다 <문자열>h>  /* 매크로를 포치하여 지정된 유형의 배열을 지정된 유형의 값 집합으로 표시합니다*/ #size arraylen(arr)(size of(arr)/size of(arr[0]) #cisco foreach(idxtype, idxpvar, col, colsiz) \ idxtype* idxpvar; \ for (idxpvar = col; idxpvar < ( col + colsiz), ++idxpvar)  인트 주된(인트 argc, 차** argv) {  차* c1 = '수집';  인트 c2[] = {3, 1, 4, 1, 5, 9};  이중으로 하다* c3;  인트 c3len = 4;  c3 = (이중으로 하다*)하드 디스크(c3len, 크기(이중으로 하다));   c3[0] = 1.2; c3[1] = 3.4; c3[2] = 5.6; c3[3] = 7.8;   앞지르다 (차, p1, c1, 스트렌(c1)) {   인쇄물("루프 1: %c\n", *p1);  }  앞지르다 (인트, p2, c2, 어레이렌(c2)) {   인쇄물("루프 2: %d\n", *p2);  }  앞지르다 (이중으로 하다, p3, c3, c3len) {   인쇄물("루프 3: %.1lf\n", *p3);  }  돌아가다 0; } 

C#

C#에서는 myArray가 정수 배열이라고 가정합니다.

앞지르다 (인트 x 에 myArray) { 콘솔.기입선(x); } 

Language Integrated Query(LINQ; 언어 통합 쿼리)는 위임식 또는 람다 식을 수락하여 다음과 같은 구문을 제공합니다.

myArray.대상 목록().각각에 대해서(x => 콘솔.기입선(x)); 

C++

C++11은 foreach 루프를 제공합니다.구문은 Java의 구문과 유사합니다.

#실패하다 <iostream>  인트 주된() {   인트 마인트[] = {1, 2, 3, 4, 5};    위해서 (인트 i : 마인트)   {     표준::외치다 << > i << > '\n';   } } 

스테이트먼트의 C++11 범위 베이스는 GNU 컴파일러 컬렉션(GCC) (버전 4.6 이후), Clang (버전 3.0 이후), Visual C++ 2012 (버전 11)에 실장되어 있습니다.

범위 베이스for통사당은 다음과 같다.

  위해서 (자동 __anon = 시작한다.(마인트); __anon != 끝.(마인트); ++__anon)   {     자동 i = *__anon;     표준::외치다 << > i << > '\n';   } 

컴파일러는 인수에 의존한 룩업을 사용하여begin그리고.end기능하고 있습니다.^[9]

C++ 스탠다드 라이브러리는 또한for_each각 요소를 함수에 적용합니다.^[10] 함수는 사전 정의된 함수 또는 람다 식일 수 있습니다.의 범위 기반은 시작부터 끝까지뿐이지만 처음 두 개의 파라미터를 변경하여 범위와 방향을 변경할 수 있습니다.

#실패하다 <iostream> #실패하다 <blocks>// std:: for_각각 포함 #실패하다 <blocks>  인트 주된() {   표준::벡터< >인트> v {1, 2, 3, 4, 5};    표준::각각(v.시작한다.(), v.끝.(), [](인트 i)   {     표준::외치다 << > i << > '\n';   });    표준::외치다 << > "단, 두 가지 요소를 건너뜁니다.\n";    표준::각각(v.RBE긴()+2, v.찢다(), [](인트 i)   {     표준::외치다 << > i << > '\n';   }); } 

C++ 프레임워크인 Qt는 STL 반복기 인터페이스를 사용하여 foreach^[11] 루프를 제공하는 매크로를 제공합니다.

#실패하다 <QList> #실패하다 <QDebug>  인트 주된() {   QList< >인트> 목록.;    목록. << > 1 << > 2 << > 3 << > 4 << > 5;    앞지르다 (인트 i, 목록.)   {     q디버깅() << > i;   } } 

Boost(피어 리뷰 대상 무료 노트북 C++ 라이브러리 세트)는 포어치 루프도 ^[12]제공합니다.

#실패하다 <boost/foreach.hpp> #실패하다 <iostream>   인트 주된() {   인트 마인트[] = {1, 2, 3, 4, 5};     부스트_포어치(인트 &i, 마인트)   {     표준::외치다 << > i << > '\n';   } } 

C++/CLI

C++/CLI 언어는 C#과 유사한 구조를 제안합니다.

myArray가 정수 배열이라고 가정하면:

위해서 각각 (인트 x 에 myArray) {     콘솔::기입선(x); } 

ColdFusion Markup Language(CFML)

스크립트 구문

// 어레이 각 배열([1,2,3,4,5], 기능.(v){     기입 출력(v); });  // 또는  위해서 (v 에 [1,2,3,4,5]){     기입 출력(v); }  // 또는  // (Railo만, ColdFusion에서는 지원되지 않음) 편지들 = ["a","b","c","d","e"]; 각 문자(기능.(v){     기입 출력(v); // abcde });  // 구조 위해서 (k 에 수집){     기입 출력(수집[k]); }  // 또는  각 구조(수집, 기능.(k,v){     기입 출력(「키:#k#, 값:#v#;"); });  // 또는 // (Railo만, ColdFusion에서는 지원되지 않음) collection.각각(기능.(k,v){     기입 출력(「키:#k#, 값:#v#;"); }); 

태그 구문

<!--- 어레이 ---> < cfloop > 색인="v" 배열="#['a' 'b' 'c' 'd' 'e']#">   <cfoutput>#v#</cfoutput><!--- a b c d e ---> </cfloop> 

CFML은 이 구성에서 값을 "index"로 잘못 식별합니다.index변수는 인덱스가 아닌 배열 요소의 실제 값을 수신합니다.

<!--- 구조 ---> < cfloop > 아이템="k" 수집="#수집#">     <cfoutput>#수집[k]#</cfoutput> </cfloop> 

일반적인 리스프

Common Lisp는 dolist 매크로 중 하나를 사용하여 포어치 기능을 제공합니다.

(돌리스트 (i '(1 3 5 6 8 10 14 17))   (인쇄물 i)) 

또는 강력한 루프 매크로를 사용하여 더 많은 데이터 유형에서 반복할 수 있습니다.

(고리 위해서 i 에 '(1 3 5 6 8 10 14 17)       하다 (인쇄물 i)) 

맵카 기능도 있습니다.

(맵카 #'인쇄물 '(1 3 5 6 8 10 14 17)) 

D

앞지르다(아이템; 세트) {   // 항목에 작업 수행 } 

또는

앞지르다(논쟁) {   // 값 전달 } 

다트

위해서 (최종 요소 에 일부 컬렉션) {   // 요소를 사용하여 작업 } 

오브젝트 파스칼, 델파이

Forech 지원은 Dellphi 2005에서 추가되었으며 var 섹션에서 선언해야 하는 열거형 변수를 사용합니다.

위해서 열거자 에 수집 하다 시작한다.   //여기서 뭔가 해 끝.; 

에펠

Effel 루프 구성의 반복(전방) 형식은 키워드에 의해 도입됩니다.across.

이 예에서는 구조의 모든 요소가my_list인쇄:

            ~건너 my_list ~하듯이 ic 고리 인쇄물 (ic.아이템) 끝. 

로컬 엔티티ic라이브러리 클래스의 인스턴스입니다.ITERATION_CURSOR. 커서의 특징item는 각 구조 요소에 대한 접근을 제공합니다.클래스의 후예ITERATION_CURSOR특수한 반복 알고리즘을 처리하기 위해 생성할 수 있습니다.반복할 수 있는 오브젝트 타입 ( )my_list이 예에서)는 라이브러리 클래스에서 상속되는 클래스를 기반으로 합니다.ITERABLE.

에펠 루프의 반복 형식은 키워드가 다음과 같은 경우 부울 표현으로도 사용할 수 있습니다.loop다음 중 하나로 대체됩니다.all(유효한 보편적 수량화) 또는some(실존적 정량화의 효력)

이 반복은 부울식이며 의 모든 항목이 true인 경우 true입니다.my_list의 카운트는 3을 넘습니다.

            ~건너 my_list ~하듯이 ic 모든. ic.아이템.세어보세요 > 3 끝. 

하나 이상의 항목이 3보다 큰 경우 다음과 같습니다.

            ~건너 my_list ~하듯이 ic 몇개 ic.아이템.세어보세요 > 3 끝. 

가세요

Go의 Foreach 루프는 배열, 슬라이스, 문자열, 맵 또는 채널에서 루프할 때 사용할 수 있습니다.

2개의 값 형식을 사용하면 인덱스/키(첫 번째 요소)와 값(두 번째 요소)을 얻을 수 있습니다.

위해서 색인, 가치 := 범위 일부 컬렉션 {  // 인덱스와 값을 지정하기 위해 작업을 수행합니다. } 

one-value 형식을 사용하면 인덱스/키(첫 번째 요소)를 얻을 수 있습니다.

위해서 색인 := 범위 일부 컬렉션 {  // 인덱싱 작업 } 

^[13]

그루비

Groovy는 어레이, 목록, 범위 등의 컬렉션에 대한 루프를 지원합니다.

방어하다 x = [1,2,3,4] 위해서 (v 에 x)           // 4 소켓 어레이를 루프합니다.x {     인쇄 v }  위해서 (v 에 [1,2,3,4])   // 4자리 리터럴리스트에 루프 오버하다 {     인쇄 v }  위해서 (v 에 1..4)        // 범위 1을 루프합니다.4 {     인쇄 v } 

Groovy는 배열 인덱스를 가진 C-스타일 루프도 지원합니다.

위해서 (i = 0; i < > x.크기(); i++) {     인쇄 x[i] } 

Groovy의 컬렉션은 각 키워드와 closure를 사용하여 반복할 수도 있습니다.디폴트로는 루프 더미의 이름은

x.각각{ 인쇄 그것 }     // x 배열의 모든 요소를 인쇄합니다. x.각각{i-> 인쇄 i}    // 위의 행과 동일하며, 명시적으로 "i"라는 이름의 루프 더미만 있습니다. 

하스켈

Haskell은 다음을 사용하여 단일 액션을 사용하여 목록을 루핑할 수 있습니다.mapM_그리고.forM_(mapM_(인수가 뒤집힌 상태)를 선택합니다.모나드:

맵M_ 인쇄물 [1..4] 

1 2 3 4

M_ '테스트" $ \차 -> 하다      putChar 차     putChar 차 

패널

또한 이러한 기능을 일반화하여 모나드 및 데이터 구조를 사용하여 통과할 수 있는 데이터 구조 대신 응용 함수에서 작업할 수 있습니다.traverse(for논거가 뒤바뀌어)와mapM(forM인수 뒤집기)를 사용합니다.통과 가능.

Haxe

위해서 (가치 에 반복할 수 있다) {     추적하다(가치); }  람다.반복하다(반복할 수 있다, 기능.(가치) 추적하다(가치)); 

자바

Java에서는 foreach-constructure가 Java Development Kit(JDK) 1.5.^[14]0에 도입되었습니다.

공식 출처는 이 구조에 여러 이름을 사용합니다.이것은 "Enhanced for Loop",^[14] "For-Each Loop"^[15] 및 "Foreach 스테이트먼트"^[16]라고 불립니다.

위해서 (유형 아이템 : 반복 가능한 컬렉션) {     // 항목에 작업 수행 } 

자바스크립트

ECMAScript 6 규격에는for..of생성기, 어레이 등에 대한 인덱스 없는 반복:

위해서 (변화하다 아이템 의 배열){     // 일을 하다 } 

또는 기능 기반 스타일:

배열.각각(아이템 => {     // 일을 하다 }) 

오브젝트 내의 키를 통한 순서 없는 반복의 경우 JavaScript는 다음 기능을 제공합니다.for...in루프:

위해서 (변화하다 열쇠 에 물건) {     // 오브젝트[키]로 작업하기 } 

프로토타입 체인을 통해 상속된 속성을 제외하고 개체 자체의 속성으로 반복을 제한하려면 JavaScript 엔진에서 지원되는 경우 hasOwnProperty() 테스트를 추가하는 것이 유용할 수 있습니다(WebKit/Safari의 경우 "버전 3 이상"을 의미합니다).

위해서 (변화하다 열쇠 에 물건) {     한다면 (물건.has Own Property(열쇠)) {         // 오브젝트[키]로 작업하기     } } 

ECMAScript 5는 객체를 제공했습니다.keys 메서드: 객체의 자체 키를 ^[18]배열로 전송합니다.

변화하다 책 = { 이름.: '크리스마스 캐롤', 작가.: 찰스 디킨스 };  위해서(변화하다 열쇠 의 물건.열쇠들.(책)){     경계.("PropertyName =" 열쇠 + "속성 값 = " + 책[열쇠]); } 

루아^[19]

숫자 인덱스 값을 통해서만 반복합니다.

위해서 색인, 가치 에 아이페어(배열) 하다  --무엇인가를 하다 끝. 

모든 인덱스 값을 반복합니다.

위해서 색인, 가치 에 쌍들(배열) 하다  --무엇인가를 하다 끝. 

매스매티카

매스매티카에서는Do는 단순히 목록의 각 요소에 대한 식을 평가하며 값은 반환하지 않습니다.

인[]:= 하다[doSomething With Item(항목과 함께 작업), {아이템, 목록.}] 

사용하는 것이 일반적입니다.Table새 목록의 각 평가 결과를 반환합니다.

인[]:= 목록. = {3, 4, 5};  인[]:= 테이블[아이템^2, {아이템, 목록.}] 나가.[]= {9, 16, 25} 

매트랩

위해서 아이템 = 배열 %do something 끝. 

민트

Mint에서는 각 루프가 다음 구문을 사용하여 지원됩니다.

위해서 각각 요소 의 목록.     /* '뭔가 해봐' */ 끝. 

그for (;;)또는while (true) Mint의 무한 루프는 각 루프 및 무한히 긴 ^[20]목록을 사용하여 작성할 수 있습니다.

수입품 유형 /* '이 함수는 매핑 대상' * '각 인덱스 번호 i' * '무한히 긴 목록' */ 후보선수 신원(x)     돌아가다 x 끝. /* '다음으로 리스트 작성' * '[0, 1, 2, 3, 4, 5, ..., 무한대]' */ 무한 리스트 = 목록.(신원) 위해서 각각 요소 의 무한 리스트     /* '영원히 뭔가를 해라' */ 끝. 

목표-C

Fast Enumeration이라고 불리는 Foreach 루프는 Objective-C 2.0부터 지원됩니다.NSArray, NSDictionary(키를 통해 반복), NSSet 등을 포함하여 NSFastEnumeration 프로토콜을 구현하는 모든 개체에 대해 반복할 수 있습니다.

NSAray *a = [NSAray 신규];       // 모든 컨테이너 클래스를 대체할 수 있습니다.  위해서(아이디 obj 에 a) {                // 동적 입력에 주의해 주세요(이것에 대해서는,                                   // 'a'에 저장된 개체 유형입니다.사실, 여기엔                                   // 배열 내의 다양한 유형의 객체.      인쇄물(%s\n", [[obj 묘사] UTF8String]);  // %s에서 UTF8String을 사용해야 합니다.     NSlog(@"%@", obj);                               // 객체로 남기다 } 

NSAray는 멤버에게 다음과 같은 메시지를 방송할 수도 있습니다.

NSAray *a = [NSAray 신규];  [a make Objects Perform Selector:@parames(@parames)(print 설명)]; 

블록을 사용할 수 있는 경우 NSArray는 포함된 모든 항목에 대해 블록을 자동으로 수행할 수 있습니다.

[myArray 열거 객체 Using Block:^(아이디 obj, NSInterger idx, 부루 *이제 그만)  {   NSlog(@"obj %@", obj);   한다면 ([obj 지금 당장 중지해야 합니다.])    *이제 그만 = 네.;  }]; 

반복되는 수집 유형에 따라 각 반복과 함께 반환되는 항목이 결정됩니다.예를 들어 다음과 같습니다.

NSDirectionary *d = [NSDirectionary 신규];  위해서(아이디 열쇠 에 d) {     NSObject *obj = [d objectForKey(오브젝트포키):열쇠];      // (고유한) 키를 사용하여 (고유하지 않을 수 있음) 개체에 액세스합니다.     NSlog(@"%@", obj); } 

OCaml

OCaml은 기능적인 언어입니다.따라서 목록 및 배열에 대한 라이브러리 함수로 포어치 루프와 동등한 값을 달성할 수 있습니다.

목록의 경우:

목록..반복하다 (재밌어요 x -> print_int x) [1;2;3;4];; 

또는 간단히 말하면:

목록..반복하다 print_int [1;2;3;4];; 

어레이의 경우:

어레이.반복하다 (재밌어요 x -> print_int x) [1;2;3;4];; 

또는 간단히 말하면:

어레이.반복하다 print_int [1;2;3;4];; 

패러세일

ParaSail 병렬 프로그래밍 언어는 컨테이너 상의 일반 "각" 반복기를 포함하여 여러 종류의 반복기를 지원합니다.

변화하다 단점 : 컨테이너.< >요소_유형> := ... // ... 위해서 각각 엘렘 의 단점 동시. 고리  // 루프는 "forward" 또는 "forward" 또는 "unordered"(기본값)일 수도 있습니다.   //... Elem으로 뭔가 해 주세요. 끝. 고리 

ParaSail은 반복기 필터 및 맵의 키와 값을 모두 참조하는 기능도 지원합니다.다음은 키가 "My_Set"에 있는 요소만 선택하는 "My_Map" 요소에 대한 앞으로 반복입니다.

변화하다 My_My_Map : 지도< >키_타입 => Univ_String, 값_타입 => 트리< >정수>> := ... 컨스턴트 마이 세트 : 세트< >Univ_String> := ["실패", "def", "ghi"];  위해서 각각 [스트링 => Tr] 의 My_My_Map {스트링 에 마이 세트} 앞으로 고리    //...Str 또는 Tr로 작업합니다. 끝. 고리 

파스칼

Pascal에서 ISO 표준 10206:1990은 집합 유형에 반복을 도입하여 다음과 같이 합니다.

변화하다   엘트: 요소 유형;   eltset: 세트 의 요소 유형;  {...}  위해서 엘트 에 eltset 하다   {...elt로 작업하세요} 

펄

Perl에서는 foreach(단축에 상당)를 사용하여 목록의 요소를 통과할 수 있습니다.루프오버할 컬렉션을 나타내는 표현은 목록 컨텍스트로 평가되며 결과 목록의 각 항목은 루프 변수에 에일리어스 됩니다.

리터럴의 예를 나타냅니다.

앞지르다 (1, 2, 3, 4) {     인쇄물 $_; } 

어레이의 예:

앞지르다 (@arr) {     인쇄물 $_; } 

앞지르다 x달러 (@arr) { #$x는 @arr의 요소입니다.     인쇄물 x달러; } 

해시 예시:

앞지르다 x달러 (열쇠들. %parames(%pause)) {     인쇄물 x달러 . " = " . $140{x달러}; # $x는 %syslog의 키이고 $syslog{$x}는 값입니다. } 

컬렉션 멤버의 직접 수정:

@arr = ( '삭제 후', '제거 막대' ); 앞지르다 x달러 (@arr){     x달러 =~ s/remove-//; } # 이제 @arr = ('foo', 'bar'); 

PHP

앞지르다 ($set ~하듯이 $value($value)) {     // $value에 대한 조치를 취한다. } 

대체 구문을 사용하여 키와 값을 모두 추출할 수도 있습니다.

앞지르다 ($set ~하듯이 키 => $value($value)) {     메아리치다 "{키}의 가치가 있다{$value($value)}"; } 

컬렉션 멤버의 직접 수정:

$arr = 배열(1, 2, 3); 앞지르다 ($arr ~하듯이 &$value($value)) { // &, $value는 $arr 내의 원래 값을 참조합니다.     $value($value)++; } // 이제 $arr = 어레이(2, 3, 4);  // 완전한 구문에서도 동작합니다. 앞지르다 ($arr ~하듯이 키 => &$value($value)) {     $value($value)++; } 

• 상세 정보

파이썬

위해서 아이템 에 반복 가능한 수집:     # 아이템으로 작업하기 

Python의 태플 할당은 Foreach 루프에서 완전히 사용 가능하기 때문에 연관 배열의 (키, 값) 쌍에서 반복하는 것도 간단하다.

위해서 열쇠, 가치 에 일부_부적합.항목들():  # 딕트에서의 직접 반복은 키에서 반복됩니다.     # 일을 하다 

~하듯이for ... inPython에서는 유일한 for 루프 종류이며, 다른 언어에서는 "counter" 루프에 해당합니다.

위해서 i 에 범위(렌(인식하다)):     # 뭔가를 해라 [i] 

...를 사용하여enumerate함수는 더 "피톤"으로 간주됩니다.

위해서 i, 아이템 에 열거하다(인식하다):     # 아이템으로 작업하기     # seq[i]에 다시 할당하다 

라켓

(위해서 ([아이템 세트])   (무엇인가를 하다 아이템)) 

또는 종래의 스킴을 사용한다.for-each기능:

(각각을 위한 무엇인가를 하다 일람표) 

do-something-with는 1소문자 함수입니다.

라쿠

Raku에서는 Perl의 자매 언어인 for를 사용하여 목록의 요소를 통과해야 합니다(앞으로 수행할 수 없습니다).루프오버할 컬렉션을 나타내는 표현은 목록 컨텍스트에서 평가되지만 기본적으로는 평탄화되지 않습니다.그리고 결과 목록의 각 항목은 루프 변수에 에일리어스 됩니다.

리터럴의 예를 나타냅니다.

1 . 4 { . say ; }의 경우

어레이의 예:

@arr {.say; }의 경우

스테이트먼트 수식자 형식의 for 루프:

. @arr에 대해 말합니다.

@arr -> $x { say $x ; }의 경우

@arr -> $x, $y { #의 경우 한 번에 여러 항목을 "$x, $y"로 발음합니다; }

해시 예시:

키 %syslog -> $key {"$key: $syslog{$key}", }의 경우

또는

%syslog.syslog -> $key, $value {"$key: $value"; }의 경우

또는

%hash -> $x {"$x.key(): $x.value()」라고 합니다.# 괄호는 이중 따옴표로 묶은 문자열로 인라인해야 합니다.}

더블 포인트 블록이 있는 컬렉션 멤버의 직접 수정 <->

my @ar = 1,2,3; @arr <-> $x { $x * = 2; } # 지금 @ar = 2,4,6;

루비

세트.각각 하다  아이템    # 아이템에 대한 작업 끝. 

또는

위해서 아이템 에 세트   # 아이템에 대한 작업 끝. 

이것은 해시에도 사용할 수 있습니다.

세트.각각 하다  아이템,가치    # 아이템에 대한 작업   # 가치 있는 일을 하다 끝. 

녹

그for루프는 구조화 되어 있습니다.for <pattern> in <expression> { /* optional statements */ }식에서 메서드를 암묵적으로 호출하고 그 결과 값을 사용합니다.이 값은 특성을 구현해야 합니다.표현 자체가 반복자일 경우, 이 표현은 에 의해 직접 사용됩니다.for는 변경되지 않고 반복기를 반환하는 모든 의 실장을 루프합니다.루프가 호출한다.Iterator::next루프 본문을 실행하기 전에 반복기로 메서드를 지정합니다.한다면Iterator::next돌아온다Some(_)inside 값이 패턴에 할당되어 루프 본체가 실행됩니다.None루프가 종료됩니다.

허락하다 뮤트 숫자 = VEC![1, 2, 3];  // 불변 참조: 위해서 번호 에 &숫자 { // IntoIterator 호출::into_iter(&numbers)     프린트!("{}", 번호); }  위해서 광장 에 숫자.반복하다().지도( x  x * x) { // numbers.iter().map(x x * x)은 반복기를 구현합니다.     프린트!("{}", 광장); }  // 가변 기준: 위해서 번호 에 &뮤트 숫자 { // IntoIterator 호출::into_iter(&mut 번호)     *번호 *= 2; }  // [2, 4, 6] 인쇄: 프린트!("{:?}", 숫자);  // Vec을 소비하고 반복기를 만듭니다. 위해서 번호 에 숫자 { // IntoIterator 호출::into_iter(숫자)     // ... }  // "이동된 값의 차용" 오류: // println!("{:?}), 숫자; 

스칼라

// 수정된 요소 목록 반환 항목들 지도 { x => 어떻게 좀 해봐.(x) } 항목들 지도 곱셈 배율두명  위해서 {x <-> 항목들} 산출하다 어떻게 좀 해봐.(x) 위해서 {x <-> 항목들} 산출하다 곱셈 배율두명(x)  // 아무것도 반환하지 않고 작업만 수행합니다. 항목들 앞지르다 { x => 어떻게 좀 해봐.(x) } 항목들 앞지르다 인쇄  위해서 {x <-> 항목들} 어떻게 좀 해봐.(x) 위해서 {x <-> 항목들} 인쇄(x)  // 이해를 위한 패턴 일치 예시 위해서 ((열쇠, 가치) <-> 일부 맵) 인쇄(s"$열쇠->$가치") 

스킴

(각각을 위한무엇인가를 하다 일람표) 

do-something-with는 1소문자 함수입니다.

스몰토크

collection do: [: item "do something to item"]

재빠르다

Swift는for…in컬렉션의 ^[21]구성원에 대해 반복하도록 구성합니다.

위해서 것 에 일부 컬렉션 {     // 물건으로 뭔가를 하다 } 

그for…in루프는 루프 본체를 통해 일정 횟수 반복하기 위해 폐쇄 및 하프 오픈 범위 구성에서 자주 사용됩니다.

위해서 i 에 0..< >10 {     // 0..< 10은 하프 오픈 범위를 구성하므로 루프 본체는     //는 i = 0, i = 1, …, i = 9에 대해 반복됩니다. }  위해서 i 에 0...10 {     // 0...10은 닫힌 범위를 구성하므로 루프 본체는     //는 i = 0, i = 1, …, i = 9, i = 10에 대해 반복됩니다. } 

시스템 Verilog

SystemVerilog는 다음을 사용하여 모든 벡터 또는 어레이 유형에 걸친 반복을 지원합니다.foreach키워드를 지정합니다.

간단한 예는 정수 배열에 걸쳐 반복됩니다.

인트  어레이_1d[] = '{ 3, 2, 1, 0 };  앞지르다 어레이_1d[색인]   $표시("array_1d[%0d]: %0d", 색인, 어레이_1d[색인]); 

array_1d[0]: 3 array_1d[1]: 2 array_1d[2]: 1 array_1d[3]: 0

더 복잡한 예는 정수 배열의 연관 배열에 대해 반복됩니다.

인트  어레이_2d[스트링][] = '{ "실패": '{ 10, 11 },                              "실패": '{ 20, 21 } };  앞지르다 어레이_2d[열쇠,색인]   $표시("array_2d[%s,%0d]: %0d", 열쇠, 색인, 어레이_2d[열쇠,색인]); 

array_2d[array,0]: 10 array_2d[array,1]: 11 array_2d[array,0]: 20 array_2d[array,1]: 21

TCL

TCL은 foreach를 사용하여 목록에 대해 반복합니다.둘 이상의 반복 변수를 지정할 수 있습니다. 이 경우 이 변수에는 목록에서 순차 값이 할당됩니다.

{i j} {1 2 3 4 5 6} {puts "$i $j}

1 2 3 4 5 6

여러 목록에서 동시에 반복할 수도 있습니다.다음 중i첫 번째 목록의 순차 값을 가정합니다.j두 번째 목록의 순차 값:

foreach i {1 2 3} j {a b c} {puts "$i $j" }

1 a 2 b 3 c

Visual Basic.그물

위해서 각각 아이템 인 열거할 수 있다     '아이템을 어떻게 해요. 다음 분. 

또는 유형 추론 없이

위해서 각각 아이템 ~하듯이 유형 인 열거할 수 있다     '아이템을 어떻게 해요. 다음 분. 

창문들

기존 명령어 프로세서

가설을 제기하다frob명령어를 세 번, 매번 색상 이름을 지정합니다.

C:\>%a IN(빨간 녹색 파란색)의 경우 %%a를 실행합니다.

Windows PowerShell

앞지르다 ($아이템 에 $set) {     # $아이템에 대한 작업 수행 } 

파이프라인에서

$리스트   각각에 대해서- 오브젝트 {기입 호스트 $_}  또는 에일리어스를 사용합니다. $리스트   앞지르다 {쓰다$_} $리스트   % {쓰다$_} 

XSLT

 <xsl: 각 선택="세트'>    <!--< set > -- >내의 요소에 대해서, 작업을 실시합니다.  </xsl: 각 > 

^[22]

「 」를 참조해 주세요.

• 루프 중에 실행
• 루프의 경우
• While 루프
• 지도(고차 함수)

레퍼런스