ਅਸਰਦਾਰ ਚੱਕਰ foreach: PHP ਦਾ ਹੱਕ ਹੈ ਅਤੇ ਐਰੇ

ਐਰੇ ਵਿੱਚ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਨੂੰ, ਕਿਸਮ ਮੁੱਲ ਅਤੇ ਆਪਣੇ ਆਕਾਰ ਅਤੇ ਤੱਤ ਦੀ ਗਿਣਤੀ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦਾ ਹੈ ਨੂੰ ਹਮੇਸ਼ਾ ਪੇਸ਼ਗੀ ਵਿੱਚ ਪੱਕਾ ਇਰਾਦਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਆਧੁਨਿਕ ਪਰੋਗਰਾਮਿੰਗ, ਖਾਸ ਤੌਰ 'ਤੇ ਵੰਡੇ ਪੁੰਜ ਵਿੱਚ, ਇਸ ਨੂੰ ਬਣਾਉਣ ਲਈ ਸਹਾਇਕ ਹੈ ਗੁੰਝਲਦਾਰ ਡਾਟਾ ਬਣਤਰ, ਸਮੱਗਰੀ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾ ਇੱਕ ਵੱਖਰੀ ਕ੍ਰਮ ਵਿਚ ਵੱਖ-ਵੱਖ ਕੰਮ ਜ ਘਟਨਾ ਦੇ ਨਤੀਜੇ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਸਦਾ ਆਰਜੀ ਪਰਿਭਾਸ਼ਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.

ਇਹ ਹਮੇਸ਼ਾ ਹਰ ਸੰਭਵ ਵਰਣਨ ਅਤੇ ਜਾਣਕਾਰੀ ਨੂੰ ਵਰਤਣ ਦੀ, ਆਪਣੇ ਦਿੱਖ ਅਤੇ ਵਰਤਣ ਦਾ ਗਣਿਤ ਲਈ ਕਾਰਵਾਈ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਾ ਅਨੁਮਾਨ ਕਰਨ ਡਿਜ਼ਾਇਨ ਪੜਾਅ 'ਤੇ ਸੰਭਵ ਹੈ.

ਸਮੱਗਰੀ ਦੇ ਸੰਟੈਕਸ

foreach ਦੇ ਸੰਟੈਕਸ ਨੂੰ ਤਿਆਰ ਕਰਨ, PHP ਤੱਤ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਦੋ ਤਰੀਕੇ ਦਾ ਪ੍ਰਸਤਾਵ. ਦੋਨੋ ਕੁੰਜੀ ਦੀ ਕਿਸਮ, ਜ ਮੁੱਲ ਦੀ ਕਿਸਮ 'ਤੇ ਨਿਰਭਰ ਨਾ ਕਰੋ ਅਤੇ ਰਵਾਇਤੀ ਚੱਕਰ ਇਮੂਲੇਟਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਤੱਤ ਦੀ ਇੱਕ plurality ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਐਰੇ ਤੇ ਵਿਚਾਰ ਕਰਨ ਦਾ ਪ੍ਰਸਤਾਵ ਹੈ, ਜਿਸ ਦੀ ਗਿਣਤੀ ਸ਼ੁਰੂ ਵਿਚ ਪੱਕਾ ਇਰਾਦਾ ਨਾ ਕੀਤਾ ਗਿਆ ਸੀ. ਐਰੇ ਫਲਾਈ ਕੁੰਜੀ ਦੇ ਤੌਰ ਤੇ, ਅਤੇ ਬਿਨਾ ਤੇ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਐਰੇ ਤੱਤ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਕੁੰਜੀ ਜੁੜਨਸ਼ੀਲ ਅਤੇ ਮੂਲ ਪੜ੍ਹੇ ਹੋ ਸਕਦਾ ਹੈ.

foreach ($ xValue ਦੇ ਤੌਰ ਤੇ $ aArrayName) {ਲੂਪ ਸਰੀਰ ਨੂੰ}

