ਸਰੂਪ ਦੇ ਤੌਰ ਤੇ ਜੇ.ਐਸ. foreach ਆਬਜੈਕਟ

ਜਾਵਾਸਕਰਿਪਟ ਸੰਟੈਕਸ ਐਰੇ ਅਤੇ ਆਬਜੈਕਟ ਵਿੱਚ ਵੇਰੀਏਬਲ ਜੋੜ ਕਰਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਤੱਤ ਤੱਕ ਪਹੁੰਚ ਲਈ ਇੱਕ ਚੱਕਰ ਦੇ ਚਾਲਕ ਦੁਆਰਾ ਇੰਡੈਕਸ ਅਤੇ ਨਾਮ ਦੁਆਰਾ ਇਸਤੇਮਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ.

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

ਕਲਾਸਿਕ ਡਿਜ਼ਾਇਨ

ਸਧਾਰਨ ਲੂਪ ਬਿਆਨ 'ਲਈ (var i = 0; ਮੈਨੂੰ

var i = 0;
ਜਦਕਿ {... aData [i] (typeof aData [i] = 'ਪਰਭਾਸ਼ਿਤ'!); ... ਮੈਨੂੰ ++; }

ਜਦ ਤੱਤ ਦੀ ਗਿਣਤੀ ਅਣਜਾਣ ਹੈ.

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

ਕਲਾਸਿਕ ਚੰਗਾ ਤੁਹਾਨੂੰ ਸਵਾਲ HR (ਗੋਤ, ਪਹਿਲੇ ਨਾਮ, ਸਥਿਤੀ) ਤੇ ਕਾਰਵਾਈ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਸਾਜ਼ੋ (ਮਾਡਲ, ਨਿਰਮਾਤਾ, ਵੇਚਣ, ਵਿਕਰੀ ਦੀ ਮਿਤੀ) ਅਤੇ ਹੋਰ ਡਾਟਾ ਹੈ, ਜੋ ਕਿ ਜੋੜਿਆ ਨੂੰ ਤਬਦੀਲ ਨਹੀ ਕਰ ਰਹੇ ਹਨ ਅਤੇ ਸੰਚਤ ਵਿਆਜ ਦੀ ਨੁਮਾਇੰਦਗੀ ਲਈ ਕਾਰਡ.

ਜਦ ਆਪਣੇ ਆਪ ਵਿਚ ਐਰੇ ਤੱਤ ਇੱਕ ਇਕਾਈ ਜ ਬਣਤਰ ਇਸ ਦੇ ਆਪਣੇ ਦਾ ਦਰਜਾ ਪ੍ਰਾਪਤ ਅਤੇ ਢੰਗ ਹੈ, ਜੋ ਕਿ ਹੈ, ਕਲਾਸਿਕ ਕਿਰਿਆਸ਼ੀਲਤਾ ਮਾਤਰਾ ਅਤੇ ਗੁਣਵੱਤਾ ਦੇ ਨਾਲ ਮੁਕਾਬਲਾ ਨਾ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਵੱਖਰਾ ਮਤਲਬ ਐਰੇ ਲੱਗਦਾ ਹੈ.

Foreach ਲੂਪ

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

ਮੰਨ ਲਓ ਇੱਕ ਐਰੇ ਨੂੰ ਇੱਕ ਸੜਕ (ਆਪਣੇ ਗੁਣਾਤਮਕ ਅਤੇ ਗਿਣਾਤਮਕ ਗੁਣ), ਅਤੇ ਕਿਸੇ ਹੋਰ ਐਰੇ ਬਣਿਆ ਹੈ - ਵਾਹਨ ਹੈ, ਜੋ ਕਿ ਸਿਰਫ ਕੁਝ ਖਾਸ ਸੜਕ 'ਤੇ ਸਫ਼ਰ ਕਰਦੇ ਹਨ ਅਤੇ ਵੱਖ-ਵੱਖ ਵਾਲੀਅਮ ਬਾਲਣ ਕੁੰਡ ਹੈ, ਹੋ ਸਕਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ ਸਮੱਗਰੀ ਦੇ ਵਿਚਕਾਰ ਦੂਰੀ ਨੂੰ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹਨ.

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

ਜੇ.ਐਸ. foreach ਬਣਤਰ 'ਤੇ ਤਕਨੀਕੀ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਹੈ: "aData.forEach (fData);" ਹੈ, ਜਿੱਥੇ fData - ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ, ਜੋ ਕਿ ਐਰੇ aData ਦੇ ਹਰ ਤੱਤ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ:

ਕੰਮ fData (ਮੁੱਲ, ਇੰਡੈਕਸ) {sText + = ਦਾ ਸੂਚਕ + '=' + ਮੁੱਲ + '; '; }.

ਹੇਠ ਸਰੋਤ ਡਾਟਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਜੇ:

var aData = [1,2,3,4];
aData.push (11);
aData.push (22);
aData.push (44);
aData.push ( 'ਲਾਈਨ 1');
aData.push ( 'ਲਾਈਨ 2');

var sText = '',

ਅਜਿਹੇ ਵਰਤਣ ਜੇ.ਐਸ. foreach ਦੇ ਨਤੀਜੇ:

"0 = 1 1 = 2 2 = 3 3 = 4 4 = 11; 5 = 22, 6 = 44, 7 = ਲਾਈਨ 1, 8 = ਲਾਈਨ 2;".

ਫੀਚਰ ਅਰੇ ਆਬਜੈਕਟ

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

ਵੇਰੀਏਬਲ ਭਾਵਨਾ ਤਿਆਰ: ਨੂੰ ਇਕਾਈ ਦਾ ਜਦ ਜੇ.ਐਸ. foreach ਇਕਾਈ ਬਣਤਰ ਵਿੱਚ ਵੀ ਦੁਹਰਾਉਣਾ ਫਿਲਮਸਟ੍ਰਿਪ ਤੇ ਫਰੇਮ ਦੇ ਤੌਰ ਤੇ ਐਰੇ ਵਿੱਚ ਆਉਣ ਇੱਕ ਨਵ Semantics ਬਣਦੇ.

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

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

ਅਭਿਆਸ ਜੇ.ਐਸ. foreach ਅਤੇ ਅਸਲੀ ਆਬਜੈਕਟ

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

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

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

ਪਰ, ਇਰਾਦਤਨ ਵਰਤਣ ਡਿਵੈਲਪਰ ਲਈ JavaScript ਕੋਡ ਦੀ ਉਪਲਬਧਤਾ ਨੂੰ ਇੱਕ ਗਤੀਸ਼ੀਲ ਹੈ ਅਤੇ ਅਸਲ-ਸੰਸਾਰ ਇਕਾਈ ਲਈ ਹੋਨਹਾਰ ਵਿਚਾਰ ਦੇ ਵਿਕਾਸ 'ਤੇ ਇੱਕ ਅਸਿੱਧੇ ਅਸਰ ਹੈ. ਜੇ.ਐਸ. foreach ਉਸਾਰੀ ਅਜੇ ਵੀ ਸੰਪੂਰਣ ਨਹੀ ਹੈ, ਅਤੇ ਆਪਣੇ Semantics ਦੇ ਵਿਕਾਸ ਨੂੰ ਬਹੁਤ ਹੀ ਹੋਨਹਾਰ ਦਿਸ਼ਾ ਹੋਣ ਦੀ ਲਗਦੀ ਹੈ.