ਇਹ ਡਿਜ਼ਾਇਨ foreach PHP ਲੂਪ ਇੱਕ ਕਤਾਰ ਵਿੱਚ ਸਭ ਤੱਤ ਦੁਆਰਾ ਜਾਣ ਦੀ ਲੋੜ ਹੈ. ਲੂਪ ਵੇਰੀਏਬਲ ਦੇ ਸਰੀਰ ਵਿੱਚ $ xValue ਲਗਾਤਾਰ, ਜਿਸ ਵਿੱਚ ਕ੍ਰਮ ਉਹ ਸ਼ਾਮਿਲ ਕੀਤਾ ਗਿਆ ਸੀ ਐਰੇ $ aArrayName ਦੇ ਸਾਰੇ ਮੁੱਲ ਲੈ ਜਾਵੇਗਾ. ਕੁੰਜੀ ਤੱਤ ਦੇ ਮੁੱਲ ਉਪਲੱਬਧ ਨਾ ਹੋ ਜਾਵੇਗਾ.

foreach ($ aArrayName $ xKey => $ xValue ਦੇ ਤੌਰ ਤੇ) {ਲੂਪ ਸਰੀਰ ਨੂੰ}

ਇੱਥੇ ਵੀ, ਡਿਜ਼ਾਇਨ foreach ਪੂਰਾ, PHP ਐਰੇ ਦੀ ਸਾਰੀ ਸਮੱਗਰੀ ਨੂੰ ਸਕੈਨ ਹੋਵੇਗਾ, ਪਰ ਲੂਪ ਜੋੜੇ ਵੇਰੀਏਬਲ $ xValue ਦੇ ਤੌਰ ਤੇ ਉਚਿਤ ਮੁੱਲ ਹੈ, ਅਤੇ ਵੇਰੀਏਬਲ $ xKey ਲੈ ਜਾਵੇਗਾ - ਕੁੰਜੀ ਤੱਤ.

ਤੱਤ ਦੀ ਤਰਤੀਬ

foreach ਅੰਦਰ PHP ਦਾ ਕ੍ਰਮ ਵਿੱਚ ਸਮੱਗਰੀ ਨੂੰ ਪੇਸ਼ਕਸ਼ ਕਰੇਗਾ, ਜਿਸ 'ਚ ਸ਼ਾਮਿਲ ਕੀਤਾ ਤੱਤ ਹੈ, ਪਰ ਜੇ ਕੋਈ ਇਸ ਦੇ ਨਾਲ / ਹਟਾਉਣ ਵਾਰ ਵਾਰ ਗਿਆ ਸੀ, ਅਤੇ ਬਿਨਾ ਕੁੰਜੀ ਲਈ ਕੁਝ, ਅਤੇ ਕੁਝ ਸ਼ਾਮਿਲ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਵਧੀਆ ਹੈ ਦੇ ਨਾਲ ਇੱਕ ਐਰੇ ਨਾਲ ਐਰੇ ਦੇ ਗਠਨ ਵਿਚ ਕੰਮ ਕਰਨ ਲਈ ਸਥਿਤੀ ਕ੍ਰਮ ਤੱਤ ਹੈ, ਅਤੇ ਆਪਣੀ ਸਮੱਗਰੀ 'ਤੇ ਜ ਕੁੰਜੀ' ਤੇ ਅਧਾਰਿਤ ਹੈ.

ਵੱਖ-ਵੱਖ ਉਦੇਸ਼ ਕਾਰਨ ਕਰਕੇ ਐਰੇ ਦੇ ਅੰਦਰ ਕ੍ਰਮ ਦੇ ਨਾਲ ਪਾਲਣਾ ਨਹੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ / ਜ ਮਾਮਲੇ ਨੂੰ ਬਹੁਤ ਕੁਝ ਹੈ, ਪਰ ਇਸ ਨੂੰ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਅਨੁਕੂਲ ਨਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ. ਮਾਮੂਲੀ ਡਾਟਾ ਸੈੱਟ, ਕੋਈ ਸਮੱਸਿਆ ਹੈ, ਅਤੇ ਐਲਗੋਰਿਥਮ ਤੇ ਸਧਾਰਨ ਕੰਮ ਵਿੱਚ ਕ੍ਰਮ ਨੂੰ ਕਾਰਵਾਈ ਕਰਨ ਲਈ ਸੈੱਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਜਦ ਬਣਾਉਣ / ਸੋਧ ਨੂੰ ਐਰੇ ਕਾਰਜ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਕਾਰਕ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਹੁੰਦਾ ਹੈ, ਸਮੱਗਰੀ 'ਤੇ ਧਿਆਨ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ.

ਆਧੁਨਿਕ "ਸੱਜੇ" ਤੱਤ

ਮੌਜੂਦਾ ਸਵੈ-ਸੰਕਲਪ ਦੇ ਨਜ਼ਰੀਏ ਤੱਕ, ਵੀ ਖਾਤੇ ਭਾਸ਼ਾ ਵਰਗੇ ਸ਼ਰਤ ਵਿੱਚ ਲੈ ਕੇ ਬਿਨਾ, PHP foreach ਐਰੇ ਸੁਤੰਤਰ ਖਾਤੇ ਵਿੱਚ ਅਸਲ ਖਾਸ ਕੰਮ ਨੂੰ ਲੈ ਕੇ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ.

ਅਭਿਆਸ, ਇੱਕ ਦਿੱਤੇ ਹੁੰਦਾ ਹੈ, ਜਦ, ਅਤੇ ਇਸ ਵਿੱਚ ਖਾਸ ਸੀਮਾ ਦੇ ਅਨੁਸਾਰ ਸਬੰਧਿਤ ਉਤਪਾਦ ਦੇ ਆਮ ਭੰਡਾਰ '' ਚ ਇਕ ਸੂਚਕ ਵੀ ਹੁੰਦਾ ਹੈ - ਇਸ ਨੂੰ ਕੱਲ੍ਹ ਸੀ.

ਇੰਡੈਕਸ ਕੁੰਜੀ ਸੀ, ਅਤੇ ਜੁੜਨਸ਼ੀਲ ਐਰੇ ਦੀ ਲੜੀ ਦੇ ਰੂਪ ਲੈ ਲਿਆ. ਜੋ ਕਿ ਕੁੰਜੀ ਇਸ ਦੇ ਵਿਲੱਖਣ ਸੀਰੀਅਲ (ਆਮ ਤੌਰ 'ਤੇ ਲਗਾਤਾਰ ਚੰਗਾ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ: 0, 1, 2, ... n) ਨੂੰ ਖਤਮ ਹੋ ਰਿਹਾ ਹੈ ਅਤੇ ਇਹ ਵੀ ਮੁੱਲ ਨੂੰ ਕਰਨ ਲਈ ਸ਼ੁਰੂ ਕੀਤਾ ਹੈ, ਪਰ ਇੱਕ ਸਧਾਰਨ ਮੁੱਲ (ਭਾਵ ਕੁੰਜੀ) ਅਸਲ ਮੁੱਲ ਨਾਲ ਸੰਬੰਧਿਤ ਹੈ (ਭਾਵ ਤੱਤ ਦੀ ਸਮੱਗਰੀ). ਇਸ ਨੂੰ ਅੱਜ ਹੈ, ਜੋ ਕਿ ਸਹੀ ਹੈ, ਪਰ ਕਾਫ਼ੀ ਨਹੀ ਹੈ.

ਇਸੇ ਲਈ ਚੱਕਰ foreach PHP ਦਾ ਰਵਾਇਤੀ ਐਰੇ 'ਤੇ ਧਿਆਨ ਆਮ ਚੱਕਰ ਦੇ ਬਦਲ ਦੇ ਤੌਰ ਤੇ,' ਤੇ ਵਿਚਾਰ ਕਰ ਰਿਹਾ ਹੈ. ਇਹ ਸਭ ਉਪਰ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਬਹੁਤ ਹੀ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕਿਉਕਿ ਇਸ ਦਾ ਮਤਲਬ ਹੈ, ਜੋ ਕਿ ਐਰੇ ਤੱਤ ਦੀ ਅਸਲੀ ਸ਼ੁੱਧਤਾ, ਦੇ ਨਾਲ ਨਾਲ ਆਪਣੇ ਕੁੰਜੀ!

ਰੈਗੂਲਰ ਤੱਤ ਦੇ ਸੱਜੇ ਐਰੇ

ਪਹਿਲੀ ਉੱਥੇ ਇੱਕ ਤੱਤ ਦੋ ਤੱਤ ਸੀ, ਫਿਰ ... ਇਸ ਲਈ ਤੱਤ ਦੀ ਲੜੀ ਅਤੇ ਜਿਹੜੇ ਦੇ ਐਰੇ ਦੁਆਰਾ ਲੂਪ ਉੱਥੇ ਸੀ:

ਲਈ ($ i = 0; $ i ਗਿਣਤੀ <($ aArrayName); $ i ++) {

ਹਰ $ aArrayName ਦੇ ਸਰੀਰ ਨੂੰ ਕਾਰਵਾਈ [$ i]

}

ਫਿਰ ਦੀ ਬਜਾਏ ਇਕਾਈ ਨੂੰ ਇੱਕ faceless 0, 1, 2, ... n ਇਸ ਦੇ ਆਪਣੇ ਨਾਮ ਹੈ ਜਾਵੇਗਾ - ਕੁੰਜੀ ਹੈ ਅਤੇ ਫਿਰ ਜੁੜਨਸ਼ੀਲ ਐਰੇ ਬਣ ਅਤੇ ਫਿਰ ਇੱਕ foreach ਲੂਪ ਦੀ ਲੋੜ - "ਹਰੇਕ ਲਈ ਚੱਕਰ ':

foreach ($ aArrayName ਤੌਰ $ xKey => $ xValue) {

ਹਰ $ aArrayName [$ xKey] $ xValue ਜ, ਜੋ ਕਿ ਇੱਕ ਹੈ ਅਤੇ ਉਸੇ ਹੀ ਦੇ ਸਰੀਰ ਨੂੰ ਕਾਰਵਾਈ ਕਰਨ

}

ਹੁਣ ਜਦ ਐਰੇ ਨੂੰ ਸਹੀ ਤੱਤ ਆਉਣਾ ਚਾਹੀਦਾ ਹੈ ਵਾਰ ਆ ਗਈ ਹੈ, ਆਪਣੇ ਆਪ ਨੂੰ ਦੇ ਕੇ, ਜੋ ਕਿ ਜਿਹੜੇ ਭਾਵ. ਉਹ ਆਪਣੇ ਕੋਡ, ਇਸ ਦੇ ਸਮੱਗਰੀ, ਕ੍ਰਮ ਵਿੱਚ ਇਸ ਦੇ ਸਥਾਨ ਲੜੀ ਦੇ ਆਪਣੇ ਖੁਦ ਦੇ ਪਸੰਦ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਹ ਸਾਰੇ ਸੰਭਾਵਨਾ ਆਪਣੇ ਹੀ ਐਰੇ ਦੇਣੇ ਨੂੰ ਰੱਖਣ ਵਾਲੇ ਲਈ ਹੁੰਦੇ ਹਨ ਪਤਾ ਹੈ.

ਅਜਿਹੇ ਰੈਗੂਲਰ ਐਰੇ ਆਪ ਦੁਆਰਾ ਸੰਭਾਲਿਆ ਰਹੇ ਹਨ. ਰਵਾਇਤੀ ਚੱਕਰ ਅਤੇ ਹਰ ਇੱਕ ਦੇ ਚੱਕਰ ਵਿਚ ਵਿਸ਼ੇਸ਼ ਲੋੜ ਹੀ ਸਧਾਰਨ ਹੈ, ਨਾ ਹੋਵੇਗਾ. ਰਸਮੀ, ਸੰਟੈਕਸ ਅਤੇ ਇਸ ਦੇ Semantics ਹੀ ਸਹਾਇਕ ਹੈ, ਚੇਤਨਾ ਦੇ ਡਿਵੈਲਪਰ ਖੜੋਤ ਲਈ ਹੀ ਸਵਾਲ.